@omarestrella/ai-sdk-agent-sdk 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omar Estrella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,91 @@
+# ai-sdk-claude-agent
+
+[AI SDK](https://sdk.vercel.ai/) provider that wraps the [Claude Agent SDK](https://platform.claude.com/docs/en/agent-sdk/overview), exposing it as a standard `LanguageModelV2`.
+
+## Install
+
+```bash
+bun install ai-sdk-claude-agent @anthropic-ai/claude-agent-sdk
+```
+
+## Usage
+
+```ts
+import { createClaudeAgent } from "ai-sdk-claude-agent";
+import { generateText, streamText } from "ai";
+
+const provider = createClaudeAgent();
+
+// Generate text
+const { text } = await generateText({
+  model: provider("claude-sonnet-4-5-20250929"),
+  prompt: "Explain how async generators work in JavaScript.",
+});
+
+// Stream text
+const result = streamText({
+  model: provider("claude-sonnet-4-5-20250929"),
+  prompt: "Write a haiku about TypeScript.",
+});
+
+for await (const chunk of result.textStream) {
+  process.stdout.write(chunk);
+}
+```
+
+## How it works
+
+- Calls the Agent SDK's `query()` with `maxTurns: 1` so the AI SDK controls the agentic loop
+- All built-in Agent SDK tools are disabled (`allowedTools: []`)
+- AI SDK tool definitions are passed through as in-process MCP tools via `createSdkMcpServer()`
+- Streaming uses `includePartialMessages: true` to get raw Anthropic events, mapped to `LanguageModelV2StreamPart`
+
+## Provider options
+
+```ts
+const provider = createClaudeAgent({
+  name: "my-agent", // provider display name (default: "claude-agent")
+  cwd: "/path/to/dir", // working directory for the agent
+});
+```
+
+## Available models
+
+| Model             | ID                           |
+| ----------------- | ---------------------------- |
+| Claude Sonnet 4.5 | `claude-sonnet-4-5-20250929` |
+| Claude Opus 4.5   | `claude-opus-4-5-20251101`   |
+| Claude Haiku 4.5  | `claude-haiku-4-5-20251001`  |
+
+Any model ID supported by the Agent SDK can be used.
+
+## Using with opencode
+
+The Claude Agent SDK requires a Claude Code & Claude Account or Anthropic API key.
+
+Install the [Claude Code CLI](https://code.claude.com/docs/en/setup) before you start.
+
+Add to your `opencode.json`:
+
+```json
+{
+  "provider": {
+    "claude-agent": {
+      "npm": "ai-sdk-claude-agent",
+      "name": "Claude Agent SDK",
+      "models": {
+        "claude-sonnet-4-5-20250929": {
+          "name": "Claude Sonnet 4.5 (Agent SDK)",
+          "tool_call": true,
+          "reasoning": true,
+          "limit": { "context": 200000, "output": 64000 }
+        }
+      }
+    }
+  }
+}
+```
+
+## License
+
+MIT

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { createClaudeAgent, type ClaudeAgentProvider, type ClaudeAgentProviderSettings, } from "./provider";
+export { ClaudeAgentLanguageModel } from "./language-model";
+export { createClaudeAgent as create } from "./provider";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,2BAA2B,GACjC,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAI5D,OAAO,EAAE,iBAAiB,IAAI,MAAM,EAAE,MAAM,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,6 @@
+export { createClaudeAgent, } from "./provider";
+export { ClaudeAgentLanguageModel } from "./language-model";
+// `create` alias for compatibility with opencode's dynamic provider loader,
+// which looks for a `create` function export from npm packages.
+export { createClaudeAgent as create } from "./provider";
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,GAGlB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAE5D,4EAA4E;AAC5E,gEAAgE;AAChE,OAAO,EAAE,iBAAiB,IAAI,MAAM,EAAE,MAAM,YAAY,CAAC"}

package/dist/src/json.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Safely serializes a value to JSON, handling circular references
+ * by replacing them with `[Circular]`.
+ */
+export declare function safeJsonStringify(value: unknown, space?: string | number): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/src/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/json.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,CA4BR"}

package/dist/src/json.js

@@ -0,0 +1,29 @@
+import { logger } from "./logger";
+/**
+ * Safely serializes a value to JSON, handling circular references
+ * by replacing them with `[Circular]`.
+ */
+export function safeJsonStringify(value, space) {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(value, (key, val) => {
+            if (val === null || typeof val !== "object") {
+                return val;
+            }
+            if (seen.has(val)) {
+                return "[Circular]";
+            }
+            seen.add(val);
+            return val;
+        }, space);
+    }
+    catch (e) {
+        const err = e;
+        logger.error("Cannot stringify JSON", {
+            error: err.message,
+            stack: err.stack,
+        });
+        return "{}";
+    }
+}
+//# sourceMappingURL=json.js.map

package/dist/src/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAAc,EACd,KAAuB;IAEvB,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;IAE3B,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,SAAS,CACnB,KAAK,EACL,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;YACX,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;gBAC5C,OAAO,GAAG,CAAC;YACb,CAAC;YAED,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;gBAClB,OAAO,YAAY,CAAC;YACtB,CAAC;YAED,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACd,OAAO,GAAG,CAAC;QACb,CAAC,EACD,KAAK,CACN,CAAC;IACJ,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,GAAG,GAAG,CAAU,CAAC;QACvB,MAAM,CAAC,KAAK,CAAC,uBAAuB,EAAE;YACpC,KAAK,EAAE,GAAG,CAAC,OAAO;YAClB,KAAK,EAAE,GAAG,CAAC,KAAK;SACjB,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/src/language-model.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+export interface ClaudeAgentLanguageModelConfig {
+    provider: string;
+    cwd?: string;
+}
+type DoGenerateOptions = Parameters<LanguageModelV2["doGenerate"]>[0];
+type DoGenerateResult = Awaited<ReturnType<LanguageModelV2["doGenerate"]>>;
+type DoStreamOptions = Parameters<LanguageModelV2["doStream"]>[0];
+type DoStreamResult = Awaited<ReturnType<LanguageModelV2["doStream"]>>;
+export declare class ClaudeAgentLanguageModel implements LanguageModelV2 {
+    readonly specificationVersion: "v2";
+    readonly modelId: string;
+    readonly defaultObjectGenerationMode: undefined;
+    private readonly config;
+    constructor(modelId: string, config: ClaudeAgentLanguageModelConfig);
+    get provider(): string;
+    get supportedUrls(): Record<string, RegExp[]>;
+    private buildQueryOptions;
+    doGenerate(options: DoGenerateOptions): Promise<DoGenerateResult>;
+    doStream(options: DoStreamOptions): Promise<DoStreamResult>;
+}
+export {};
+//# sourceMappingURL=language-model.d.ts.map

package/dist/src/language-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-model.d.ts","sourceRoot":"","sources":["../../src/language-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EAOhB,MAAM,kBAAkB,CAAC;AAwC1B,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,KAAK,iBAAiB,GAAG,UAAU,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACtE,KAAK,gBAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;AAC3E,KAAK,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAClE,KAAK,cAAc,GAAG,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAOvE,qBAAa,wBAAyB,YAAW,eAAe;IAC9D,QAAQ,CAAC,oBAAoB,EAAG,IAAI,CAAU;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,2BAA2B,YAAa;IAEjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;gBAE5C,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,8BAA8B;IAKnE,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,IAAI,aAAa,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAE5C;IAED,OAAO,CAAC,iBAAiB;IAmCnB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA0GjE,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;CA6SlE"}

package/dist/src/language-model.js

@@ -0,0 +1,440 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { safeJsonStringify } from "./json";
+import { convertMessages } from "./messages";
+import { AI_SDK_MCP_SERVER_NAME, convertTools } from "./tools";
+import { logger } from "./logger";
+/**
+ * Strips the MCP prefix from tool names returned by the Agent SDK.
+ * The Agent SDK returns tools in format: mcp__{serverName}__{toolName}
+ * The AI SDK expects just the original tool name.
+ */
+function stripMcpPrefix(toolName) {
+    const prefix = `mcp__${AI_SDK_MCP_SERVER_NAME}__`;
+    if (toolName.startsWith(prefix)) {
+        return toolName.slice(prefix.length);
+    }
+    return toolName;
+}
+function mapFinishReason(stopReason, hasToolCalls) {
+    if (hasToolCalls)
+        return "tool-calls";
+    switch (stopReason) {
+        case "end_turn":
+            return "stop";
+        case "max_tokens":
+            return "length";
+        case "stop_sequence":
+            return "stop";
+        case "tool_use":
+            return "tool-calls";
+        default:
+            return "unknown";
+    }
+}
+let idCounter = 0;
+function generateId() {
+    return `agent-${Date.now()}-${++idCounter}`;
+}
+export class ClaudeAgentLanguageModel {
+    specificationVersion = "v2";
+    modelId;
+    defaultObjectGenerationMode = undefined;
+    config;
+    constructor(modelId, config) {
+        this.modelId = modelId;
+        this.config = config;
+    }
+    get provider() {
+        return this.config.provider;
+    }
+    get supportedUrls() {
+        return {};
+    }
+    buildQueryOptions(options) {
+        const { systemPrompt, prompt } = convertMessages(options.prompt);
+        const convertedTools = convertTools(options.tools);
+        const abortController = new AbortController();
+        if (options.abortSignal) {
+            options.abortSignal.addEventListener("abort", () => {
+                abortController.abort();
+            });
+        }
+        const queryOptions = {
+            model: this.modelId,
+            maxTurns: 1,
+            permissionMode: "bypassPermissions",
+            allowDangerouslySkipPermissions: true,
+            abortController,
+            tools: [],
+            allowedTools: [`mcp__${AI_SDK_MCP_SERVER_NAME}__*`],
+            ...(this.config.cwd ? { cwd: this.config.cwd } : {}),
+        };
+        if (systemPrompt) {
+            queryOptions.systemPrompt = systemPrompt;
+        }
+        if (convertedTools?.mcpServer) {
+            queryOptions.mcpServers = {
+                [AI_SDK_MCP_SERVER_NAME]: convertedTools.mcpServer,
+            };
+        }
+        return { prompt, queryOptions };
+    }
+    async doGenerate(options) {
+        const warnings = [];
+        const { prompt, queryOptions } = this.buildQueryOptions(options);
+        const generator = query({
+            prompt,
+            options: queryOptions,
+        });
+        const content = [];
+        let usage = {
+            inputTokens: undefined,
+            outputTokens: undefined,
+            totalTokens: undefined,
+        };
+        let finishReason = "unknown";
+        let hasToolCalls = false;
+        // Track message UUIDs to avoid counting usage multiple times
+        // Per SDK docs: all messages with same ID have identical usage
+        const seenMessageIds = new Set();
+        for await (const message of generator) {
+            if (message.type === "assistant") {
+                const apiMessage = message.message;
+                const messageId = message.uuid;
+                if (Array.isArray(apiMessage.content)) {
+                    for (const block of apiMessage.content) {
+                        if (block.type === "text") {
+                            content.push({ type: "text", text: block.text });
+                        }
+                        else if (block.type === "tool_use") {
+                            hasToolCalls = true;
+                            const originalToolName = stripMcpPrefix(block.name);
+                            content.push({
+                                type: "tool-call",
+                                toolCallId: block.id,
+                                toolName: originalToolName,
+                                input: typeof block.input === "string"
+                                    ? block.input
+                                    : safeJsonStringify(block.input),
+                            });
+                        }
+                        else if (block.type === "thinking") {
+                            content.push({
+                                type: "reasoning",
+                                text: block.thinking ?? "",
+                            });
+                        }
+                    }
+                    // Only record usage once per unique message ID
+                    if (apiMessage.usage && messageId && !seenMessageIds.has(messageId)) {
+                        seenMessageIds.add(messageId);
+                        usage = {
+                            inputTokens: apiMessage.usage.input_tokens,
+                            outputTokens: apiMessage.usage.output_tokens,
+                            totalTokens: (apiMessage.usage.input_tokens ?? 0) +
+                                (apiMessage.usage.output_tokens ?? 0),
+                        };
+                        logger.debug("Usage reported in doGenerate", {
+                            messageId,
+                            inputTokens: usage.inputTokens,
+                            outputTokens: usage.outputTokens,
+                            totalTokens: usage.totalTokens,
+                        });
+                    }
+                    finishReason = mapFinishReason(apiMessage.stop_reason, hasToolCalls);
+                }
+            }
+            if (message.type === "result") {
+                // Result message contains cumulative usage from all steps
+                if (message.usage) {
+                    usage = {
+                        inputTokens: message.usage.input_tokens ?? usage.inputTokens,
+                        outputTokens: message.usage.output_tokens ?? usage.outputTokens,
+                        totalTokens: usage.totalTokens,
+                    };
+                    logger.debug("Final usage from result message", {
+                        inputTokens: usage.inputTokens,
+                        outputTokens: usage.outputTokens,
+                    });
+                }
+            }
+        }
+        // Calculate total tokens if we have both input and output
+        if (usage.inputTokens !== undefined && usage.outputTokens !== undefined) {
+            usage.totalTokens = usage.inputTokens + usage.outputTokens;
+        }
+        return {
+            content,
+            finishReason,
+            usage,
+            warnings,
+            request: { body: queryOptions },
+            response: {
+                headers: undefined,
+            },
+        };
+    }
+    async doStream(options) {
+        const warnings = [];
+        const { prompt, queryOptions } = this.buildQueryOptions(options);
+        // Enable partial messages to get raw Anthropic streaming events
+        queryOptions.includePartialMessages = true;
+        const generator = query({
+            prompt,
+            options: queryOptions,
+        });
+        let hasToolCalls = false;
+        const stream = new ReadableStream({
+            async start(controller) {
+                controller.enqueue({ type: "stream-start", warnings });
+                let finishReason = "unknown";
+                let usage = {
+                    inputTokens: undefined,
+                    outputTokens: undefined,
+                    totalTokens: undefined,
+                };
+                // Track active text block for start/delta/end lifecycle
+                let activeTextId = null;
+                // Track active reasoning block
+                let activeReasoningId = null;
+                // Track tool calls being streamed (keyed by content block index)
+                const toolCalls = new Map();
+                // Track message UUIDs to avoid counting usage multiple times
+                // Per SDK docs: all messages with same ID have identical usage
+                const seenMessageIds = new Set();
+                try {
+                    for await (const message of generator) {
+                        if (message.type === "stream_event") {
+                            const event = message.event;
+                            if (!event || !event.type)
+                                continue;
+                            switch (event.type) {
+                                case "message_start": {
+                                    const msg = event.message;
+                                    if (msg) {
+                                        controller.enqueue({
+                                            type: "response-metadata",
+                                            id: msg.id,
+                                            timestamp: new Date(),
+                                            modelId: msg.model,
+                                        });
+                                        if (msg.usage) {
+                                            usage.inputTokens = msg.usage.input_tokens;
+                                            logger.debug("Initial usage reported in doStream (message_start)", {
+                                                inputTokens: usage.inputTokens,
+                                            });
+                                        }
+                                    }
+                                    break;
+                                }
+                                case "content_block_start": {
+                                    const block = event.content_block;
+                                    const index = event.index;
+                                    if (block?.type === "text") {
+                                        activeTextId = generateId();
+                                        controller.enqueue({
+                                            type: "text-start",
+                                            id: activeTextId,
+                                        });
+                                    }
+                                    else if (block?.type === "tool_use") {
+                                        hasToolCalls = true;
+                                        const id = block.id ?? generateId();
+                                        toolCalls.set(index, {
+                                            toolCallId: id,
+                                            toolName: block.name,
+                                            argsText: "",
+                                        });
+                                        controller.enqueue({
+                                            type: "tool-input-start",
+                                            id,
+                                            toolName: block.name,
+                                        });
+                                    }
+                                    else if (block?.type === "thinking") {
+                                        activeReasoningId = generateId();
+                                        controller.enqueue({
+                                            type: "reasoning-start",
+                                            id: activeReasoningId,
+                                        });
+                                    }
+                                    break;
+                                }
+                                case "content_block_delta": {
+                                    const delta = event.delta;
+                                    const index = event.index;
+                                    if (delta?.type === "text_delta") {
+                                        if (!activeTextId) {
+                                            activeTextId = generateId();
+                                            controller.enqueue({
+                                                type: "text-start",
+                                                id: activeTextId,
+                                            });
+                                        }
+                                        controller.enqueue({
+                                            type: "text-delta",
+                                            id: activeTextId,
+                                            delta: delta.text,
+                                        });
+                                    }
+                                    else if (delta?.type === "input_json_delta") {
+                                        const tc = toolCalls.get(index);
+                                        if (tc) {
+                                            tc.argsText += delta.partial_json;
+                                            controller.enqueue({
+                                                type: "tool-input-delta",
+                                                id: tc.toolCallId,
+                                                delta: delta.partial_json,
+                                            });
+                                        }
+                                    }
+                                    else if (delta?.type === "thinking_delta") {
+                                        if (!activeReasoningId) {
+                                            activeReasoningId = generateId();
+                                            controller.enqueue({
+                                                type: "reasoning-start",
+                                                id: activeReasoningId,
+                                            });
+                                        }
+                                        controller.enqueue({
+                                            type: "reasoning-delta",
+                                            id: activeReasoningId,
+                                            delta: delta.thinking,
+                                        });
+                                    }
+                                    break;
+                                }
+                                case "content_block_stop": {
+                                    const index = event.index;
+                                    const tc = toolCalls.get(index);
+                                    if (tc) {
+                                        const originalToolName = stripMcpPrefix(tc.toolName);
+                                        // End the tool input stream
+                                        controller.enqueue({
+                                            type: "tool-input-end",
+                                            id: tc.toolCallId,
+                                        });
+                                        // Emit the complete tool call
+                                        controller.enqueue({
+                                            type: "tool-call",
+                                            toolCallId: tc.toolCallId,
+                                            toolName: originalToolName,
+                                            input: tc.argsText,
+                                        });
+                                        toolCalls.delete(index);
+                                    }
+                                    else if (activeTextId) {
+                                        controller.enqueue({
+                                            type: "text-end",
+                                            id: activeTextId,
+                                        });
+                                        activeTextId = null;
+                                    }
+                                    else if (activeReasoningId) {
+                                        controller.enqueue({
+                                            type: "reasoning-end",
+                                            id: activeReasoningId,
+                                        });
+                                        activeReasoningId = null;
+                                    }
+                                    break;
+                                }
+                                case "message_delta": {
+                                    if (event.usage) {
+                                        usage.outputTokens = event.usage.output_tokens;
+                                        if (usage.inputTokens !== undefined) {
+                                            usage.totalTokens =
+                                                usage.inputTokens + (event.usage.output_tokens ?? 0);
+                                        }
+                                        logger.debug("Usage delta reported in doStream (message_delta)", {
+                                            outputTokens: usage.outputTokens,
+                                            totalTokens: usage.totalTokens,
+                                        });
+                                    }
+                                    finishReason = mapFinishReason(event.delta?.stop_reason, hasToolCalls);
+                                    break;
+                                }
+                                case "message_stop": {
+                                    // Final streaming event
+                                    break;
+                                }
+                            }
+                        }
+                        else if (message.type === "assistant") {
+                            // Full assistant message — only update finish reason, not usage
+                            // Usage is tracked from streaming events (message_start, message_delta)
+                            // Per SDK docs: assistant messages share usage with streaming events
+                            const apiMessage = message.message;
+                            const messageId = message.uuid;
+                            if (Array.isArray(apiMessage?.content)) {
+                                for (const block of apiMessage.content) {
+                                    if (block.type === "tool_use") {
+                                        hasToolCalls = true;
+                                    }
+                                }
+                            }
+                            // Don't overwrite usage from streaming events - they are more accurate
+                            // and already tracked. Only log if this is a new message ID.
+                            if (apiMessage?.usage &&
+                                messageId &&
+                                !seenMessageIds.has(messageId)) {
+                                seenMessageIds.add(messageId);
+                                logger.debug("Assistant message usage (already tracked from streaming)", {
+                                    messageId,
+                                    inputTokens: apiMessage.usage.input_tokens,
+                                    outputTokens: apiMessage.usage.output_tokens,
+                                });
+                            }
+                            if (apiMessage?.stop_reason) {
+                                finishReason = mapFinishReason(apiMessage.stop_reason, hasToolCalls);
+                            }
+                        }
+                        else if (message.type === "result") {
+                            // Final result with cumulative usage from all steps
+                            const result = message;
+                            if (result.usage) {
+                                usage.inputTokens =
+                                    result.usage.input_tokens ?? usage.inputTokens;
+                                usage.outputTokens =
+                                    result.usage.output_tokens ?? usage.outputTokens;
+                                logger.debug("Final usage from result message", {
+                                    inputTokens: usage.inputTokens,
+                                    outputTokens: usage.outputTokens,
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    controller.enqueue({ type: "error", error });
+                }
+                // Close any dangling blocks
+                if (activeTextId) {
+                    controller.enqueue({ type: "text-end", id: activeTextId });
+                }
+                if (activeReasoningId) {
+                    controller.enqueue({ type: "reasoning-end", id: activeReasoningId });
+                }
+                // Calculate total tokens if not already done
+                if (usage.inputTokens !== undefined &&
+                    usage.outputTokens !== undefined) {
+                    usage.totalTokens = usage.inputTokens + usage.outputTokens;
+                }
+                controller.enqueue({
+                    type: "finish",
+                    finishReason,
+                    usage,
+                });
+                controller.close();
+            },
+        });
+        return {
+            stream,
+            request: { body: queryOptions },
+            response: {
+                headers: undefined,
+            },
+        };
+    }
+}
+//# sourceMappingURL=language-model.js.map