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

package/README.md

@@ -46,17 +46,13 @@ npm install ai-sdk-provider-claude-code@ai-sdk-v4 ai@^4.3.16
 
 ## Zod Compatibility
 
-This package is **fully compatible with both Zod 3 and Zod 4**.
+**Starting from v3.2.0, this package requires Zod 4.**
 
 ```bash
-# With Zod 3
-npm install ai-sdk-provider-claude-code ai zod@^3.0.0
-
-# With Zod 4
 npm install ai-sdk-provider-claude-code ai zod@^4.0.0
 ```
 
-Both this package and the underlying `@anthropic-ai/claude-agent-sdk` declare support for both versions (`peerDependencies: "zod": "^3.24.1 || ^4.0.0"`).
+> **Note:** Zod 3 support was dropped in v3.2.0 due to the underlying `@anthropic-ai/claude-agent-sdk@0.2.x` requiring Zod 4. If you need Zod 3 support, use `ai-sdk-provider-claude-code@3.1.x`.
 
 ## Installation
 
@@ -269,6 +265,49 @@ console.log(result.object); // Guaranteed to match schema
 - 🔧 Tool management (MCP servers, permissions)
 - 🧩 Callbacks (hooks, canUseTool)
 
+## Agent SDK Options (Advanced)
+
+This provider exposes Agent SDK options directly. Key options include:
+
+| Option                            | Description                                                                                               |
+| --------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| `betas`                           | Enable beta features (e.g., `['context-1m-2025-08-07']`)                                                  |
+| `sandbox`                         | Configure sandbox behavior (`{ enabled: true }`)                                                          |
+| `plugins`                         | Load custom plugins from local paths                                                                      |
+| `resumeSessionAt`                 | Resume session at a specific message UUID                                                                 |
+| `enableFileCheckpointing`         | Enable file rewind support                                                                                |
+| `maxBudgetUsd`                    | Maximum budget in USD for the query                                                                       |
+| `tools`                           | Tool configuration (array of names or preset)                                                             |
+| `allowDangerouslySkipPermissions` | Allow bypassing permissions                                                                               |
+| `persistSession`                  | When `false`, disables session persistence to disk (v3.2.0+)                                              |
+| `spawnClaudeCodeProcess`          | Custom process spawner for VMs/containers (v3.2.0+)                                                       |
+| `permissionMode`                  | Permission mode: `'default'`, `'acceptEdits'`, `'bypassPermissions'`, `'plan'`, `'delegate'`, `'dontAsk'` |
+
+**Agent definitions** (`agents`) now support additional fields (v3.2.0+):
+
+- `disallowedTools` - Tools to explicitly disallow for the agent
+- `mcpServers` - MCP servers available to the agent
+- `criticalSystemReminder_EXPERIMENTAL` - Experimental critical reminder
+
+See [`ClaudeCodeSettings`](https://github.com/ben-vargas/ai-sdk-provider-claude-code/blob/main/src/types.ts) for the full list of supported options (e.g., `allowedTools`, `disallowedTools`, `hooks`, `canUseTool`, `env`, `settingSources`).
+
+For options not explicitly exposed, use the `sdkOptions` escape hatch. It **overrides** explicit settings,
+but provider-managed fields are ignored (`model`, `abortController`, `prompt`, `outputFormat`).
+If you set `sdkOptions.resume`, it also drives the streaming prompt `session_id` so the SDK
+and prompt target the same session.
+
+```ts
+const model = claudeCode('sonnet', {
+  betas: ['context-1m-2025-08-07'],
+  sandbox: { enabled: true },
+  persistSession: false, // Don't persist session to disk
+  sdkOptions: {
+    maxBudgetUsd: 1,
+    resume: 'session-abc',
+  },
+});
+```
+
 ## Image Inputs (Streaming Only)
 
 - Enable streaming input (`streamingInput: 'always'` or provide `canUseTool`) before sending images.

package/dist/index.cjs

@@ -461,12 +461,33 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   ).optional(),
   executable: import_zod.z.enum(["bun", "deno", "node"]).optional(),
   executableArgs: import_zod.z.array(import_zod.z.string()).optional(),
-  permissionMode: import_zod.z.enum(["default", "acceptEdits", "bypassPermissions", "plan"]).optional(),
+  permissionMode: import_zod.z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "delegate", "dontAsk"]).optional(),
   permissionPromptToolName: import_zod.z.string().optional(),
   continue: import_zod.z.boolean().optional(),
   resume: import_zod.z.string().optional(),
   allowedTools: import_zod.z.array(import_zod.z.string()).optional(),
   disallowedTools: import_zod.z.array(import_zod.z.string()).optional(),
