ai-sdk-provider-claude-code 3.2.1 → 3.3.0

package/README.md

@@ -361,6 +361,31 @@ See [examples/skills-management.ts](examples/skills-management.ts) for more exam
 - For parity with other tool events, `tool-error` includes `providerExecuted: true` and `providerMetadata['claude-code']` (e.g., `rawError`). These fields are documented extensions; downstream consumers may safely ignore them if unused.
 - See Tool Streaming Support for full event list, ordering guarantees, and performance considerations.
 
+## Content Block Streaming
+
+This provider handles Anthropic `content_block_*` stream events directly for more responsive UIs:
+
+- **Tool input streaming** — `tool-input-delta` streams arguments incrementally; `tool-call` emits when the tool input block completes (before results), enabling “running” state in UIs.
+- **Text streaming** — `text-start/delta/end` emitted from content blocks with proper lifecycle management.
+- **Extended thinking** — `reasoning-start/delta/end` emitted from `thinking` content blocks (availability depends on model and request).
+
+For subagent parent/child tracking, see **Subagent Hierarchy Tracking** in this README.
+
+## Subagent Hierarchy Tracking
+
+When Claude Code spawns subagents via the `Task` tool, this provider exposes parent-child relationships through `providerMetadata`:
+
+```ts
+// Available on tool-input-start, tool-call, tool-result, and tool-error events
+providerMetadata['claude-code'].parentToolCallId: string | null;
+```
+
+- Task tools: Always null (top-level)
+- Child tools: Reference their parent Task's ID
+- Parallel Tasks: Child returns null if parent is ambiguous
+
+This enables UIs to build hierarchical views of nested agent execution.
+
 ## Contributing
 
 We welcome contributions, especially:

package/dist/index.cjs

@@ -567,7 +567,8 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   spawnClaudeCodeProcess: import_zod.z.any().refine((val) => val === void 0 || typeof val === "function", {
     message: "spawnClaudeCodeProcess must be a function"
   }).optional(),
-  sdkOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional()
+  sdkOptions: import_zod.z.record(import_zod.z.string(), import_zod.z.any()).optional(),
+  maxToolResultSize: import_zod.z.number().int().min(100).max(1e6).optional()
 }).strict();
 function validateModelId(modelId) {
   const knownModels = ["opus", "sonnet", "haiku"];
@@ -732,6 +733,37 @@ function isAbortError(err) {
   }
   return false;
 }
