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

package/dist/src/providers/openai/OpenAIProvider.js

@@ -17,210 +17,158 @@
  * @plan PLAN-20250120-DEBUGLOGGING.P15
  * @requirement REQ-INT-001.1
  */
-import { DebugLogger } from '../../debug/index.js';
-import { ContentGeneratorRole } from '../ContentGeneratorRole.js';
-import { GemmaToolCallParser } from '../../parsers/TextToolCallParser.js';
-import { ToolFormatter } from '../../tools/ToolFormatter.js';
 import OpenAI from 'openai';
+import * as http from 'http';
+import * as https from 'https';
+import * as net from 'net';
 import { BaseProvider } from '../BaseProvider.js';
-import { isQwenEndpoint, generateOAuthEndpointMismatchError, } from '../../config/endpoints.js';
-import { getSettingsService } from '../../settings/settingsServiceInstance.js';
+import { DebugLogger } from '../../debug/index.js';
+import { ToolFormatter } from '../../tools/ToolFormatter.js';
+import { processToolParameters } from '../../tools/doubleEscapeUtils.js';
+import { getCoreSystemPromptAsync } from '../../core/prompts.js';
+import { retryWithBackoff } from '../../utils/retry.js';
 export class OpenAIProvider extends BaseProvider {
+    name = 'openai';
     logger;
-    openai;
-    currentModel = process.env.LLXPRT_DEFAULT_MODEL || 'gpt-5';
-    baseURL;
-    providerConfig;
     toolFormatter;
-    toolFormatOverride;
-    modelParams;
     _cachedClient;
     _cachedClientKey;
     constructor(apiKey, baseURL, config, oauthManager) {
+        // Normalize empty string to undefined for proper precedence handling
+        const normalizedApiKey = apiKey && apiKey.trim() !== '' ? apiKey : undefined;
+        // Detect if this is a Qwen endpoint
+        const isQwenEndpoint = !!(baseURL &&
+            (baseURL.includes('dashscope.aliyuncs.com') ||
+                baseURL.includes('api.qwen.com') ||
+                baseURL.includes('qwen')));
         // Initialize base provider with auth configuration
-        // Check if we should enable OAuth for Qwen
-        // Check OAuth enablement from OAuth manager if available
-        let shouldEnableQwenOAuth = false;
-        if (oauthManager) {
-            // Check if OAuth is enabled for qwen in the OAuth manager (from settings)
-            const manager = oauthManager;
-            if (manager.isOAuthEnabled &&
-                typeof manager.isOAuthEnabled === 'function') {
-                shouldEnableQwenOAuth = manager.isOAuthEnabled('qwen');
-            }
-            // Also enable if this looks like a Qwen endpoint
-            if (!shouldEnableQwenOAuth) {
-                shouldEnableQwenOAuth =
-                    isQwenEndpoint(baseURL || '') ||
-                        (!baseURL && (!apiKey || apiKey === '')) ||
-                        baseURL === 'https://portal.qwen.ai/v1';
-            }
-        }
-        const baseConfig = {
+        super({
             name: 'openai',
-            apiKey,
+            apiKey: normalizedApiKey,
             baseURL,
-            envKeyNames: ['OPENAI_API_KEY'],
-            isOAuthEnabled: shouldEnableQwenOAuth,
-            oauthProvider: shouldEnableQwenOAuth ? 'qwen' : undefined,
+            envKeyNames: ['OPENAI_API_KEY'], // Support environment variable fallback
+            isOAuthEnabled: isQwenEndpoint && !!oauthManager,
+            oauthProvider: isQwenEndpoint ? 'qwen' : undefined,
             oauthManager,
-        };
-        super(baseConfig);
-        this.logger = new DebugLogger('llxprt:providers:openai');
-        this.logger.debug(() => `Constructor - baseURL: ${baseURL}, apiKey: ${apiKey?.substring(0, 10) || 'none'}, oauthManager: ${!!oauthManager}, shouldEnableQwenOAuth: ${shouldEnableQwenOAuth}`);
-        this.baseURL = baseURL;
-        this.providerConfig = config;
+        }, config);
         this.toolFormatter = new ToolFormatter();
-        // Initialize from SettingsService
-        this.initializeFromSettings().catch((error) => {
-            this.logger.debug(() => `Failed to initialize from SettingsService: ${error}`);
-        });
-        // Set appropriate default model based on the provider
-        if (shouldEnableQwenOAuth || isQwenEndpoint(baseURL || '')) {
-            // Default to Qwen model when using Qwen endpoints
-            this.currentModel = 'qwen3-coder-plus';
-        }
-        else if (process.env.LLXPRT_DEFAULT_MODEL) {
-            // Use environment variable if set
-            this.currentModel = process.env.LLXPRT_DEFAULT_MODEL;
-        }
-        const clientOptions = {
-            apiKey: apiKey || 'placeholder', // OpenAI client requires a string, use placeholder if OAuth will be used
-            // Allow browser environment if explicitly configured
-            dangerouslyAllowBrowser: config?.allowBrowserEnvironment || false,
-        };
-        // Only include baseURL if it's defined
-        if (baseURL) {
-            clientOptions.baseURL = baseURL;
-        }
-        this.openai = new OpenAI(clientOptions);
-        this._cachedClientKey = apiKey; // Track the initial key used
-        // Cached client reserved for future optimization
-        void this._cachedClient;
-    }
-    /**
-     * Implementation of BaseProvider abstract method
-     * Determines if this provider supports OAuth authentication
-     */
-    supportsOAuth() {
-        // Only support Qwen OAuth for Qwen endpoints
-        // Use baseProviderConfig.baseURL if this.baseURL not set yet (during constructor)
-        const baseURL = this.baseURL ||
-            this.baseProviderConfig.baseURL ||
-            'https://api.openai.com/v1';
-        return isQwenEndpoint(baseURL);
+        // new DebugLogger('llxprt:core:toolformatter'), // TODO: Fix ToolFormatter constructor
+        // Setup debug logger
+        this.logger = new DebugLogger('llxprt:provider:openai');
     }
     /**
-     * Helper method to determine if we're using Qwen (via OAuth or direct endpoint)
+     * Create HTTP/HTTPS agents with socket configuration for local AI servers
+     * Returns undefined if no socket settings are configured
      */
-    isUsingQwen() {
-        // Check if we're using qwen format based on tool format detection
-        const toolFormat = this.detectToolFormat();
-        return toolFormat === 'qwen';
+    createHttpAgents() {
+        // Get socket configuration from ephemeral settings
+        const settings = this.providerConfig?.getEphemeralSettings?.() || {};
+        // Check if any socket settings are explicitly configured
+        const hasSocketSettings = 'socket-timeout' in settings ||
+            'socket-keepalive' in settings ||
+            'socket-nodelay' in settings;
+        // Only create custom agents if socket settings are configured
+        if (!hasSocketSettings) {
+            return undefined;
+        }
+        // Socket configuration with defaults for when settings ARE configured
+        const socketTimeout = settings['socket-timeout'] || 60000; // 60 seconds default
+        const socketKeepAlive = settings['socket-keepalive'] !== false; // true by default
+        const socketNoDelay = settings['socket-nodelay'] !== false; // true by default
+        // Create HTTP agent with socket options
+        const httpAgent = new http.Agent({
+            keepAlive: socketKeepAlive,
+            keepAliveMsecs: 1000,
+            timeout: socketTimeout,
+        });
+        // Create HTTPS agent with socket options
+        const httpsAgent = new https.Agent({
+            keepAlive: socketKeepAlive,
+            keepAliveMsecs: 1000,
+            timeout: socketTimeout,
+        });
+        // Apply TCP_NODELAY if enabled (reduces latency for local servers)
+        if (socketNoDelay) {
+            const originalCreateConnection = httpAgent.createConnection;
+            httpAgent.createConnection = function (options, callback) {
+                const socket = originalCreateConnection.call(this, options, callback);
+                if (socket instanceof net.Socket) {
+                    socket.setNoDelay(true);
+                }
+                return socket;
+            };
+            const originalHttpsCreateConnection = httpsAgent.createConnection;
+            httpsAgent.createConnection = function (options, callback) {
+                const socket = originalHttpsCreateConnection.call(this, options, callback);
+                if (socket instanceof net.Socket) {
+                    socket.setNoDelay(true);
+                }
+                return socket;
+            };
+        }
+        return { httpAgent, httpsAgent };
     }
     /**
-     * Update the OpenAI client with resolved authentication if needed
+     * Get or create OpenAI client instance
+     * Will use the API key from resolved auth
+     * @returns OpenAI client instance
      */
-    async updateClientWithResolvedAuth() {
+    async getClient() {
         const resolvedKey = await this.getAuthToken();
-        if (!resolvedKey) {
-            // Provide specific error message based on endpoint validation
-            const endpoint = this.baseURL || 'https://api.openai.com/v1';
-            if (this.isOAuthEnabled() && !this.supportsOAuth()) {
-                throw new Error(generateOAuthEndpointMismatchError(endpoint, 'qwen'));
-            }
-            throw new Error('No authentication available for OpenAI API calls');
-        }
-        // Check if we're using Qwen OAuth and need to update the baseURL
-        let effectiveBaseURL = this.baseURL;
-        this.logger.debug(() => `updateClientWithResolvedAuth - OAuth enabled: ${this.isOAuthEnabled()}, OAuth provider: ${this.baseProviderConfig.oauthProvider}, baseURL: ${this.baseURL}, resolvedKey: ${resolvedKey?.substring(0, 10)}...`);
-        if (this.isOAuthEnabled() &&
-            this.baseProviderConfig.oauthProvider === 'qwen') {
-            // Get the OAuth token to check for resource_url
-            const oauthManager = this.baseProviderConfig.oauthManager;
-            if (oauthManager?.getOAuthToken) {
-                const oauthToken = await oauthManager.getOAuthToken('qwen');
-                this.logger.debug(() => `OAuth token retrieved:\n` +
-                    `  resource_url: ${oauthToken?.resource_url}\n` +
-                    `  access_token: ${oauthToken?.access_token?.substring(0, 10)}...`);
-                if (oauthToken?.resource_url) {
-                    // Use the resource_url from the OAuth token
-                    effectiveBaseURL = `https://${oauthToken.resource_url}/v1`;
-                    this.logger.debug(() => `Using Qwen OAuth endpoint: ${effectiveBaseURL}`);
-                }
-            }
-        }
-        // Only update client if the key or URL has changed
-        if (this._cachedClientKey !== resolvedKey ||
-            this.baseURL !== effectiveBaseURL) {
-            const clientOptions = {
-                apiKey: resolvedKey,
-                // Allow browser environment if explicitly configured
-                dangerouslyAllowBrowser: this.providerConfig?.allowBrowserEnvironment || false,
-            };
-            // Only include baseURL if it's defined
-            if (effectiveBaseURL) {
-                clientOptions.baseURL = effectiveBaseURL;
-            }
-            this.openai = new OpenAI(clientOptions);
-            this._cachedClientKey = resolvedKey;
-            // Update the baseURL to track changes
-            if (effectiveBaseURL !== this.baseURL) {
-                this.baseURL = effectiveBaseURL;
+        // Use the unified getBaseURL() method from BaseProvider
+        const baseURL = this.getBaseURL();
+        const clientKey = `${baseURL}-${resolvedKey}`;
+        // Return cached client if available and auth hasn't changed
+        if (this._cachedClient && this._cachedClientKey === clientKey) {
+            return this._cachedClient;
+        }
+        // Create HTTP agents with socket configuration (if configured)
+        const agents = this.createHttpAgents();
+        // Build client options - OpenAI SDK accepts httpAgent/httpsAgent at runtime
+        // even though they're not in the TypeScript definitions
+        const baseOptions = {
+            apiKey: resolvedKey || '',
+            baseURL,
+        };
+        // Add socket configuration if available
+        const clientOptions = agents
+            ? {
+                ...baseOptions,
+                httpAgent: agents.httpAgent,
+                httpsAgent: agents.httpsAgent,
             }
-        }
+            : baseOptions;
+        // Create new client with current auth and optional socket configuration
+        // Cast to unknown then to the expected type to bypass TypeScript's structural checking
+        this._cachedClient = new OpenAI(clientOptions);
+        this._cachedClientKey = clientKey;
+        return this._cachedClient;
     }
-    requiresTextToolCallParsing() {
-        if (this.providerConfig?.enableTextToolCallParsing === false) {
-            return false;
-        }
-        // Check if current tool format requires text-based parsing
-        const currentFormat = this.getToolFormat();
-        const textBasedFormats = ['hermes', 'xml', 'llama'];
-        if (textBasedFormats.includes(currentFormat)) {
+    /**
+     * Check if OAuth is supported for this provider
+     * Qwen endpoints support OAuth, standard OpenAI does not
+     */
+    supportsOAuth() {
+        const baseURL = this.getBaseURL();
+        // Check if this is a Qwen endpoint that supports OAuth
+        if (baseURL &&
+            (baseURL.includes('dashscope.aliyuncs.com') ||
+                baseURL.includes('api.qwen.com') ||
+                baseURL.includes('qwen'))) {
             return true;
         }
-        const configuredModels = this.providerConfig?.textToolCallModels || [];
-        return configuredModels.includes(this.currentModel);
-    }
-    getToolFormat() {
-        // Check manual override first
-        if (this.toolFormatOverride) {
-            return this.toolFormatOverride;
-        }
-        // Check for settings override
-        if (this.providerConfig?.providerToolFormatOverrides?.[this.name]) {
-            return this.providerConfig.providerToolFormatOverrides[this.name];
-        }
-        // Auto-detect tool format based on model or base URL
-        if (this.currentModel.includes('deepseek') ||
-            this.baseURL?.includes('deepseek')) {
-            return 'deepseek';
-        }
-        // Check for Qwen - including OAuth authenticated Qwen
-        if (this.isUsingQwen()) {
-            return 'qwen';
-        }
-        // Default to OpenAI format
-        return 'openai';
+        // Standard OpenAI endpoints don't support OAuth
+        return false;
     }
     async getModels() {
-        // Check if API key is available (using resolved authentication)
-        const apiKey = await this.getAuthToken();
-        if (!apiKey) {
-            const endpoint = this.baseURL || 'https://api.openai.com/v1';
-            if (this.isOAuthEnabled() && !this.supportsOAuth()) {
-                throw new Error(generateOAuthEndpointMismatchError(endpoint, 'qwen'));
-            }
-            throw new Error('OpenAI API key is required to fetch models');
-        }
         try {
-            // Get resolved authentication and update client if needed
-            await this.updateClientWithResolvedAuth();
-            const response = await this.openai.models.list();
+            // Always try to fetch models, regardless of auth status
+            // Local endpoints often work without authentication
+            const client = await this.getClient();
+            const response = await client.models.list();
             const models = [];
             for await (const model of response) {
-                // Filter out non-chat models (embeddings, audio, image, moderation, DALL·E, etc.)
+                // Filter out non-chat models (embeddings, audio, image, vision, DALL·E, etc.)
                 if (!/embedding|whisper|audio|tts|image|vision|dall[- ]?e|moderation/i.test(model.id)) {
                     models.push({
                         id: model.id,
@@ -235,844 +183,532 @@ export class OpenAIProvider extends BaseProvider {
         catch (error) {
             this.logger.debug(() => `Error fetching models from OpenAI: ${error}`);
             // Return a hardcoded list as fallback
-            // Check if this is a Qwen endpoint
-            if (isQwenEndpoint(this.baseURL || '')) {
-                return [
-                    {
-                        id: 'qwen3-coder-plus',
-                        name: 'qwen3-coder-plus',
-                        provider: 'openai',
-                        supportedToolFormats: ['openai'],
-                    },
-                ];
-            }
-            // Default OpenAI models
-            return [
-                {
-                    id: 'gpt-4o',
-                    name: 'gpt-4o',
-                    provider: 'openai',
-                    supportedToolFormats: ['openai'],
-                },
-                {
-                    id: 'gpt-4o-mini',
-                    name: 'gpt-4o-mini',
-                    provider: 'openai',
-                    supportedToolFormats: ['openai'],
-                },
-                {
-                    id: 'gpt-4-turbo',
-                    name: 'gpt-4-turbo',
-                    provider: 'openai',
-                    supportedToolFormats: ['openai'],
-                },
-                {
-                    id: 'gpt-3.5-turbo',
-                    name: 'gpt-3.5-turbo',
-                    provider: 'openai',
-                    supportedToolFormats: ['openai'],
-                },
-            ];
-        }
-    }
-    async *generateChatCompletion(messages, tools, _toolFormat) {
-        // 1. Validate authentication and messages
-        await this.validateRequestPreconditions(messages);
-        // 2. Prepare request configuration
-        const requestConfig = this.prepareApiRequest(messages, tools);
-        // 3. Make API call with error handling
-        const response = await this.executeApiCall(messages, tools, requestConfig);
-        // 4. Process response based on streaming mode
-        let processedData = {
-            fullContent: '',
-            accumulatedToolCalls: [],
-            hasStreamedContent: false,
-            usageData: undefined,
-            pendingWhitespace: null,
-        };
-        if (requestConfig.streamingEnabled) {
-            // Need to yield streaming content as it comes
-            const streamResponse = response;
-            for await (const chunk of streamResponse) {
-                const delta = chunk.choices?.[0]?.delta;
-                if (delta?.content && !requestConfig.parser) {
-                    if (this.isUsingQwen()) {
-                        // Handle Qwen whitespace buffering inline for yielding
-                        // This is needed because we yield during streaming
-                        // We'll refactor this separately if needed
-                        const whitespaceResult = this.handleQwenStreamingWhitespace(delta, processedData.pendingWhitespace, processedData.fullContent);
-                        if (whitespaceResult.shouldYield) {
-                            yield {
-                                role: ContentGeneratorRole.ASSISTANT,
-                                content: whitespaceResult.content,
-                            };
-                        }
-                        // Update our tracking of processed data
-                        processedData = {
-                            fullContent: whitespaceResult.updatedFullContent,
-                            accumulatedToolCalls: processedData.accumulatedToolCalls,
-                            hasStreamedContent: processedData.hasStreamedContent ||
-                                whitespaceResult.shouldYield,
-                            usageData: processedData.usageData,
-                            pendingWhitespace: whitespaceResult.updatedPendingWhitespace,
-                        };
-                    }
-                    else {
-                        yield {
-                            role: ContentGeneratorRole.ASSISTANT,
-                            content: delta.content,
-                        };
-                        processedData = {
-                            fullContent: processedData.fullContent + delta.content,
-                            accumulatedToolCalls: processedData.accumulatedToolCalls,
-                            hasStreamedContent: true,
-                            usageData: processedData.usageData,
-                            pendingWhitespace: null,
-                        };
-                    }
-                }
-                else if (delta?.content) {
-                    // Parser mode - just accumulate
-                    processedData = {
-                        fullContent: processedData.fullContent + delta.content,
-                        accumulatedToolCalls: processedData.accumulatedToolCalls,
-                        hasStreamedContent: processedData.hasStreamedContent,
-                        usageData: processedData.usageData,
-                        pendingWhitespace: processedData.pendingWhitespace,
-                    };
-                }
-                // Handle tool calls
-                if (delta?.tool_calls) {
-                    const accumulated = processedData.accumulatedToolCalls;
-                    for (const toolCall of delta.tool_calls) {
-                        this.toolFormatter.accumulateStreamingToolCall(toolCall, accumulated, requestConfig.currentToolFormat);
-                    }
-                    processedData = {
-                        ...processedData,
-                        accumulatedToolCalls: accumulated,
-                    };
-                }
-                // Check for usage data
-                if (chunk.usage) {
-                    processedData = {
-                        ...processedData,
-                        usageData: {
-                            prompt_tokens: chunk.usage.prompt_tokens || 0,
-                            completion_tokens: chunk.usage.completion_tokens || 0,
-                            total_tokens: chunk.usage.total_tokens || 0,
-                        },
-                    };
-                }
-            }
-        }
-        else {
-            // Non-streaming response
-            processedData = this.processNonStreamingResponse(response);
-            // For non-streaming, yield content if no parser
-            if (!requestConfig.parser && processedData.fullContent) {
-                yield {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: processedData.fullContent,
-                };
-                processedData.hasStreamedContent = true;
-            }
-        }
-        // 5. Flush pending whitespace if needed (for Qwen)
-        if (processedData.pendingWhitespace &&
-            this.isUsingQwen() &&
-            !requestConfig.parser) {
-            this.logger.debug(() => `Flushing trailing pending whitespace (len=${processedData.pendingWhitespace?.length ?? 0}) at stream end`);
-            yield {
-                role: ContentGeneratorRole.ASSISTANT,
-                content: processedData.pendingWhitespace,
-            };
-            processedData.hasStreamedContent = true;
-            processedData.fullContent += processedData.pendingWhitespace;
-            processedData.pendingWhitespace = null;
-        }
-        // 6. Process and yield final results
-        yield* this.processFinalResponse(processedData, requestConfig.parser);
-    }
-    setModel(modelId) {
-        // Update SettingsService as the source of truth
-        this.setModelInSettings(modelId).catch((error) => {
-            this.logger.debug(() => `Failed to persist model to SettingsService: ${error}`);
-        });
-        // Keep local cache for performance
-        this.currentModel = modelId;
-    }
-    getCurrentModel() {
-        // Try to get from SettingsService first (source of truth)
-        try {
-            const settingsService = getSettingsService();
-            const providerSettings = settingsService.getProviderSettings(this.name);
-            if (providerSettings.model) {
-                return providerSettings.model;
-            }
-        }
-        catch (error) {
-            this.logger.debug(() => `Failed to get model from SettingsService: ${error}`);
-        }
-        // Fall back to cached value or default
-        return this.currentModel || this.getDefaultModel();
+            return this.getFallbackModels();
+        }
+    }
+    getFallbackModels() {
+        return [
+            {
+                id: 'gpt-5',
+                name: 'GPT-5',
+                provider: 'openai',
+                supportedToolFormats: ['openai'],
+            },
+            {
+                id: 'gpt-4.1',
+                name: 'GPT-4.1',
+                provider: 'openai',
+                supportedToolFormats: ['openai'],
+            },
+            {
+                id: 'gpt-4o',
+                name: 'GPT-4o',
+                provider: 'openai',
+                supportedToolFormats: ['openai'],
+            },
+            {
+                id: 'o3',
+                name: 'O3',
+                provider: 'openai',
+                supportedToolFormats: ['openai'],
+            },
+            {
+                id: 'o4-mini',
+                name: 'O4 Mini',
+                provider: 'openai',
+                supportedToolFormats: ['openai'],
+            },
+            {
+                id: 'gpt-3.5-turbo',
+                name: 'GPT-3.5 Turbo (Legacy)',
+                provider: 'openai',
+                supportedToolFormats: ['openai'],
+            },
+        ];
     }
     getDefaultModel() {
-        // Return the default model for this provider
-        // This can be overridden based on configuration or endpoint
-        if (this.isUsingQwen()) {
-            return 'qwen3-coder-plus';
-        }
+        // Return hardcoded default - do NOT call getModel() to avoid circular dependency
         return process.env.LLXPRT_DEFAULT_MODEL || 'gpt-5';
     }
-    setApiKey(apiKey) {
-        // Call base provider implementation
-        super.setApiKey(apiKey);
-        // Persist to SettingsService if available
-        this.setApiKeyInSettings(apiKey).catch((error) => {
-            this.logger.debug(() => `Failed to persist API key to SettingsService: ${error}`);
-        });
-        // Create a new OpenAI client with the updated API key
-        const clientOptions = {
-            apiKey,
-            dangerouslyAllowBrowser: this.providerConfig?.allowBrowserEnvironment || false,
-        };
-        // Only include baseURL if it's defined
-        if (this.baseURL) {
-            clientOptions.baseURL = this.baseURL;
-        }
-        this.openai = new OpenAI(clientOptions);
-        this._cachedClientKey = apiKey; // Update cached key
-    }
-    setBaseUrl(baseUrl) {
-        // If no baseUrl is provided, clear to default (undefined)
-        this.baseURL = baseUrl && baseUrl.trim() !== '' ? baseUrl : undefined;
-        // Persist to SettingsService if available
-        this.setBaseUrlInSettings(this.baseURL).catch((error) => {
-            this.logger.debug(() => `Failed to persist base URL to SettingsService: ${error}`);
-        });
-        // Update OAuth configuration based on endpoint validation
-        // Enable OAuth for Qwen endpoints if we have an OAuth manager
-        const shouldEnableQwenOAuth = !!this.baseProviderConfig.oauthManager &&
-            (isQwenEndpoint(this.baseURL || '') ||
-                this.baseURL === 'https://portal.qwen.ai/v1');
-        this.updateOAuthConfig(shouldEnableQwenOAuth, shouldEnableQwenOAuth ? 'qwen' : undefined, this.baseProviderConfig.oauthManager);
-        // Call base provider implementation
-        super.setBaseUrl?.(baseUrl);
-        // Create a new OpenAI client with the updated (or cleared) base URL
-        const clientOptions = {
-            // Use existing key or empty string as placeholder
-            apiKey: this._cachedClientKey || 'placeholder',
-            dangerouslyAllowBrowser: this.providerConfig?.allowBrowserEnvironment || false,
-        };
-        // Only include baseURL if it's defined
-        if (this.baseURL) {
-            clientOptions.baseURL = this.baseURL;
-        }
-        this.openai = new OpenAI(clientOptions);
-        // Clear cached key to force re-resolution on next API call
-        this._cachedClientKey = undefined;
-    }
-    setConfig(config) {
-        this.providerConfig = config;
-    }
-    setToolFormatOverride(format) {
-        this.toolFormatOverride = format || undefined;
-    }
-    /**
-     * OpenAI always requires payment (API key)
-     */
-    isPaidMode() {
-        return true;
-    }
-    clearState() {
-        // No state to clear in base OpenAI provider
-    }
-    /**
-     * Get the list of server tools supported by this provider
-     */
     getServerTools() {
+        // TODO: Implement server tools for OpenAI provider
         return [];
     }
-    /**
-     * Invoke a server tool (native provider tool)
-     */
-    async invokeServerTool(_toolName, _params, _config) {
-        throw new Error('Server tools not supported by OpenAI provider');
+    async invokeServerTool(toolName, _params, _config) {
+        // TODO: Implement server tool invocation for OpenAI provider
+        throw new Error(`Server tool '${toolName}' not supported by OpenAI provider`);
     }
     /**
-     * Set model parameters to be included in API calls
-     * @param params Parameters to merge with existing, or undefined to clear all
+     * Normalize tool IDs from various formats to OpenAI format
+     * Handles IDs from OpenAI (call_xxx), Anthropic (toolu_xxx), and history (hist_tool_xxx)
      */
-    setModelParams(params) {
-        if (params === undefined) {
-            this.modelParams = undefined;
+    normalizeToOpenAIToolId(id) {
+        // If already in OpenAI format, return as-is
+        if (id.startsWith('call_')) {
+            return id;
         }
-        else {
-            this.modelParams = { ...this.modelParams, ...params };
+        // For history format, extract the UUID and add OpenAI prefix
+        if (id.startsWith('hist_tool_')) {
+            const uuid = id.substring('hist_tool_'.length);
+            return 'call_' + uuid;
         }
-        // Persist to SettingsService if available
-        this.setModelParamsInSettings(this.modelParams).catch((error) => {
-            this.logger.debug(() => `Failed to persist model params to SettingsService: ${error}`);
-        });
-    }
-    /**
-     * Get current model parameters
-     * @returns Current parameters or undefined if not set
-     */
-    getModelParams() {
-        return this.modelParams;
+        // For Anthropic format, extract the UUID and add OpenAI prefix
+        if (id.startsWith('toolu_')) {
+            const uuid = id.substring('toolu_'.length);
+            return 'call_' + uuid;
+        }
+        // Unknown format - assume it's a raw UUID
+        return 'call_' + id;
     }
     /**
-     * Initialize provider configuration from SettingsService
+     * Normalize tool IDs from OpenAI format to history format
      */
-    async initializeFromSettings() {
-        try {
-            // Load saved model if available
-            const savedModel = await this.getModelFromSettings();
-            if (savedModel) {
-                this.currentModel = savedModel;
-            }
-            // Load saved base URL if available
-            const savedBaseUrl = await this.getBaseUrlFromSettings();
-            if (savedBaseUrl !== undefined) {
-                this.baseURL = savedBaseUrl;
-            }
-            // Load saved model parameters if available
-            const savedParams = await this.getModelParamsFromSettings();
-            if (savedParams) {
-                this.modelParams = savedParams;
-            }
-            this.logger.debug(() => `Initialized from SettingsService - model: ${this.currentModel}, baseURL: ${this.baseURL}, params: ${JSON.stringify(this.modelParams)}`);
+    normalizeToHistoryToolId(id) {
+        // If already in history format, return as-is
+        if (id.startsWith('hist_tool_')) {
+            return id;
         }
-        catch (error) {
-            this.logger.debug(() => `Failed to initialize OpenAI provider from SettingsService: ${error}`);
+        // For OpenAI format, extract the UUID and add history prefix
+        if (id.startsWith('call_')) {
+            const uuid = id.substring('call_'.length);
+            return 'hist_tool_' + uuid;
         }
+        // For Anthropic format, extract the UUID and add history prefix
+        if (id.startsWith('toolu_')) {
+            const uuid = id.substring('toolu_'.length);
+            return 'hist_tool_' + uuid;
+        }
+        // Unknown format - assume it's a raw UUID
+        return 'hist_tool_' + id;
     }
     /**
-     * Check if the provider is authenticated using any available method
-     * Uses the base provider's isAuthenticated implementation
+     * Generate chat completion with IContent interface
+     * Internally converts to OpenAI API format, but only yields IContent
+     * @param contents Array of content blocks (text and tool_call)
+     * @param tools Array of available tools
      */
-    async isAuthenticated() {
-        return super.isAuthenticated();
+    async *generateChatCompletion(contents, tools) {
+        // Debug log what we receive
+        if (this.logger.enabled) {
+            this.logger.debug(() => `[OpenAIProvider] generateChatCompletion received tools:`, {
+                hasTools: !!tools,
+                toolsLength: tools?.length,
+                toolsType: typeof tools,
+                isArray: Array.isArray(tools),
+                firstToolName: tools?.[0]?.functionDeclarations?.[0]?.name,
+                toolsStructure: tools ? 'available' : 'undefined',
+            });
+        }
+        // Pass tools directly in Gemini format - they'll be converted in generateChatCompletionImpl
+        const generator = this.generateChatCompletionImpl(contents, tools, undefined, undefined, undefined);
+        for await (const item of generator) {
+            yield item;
+        }
     }
     /**
-     * Detect the appropriate tool format for the current model/configuration
-     * @returns The detected tool format
+     * Convert IContent array to OpenAI ChatCompletionMessageParam array
      */
-    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.currentModel.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';
+    convertToOpenAIMessages(contents) {
+        const messages = [];
+        for (const content of contents) {
+            if (content.speaker === 'human') {
+                // Convert human messages to user messages
+                const textBlocks = content.blocks.filter((b) => b.type === 'text');
+                const text = textBlocks.map((b) => b.text).join('\n');
+                if (text) {
+                    messages.push({
+                        role: 'user',
+                        content: text,
+                    });
+                }
             }
-            // Default to 'openai' format
-            return 'openai';
-        }
-        catch (error) {
-            this.logger.debug(() => `Failed to detect tool format from SettingsService: ${error}`);
-            // Fallback detection without SettingsService
-            const modelName = this.currentModel.toLowerCase();
-            if (modelName.includes('glm-4.5') || modelName.includes('glm-4-5')) {
-                return 'qwen';
+            else if (content.speaker === 'ai') {
+                // Convert AI messages
+                const textBlocks = content.blocks.filter((b) => b.type === 'text');
+                const toolCalls = content.blocks.filter((b) => b.type === 'tool_call');
+                if (toolCalls.length > 0) {
+                    // Assistant message with tool calls
+                    const text = textBlocks.map((b) => b.text).join('\n');
+                    messages.push({
+                        role: 'assistant',
+                        content: text || null,
+                        tool_calls: toolCalls.map((tc) => ({
+                            id: this.normalizeToOpenAIToolId(tc.id),
+                            type: 'function',
+                            function: {
+                                name: tc.name,
+                                arguments: typeof tc.parameters === 'string'
+                                    ? tc.parameters
+                                    : JSON.stringify(tc.parameters),
+                            },
+                        })),
+                    });
+                }
+                else if (textBlocks.length > 0) {
+                    // Plain assistant message
+                    const text = textBlocks.map((b) => b.text).join('\n');
+                    messages.push({
+                        role: 'assistant',
+                        content: text,
+                    });
+                }
             }
-            if (modelName.includes('qwen')) {
-                return 'qwen';
+            else if (content.speaker === 'tool') {
+                // Convert tool responses
+                const toolResponses = content.blocks.filter((b) => b.type === 'tool_response');
+                for (const tr of toolResponses) {
+                    messages.push({
+                        role: 'tool',
+                        content: typeof tr.result === 'string'
+                            ? tr.result
+                            : JSON.stringify(tr.result),
+                        tool_call_id: this.normalizeToOpenAIToolId(tr.callId),
+                    });
+                }
             }
-            return 'openai';
         }
+        return messages;
     }
     /**
-     * Get appropriate tool_choice value based on detected tool format
-     * @param tools Array of tools (if any)
-     * @returns Appropriate tool_choice value for the current format
-     */
-    getToolChoiceForFormat(tools) {
-        if (!tools || tools.length === 0) {
-            return undefined;
-        }
-        // For all formats, use 'auto' (standard behavior)
-        // Future enhancement: different formats may need different tool_choice values
-        return 'auto';
-    }
-    /**
-     * Format tools for API based on detected tool format
-     * @param tools Array of tools to format
-     * @returns Formatted tools for API consumption
-     */
-    formatToolsForAPI(tools) {
-        // For now, always use OpenAI format through OpenRouter
-        // TODO: Investigate if OpenRouter needs special handling for GLM/Qwen
-        // const detectedFormat = this.detectToolFormat();
-        // if (detectedFormat === 'qwen') {
-        //   // Convert OpenAI format to Qwen format: {name, description, parameters} without type/function wrapper
-        //   return tools.map((tool) => ({
-        //     name: tool.function.name,
-        //     description: tool.function.description,
-        //     parameters: tool.function.parameters,
-        //   }));
-        // }
-        // For all formats, use the existing ToolFormatter
-        return this.toolFormatter.toProviderFormat(tools, 'openai');
-    }
-    /**
-     * Parse tool response from API (placeholder for future response parsing)
-     * @param response The raw API response
-     * @returns Parsed tool response
-     */
-    parseToolResponse(response) {
-        // TODO: Implement response parsing based on detected format
-        // For now, return the response as-is
-        return response;
-    }
-    /**
-     * Validate authentication and message preconditions for API calls
+     * Internal implementation for chat completion
      */
-    async validateRequestPreconditions(messages) {
-        // Check if API key is available (using resolved authentication)
-        const apiKey = await this.getAuthToken();
-        if (!apiKey) {
-            const endpoint = this.baseURL || 'https://api.openai.com/v1';
-            if (this.isOAuthEnabled() && !this.supportsOAuth()) {
-                throw new Error(generateOAuthEndpointMismatchError(endpoint, 'qwen'));
-            }
-            throw new Error('OpenAI API key is required to generate completions');
-        }
-        // Validate tool messages have required tool_call_id
-        const toolMessages = messages.filter((msg) => msg.role === 'tool');
-        const missingIds = toolMessages.filter((msg) => !msg.tool_call_id);
-        if (missingIds.length > 0) {
-            this.logger.error(() => `FATAL: Tool messages missing tool_call_id: ${JSON.stringify(missingIds)}`);
-            throw new Error(`OpenAI API requires tool_call_id for all tool messages. Found ${missingIds.length} tool message(s) without IDs.`);
+    async *generateChatCompletionImpl(contents, tools, maxTokens, abortSignal, modelName) {
+        // Always look up model from SettingsService
+        const model = modelName || this.getModel() || this.getDefaultModel();
+        // Convert IContent to OpenAI messages format
+        const messages = this.convertToOpenAIMessages(contents);
+        // Convert Gemini format tools directly to OpenAI format using the new method
+        const formattedTools = this.toolFormatter.convertGeminiToOpenAI(tools);
+        // Debug log the conversion result
+        if (this.logger.enabled) {
+            this.logger.debug(() => `[OpenAIProvider] Tool conversion summary:`, {
+                inputHadTools: !!tools,
+                inputToolsLength: tools?.length,
+                outputHasTools: !!formattedTools,
+                outputToolsLength: formattedTools?.length,
+                outputToolNames: formattedTools?.map((t) => t.function.name),
+            });
         }
-    }
-    /**
-     * Prepare API request configuration
-     */
-    prepareApiRequest(messages, tools) {
-        const parser = this.requiresTextToolCallParsing()
-            ? new GemmaToolCallParser()
-            : null;
-        // Get current tool format (with override support)
-        const currentToolFormat = this.getToolFormat();
-        // Format tools using formatToolsForAPI method
-        const formattedTools = tools ? this.formatToolsForAPI(tools) : undefined;
-        // Get stream_options from ephemeral settings (not model params)
-        const streamOptions = this.providerConfig?.getEphemeralSettings?.()?.['stream-options'];
-        // Default stream_options to { include_usage: true } unless explicitly set
-        const finalStreamOptions = streamOptions !== undefined ? streamOptions : { include_usage: true };
         // Get streaming setting from ephemeral settings (default: enabled)
         const streamingSetting = this.providerConfig?.getEphemeralSettings?.()?.['streaming'];
         const streamingEnabled = streamingSetting !== 'disabled';
-        return {
-            parser,
-            currentToolFormat,
-            formattedTools,
-            finalStreamOptions,
-            streamingEnabled,
+        // Get the system prompt
+        const userMemory = this.globalConfig?.getUserMemory
+            ? this.globalConfig.getUserMemory()
+            : '';
+        const systemPrompt = await getCoreSystemPromptAsync(userMemory, model, undefined);
+        // Add system prompt as the first message in the array
+        const messagesWithSystem = [
+            { role: 'system', content: systemPrompt },
+            ...messages,
+        ];
+        // Build request - only include tools if they exist and are not empty
+        const requestBody = {
+            model,
+            messages: messagesWithSystem,
+            ...(formattedTools && formattedTools.length > 0
+                ? {
+                    tools: formattedTools,
+                    // Add tool_choice for Qwen/Cerebras to ensure proper tool calling
+                    tool_choice: 'auto',
+                }
+                : {}),
+            max_tokens: maxTokens,
+            stream: streamingEnabled,
         };
-    }
-    /**
-     * Execute API call with error handling
-     */
-    async executeApiCall(messages, tools, requestConfig) {
-        // Get resolved authentication and update client if needed
-        await this.updateClientWithResolvedAuth();
-        this.logger.debug(() => `About to make API call with model: ${this.currentModel}, baseURL: ${this.openai.baseURL}, apiKey: ${this.openai.apiKey?.substring(0, 10)}..., streaming: ${requestConfig.streamingEnabled}, messages (${messages.length} total): ${messages
-            .map((m) => `${m.role}${m.role === 'system' ? ` (length: ${m.content?.length})` : ''}`)
-            .join(', ')}`);
-        try {
-            // Build request params with exact order from original
-            return await this.openai.chat.completions.create({
-                model: this.currentModel,
-                messages: messages,
-                stream: requestConfig.streamingEnabled,
-                ...(requestConfig.streamingEnabled && requestConfig.finalStreamOptions
-                    ? { stream_options: requestConfig.finalStreamOptions }
-                    : {}),
-                tools: requestConfig.formattedTools,
-                tool_choice: this.getToolChoiceForFormat(tools),
-                ...this.modelParams,
+        // Debug log request summary for Cerebras/Qwen
+        if (this.logger.enabled &&
+            (model.toLowerCase().includes('qwen') ||
+                this.getBaseURL()?.includes('cerebras'))) {
+            this.logger.debug(() => `Request to ${this.getBaseURL()} for model ${model}:`, {
+                baseURL: this.getBaseURL(),
+                model,
+                streamingEnabled,
+                hasTools: 'tools' in requestBody,
+                toolCount: formattedTools?.length || 0,
+                messageCount: messages.length,
+                toolsInRequest: 'tools' in requestBody ? requestBody.tools?.length : 'not included',
             });
         }
-        catch (error) {
-            this.handleApiError(error, messages);
-            throw error; // Re-throw after logging
-        }
-    }
-    /**
-     * Handle and log API errors
-     */
-    handleApiError(error, messages) {
-        const errorStatus = error?.status ||
-            error?.response?.status;
-        const errorLabel = errorStatus === 400 ? '[API Error 400]' : '[API Error]';
-        this.logger.error(() => `${errorLabel} Error caught in API call:\n` +
-            `  Error: ${error}\n` +
-            `  Type: ${error?.constructor?.name}\n` +
-            `  Status: ${errorStatus}\n` +
-            `  Response data: ${JSON.stringify(error?.response?.data, null, 2)}`);
-        // Log the last few messages to understand what's being sent
-        if (errorStatus === 400) {
-            // Log additional diagnostics for 400 errors
-            const hasPendingToolCalls = messages.some((msg, idx) => {
-                if (msg.role === 'assistant' && msg.tool_calls) {
-                    // Check if there's a matching tool response
-                    const toolCallIds = msg.tool_calls.map((tc) => tc.id);
-                    const hasResponses = toolCallIds.every((id) => messages
-                        .slice(idx + 1)
-                        .some((m) => m.role === 'tool' && m.tool_call_id === id));
-                    return !hasResponses;
+        // Get OpenAI client
+        const client = await this.getClient();
+        // Get retry settings from ephemeral settings
+        const ephemeralSettings = this.providerConfig?.getEphemeralSettings?.() || {};
+        const maxRetries = ephemeralSettings['retries'] ?? 6; // Default for OpenAI
+        const initialDelayMs = ephemeralSettings['retrywait'] ?? 4000; // Default for OpenAI
+        // Wrap the API call with retry logic using centralized retry utility
+        const response = await retryWithBackoff(() => client.chat.completions.create(requestBody, { signal: abortSignal }), {
+            maxAttempts: maxRetries,
+            initialDelayMs,
+            maxDelayMs: 30000, // 30 seconds
+            shouldRetry: this.shouldRetryResponse.bind(this),
+        });
+        // Check if response is streaming or not
+        if (streamingEnabled) {
+            // Process streaming response
+            let _accumulatedText = '';
+            const accumulatedToolCalls = [];
+            // Buffer for accumulating text chunks for providers that need it
+            let textBuffer = '';
+            const detectedFormat = this.detectToolFormat();
+            // Buffer text for Qwen format providers to avoid stanza formatting
+            const shouldBufferText = detectedFormat === 'qwen';
+            try {
+                // Handle streaming response
+                for await (const chunk of response) {
+                    if (abortSignal?.aborted) {
+                        break;
+                    }
+                    const choice = chunk.choices?.[0];
+                    if (!choice)
+                        continue;
+                    // Check for finish_reason to detect proper stream ending
+                    if (choice.finish_reason) {
+                        this.logger.debug(() => `[Streaming] Stream finished with reason: ${choice.finish_reason}`, {
+                            model,
+                            finishReason: choice.finish_reason,
+                            hasAccumulatedText: _accumulatedText.length > 0,
+                            hasAccumulatedTools: accumulatedToolCalls.length > 0,
+                            hasBufferedText: textBuffer.length > 0,
+                        });
+                        // If finish_reason is 'length', the response was cut off
+                        if (choice.finish_reason === 'length') {
+                            this.logger.debug(() => `Response truncated due to length limit for model ${model}`);
+                        }
+                        // Flush any buffered text when stream finishes
+                        if (textBuffer.length > 0) {
+                            yield {
+                                speaker: 'ai',
+                                blocks: [
+                                    {
+                                        type: 'text',
+                                        text: textBuffer,
+                                    },
+                                ],
+                            };
+                            textBuffer = '';
+                        }
+                    }
+                    // Handle text content - buffer for Qwen format, emit immediately for others
+                    const deltaContent = choice.delta?.content;
+                    if (deltaContent) {
+                        _accumulatedText += deltaContent;
+                        // Debug log for providers that need buffering
+                        if (shouldBufferText) {
+                            this.logger.debug(() => `[Streaming] Chunk content for ${detectedFormat} format:`, {
+                                deltaContent,
+                                length: deltaContent.length,
+                                hasNewline: deltaContent.includes('\n'),
+                                escaped: JSON.stringify(deltaContent),
+                                bufferSize: textBuffer.length,
+                            });
+                            // Buffer text to avoid stanza formatting
+                            textBuffer += deltaContent;
+                            // Emit buffered text when we have a complete sentence or paragraph
+                            // Look for natural break points
+                            if (textBuffer.includes('\n') ||
+                                textBuffer.endsWith('. ') ||
+                                textBuffer.endsWith('! ') ||
+                                textBuffer.endsWith('? ') ||
+                                textBuffer.length > 100) {
+                                yield {
+                                    speaker: 'ai',
+                                    blocks: [
+                                        {
+                                            type: 'text',
+                                            text: textBuffer,
+                                        },
+                                    ],
+                                };
+                                textBuffer = '';
+                            }
+                        }
+                        else {
+                            // For other providers, emit text immediately as before
+                            yield {
+                                speaker: 'ai',
+                                blocks: [
+                                    {
+                                        type: 'text',
+                                        text: deltaContent,
+                                    },
+                                ],
+                            };
+                        }
+                    }
+                    // Handle tool calls
+                    const deltaToolCalls = choice.delta?.tool_calls;
+                    if (deltaToolCalls && deltaToolCalls.length > 0) {
+                        for (const deltaToolCall of deltaToolCalls) {
+                            if (deltaToolCall.index === undefined)
+                                continue;
+                            // Initialize or update accumulated tool call
+                            if (!accumulatedToolCalls[deltaToolCall.index]) {
+                                accumulatedToolCalls[deltaToolCall.index] = {
+                                    id: deltaToolCall.id || '',
+                                    type: 'function',
+                                    function: {
+                                        name: deltaToolCall.function?.name || '',
+                                        arguments: '',
+                                    },
+                                };
+                            }
+                            const tc = accumulatedToolCalls[deltaToolCall.index];
+                            if (tc) {
+                                if (deltaToolCall.id)
+                                    tc.id = deltaToolCall.id;
+                                if (deltaToolCall.function?.name)
+                                    tc.function.name = deltaToolCall.function.name;
+                                if (deltaToolCall.function?.arguments) {
+                                    tc.function.arguments += deltaToolCall.function.arguments;
+                                }
+                            }
+                        }
+                    }
                 }
-                return false;
-            });
-            this.logger.error(() => `${errorLabel} Last 5 messages being sent:\n` +
-                `  Has pending tool calls without responses: ${hasPendingToolCalls}`);
-            const lastMessages = messages.slice(-5);
-            lastMessages.forEach((msg, idx) => {
-                this.logger.error(() => `  [${messages.length - 5 + idx}] ${msg.role}${msg.tool_call_id ? ` (tool response for ${msg.tool_call_id})` : ''}${msg.tool_calls ? ` (${msg.tool_calls.length} tool calls)` : ''}`);
-                if (msg.tool_calls) {
-                    msg.tool_calls.forEach((tc) => {
-                        this.logger.error(() => `    - Tool call: ${tc.id} -> ${tc.function.name}`);
-                    });
+            }
+            catch (error) {
+                if (abortSignal?.aborted) {
+                    throw error;
                 }
-            });
-        }
-    }
-    /**
-     * Process non-streaming response
-     */
-    processNonStreamingResponse(response) {
-        const choice = response.choices[0];
-        let fullContent = '';
-        const accumulatedToolCalls = [];
-        let usageData;
-        if (choice?.message.content) {
-            fullContent = choice.message.content;
-        }
-        if (choice?.message.tool_calls) {
-            // Convert tool calls to the standard format
-            for (const toolCall of choice.message.tool_calls) {
-                if (toolCall.type === 'function' && toolCall.function) {
-                    // Don't fix double stringification here - it's handled later in the final processing
-                    accumulatedToolCalls.push({
-                        id: toolCall.id,
-                        type: 'function',
-                        function: toolCall.function,
-                    });
+                else {
+                    this.logger.error('Error processing streaming response:', error);
+                    throw error;
                 }
             }
-        }
-        if (response.usage) {
-            usageData = {
-                prompt_tokens: response.usage.prompt_tokens,
-                completion_tokens: response.usage.completion_tokens,
-                total_tokens: response.usage.total_tokens,
-            };
-        }
-        return {
-            fullContent,
-            accumulatedToolCalls,
-            hasStreamedContent: false, // Non-streaming never has streamed content
-            usageData,
-            pendingWhitespace: null,
-        };
-    }
-    /**
-     * Process and build final response messages
-     */
-    *processFinalResponse(processedData, parser) {
-        const { fullContent, accumulatedToolCalls, hasStreamedContent, usageData, pendingWhitespace, } = processedData;
-        // Flush any remaining pending whitespace for Qwen
-        let finalFullContent = fullContent;
-        if (pendingWhitespace && this.isUsingQwen() && !parser) {
-            this.logger.debug(() => `Flushing trailing pending whitespace (len=${pendingWhitespace?.length ?? 0}) at stream end`);
-            finalFullContent += pendingWhitespace;
-        }
-        // After stream ends, parse text-based tool calls if needed
-        if (parser && finalFullContent) {
-            const { cleanedContent, toolCalls } = parser.parse(finalFullContent);
-            if (toolCalls.length > 0) {
-                // Convert to standard format
-                const standardToolCalls = toolCalls.map((tc, index) => ({
-                    id: `call_${Date.now()}_${index}`,
-                    type: 'function',
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.arguments),
-                    },
-                }));
+            // Flush any remaining buffered text
+            if (textBuffer.length > 0) {
                 yield {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: cleanedContent,
-                    tool_calls: standardToolCalls,
-                    usage: usageData,
+                    speaker: 'ai',
+                    blocks: [
+                        {
+                            type: 'text',
+                            text: textBuffer,
+                        },
+                    ],
                 };
+                textBuffer = '';
             }
-            else {
-                // No tool calls found, yield cleaned content
-                yield {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: cleanedContent,
-                    usage: usageData,
-                };
+            // Emit accumulated tool calls as IContent if any
+            if (accumulatedToolCalls.length > 0) {
+                const blocks = [];
+                const detectedFormat = this.detectToolFormat();
+                for (const tc of accumulatedToolCalls) {
+                    if (!tc)
+                        continue;
+                    // Process tool parameters with double-escape handling
+                    const processedParameters = processToolParameters(tc.function.arguments || '', tc.function.name || '', detectedFormat);
+                    blocks.push({
+                        type: 'tool_call',
+                        id: this.normalizeToHistoryToolId(tc.id),
+                        name: tc.function.name || '',
+                        parameters: processedParameters,
+                    });
+                }
+                if (blocks.length > 0) {
+                    yield {
+                        speaker: 'ai',
+                        blocks,
+                    };
+                }
             }
         }
         else {
-            // Standard OpenAI tool call handling
-            if (accumulatedToolCalls.length > 0) {
-                // Process tool calls with Qwen-specific fixes if needed
-                const fixedToolCalls = this.processQwenToolCalls(accumulatedToolCalls);
-                if (this.isUsingQwen()) {
-                    this.logger.debug(() => `Final message with tool calls: ${JSON.stringify({
-                        contentLength: finalFullContent.length,
-                        content: finalFullContent.substring(0, 200) +
-                            (finalFullContent.length > 200 ? '...' : ''),
-                        toolCallCount: accumulatedToolCalls.length,
-                        hasStreamedContent,
-                    })}`);
+            // Handle non-streaming response
+            const completion = response;
+            const choice = completion.choices?.[0];
+            if (!choice) {
+                throw new Error('No choices in completion response');
+            }
+            const blocks = [];
+            // Handle text content
+            if (choice.message?.content) {
+                blocks.push({
+                    type: 'text',
+                    text: choice.message.content,
+                });
+            }
+            // Handle tool calls
+            if (choice.message?.tool_calls && choice.message.tool_calls.length > 0) {
+                const detectedFormat = this.detectToolFormat();
+                for (const toolCall of choice.message.tool_calls) {
+                    if (toolCall.type === 'function') {
+                        // Process tool parameters with double-escape handling
+                        const processedParameters = processToolParameters(toolCall.function.arguments || '', toolCall.function.name || '', detectedFormat);
+                        blocks.push({
+                            type: 'tool_call',
+                            id: this.normalizeToHistoryToolId(toolCall.id),
+                            name: toolCall.function.name || '',
+                            parameters: processedParameters,
+                        });
+                    }
                 }
-                // Build the final message based on provider-specific requirements
-                const finalMessage = this.buildFinalToolCallMessage(hasStreamedContent, finalFullContent, fixedToolCalls, usageData);
-                yield finalMessage;
             }
-            else if (usageData) {
-                // Always emit usage data so downstream consumers can update stats
+            // Emit the complete response as a single IContent
+            if (blocks.length > 0) {
                 yield {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: '',
-                    usage: usageData,
+                    speaker: 'ai',
+                    blocks,
                 };
             }
         }
     }
     /**
-     * Handle Qwen-specific whitespace buffering during streaming
-     * @param delta The stream delta containing content
-     * @param pendingWhitespace Current buffered whitespace
-     * @param fullContent Accumulated full content
-     * @returns Object with updated state and whether to yield content
+     * Detects the tool call format based on the model being used
+     * @returns The detected tool format ('openai' or 'qwen')
      */
-    handleQwenStreamingWhitespace(delta, pendingWhitespace, fullContent) {
-        if (!delta.content) {
-            return {
-                shouldYield: false,
-                content: '',
-                updatedPendingWhitespace: pendingWhitespace,
-                updatedFullContent: fullContent,
-            };
+    detectToolFormat() {
+        try {
+            // Try to get format from SettingsService if available
+            const settings = this.providerConfig?.getEphemeralSettings?.();
+            if (settings && settings['tool-format']) {
+                return settings['tool-format'];
+            }
         }
-        const isWhitespaceOnly = delta.content.trim() === '';
-        if (isWhitespaceOnly) {
-            // Buffer whitespace-only chunk
-            const newPendingWhitespace = (pendingWhitespace || '') + delta.content;
-            this.logger.debug(() => `[Whitespace Buffering] Buffered whitespace-only chunk (len=${delta.content?.length ?? 0}). pendingWhitespace now len=${newPendingWhitespace?.length ?? 0}`);
-            return {
-                shouldYield: false,
-                content: '',
-                updatedPendingWhitespace: newPendingWhitespace,
-                updatedFullContent: fullContent + delta.content,
-            };
+        catch (error) {
+            this.logger.debug(() => `Failed to detect tool format from SettingsService: ${error}`);
         }
-        // Non-whitespace content - flush any pending whitespace first
-        if (pendingWhitespace) {
-            this.logger.debug(() => `Flushing pending whitespace (len=${pendingWhitespace?.length ?? 0}) before non-empty chunk`);
-            return {
-                shouldYield: true,
-                content: pendingWhitespace + delta.content,
-                updatedPendingWhitespace: null,
-                updatedFullContent: fullContent + pendingWhitespace + delta.content,
-            };
+        // Fallback detection without SettingsService - always look up current model
+        const modelName = (this.getModel() || this.getDefaultModel()).toLowerCase();
+        if (modelName.includes('glm-4.5') || modelName.includes('glm-4-5')) {
+            return 'qwen';
         }
-        return {
-            shouldYield: true,
-            content: delta.content,
-            updatedPendingWhitespace: null,
-            updatedFullContent: fullContent + delta.content,
-        };
-    }
-    /**
-     * Process tool calls for Qwen models, fixing double stringification
-     * @param toolCalls The tool calls to process
-     * @returns Processed tool calls with fixes applied
-     */
-    processQwenToolCalls(toolCalls) {
-        if (!this.isUsingQwen()) {
-            return toolCalls;
+        if (modelName.includes('qwen')) {
+            return 'qwen';
         }
-        this.logger.debug(() => `[Qwen Fix] Processing ${toolCalls.length} tool calls for double-stringification fix`);
-        return toolCalls.map((toolCall, index) => {
-            this.logger.debug(() => `[Qwen Fix] Tool call ${index}: ${JSON.stringify({
-                name: toolCall.function.name,
-                argumentsType: typeof toolCall.function.arguments,
-                argumentsLength: toolCall.function.arguments?.length,
-                argumentsSample: toolCall.function.arguments?.substring(0, 100),
-            })}`);
-            return this.fixQwenDoubleStringification(toolCall);
-        });
+        return 'openai';
     }
     /**
-     * Determine how to yield the final message with tool calls based on provider quirks
-     * @param hasStreamedContent Whether content was already streamed
-     * @param fullContent The complete content
-     * @param toolCalls The tool calls to include
-     * @param usageData Optional usage statistics
-     * @returns The message to yield
+     * Parse tool response from API (placeholder for future response parsing)
+     * @param response The raw API response
+     * @returns Parsed tool response
      */
-    buildFinalToolCallMessage(hasStreamedContent, fullContent, toolCalls, usageData) {
-        const isCerebras = this.baseURL?.toLowerCase().includes('cerebras.ai');
-        if (isCerebras) {
-            this.logger.debug(() => '[Cerebras] Special handling for Cerebras provider after tool responses', {
-                hasStreamedContent,
-                willSendSpace: hasStreamedContent,
-            });
-        }
-        const shouldOmitContent = hasStreamedContent && this.isUsingQwen() && !isCerebras;
-        this.logger.debug(() => '[Tool Call Handling] Deciding how to yield tool calls', {
-            hasStreamedContent,
-            isUsingQwen: this.isUsingQwen(),
-            isCerebras,
-            shouldOmitContent,
-            fullContentLength: fullContent.length,
-            toolCallCount: toolCalls?.length || 0,
-        });
-        if (shouldOmitContent || (isCerebras && hasStreamedContent)) {
-            // Send just a space to prevent stream stopping or duplication
-            if (isCerebras && hasStreamedContent) {
-                this.logger.debug(() => '[Cerebras] Sending minimal space content to prevent duplication');
-            }
-            return {
-                role: ContentGeneratorRole.ASSISTANT,
-                content: ' ',
-                tool_calls: toolCalls,
-                usage: usageData,
-            };
-        }
-        // Include full content with tool calls
-        return {
-            role: ContentGeneratorRole.ASSISTANT,
-            content: fullContent || '',
-            tool_calls: toolCalls,
-            usage: usageData,
-        };
+    parseToolResponse(response) {
+        // TODO: Implement response parsing based on detected format
+        // For now, return the response as-is
+        return response;
     }
     /**
-     * Fix Qwen's double stringification of tool call arguments
-     * Qwen models stringify array/object values WITHIN the JSON arguments
-     * @param toolCall The tool call to fix
-     * @returns The fixed tool call or the original if no fix is needed
+     * Determines whether a response should be retried based on error codes
+     * @param error The error object from the API response
+     * @returns true if the request should be retried, false otherwise
      */
-    fixQwenDoubleStringification(toolCall) {
-        if (!toolCall.function.arguments ||
-            typeof toolCall.function.arguments !== 'string') {
-            return toolCall;
-        }
-        try {
-            // First, parse the arguments to get the JSON object
-            const parsedArgs = JSON.parse(toolCall.function.arguments);
-            let hasNestedStringification = false;
-            // Check each property to see if it's a stringified array/object/number
-            const fixedArgs = {};
-            for (const [key, value] of Object.entries(parsedArgs)) {
-                if (typeof value === 'string') {
-                    const trimmed = value.trim();
-                    // Check if it's a stringified number (integer or float)
-                    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
-                        const numValue = trimmed.includes('.')
-                            ? parseFloat(trimmed)
-                            : parseInt(trimmed, 10);
-                        fixedArgs[key] = numValue;
-                        hasNestedStringification = true;
-                        this.logger.debug(() => `[Qwen Fix] Fixed stringified number in property '${key}' for ${toolCall.function.name}: "${value}" -> ${numValue}`);
-                    }
-                    // Check if it looks like a stringified array or object
-                    // Also check for Python-style dictionaries with single quotes
-                    else if ((trimmed.startsWith('[') && trimmed.endsWith(']')) ||
-                        (trimmed.startsWith('{') && trimmed.endsWith('}'))) {
-                        try {
-                            // Try to parse it as JSON
-                            const nestedParsed = JSON.parse(value);
-                            fixedArgs[key] = nestedParsed;
-                            hasNestedStringification = true;
-                            this.logger.debug(() => `[Qwen Fix] Fixed nested stringification in property '${key}' for ${toolCall.function.name}`);
-                        }
-                        catch {
-                            // Try to convert Python-style to JSON (single quotes to double quotes)
-                            try {
-                                const jsonified = value
-                                    .replace(/'/g, '"')
-                                    .replace(/: True/g, ': true')
-                                    .replace(/: False/g, ': false')
-                                    .replace(/: None/g, ': null');
-                                const nestedParsed = JSON.parse(jsonified);
-                                fixedArgs[key] = nestedParsed;
-                                hasNestedStringification = true;
-                                this.logger.debug(() => `[Qwen Fix] Fixed Python-style nested stringification in property '${key}' for ${toolCall.function.name}`);
-                            }
-                            catch {
-                                // Not valid JSON even after conversion, keep as string
-                                fixedArgs[key] = value;
-                            }
-                        }
-                    }
-                    else {
-                        fixedArgs[key] = value;
-                    }
-                }
-                else {
-                    fixedArgs[key] = value;
-                }
-            }
-            if (hasNestedStringification) {
-                this.logger.debug(() => `[Qwen Fix] Fixed nested double-stringification for ${toolCall.function.name}`);
-                return {
-                    ...toolCall,
-                    function: {
-                        ...toolCall.function,
-                        arguments: JSON.stringify(fixedArgs),
-                    },
-                };
-            }
-        }
-        catch (_e) {
-            // If parsing fails, check for old-style double-stringification
-            if (toolCall.function.arguments.startsWith('"') &&
-                toolCall.function.arguments.endsWith('"')) {
-                try {
-                    // Old fix: entire arguments were double-stringified
-                    const parsedArgs = JSON.parse(toolCall.function.arguments);
-                    this.logger.debug(() => `[Qwen Fix] Fixed whole-argument double-stringification for ${toolCall.function.name}`);
-                    return {
-                        ...toolCall,
-                        function: {
-                            ...toolCall.function,
-                            arguments: JSON.stringify(parsedArgs),
-                        },
-                    };
-                }
-                catch {
-                    // Leave as-is if we can't parse
-                }
-            }
+    shouldRetryResponse(error) {
+        // Don't retry if we're streaming chunks - just continue processing
+        if (error &&
+            typeof error === 'object' &&
+            'status' in error &&
+            error.status === 200) {
+            return false;
         }
-        // No fix needed
-        this.logger.debug(() => `[Qwen Fix] No double-stringification detected for ${toolCall.function.name}, keeping original`);
-        return toolCall;
+        // Retry on 429 rate limit errors or 5xx server errors
+        const shouldRetry = Boolean(error &&
+            typeof error === 'object' &&
+            'status' in error &&
+            (error.status === 429 ||
+                (error.status >= 500 &&
+                    error.status < 600)));
+        return shouldRetry;
     }
 }
 //# sourceMappingURL=OpenAIProvider.js.map