← Back to daily report

build-with-claude/streaming.md

Changed on 2026-03-03 18:21:53 EST

Unified Diff

--- a/build-with-claude/streaming.md
+++ b/build-with-claude/streaming.md
@@ -23,7 +23,7 @@
             print(text, end="", flush=True)
     ```
 
-    ```typescript TypeScript
+    ```typescript TypeScript hidelines={1..4}
     import Anthropic from "@anthropic-ai/sdk";
 
     const client = new Anthropic();
@@ -38,6 +38,31 @@
         console.log(text);
       });
     ```
+
+    ```csharp C#
+    using Anthropic;
+    using Anthropic.Models.Messages;
+
+    class Program
+    {
+        static async Task Main(string[] args)
+        {
+            AnthropicClient client = new();
+
+            var parameters = new MessageCreateParams
+            {
+                Model = Model.ClaudeOpus4_6,
+                MaxTokens = 1024,
+                Messages = [new() { Role = Role.User, Content = "Hello" }]
+            };
+
+            await foreach (var msg in client.Messages.CreateStreaming(parameters))
+            {
+                Console.Write(msg);
+            }
+        }
+    }
+    ```
 </CodeGroup>
 
 ## Get the final message without handling events
@@ -45,7 +70,7 @@
 If you don't need to process text as it arrives, the SDKs provide a way to use streaming under the hood while returning the complete `Message` object, identical to what `.create()` returns. This is especially useful for requests with large `max_tokens` values, where the SDKs require streaming to avoid HTTP timeouts.
 
 <CodeGroup>
-    ```python Python
+    ```python Python hidelines={1..4,-1}
     import anthropic
 
     client = anthropic.Anthropic()
@@ -60,7 +85,7 @@
     print(message.content[0].text)
     ```
 
-    ```typescript TypeScript
+    ```typescript TypeScript hidelines={1..4}
     import Anthropic from "@anthropic-ai/sdk";
 
     const client = new Anthropic();
@@ -72,7 +97,41 @@
     });
 
     const message = await stream.finalMessage();
-    console.log(message.content[0].text);
+    const textBlock = message.content.find((block) => block.type === "text");
+    if (textBlock && textBlock.type === "text") {
+      console.log(textBlock.text);
+    }
+    ```
+
+    
+    ```csharp C# nocheck
+    using System;
+    using System.Threading.Tasks;
+    using Anthropic;
+    using Anthropic.Models.Messages;
+
+    class Program
+    {
+        static async Task Main()
+        {
+            AnthropicClient client = new();
+
+            var parameters = new MessageCreateParams
+            {
+                Model = Model.ClaudeOpus4_6,
+                MaxTokens = 128000,
+                Messages = [new() { Role = Role.User, Content = "Write a detailed analysis..." }]
+            };
+
+            var fullText = "";
+            await foreach (var msg in client.Messages.CreateStreaming(parameters))
+            {
+                fullText += msg;
+            }
+
+            Console.WriteLine(fullText);
+        }
+    }
     ```
 </CodeGroup>
 
@@ -185,7 +244,7 @@
 }'
 ```
 
-```python Python
+```python Python hidelines={1..4}
 import anthropic
 
 client = anthropic.Anthropic()
@@ -197,6 +256,51 @@
 ) as stream:
     for text in stream.text_stream:
         print(text, end="", flush=True)
+```
+
+```typescript TypeScript hidelines={1..4}
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic();
+
+const stream = client.messages.stream({
+  model: "claude-opus-4-6",
+  messages: [{ role: "user", content: "Hello" }],
+  max_tokens: 256
+});
+
+for await (const event of stream) {
+  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+    process.stdout.write(event.delta.text);
+  }
+}
+```
+
+```csharp C#
+using System;
+using System.Threading.Tasks;
+using Anthropic;
+using Anthropic.Models.Messages;
+
+class Program
+{
+    static async Task Main(string[] args)
+    {
+        AnthropicClient client = new();
+
+        var parameters = new MessageCreateParams
+        {
+            Model = Model.ClaudeOpus4_6,
+            MaxTokens = 256,
+            Messages = [new() { Role = Role.User, Content = "Hello" }]
+        };
+
+        await foreach (var msg in client.Messages.CreateStreaming(parameters))
+        {
+            Console.Write(msg);
+        }
+    }
+}
 ```
 </CodeGroup>
 