+var DEFAULT_INHERITED_ENV_VARS = process.platform === "win32" ? [
+  "APPDATA",
+  "HOMEDRIVE",
+  "HOMEPATH",
+  "LOCALAPPDATA",
+  "PATH",
+  "PATHEXT",
+  "SYSTEMDRIVE",
+  "SYSTEMROOT",
+  "TEMP",
+  "TMP",
+  "USERNAME",
+  "USERPROFILE",
+  "WINDIR"
+] : ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER", "LANG", "LC_ALL", "TMPDIR"];
+var CLAUDE_ENV_VARS = ["CLAUDE_CONFIG_DIR"];
+function getBaseProcessEnv() {
+  const env = {};
+  const allowedKeys = /* @__PURE__ */ new Set([...DEFAULT_INHERITED_ENV_VARS, ...CLAUDE_ENV_VARS]);
+  for (const key of allowedKeys) {
+    const value = process.env[key];
+    if (typeof value !== "string") {
+      continue;
+    }
+    if (value.startsWith("()")) {
+      continue;
+    }
+    env[key] = value;
+  }
+  return env;
+}
 var STREAMING_FEATURE_WARNING = "Claude Agent SDK features (hooks/MCP/images) require streaming input. Set `streamingInput: 'always'` or provide `canUseTool` (auto streams only when canUseTool is set).";
 var SDK_OPTIONS_BLOCKLIST = /* @__PURE__ */ new Set(["model", "abortController", "prompt", "outputFormat"]);
 function createEmptyUsage() {
@@ -793,6 +825,49 @@ var modelMap = {
   sonnet: "sonnet",
   haiku: "haiku"
 };
+var MAX_TOOL_RESULT_SIZE = 1e4;
+function truncateToolResultForStream(result, maxSize = MAX_TOOL_RESULT_SIZE) {
+  if (typeof result === "string") {
+    if (result.length <= maxSize) return result;
+    return result.slice(0, maxSize) + `
+...[truncated ${result.length - maxSize} chars]`;
+  }
+  if (typeof result !== "object" || result === null) return result;
+  if (Array.isArray(result)) {
+    let largestIndex = -1;
+    let largestSize2 = 0;
+    for (let i = 0; i < result.length; i++) {
+      const value = result[i];
+      if (typeof value === "string" && value.length > largestSize2) {
+        largestIndex = i;
+        largestSize2 = value.length;
+      }
+    }
+    if (largestIndex >= 0 && largestSize2 > maxSize) {
+      const truncatedValue = result[largestIndex].slice(0, maxSize) + `
+...[truncated ${largestSize2 - maxSize} chars]`;
+      const cloned = [...result];
+      cloned[largestIndex] = truncatedValue;
+      return cloned;
+    }
+    return result;
+  }
+  const obj = result;
+  let largestKey = null;
+  let largestSize = 0;
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string" && value.length > largestSize) {
+      largestKey = key;
+      largestSize = value.length;
+    }
+  }
+  if (largestKey && largestSize > maxSize) {
+    const truncatedValue = obj[largestKey].slice(0, maxSize) + `
+...[truncated ${largestSize - maxSize} chars]`;
+    return { ...obj, [largestKey]: truncatedValue };
+  }
+  return result;
+}
 var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
   specificationVersion = "v3";
   defaultObjectGenerationMode = "json";
@@ -864,11 +939,12 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     return content.filter(
       (item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_use"
     ).map((item) => {
-      const { id, name, input } = item;
+      const { id, name, input, parent_tool_use_id } = item;
       return {
         id: typeof id === "string" && id.length > 0 ? id : (0, import_provider_utils.generateId)(),
         name: typeof name === "string" && name.length > 0 ? name : _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME,
-        input
+        input,
+        parentToolUseId: typeof parent_tool_use_id === "string" ? parent_tool_use_id : null
       };
     });
   }
@@ -940,6 +1016,27 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         return result;
       }
     }
+    if (Array.isArray(result) && result.length > 0) {
+      const textBlocks = result.filter(
+        (block) => block?.type === "text" && typeof block.text === "string"
+      ).map((block) => block.text);
+      if (textBlocks.length !== result.length) {
+        return result;
+      }
+      if (textBlocks.length === 1) {
+        try {
+          return JSON.parse(textBlocks[0]);
+        } catch {
+          return textBlocks[0];
+        }
+      }
+      const combined = textBlocks.join("\n");
+      try {
+        return JSON.parse(combined);
+      } catch {
+        return combined;
+      }
+    }
     return result;
   }
   generateAllWarnings(options, prompt) {
@@ -1084,7 +1181,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       };
     }
     if (this.settings.env !== void 0 || sdkEnv !== void 0) {
-      opts.env = { ...process.env, ...this.settings.env, ...sdkEnv };
+      const baseEnv = getBaseProcessEnv();
+      opts.env = { ...baseEnv, ...this.settings.env, ...sdkEnv };
     }
     if (responseFormat?.type === "json" && responseFormat.schema) {
       opts.outputFormat = {
@@ -1386,6 +1484,13 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           done = () => resolve(void 0);
         });
         const toolStates = /* @__PURE__ */ new Map();
