ai-sdk-provider-claude-code 3.4.1 → 3.4.3

package/README.md

@@ -58,9 +58,11 @@ npm install ai-sdk-provider-claude-code ai zod@^4.0.0
 
 ### 1. Install and authenticate the CLI
 
+See the [official docs](https://docs.anthropic.com/en/docs/claude-code/overview) for platform-specific options.
+
 ```bash
-npm install -g @anthropic-ai/claude-code
-claude login
+curl -fsSL https://claude.ai/install.sh | bash
+claude auth login
 ```
 
 ### 2. Add the provider
@@ -198,8 +200,8 @@ const model = claudeCode('sonnet', {
 CLI install and auth are unchanged:
 
 ```bash
-npm install -g @anthropic-ai/claude-code
-claude login
+curl -fsSL https://claude.ai/install.sh | bash
+claude auth login
 ```
 
 ### Migrating from v1.x to v2.0.0
@@ -271,22 +273,25 @@ console.log(result.object); // Matches the schema above
 
 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'` |
-| `sessionId`                       | Use a specific session ID for deterministic tracking and correlation (v3.4.0+)                            |
-| `debug`                           | Enable programmatic debug logging from the SDK (v3.4.0+)                                                  |
-| `debugFile`                       | Path to a file for SDK debug log output (v3.4.0+)                                                         |
+| 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'`        |
+| `sessionId`                       | Use a specific session ID for deterministic tracking and correlation (v3.4.0+)                                   |
+| `debug`                           | Enable programmatic debug logging from the SDK (v3.4.0+)                                                         |
+| `debugFile`                       | Path to a file for SDK debug log output (v3.4.0+)                                                                |
+| `effort`                          | Effort level: `'low'`, `'medium'`, `'high'`, or `'max'`                                                          |
+| `thinking`                        | Thinking config: `{ type: 'adaptive' }`, `{ type: 'enabled', budgetTokens?: number }`, or `{ type: 'disabled' }` |
+| `promptSuggestions`               | Enable prompt suggestions (`boolean`)                                                                            |
 
 **Agent definitions** (`agents`) now support additional fields (v3.2.0+):
 
@@ -434,7 +439,7 @@ This provider handles Anthropic `content_block_*` stream events directly for mor
 
 - **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).
+- **Extended thinking** — `reasoning-start/delta/end` emitted from `thinking` content blocks in streaming mode; `reasoning` content parts returned from `doGenerate` in non-streaming mode (availability depends on model and request).
 
 For subagent parent/child tracking, see **Subagent Hierarchy Tracking** in this README.
 

package/dist/index.cjs

@@ -465,6 +465,16 @@ var claudeCodeSettingsSchema = import_zod.z.object({
   ]).optional(),
   maxTurns: import_zod.z.number().int().min(1).max(100).optional(),
   maxThinkingTokens: import_zod.z.number().int().positive().max(1e5).optional(),
+  thinking: import_zod.z.union([
+    import_zod.z.object({ type: import_zod.z.literal("adaptive") }).strict(),
+    import_zod.z.object({
+      type: import_zod.z.literal("enabled"),
+      budgetTokens: import_zod.z.number().int().positive().optional()
+    }).strict(),
+    import_zod.z.object({ type: import_zod.z.literal("disabled") }).strict()
+  ]).optional(),
+  effort: import_zod.z.enum(["low", "medium", "high", "max"]).optional(),
+  promptSuggestions: import_zod.z.boolean().optional(),
   cwd: import_zod.z.string().refine(
     (val) => {
       if (typeof process === "undefined" || !process.versions?.node) {
@@ -791,6 +801,22 @@ function getBaseProcessEnv() {
 }
 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 isContentBlock(item) {
+  return typeof item === "object" && item !== null && "type" in item;
+}
+function filterContentBlocks(content, type) {
+  if (!Array.isArray(content)) return [];
+  const blocks = content.filter(
+    (item) => isContentBlock(item) && item.type === type
+  );
+  const mismatch = blocks.find((b) => b.type !== type);
+  if (mismatch) {
+    throw new Error(
+      `filterContentBlocks: block type '${mismatch.type}' passed filter for '${type}'`
+    );
+  }
+  return blocks;
+}
 function createEmptyUsage() {
   return {
     inputTokens: {
@@ -1046,14 +1072,29 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
   getEffectiveResume(sdkOptions) {
     return sdkOptions?.resume ?? this.settings.resume ?? this.sessionId;
   }
-  extractToolUses(content) {
-    if (!Array.isArray(content)) {
-      return [];
+  extractTextAndThinking(content) {
+    if (!Array.isArray(content)) return { text: "", thinking: [] };
+    let text = "";
+    const thinking = [];
+    for (const part of content) {
+      if (!isContentBlock(part)) continue;
+      if (part.type === "text" && typeof part.text === "string") {
+        text += part.text;
+      } else if (part.type === "thinking" && typeof part.thinking === "string") {
+        thinking.push(part.thinking);
+      }
+    }
+    if (text.length > 0 && typeof text !== "string") {
+      throw new Error("extractTextAndThinking: accumulated text must be a string");
+    }
+    if (thinking.some((t) => typeof t !== "string")) {
+      throw new Error("extractTextAndThinking: all thinking entries must be strings");
     }
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_use"
-    ).map((item) => {
-      const { id, name, input, parent_tool_use_id } = item;
+    return { text, thinking };
+  }
+  extractToolUses(content) {
+    return filterContentBlocks(content, "tool_use").map((block) => {
+      const { id, name, input, parent_tool_use_id } = block;
       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,
@@ -1063,13 +1104,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     });
   }
   extractToolResults(content) {
-    if (!Array.isArray(content)) {
-      return [];
-    }
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_result"
-    ).map((item) => {
-      const { tool_use_id, content: content2, is_error, name } = item;
+    return filterContentBlocks(content, "tool_result").map((block) => {
+      const { tool_use_id, content: content2, is_error, name } = block;
       return {
         id: typeof tool_use_id === "string" && tool_use_id.length > 0 ? tool_use_id : (0, import_provider_utils.generateId)(),
         name: typeof name === "string" && name.length > 0 ? name : void 0,
@@ -1079,13 +1115,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     });
   }
   extractToolErrors(content) {
-    if (!Array.isArray(content)) {
-      return [];
-    }
-    return content.filter(
-      (item) => typeof item === "object" && item !== null && "type" in item && item.type === "tool_error"
-    ).map((item) => {
-      const { tool_use_id, error, name } = item;
+    return filterContentBlocks(content, "tool_error").map((block) => {
+      const { tool_use_id, error, name } = block;
       return {
         id: typeof tool_use_id === "string" && tool_use_id.length > 0 ? tool_use_id : (0, import_provider_utils.generateId)(),
         name: typeof name === "string" && name.length > 0 ? name : void 0,
@@ -1209,6 +1240,9 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       pathToClaudeCodeExecutable: this.settings.pathToClaudeCodeExecutable,
       maxTurns: this.settings.maxTurns,
       maxThinkingTokens: this.settings.maxThinkingTokens,
+      thinking: this.settings.thinking,
+      effort: this.settings.effort,
+      promptSuggestions: this.settings.promptSuggestions,
       cwd: this.settings.cwd,
       executable: this.settings.executable,
       executableArgs: this.settings.executableArgs,
@@ -1332,6 +1366,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       "auth failed",
       "please login",
       "claude login",
+      "claude auth login",
       "/login",
       // CLI returns "Please run /login"
       "invalid api key"
@@ -1372,6 +1407,25 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       this.logger.warn(`Claude Code Session: ${warning}`);
     }
   }
+  logMcpConnectionIssues(mcpServers) {
+    if (!Array.isArray(mcpServers) || mcpServers.length === 0) {
+      return;
+    }
+    const serversNeedingAttention = mcpServers.filter((server) => {
+      const status = typeof server.status === "string" ? server.status.toLowerCase() : "";
+      return status === "failed" || status === "needs-auth";
+    });
+    if (serversNeedingAttention.length === 0) {
+      return;
+    }
+    const details = serversNeedingAttention.map((server) => {
+      const name = typeof server.name === "string" && server.name.trim().length > 0 ? server.name : "<unknown>";
+      const status = typeof server.status === "string" && server.status.trim().length > 0 ? server.status : "unknown";
+      const error = typeof server.error === "string" && server.error.trim().length > 0 ? ` (${server.error})` : "";
+      return `${name}:${status}${error}`;
+    }).join(", ");
+    this.logger.warn(`[claude-code] MCP servers not connected: ${details}`);
+  }
   async doGenerate(options) {
     this.logger.debug(`[claude-code] Starting doGenerate request with model: ${this.modelId}`);
     this.logger.debug(`[claude-code] Response format: ${options.responseFormat?.type ?? "none"}`);
@@ -1406,6 +1460,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       effectiveResume
     );
     let text = "";
+    const thinkingTraces = [];
     let structuredOutput;
     let usage = createEmptyUsage();
     let finishReason = { unified: "stop", raw: void 0 };
@@ -1461,7 +1516,11 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       for await (const message of response) {
         this.logger.debug(`[claude-code] Received message type: ${message.type}`);
         if (message.type === "assistant") {
-          text += message.message.content.map((c) => c.type === "text" ? c.text : "").join("");
+          const { text: messageText, thinking: messageThinking } = this.extractTextAndThinking(
+            message.message.content
+          );
+          text += messageText;
+          thinkingTraces.push(...messageThinking);
         } else if (message.type === "result") {
           done();
           this.setSessionId(message.session_id);
@@ -1494,6 +1553,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           finishReason = mapClaudeCodeFinishReason(message.subtype, stopReason);
           this.logger.debug(`[claude-code] Finish reason: ${finishReason.unified}`);
         } else if (message.type === "system" && message.subtype === "init") {
+          this.logMcpConnectionIssues(message.mcp_servers);
           this.setSessionId(message.session_id);
           this.logger.info(`[claude-code] Session initialized: ${message.session_id}`);
         }
@@ -1527,7 +1587,13 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
     }
     const finalText = structuredOutput !== void 0 ? JSON.stringify(structuredOutput) : text;
     return {
-      content: [{ type: "text", text: finalText }],
+      content: [
+        ...thinkingTraces.map((trace) => ({
+          type: "reasoning",
+          text: trace
+        })),
+        { type: "text", text: finalText }
+      ],
       usage,
       finishReason,
       warnings,
@@ -1545,7 +1611,8 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
           ...costUsd !== void 0 && { costUsd },
           ...durationMs !== void 0 && { durationMs },
           ...modelUsage !== void 0 && { modelUsage },
-          ...wasTruncated && { truncated: true }
+          ...wasTruncated && { truncated: true },
+          ...thinkingTraces.length > 0 && { thinkingTraces }
         }
       }
     };
@@ -2315,6 +2382,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               controller.close();
               return;
             } else if (message.type === "system" && message.subtype === "init") {
+              this.logMcpConnectionIssues(message.mcp_servers);
               this.setSessionId(message.session_id);
               this.logger.info(`[claude-code] Stream session initialized: ${message.session_id}`);
               controller.enqueue({