@@ -271,7 +375,7 @@
     }'
 ```
 
-```python Python
+```python Python hidelines={1..4}
 import anthropic
 
 client = anthropic.Anthropic()
@@ -304,6 +408,94 @@
 ) as stream:
     for text in stream.text_stream:
         print(text, end="", flush=True)
+```
+
+```typescript TypeScript hidelines={1..4}
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic();
+
+const tools: Anthropic.Tool[] = [
+  {
+    name: "get_weather",
+    description: "Get the current weather in a given location",
+    input_schema: {
+      type: "object",
+      properties: {
+        location: {
+          type: "string",
+          description: "The city and state, e.g. San Francisco, CA"
+        }
+      },
+      required: ["location"]
+    }
+  }
+];
+
+const stream = client.messages.stream({
+  model: "claude-opus-4-6",
+  max_tokens: 1024,
+  tools: tools,
+  tool_choice: { type: "any" },
+  messages: [
+    {
+      role: "user",
+      content: "What is the weather like in San Francisco?"
+    }
+  ]
+});
+
+for await (const event of stream) {
+  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+    process.stdout.write(event.delta.text);
+  }
+}
+```
+
+```csharp C#
+using System;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Anthropic;
+using Anthropic.Models.Messages;
+
+class Program
+{
+    static async Task Main(string[] args)
+    {
+        AnthropicClient client = new();
+
+        var parameters = new MessageCreateParams
+        {
+            Model = Model.ClaudeOpus4_6,
+            MaxTokens = 1024,
+            Tools = [
+                new ToolUnion(new Tool()
+                {
+                    Name = "get_weather",
+                    Description = "Get the current weather in a given location",
+                    InputSchema = new InputSchema()
+                    {
+                        Properties = new Dictionary<string, JsonElement>
+                        {
+                            ["location"] = JsonSerializer.SerializeToElement(new { type = "string", description = "The city and state, e.g. San Francisco, CA" }),
+                        },
+                        Required = ["location"],
+                    },
+                }),
+            ],
+            ToolChoice = new ToolChoiceAny(),
+            Messages = [
+                new() { Role = Role.User, Content = "What is the weather like in San Francisco?" }
+            ]
+        };
+
+        await foreach (var msg in client.Messages.CreateStreaming(parameters))
+        {
+            Console.Write(msg);
+        }
+    }
+}
 ```
 </CodeGroup>
 
@@ -427,7 +619,7 @@
 }'
 ```
 
-```python Python
+```python Python hidelines={1..4}
 import anthropic
 
 client = anthropic.Anthropic()
@@ -449,6 +641,54 @@
                 print(event.delta.thinking, end="", flush=True)
             elif event.delta.type == "text_delta":
                 print(event.delta.text, end="", flush=True)
+```
+
+```typescript TypeScript hidelines={1..4}
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic();
+
+const stream = client.messages.stream({
+  model: "claude-opus-4-6",
+  max_tokens: 20000,
+  thinking: { type: "enabled", budget_tokens: 16000 },
+  messages: [
+    {
+      role: "user",
+      content: "What is the greatest common divisor of 1071 and 462?"
+    }
+  ]
+});
+
+for await (const event of stream) {
+  if (event.type === "content_block_delta") {
+    if (event.delta.type === "thinking_delta") {
+      process.stdout.write(event.delta.thinking);
+    } else if (event.delta.type === "text_delta") {
+      process.stdout.write(event.delta.text);
+    }
+  }
+}
+```
+
+```csharp C#
+using Anthropic;
+using Anthropic.Models.Messages;
+
+AnthropicClient client = new();
+
+var parameters = new MessageCreateParams
+{
+    Model = Model.ClaudeOpus4_6,
+    MaxTokens = 20000,
+    Thinking = new ThinkingConfigEnabled(budgetTokens: 16000),
+    Messages = [new() { Role = Role.User, Content = "What is the greatest common divisor of 1071 and 462?" }]
+};
+
+await foreach (var msg in client.Messages.CreateStreaming(parameters))
+{
+    Console.Write(msg);
+}
 ```
 </CodeGroup>
 