+        const activeTaskTools = /* @__PURE__ */ new Map();
+        const getFallbackParentId = () => {
+          if (activeTaskTools.size === 1) {
+            return activeTaskTools.keys().next().value ?? null;
+          }
+          return null;
+        };
         const streamWarnings = [];
         const closeToolInput = (toolId, state) => {
           if (!state.inputClosed && state.inputStarted) {
@@ -1414,7 +1519,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 // rawInput preserves the original serialized format before AI SDK normalization.
                 // Use this if you need the exact string sent to the Claude CLI, which may differ
                 // from the `input` field after AI SDK processing.
-                rawInput: state.lastSerializedInput ?? ""
+                rawInput: state.lastSerializedInput ?? "",
+                parentToolCallId: state.parentToolCallId ?? null
               }
             }
           });
@@ -1432,6 +1538,12 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         let streamedTextLength = 0;
         let hasReceivedStreamEvents = false;
         let hasStreamedJson = false;
+        const toolBlocksByIndex = /* @__PURE__ */ new Map();
+        const toolInputAccumulators = /* @__PURE__ */ new Map();
+        const textBlocksByIndex = /* @__PURE__ */ new Map();
+        let textStreamedViaContentBlock = false;
+        const reasoningBlocksByIndex = /* @__PURE__ */ new Map();
+        let currentReasoningPartId;
         try {
           controller.enqueue({ type: "stream-start", warnings });
           if (effectiveCanUseTool && effectivePermissionPromptToolName) {
@@ -1483,6 +1595,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               if (event.type === "content_block_delta" && event.delta.type === "input_json_delta" && "partial_json" in event.delta && event.delta.partial_json) {
                 const jsonDelta = event.delta.partial_json;
                 hasReceivedStreamEvents = true;
+                const blockIndex = "index" in event ? event.index : -1;
                 if (options.responseFormat?.type === "json") {
                   if (!textPartId) {
                     textPartId = (0, import_provider_utils.generateId)();
@@ -1499,6 +1612,189 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   accumulatedText += jsonDelta;
                   streamedTextLength += jsonDelta.length;
                   hasStreamedJson = true;
+                  continue;
+                }
+                const toolId = toolBlocksByIndex.get(blockIndex);
+                if (toolId) {
+                  const accumulated = (toolInputAccumulators.get(toolId) ?? "") + jsonDelta;
+                  toolInputAccumulators.set(toolId, accumulated);
+                  controller.enqueue({
+                    type: "tool-input-delta",
+                    id: toolId,
+                    delta: jsonDelta
+                  });
+                  continue;
+                }
+              }
+              if (event.type === "content_block_start" && "content_block" in event && event.content_block?.type === "tool_use") {
+                const blockIndex = "index" in event ? event.index : -1;
+                const toolBlock = event.content_block;
+                const toolId = typeof toolBlock.id === "string" && toolBlock.id.length > 0 ? toolBlock.id : (0, import_provider_utils.generateId)();
+                const toolName = typeof toolBlock.name === "string" && toolBlock.name.length > 0 ? toolBlock.name : _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
+                hasReceivedStreamEvents = true;
+                if (textPartId) {
+                  controller.enqueue({
+                    type: "text-end",
+                    id: textPartId
+                  });
+                  textPartId = void 0;
+                }
+                toolBlocksByIndex.set(blockIndex, toolId);
+                toolInputAccumulators.set(toolId, "");
+                let state = toolStates.get(toolId);
+                if (!state) {
+                  const currentParentId = toolName === "Task" ? null : getFallbackParentId();
+                  state = {
+                    name: toolName,
+                    inputStarted: false,
+                    inputClosed: false,
+                    callEmitted: false,
+                    parentToolCallId: currentParentId
+                  };
+                  toolStates.set(toolId, state);
+                }
+                if (!state.inputStarted) {
+                  this.logger.debug(
+                    `[claude-code] Tool input started (content_block) - Tool: ${toolName}, ID: ${toolId}, parent: ${state.parentToolCallId}`
+                  );
+                  controller.enqueue({
+                    type: "tool-input-start",
+                    id: toolId,
+                    toolName,
+                    providerExecuted: true,
+                    dynamic: true,
+                    providerMetadata: {
+                      "claude-code": {
+                        parentToolCallId: state.parentToolCallId ?? null
+                      }
+                    }
+                  });
+                  if (toolName === "Task") {
+                    activeTaskTools.set(toolId, { startTime: Date.now() });
+                  }
+                  state.inputStarted = true;
+                }
+                continue;
+              }
+              if (event.type === "content_block_start" && "content_block" in event && event.content_block?.type === "text") {
+                const blockIndex = "index" in event ? event.index : -1;
+                hasReceivedStreamEvents = true;
+                const partId = (0, import_provider_utils.generateId)();
+                textBlocksByIndex.set(blockIndex, partId);
+                textPartId = partId;
+                this.logger.debug(
+                  `[claude-code] Text content block started - Index: ${blockIndex}, ID: ${partId}`
+                );
+                controller.enqueue({
+                  type: "text-start",
+                  id: partId
+                });
+                textStreamedViaContentBlock = true;
+                continue;
+              }
+              if (event.type === "content_block_start" && "content_block" in event && event.content_block?.type === "thinking") {
+                const blockIndex = "index" in event ? event.index : -1;
+                hasReceivedStreamEvents = true;
+                if (textPartId) {
+                  controller.enqueue({
+                    type: "text-end",
+                    id: textPartId
+                  });
+                  textPartId = void 0;
+                }
+                const reasoningPartId = (0, import_provider_utils.generateId)();
+                reasoningBlocksByIndex.set(blockIndex, reasoningPartId);
+                currentReasoningPartId = reasoningPartId;
+                this.logger.debug(
+                  `[claude-code] Reasoning started (content_block) - ID: ${reasoningPartId}`
+                );
+                controller.enqueue({
+                  type: "reasoning-start",
+                  id: reasoningPartId
+                });
+                continue;
+              }
+              if (event.type === "content_block_delta" && event.delta.type === "thinking_delta" && "thinking" in event.delta && event.delta.thinking) {
+                const blockIndex = "index" in event ? event.index : -1;
+                const reasoningPartId = reasoningBlocksByIndex.get(blockIndex) ?? currentReasoningPartId;
+                hasReceivedStreamEvents = true;
+                if (reasoningPartId) {
+                  controller.enqueue({
+                    type: "reasoning-delta",
+                    id: reasoningPartId,
+                    delta: event.delta.thinking
+                  });
+                }
+                continue;
+              }
+              if (event.type === "content_block_stop") {
+                const blockIndex = "index" in event ? event.index : -1;
+                hasReceivedStreamEvents = true;
+                const toolId = toolBlocksByIndex.get(blockIndex);
+                if (toolId) {
+                  const state = toolStates.get(toolId);
+                  if (state && !state.inputClosed) {
+                    const accumulatedInput = toolInputAccumulators.get(toolId) ?? "";
+                    this.logger.debug(
+                      `[claude-code] Tool content block stopped - Index: ${blockIndex}, Tool: ${state.name}, ID: ${toolId}`
+                    );
+                    controller.enqueue({
+                      type: "tool-input-end",
+                      id: toolId
+                    });
+                    state.inputClosed = true;
+                    state.lastSerializedInput = accumulatedInput;
+                    if (!state.callEmitted) {
+                      controller.enqueue({
+                        type: "tool-call",
+                        toolCallId: toolId,
+                        toolName: state.name,
+                        input: accumulatedInput,
+                        providerExecuted: true,
+                        dynamic: true,
+                        providerMetadata: {
+                          "claude-code": {
+                            rawInput: accumulatedInput,
+                            parentToolCallId: state.parentToolCallId ?? null
+                          }
+                        }
+                      });
+                      state.callEmitted = true;
+                    }
+                  }
+                  toolBlocksByIndex.delete(blockIndex);
+                  toolInputAccumulators.delete(toolId);
+                  continue;
+                }
+                const textId = textBlocksByIndex.get(blockIndex);
+                if (textId) {
+                  this.logger.debug(
+                    `[claude-code] Text content block stopped - Index: ${blockIndex}, ID: ${textId}`
+                  );
+                  controller.enqueue({
+                    type: "text-end",
+                    id: textId
+                  });
+                  textBlocksByIndex.delete(blockIndex);
+                  if (textPartId === textId) {
+                    textPartId = void 0;
+                  }
+                  continue;
+                }
+                const reasoningPartId = reasoningBlocksByIndex.get(blockIndex);
+                if (reasoningPartId) {
+                  this.logger.debug(
+                    `[claude-code] Reasoning ended (content_block) - ID: ${reasoningPartId}`
+                  );
+                  controller.enqueue({
+                    type: "reasoning-end",
+                    id: reasoningPartId
+                  });
+                  reasoningBlocksByIndex.delete(blockIndex);
+                  if (currentReasoningPartId === reasoningPartId) {
+                    currentReasoningPartId = void 0;
+                  }
+                  continue;
                 }
               }
               continue;
@@ -1510,6 +1806,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 );
                 continue;
               }
+              const sdkParentToolUseId = message.parent_tool_use_id;
               const content = message.message.content;
               const tools = this.extractToolUses(content);
               if (textPartId && tools.length > 0) {
@@ -1523,15 +1820,22 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 const toolId = tool3.id;
                 let state = toolStates.get(toolId);
                 if (!state) {
+                  const currentParentId = tool3.name === "Task" ? null : sdkParentToolUseId ?? tool3.parentToolUseId ?? getFallbackParentId();
                   state = {
                     name: tool3.name,
                     inputStarted: false,
                     inputClosed: false,
-                    callEmitted: false
+                    callEmitted: false,
+                    parentToolCallId: currentParentId
                   };
                   toolStates.set(toolId, state);
                   this.logger.debug(
-                    `[claude-code] New tool use detected - Tool: ${tool3.name}, ID: ${toolId}`
+                    `[claude-code] New tool use detected - Tool: ${tool3.name}, ID: ${toolId}, SDK parent: ${sdkParentToolUseId}, resolved parent: ${currentParentId}`
+                  );
+                } else if (!state.parentToolCallId && sdkParentToolUseId && tool3.name !== "Task") {
+                  state.parentToolCallId = sdkParentToolUseId;
+                  this.logger.debug(
+                    `[claude-code] Retroactive parent context - Tool: ${tool3.name}, ID: ${toolId}, parent: ${sdkParentToolUseId}`
                   );
                 }
                 state.name = tool3.name;
@@ -1544,9 +1848,17 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                     id: toolId,
                     toolName: tool3.name,
                     providerExecuted: true,
-                    dynamic: true
+                    dynamic: true,
                     // V3 field: indicates tool is provider-defined
+                    providerMetadata: {
+                      "claude-code": {
+                        parentToolCallId: state.parentToolCallId ?? null
+                      }
+                    }
                   });
