@vybestack/llxprt-code-core 0.1.23 → 0.2.2-nightly.250908.7b895396

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

@@ -1,29 +1,16 @@
 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';
+import { processToolParameters, logDoubleEscapingInChunk, } from '../../tools/doubleEscapeUtils.js';
+import { getCoreSystemPromptAsync } from '../../core/prompts.js';
 export class AnthropicProvider extends BaseProvider {
     logger;
     anthropic;
     toolFormatter;
     toolFormat = 'anthropic';
-    baseURL;
-    _config;
-    currentModel = 'claude-sonnet-4-20250514'; // Default model
-    modelParams;
-    // Model cache for latest resolution
-    modelCache = null;
-    modelCacheTTL = 5 * 60 * 1000; // 5 minutes
-    // Retry configuration
-    retryableErrorMessages = [
-        'overloaded',
-        'rate_limit',
-        'server_error',
-        'service_unavailable',
-    ];
+    _cachedAuthKey; // Track cached auth key for client recreation
     // Model patterns for max output tokens
     modelTokenPatterns = [
         { pattern: /claude-.*opus-4/i, tokens: 32000 },
@@ -41,21 +28,16 @@ export class AnthropicProvider extends BaseProvider {
             name: 'anthropic',
             apiKey,
             baseURL,
-            cliKey: !apiKey || apiKey === '' ? undefined : apiKey,
             envKeyNames: ['ANTHROPIC_API_KEY'],
             isOAuthEnabled: !!oauthManager,
             oauthProvider: oauthManager ? 'anthropic' : undefined,
             oauthManager,
         };
-        super(baseConfig);
+        super(baseConfig, config);
         this.logger = new DebugLogger('llxprt:anthropic:provider');
-        this.baseURL = baseURL;
-        this._config = config;
-        // Config reserved for future provider customization
-        void this._config;
         this.anthropic = new Anthropic({
             apiKey: apiKey || '', // Empty string if OAuth will be used
-            baseURL,
+            baseURL: config?.baseUrl || baseURL,
             dangerouslyAllowBrowser: true,
         });
         this.toolFormatter = new ToolFormatter();
@@ -69,37 +51,44 @@ export class AnthropicProvider extends BaseProvider {
         return true;
     }
     /**
+     * @plan:PLAN-20250823-AUTHFIXES.P15
+     * @requirement:REQ-004
      * Update the Anthropic client with resolved authentication if needed
      */
     async updateClientWithResolvedAuth() {
         const resolvedToken = await this.getAuthToken();
         if (!resolvedToken) {
-            throw new Error('No authentication available for Anthropic API calls');
-        }
-        // Check if this is an OAuth token (starts with sk-ant-oat)
-        const isOAuthToken = resolvedToken.startsWith('sk-ant-oat');
-        if (isOAuthToken) {
-            // For OAuth tokens, use authToken field which sends Bearer token
-            // Don't pass apiKey at all - just authToken
-            const oauthConfig = {
-                authToken: resolvedToken, // Use authToken for OAuth Bearer tokens
-                baseURL: this.baseURL,
-                dangerouslyAllowBrowser: true,
-                defaultHeaders: {
-                    'anthropic-beta': 'oauth-2025-04-20', // Still need the beta header
-                },
-            };
-            this.anthropic = new Anthropic(oauthConfig);
+            throw new Error('No authentication available for Anthropic API calls. Use /auth anthropic to re-authenticate or /auth anthropic logout to clear any expired session.');
         }
-        else {
-            // Regular API key auth
-            if (this.anthropic.apiKey !== resolvedToken) {
+        // Only recreate client if auth changed
+        if (this._cachedAuthKey !== resolvedToken) {
+            // Check if this is an OAuth token (starts with sk-ant-oat)
+            const isOAuthToken = resolvedToken.startsWith('sk-ant-oat');
+            // Use the unified getBaseURL() method from BaseProvider
+            const baseURL = this.getBaseURL();
+            if (isOAuthToken) {
+                // For OAuth tokens, use authToken field which sends Bearer token
+                // Don't pass apiKey at all - just authToken
+                const oauthConfig = {
+                    authToken: resolvedToken, // Use authToken for OAuth Bearer tokens
+                    baseURL,
+                    dangerouslyAllowBrowser: true,
+                    defaultHeaders: {
+                        'anthropic-beta': 'oauth-2025-04-20', // Still need the beta header
+                    },
+                };
+                this.anthropic = new Anthropic(oauthConfig);
+            }
+            else {
+                // Regular API key auth
                 this.anthropic = new Anthropic({
                     apiKey: resolvedToken,
-                    baseURL: this.baseURL,
+                    baseURL,
                     dangerouslyAllowBrowser: true,
                 });
             }
+            // Track the key to avoid unnecessary client recreation
+            this._cachedAuthKey = resolvedToken;
         }
     }
     async getModels() {
@@ -172,331 +161,26 @@ 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);
+        super.setApiKey(apiKey);
         // Create a new Anthropic client with the updated API key
+        const resolvedBaseURL = this.providerConfig?.baseUrl || this.baseProviderConfig.baseURL;
         this.anthropic = new Anthropic({
             apiKey,
-            baseURL: this.baseURL,
+            baseURL: resolvedBaseURL,
             dangerouslyAllowBrowser: true,
         });
     }
     setBaseUrl(baseUrl) {
-        // If no baseUrl is provided, clear to default (undefined)
-        this.baseURL = baseUrl && baseUrl.trim() !== '' ? baseUrl : undefined;
-        // Call base provider implementation
+        // Call base provider implementation which stores in ephemeral settings
         super.setBaseUrl?.(baseUrl);
         // Create a new Anthropic client with the updated (or cleared) base URL
         // Will be updated with actual token in updateClientWithResolvedAuth
+        const resolvedBaseURL = this.getBaseURL();
         this.anthropic = new Anthropic({
             apiKey: '', // Empty string, will be replaced when auth is resolved
-            baseURL: this.baseURL,
+            baseURL: resolvedBaseURL,
             dangerouslyAllowBrowser: true,
         });
     }
@@ -509,8 +193,7 @@ ${llxprtPrompts}`;
         catch (error) {
             this.logger.debug(() => `Failed to persist model to SettingsService: ${error}`);
         }
-        // Keep local cache for performance
-        this.currentModel = modelId;
+        // No local caching - always look up from SettingsService
     }
     getCurrentModel() {
         // Try to get from SettingsService first (source of truth)
@@ -524,11 +207,11 @@ ${llxprtPrompts}`;
         catch (error) {
             this.logger.debug(() => `Failed to get model from SettingsService: ${error}`);
         }
-        // Fall back to cached value or default
-        return this.currentModel || this.getDefaultModel();
+        // Always return from getDefaultModel, no caching
+        return this.getDefaultModel();
     }
     getDefaultModel() {
-        // Return the default model for this provider
+        // Return hardcoded default - do NOT call getModel() to avoid circular dependency
         return 'claude-sonnet-4-20250514';
     }
     /**
@@ -550,54 +233,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' ||
@@ -632,88 +267,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)
      */
@@ -737,11 +290,31 @@ ${llxprtPrompts}`;
      * @param params Parameters to merge with existing, or undefined to clear all
      */
     setModelParams(params) {
+        const settingsService = getSettingsService();
         if (params === undefined) {
-            this.modelParams = undefined;
+            // Clear all model params
+            settingsService.setProviderSetting(this.name, 'temperature', undefined);
+            settingsService.setProviderSetting(this.name, 'max_tokens', undefined);
+            settingsService.setProviderSetting(this.name, 'top_p', undefined);
+            settingsService.setProviderSetting(this.name, 'top_k', undefined);
         }
         else {
-            this.modelParams = { ...this.modelParams, ...params };
+            // Set each param individually
+            if ('temperature' in params) {
+                settingsService.setProviderSetting(this.name, 'temperature', params.temperature);
+            }
+            if ('max_tokens' in params) {
+                settingsService.setProviderSetting(this.name, 'max_tokens', params.max_tokens);
+            }
+            if ('top_p' in params) {
+                settingsService.setProviderSetting(this.name, 'top_p', params.top_p);
+            }
+            if ('top_k' in params) {
+                settingsService.setProviderSetting(this.name, 'top_k', params.top_k);
+            }
+            if ('stop_sequences' in params) {
+                settingsService.setProviderSetting(this.name, 'stop_sequences', params.stop_sequences);
+            }
         }
     }
     /**
@@ -749,7 +322,31 @@ ${llxprtPrompts}`;
      * @returns Current parameters or undefined if not set
      */
     getModelParams() {
-        return this.modelParams;
+        // Always get from SettingsService
+        const settingsService = getSettingsService();
+        const providerSettings = settingsService.getProviderSettings(this.name);
+        if (!providerSettings) {
+            return undefined;
+        }
+        const params = {};
+        if (providerSettings.temperature !== undefined)
+            params.temperature = providerSettings.temperature;
+        if (providerSettings.max_tokens !== undefined)
+            params.max_tokens = providerSettings.max_tokens;
+        if (providerSettings.top_p !== undefined)
+            params.top_p = providerSettings.top_p;
+        if (providerSettings.top_k !== undefined)
+            params.top_k = providerSettings.top_k;
+        if (providerSettings.stop_sequences !== undefined)
+            params.stop_sequences = providerSettings.stop_sequences;
+        return Object.keys(params).length > 0 ? params : undefined;
+    }
+    /**
+     * Override clearAuthCache to also clear cached auth key
+     */
+    clearAuthCache() {
+        super.clearAuthCache();
+        this._cachedAuthKey = undefined;
     }
     /**
      * Check if the provider is authenticated using any available method
@@ -758,5 +355,421 @@ ${llxprtPrompts}`;
     async isAuthenticated() {
         return super.isAuthenticated();
     }
+    /**
+     * Detect the appropriate tool format for the current model/configuration
+     * @returns The detected tool format
+     */
+    detectToolFormat() {
+        try {
+            const settingsService = getSettingsService();
+            // First check SettingsService for toolFormat override in provider settings
+            // Note: This is synchronous access to cached settings, not async
+            const currentSettings = settingsService['settings'];
+            const providerSettings = currentSettings?.providers?.[this.name];
+            const toolFormatOverride = providerSettings?.toolFormat;
+            // If explicitly set to a specific format (not 'auto'), use it
+            if (toolFormatOverride && toolFormatOverride !== 'auto') {
+                return toolFormatOverride;
+            }
+            // Auto-detect based on model name if set to 'auto' or not set
+            const modelName = this.getCurrentModel().toLowerCase();
+            // Check for GLM-4.5 models (glm-4.5, glm-4-5)
+            if (modelName.includes('glm-4.5') || modelName.includes('glm-4-5')) {
+                return 'qwen';
+            }
+            // Check for qwen models
+            if (modelName.includes('qwen')) {
+                return 'qwen';
+            }
+            // Default to 'anthropic' format
+            return 'anthropic';
+        }
+        catch (error) {
+            this.logger.debug(() => `Failed to detect tool format from SettingsService: ${error}`);
+            // Fallback detection without SettingsService
+            const modelName = this.getCurrentModel().toLowerCase();
+            if (modelName.includes('glm-4.5') || modelName.includes('glm-4-5')) {
+                return 'qwen';
+            }
+            if (modelName.includes('qwen')) {
+                return 'qwen';
+            }
+            return 'anthropic';
+        }
+    }
+    getToolFormat() {
+        // Use the same detection logic as detectToolFormat()
+        return this.detectToolFormat();
+    }
+    /**
+     * Normalize tool IDs from various formats to Anthropic format
+     * Handles IDs from OpenAI (call_xxx), Anthropic (toolu_xxx), and history (hist_tool_xxx)
+     */
+    normalizeToAnthropicToolId(id) {
+        // If already in Anthropic format, return as-is
+        if (id.startsWith('toolu_')) {
+            return id;
+        }
+        // For history format, extract the UUID and add Anthropic prefix
+        if (id.startsWith('hist_tool_')) {
+            const uuid = id.substring('hist_tool_'.length);
+            return 'toolu_' + uuid;
+        }
+        // For OpenAI format, extract the UUID and add Anthropic prefix
+        if (id.startsWith('call_')) {
+            const uuid = id.substring('call_'.length);
+            return 'toolu_' + uuid;
+        }
+        // Unknown format - assume it's a raw UUID
+        return 'toolu_' + id;
+    }
+    /**
+     * Normalize tool IDs from Anthropic format to history format
+     */
+    normalizeToHistoryToolId(id) {
+        // If already in history format, return as-is
+        if (id.startsWith('hist_tool_')) {
+            return id;
+        }
+        // For Anthropic format, extract the UUID and add history prefix
+        if (id.startsWith('toolu_')) {
+            const uuid = id.substring('toolu_'.length);
+            return 'hist_tool_' + uuid;
+        }
+        // For OpenAI format, extract the UUID and add history prefix
+        if (id.startsWith('call_')) {
+            const uuid = id.substring('call_'.length);
+            return 'hist_tool_' + uuid;
+        }
+        // Unknown format - assume it's a raw UUID
+        return 'hist_tool_' + id;
+    }
+    /**
+     * 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: string | undefined;
+        // Filter out orphaned tool responses at the beginning of the conversation
+        // TODO: Investigate post-0.2.2 - These shouldn't be truly orphaned since the same
+        // history works with OpenAI/Cerebras. Likely Anthropic has stricter formatting
+        // requirements for tool responses that we're not fully meeting yet.
+        let startIndex = 0;
+        while (startIndex < content.length &&
+            content[startIndex].speaker === 'tool') {
+            this.logger.debug(() => `Skipping orphaned tool response at beginning of conversation`);
+            startIndex++;
+        }
+        const filteredContent = content.slice(startIndex);
+        // Group consecutive tool responses together for Anthropic API
+        let pendingToolResults = [];
+        const flushToolResults = () => {
+            if (pendingToolResults.length > 0) {
+                anthropicMessages.push({
+                    role: 'user',
+                    content: pendingToolResults,
+                });
+                pendingToolResults = [];
+            }
+        };
+        for (const c of filteredContent) {
+            if (c.speaker === 'human') {
+                // Flush any pending tool results before adding a human message
+                flushToolResults();
+                const textBlock = c.blocks.find((b) => b.type === 'text');
+                // Add text block as user message
+                anthropicMessages.push({
+                    role: 'user',
+                    content: textBlock?.text || '',
+                });
+            }
+            else if (c.speaker === 'ai') {
+                // Flush any pending tool results before adding an AI message
+                flushToolResults();
+                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) {
+                        // Ensure parameters are an object, not a string
+                        let parametersObj = tc.parameters;
+                        if (typeof parametersObj === 'string') {
+                            try {
+                                parametersObj = JSON.parse(parametersObj);
+                            }
+                            catch (e) {
+                                this.logger.debug(() => `Failed to parse tool parameters as JSON: ${e}`);
+                                parametersObj = {};
+                            }
+                        }
+                        contentArray.push({
+                            type: 'tool_use',
+                            id: this.normalizeToAnthropicToolId(tc.id),
+                            name: tc.name,
+                            input: parametersObj,
+                        });
+                    }
+                    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');
+                }
+                // Collect tool results to be grouped together
+                pendingToolResults.push({
+                    type: 'tool_result',
+                    tool_use_id: this.normalizeToAnthropicToolId(toolResponseBlock.callId),
+                    content: JSON.stringify(toolResponseBlock.result),
+                });
+            }
+            else {
+                throw new Error(`Unknown speaker type: ${c.speaker}`);
+            }
+        }
+        // Flush any remaining tool results at the end
+        flushToolResults();
+        // Validate that all tool_results have corresponding tool_uses
+        // Anthropic requires strict pairing between tool_use and tool_result
+        const toolUseIds = new Set();
+        const toolResultIds = new Set();
+        for (const msg of anthropicMessages) {
+            if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_use') {
+                        toolUseIds.add(block.id);
+                    }
+                }
+            }
+            else if (msg.role === 'user' && Array.isArray(msg.content)) {
+                for (const block of msg.content) {
+                    if (block.type === 'tool_result') {
+                        toolResultIds.add(block.tool_use_id);
+                    }
+                }
+            }
+        }
+        // Remove orphaned tool results (results without corresponding tool uses)
+        const orphanedResults = Array.from(toolResultIds).filter((id) => !toolUseIds.has(id));
+        if (orphanedResults.length > 0) {
+            this.logger.debug(() => `Found ${orphanedResults.length} orphaned tool results, removing them`);
+            // Filter out messages that only contain orphaned tool results
+            const filteredMessages = anthropicMessages.filter((msg) => {
+                if (msg.role === 'user' && Array.isArray(msg.content)) {
+                    const filteredContent = msg.content.filter((block) => block.type !== 'tool_result' ||
+                        !orphanedResults.includes(block.tool_use_id));
+                    if (filteredContent.length === 0) {
+                        // Remove empty user messages
+                        return false;
+                    }
+                    msg.content = filteredContent;
+                }
+                return true;
+            });
+            // Replace the messages array
+            anthropicMessages.length = 0;
+            anthropicMessages.push(...filteredMessages);
+        }
+        // Ensure the conversation starts with a valid message type
+        // Anthropic requires the first message to be from the user
+        if (anthropicMessages.length > 0 && anthropicMessages[0].role !== 'user') {
+            // If the first message is not from the user, add a minimal user message
+            this.logger.debug(() => `First message is not from user, adding placeholder user message`);
+            anthropicMessages.unshift({
+                role: 'user',
+                content: 'Continue the conversation',
+            });
+        }
+        // Ensure we have at least one message
+        if (anthropicMessages.length === 0) {
+            anthropicMessages.push({
+                role: 'user',
+                content: 'Hello',
+            });
+        }
+        // Convert Gemini format tools directly to Anthropic format using the new method
+        const anthropicTools = this.toolFormatter.convertGeminiToAnthropic(tools);
+        // 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.providerConfig?.getEphemeralSettings?.()?.['streaming'];
+        const streamingEnabled = streamingSetting !== 'disabled';
+        // Build request with proper typing
+        const currentModel = this.getCurrentModel();
+        // Get the system prompt for non-OAuth mode
+        const userMemory = this.globalConfig?.getUserMemory
+            ? this.globalConfig.getUserMemory()
+            : '';
+        // For OAuth mode, inject core system prompt as the first human message
+        if (isOAuth) {
+            const corePrompt = await getCoreSystemPromptAsync(userMemory, currentModel, undefined);
+            if (corePrompt) {
+                anthropicMessages.unshift({
+                    role: 'user',
+                    content: `<system>\n${corePrompt}\n</system>\n\nUser provided conversation begins here:`,
+                });
+            }
+        }
+        const systemPrompt = !isOAuth
+            ? await getCoreSystemPromptAsync(userMemory, currentModel, undefined)
+            : undefined;
+        const requestBody = {
+            model: currentModel,
+            messages: anthropicMessages,
+            max_tokens: this.getMaxTokensForModel(currentModel),
+            stream: streamingEnabled,
+            ...(this.getModelParams() || {}),
+            ...(isOAuth
+                ? {
+                    system: "You are Claude Code, Anthropic's official CLI for Claude.",
+                }
+                : systemPrompt
+                    ? { system: systemPrompt }
+                    : {}),
+            ...(anthropicTools && anthropicTools.length > 0
+                ? { tools: anthropicTools }
+                : {}),
+        };
+        // Debug log the tools being sent to Anthropic
+        if (anthropicTools && anthropicTools.length > 0) {
+            this.logger.debug(() => `[AnthropicProvider] Sending tools to API:`, {
+                toolCount: anthropicTools.length,
+                toolNames: anthropicTools.map((t) => t.name),
+                firstTool: anthropicTools[0],
+                requestHasTools: 'tools' in requestBody,
+            });
+        }
+        // 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;
+                        // Check for double-escaping patterns
+                        const detectedFormat = this.detectToolFormat();
+                        logDoubleEscapingInChunk(chunk.delta.partial_json, currentToolCall.name, detectedFormat);
+                    }
+                }
+                else if (chunk.type === 'content_block_stop') {
+                    if (currentToolCall) {
+                        // Process tool parameters with double-escape handling
+                        const detectedFormat = this.detectToolFormat();
+                        const processedParameters = processToolParameters(currentToolCall.input, currentToolCall.name, detectedFormat);
+                        yield {
+                            speaker: 'ai',
+                            blocks: [
+                                {
+                                    type: 'tool_call',
+                                    id: this.normalizeToHistoryToolId(currentToolCall.id),
+                                    name: currentToolCall.name,
+                                    parameters: processedParameters,
+                                },
+                            ],
+                        };
+                        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
+            const detectedFormat = this.detectToolFormat();
+            for (const contentBlock of message.content) {
+                if (contentBlock.type === 'text') {
+                    blocks.push({ type: 'text', text: contentBlock.text });
+                }
+                else if (contentBlock.type === 'tool_use') {
+                    // Process tool parameters with double-escape handling
+                    const processedParameters = processToolParameters(JSON.stringify(contentBlock.input), contentBlock.name, detectedFormat);
+                    blocks.push({
+                        type: 'tool_call',
+                        id: this.normalizeToHistoryToolId(contentBlock.id),
+                        name: contentBlock.name,
+                        parameters: processedParameters,
+                    });
+                }
+            }
+            // 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