@@ -524,7 +764,7 @@
 }'
 ```
 
-```python Python
+```python Python hidelines={1..4}
 import anthropic
 
 client = anthropic.Anthropic()
@@ -541,36 +781,42 @@
         print(text, end="", flush=True)
 ```
 
-```java Java
-import com.anthropic.client.AnthropicClient;
-import com.anthropic.client.okhttp.AnthropicOkHttpClient;
-import com.anthropic.models.messages.MessageCreateParams;
-import com.anthropic.models.messages.Model;
-import com.anthropic.models.messages.WebSearchTool20250305;
-
-public class WebSearchStreaming {
-    public static void main(String[] args) {
-        AnthropicClient client = AnthropicOkHttpClient.fromEnv();
-
-        MessageCreateParams params = MessageCreateParams.builder()
-            .model(Model.CLAUDE_OPUS_4_6)
-            .maxTokens(1024L)
-            .addTool(WebSearchTool20250305.builder()
-                .maxUses(5L)
-                .build())
-            .addUserMessage("What is the weather like in New York City today?")
-            .build();
-
-        try (var streamResponse = client.messages().createStreaming(params)) {
-            streamResponse.stream().forEach(event -> {
-                event.contentBlockDelta().ifPresent(deltaEvent ->
-                    deltaEvent.delta().text().ifPresent(td ->
-                        System.out.print(td.text())
-                    )
-                );
-            });
-        }
-    }
+```typescript TypeScript hidelines={1..4}
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic();
+
+const stream = client.messages.stream({
+  model: "claude-opus-4-6",
+  max_tokens: 1024,
+  tools: [{ type: "web_search_20250305", name: "web_search", max_uses: 5 }],
+  messages: [{ role: "user", content: "What is the weather like in New York City today?" }]
+});
+
+for await (const event of stream) {
+  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+    process.stdout.write(event.delta.text);
+  }
+}
+```
+
+```csharp C#
+using Anthropic;
+using Anthropic.Models.Messages;
+
+AnthropicClient client = new();
+
+var parameters = new MessageCreateParams
+{
+    Model = Model.ClaudeOpus4_6,
+    MaxTokens = 1024,
+    Tools = [new ToolUnion(new WebSearchTool20250305() { MaxUses = 5 })],
+    Messages = [new() { Role = Role.User, Content = "What is the weather like in New York City today?" }]
+};
+
+await foreach (var msg in client.Messages.CreateStreaming(parameters))
+{
+    Console.Write(msg);
 }
 ```
 
@@ -619,6 +865,39 @@
 }
 ```
 
+```java Java
+import com.anthropic.client.AnthropicClient;
+import com.anthropic.client.okhttp.AnthropicOkHttpClient;
+import com.anthropic.models.messages.MessageCreateParams;
+import com.anthropic.models.messages.Model;
+import com.anthropic.models.messages.WebSearchTool20250305;
+
+public class WebSearchStreaming {
+    public static void main(String[] args) {
+        AnthropicClient client = AnthropicOkHttpClient.fromEnv();
+
+        MessageCreateParams params = MessageCreateParams.builder()
+            .model(Model.CLAUDE_OPUS_4_6)
+            .maxTokens(1024L)
+            .addTool(WebSearchTool20250305.builder()
+                .maxUses(5L)
+                .build())
+            .addUserMessage("What is the weather like in New York City today?")
+            .build();
+
+        try (var streamResponse = client.messages().createStreaming(params)) {
+            streamResponse.stream().forEach(event -> {
+                event.contentBlockDelta().ifPresent(deltaEvent ->
+                    deltaEvent.delta().text().ifPresent(td ->
+                        System.out.print(td.text())
+                    )
+                );
+            });
+        }
+    }
+}
+```
+
 ```ruby Ruby
 require "anthropic"