+                  if (tool3.name === "Task") {
+                    activeTaskTools.set(toolId, { startTime: Date.now() });
+                  }
                   state.inputStarted = true;
                 }
                 const serializedInput = this.serializeToolInput(tool3.input);
@@ -1617,6 +1929,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 );
                 continue;
               }
+              const sdkParentToolUseIdForResults = message.parent_tool_use_id;
               const content = message.message.content;
               for (const result of this.extractToolResults(content)) {
                 let state = toolStates.get(result.id);
@@ -1628,11 +1941,13 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   this.logger.warn(
                     `[claude-code] Received tool result for unknown tool ID: ${result.id}`
                   );
+                  const resolvedParentId = toolName === "Task" ? null : sdkParentToolUseIdForResults ?? getFallbackParentId();
                   state = {
                     name: toolName,
                     inputStarted: false,
                     inputClosed: false,
-                    callEmitted: false
+                    callEmitted: false,
+                    parentToolCallId: resolvedParentId
                   };
                   toolStates.set(result.id, state);
                   if (!state.inputStarted) {
@@ -1641,8 +1956,13 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                       id: result.id,
                       toolName,
                       providerExecuted: true,
-                      dynamic: true
+                      dynamic: true,
                       // V3 field: indicates tool is provider-defined
+                      providerMetadata: {
+                        "claude-code": {
+                          parentToolCallId: state.parentToolCallId ?? null
+                        }
+                      }
                     });
                     state.inputStarted = true;
                   }
