@vybestack/llxprt-code-core 0.1.21 → 0.1.23

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

@@ -13,6 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * @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';
@@ -27,8 +32,9 @@ import { BaseProvider } from '../BaseProvider.js';
 import { isQwenEndpoint, generateOAuthEndpointMismatchError, } from '../../config/endpoints.js';
 import { getSettingsService } from '../../settings/settingsServiceInstance.js';
 export class OpenAIProvider extends BaseProvider {
+    logger;
     openai;
-    currentModel = process.env.LLXPRT_DEFAULT_MODEL || 'llama3-70b-8192';
+    currentModel = process.env.LLXPRT_DEFAULT_MODEL || 'gpt-5';
     baseURL;
     providerConfig;
     toolFormatter;
@@ -40,13 +46,22 @@ export class OpenAIProvider extends BaseProvider {
     constructor(apiKey, baseURL, config, oauthManager) {
         // Initialize base provider with auth configuration
         // Check if we should enable OAuth for Qwen
-        // Enable OAuth if: 1) we have an oauth manager, and 2) either the baseURL is a Qwen endpoint OR no baseURL/apiKey is provided
-        const shouldEnableQwenOAuth = !!oauthManager &&
-            (isQwenEndpoint(baseURL || '') ||
-                (!baseURL && (!apiKey || apiKey === '')) ||
-                baseURL === 'https://portal.qwen.ai/v1');
-        if (process.env.DEBUG) {
-            console.log(`[OpenAI Constructor] baseURL: ${baseURL}, apiKey: ${apiKey?.substring(0, 10) || 'none'}, oauthManager: ${!!oauthManager}, shouldEnableQwenOAuth: ${shouldEnableQwenOAuth}`);
+        // 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 = {
             name: 'openai',
@@ -59,15 +74,15 @@ export class OpenAIProvider extends BaseProvider {
             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;
         this.toolFormatter = new ToolFormatter();
         this.conversationCache = new ConversationCache();
         // Initialize from SettingsService
         this.initializeFromSettings().catch((error) => {
-            if (process.env.DEBUG) {
-                console.warn('Failed to initialize OpenAI provider from SettingsService:', error);
-            }
+            this.logger.debug(() => `Failed to initialize from SettingsService: ${error}`);
         });
         // Set appropriate default model based on the provider
         if (shouldEnableQwenOAuth || isQwenEndpoint(baseURL || '')) {
@@ -127,25 +142,18 @@ export class OpenAIProvider extends BaseProvider {
         }
         // Check if we're using Qwen OAuth and need to update the baseURL
         let effectiveBaseURL = this.baseURL;
-        // Debug logging
-        if (process.env.DEBUG) {
-            console.log(`[OpenAI] updateClientWithResolvedAuth - OAuth enabled: ${this.isOAuthEnabled()}, OAuth provider: ${this.baseProviderConfig.oauthProvider}, baseURL: ${this.baseURL}, resolvedKey: ${resolvedKey?.substring(0, 10)}...`);
-        }
+        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');
-                if (process.env.DEBUG) {
-                    console.log(`[OpenAI] OAuth token retrieved, resource_url: ${oauthToken?.resource_url}, access_token: ${oauthToken?.access_token?.substring(0, 10)}...`);
-                }
+                this.logger.debug(() => `OAuth token retrieved, resource_url: ${oauthToken?.resource_url}, 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`;
-                    if (process.env.DEBUG) {
-                        console.log(`[OpenAI] Using Qwen OAuth endpoint: ${effectiveBaseURL}`);
-                    }
+                    this.logger.debug(() => `Using Qwen OAuth endpoint: ${effectiveBaseURL}`);
                 }
             }
         }
@@ -236,11 +244,7 @@ export class OpenAIProvider extends BaseProvider {
             const contextInfo = this.estimateContextUsage(options.conversationId, options.parentId, messages);
             // Warn if less than 4k tokens remaining
             if (contextInfo.tokensRemaining < 4000) {
-                if (process.env.DEBUG) {
-                    console.warn(`[OpenAI] Warning: Only ${contextInfo.tokensRemaining} tokens remaining ` +
-                        `(${contextInfo.contextUsedPercent.toFixed(1)}% context used). ` +
-                        `Consider starting a new conversation.`);
-                }
+                this.logger.debug(() => `Warning: Only ${contextInfo.tokensRemaining} tokens remaining (${contextInfo.contextUsedPercent.toFixed(1)}% context used). Consider starting a new conversation.`);
             }
         }
         // Check cache for existing conversation
@@ -295,9 +299,7 @@ export class OpenAIProvider extends BaseProvider {
             // Handle 422 context_length_exceeded error
             if (response.status === 422 &&
                 errorBody.includes('context_length_exceeded')) {
-                if (process.env.DEBUG) {
-                    console.warn('[OpenAI] Context length exceeded, invalidating cache and retrying stateless...');
-                }
+                this.logger.debug(() => 'Context length exceeded, invalidating cache and retrying stateless...');
                 // Invalidate the cache for this conversation
                 if (options?.conversationId && options?.parentId) {
                     this.conversationCache.invalidate(options.conversationId, options.parentId);
@@ -377,6 +379,49 @@ export class OpenAIProvider extends BaseProvider {
         }
         const data = (await response.json());
         const resultMessages = [];
+        // DEFENSIVE FIX: Handle potential array response from providers that violate OpenAI spec
+        // Some providers (like Cerebras) may return an array of responses instead of a single response
+        if (Array.isArray(data)) {
+            this.logger.error(() => '[Cerebras Corruption] Detected malformed array response from provider, aggregating...', {
+                provider: this.baseURL,
+                arrayLength: data.length,
+            });
+            const aggregatedContent = [];
+            let aggregatedToolCalls = [];
+            let aggregatedUsage = undefined;
+            for (const item of data) {
+                if (item.choices?.[0]?.message?.content) {
+                    aggregatedContent.push(item.choices[0].message.content);
+                }
+                if (item.choices?.[0]?.message?.tool_calls) {
+                    aggregatedToolCalls = item.choices[0].message.tool_calls;
+                }
+                if (item.usage) {
+                    aggregatedUsage = item.usage;
+                }
+            }
+            const message = {
+                role: ContentGeneratorRole.ASSISTANT,
+                content: aggregatedContent.join(''),
+            };
+            if (aggregatedToolCalls.length > 0) {
+                message.tool_calls = aggregatedToolCalls;
+            }
+            if (aggregatedUsage) {
+                message.usage = {
+                    prompt_tokens: aggregatedUsage.prompt_tokens || 0,
+                    completion_tokens: aggregatedUsage.completion_tokens || 0,
+                    total_tokens: aggregatedUsage.total_tokens || 0,
+                };
+            }
+            resultMessages.push(message);
+            // Convert to async iterator for consistent return type
+            return (async function* () {
+                for (const msg of resultMessages) {
+                    yield msg;
+                }
+            })();
+        }
         if (data.choices && data.choices.length > 0) {
             const choice = data.choices[0];
             const message = {
@@ -441,9 +486,7 @@ export class OpenAIProvider extends BaseProvider {
             return models;
         }
         catch (error) {
-            if (process.env.DEBUG) {
-                console.error('Error fetching models from OpenAI:', 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 || '')) {
@@ -509,15 +552,32 @@ export class OpenAIProvider extends BaseProvider {
             });
             return;
         }
+        // Fix messages in place like AnthropicProvider does - this ensures synthetic responses persist
+        // This is critical for preventing 400 errors on subsequent calls with Qwen/Cerebras
+        const missingToolIds = this.identifyAndFixMissingToolResponses(messages);
+        if (missingToolIds.length > 0) {
+            this.logger.debug(() => `[Synthetic] Added ${missingToolIds.length} synthetic responses to conversation history: ${JSON.stringify(missingToolIds)}`);
+            // Log the actual tool calls and their IDs for debugging
+            const assistantMessagesWithTools = messages.filter((m) => m.role === 'assistant' && m.tool_calls && m.tool_calls.length > 0);
+            const lastAssistantWithTools = assistantMessagesWithTools[assistantMessagesWithTools.length - 1];
+            if (lastAssistantWithTools?.tool_calls) {
+                this.logger.debug(() => `[Synthetic] Last assistant tool calls: ${JSON.stringify(lastAssistantWithTools.tool_calls?.map((tc) => ({ id: tc.id, name: tc.function.name })) ?? [])}`);
+            }
+        }
+        // Now messages array has been modified in place with synthetic responses
+        const patchedMessages = messages;
         // Validate tool messages have required tool_call_id
-        const toolMessages = messages.filter((msg) => msg.role === 'tool');
+        const toolMessages = patchedMessages.filter((msg) => msg.role === 'tool');
         const missingIds = toolMessages.filter((msg) => !msg.tool_call_id);
         if (missingIds.length > 0) {
-            if (process.env.DEBUG) {
-                console.error('[OpenAIProvider] FATAL: Tool messages missing tool_call_id:', missingIds);
-            }
+            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.`);
         }
+        // Log synthetic responses for debugging
+        const syntheticMessages = patchedMessages.filter((msg) => msg._synthetic);
+        if (syntheticMessages.length > 0) {
+            this.logger.debug(() => `[Synthetic] Added ${syntheticMessages.length} synthetic tool responses`);
+        }
         const parser = this.requiresTextToolCallParsing()
             ? new GemmaToolCallParser()
             : null;
@@ -529,94 +589,389 @@ export class OpenAIProvider extends BaseProvider {
         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'];
+        let streamingEnabled = streamingSetting !== 'disabled';
         // Get resolved authentication and update client if needed
         await this.updateClientWithResolvedAuth();
-        if (process.env.DEBUG) {
-            console.log(`[OpenAI] About to make API call with model: ${this.currentModel}, baseURL: ${this.openai.baseURL}, apiKey: ${this.openai.apiKey?.substring(0, 10)}...`);
-        }
-        // Build request params with exact order from original
-        const stream = await this.openai.chat.completions.create({
-            model: this.currentModel,
-            messages: messages,
-            stream: true,
-            ...(finalStreamOptions !== null
-                ? { stream_options: finalStreamOptions }
-                : {}),
-            tools: formattedTools,
-            tool_choice: this.getToolChoiceForFormat(tools),
-            ...this.modelParams,
+        // Strip internal tracking fields that some APIs don't accept
+        // We keep the synthetic responses but remove the metadata fields
+        const cleanedMessages = patchedMessages.map((msg) => {
+            // Create a shallow copy and remove internal fields
+            const { _synthetic, _cancelled, ...cleanMsg } = msg;
+            // Log synthetic tool responses for debugging
+            if (msg._synthetic) {
+                this.logger.debug(() => `[Synthetic Tool Response] ${JSON.stringify(cleanMsg)}`);
+            }
+            return cleanMsg;
         });
+        this.logger.debug(() => `About to make API call with model: ${this.currentModel}, baseURL: ${this.openai.baseURL}, apiKey: ${this.openai.apiKey?.substring(0, 10)}..., streaming: ${streamingEnabled}`);
+        // Debug: Log message roles being sent
+        this.logger.debug(() => `Messages being sent to OpenAI (${cleanedMessages.length} total): ${cleanedMessages
+            .map((m) => `${m.role}${m.role === 'system' ? ` (length: ${m.content?.length})` : ''}`)
+            .join(', ')}`);
+        let response;
+        try {
+            // Build request params with exact order from original
+            response = await this.openai.chat.completions.create({
+                model: this.currentModel,
+                messages: cleanedMessages,
+                stream: streamingEnabled,
+                ...(streamingEnabled && finalStreamOptions !== null
+                    ? { stream_options: finalStreamOptions }
+                    : {}),
+                tools: formattedTools,
+                tool_choice: this.getToolChoiceForFormat(tools),
+                ...this.modelParams,
+            });
+        }
+        catch (error) {
+            // Debug the error
+            this.logger.error(() => `[Cancellation 400] Error caught in API call: ${error}`);
+            this.logger.error(() => `[Cancellation 400] Error type: ${error?.constructor?.name}`);
+            this.logger.error(() => `[Cancellation 400] Error status: ${error?.status || error?.response?.status}`);
+            this.logger.error(() => `[Cancellation 400] Error response data: ${JSON.stringify(error?.response?.data, null, 2)}`);
+            // Log the last few messages to understand what's being sent
+            if (error?.status === 400 ||
+                error?.response?.status === 400) {
+                this.logger.error(() => `[Cancellation 400] Last 5 messages being sent:`);
+                const lastMessages = cleanedMessages.slice(-5);
+                lastMessages.forEach((msg, idx) => {
+                    this.logger.error(() => `  [${cleanedMessages.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}`);
+                        });
+                    }
+                });
+            }
+            // Check for JSONResponse mutation errors
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage?.includes('JSONResponse') &&
+                errorMessage?.includes('does not support item assignment')) {
+                this.logger.debug(() => '[Cancellation 400] Detected JSONResponse mutation error, retrying without streaming');
+                this.logger.error(() => '[Cerebras Corruption] JSONResponse mutation error detected. This typically occurs with certain providers like Cerebras. Falling back to non-streaming mode.', {
+                    errorMessage,
+                    provider: this.baseURL,
+                    streamingEnabled,
+                });
+                // Retry with streaming disabled
+                response = await this.openai.chat.completions.create({
+                    model: this.currentModel,
+                    messages: cleanedMessages,
+                    stream: false, // Force non-streaming
+                    tools: formattedTools,
+                    tool_choice: this.getToolChoiceForFormat(tools),
+                    ...this.modelParams,
+                });
+                // Override streamingEnabled for the rest of this function
+                streamingEnabled = false;
+            }
+            else {
+                this.logger.debug(() => '[Cancellation 400] Re-throwing error (not a JSONResponse mutation)');
+                // Re-throw other errors
+                throw error;
+            }
+        }
         let fullContent = '';
         const accumulatedToolCalls = [];
         let hasStreamedContent = false;
         let usageData;
         // For Qwen streaming, buffer whitespace-only chunks to preserve spacing across chunk boundaries
         let pendingWhitespace = null;
-        for await (const chunk of stream) {
-            const delta = chunk.choices[0]?.delta;
-            if (delta?.content) {
-                // Enhanced debug logging to understand streaming behavior
-                if (process.env.DEBUG && this.isUsingQwen()) {
-                    console.log(`[OpenAIProvider/${this.currentModel}] Chunk:`, {
-                        content: delta.content,
-                        contentLength: delta.content.length,
-                        isWhitespaceOnly: delta.content.trim() === '',
-                        chunkIndex: chunk.choices[0]?.index,
+        // Handle streaming vs non-streaming response
+        if (streamingEnabled) {
+            // We need to buffer all chunks to detect and handle malformed streams
+            // Some providers (like Cerebras) send message format instead of delta
+            const allChunks = [];
+            this.logger.debug(() => '[Stream Detection] Starting to buffer chunks for corruption detection', {
+                provider: this.baseURL,
+                streamingEnabled,
+            });
+            try {
+                for await (const chunk of response) {
+                    // CRITICAL: Create a deep copy to avoid JSONResponse mutation issues
+                    // Cerebras and other providers may return immutable JSONResponse objects
+                    // Cast to unknown first to bypass type checking, then to our extended type
+                    const extendedChunk = chunk;
+                    const safeChunk = {
+                        choices: extendedChunk.choices?.map((choice) => ({
+                            delta: choice.delta
+                                ? {
+                                    content: choice.delta.content ?? undefined,
+                                    role: choice.delta.role,
+                                    tool_calls: choice.delta.tool_calls?.map((tc, idx) => ({
+                                        id: tc.id,
+                                        type: tc.type,
+                                        function: tc.function
+                                            ? {
+                                                name: tc.function.name,
+                                                arguments: tc.function.arguments,
+                                            }
+                                            : undefined,
+                                        index: tc.index !== undefined ? tc.index : idx,
+                                    })),
+                                }
+                                : undefined,
+                            message: choice.message
+                                ? {
+                                    content: choice.message.content ?? undefined,
+                                    role: choice.message.role,
+                                    tool_calls: choice.message.tool_calls?.map((tc) => ({
+                                        id: tc.id,
+                                        type: tc.type,
+                                        function: tc.function
+                                            ? {
+                                                name: tc.function.name,
+                                                arguments: tc.function.arguments,
+                                            }
+                                            : undefined,
+                                    })),
+                                }
+                                : undefined,
+                            index: choice.index,
+                            finish_reason: choice.finish_reason,
+                        })),
+                        usage: extendedChunk.usage
+                            ? {
+                                prompt_tokens: extendedChunk.usage.prompt_tokens,
+                                completion_tokens: extendedChunk.usage.completion_tokens,
+                                total_tokens: extendedChunk.usage.total_tokens,
+                            }
+                            : undefined,
+                    };
+                    allChunks.push(safeChunk);
+                }
+            }
+            catch (error) {
+                // Handle JSONResponse mutation errors that occur during iteration
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                if (errorMessage?.includes('JSONResponse') &&
+                    errorMessage?.includes('does not support item assignment')) {
+                    this.logger.error(() => '[Cerebras Corruption] JSONResponse mutation error during stream iteration. This is a known issue with Cerebras. The OpenAI client library is trying to mutate immutable response objects. Falling back to non-streaming mode.', {
+                        error: errorMessage,
+                        provider: this.baseURL,
+                        chunksCollected: allChunks.length,
+                    });
+                    // Retry the entire request with streaming disabled
+                    // This is the nuclear option but ensures we get a response
+                    const nonStreamingResponse = await this.openai.chat.completions.create({
+                        model: this.currentModel,
+                        messages: cleanedMessages,
+                        stream: false, // Force non-streaming
+                        tools: formattedTools,
+                        tool_choice: this.getToolChoiceForFormat(tools),
+                        ...this.modelParams,
                     });
+                    // Handle as non-streaming response
+                    const completionResponse = nonStreamingResponse;
+                    const choice = completionResponse.choices[0];
+                    if (choice?.message.content) {
+                        fullContent = choice.message.content;
+                    }
+                    if (choice?.message.tool_calls) {
+                        for (const toolCall of choice.message.tool_calls) {
+                            if (toolCall.type === 'function' && toolCall.function) {
+                                accumulatedToolCalls.push({
+                                    id: toolCall.id,
+                                    type: 'function',
+                                    function: toolCall.function,
+                                });
+                            }
+                        }
+                    }
+                    if (completionResponse.usage) {
+                        usageData = {
+                            prompt_tokens: completionResponse.usage.prompt_tokens,
+                            completion_tokens: completionResponse.usage.completion_tokens,
+                            total_tokens: completionResponse.usage.total_tokens,
+                        };
+                    }
+                    // Yield the complete response
+                    yield {
+                        role: ContentGeneratorRole.ASSISTANT,
+                        content: fullContent || '',
+                        tool_calls: accumulatedToolCalls.length > 0
+                            ? accumulatedToolCalls
+                            : undefined,
+                        usage: usageData,
+                    };
+                    return;
                 }
-                // For text-based models, don't yield content chunks yet
-                if (!parser) {
+                // Re-throw other errors
+                throw error;
+            }
+            // Check first chunk to see if we have malformed stream
+            let detectedMalformedStream = false;
+            if (allChunks.length > 0) {
+                const firstChunk = allChunks[0];
+                if (firstChunk.choices?.[0]?.message &&
+                    !firstChunk.choices?.[0]?.delta) {
+                    detectedMalformedStream = true;
+                    this.logger.debug(() => 'Detected malformed stream (message instead of delta), using aggregation mode');
+                }
+            }
+            // If we detected issues, aggregate everything
+            if (detectedMalformedStream) {
+                const contentParts = [];
+                let aggregatedToolCalls = [];
+                let finalUsageData = undefined;
+                // Process all buffered chunks
+                for (const chunk of allChunks) {
+                    const message = chunk.choices?.[0]?.message || chunk.choices?.[0]?.delta;
+                    if (message?.content) {
+                        contentParts.push(message.content);
+                    }
+                    if (message?.tool_calls) {
+                        // Ensure tool_calls match the expected format
+                        aggregatedToolCalls = message.tool_calls.map((tc) => ({
+                            id: tc.id || `call_${Date.now()}`,
+                            type: (tc.type || 'function'),
+                            function: {
+                                name: tc.function?.name || '',
+                                arguments: tc.function?.arguments || '',
+                            },
+                        }));
+                    }
+                    if (chunk.usage) {
+                        finalUsageData = {
+                            prompt_tokens: chunk.usage.prompt_tokens || 0,
+                            completion_tokens: chunk.usage.completion_tokens || 0,
+                            total_tokens: chunk.usage.total_tokens || 0,
+                        };
+                    }
+                }
+                // Yield single reconstructed message
+                yield {
+                    role: ContentGeneratorRole.ASSISTANT,
+                    content: contentParts.join(''),
+                    tool_calls: aggregatedToolCalls.length > 0 ? aggregatedToolCalls : undefined,
+                    usage: finalUsageData,
+                };
+                return;
+            }
+            // Process chunks normally - stream them as they come
+            for (const chunk of allChunks) {
+                // Since we created safe copies during buffering, chunks are now mutable
+                // Check if this chunk has message format instead of delta (malformed stream)
+                let processedChunk = chunk;
+                if (chunk.choices?.[0]?.message && !chunk.choices?.[0]?.delta) {
+                    this.logger.error(() => '[Cerebras Corruption] Converting malformed chunk from message to delta format', {
+                        provider: this.baseURL,
+                        hasMessage: true,
+                        hasDelta: false,
+                        messageContent: chunk.choices[0].message?.content?.substring(0, 100),
+                    });
+                    // Convert message format to delta format for consistent processing
+                    const message = chunk.choices[0].message;
+                    processedChunk = {
+                        choices: [
+                            {
+                                delta: {
+                                    content: message?.content ?? undefined,
+                                    role: message?.role,
+                                    tool_calls: message?.tool_calls,
+                                },
+                            },
+                        ],
+                        usage: chunk.usage,
+                    };
+                }
+                const delta = processedChunk.choices?.[0]?.delta;
+                if (delta?.content) {
+                    // Enhanced debug logging to understand streaming behavior
                     if (this.isUsingQwen()) {
-                        const isWhitespaceOnly = delta.content.trim() === '';
-                        if (isWhitespaceOnly) {
-                            // Buffer whitespace-only chunk
-                            pendingWhitespace = (pendingWhitespace || '') + delta.content;
-                            if (process.env.DEBUG) {
-                                console.log(`[OpenAIProvider/${this.currentModel}] Buffered whitespace-only chunk (len=${delta.content.length}). pendingWhitespace now len=${pendingWhitespace.length}`);
+                        this.logger.debug(() => `Chunk: ${JSON.stringify({
+                            content: delta.content,
+                            contentLength: delta.content?.length ?? 0,
+                            isWhitespaceOnly: delta.content?.trim() === '',
+                            chunkIndex: 0,
+                        })}`);
+                    }
+                    // For text-based models, don't yield content chunks yet
+                    if (!parser && delta.content) {
+                        if (this.isUsingQwen()) {
+                            const isWhitespaceOnly = delta.content.trim() === '';
+                            if (isWhitespaceOnly) {
+                                // Buffer whitespace-only chunk
+                                pendingWhitespace = (pendingWhitespace || '') + delta.content;
+                                this.logger.debug(() => `Buffered whitespace-only chunk (len=${delta.content?.length ?? 0}). pendingWhitespace now len=${pendingWhitespace?.length ?? 0}`);
+                                continue;
                             }
-                            continue;
-                        }
-                        else if (pendingWhitespace) {
-                            // Flush buffered whitespace before non-empty chunk to preserve spacing
-                            if (process.env.DEBUG) {
-                                console.log(`[OpenAIProvider/${this.currentModel}] Flushing pending whitespace (len=${pendingWhitespace.length}) before non-empty chunk`);
+                            else if (pendingWhitespace) {
+                                // Flush buffered whitespace before non-empty chunk to preserve spacing
+                                this.logger.debug(() => `Flushing pending whitespace (len=${pendingWhitespace?.length ?? 0}) before non-empty chunk`);
+                                yield {
+                                    role: ContentGeneratorRole.ASSISTANT,
+                                    content: pendingWhitespace,
+                                };
+                                hasStreamedContent = true;
+                                fullContent += pendingWhitespace;
+                                pendingWhitespace = null;
                             }
-                            yield {
-                                role: ContentGeneratorRole.ASSISTANT,
-                                content: pendingWhitespace,
-                            };
-                            hasStreamedContent = true;
-                            fullContent += pendingWhitespace;
-                            pendingWhitespace = null;
                         }
+                        yield {
+                            role: ContentGeneratorRole.ASSISTANT,
+                            content: delta.content,
+                        };
+                        hasStreamedContent = true;
                     }
-                    yield {
-                        role: ContentGeneratorRole.ASSISTANT,
-                        content: delta.content,
+                    fullContent += delta.content;
+                }
+                if (delta?.tool_calls) {
+                    for (const toolCall of delta.tool_calls) {
+                        this.toolFormatter.accumulateStreamingToolCall(toolCall, accumulatedToolCalls, currentToolFormat);
+                    }
+                }
+                // Check for usage data in the chunk
+                if (processedChunk.usage) {
+                    usageData = {
+                        prompt_tokens: processedChunk.usage.prompt_tokens || 0,
+                        completion_tokens: processedChunk.usage.completion_tokens || 0,
+                        total_tokens: processedChunk.usage.total_tokens || 0,
                     };
-                    hasStreamedContent = true;
                 }
-                fullContent += delta.content;
             }
-            if (delta?.tool_calls) {
-                for (const toolCall of delta.tool_calls) {
-                    this.toolFormatter.accumulateStreamingToolCall(toolCall, accumulatedToolCalls, currentToolFormat);
+        }
+        else {
+            // Non-streaming response - handle as a single completion
+            const completionResponse = response;
+            const choice = completionResponse.choices[0];
+            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,
+                        });
+                    }
                 }
             }
-            // Check for usage data in the chunk
-            if (chunk.usage) {
+            if (completionResponse.usage) {
                 usageData = {
-                    prompt_tokens: chunk.usage.prompt_tokens,
-                    completion_tokens: chunk.usage.completion_tokens,
-                    total_tokens: chunk.usage.total_tokens,
+                    prompt_tokens: completionResponse.usage.prompt_tokens,
+                    completion_tokens: completionResponse.usage.completion_tokens,
+                    total_tokens: completionResponse.usage.total_tokens,
+                };
+            }
+            // For non-streaming, we yield the full content at once if there's no parser
+            if (!parser && fullContent) {
+                yield {
+                    role: ContentGeneratorRole.ASSISTANT,
+                    content: fullContent,
                 };
+                hasStreamedContent = true;
             }
         }
         // Flush any remaining pending whitespace for Qwen
         if (pendingWhitespace && this.isUsingQwen() && !parser) {
-            if (process.env.DEBUG) {
-                console.log(`[OpenAIProvider/${this.currentModel}] Flushing trailing pending whitespace (len=${pendingWhitespace.length}) at stream end`);
-            }
+            this.logger.debug(() => `Flushing trailing pending whitespace (len=${pendingWhitespace?.length ?? 0}) at stream end`);
             yield {
                 role: ContentGeneratorRole.ASSISTANT,
                 content: pendingWhitespace,
@@ -657,23 +1012,144 @@ export class OpenAIProvider extends BaseProvider {
         else {
             // Standard OpenAI tool call handling
             if (accumulatedToolCalls.length > 0) {
-                if (process.env.DEBUG && this.isUsingQwen()) {
-                    console.log(`[OpenAIProvider/${this.currentModel}] Final message with tool calls:`, {
+                // Fix double stringification for Qwen tool calls
+                // Qwen models pre-stringify arguments values, but later in the process
+                // they are being JSON.stringify'd again
+                let fixedToolCalls = accumulatedToolCalls;
+                if (this.isUsingQwen()) {
+                    this.logger.debug(() => `[Qwen Fix] Processing ${accumulatedToolCalls.length} tool calls for double-stringification fix`);
+                    fixedToolCalls = accumulatedToolCalls.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),
+                        })}`);
+                        // For Qwen, check for nested double-stringification
+                        // Qwen models stringify array/object values WITHIN the JSON arguments
+                        if (toolCall.function.arguments &&
+                            typeof toolCall.function.arguments === 'string') {
+                            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
+                                const fixedArgs = {};
+                                for (const [key, value] of Object.entries(parsedArgs)) {
+                                    if (typeof value === 'string') {
+                                        const trimmed = value.trim();
+                                        // Check if it looks like a stringified array or object
+                                        // Also check for Python-style dictionaries with single quotes
+                                        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
+                                    }
+                                }
+                            }
+                        }
+                        // No fix needed
+                        this.logger.debug(() => `[Qwen Fix] No double-stringification detected for ${toolCall.function.name}, keeping original`);
+                        return toolCall;
+                    });
+                }
+                if (this.isUsingQwen()) {
+                    this.logger.debug(() => `Final message with tool calls: ${JSON.stringify({
                         contentLength: fullContent.length,
                         content: fullContent.substring(0, 200) +
                             (fullContent.length > 200 ? '...' : ''),
                         toolCallCount: accumulatedToolCalls.length,
                         hasStreamedContent,
-                    });
+                    })}`);
                 }
                 // For Qwen models, don't duplicate content if we've already streamed it
-                const shouldOmitContent = hasStreamedContent && this.isUsingQwen();
+                // BUT Cerebras needs at least a space to continue after tool responses
+                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;
                 if (shouldOmitContent) {
                     // Only yield tool calls with empty content to avoid duplication
                     yield {
                         role: ContentGeneratorRole.ASSISTANT,
                         content: '',
-                        tool_calls: accumulatedToolCalls,
+                        tool_calls: fixedToolCalls,
+                        usage: usageData,
+                    };
+                }
+                else if (isCerebras && hasStreamedContent) {
+                    // Cerebras: Send just a space to prevent duplication but allow continuation
+                    // This prevents the repeated "Let me search..." text
+                    this.logger.debug(() => '[Cerebras] Sending minimal space content to prevent duplication');
+                    yield {
+                        role: ContentGeneratorRole.ASSISTANT,
+                        content: ' ', // Single space instead of full content
+                        tool_calls: fixedToolCalls,
                         usage: usageData,
                     };
                 }
@@ -682,7 +1158,7 @@ export class OpenAIProvider extends BaseProvider {
                     yield {
                         role: ContentGeneratorRole.ASSISTANT,
                         content: fullContent || '',
-                        tool_calls: accumulatedToolCalls,
+                        tool_calls: fixedToolCalls,
                         usage: usageData,
                     };
                 }
@@ -700,9 +1176,7 @@ export class OpenAIProvider extends BaseProvider {
     setModel(modelId) {
         // Update SettingsService as the source of truth
         this.setModelInSettings(modelId).catch((error) => {
-            if (process.env.DEBUG) {
-                console.warn('Failed to persist model to SettingsService:', error);
-            }
+            this.logger.debug(() => `Failed to persist model to SettingsService: ${error}`);
         });
         // Keep local cache for performance
         this.currentModel = modelId;
@@ -717,9 +1191,7 @@ export class OpenAIProvider extends BaseProvider {
             }
         }
         catch (error) {
-            if (process.env.DEBUG) {
-                console.warn('Failed to get model from SettingsService:', error);
-            }
+            this.logger.debug(() => `Failed to get model from SettingsService: ${error}`);
         }
         // Fall back to cached value or default
         return this.currentModel || this.getDefaultModel();
@@ -730,16 +1202,14 @@ export class OpenAIProvider extends BaseProvider {
         if (this.isUsingQwen()) {
             return 'qwen3-coder-plus';
         }
-        return process.env.LLXPRT_DEFAULT_MODEL || 'llama3-70b-8192';
+        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) => {
-            if (process.env.DEBUG) {
-                console.warn('Failed to persist API key to SettingsService:', error);
-            }
+            this.logger.debug(() => `Failed to persist API key to SettingsService: ${error}`);
         });
         // Create a new OpenAI client with the updated API key
         const clientOptions = {
@@ -758,9 +1228,7 @@ export class OpenAIProvider extends BaseProvider {
         this.baseURL = baseUrl && baseUrl.trim() !== '' ? baseUrl : undefined;
         // Persist to SettingsService if available
         this.setBaseUrlInSettings(this.baseURL).catch((error) => {
-            if (process.env.DEBUG) {
-                console.warn('Failed to persist base URL to SettingsService:', 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
@@ -808,6 +1276,89 @@ export class OpenAIProvider extends BaseProvider {
     getConversationCache() {
         return this.conversationCache;
     }
+    /**
+     * Identifies and fixes missing tool responses by adding synthetic responses in place.
+     * Similar to AnthropicProvider's validateAndFixMessages approach.
+     * This ensures synthetic responses persist in the conversation history.
+     * @param messages The message array to fix in place
+     * @returns Array of tool call IDs that were fixed
+     */
+    identifyAndFixMissingToolResponses(messages) {
+        const fixedIds = [];
+        const pendingToolCalls = [];
+        // Process messages in order, tracking tool calls and responses
+        for (let i = 0; i < messages.length; i++) {
+            const msg = messages[i];
+            if (msg.role === 'assistant' && msg.tool_calls) {
+                // If we have pending tool calls from a previous assistant message,
+                // add synthetic responses for them before processing this new assistant message
+                if (pendingToolCalls.length > 0) {
+                    const syntheticResponses = pendingToolCalls.map((tc) => ({
+                        role: 'tool',
+                        tool_call_id: tc.id,
+                        content: 'Tool execution cancelled by user',
+                        _synthetic: true,
+                        _cancelled: true,
+                    }));
+                    // Insert synthetic responses before the current assistant message
+                    messages.splice(i, 0, ...syntheticResponses);
+                    // Track what we fixed
+                    fixedIds.push(...pendingToolCalls.map((tc) => tc.id));
+                    // Adjust index to account for inserted messages
+                    i += syntheticResponses.length;
+                    // Clear pending tool calls
+                    pendingToolCalls.length = 0;
+                }
+                // Now track the new tool calls from this assistant message
+                msg.tool_calls.forEach((toolCall) => {
+                    if (toolCall.id) {
+                        pendingToolCalls.push({
+                            id: toolCall.id,
+                            name: toolCall.function.name,
+                        });
+                    }
+                });
+            }
+            else if (msg.role === 'tool' && pendingToolCalls.length > 0) {
+                // Match tool responses with pending tool calls
+                pendingToolCalls.splice(pendingToolCalls.findIndex((tc) => tc.id === msg.tool_call_id), 1);
+            }
+            else if ((msg.role === 'assistant' || msg.role === 'user') &&
+                pendingToolCalls.length > 0) {
+                // We hit a non-tool message with pending tool calls - need to add synthetic responses
+                const syntheticResponses = pendingToolCalls.map((tc) => ({
+                    role: 'tool',
+                    tool_call_id: tc.id,
+                    content: 'Tool execution cancelled by user',
+                    _synthetic: true,
+                    _cancelled: true,
+                }));
+                // Insert synthetic responses before the current message
+                messages.splice(i, 0, ...syntheticResponses);
+                // Track what we fixed
+                fixedIds.push(...pendingToolCalls.map((tc) => tc.id));
+                // Adjust index to account for inserted messages
+                i += syntheticResponses.length;
+                // Clear pending tool calls
+                pendingToolCalls.length = 0;
+            }
+        }
+        // Handle any remaining pending tool calls at the end
+        if (pendingToolCalls.length > 0) {
+            const syntheticResponses = pendingToolCalls.map((tc) => ({
+                role: 'tool',
+                tool_call_id: tc.id,
+                content: 'Tool execution cancelled by user',
+                _synthetic: true,
+                _cancelled: true,
+            }));
+            // Add to the end of messages
+            messages.push(...syntheticResponses);
+            // Track what we fixed
+            fixedIds.push(...pendingToolCalls.map((tc) => tc.id));
+        }
+        return fixedIds;
+    }
     /**
      * OpenAI always requires payment (API key)
      */
@@ -843,9 +1394,7 @@ export class OpenAIProvider extends BaseProvider {
         }
         // Persist to SettingsService if available
         this.setModelParamsInSettings(this.modelParams).catch((error) => {
-            if (process.env.DEBUG) {
-                console.warn('Failed to persist model params to SettingsService:', error);
-            }
+            this.logger.debug(() => `Failed to persist model params to SettingsService: ${error}`);
         });
     }
     /**
@@ -875,14 +1424,10 @@ export class OpenAIProvider extends BaseProvider {
             if (savedParams) {
                 this.modelParams = savedParams;
             }
-            if (process.env.DEBUG) {
-                console.log(`[OpenAI] Initialized from SettingsService - model: ${this.currentModel}, baseURL: ${this.baseURL}, params:`, this.modelParams);
-            }
+            this.logger.debug(() => `Initialized from SettingsService - model: ${this.currentModel}, baseURL: ${this.baseURL}, params: ${JSON.stringify(this.modelParams)}`);
         }
         catch (error) {
-            if (process.env.DEBUG) {
-                console.error('Failed to initialize OpenAI provider from SettingsService:', error);
-            }
+            this.logger.debug(() => `Failed to initialize OpenAI provider from SettingsService: ${error}`);
         }
     }
     /**
@@ -922,9 +1467,7 @@ export class OpenAIProvider extends BaseProvider {
             return 'openai';
         }
         catch (error) {
-            if (process.env.DEBUG) {
-                console.warn('Failed to detect tool format from SettingsService:', 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')) {