+  betas: import_zod.z.array(import_zod.z.string()).optional(),
+  allowDangerouslySkipPermissions: import_zod.z.boolean().optional(),
+  enableFileCheckpointing: import_zod.z.boolean().optional(),
+  maxBudgetUsd: import_zod.z.number().min(0).optional(),
+  plugins: import_zod.z.array(
+    import_zod.z.object({
+      type: import_zod.z.string(),
+      path: import_zod.z.string()
+    }).passthrough()
+  ).optional(),
+  resumeSessionAt: import_zod.z.string().optional(),
+  sandbox: import_zod.z.any().refine((val) => val === void 0 || typeof val === "object", {
+    message: "sandbox must be an object"
+  }).optional(),
+  tools: import_zod.z.union([
+    import_zod.z.array(import_zod.z.string()),
+    import_zod.z.object({
+      type: import_zod.z.literal("preset"),
+      preset: import_zod.z.literal("claude_code")
+    })
+  ]).optional(),
   settingSources: import_zod.z.array(import_zod.z.enum(["user", "project", "local"])).optional(),
   streamingInput: import_zod.z.enum(["auto", "always", "off"]).optional(),
   // Hooks and tool-permission callback (permissive validation of shapes)
@@ -521,9 +542,18 @@ var claudeCodeSettingsSchema = import_zod.z.object({
     import_zod.z.object({
       description: import_zod.z.string(),
       tools: import_zod.z.array(import_zod.z.string()).optional(),
+      disallowedTools: import_zod.z.array(import_zod.z.string()).optional(),
       prompt: import_zod.z.string(),
-      model: import_zod.z.enum(["sonnet", "opus", "haiku", "inherit"]).optional()
-    })
+      model: import_zod.z.enum(["sonnet", "opus", "haiku", "inherit"]).optional(),
+      mcpServers: import_zod.z.array(
+        import_zod.z.union([
+          import_zod.z.string(),
+          import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+          // McpServerConfigForProcessTransport
+        ])
+      ).optional(),
+      criticalSystemReminder_EXPERIMENTAL: import_zod.z.string().optional()
+    }).passthrough()
   ).optional(),
   includePartialMessages: import_zod.z.boolean().optional(),
   fallbackModel: import_zod.z.string().optional(),
@@ -532,7 +562,12 @@ var claudeCodeSettingsSchema = import_zod.z.object({
     message: "stderr must be a function"
   }).optional(),
   strictMcpConfig: import_zod.z.boolean().optional(),