@@ -1663,12 +1983,25 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                     return String(result.result);
                   }
                 })();
+                const maxToolResultSize = this.settings.maxToolResultSize;
+                const truncatedResult = truncateToolResultForStream(
+                  normalizedResult,
+                  maxToolResultSize
+                );
+                const truncatedRawResult = truncateToolResultForStream(
+                  rawResult,
+                  maxToolResultSize
+                );
+                const rawResultTruncated = truncatedRawResult !== rawResult;
                 emitToolCall(result.id, state);
+                if (toolName === "Task") {
+                  activeTaskTools.delete(result.id);
+                }
                 controller.enqueue({
                   type: "tool-result",
                   toolCallId: result.id,
                   toolName,
-                  result: normalizedResult,
+                  result: truncatedResult,
                   isError: result.isError,
                   providerExecuted: true,
                   dynamic: true,
@@ -1678,7 +2011,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                       // rawResult preserves the original CLI output string before JSON parsing.
                       // Use this when you need the exact string returned by the tool, especially
                       // if the `result` field has been parsed/normalized and you need the original format.
-                      rawResult
+                      rawResult: truncatedRawResult,
+                      rawResultTruncated,
+                      parentToolCallId: state.parentToolCallId ?? null
                     }
                   }
                 });
@@ -1693,15 +2028,20 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   this.logger.warn(
                     `[claude-code] Received tool error for unknown tool ID: ${error.id}`
                   );
