@mariozechner/pi-ai 0.5.26 → 0.5.28

package/dist/providers/anthropic.js

@@ -1,60 +1,16 @@
 import Anthropic from "@anthropic-ai/sdk";
+import { QueuedGenerateStream } from "../generate.js";
 import { calculateCost } from "../models.js";
 import { transformMessages } from "./utils.js";
-export class AnthropicLLM {
-    client;
-    modelInfo;
-    isOAuthToken = false;
-    constructor(model, apiKey) {
-        if (!apiKey) {
-            if (!process.env.ANTHROPIC_API_KEY) {
-                throw new Error("Anthropic API key is required. Set ANTHROPIC_API_KEY environment variable or pass it as an argument.");
-            }
-            apiKey = process.env.ANTHROPIC_API_KEY;
-        }
-        if (apiKey.includes("sk-ant-oat")) {
-            const defaultHeaders = {
-                accept: "application/json",
-                "anthropic-dangerous-direct-browser-access": "true",
-                "anthropic-beta": "oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14",
-            };
-            // Clear the env var if we're in Node.js to prevent SDK from using it
-            if (typeof process !== "undefined" && process.env) {
-                process.env.ANTHROPIC_API_KEY = undefined;
-            }
-            this.client = new Anthropic({
-                apiKey: null,
-                authToken: apiKey,
-                baseURL: model.baseUrl,
-                defaultHeaders,
-                dangerouslyAllowBrowser: true,
-            });
-            this.isOAuthToken = true;
-        }
-        else {
-            const defaultHeaders = {
-                accept: "application/json",
-                "anthropic-dangerous-direct-browser-access": "true",
-                "anthropic-beta": "fine-grained-tool-streaming-2025-05-14",
-            };
-            this.client = new Anthropic({ apiKey, baseURL: model.baseUrl, dangerouslyAllowBrowser: true, defaultHeaders });
-            this.isOAuthToken = false;
-        }
-        this.modelInfo = model;
-    }
-    getModel() {
-        return this.modelInfo;
-    }
-    getApi() {
-        return "anthropic-messages";
-    }
-    async generate(context, options) {
+export const streamAnthropic = (model, context, options) => {
+    const stream = new QueuedGenerateStream();
+    (async () => {
         const output = {
             role: "assistant",
             content: [],
-            api: this.getApi(),
-            provider: this.modelInfo.provider,
-            model: this.modelInfo.id,
+            api: "anthropic-messages",
+            provider: model.provider,
+            model: model.id,
             usage: {
                 input: 0,
                 output: 0,
@@ -65,67 +21,12 @@ export class AnthropicLLM {
             stopReason: "stop",
         };
         try {
-            const messages = this.convertMessages(context.messages);
-            const params = {
-                model: this.modelInfo.id,
-                messages,
-                max_tokens: options?.maxTokens || 4096,
-                stream: true,
-            };
-            // For OAuth tokens, we MUST include Claude Code identity
-            if (this.isOAuthToken) {
-                params.system = [
-                    {
-                        type: "text",
-                        text: "You are Claude Code, Anthropic's official CLI for Claude.",
-                        cache_control: {
-                            type: "ephemeral",
-                        },
-                    },
-                ];
-                if (context.systemPrompt) {
-                    params.system.push({
-                        type: "text",
-                        text: context.systemPrompt,
-                        cache_control: {
-                            type: "ephemeral",
-                        },
-                    });
-                }
-            }
-            else if (context.systemPrompt) {
-                params.system = context.systemPrompt;
-            }
-            if (options?.temperature !== undefined) {
-                params.temperature = options?.temperature;
-            }
-            if (context.tools) {
-                params.tools = this.convertTools(context.tools);
-            }
-            // Only enable thinking if the model supports it
-            if (options?.thinking?.enabled && this.modelInfo.reasoning) {
-                params.thinking = {
-                    type: "enabled",
-                    budget_tokens: options.thinking.budgetTokens || 1024,
-                };
-            }
-            if (options?.toolChoice) {
-                if (typeof options.toolChoice === "string") {
-                    params.tool_choice = { type: options.toolChoice };
-                }
-                else {
-                    params.tool_choice = options.toolChoice;
-                }
-            }
-            const stream = this.client.messages.stream({
-                ...params,
-                stream: true,
-            }, {
-                signal: options?.signal,
-            });
-            options?.onEvent?.({ type: "start", model: this.modelInfo.id, provider: this.modelInfo.provider });
+            const { client, isOAuthToken } = createClient(model, options?.apiKey);
+            const params = buildParams(model, context, isOAuthToken, options);
+            const anthropicStream = client.messages.stream({ ...params, stream: true }, { signal: options?.signal });
+            stream.push({ type: "start", partial: output });
             let currentBlock = null;
-            for await (const event of stream) {
+            for await (const event of anthropicStream) {
                 if (event.type === "content_block_start") {
                     if (event.content_block.type === "text") {
                         currentBlock = {
@@ -133,7 +34,7 @@ export class AnthropicLLM {
                             text: "",
                         };
                         output.content.push(currentBlock);
-                        options?.onEvent?.({ type: "text_start" });
+                        stream.push({ type: "text_start", partial: output });
                     }
                     else if (event.content_block.type === "thinking") {
                         currentBlock = {
@@ -142,10 +43,10 @@ export class AnthropicLLM {
                             thinkingSignature: "",
                         };
                         output.content.push(currentBlock);
-                        options?.onEvent?.({ type: "thinking_start" });
+                        stream.push({ type: "thinking_start", partial: output });
                     }
                     else if (event.content_block.type === "tool_use") {
-                        // We wait for the full tool use to be streamed to send the event
+                        // We wait for the full tool use to be streamed
                         currentBlock = {
                             type: "toolCall",
                             id: event.content_block.id,
@@ -159,16 +60,20 @@ export class AnthropicLLM {
                     if (event.delta.type === "text_delta") {
                         if (currentBlock && currentBlock.type === "text") {
                             currentBlock.text += event.delta.text;
-                            options?.onEvent?.({ type: "text_delta", content: currentBlock.text, delta: event.delta.text });
+                            stream.push({
+                                type: "text_delta",
+                                delta: event.delta.text,
+                                partial: output,
+                            });
                         }
                     }
                     else if (event.delta.type === "thinking_delta") {
                         if (currentBlock && currentBlock.type === "thinking") {
                             currentBlock.thinking += event.delta.thinking;
-                            options?.onEvent?.({
+                            stream.push({
                                 type: "thinking_delta",
-                                content: currentBlock.thinking,
                                 delta: event.delta.thinking,
+                                partial: output,
                             });
                         }
                     }
@@ -187,10 +92,18 @@ export class AnthropicLLM {
                 else if (event.type === "content_block_stop") {
                     if (currentBlock) {
                         if (currentBlock.type === "text") {
-                            options?.onEvent?.({ type: "text_end", content: currentBlock.text });
+                            stream.push({
+                                type: "text_end",
+                                content: currentBlock.text,
+                                partial: output,
+                            });
                         }
                         else if (currentBlock.type === "thinking") {
-                            options?.onEvent?.({ type: "thinking_end", content: currentBlock.thinking });
+                            stream.push({
+                                type: "thinking_end",
+                                content: currentBlock.thinking,
+                                partial: output,
+                            });
                         }
                         else if (currentBlock.type === "toolCall") {
                             const finalToolCall = {
@@ -200,150 +113,259 @@ export class AnthropicLLM {
                                 arguments: JSON.parse(currentBlock.partialJson),
                             };
                             output.content.push(finalToolCall);
-                            options?.onEvent?.({ type: "toolCall", toolCall: finalToolCall });
+                            stream.push({
+                                type: "toolCall",
+                                toolCall: finalToolCall,
+                                partial: output,
+                            });
                         }
                         currentBlock = null;
                     }
                 }
                 else if (event.type === "message_delta") {
                     if (event.delta.stop_reason) {
-                        output.stopReason = this.mapStopReason(event.delta.stop_reason);
+                        output.stopReason = mapStopReason(event.delta.stop_reason);
                     }
                     output.usage.input += event.usage.input_tokens || 0;
                     output.usage.output += event.usage.output_tokens || 0;
                     output.usage.cacheRead += event.usage.cache_read_input_tokens || 0;
                     output.usage.cacheWrite += event.usage.cache_creation_input_tokens || 0;
-                    calculateCost(this.modelInfo, output.usage);
+                    calculateCost(model, output.usage);
                 }
             }
-            options?.onEvent?.({ type: "done", reason: output.stopReason, message: output });
-            return output;
+            if (options?.signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            stream.push({ type: "done", reason: output.stopReason, message: output });
+            stream.end();
         }
         catch (error) {
             output.stopReason = "error";
             output.error = error instanceof Error ? error.message : JSON.stringify(error);
-            options?.onEvent?.({ type: "error", error: output.error });
-            return output;
+            stream.push({ type: "error", error: output.error, partial: output });
+            stream.end();
         }
+    })();
+    return stream;
+};
+function createClient(model, apiKey) {
+    if (apiKey.includes("sk-ant-oat")) {
+        const defaultHeaders = {
+            accept: "application/json",
+            "anthropic-dangerous-direct-browser-access": "true",
+            "anthropic-beta": "oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14",
+        };
+        // Clear the env var if we're in Node.js to prevent SDK from using it
+        if (typeof process !== "undefined" && process.env) {
+            process.env.ANTHROPIC_API_KEY = undefined;
+        }
+        const client = new Anthropic({
+            apiKey: null,
+            authToken: apiKey,
+            baseURL: model.baseUrl,
+            defaultHeaders,
+            dangerouslyAllowBrowser: true,
+        });
+        return { client, isOAuthToken: true };
+    }
+    else {
+        const defaultHeaders = {
+            accept: "application/json",
+            "anthropic-dangerous-direct-browser-access": "true",
+            "anthropic-beta": "fine-grained-tool-streaming-2025-05-14",
+        };
+        const client = new Anthropic({
+            apiKey,
+            baseURL: model.baseUrl,
+            dangerouslyAllowBrowser: true,
+            defaultHeaders,
+        });
+        return { client, isOAuthToken: false };
+    }
+}
+function buildParams(model, context, isOAuthToken, options) {
+    const params = {
+        model: model.id,
+        messages: convertMessages(context.messages, model),
+        max_tokens: options?.maxTokens || model.maxTokens,
+        stream: true,
+    };
+    // For OAuth tokens, we MUST include Claude Code identity
+    if (isOAuthToken) {
+        params.system = [
+            {
+                type: "text",
+                text: "You are Claude Code, Anthropic's official CLI for Claude.",
+                cache_control: {
+                    type: "ephemeral",
+                },
+            },
+        ];
+        if (context.systemPrompt) {
+            params.system.push({
+                type: "text",
+                text: context.systemPrompt,
+                cache_control: {
+                    type: "ephemeral",
+                },
+            });
+        }
+    }
+    else if (context.systemPrompt) {
+        params.system = context.systemPrompt;
+    }
+    if (options?.temperature !== undefined) {
+        params.temperature = options.temperature;
     }
-    convertMessages(messages) {
-        const params = [];
-        // Transform messages for cross-provider compatibility
-        const transformedMessages = transformMessages(messages, this.modelInfo, this.getApi());
-        for (const msg of transformedMessages) {
-            if (msg.role === "user") {
-                // Handle both string and array content
-                if (typeof msg.content === "string") {
+    if (context.tools) {
+        params.tools = convertTools(context.tools);
+    }
+    if (options?.thinkingEnabled && model.reasoning) {
+        params.thinking = {
+            type: "enabled",
+            budget_tokens: options.thinkingBudgetTokens || 1024,
+        };
+    }
+    if (options?.toolChoice) {
+        if (typeof options.toolChoice === "string") {
+            params.tool_choice = { type: options.toolChoice };
+        }
+        else {
+            params.tool_choice = options.toolChoice;
+        }
+    }
+    return params;
+}
+function convertMessages(messages, model) {
+    const params = [];
+    // Transform messages for cross-provider compatibility
+    const transformedMessages = transformMessages(messages, model);
+    for (const msg of transformedMessages) {
+        if (msg.role === "user") {
+            if (typeof msg.content === "string") {
+                if (msg.content.trim().length > 0) {
                     params.push({
                         role: "user",
                         content: msg.content,
                     });
                 }
-                else {
-                    // Convert array content to Anthropic format
-                    const blocks = msg.content.map((item) => {
-                        if (item.type === "text") {
-                            return {
-                                type: "text",
-                                text: item.text,
-                            };
-                        }
-                        else {
-                            // Image content
-                            return {
-                                type: "image",
-                                source: {
-                                    type: "base64",
-                                    media_type: item.mimeType,
-                                    data: item.data,
-                                },
-                            };
-                        }
-                    });
-                    const filteredBlocks = !this.modelInfo?.input.includes("image")
-                        ? blocks.filter((b) => b.type !== "image")
-                        : blocks;
-                    params.push({
-                        role: "user",
-                        content: filteredBlocks,
-                    });
-                }
             }
-            else if (msg.role === "assistant") {
-                const blocks = [];
-                for (const block of msg.content) {
-                    if (block.type === "text") {
-                        blocks.push({
+            else {
+                const blocks = msg.content.map((item) => {
+                    if (item.type === "text") {
+                        return {
                             type: "text",
-                            text: block.text,
-                        });
+                            text: item.text,
+                        };
                     }
-                    else if (block.type === "thinking") {
-                        blocks.push({
-                            type: "thinking",
-                            thinking: block.thinking,
-                            signature: block.thinkingSignature || "",
-                        });
+                    else {
+                        return {
+                            type: "image",
+                            source: {
+                                type: "base64",
+                                media_type: item.mimeType,
+                                data: item.data,
+                            },
+                        };
                     }
-                    else if (block.type === "toolCall") {
-                        blocks.push({
-                            type: "tool_use",
-                            id: block.id,
-                            name: block.name,
-                            input: block.arguments,
-                        });
+                });
+                let filteredBlocks = !model?.input.includes("image") ? blocks.filter((b) => b.type !== "image") : blocks;
+                filteredBlocks = filteredBlocks.filter((b) => {
+                    if (b.type === "text") {
+                        return b.text.trim().length > 0;
                     }
-                }
-                params.push({
-                    role: "assistant",
-                    content: blocks,
+                    return true;
                 });
-            }
-            else if (msg.role === "toolResult") {
+                if (filteredBlocks.length === 0)
+                    continue;
                 params.push({
                     role: "user",
-                    content: [
-                        {
-                            type: "tool_result",
-                            tool_use_id: msg.toolCallId,
-                            content: msg.content,
-                            is_error: msg.isError,
-                        },
-                    ],
+                    content: filteredBlocks,
                 });
             }
         }
-        return params;
-    }
-    convertTools(tools) {
-        if (!tools)
-            return [];
-        return tools.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            input_schema: {
-                type: "object",
-                properties: tool.parameters.properties || {},
-                required: tool.parameters.required || [],
-            },
-        }));
+        else if (msg.role === "assistant") {
+            const blocks = [];
+            for (const block of msg.content) {
+                if (block.type === "text") {
+                    if (block.text.trim().length === 0)
+                        continue;
+                    blocks.push({
+                        type: "text",
+                        text: block.text,
+                    });
+                }
+                else if (block.type === "thinking") {
+                    if (block.thinking.trim().length === 0)
+                        continue;
+                    blocks.push({
+                        type: "thinking",
+                        thinking: block.thinking,
+                        signature: block.thinkingSignature || "",
+                    });
+                }
+                else if (block.type === "toolCall") {
+                    blocks.push({
+                        type: "tool_use",
+                        id: block.id,
+                        name: block.name,
+                        input: block.arguments,
+                    });
+                }
+            }
+            if (blocks.length === 0)
+                continue;
+            params.push({
+                role: "assistant",
+                content: blocks,
+            });
+        }
+        else if (msg.role === "toolResult") {
+            params.push({
+                role: "user",
+                content: [
+                    {
+                        type: "tool_result",
+                        tool_use_id: msg.toolCallId,
+                        content: msg.content,
+                        is_error: msg.isError,
+                    },
+                ],
+            });
+        }
     }
-    mapStopReason(reason) {
-        switch (reason) {
-            case "end_turn":
-                return "stop";
-            case "max_tokens":
-                return "length";
-            case "tool_use":
-                return "toolUse";
-            case "refusal":
-                return "safety";
-            case "pause_turn": // Stop is good enough -> resubmit
-                return "stop";
-            case "stop_sequence":
-                return "stop"; // We don't supply stop sequences, so this should never happen
-            default:
-                return "stop";
+    return params;
+}
+function convertTools(tools) {
+    if (!tools)
+        return [];
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        input_schema: {
+            type: "object",
+            properties: tool.parameters.properties || {},
+            required: tool.parameters.required || [],
+        },
+    }));
+}
+function mapStopReason(reason) {
+    switch (reason) {
+        case "end_turn":
+            return "stop";
+        case "max_tokens":
+            return "length";
+        case "tool_use":
+            return "toolUse";
+        case "refusal":
+            return "safety";
+        case "pause_turn": // Stop is good enough -> resubmit
+            return "stop";
+        case "stop_sequence":
+            return "stop"; // We don't supply stop sequences, so this should never happen
+        default: {
+            const _exhaustive = reason;
+            throw new Error(`Unhandled stop reason: ${_exhaustive}`);
         }
     }
 }