1# Streaming — TypeScript
2 
3## Quick Start
4 
5```typescript
6const stream = client.messages.stream({
7  model: "claude-opus-4-7",
8  max_tokens: 64000,
9  messages: [{ role: "user", content: "Write a story" }],
10});
11 
12for await (const event of stream) {
13  if (
14    event.type === "content_block_delta" &&
15    event.delta.type === "text_delta"
16  ) {
17    process.stdout.write(event.delta.text);
18  }
19}
20```
21 
22---
23 
24## Handling Different Content Types
25 
26> **Opus 4.7 / Opus 4.6:** Use `thinking: {type: "adaptive"}`. On older models, use `thinking: {type: "enabled", budget_tokens: N}` instead.
27 
28```typescript
29const stream = client.messages.stream({
30  model: "claude-opus-4-7",
31  max_tokens: 64000,
32  thinking: { type: "adaptive" },
33  messages: [{ role: "user", content: "Analyze this problem" }],
34});
35 
36for await (const event of stream) {
37  switch (event.type) {
38    case "content_block_start":
39      switch (event.content_block.type) {
40        case "thinking":
41          console.log("\n[Thinking...]");
42          break;
43        case "text":
44          console.log("\n[Response:]");
45          break;
46      }
47      break;
48    case "content_block_delta":
49      switch (event.delta.type) {
50        case "thinking_delta":
51          process.stdout.write(event.delta.thinking);
52          break;
53        case "text_delta":
54          process.stdout.write(event.delta.text);
55          break;
56      }
57      break;
58  }
59}
60```
61 
62---
63 
64## Streaming with Tool Use (Tool Runner)
65 
66Use the tool runner with `stream: true`. The outer loop iterates over tool runner iterations (messages), the inner loop processes stream events:
67 
68```typescript
69import Anthropic from "@anthropic-ai/sdk";
70import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
71import { z } from "zod";
72 
73const client = new Anthropic();
74 
75const getWeather = betaZodTool({
76  name: "get_weather",
77  description: "Get current weather for a location",
78  inputSchema: z.object({
79    location: z.string().describe("City and state, e.g., San Francisco, CA"),
80  }),
81  run: async ({ location }) => `72°F and sunny in ${location}`,
82});
83 
84const runner = client.beta.messages.toolRunner({
85  model: "claude-opus-4-7",
86  max_tokens: 64000,
87  tools: [getWeather],
88  messages: [
89    { role: "user", content: "What's the weather in Paris and London?" },
90  ],
91  stream: true,
92});
93 
94// Outer loop: each tool runner iteration
95for await (const messageStream of runner) {
96  // Inner loop: stream events for this iteration
97  for await (const event of messageStream) {
98    switch (event.type) {
99      case "content_block_delta":
100        switch (event.delta.type) {
101          case "text_delta":
102            process.stdout.write(event.delta.text);
103            break;
104          case "input_json_delta":
105            // Tool input being streamed
106            break;
107        }
108        break;
109    }
110  }
111}
112```
113 
114---
115 
116## Getting the Final Message
117 
118```typescript
119const stream = client.messages.stream({
120  model: "claude-opus-4-7",
121  max_tokens: 64000,
122  messages: [{ role: "user", content: "Hello" }],
123});
124 
125for await (const event of stream) {
126  // Process events...
127}
128 
129const finalMessage = await stream.finalMessage();
130console.log(`Tokens used: ${finalMessage.usage.output_tokens}`);
131```
132 
133---
134 
135## Stream Event Types
136 
137| Event Type            | Description                 | When it fires                     |
138| --------------------- | --------------------------- | --------------------------------- |
139| `message_start`       | Contains message metadata   | Once at the beginning             |
140| `content_block_start` | New content block beginning | When a text/tool_use block starts |
141| `content_block_delta` | Incremental content update  | For each token/chunk              |
142| `content_block_stop`  | Content block complete      | When a block finishes             |
143| `message_delta`       | Message-level updates       | Contains `stop_reason`, usage     |
144| `message_stop`        | Message complete            | Once at the end                   |
145 
146## Best Practices
147 
1481. **Always flush output** — Use `process.stdout.write()` for immediate display
1492. **Handle partial responses** — If the stream is interrupted, you may have incomplete content
1503. **Track token usage** — The `message_delta` event contains usage information
1514. **Use `finalMessage()`** — Get the complete `Anthropic.Message` object even when streaming. Don't wrap `.on()` events in `new Promise()` — `finalMessage()` handles all completion/error/abort states internally
1525. **Buffer for web UIs** — Consider buffering a few tokens before rendering to avoid excessive DOM updates
1536. **Use `stream.on("text", ...)` for deltas** — The `text` event provides just the delta string, simpler than manually filtering `content_block_delta` events
1547. **For agentic loops with streaming** — See the [Streaming Manual Loop](./tool-use.md#streaming-manual-loop) section in tool-use.md for combining `stream()` + `finalMessage()` with a tool-use loop
155 
156## Raw SSE Format
157 
158If using raw HTTP (not SDKs), the stream returns Server-Sent Events:
159 
160```
161event: message_start
162data: {"type":"message_start","message":{"id":"msg_...","type":"message",...}}
163 
164event: content_block_start
165data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}
166 
167event: content_block_delta
168data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}
169 
170event: content_block_stop
171data: {"type":"content_block_stop","index":0}
172 
173event: message_delta
174data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":12}}
175 
176event: message_stop
177data: {"type":"message_stop"}
178```
179