+                  const errorResolvedParentId = toolName === "Task" ? null : sdkParentToolUseIdForResults ?? getFallbackParentId();
                   state = {
                     name: toolName,
                     inputStarted: true,
                     inputClosed: true,
-                    callEmitted: false
+                    callEmitted: false,
+                    parentToolCallId: errorResolvedParentId
                   };
                   toolStates.set(error.id, state);
                 }
                 emitToolCall(error.id, state);
+                if (toolName === "Task") {
+                  activeTaskTools.delete(error.id);
+                }
                 const rawError = typeof error.error === "string" ? error.error : typeof error.error === "object" && error.error !== null ? (() => {
                   try {
                     return JSON.stringify(error.error);
@@ -1719,7 +2059,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   // V3 field: indicates tool is provider-defined
                   providerMetadata: {
                     "claude-code": {
-                      rawError
+                      rawError,
+                      parentToolCallId: state.parentToolCallId ?? null
                     }
                   }
                 });
@@ -1779,7 +2120,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   type: "text-end",
                   id: textPartId
                 });
-              } else if (accumulatedText) {
+              } else if (accumulatedText && !textStreamedViaContentBlock) {
                 const fallbackTextId = (0, import_provider_utils.generateId)();
                 controller.enqueue({
                   type: "text-start",
@@ -1817,6 +2158,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   }
                 }
               });
+              controller.close();
+              return;
             } else if (message.type === "system" && message.subtype === "init") {
               this.setSessionId(message.session_id);
               this.logger.info(`[claude-code] Stream session initialized: ${message.session_id}`);
@@ -1850,7 +2193,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 type: "text-end",
                 id: textPartId
               });
-            } else if (accumulatedText) {
+            } else if (accumulatedText && !textStreamedViaContentBlock) {
               const fallbackTextId = (0, import_provider_utils.generateId)();
               controller.enqueue({
                 type: "text-start",