@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/llm/providers/anthropic.js

@@ -0,0 +1,430 @@
+/**
+ * Anthropic Claude Provider
+ * Supports Claude Sonnet 4, Haiku 4, and Opus 4
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { BaseProvider, } from '../types';
+import { getProviderApiKey } from '../auth-bridge';
+export class AnthropicProvider extends BaseProvider {
+    name = 'anthropic';
+    client;
+    defaultModel = 'claude-sonnet-4-20250514';
+    constructor(apiKey) {
+        super();
+        this.client = new Anthropic({
+            apiKey: apiKey || getProviderApiKey('anthropic') || process.env.ANTHROPIC_API_KEY,
+        });
+    }
+    async complete(request) {
+        const systemPrompt = this.extractSystemPrompt(request.messages);
+        const messages = this.convertMessages(this.filterSystemMessages(request.messages));
+        const response = await this.client.messages.create({
+            model: request.model || this.defaultModel,
+            max_tokens: request.maxTokens || 4096,
+            messages,
+            system: systemPrompt,
+            temperature: request.temperature,
+            stop_sequences: request.stopSequences,
+        });
+        return this.convertResponse(response);
+    }
+    async *stream(request) {
+        const systemPrompt = this.extractSystemPrompt(request.messages);
+        const messages = this.convertMessages(this.filterSystemMessages(request.messages));
+        const stream = await this.client.messages.stream({
+            model: request.model || this.defaultModel,
+            max_tokens: request.maxTokens || 4096,
+            messages,
+            system: systemPrompt,
+            temperature: request.temperature,
+            stop_sequences: request.stopSequences,
+        });
+        let usage;
+        let inputTokensFromStart = 0;
+        for await (const event of stream) {
+            if (event.type === 'message_start') {
+                const msgEvent = event;
+                if (msgEvent.message?.usage?.input_tokens) {
+                    inputTokensFromStart = msgEvent.message.usage.input_tokens;
+                }
+            }
+            else if (event.type === 'content_block_delta') {
+                if (event.delta.type === 'text_delta') {
+                    yield {
+                        content: event.delta.text,
+                        done: false,
+                    };
+                }
+            }
+            else if (event.type === 'message_delta') {
+                // Capture usage: input_tokens from message_start, output_tokens from message_delta
+                const deltaEvent = event;
+                if (deltaEvent.usage) {
+                    const inputTokens = inputTokensFromStart || deltaEvent.usage.input_tokens || 0;
+                    const outputTokens = deltaEvent.usage.output_tokens || 0;
+                    usage = {
+                        promptTokens: inputTokens,
+                        completionTokens: outputTokens,
+                        totalTokens: inputTokens + outputTokens,
+                    };
+                }
+            }
+            else if (event.type === 'message_stop') {
+                // If we didn't get usage from message_delta, try to get final message usage
+                if (!usage) {
+                    try {
+                        const finalMessage = await stream.finalMessage();
+                        usage = {
+                            promptTokens: finalMessage.usage.input_tokens,
+                            completionTokens: finalMessage.usage.output_tokens,
+                            totalTokens: finalMessage.usage.input_tokens + finalMessage.usage.output_tokens,
+                        };
+                    }
+                    catch {
+                        // Non-critical: token count will be estimated
+                    }
+                }
+                yield { done: true, usage };
+            }
+        }
+    }
+    /** H4: Format a rate limit error with actionable guidance. */
+    formatRateLimitError(error) {
+        const retryAfter = error?.headers?.['retry-after'];
+        const waitMsg = retryAfter ? `Wait ${retryAfter}s and retry` : 'Wait ~60 seconds and retry';
+        return new Error(`Rate limit reached. Options:\n` +
+            `  • ${waitMsg}\n` +
+            `  • Switch to a faster model: /model claude-haiku-4-5\n` +
+            `  • Check usage: https://console.anthropic.com/settings/usage`);
+    }
+    /** H4: Return true if the error is an Anthropic rate limit (429). */
+    isRateLimitError(error) {
+        if (!error || typeof error !== 'object')
+            return false;
+        const e = error;
+        return e.status === 429 || e.error?.type === 'rate_limit_error';
+    }
+    async completeWithTools(request) {
+        const systemPrompt = this.extractSystemPrompt(request.messages);
+        const messages = this.convertMessages(this.filterSystemMessages(request.messages));
+        const toolChoice = this.convertToolChoice(request.toolChoice);
+        try {
+            const response = await this.client.messages.create({
+                model: request.model || this.defaultModel,
+                max_tokens: request.maxTokens || 4096,
+                messages,
+                system: systemPrompt,
+                ...(request.toolChoice !== 'none' && { tools: this.convertTools(request.tools) }),
+                ...(toolChoice && { tool_choice: toolChoice }),
+                temperature: request.temperature,
+            });
+            return this.convertResponse(response);
+        }
+        catch (error) {
+            if (this.isRateLimitError(error))
+                throw this.formatRateLimitError(error);
+            throw error;
+        }
+    }
+    async *streamWithTools(request) {
+        const systemPrompt = this.extractSystemPrompt(request.messages);
+        const messages = this.convertMessages(this.filterSystemMessages(request.messages));
+        const toolChoice = this.convertToolChoice(request.toolChoice);
+        let stream;
+        try {
+            stream = await this.client.messages.stream({
+                model: request.model || this.defaultModel,
+                max_tokens: request.maxTokens || 4096,
+                messages,
+                system: systemPrompt,
+                ...(request.toolChoice !== 'none' && { tools: this.convertTools(request.tools) }),
+                ...(toolChoice && { tool_choice: toolChoice }),
+                temperature: request.temperature,
+            });
+        }
+        catch (error) {
+            if (this.isRateLimitError(error))
+                throw this.formatRateLimitError(error);
+            throw error;
+        }
+        let usage;
+        let inputTokensFromStart = 0; // Captured from message_start event
+        const toolCallAccumulator = new Map();
+        let toolCallIndex = 0;
+        let currentToolId = '';
+        let currentToolName = '';
+        for await (const event of stream) {
+            // Capture input tokens from message_start (sent at beginning of stream)
+            if (event.type === 'message_start') {
+                const msgEvent = event;
+                if (msgEvent.message?.usage?.input_tokens) {
+                    inputTokensFromStart = msgEvent.message.usage.input_tokens;
+                }
+            }
+            else if (event.type === 'content_block_start') {
+                const block = event.content_block;
+                if (block?.type === 'tool_use') {
+                    currentToolId = block.id || '';
+                    currentToolName = block.name || '';
+                    toolCallAccumulator.set(toolCallIndex, {
+                        id: currentToolId,
+                        name: currentToolName,
+                        arguments: '',
+                    });
+                    // Emit early notification so the TUI can show "preparing tool X..."
+                    yield { done: false, toolCallStart: { id: currentToolId, name: currentToolName } };
+                }
+            }
+            else if (event.type === 'content_block_delta') {
+                if (event.delta.type === 'text_delta' && event.delta.text) {
+                    yield { content: event.delta.text, done: false };
+                }
+                else if (event.delta.type === 'input_json_delta') {
+                    const existing = toolCallAccumulator.get(toolCallIndex);
+                    if (existing) {
+                        existing.arguments += event.delta.partial_json || '';
+                    }
+                }
+            }
+            else if (event.type === 'content_block_stop') {
+                if (toolCallAccumulator.has(toolCallIndex) && currentToolId) {
+                    toolCallIndex++;
+                    currentToolId = '';
+                    currentToolName = '';
+                }
+            }
+            else if (event.type === 'message_delta') {
+                const deltaEvent = event;
+                if (deltaEvent.usage) {
+                    // message_delta.usage contains output_tokens; input_tokens comes
+                    // from message_start. Combine both for accurate totals.
+                    const inputTokens = inputTokensFromStart || deltaEvent.usage.input_tokens || 0;
+                    const outputTokens = deltaEvent.usage.output_tokens || 0;
+                    usage = {
+                        promptTokens: inputTokens,
+                        completionTokens: outputTokens,
+                        totalTokens: inputTokens + outputTokens,
+                    };
+                }
+            }
+            else if (event.type === 'message_stop') {
+                if (!usage) {
+                    try {
+                        const finalMessage = await stream.finalMessage();
+                        usage = {
+                            promptTokens: finalMessage.usage.input_tokens,
+                            completionTokens: finalMessage.usage.output_tokens,
+                            totalTokens: finalMessage.usage.input_tokens + finalMessage.usage.output_tokens,
+                        };
+                    }
+                    catch {
+                        /* non-critical */
+                    }
+                }
+                // Emit accumulated tool calls on the final chunk
+                const toolCalls = toolCallAccumulator.size > 0
+                    ? Array.from(toolCallAccumulator.values()).map(tc => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: { name: tc.name, arguments: tc.arguments },
+                    }))
+                    : undefined;
+                yield { done: true, usage, toolCalls };
+                return;
+            }
+        }
+    }
+    async countTokens(text) {
+        try {
+            const response = await this.client.messages.countTokens({
+                model: this.defaultModel,
+                messages: [{ role: 'user', content: text }],
+            });
+            return response.input_tokens;
+        }
+        catch {
+            // Fallback to approximation if API call fails
+            return Math.ceil(text.length / 4);
+        }
+    }
+    getMaxTokens(model) {
+        const limits = {
+            'claude-sonnet-4-20250514': 8192,
+            'claude-haiku-4-20250514': 8192,
+            'claude-opus-4-20250514': 8192,
+            'claude-3-5-sonnet-20241022': 8192,
+            'claude-3-5-haiku-20241022': 8192,
+        };
+        return limits[model] || 4096;
+    }
+    async listModels() {
+        return [
+            'claude-sonnet-4-20250514',
+            'claude-haiku-4-20250514',
+            'claude-opus-4-20250514',
+            'claude-3-5-sonnet-20241022',
+            'claude-3-5-haiku-20241022',
+        ];
+    }
+    /**
+     * Convert messages to Anthropic format
+     */
+    convertMessages(messages) {
+        return messages.map(m => {
+            if (m.role === 'tool') {
+                // Tool result message
+                const toolContent = typeof m.content === 'string'
+                    ? m.content
+                    : Array.isArray(m.content)
+                        ? m.content
+                            .filter((b) => b.type === 'text')
+                            .map(b => b.text)
+                            .join('')
+                        : '';
+                return {
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: m.toolCallId,
+                            content: toolContent,
+                        },
+                    ],
+                };
+            }
+            if (m.toolCalls && m.toolCalls.length > 0) {
+                // Assistant message with tool calls
+                const textContent = typeof m.content === 'string'
+                    ? m.content
+                    : Array.isArray(m.content)
+                        ? m.content
+                            .filter((b) => b.type === 'text')
+                            .map(b => b.text)
+                            .join('')
+                        : '';
+                return {
+                    role: 'assistant',
+                    content: [
+                        ...(textContent
+                            ? [
+                                {
+                                    type: 'text',
+                                    text: textContent,
+                                },
+                            ]
+                            : []),
+                        ...m.toolCalls.map(tc => {
+                            try {
+                                return {
+                                    type: 'tool_use',
+                                    id: tc.id,
+                                    name: tc.function.name,
+                                    input: JSON.parse(tc.function.arguments),
+                                };
+                            }
+                            catch (error) {
+                                console.error(`Failed to parse tool call arguments for ${tc.function.name}:`, error);
+                                return {
+                                    type: 'tool_use',
+                                    id: tc.id,
+                                    name: tc.function.name,
+                                    input: {},
+                                };
+                            }
+                        }),
+                    ],
+                };
+            }
+            // Regular message — handle multimodal content arrays
+            if (Array.isArray(m.content)) {
+                const blocks = m.content.map(block => {
+                    if (block.type === 'image') {
+                        return {
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: block.source.media_type,
+                                data: block.source.data,
+                            },
+                        };
+                    }
+                    return { type: 'text', text: block.text };
+                });
+                return {
+                    role: m.role === 'assistant' ? 'assistant' : 'user',
+                    content: blocks,
+                };
+            }
+            return {
+                role: m.role === 'assistant' ? 'assistant' : 'user',
+                content: m.content,
+            };
+        });
+    }
+    /**
+     * Convert tool definitions to Anthropic format
+     */
+    convertTools(tools) {
+        return tools.map(t => ({
+            name: t.function.name,
+            description: t.function.description,
+            input_schema: {
+                ...t.function.parameters,
+                type: 'object',
+            },
+        }));
+    }
+    /**
+     * Convert tool choice to Anthropic format
+     */
+    convertToolChoice(toolChoice) {
+        if (!toolChoice || toolChoice === 'auto') {
+            return { type: 'auto' };
+        }
+        if (toolChoice === 'none') {
+            // When 'none' is specified, don't send tool_choice parameter
+            // This prevents Anthropic from using tools
+            return undefined;
+        }
+        if (typeof toolChoice === 'object' && toolChoice.type === 'function') {
+            return {
+                type: 'tool',
+                name: toolChoice.function.name,
+            };
+        }
+        return { type: 'auto' };
+    }
+    /**
+     * Convert Anthropic response to standard format
+     */
+    convertResponse(response) {
+        let content = '';
+        const toolCalls = [];
+        for (const block of response.content) {
+            if (block.type === 'text') {
+                content += block.text;
+            }
+            else if (block.type === 'tool_use') {
+                toolCalls.push({
+                    id: block.id,
+                    type: 'function',
+                    function: {
+                        name: block.name,
+                        arguments: JSON.stringify(block.input),
+                    },
+                });
+            }
+        }
+        return {
+            content,
+            toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+            usage: {
+                promptTokens: response.usage.input_tokens,
+                completionTokens: response.usage.output_tokens,
+                totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+            },
+            model: response.model,
+            finishReason: this.mapFinishReason(response.stop_reason),
+        };
+    }
+}