@just-every/ensemble 0.1.0

package/dist/model_providers/claude.js

@@ -0,0 +1,788 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { v4 as uuidv4 } from 'uuid';
+function formatWebSearchResults(results) {
+    if (!Array.isArray(results))
+        return '';
+    return results
+        .filter(r => r.type === 'web_search_result')
+        .map((r, i) => `${i + 1}. ${r.title || 'Untitled'} – ${r.url}`)
+        .join('\n');
+}
+function createCitationTracker() {
+    return {
+        citations: new Map(),
+        lastIndex: 0,
+    };
+}
+function formatCitation(tracker, citation) {
+    const url = citation.url;
+    let index;
+    if (tracker.citations.has(url)) {
+        const entries = Array.from(tracker.citations.entries());
+        index = entries.findIndex(([k]) => k === url) + 1;
+    }
+    else {
+        tracker.lastIndex++;
+        index = tracker.lastIndex;
+        tracker.citations.set(url, {
+            title: citation.title,
+            url: citation.url,
+            citedText: citation.cited_text,
+        });
+    }
+    return ` [${index}]`;
+}
+function generateFootnotes(tracker) {
+    if (tracker.citations.size === 0)
+        return '';
+    const footnotes = Array.from(tracker.citations.values())
+        .map((citation, i) => `[${i + 1}] ${citation.title} – ${citation.url}`)
+        .join('\n');
+    return '\n\nReferences:\n' + footnotes;
+}
+import { costTracker } from '@just-every/ensemble/cost_tracker';
+import { log_llm_error, log_llm_request, log_llm_response, } from '../utils/llm_logger.js';
+import { isPaused } from '../utils/communication.js';
+import { extractBase64Image, resizeAndTruncateForClaude, } from '../utils/image_utils.js';
+import { convertImageToTextIfNeeded } from '../utils/image_to_text.js';
+import { bufferDelta, flushBufferedDeltas, } from '../utils/delta_buffer.js';
+function convertToClaudeTools(tools) {
+    return tools.map(tool => {
+        if (tool.definition.function.name === 'claude_web_search') {
+            return {
+                type: 'web_search_20250305',
+                name: 'web_search',
+            };
+        }
+        return {
+            name: tool.definition.function.name,
+            description: tool.definition.function.description,
+            input_schema: tool.definition.function.parameters,
+        };
+    });
+}
+function getImageMediaType(imageData) {
+    if (imageData.includes('data:image/jpeg'))
+        return 'image/jpeg';
+    if (imageData.includes('data:image/png'))
+        return 'image/png';
+    if (imageData.includes('data:image/gif'))
+        return 'image/gif';
+    if (imageData.includes('data:image/webp'))
+        return 'image/webp';
+    return 'image/jpeg';
+}
+function cleanBase64Data(imageData) {
+    return imageData.replace(/^data:image\/[a-z]+;base64,/, '');
+}
+async function convertToClaudeMessage(role, content, msg, result) {
+    if (!msg)
+        return null;
+    if (msg.type === 'function_call') {
+        let inputArgs = {};
+        try {
+            inputArgs = JSON.parse(msg.arguments || '{}');
+        }
+        catch (e) {
+            console.error(`Error parsing function call arguments for ${msg.name}: ${msg.arguments}`, e);
+            return null;
+        }
+        const toolUseBlock = {
+            type: 'tool_use',
+            id: msg.call_id,
+            name: msg.name,
+            input: inputArgs,
+        };
+        return { role: 'assistant', content: [toolUseBlock] };
+    }
+    else if (msg.type === 'function_call_output') {
+        if (typeof msg.output === 'string') {
+            const extracted = extractBase64Image(msg.output);
+            if (extracted.found && extracted.image_id !== null) {
+                const image_id = extracted.image_id;
+                try {
+                    const originalImageData = extracted.images[image_id];
+                    const processedImageData = await resizeAndTruncateForClaude(originalImageData);
+                    const mediaType = getImageMediaType(processedImageData);
+                    const cleanedImageData = cleanBase64Data(processedImageData);
+                    const toolResultBlock = {
+                        type: 'tool_result',
+                        tool_use_id: msg.call_id,
+                        content: extracted.replaceContent.trim() || '',
+                        ...(msg.status === 'incomplete'
+                            ? { is_error: true }
+                            : {}),
+                    };
+                    const contentBlocks = [
+                        toolResultBlock,
+                        {
+                            type: 'image',
+                            source: {
+                                type: 'base64',
+                                media_type: mediaType,
+                                data: cleanedImageData,
+                            },
+                        },
+                        {
+                            type: 'text',
+                            text: `This is [image #${image_id}] from the function call output of ${msg.name}`,
+                        },
+                    ];
+                    return { role: 'user', content: contentBlocks };
+                }
+                catch (error) {
+                    console.error('Error processing image in function call output:', error);
+                }
+            }
+        }
+        const toolResultBlock = {
+            type: 'tool_result',
+            tool_use_id: msg.call_id,
+            content: msg.output || '',
+            ...(msg.status === 'incomplete' ? { is_error: true } : {}),
+        };
+        return { role: 'user', content: [toolResultBlock] };
+    }
+    else if (msg.type === 'thinking') {
+        if (!content) {
+            return null;
+        }
+        if ('signature' in msg && msg.signature) {
+            return {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'thinking',
+                        thinking: content.trim(),
+                        signature: msg.signature,
+                    },
+                ],
+            };
+        }
+        return { role: 'assistant', content: 'Thinking: ' + content.trim() };
+    }
+    else {
+        if (!content) {
+            return null;
+        }
+        let messageRole = role === 'assistant'
+            ? 'assistant'
+            : (role === 'system' || role === 'developer') && !result?.length
+                ? 'system'
+                : 'user';
+        if (messageRole !== 'system') {
+            const extracted = extractBase64Image(content);
+            if (extracted.found && extracted.image_id !== null) {
+                messageRole = 'user';
+                try {
+                    const image_id = extracted.image_id;
+                    const originalImageData = extracted.images[image_id];
+                    const processedImageData = await resizeAndTruncateForClaude(originalImageData);
+                    const mediaType = getImageMediaType(processedImageData);
+                    const cleanedImageData = cleanBase64Data(processedImageData);
+                    const contentBlocks = [];
+                    contentBlocks.push({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: mediaType,
+                            data: cleanedImageData,
+                        },
+                    });
+                    if (extracted.replaceContent.trim()) {
+                        contentBlocks.push({
+                            type: 'text',
+                            text: extracted.replaceContent.trim(),
+                        });
+                    }
+                    return {
+                        role: messageRole,
+                        content: contentBlocks,
+                    };
+                }
+                catch (error) {
+                    console.error('Error processing image in message:', error);
+                }
+            }
+        }
+        return {
+            role: messageRole,
+            content: content.trim(),
+        };
+    }
+}
+export class ClaudeProvider {
+    client;
+    constructor(apiKey) {
+        this.client = new Anthropic({
+            apiKey: apiKey || process.env.ANTHROPIC_API_KEY,
+        });
+        if (!this.client) {
+            throw new Error('Failed to initialize Claude client. Make sure ANTHROPIC_API_KEY is set.');
+        }
+    }
+    async preprocessMessagesForImageSupport(messages, modelId) {
+        const processedMessages = [...messages];
+        for (let i = 0; i < processedMessages.length; i++) {
+            const msg = processedMessages[i];
+            if (!this.isMessageWithStringContent(msg)) {
+                continue;
+            }
+            if (typeof msg.content === 'string') {
+                const extracted = extractBase64Image(msg.content);
+                if (extracted.found && extracted.image_id !== null) {
+                    try {
+                        const image_id = extracted.image_id;
+                        const imageData = extracted.images[image_id];
+                        const processedImageData = await convertImageToTextIfNeeded(imageData, modelId);
+                        if (!processedImageData.startsWith('data:image/')) {
+                            const newContent = extracted.replaceContent.trim()
+                                ? extracted.replaceContent.trim() +
+                                    ' ' +
+                                    processedImageData
+                                : processedImageData;
+                            processedMessages[i] = {
+                                ...msg,
+                                content: newContent,
+                            };
+                            console.log(`Converted image to text description for model ${modelId}`);
+                        }
+                    }
+                    catch (error) {
+                        console.error('Error converting image to text:', error);
+                    }
+                }
+            }
+            else if (Array.isArray(msg.content)) {
+                let hasChanges = false;
+                const newContentItems = [...msg.content];
+                for (let j = 0; j < newContentItems.length; j++) {
+                    const item = newContentItems[j];
+                    if (item.type === 'input_text' &&
+                        typeof item.text === 'string') {
+                        const extracted = extractBase64Image(item.text);
+                        if (extracted.found && extracted.image_id !== null) {
+                            try {
+                                const image_id = extracted.image_id;
+                                const imageData = extracted.images[image_id];
+                                const processedImageData = await convertImageToTextIfNeeded(imageData, modelId);
+                                if (!processedImageData.startsWith('data:image/')) {
+                                    const newText = extracted.replaceContent.trim()
+                                        ? extracted.replaceContent.trim() +
+                                            ' ' +
+                                            processedImageData
+                                        : processedImageData;
+                                    newContentItems[j] = {
+                                        ...item,
+                                        text: newText,
+                                    };
+                                    hasChanges = true;
+                                    console.log(`Converted image to text description in array content for model ${modelId}`);
+                                }
+                            }
+                            catch (error) {
+                                console.error('Error converting image to text in array content:', error);
+                            }
+                        }
+                    }
+                }
+                if (hasChanges) {
+                    processedMessages[i] = {
+                        ...msg,
+                        content: newContentItems,
+                    };
+                }
+            }
+        }
+        return processedMessages;
+    }
+    async prepareClaudeMessages(messages, modelId) {
+        const result = [];
+        for (const originalMsg of messages) {
+            let msg = originalMsg;
+            if (this.isMessageWithStringContent(msg)) {
+                if (typeof msg.content === 'string') {
+                    const extracted = extractBase64Image(msg.content);
+                    if (extracted.found && extracted.image_id !== null) {
+                        try {
+                            const image_id = extracted.image_id;
+                            const imageData = extracted.images[image_id];
+                            const processedImageData = await convertImageToTextIfNeeded(imageData, modelId);
+                            if (processedImageData &&
+                                !processedImageData.startsWith('data:image/')) {
+                                const newContent = extracted.replaceContent.trim()
+                                    ? extracted.replaceContent.trim() +
+                                        ' ' +
+                                        processedImageData
+                                    : processedImageData;
+                                msg = {
+                                    ...msg,
+                                    content: newContent,
+                                };
+                            }
+                        }
+                        catch (error) {
+                            console.error('Error converting image to text:', error);
+                        }
+                    }
+                }
+                else if (Array.isArray(msg.content)) {
+                    let hasChanges = false;
+                    const newContentItems = [...msg.content];
+                    for (let j = 0; j < newContentItems.length; j++) {
+                        const item = newContentItems[j];
+                        if (item.type === 'input_text' &&
+                            typeof item.text === 'string') {
+                            const extracted = extractBase64Image(item.text);
+                            if (extracted.found &&
+                                extracted.image_id !== null) {
+                                try {
+                                    const image_id = extracted.image_id;
+                                    const imageData = extracted.images[image_id];
+                                    const processedImageData = await convertImageToTextIfNeeded(imageData, modelId);
+                                    if (processedImageData &&
+                                        !processedImageData.startsWith('data:image/')) {
+                                        const newText = extracted.replaceContent.trim()
+                                            ? extracted.replaceContent.trim() +
+                                                ' ' +
+                                                processedImageData
+                                            : processedImageData;
+                                        newContentItems[j] = {
+                                            ...item,
+                                            text: newText,
+                                        };
+                                        hasChanges = true;
+                                    }
+                                }
+                                catch (error) {
+                                    console.error('Error converting image to text in array content:', error);
+                                }
+                            }
+                        }
+                    }
+                    if (hasChanges) {
+                        msg = {
+                            ...msg,
+                            content: newContentItems,
+                        };
+                    }
+                }
+            }
+            const role = 'role' in msg && msg.role !== 'developer' ? msg.role : 'system';
+            let content = '';
+            if ('content' in msg) {
+                if (typeof msg.content === 'string') {
+                    content = msg.content;
+                }
+                else if (msg.content.text &&
+                    typeof msg.content.text === 'string') {
+                    content = msg.content.text;
+                }
+            }
+            const structuredMsg = await convertToClaudeMessage(role, content, msg, result);
+            if (structuredMsg) {
+                result.push(structuredMsg);
+            }
+        }
+        return result;
+    }
+    isMessageWithStringContent(msg) {
+        if (!('content' in msg))
+            return false;
+        if (!msg.content)
+            return false;
+        if (msg.type &&
+            ['function_call', 'function_call_output'].includes(msg.type))
+            return false;
+        if (typeof msg.content === 'string') {
+            return true;
+        }
+        else if (Array.isArray(msg.content)) {
+            return msg.content.some(item => item.type === 'input_text' && typeof item.text === 'string');
+        }
+        return false;
+    }
+    async *createResponseStream(model, messages, agent) {
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        let totalCacheCreationInputTokens = 0;
+        let totalCacheReadInputTokens = 0;
+        let streamCompletedSuccessfully = false;
+        let messageCompleteYielded = false;
+        let requestId;
+        try {
+            const tools = agent
+                ? await agent.getTools()
+                : [];
+            const settings = agent?.modelSettings;
+            const modelClass = agent?.modelClass;
+            let thinking = undefined;
+            let max_tokens = settings?.max_tokens || 64000;
+            switch (modelClass) {
+                case 'monologue':
+                case 'reasoning':
+                case 'code':
+                    if (model === 'claude-3-7-sonnet-latest') {
+                        thinking = {
+                            type: 'enabled',
+                            budget_tokens: 16000,
+                        };
+                        max_tokens = Math.min(max_tokens, 64000);
+                    }
+                    else {
+                        max_tokens = Math.min(max_tokens, 8192);
+                    }
+                    break;
+                case 'standard':
+                    max_tokens = Math.min(max_tokens, 8192);
+                    break;
+                default:
+                    max_tokens = Math.min(max_tokens, 4096);
+            }
+            if (settings?.json_schema) {
+                messages.push({
+                    type: 'message',
+                    role: 'system',
+                    content: `Your response MUST be a valid JSON object that conforms to this schema:\n${JSON.stringify(settings.json_schema, null, 2)}`,
+                });
+            }
+            const claudeMessages = await this.prepareClaudeMessages(messages, model);
+            const systemPrompt = claudeMessages.reduce((acc, msg) => {
+                if (msg.role === 'system' &&
+                    msg.content &&
+                    typeof msg.content === 'string') {
+                    return acc + msg.content + '\n';
+                }
+                return acc;
+            }, '');
+            const requestParams = {
+                model: model,
+                messages: claudeMessages.filter(m => m.role === 'user' || m.role === 'assistant'),
+                ...(systemPrompt ? { system: systemPrompt } : {}),
+                stream: true,
+                max_tokens,
+                ...(thinking ? { thinking } : {}),
+                ...(settings?.temperature !== undefined
+                    ? { temperature: settings.temperature }
+                    : {}),
+            };
+            if (tools && tools.length > 0) {
+                requestParams.tools = convertToClaudeTools(tools);
+            }
+            if (!requestParams.messages ||
+                requestParams.messages.length === 0) {
+                console.warn('Claude API Warning: No user or assistant messages provided after filtering. Adding default message.');
+                requestParams.messages = [
+                    {
+                        role: 'user',
+                        content: "Let's think this through step by step.",
+                    },
+                ];
+            }
+            requestId = log_llm_request(agent.agent_id, 'anthropic', model, requestParams, new Date());
+            let currentToolCall = null;
+            let accumulatedSignature = '';
+            let accumulatedThinking = '';
+            let accumulatedContent = '';
+            const messageId = uuidv4();
+            let deltaPosition = 0;
+            const deltaBuffers = new Map();
+            const citationTracker = createCitationTracker();
+            const stream = await this.client.messages.create(requestParams);
+            const events = [];
+            try {
+                for await (const event of stream) {
+                    events.push(event);
+                    if (isPaused()) {
+                        console.log(`[Claude] System paused during stream for model ${model}. Aborting processing.`);
+                        yield {
+                            type: 'message_delta',
+                            content: '\n⏸️ Stream paused by user.',
+                            message_id: messageId,
+                            order: 999,
+                        };
+                        streamCompletedSuccessfully = false;
+                        break;
+                    }
+                    if (event.type === 'message_start' &&
+                        event.message?.usage) {
+                        const usage = event.message.usage;
+                        totalInputTokens += usage.input_tokens || 0;
+                        totalOutputTokens += usage.output_tokens || 0;
+                        totalCacheCreationInputTokens +=
+                            usage.cache_creation_input_tokens || 0;
+                        totalCacheReadInputTokens +=
+                            usage.cache_read_input_tokens || 0;
+                    }
+                    else if (event.type === 'message_delta' && event.usage) {
+                        const usage = event.usage;
+                        totalInputTokens += usage.input_tokens || 0;
+                        totalOutputTokens += usage.output_tokens || 0;
+                        totalCacheCreationInputTokens +=
+                            usage.cache_creation_input_tokens || 0;
+                        totalCacheReadInputTokens +=
+                            usage.cache_read_input_tokens || 0;
+                    }
+                    if (event.type === 'content_block_delta') {
+                        if (event.delta.type === 'signature_delta' &&
+                            event.delta.signature) {
+                            accumulatedSignature += event.delta.signature;
+                        }
+                        else if (event.delta.type === 'thinking_delta' &&
+                            event.delta.thinking) {
+                            yield {
+                                type: 'message_delta',
+                                content: '',
+                                thinking_content: event.delta.thinking,
+                                message_id: messageId,
+                                order: deltaPosition++,
+                            };
+                            accumulatedThinking += event.delta.thinking;
+                        }
+                        else if (event.delta.type === 'text_delta' &&
+                            event.delta.text) {
+                            for (const ev of bufferDelta(deltaBuffers, messageId, event.delta.text, content => ({
+                                type: 'message_delta',
+                                content,
+                                message_id: messageId,
+                                order: deltaPosition++,
+                            }))) {
+                                yield ev;
+                            }
+                            accumulatedContent += event.delta.text;
+                        }
+                        else if (event.delta.type === 'input_json_delta' &&
+                            currentToolCall &&
+                            event.delta.partial_json) {
+                            try {
+                                if (!currentToolCall.function._partialArguments) {
+                                    currentToolCall.function._partialArguments =
+                                        '';
+                                }
+                                currentToolCall.function._partialArguments +=
+                                    event.delta.partial_json;
+                                currentToolCall.function.arguments =
+                                    currentToolCall.function._partialArguments;
+                                yield {
+                                    type: 'tool_delta',
+                                    tool_calls: [currentToolCall],
+                                };
+                            }
+                            catch (err) {
+                                console.error('Error processing tool_use delta (input_json_delta):', err, event);
+                            }
+                        }
+                        else if (event.delta.type === 'citations_delta' &&
+                            event.delta.citation) {
+                            const citationMarker = formatCitation(citationTracker, event.delta.citation);
+                            yield {
+                                type: 'message_delta',
+                                content: citationMarker,
+                                message_id: messageId,
+                                order: deltaPosition++,
+                            };
+                            accumulatedContent += citationMarker;
+                        }
+                    }
+                    else if (event.type === 'content_block_start' &&
+                        event.content_block?.type === 'text') {
+                        if (event.content_block.text) {
+                            for (const ev of bufferDelta(deltaBuffers, messageId, event.content_block.text, content => ({
+                                type: 'message_delta',
+                                content,
+                                message_id: messageId,
+                                order: deltaPosition++,
+                            }))) {
+                                yield ev;
+                            }
+                            accumulatedContent += event.content_block.text;
+                        }
+                    }
+                    else if (event.type === 'content_block_stop' &&
+                        event.content_block?.type === 'text') {
+                    }
+                    else if (event.type === 'content_block_start' &&
+                        event.content_block?.type === 'web_search_tool_result') {
+                        if (event.content_block.content) {
+                            const formatted = formatWebSearchResults(event.content_block.content);
+                            if (formatted) {
+                                yield {
+                                    type: 'message_delta',
+                                    content: '\n\nSearch Results:\n' +
+                                        formatted +
+                                        '\n',
+                                    message_id: messageId,
+                                    order: deltaPosition++,
+                                };
+                                accumulatedContent +=
+                                    '\n\nSearch Results:\n' + formatted + '\n';
+                            }
+                        }
+                    }
+                    else if (event.type === 'content_block_start' &&
+                        event.content_block?.type === 'tool_use') {
+                        const toolUse = event.content_block;
+                        const toolId = toolUse.id || `call_${Date.now()}`;
+                        const toolName = toolUse.name;
+                        const toolInput = toolUse.input !== undefined ? toolUse.input : {};
+                        currentToolCall = {
+                            id: toolId,
+                            type: 'function',
+                            function: {
+                                name: toolName,
+                                arguments: typeof toolInput === 'string'
+                                    ? toolInput
+                                    : JSON.stringify(toolInput),
+                            },
+                        };
+                    }
+                    else if (event.type === 'content_block_stop' &&
+                        event.content_block?.type === 'tool_use' &&
+                        currentToolCall) {
+                        try {
+                            if (currentToolCall.function._partialArguments) {
+                                currentToolCall.function.arguments =
+                                    currentToolCall.function._partialArguments;
+                                delete currentToolCall.function
+                                    ._partialArguments;
+                            }
+                            yield {
+                                type: 'tool_start',
+                                tool_calls: [currentToolCall],
+                            };
+                        }
+                        catch (err) {
+                            console.error('Error finalizing tool call:', err, event);
+                        }
+                        finally {
+                            currentToolCall = null;
+                        }
+                    }
+                    else if (event.type === 'message_stop') {
+                        if (event['amazon-bedrock-invocationMetrics']) {
+                            const metrics = event['amazon-bedrock-invocationMetrics'];
+                            totalInputTokens += metrics.inputTokenCount || 0;
+                            totalOutputTokens += metrics.outputTokenCount || 0;
+                        }
+                        else if (event.usage) {
+                            const usage = event.usage;
+                            totalInputTokens += usage.input_tokens || 0;
+                            totalOutputTokens += usage.output_tokens || 0;
+                            totalCacheCreationInputTokens +=
+                                usage.cache_creation_input_tokens || 0;
+                            totalCacheReadInputTokens +=
+                                usage.cache_read_input_tokens || 0;
+                        }
+                        if (currentToolCall) {
+                            console.warn('Tool call was still active at message_stop:', currentToolCall);
+                            yield {
+                                type: 'tool_start',
+                                tool_calls: [currentToolCall],
+                            };
+                            currentToolCall = null;
+                        }
+                        for (const ev of flushBufferedDeltas(deltaBuffers, (_id, content) => ({
+                            type: 'message_delta',
+                            content,
+                            message_id: messageId,
+                            order: deltaPosition++,
+                        }))) {
+                            yield ev;
+                        }
+                        if (accumulatedContent || accumulatedThinking) {
+                            if (citationTracker.citations.size > 0) {
+                                const footnotes = generateFootnotes(citationTracker);
+                                accumulatedContent += footnotes;
+                            }
+                            yield {
+                                type: 'message_complete',
+                                message_id: messageId,
+                                content: accumulatedContent,
+                                thinking_content: accumulatedThinking,
+                                thinking_signature: accumulatedSignature,
+                            };
+                            messageCompleteYielded = true;
+                        }
+                        streamCompletedSuccessfully = true;
+                    }
+                    else if (event.type === 'error') {
+                        log_llm_error(requestId, event);
+                        console.error('Claude API error event:', event.error);
+                        yield {
+                            type: 'error',
+                            error: 'Claude API error: ' +
+                                (event.error
+                                    ? event.error.message ||
+                                        JSON.stringify(event.error)
+                                    : 'Unknown error'),
+                        };
+                        streamCompletedSuccessfully = false;
+                        break;
+                    }
+                }
+                if (streamCompletedSuccessfully &&
+                    (accumulatedContent || accumulatedThinking) &&
+                    !messageCompleteYielded) {
+                    console.warn('Stream finished successfully but message_stop might not have triggered message_complete emission. Emitting now.');
+                    for (const ev of flushBufferedDeltas(deltaBuffers, (_id, content) => ({
+                        type: 'message_delta',
+                        content,
+                        message_id: messageId,
+                        order: deltaPosition++,
+                    }))) {
+                        yield ev;
+                    }
+                    if (citationTracker.citations.size > 0) {
+                        const footnotes = generateFootnotes(citationTracker);
+                        accumulatedContent += footnotes;
+                    }
+                    yield {
+                        type: 'message_complete',
+                        message_id: messageId,
+                        content: accumulatedContent,
+                        thinking_content: accumulatedThinking,
+                        thinking_signature: accumulatedSignature,
+                    };
+                    messageCompleteYielded = true;
+                }
+            }
+            catch (streamError) {
+                log_llm_error(requestId, streamError);
+                console.error('Error processing Claude stream:', streamError);
+                yield {
+                    type: 'error',
+                    error: `Claude stream error (${model}): ${streamError}`,
+                };
+            }
+            finally {
+                log_llm_response(requestId, events);
+            }
+        }
+        catch (error) {
+            log_llm_error(requestId, error);
+            console.error('Error in Claude streaming completion setup:', error);
+            yield {
+                type: 'error',
+                error: `Claude request error (${model}): ${error}`,
+            };
+        }
+        finally {
+            if (totalInputTokens > 0 || totalOutputTokens > 0) {
+                const cachedTokens = totalCacheCreationInputTokens + totalCacheReadInputTokens;
+                costTracker.addUsage({
+                    model,
+                    input_tokens: totalInputTokens,
+                    output_tokens: totalOutputTokens,
+                    cached_tokens: cachedTokens,
+                    metadata: {
+                        cache_creation_input_tokens: totalCacheCreationInputTokens,
+                        cache_read_input_tokens: totalCacheReadInputTokens,
+                        total_tokens: totalInputTokens + totalOutputTokens,
+                    },
+                });
+            }
+        }
+    }
+}
+export const claudeProvider = new ClaudeProvider();
+//# sourceMappingURL=claude.js.map