ai-sdk-provider-claude-code 3.4.2 → 3.4.4

package/README.md

@@ -7,7 +7,7 @@
   <a href="https://www.npmjs.com/package/ai-sdk-provider-claude-code"><img src="https://img.shields.io/npm/l/ai-sdk-provider-claude-code?color=00A79E" alt="License: MIT" /></a>
 </p>
 
-# AI SDK Provider for Claude Code SDK
+# AI SDK Provider for Claude Agent SDK
 
 > **Latest Release**: Version 3.x supports AI SDK v6 stable with the Claude Agent SDK. For AI SDK v5 support, use the `ai-sdk-v5` tag.
 
@@ -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
@@ -80,7 +82,7 @@ npm install ai-sdk-provider-claude-code@ai-sdk-v4 ai@^4.3.16
 
 **This is an unofficial community provider** and is not affiliated with or endorsed by Anthropic or Vercel. By using this provider:
 
-- You understand that your data will be sent to Anthropic's servers through the Claude Code SDK
+- You understand that your data will be sent to Anthropic's servers through the Claude Agent SDK
 - You agree to comply with [Anthropic's Terms of Service](https://www.anthropic.com/legal/consumer-terms)
 - You acknowledge this software is provided "as is" without warranties of any kind
 
@@ -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"
@@ -1425,6 +1460,7 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
       effectiveResume
     );
     let text = "";
+    const thinkingTraces = [];
     let structuredOutput;
     let usage = createEmptyUsage();
     let finishReason = { unified: "stop", raw: void 0 };
@@ -1480,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);
@@ -1547,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,
@@ -1565,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 }
         }
       }
     };
@@ -1784,11 +1831,18 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 const toolName = typeof toolBlock.name === "string" && toolBlock.name.length > 0 ? toolBlock.name : _ClaudeCodeLanguageModel.UNKNOWN_TOOL_NAME;
                 hasReceivedStreamEvents = true;
                 if (textPartId) {
+                  const closedTextId = textPartId;
                   controller.enqueue({
                     type: "text-end",
-                    id: textPartId
+                    id: closedTextId
                   });
                   textPartId = void 0;
+                  for (const [idx, blockTextId] of textBlocksByIndex) {
+                    if (blockTextId === closedTextId) {
+                      textBlocksByIndex.delete(idx);
+                      break;
+                    }
+                  }
                 }
                 toolBlocksByIndex.set(blockIndex, toolId);
                 toolInputAccumulators.set(toolId, "");
@@ -1847,11 +1901,18 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
                 const blockIndex = "index" in event ? event.index : -1;
                 hasReceivedStreamEvents = true;
                 if (textPartId) {
+                  const closedTextId = textPartId;
                   controller.enqueue({
                     type: "text-end",
-                    id: textPartId
+                    id: closedTextId
                   });
                   textPartId = void 0;
+                  for (const [idx, blockTextId] of textBlocksByIndex) {
+                    if (blockTextId === closedTextId) {
+                      textBlocksByIndex.delete(idx);
+                      break;
+                    }
+                  }
                 }
                 const reasoningPartId = (0, import_provider_utils.generateId)();
                 reasoningBlocksByIndex.set(blockIndex, reasoningPartId);
@@ -1962,11 +2023,18 @@ var ClaudeCodeLanguageModel = class _ClaudeCodeLanguageModel {
               const content = message.message.content;
               const tools = this.extractToolUses(content);
               if (textPartId && tools.length > 0) {
+                const closedTextId = textPartId;
                 controller.enqueue({
                   type: "text-end",
-                  id: textPartId
+                  id: closedTextId
                 });
                 textPartId = void 0;
+                for (const [idx, blockTextId] of textBlocksByIndex) {
+                  if (blockTextId === closedTextId) {
+                    textBlocksByIndex.delete(idx);
+                    break;
+                  }
+                }
               }
               for (const tool3 of tools) {
                 const toolId = tool3.id;