@vybestack/llxprt-code-core 0.1.23-nightly.250903.97906524 → 0.1.23-nightly.250905.67589d14

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

@@ -1,10 +1,8 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { DebugLogger } from '../../debug/index.js';
-import { retryWithBackoff } from '../../utils/retry.js';
 import { ToolFormatter } from '../../tools/ToolFormatter.js';
 import { BaseProvider } from '../BaseProvider.js';
 import { getSettingsService } from '../../settings/settingsServiceInstance.js';
-import { ContentGeneratorRole } from '../ContentGeneratorRole.js';
 export class AnthropicProvider extends BaseProvider {
     logger;
     anthropic;
@@ -15,16 +13,6 @@ export class AnthropicProvider extends BaseProvider {
     currentModel = 'claude-sonnet-4-20250514'; // Default model
     modelParams;
     _cachedAuthKey; // Track cached auth key for client recreation
-    // Model cache for latest resolution
-    modelCache = null;
-    modelCacheTTL = 5 * 60 * 1000; // 5 minutes
-    // Retry configuration
-    retryableErrorMessages = [
-        'overloaded',
-        'rate_limit',
-        'server_error',
-        'service_unavailable',
-    ];
     // Model patterns for max output tokens
     modelTokenPatterns = [
         { pattern: /claude-.*opus-4/i, tokens: 32000 },
@@ -177,311 +165,6 @@ export class AnthropicProvider extends BaseProvider {
             return []; // Return empty array on error
         }
     }
-    async *generateChatCompletion(messages, tools, _toolFormat) {
-        const authToken = await this.getAuthToken();
-        if (!authToken) {
-            throw new Error('Authentication required to generate Anthropic chat completions');
-        }
-        // Get streaming setting from ephemeral settings (default: enabled)
-        const streamingSetting = this._config?.getEphemeralSettings?.()?.['streaming'];
-        const streamingEnabled = streamingSetting !== 'disabled';
-        // Update Anthropic client with resolved authentication if needed
-        await this.updateClientWithResolvedAuth();
-        const apiCall = async () => {
-            // Resolve model if it uses -latest alias
-            const resolvedModel = await this.resolveLatestModel(this.currentModel);
-            // Always validate and fix message history to prevent tool_use/tool_result mismatches
-            // This is necessary for both cancelled tools and retries
-            const validatedMessages = this.validateAndFixMessages(messages);
-            // Use the resolved model for the API call
-            const modelForApi = resolvedModel;
-            // Check if we're in OAuth mode early
-            const authToken = await this.getAuthToken();
-            const isOAuth = authToken && authToken.startsWith('sk-ant-oat');
-            // Extract system message if present and handle tool responses
-            let systemMessage;
-            let llxprtPrompts; // Store llxprt prompts separately
-            const anthropicMessages = [];
-            for (const msg of validatedMessages) {
-                if (msg.role === 'system') {
-                    if (isOAuth) {
-                        // In OAuth mode, save system content for injection as user message
-                        llxprtPrompts = msg.content;
-                    }
-                    else {
-                        // In normal mode, use as system message
-                        systemMessage = msg.content;
-                    }
-                }
-                else if (msg.role === 'tool') {
-                    // Anthropic expects tool responses as user messages with tool_result content
-                    anthropicMessages.push({
-                        role: 'user',
-                        content: [
-                            {
-                                type: 'tool_result',
-                                tool_use_id: msg.tool_call_id || 'unknown',
-                                content: msg.content,
-                            },
-                        ],
-                    });
-                }
-                else if (msg.role === 'assistant' && msg.tool_calls) {
-                    // Handle assistant messages with tool calls
-                    const content = [];
-                    if (msg.content) {
-                        content.push({ type: 'text', text: msg.content });
-                    }
-                    for (const toolCall of msg.tool_calls) {
-                        content.push({
-                            type: 'tool_use',
-                            id: toolCall.id,
-                            name: toolCall.function.name,
-                            input: toolCall.function.arguments
-                                ? JSON.parse(toolCall.function.arguments)
-                                : {},
-                        });
-                    }
-                    anthropicMessages.push({
-                        role: 'assistant',
-                        content,
-                    });
-                }
-                else {
-                    // Regular user/assistant messages
-                    anthropicMessages.push({
-                        role: msg.role,
-                        content: msg.content,
-                    });
-                }
-            }
-            // In OAuth mode, inject llxprt prompts as conversation content
-            // ONLY for the very first message in a new conversation
-            if (isOAuth && llxprtPrompts && anthropicMessages.length === 0) {
-                // This is the very first message - inject the context
-                const contextMessage = `Important context for using llxprt tools:
-
-Tool Parameter Reference:
-- read_file uses parameter 'absolute_path' (not 'file_path')
-- write_file uses parameter 'file_path' (not 'path')
-- list_directory uses parameter 'path'
-- replace uses 'file_path', 'old_string', 'new_string'
-- search_file_content (grep) expects regex patterns, not literal text
-- todo_write requires 'todos' array with {id, content, status, priority}
-- All file paths must be absolute (starting with /)
-
-${llxprtPrompts}`;
-                // Inject at the beginning of the conversation
-                anthropicMessages.unshift({
-                    role: 'user',
-                    content: contextMessage,
-                }, {
-                    role: 'assistant',
-                    content: "I understand the llxprt tool parameters and context. I'll use the correct parameter names for each tool. Ready to help with your tasks.",
-                });
-            }
-            // For ongoing conversations, the context was already injected in the first message
-            // so we don't need to inject it again
-            // Convert ITool[] to Anthropic's tool format if tools are provided
-            const anthropicTools = tools
-                ? this.toolFormatter.toProviderFormat(tools, 'anthropic')
-                : undefined;
-            // Create the request options with proper typing
-            const createOptions = {
-                model: modelForApi,
-                messages: anthropicMessages,
-                max_tokens: this.getMaxTokensForModel(resolvedModel),
-                ...this.modelParams, // Apply model params first
-                stream: streamingEnabled, // Use ephemeral streaming setting
-            };
-            // Set system message based on auth mode
-            if (isOAuth) {
-                // OAuth mode: Use Claude Code system prompt (required for Max/Pro)
-                createOptions.system =
-                    "You are Claude Code, Anthropic's official CLI for Claude.";
-                // llxprt prompts were already injected as conversation content above
-            }
-            else if (systemMessage) {
-                // Normal mode: Use full llxprt system prompt
-                createOptions.system = systemMessage;
-            }
-            if (anthropicTools) {
-                createOptions.tools = anthropicTools;
-            }
-            if (streamingEnabled) {
-                return this.anthropic.messages.create(createOptions);
-            }
-            else {
-                return this.anthropic.messages.create(createOptions);
-            }
-        };
-        try {
-            const response = await retryWithBackoff(apiCall, {
-                shouldRetry: (error) => this.isRetryableError(error),
-            });
-            if (streamingEnabled) {
-                // Handle streaming response
-                const stream = response;
-                let currentUsage;
-                // Track current tool call being streamed
-                let currentToolCall;
-                // Process the stream
-                for await (const chunk of stream) {
-                    this.logger.debug(() => `Received chunk type: ${chunk.type}${chunk.type === 'message_start'
-                        ? ` - ${JSON.stringify(chunk, null, 2)}`
-                        : ''}`);
-                    if (chunk.type === 'message_start') {
-                        // Initial usage info
-                        this.logger.debug(() => `message_start chunk: ${JSON.stringify(chunk, null, 2)}`);
-                        if (chunk.message?.usage) {
-                            const usage = chunk.message.usage;
-                            // Don't require both fields - Anthropic might send them separately
-                            currentUsage = {
-                                input_tokens: usage.input_tokens ?? 0,
-                                output_tokens: usage.output_tokens ?? 0,
-                            };
-                            this.logger.debug(() => `Set currentUsage from message_start: ${JSON.stringify(currentUsage)}`);
-                            yield {
-                                role: 'assistant',
-                                content: '',
-                                usage: {
-                                    prompt_tokens: currentUsage.input_tokens,
-                                    completion_tokens: currentUsage.output_tokens,
-                                    total_tokens: currentUsage.input_tokens + currentUsage.output_tokens,
-                                },
-                            };
-                        }
-                    }
-                    else if (chunk.type === 'content_block_start') {
-                        // Handle tool use blocks
-                        if (chunk.content_block.type === 'tool_use') {
-                            currentToolCall = {
-                                id: chunk.content_block.id,
-                                name: chunk.content_block.name,
-                                input: '',
-                            };
-                        }
-                    }
-                    else if (chunk.type === 'content_block_delta') {
-                        // Yield content chunks
-                        if (chunk.delta.type === 'text_delta') {
-                            yield {
-                                role: 'assistant',
-                                content: chunk.delta.text,
-                            };
-                        }
-                        else if (chunk.delta.type === 'input_json_delta' &&
-                            currentToolCall) {
-                            // Handle input deltas for tool calls
-                            currentToolCall.input += chunk.delta.partial_json;
-                        }
-                    }
-                    else if (chunk.type === 'content_block_stop') {
-                        // Complete the tool call
-                        if (currentToolCall) {
-                            const toolCallResult = this.toolFormatter.fromProviderFormat({
-                                id: currentToolCall.id,
-                                type: 'tool_use',
-                                name: currentToolCall.name,
-                                input: currentToolCall.input
-                                    ? JSON.parse(currentToolCall.input)
-                                    : undefined,
-                            }, 'anthropic');
-                            yield {
-                                role: 'assistant',
-                                content: '',
-                                tool_calls: toolCallResult,
-                            };
-                            currentToolCall = undefined;
-                        }
-                    }
-                    else if (chunk.type === 'message_delta') {
-                        // Update usage if provided
-                        if (chunk.usage) {
-                            this.logger.debug(() => `message_delta usage: ${JSON.stringify(chunk.usage, null, 2)}`);
-                        }
-                        if (chunk.usage) {
-                            // Anthropic may send partial usage data - merge with existing
-                            currentUsage = {
-                                input_tokens: chunk.usage.input_tokens ?? currentUsage?.input_tokens ?? 0,
-                                output_tokens: chunk.usage.output_tokens ?? currentUsage?.output_tokens ?? 0,
-                            };
-                            this.logger.debug(() => `Updated currentUsage from message_delta: ${JSON.stringify(currentUsage)}`);
-                            yield {
-                                role: 'assistant',
-                                content: '',
-                                usage: {
-                                    prompt_tokens: currentUsage.input_tokens,
-                                    completion_tokens: currentUsage.output_tokens,
-                                    total_tokens: currentUsage.input_tokens + currentUsage.output_tokens,
-                                },
-                            };
-                        }
-                    }
-                    else if (chunk.type === 'message_stop') {
-                        // Final usage info
-                        if (currentUsage) {
-                            this.logger.debug(() => `Yielding final usage: ${JSON.stringify(currentUsage)}`);
-                            yield {
-                                role: 'assistant',
-                                content: '',
-                                usage: {
-                                    prompt_tokens: currentUsage.input_tokens,
-                                    completion_tokens: currentUsage.output_tokens,
-                                    total_tokens: currentUsage.input_tokens + currentUsage.output_tokens,
-                                },
-                            };
-                        }
-                        else {
-                            this.logger.debug(() => 'No currentUsage data at message_stop');
-                        }
-                    }
-                }
-            }
-            else {
-                // Handle non-streaming response
-                const message = response;
-                let fullContent = '';
-                const toolCalls = [];
-                // Process content blocks
-                for (const content of message.content) {
-                    if (content.type === 'text') {
-                        fullContent += content.text;
-                    }
-                    else if (content.type === 'tool_use') {
-                        toolCalls.push({
-                            id: content.id,
-                            type: 'function',
-                            function: {
-                                name: content.name,
-                                arguments: JSON.stringify(content.input),
-                            },
-                        });
-                    }
-                }
-                // Build response message
-                const responseMessage = {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: fullContent,
-                };
-                if (toolCalls.length > 0) {
-                    responseMessage.tool_calls = toolCalls;
-                }
-                if (message.usage) {
-                    responseMessage.usage = {
-                        prompt_tokens: message.usage.input_tokens,
-                        completion_tokens: message.usage.output_tokens,
-                        total_tokens: message.usage.input_tokens + message.usage.output_tokens,
-                    };
-                }
-                yield responseMessage;
-            }
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            throw new Error(`Anthropic API error: ${errorMessage}`);
-        }
-    }
     setApiKey(apiKey) {
         // Call base provider implementation
         super.setApiKey(apiKey);
@@ -555,54 +238,6 @@ ${llxprtPrompts}`;
                 return 'claude-sonnet-4-latest';
         }
     }
-    /**
-     * Resolves a model ID that may contain "-latest" to the actual model ID.
-     * Caches the result to avoid frequent API calls.
-     */
-    async resolveLatestModel(modelId) {
-        // If it's not a latest alias, return as-is
-        if (!modelId.endsWith('-latest')) {
-            return modelId;
-        }
-        // Check cache
-        const now = Date.now();
-        if (this.modelCache &&
-            now - this.modelCache.timestamp < this.modelCacheTTL) {
-            // Find the corresponding model from cache
-            const model = this.modelCache.models.find((m) => m.id === modelId);
-            if (model) {
-                // The latest aliases are synthetic, find the real model
-                const tier = modelId.includes('opus') ? 'opus' : 'sonnet';
-                const realModel = this.modelCache.models
-                    .filter((m) => m.id.startsWith(`claude-${tier}-4-`) && !m.id.endsWith('-latest'))
-                    .sort((a, b) => b.id.localeCompare(a.id))[0];
-                return realModel ? realModel.id : modelId;
-            }
-        }
-        try {
-            // Ensure client has proper auth before calling getModels
-            await this.updateClientWithResolvedAuth();
-            // Fetch fresh models
-            const models = await this.getModels();
-            this.modelCache = { models, timestamp: now };
-            // Find the real model for this latest alias
-            const tier = modelId.includes('opus') ? 'opus' : 'sonnet';
-            const realModel = models
-                .filter((m) => m.id.startsWith(`claude-${tier}-4-`) && !m.id.endsWith('-latest'))
-                .sort((a, b) => b.id.localeCompare(a.id))[0];
-            return realModel ? realModel.id : modelId;
-        }
-        catch (_error) {
-            // If we can't fetch models, just use simple fallback like Claude Code does
-            this.logger.debug(() => 'Failed to fetch models for latest resolution, using fallback');
-            if (modelId.includes('opus')) {
-                return 'opus';
-            }
-            else {
-                return 'sonnet'; // Default to sonnet like Claude Code
-            }
-        }
-    }
     getMaxTokensForModel(modelId) {
         // Handle latest aliases explicitly
         if (modelId === 'claude-opus-4-latest' ||
@@ -637,88 +272,6 @@ ${llxprtPrompts}`;
         // Default for Claude 3.x models
         return 200000;
     }
-    isRetryableError(error) {
-        if (!(error instanceof Error))
-            return false;
-        const errorMessage = error.message.toLowerCase();
-        if (error.message.includes('rate_limit_error'))
-            return true;
-        // Check for Anthropic-specific error patterns
-        if (error.message.includes('Anthropic API error:')) {
-            // Extract the actual error content
-            const match = error.message.match(/{"type":"error","error":({.*})}/);
-            if (match) {
-                try {
-                    const errorData = JSON.parse(match[1]);
-                    const errorType = errorData.type?.toLowerCase() || '';
-                    const errorMsg = errorData.message?.toLowerCase() || '';
-                    return this.retryableErrorMessages.some((retryable) => errorType.includes(retryable) || errorMsg.includes(retryable));
-                }
-                catch {
-                    // If parsing fails, fall back to string matching
-                }
-            }
-        }
-        // Direct error message checking
-        return this.retryableErrorMessages.some((msg) => errorMessage.includes(msg));
-    }
-    /**
-     * Validates and potentially fixes the message history to ensure proper tool_use/tool_result pairing.
-     * This prevents the "tool_use ids were found without tool_result blocks" error after a failed request.
-     */
-    validateAndFixMessages(messages) {
-        const fixedMessages = [];
-        let pendingToolCalls = [];
-        for (let i = 0; i < messages.length; i++) {
-            const msg = messages[i];
-            if (msg.role === 'assistant' && msg.tool_calls) {
-                // Track tool calls from assistant
-                fixedMessages.push(msg);
-                pendingToolCalls = msg.tool_calls.map((tc) => ({
-                    id: tc.id,
-                    name: tc.function.name,
-                }));
-            }
-            else if (msg.role === 'tool' && pendingToolCalls.length > 0) {
-                // Match tool results with pending tool calls
-                fixedMessages.push(msg);
-                // Remove the matched tool call
-                pendingToolCalls = pendingToolCalls.filter((tc) => tc.id !== msg.tool_call_id);
-            }
-            else if (msg.role === 'assistant' ||
-                msg.role === 'user' ||
-                msg.role === 'system') {
-                // If we have pending tool calls and encounter a non-tool message,
-                // we need to add dummy tool results to maintain consistency
-                if (pendingToolCalls.length > 0 && msg.role !== 'system') {
-                    // Add dummy tool results for unmatched tool calls
-                    for (const toolCall of pendingToolCalls) {
-                        fixedMessages.push({
-                            role: 'tool',
-                            tool_call_id: toolCall.id,
-                            content: 'Error: Tool execution was interrupted. Please retry.',
-                        });
-                    }
-                    pendingToolCalls = [];
-                }
-                fixedMessages.push(msg);
-            }
-            else {
-                fixedMessages.push(msg);
-            }
-        }
-        // Handle any remaining pending tool calls at the end
-        if (pendingToolCalls.length > 0) {
-            for (const toolCall of pendingToolCalls) {
-                fixedMessages.push({
-                    role: 'tool',
-                    tool_call_id: toolCall.id,
-                    content: 'Error: Tool execution was interrupted. Please retry.',
-                });
-            }
-        }
-        return fixedMessages;
-    }
     /**
      * Anthropic always requires payment (API key or OAuth)
      */
@@ -770,5 +323,243 @@ ${llxprtPrompts}`;
     async isAuthenticated() {
         return super.isAuthenticated();
     }
+    /**
+     * Generate chat completion with IContent interface
+     * Convert IContent directly to Anthropic API format
+     */
+    async *generateChatCompletion(content, tools) {
+        // Convert IContent directly to Anthropic API format (no IMessage!)
+        const anthropicMessages = [];
+        // Extract system message if present
+        let systemMessage;
+        for (const c of content) {
+            if (c.speaker === 'human') {
+                const textBlock = c.blocks.find((b) => b.type === 'text');
+                // Check for system message (this is a hack for now - should be explicit)
+                if (anthropicMessages.length === 0 &&
+                    textBlock?.text?.includes('You are')) {
+                    systemMessage = textBlock.text;
+                    continue;
+                }
+                anthropicMessages.push({
+                    role: 'user',
+                    content: textBlock?.text || '',
+                });
+            }
+            else if (c.speaker === 'ai') {
+                const textBlocks = c.blocks.filter((b) => b.type === 'text');
+                const toolCallBlocks = c.blocks.filter((b) => b.type === 'tool_call');
+                if (toolCallBlocks.length > 0) {
+                    // Build content array with text and tool_use blocks
+                    const contentArray = [];
+                    // Add text if present
+                    const contentText = textBlocks.map((b) => b.text).join('');
+                    if (contentText) {
+                        contentArray.push({ type: 'text', text: contentText });
+                    }
+                    // Add tool uses
+                    for (const tc of toolCallBlocks) {
+                        contentArray.push({
+                            type: 'tool_use',
+                            id: tc.id.replace(/^hist_tool_/, 'toolu_'),
+                            name: tc.name,
+                            input: tc.parameters,
+                        });
+                    }
+                    anthropicMessages.push({
+                        role: 'assistant',
+                        content: contentArray,
+                    });
+                }
+                else {
+                    // Text-only message
+                    const contentText = textBlocks.map((b) => b.text).join('');
+                    anthropicMessages.push({
+                        role: 'assistant',
+                        content: contentText,
+                    });
+                }
+            }
+            else if (c.speaker === 'tool') {
+                const toolResponseBlock = c.blocks.find((b) => b.type === 'tool_response');
+                if (!toolResponseBlock) {
+                    throw new Error('Tool content must have a tool_response block');
+                }
+                // Anthropic expects tool results as user messages
+                anthropicMessages.push({
+                    role: 'user',
+                    content: [
+                        {
+                            type: 'tool_result',
+                            tool_use_id: toolResponseBlock.callId.replace(/^hist_tool_/, 'toolu_'),
+                            content: JSON.stringify(toolResponseBlock.result),
+                        },
+                    ],
+                });
+            }
+            else {
+                throw new Error(`Unknown speaker type: ${c.speaker}`);
+            }
+        }
+        // Convert Gemini format tools to ITool format then use toolFormatter
+        const anthropicTools = tools
+            ? (() => {
+                // First convert to ITool format
+                const iTools = tools[0].functionDeclarations.map((decl) => ({
+                    type: 'function',
+                    function: {
+                        name: decl.name,
+                        description: decl.description || '',
+                        parameters: decl.parameters || {},
+                    },
+                }));
+                // Then use the toolFormatter to properly convert to Anthropic format
+                // This handles schema validation, type conversion, and filtering
+                const converted = this.toolFormatter.toProviderFormat(iTools, 'anthropic');
+                return converted;
+            })()
+            : undefined;
+        // Ensure authentication
+        await this.updateClientWithResolvedAuth();
+        // Check OAuth mode
+        const authToken = await this.getAuthToken();
+        const isOAuth = authToken && authToken.startsWith('sk-ant-oat');
+        // Get streaming setting from ephemeral settings (default: enabled)
+        const streamingSetting = this._config?.getEphemeralSettings?.()?.['streaming'];
+        const streamingEnabled = streamingSetting !== 'disabled';
+        // Build request with proper typing
+        const requestBody = {
+            model: this.currentModel,
+            messages: anthropicMessages,
+            max_tokens: this.getMaxTokensForModel(this.currentModel),
+            stream: streamingEnabled,
+            ...(this.modelParams || {}),
+            ...(isOAuth
+                ? {
+                    system: "You are Claude Code, Anthropic's official CLI for Claude.",
+                }
+                : systemMessage
+                    ? { system: systemMessage }
+                    : {}),
+            ...(anthropicTools && anthropicTools.length > 0
+                ? { tools: anthropicTools }
+                : {}),
+        };
+        // Make the API call directly with type assertion
+        const response = await this.anthropic.messages.create(requestBody);
+        if (streamingEnabled) {
+            // Handle streaming response - response is already a Stream when streaming is enabled
+            const stream = response;
+            let currentToolCall;
+            for await (const chunk of stream) {
+                if (chunk.type === 'content_block_start') {
+                    if (chunk.content_block.type === 'tool_use') {
+                        currentToolCall = {
+                            id: chunk.content_block.id,
+                            name: chunk.content_block.name,
+                            input: '',
+                        };
+                    }
+                }
+                else if (chunk.type === 'content_block_delta') {
+                    if (chunk.delta.type === 'text_delta') {
+                        // Emit text immediately as IContent
+                        yield {
+                            speaker: 'ai',
+                            blocks: [{ type: 'text', text: chunk.delta.text }],
+                        };
+                    }
+                    else if (chunk.delta.type === 'input_json_delta' &&
+                        currentToolCall) {
+                        currentToolCall.input += chunk.delta.partial_json;
+                    }
+                }
+                else if (chunk.type === 'content_block_stop') {
+                    if (currentToolCall) {
+                        // Emit tool call as IContent
+                        try {
+                            const input = JSON.parse(currentToolCall.input);
+                            yield {
+                                speaker: 'ai',
+                                blocks: [
+                                    {
+                                        type: 'tool_call',
+                                        id: currentToolCall.id.replace(/^toolu_/, 'hist_tool_'),
+                                        name: currentToolCall.name,
+                                        parameters: input,
+                                    },
+                                ],
+                            };
+                        }
+                        catch (_e) {
+                            // If parsing fails, emit with string parameters
+                            yield {
+                                speaker: 'ai',
+                                blocks: [
+                                    {
+                                        type: 'tool_call',
+                                        id: currentToolCall.id.replace(/^toolu_/, 'hist_tool_'),
+                                        name: currentToolCall.name,
+                                        parameters: currentToolCall.input,
+                                    },
+                                ],
+                            };
+                        }
+                        currentToolCall = undefined;
+                    }
+                }
+                else if (chunk.type === 'message_delta' && chunk.usage) {
+                    // Emit usage metadata
+                    yield {
+                        speaker: 'ai',
+                        blocks: [],
+                        metadata: {
+                            usage: {
+                                promptTokens: chunk.usage.input_tokens || 0,
+                                completionTokens: chunk.usage.output_tokens || 0,
+                                totalTokens: (chunk.usage.input_tokens || 0) +
+                                    (chunk.usage.output_tokens || 0),
+                            },
+                        },
+                    };
+                }
+            }
+        }
+        else {
+            // Handle non-streaming response
+            const message = response;
+            const blocks = [];
+            // Process content blocks
+            for (const contentBlock of message.content) {
+                if (contentBlock.type === 'text') {
+                    blocks.push({ type: 'text', text: contentBlock.text });
+                }
+                else if (contentBlock.type === 'tool_use') {
+                    blocks.push({
+                        type: 'tool_call',
+                        id: contentBlock.id.replace(/^toolu_/, 'hist_tool_'),
+                        name: contentBlock.name,
+                        parameters: contentBlock.input,
+                    });
+                }
+            }
+            // Build response IContent
+            const result = {
+                speaker: 'ai',
+                blocks,
+            };
+            // Add usage metadata if present
+            if (message.usage) {
+                result.metadata = {
+                    usage: {
+                        promptTokens: message.usage.input_tokens,
+                        completionTokens: message.usage.output_tokens,
+                        totalTokens: message.usage.input_tokens + message.usage.output_tokens,
+                    },
+                };
+            }
+            yield result;
+        }
+    }
 }
 //# sourceMappingURL=AnthropicProvider.js.map