-  extraArgs: import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.null()])).optional()
+  extraArgs: import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.null()])).optional(),
+  persistSession: import_zod.z.boolean().optional(),
+  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()
 }).strict();
 function validateModelId(modelId) {
   const knownModels = ["opus", "sonnet", "haiku"];
@@ -614,7 +649,9 @@ function validateSessionId(sessionId) {
 
 // src/logger.ts
 var defaultLogger = {
+  // eslint-disable-next-line no-console
   debug: (message) => console.debug(`[DEBUG] ${message}`),
+  // eslint-disable-next-line no-console
   info: (message) => console.info(`[INFO] ${message}`),
   warn: (message) => console.warn(`[WARN] ${message}`),
   error: (message) => console.error(`[ERROR] ${message}`)
@@ -696,6 +733,7 @@ function isAbortError(err) {
   return false;
 }
 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() {
   return {
     inputTokens: {
@@ -800,6 +838,25 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     const mapped = modelMap[this.modelId];
     return mapped ?? this.modelId;
   }
+  getSanitizedSdkOptions() {
+    if (!this.settings.sdkOptions || typeof this.settings.sdkOptions !== "object") {
+      return void 0;
+    }
+    const sanitized = { ...this.settings.sdkOptions };
+    const blockedKeys = Array.from(SDK_OPTIONS_BLOCKLIST).filter((key) => key in sanitized);
+    if (blockedKeys.length > 0) {
+      this.logger.warn(
+        `[claude-code] sdkOptions includes provider-managed fields (${blockedKeys.join(
+          ", "
+        )}); these will be ignored.`
+      );
+      blockedKeys.forEach((key) => delete sanitized[key]);
+    }
+    return sanitized;
+  }
+  getEffectiveResume(sdkOptions) {
+    return sdkOptions?.resume ?? this.settings.resume ?? this.sessionId;
+  }
   extractToolUses(content) {
     if (!Array.isArray(content)) {
       return [];
@@ -933,11 +990,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     }
     return warnings;
   }
-  createQueryOptions(abortController, responseFormat) {
+  createQueryOptions(abortController, responseFormat, stderrCollector, sdkOptions, effectiveResume) {
     const opts = {
       model: this.getModel(),
       abortController,
-      resume: this.settings.resume ?? this.sessionId,
+      resume: effectiveResume ?? this.settings.resume ?? this.sessionId,
       pathToClaudeCodeExecutable: this.settings.pathToClaudeCodeExecutable,
       maxTurns: this.settings.maxTurns,
       maxThinkingTokens: this.settings.maxThinkingTokens,
@@ -949,6 +1006,14 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       continue: this.settings.continue,
       allowedTools: this.settings.allowedTools,
       disallowedTools: this.settings.disallowedTools,
+      betas: this.settings.betas,
+      allowDangerouslySkipPermissions: this.settings.allowDangerouslySkipPermissions,
+      enableFileCheckpointing: this.settings.enableFileCheckpointing,
+      maxBudgetUsd: this.settings.maxBudgetUsd,
+      plugins: this.settings.plugins,
+      resumeSessionAt: this.settings.resumeSessionAt,
+      sandbox: this.settings.sandbox,
+      tools: this.settings.tools,
       mcpServers: this.settings.mcpServers,
       canUseTool: this.settings.canUseTool
     };
@@ -987,20 +1052,39 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     if (this.settings.forkSession !== void 0) {
       opts.forkSession = this.settings.forkSession;
     }
-    if (this.settings.stderr !== void 0) {
-      opts.stderr = this.settings.stderr;
-    }
     if (this.settings.strictMcpConfig !== void 0) {
       opts.strictMcpConfig = this.settings.strictMcpConfig;
     }
     if (this.settings.extraArgs !== void 0) {
       opts.extraArgs = this.settings.extraArgs;
     }
+    if (this.settings.persistSession !== void 0) {
+      opts.persistSession = this.settings.persistSession;
+    }
+    if (this.settings.spawnClaudeCodeProcess !== void 0) {
+      opts.spawnClaudeCodeProcess = this.settings.spawnClaudeCodeProcess;
+    }
     if (this.settings.hooks) {
       opts.hooks = this.settings.hooks;
     }
-    if (this.settings.env !== void 0) {
-      opts.env = { ...process.env, ...this.settings.env };
+    const sdkOverrides = sdkOptions ? sdkOptions : void 0;
+    const sdkEnv = sdkOverrides && typeof sdkOverrides.env === "object" && sdkOverrides.env !== null ? sdkOverrides.env : void 0;
+    const sdkStderr = sdkOverrides && typeof sdkOverrides.stderr === "function" ? sdkOverrides.stderr : void 0;
+    if (sdkOverrides) {
+      const rest = { ...sdkOverrides };
+      delete rest.env;
+      delete rest.stderr;
+      Object.assign(opts, rest);
+    }
+    const userStderrCallback = sdkStderr ?? this.settings.stderr;
+    if (stderrCollector || userStderrCallback) {
+      opts.stderr = (data) => {
+        if (stderrCollector) stderrCollector(data);
+        if (userStderrCallback) userStderrCallback(data);
+      };
+    }
+    if (this.settings.env !== void 0 || sdkEnv !== void 0) {
+      opts.env = { ...process.env, ...this.settings.env, ...sdkEnv };
     }
     if (responseFormat?.type === "json" && responseFormat.schema) {
       opts.outputFormat = {
@@ -1010,7 +1094,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     }
     return opts;
   }
-  handleClaudeCodeError(error, messagesPrompt) {
+  handleClaudeCodeError(error, messagesPrompt, collectedStderr) {
     if (isAbortError(error)) {
       throw error;
     }
@@ -1026,7 +1110,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       "unauthorized",
       "auth failed",
       "please login",
-      "claude login"
+      "claude login",
+      "/login",
+      // CLI returns "Please run /login"
+      "invalid api key"
     ];
     const errorMessage = isErrorWithMessage(error) && error.message ? error.message.toLowerCase() : "";
     const exitCode = isErrorWithCode(error) && typeof error.exitCode === "number" ? error.exitCode : void 0;
@@ -1046,11 +1133,13 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       });
     }
     const isRetryable = errorCode === "ENOENT" || errorCode === "ECONNREFUSED" || errorCode === "ETIMEDOUT" || errorCode === "ECONNRESET";
+    const stderrFromError = isErrorWithCode(error) && typeof error.stderr === "string" ? error.stderr : void 0;
+    const stderr = stderrFromError || collectedStderr || void 0;
     return createAPICallError({
       message: isErrorWithMessage(error) && error.message ? error.message : "Claude Code SDK error",
       code: errorCode || void 0,
       exitCode,
-      stderr: isErrorWithCode(error) && typeof error.stderr === "string" ? error.stderr : void 0,
+      stderr,
       promptExcerpt: messagesPrompt.substring(0, 200),
       isRetryable
     });
@@ -1082,7 +1171,19 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       abortListener = () => abortController.abort(options.abortSignal?.reason);
       options.abortSignal.addEventListener("abort", abortListener, { once: true });
     }
-    const queryOptions = this.createQueryOptions(abortController, options.responseFormat);
+    let collectedStderr = "";
+    const stderrCollector = (data) => {
+      collectedStderr += data;
+    };
+    const sdkOptions = this.getSanitizedSdkOptions();
+    const effectiveResume = this.getEffectiveResume(sdkOptions);
+    const queryOptions = this.createQueryOptions(
+      abortController,
+      options.responseFormat,
+      stderrCollector,
+      sdkOptions,
+      effectiveResume
+    );
     let text = "";
     let structuredOutput;
     let usage = createEmptyUsage();
@@ -1100,7 +1201,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       });
     }
     const modeSetting = this.settings.streamingInput ?? "auto";
-    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!this.settings.canUseTool;
+    const effectiveCanUseTool = sdkOptions?.canUseTool ?? this.settings.canUseTool;
+    const effectivePermissionPromptToolName = sdkOptions?.permissionPromptToolName ?? this.settings.permissionPromptToolName;
+    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!effectiveCanUseTool;
     if (!wantsStreamInput && hasImageParts) {
       warnings.push({
         type: "other",
@@ -1113,7 +1216,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       done = () => resolve(void 0);
     });
     try {
-      if (this.settings.canUseTool && this.settings.permissionPromptToolName) {
+      if (effectiveCanUseTool && effectivePermissionPromptToolName) {
         throw new Error(
           "canUseTool requires streamingInput mode ('auto' or 'always') and cannot be used with permissionPromptToolName (SDK constraint). Set streamingInput: 'auto' (or 'always') and remove permissionPromptToolName, or remove canUseTool."
         );
@@ -1121,11 +1224,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       const sdkPrompt = wantsStreamInput ? toAsyncIterablePrompt(
         messagesPrompt,
         outputStreamEnded,
-        this.settings.resume ?? this.sessionId,
+        effectiveResume,
         streamingContentParts
       ) : messagesPrompt;
       this.logger.debug(
-        `[claude-code] Executing query with streamingInput: ${wantsStreamInput}, session: ${this.settings.resume ?? this.sessionId ?? "new"}`
+        `[claude-code] Executing query with streamingInput: ${wantsStreamInput}, session: ${effectiveResume ?? "new"}`
       );
       const response = (0, import_claude_agent_sdk.query)({
         prompt: sdkPrompt,
@@ -1140,6 +1243,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           this.setSessionId(message.session_id);
           costUsd = message.total_cost_usd;
           durationMs = message.duration_ms;
+          if ("is_error" in message && message.is_error === true) {
+            const errorMessage = "result" in message && typeof message.result === "string" ? message.result : "Claude Code CLI returned an error";
+            throw Object.assign(new Error(errorMessage), { exitCode: 1 });
+          }
           if (message.subtype === "error_max_structured_output_retries") {
             throw new Error(
               "Failed to generate valid structured output after maximum retries. The model could not produce a response matching the required schema."
@@ -1185,7 +1292,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           message: CLAUDE_CODE_TRUNCATION_WARNING
         });
       } else {
-        throw this.handleClaudeCodeError(error, messagesPrompt);
+        throw this.handleClaudeCodeError(error, messagesPrompt, collectedStderr);
       }
     } finally {
       if (options.abortSignal && abortListener) {
@@ -1236,7 +1343,19 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       abortListener = () => abortController.abort(options.abortSignal?.reason);
       options.abortSignal.addEventListener("abort", abortListener, { once: true });
     }
-    const queryOptions = this.createQueryOptions(abortController, options.responseFormat);
+    let collectedStderr = "";
+    const stderrCollector = (data) => {
+      collectedStderr += data;
+    };
+    const sdkOptions = this.getSanitizedSdkOptions();
+    const effectiveResume = this.getEffectiveResume(sdkOptions);
+    const queryOptions = this.createQueryOptions(
+      abortController,
+      options.responseFormat,
+      stderrCollector,
+      sdkOptions,
+      effectiveResume
+    );
     if (queryOptions.includePartialMessages === void 0) {
       queryOptions.includePartialMessages = true;
     }
@@ -1250,7 +1369,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       });
     }
     const modeSetting = this.settings.streamingInput ?? "auto";
-    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!this.settings.canUseTool;
+    const effectiveCanUseTool = sdkOptions?.canUseTool ?? this.settings.canUseTool;
+    const effectivePermissionPromptToolName = sdkOptions?.permissionPromptToolName ?? this.settings.permissionPromptToolName;
+    const wantsStreamInput = modeSetting === "always" || modeSetting === "auto" && !!effectiveCanUseTool;
     if (!wantsStreamInput && hasImageParts) {
       warnings.push({
         type: "other",
@@ -1310,9 +1431,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
         let textPartId;
         let streamedTextLength = 0;
         let hasReceivedStreamEvents = false;
+        let hasStreamedJson = false;
         try {
           controller.enqueue({ type: "stream-start", warnings });
-          if (this.settings.canUseTool && this.settings.permissionPromptToolName) {
+          if (effectiveCanUseTool && effectivePermissionPromptToolName) {
             throw new Error(
               "canUseTool requires streamingInput mode ('auto' or 'always') and cannot be used with permissionPromptToolName (SDK constraint). Set streamingInput: 'auto' (or 'always') and remove permissionPromptToolName, or remove canUseTool."
             );
@@ -1320,11 +1442,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           const sdkPrompt = wantsStreamInput ? toAsyncIterablePrompt(
             messagesPrompt,
             outputStreamEnded,
-            this.settings.resume ?? this.sessionId,
+            effectiveResume,
             streamingContentParts
           ) : messagesPrompt;
           this.logger.debug(
-            `[claude-code] Starting stream query with streamingInput: ${wantsStreamInput}, session: ${this.settings.resume ?? this.sessionId ?? "new"}`
+            `[claude-code] Starting stream query with streamingInput: ${wantsStreamInput}, session: ${effectiveResume ?? "new"}`
           );
           const response = (0, import_claude_agent_sdk.query)({
             prompt: sdkPrompt,
@@ -1376,6 +1498,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                   });
                   accumulatedText += jsonDelta;
                   streamedTextLength += jsonDelta.length;
+                  hasStreamedJson = true;
                 }
               }
               continue;
@@ -1388,7 +1511,15 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 continue;
               }
               const content = message.message.content;
-              for (const tool3 of this.extractToolUses(content)) {
+              const tools = this.extractToolUses(content);
+              if (textPartId && tools.length > 0) {
+                controller.enqueue({
+                  type: "text-end",
+                  id: textPartId
+                });
+                textPartId = void 0;
+              }
+              for (const tool3 of tools) {
                 const toolId = tool3.id;
                 let state = toolStates.get(toolId);
                 if (!state) {
@@ -1595,6 +1726,10 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               }
             } else if (message.type === "result") {
               done();
+              if ("is_error" in message && message.is_error === true) {
+                const errorMessage = "result" in message && typeof message.result === "string" ? message.result : "Claude Code CLI returned an error";
+                throw Object.assign(new Error(errorMessage), { exitCode: 1 });
+              }
               if (message.subtype === "error_max_structured_output_retries") {
                 throw new Error(
                   "Failed to generate valid structured output after maximum retries. The model could not produce a response matching the required schema."
@@ -1615,12 +1750,14 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               this.logger.debug(`[claude-code] Stream finish reason: ${finishReason.unified}`);
               this.setSessionId(message.session_id);
               const structuredOutput = "structured_output" in message ? message.structured_output : void 0;
-              const alreadyStreamedJson = textPartId && options.responseFormat?.type === "json" && hasReceivedStreamEvents;
-              if (alreadyStreamedJson && textPartId) {
-                controller.enqueue({
-                  type: "text-end",
-                  id: textPartId
-                });
+              const alreadyStreamedJson = hasStreamedJson && options.responseFormat?.type === "json" && hasReceivedStreamEvents;
+              if (alreadyStreamedJson) {
+                if (textPartId) {
+                  controller.enqueue({
+                    type: "text-end",
+                    id: textPartId
+                  });
+                }
               } else if (structuredOutput !== void 0) {
                 const jsonTextId = (0, import_provider_utils.generateId)();
                 const jsonText = JSON.stringify(structuredOutput);
@@ -1753,7 +1890,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           if (isAbortError(error)) {
             errorToEmit = options.abortSignal?.aborted ? options.abortSignal.reason : error;
           } else {
-            errorToEmit = this.handleClaudeCodeError(error, messagesPrompt);
+            errorToEmit = this.handleClaudeCodeError(error, messagesPrompt, collectedStderr);
           }
           controller.enqueue({
             type: "error",