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

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

@@ -18,13 +18,12 @@
  * @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 { BaseProvider } from '../BaseProvider.js';
 import { isQwenEndpoint, generateOAuthEndpointMismatchError, } from '../../config/endpoints.js';
 import { getSettingsService } from '../../settings/settingsServiceInstance.js';
+import { retryWithBackoff } from '../../utils/retry.js';
 export class OpenAIProvider extends BaseProvider {
     logger;
     openai;
@@ -68,7 +67,7 @@ export class OpenAIProvider extends BaseProvider {
         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.baseURL = baseURL || 'https://api.openai.com/v1';
         this.providerConfig = config;
         this.toolFormatter = new ToolFormatter();
         // Initialize from SettingsService
@@ -170,19 +169,6 @@ export class OpenAIProvider extends BaseProvider {
             }
         }
     }
-    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)) {
-            return true;
-        }
-        const configuredModels = this.providerConfig?.textToolCallModels || [];
-        return configuredModels.includes(this.currentModel);
-    }
     getToolFormat() {
         // Check manual override first
         if (this.toolFormatOverride) {
@@ -275,124 +261,6 @@ export class OpenAIProvider extends BaseProvider {
             ];
         }
     }
-    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) => {
@@ -444,8 +312,9 @@ export class OpenAIProvider extends BaseProvider {
         this._cachedClientKey = apiKey; // Update cached key
     }
     setBaseUrl(baseUrl) {
-        // If no baseUrl is provided, clear to default (undefined)
-        this.baseURL = baseUrl && baseUrl.trim() !== '' ? baseUrl : undefined;
+        // If no baseUrl is provided, use default OpenAI URL
+        this.baseURL =
+            baseUrl && baseUrl.trim() !== '' ? baseUrl : 'https://api.openai.com/v1';
         // Persist to SettingsService if available
         this.setBaseUrlInSettings(this.baseURL).catch((error) => {
             this.logger.debug(() => `Failed to persist base URL to SettingsService: ${error}`);
@@ -522,6 +391,220 @@ export class OpenAIProvider extends BaseProvider {
     getModelParams() {
         return this.modelParams;
     }
+    /**
+     * Generate chat completion with IContent interface
+     * Internally converts to OpenAI API format, but only yields IContent
+     */
+    async *generateChatCompletion(content, tools) {
+        // Convert IContent directly to OpenAI API format (no IMessage!)
+        const apiMessages = [];
+        for (const c of content) {
+            if (c.speaker === 'human') {
+                const textBlock = c.blocks.find((b) => b.type === 'text');
+                apiMessages.push({
+                    role: 'user',
+                    content: textBlock?.text || '',
+                });
+            }
+            else if (c.speaker === 'ai') {
+                const textBlocks = c.blocks.filter((b) => b.type === 'text');
+                const toolCallBlocks = c.blocks.filter((b) => b.type === 'tool_call');
+                const contentText = textBlocks.map((b) => b.text).join('');
+                const toolCalls = toolCallBlocks.length > 0
+                    ? toolCallBlocks.map((tc) => ({
+                        id: tc.id,
+                        type: 'function',
+                        function: {
+                            name: tc.name,
+                            arguments: JSON.stringify(tc.parameters),
+                        },
+                    }))
+                    : undefined;
+                apiMessages.push({
+                    role: 'assistant',
+                    content: contentText || null,
+                    tool_calls: toolCalls,
+                });
+            }
+            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');
+                }
+                apiMessages.push({
+                    role: 'tool',
+                    content: JSON.stringify(toolResponseBlock.result),
+                    tool_call_id: toolResponseBlock.callId,
+                });
+            }
+            else {
+                throw new Error(`Unknown speaker type: ${c.speaker}`);
+            }
+        }
+        // Debug log the converted messages
+        this.logger.debug(() => `Converted messages for OpenAI API: ${JSON.stringify(apiMessages, null, 2)}`);
+        // Convert Gemini format tools to OpenAI format
+        // Handle both legacy 'parameters' and new 'parametersJsonSchema' formats
+        const apiTools = tools
+            ? tools[0].functionDeclarations.map((decl) => {
+                // Support both old 'parameters' and new 'parametersJsonSchema' formats
+                // DeclarativeTool uses parametersJsonSchema, while legacy tools use parameters
+                const toolParameters = 'parametersJsonSchema' in decl
+                    ? decl
+                        .parametersJsonSchema
+                    : decl.parameters;
+                return {
+                    type: 'function',
+                    function: {
+                        name: decl.name,
+                        description: decl.description || '',
+                        parameters: toolParameters || {},
+                    },
+                };
+            })
+            : undefined;
+        // Get auth token
+        const apiKey = await this.getAuthToken();
+        if (!apiKey) {
+            throw new Error('OpenAI API key is required');
+        }
+        // Build request
+        const requestBody = {
+            model: this.currentModel || 'gpt-4o-mini',
+            messages: apiMessages,
+            ...(apiTools && { tools: apiTools }),
+            stream: true,
+            ...(this.modelParams || {}),
+        };
+        // Wrap the API call with retry logic
+        const makeApiCall = async () => {
+            const response = await fetch(`${this.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                // Create an error object that matches what we check for in isRetryableError
+                const error = new Error(`OpenAI API error: ${errorText}`);
+                error.status = response.status;
+                // Try to parse the error response
+                try {
+                    const errorObj = JSON.parse(errorText);
+                    error.error = errorObj;
+                }
+                catch {
+                    // If not JSON, keep as text
+                }
+                this.logger.debug(() => `API call error in generateChatCompletion: status=${response.status}, error=${errorText}`);
+                throw error;
+            }
+            return response;
+        };
+        // Use retry logic with longer delays for rate limits
+        const response = await retryWithBackoff(makeApiCall, {
+            shouldRetry: (error) => {
+                const shouldRetry = this.isRetryableError(error);
+                this.logger.debug(() => `Retry decision in generateChatCompletion: shouldRetry=${shouldRetry}, error=${String(error).substring(0, 200)}`);
+                return shouldRetry;
+            },
+            maxAttempts: 6, // Allow up to 6 attempts (initial + 5 retries)
+            initialDelayMs: 4000, // Start with 4 seconds for 429 errors
+            maxDelayMs: 65000, // Allow up to 65 seconds delay
+        });
+        // Parse streaming response and emit IContent
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const accumulatedToolCalls = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data: '))
+                    continue;
+                const data = line.slice(6);
+                if (data === '[DONE]')
+                    continue;
+                try {
+                    const parsed = JSON.parse(data);
+                    const delta = parsed.choices?.[0]?.delta;
+                    if (delta?.content) {
+                        // Emit text content immediately as IContent
+                        yield {
+                            speaker: 'ai',
+                            blocks: [{ type: 'text', text: delta.content }],
+                        };
+                    }
+                    if (delta?.tool_calls) {
+                        // Accumulate tool calls
+                        for (const toolCall of delta.tool_calls) {
+                            if (toolCall.index !== undefined) {
+                                if (!accumulatedToolCalls[toolCall.index]) {
+                                    accumulatedToolCalls[toolCall.index] = {
+                                        id: toolCall.id || '',
+                                        type: 'function',
+                                        function: { name: '', arguments: '' },
+                                    };
+                                }
+                                const tc = accumulatedToolCalls[toolCall.index];
+                                if (toolCall.id)
+                                    tc.id = toolCall.id;
+                                if (toolCall.function?.name)
+                                    tc.function.name = toolCall.function.name;
+                                if (toolCall.function?.arguments)
+                                    tc.function.arguments += toolCall.function.arguments;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    // Skip invalid JSON lines
+                    this.logger.debug(() => `Failed to parse SSE line: ${e}`);
+                }
+            }
+        }
+        // Emit accumulated tool calls as IContent if any
+        if (accumulatedToolCalls.length > 0) {
+            const blocks = [];
+            for (const tc of accumulatedToolCalls) {
+                if (!tc)
+                    continue;
+                try {
+                    blocks.push({
+                        type: 'tool_call',
+                        id: tc.id,
+                        name: tc.function.name,
+                        parameters: JSON.parse(tc.function.arguments),
+                    });
+                }
+                catch (_e) {
+                    // If parsing fails, emit with string parameters
+                    blocks.push({
+                        type: 'tool_call',
+                        id: tc.id,
+                        name: tc.function.name,
+                        parameters: tc.function.arguments,
+                    });
+                }
+            }
+            if (blocks.length > 0) {
+                yield {
+                    speaker: 'ai',
+                    blocks,
+                };
+            }
+        }
+    }
     /**
      * Initialize provider configuration from SettingsService
      */
@@ -535,7 +618,7 @@ export class OpenAIProvider extends BaseProvider {
             // Load saved base URL if available
             const savedBaseUrl = await this.getBaseUrlFromSettings();
             if (savedBaseUrl !== undefined) {
-                this.baseURL = savedBaseUrl;
+                this.baseURL = savedBaseUrl || 'https://api.openai.com/v1';
             }
             // Load saved model parameters if available
             const savedParams = await this.getModelParamsFromSettings();
@@ -597,19 +680,6 @@ export class OpenAIProvider extends BaseProvider {
             return 'openai';
         }
     }
-    /**
-     * 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
@@ -641,438 +711,63 @@ export class OpenAIProvider extends BaseProvider {
         return response;
     }
     /**
-     * Validate authentication and message preconditions for API calls
-     */
-    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.`);
-        }
-    }
-    /**
-     * 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,
-        };
-    }
-    /**
-     * 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,
-            });
-        }
-        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;
-                }
-                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}`);
-                    });
-                }
-            });
-        }
-    }
-    /**
-     * 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,
-                    });
-                }
-            }
-        }
-        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),
-                    },
-                }));
-                yield {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: cleanedContent,
-                    tool_calls: standardToolCalls,
-                    usage: usageData,
-                };
-            }
-            else {
-                // No tool calls found, yield cleaned content
-                yield {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: cleanedContent,
-                    usage: usageData,
-                };
-            }
-        }
-        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,
-                    })}`);
-                }
-                // 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
-                yield {
-                    role: ContentGeneratorRole.ASSISTANT,
-                    content: '',
-                    usage: usageData,
-                };
-            }
-        }
-    }
-    /**
-     * 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
+     * Determines if an error should trigger a retry
      */
-    handleQwenStreamingWhitespace(delta, pendingWhitespace, fullContent) {
-        if (!delta.content) {
-            return {
-                shouldYield: false,
-                content: '',
-                updatedPendingWhitespace: pendingWhitespace,
-                updatedFullContent: fullContent,
-            };
-        }
-        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,
-            };
-        }
-        // 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,
-            };
-        }
-        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;
-        }
-        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);
-        });
-    }
-    /**
-     * 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
-     */
-    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');
+    isRetryableError(error) {
+        // Check for OpenAI SDK specific error types
+        // The OpenAI SDK throws specific error classes for different error types
+        if (error && typeof error === 'object') {
+            const errorName = error.constructor?.name;
+            // Check for OpenAI SDK RateLimitError or InternalServerError
+            if (errorName === 'RateLimitError' ||
+                errorName === 'InternalServerError') {
+                this.logger.debug(() => `Retryable OpenAI SDK error detected: ${errorName}`);
+                return true;
             }
-            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,
-        };
-    }
-    /**
-     * 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
-     */
-    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;
-                    }
+            // Check for status property (OpenAI APIError has a status property)
+            if ('status' in error) {
+                const status = error.status;
+                // Retry on 429 (rate limit) and 5xx errors
+                if (status === 429 || (status >= 500 && status < 600)) {
+                    this.logger.debug(() => `Retryable error detected - status: ${status}`);
+                    return true;
                 }
-                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
+            // Check for nested error object (some OpenAI errors have error.error structure)
+            if ('error' in error &&
+                typeof error.error === 'object') {
+                const nestedError = error.error;
+                if (nestedError?.code === 'token_quota_exceeded' ||
+                    nestedError?.type === 'too_many_tokens_error' ||
+                    nestedError?.code === 'rate_limit_exceeded') {
+                    this.logger.debug(() => `Retryable error detected from error code: ${nestedError.code || nestedError.type}`);
+                    return true;
                 }
             }
         }
-        // No fix needed
-        this.logger.debug(() => `[Qwen Fix] No double-stringification detected for ${toolCall.function.name}, keeping original`);
-        return toolCall;
+        // Check error message for rate limit indicators
+        const errorMessage = String(error).toLowerCase();
+        const retryablePatterns = [
+            'rate limit',
+            'rate_limit',
+            'quota_exceeded',
+            'too_many_tokens',
+            'too many requests',
+            '429',
+            'overloaded',
+            'server_error',
+            'service_unavailable',
+            'internal server error',
+            '500',
+            '502',
+            '503',
+            '504',
+        ];
+        const shouldRetry = retryablePatterns.some((pattern) => errorMessage.includes(pattern));
+        if (shouldRetry) {
+            this.logger.debug(() => `Retryable error detected from message pattern: ${errorMessage}`);
+        }
+        return shouldRetry;
     }
 }
 //# sourceMappingURL=OpenAIProvider.js.map