@vybestack/llxprt-code-core 0.1.22 → 0.1.23-nightly.250824.52dcfe37

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
@@ -271,6 +275,7 @@ export class OpenAIProvider extends BaseProvider {
             conversationId: options?.conversationId,
             parentId: options?.parentId,
             tool_choice: options?.tool_choice,
+            ...(this.modelParams || {}),
         });
         // Make the API call
         const baseURL = this.baseURL || 'https://api.openai.com/v1';
@@ -295,9 +300,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);
@@ -310,6 +313,7 @@ export class OpenAIProvider extends BaseProvider {
                     stream: options?.stream ?? true,
                     // Omit conversationId and parentId for stateless retry
                     tool_choice: options?.tool_choice,
+                    ...(this.modelParams || {}),
                 });
                 // Ensure proper UTF-8 encoding for retry request as well
                 const retryRequestBody = JSON.stringify(retryRequest);
@@ -380,9 +384,10 @@ export class OpenAIProvider extends BaseProvider {
         // 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)) {
-            if (process.env.DEBUG) {
-                console.log('[OpenAIProvider] Detected malformed array response, aggregating...');
-            }
+            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;
@@ -483,9 +488,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 || '')) {
@@ -551,15 +554,60 @@ export class OpenAIProvider extends BaseProvider {
             });
             return;
         }
+        // Don't automatically add synthetic responses - they should only be added when tools are actually cancelled
+        // Check if we have any existing synthetic responses (from actual cancellations)
+        const existingSyntheticCount = messages.filter((msg) => msg._synthetic).length;
+        if (existingSyntheticCount > 0) {
+            this.logger.debug(() => `[Synthetic] Found ${existingSyntheticCount} existing synthetic responses in conversation`);
+        }
+        // Just use the messages as-is without "fixing" them
+        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`);
+            // Check for ordering issues - using debug logger which only executes when enabled
+            this.logger.debug(() => {
+                const orderingErrors = [];
+                const orderingWarnings = [];
+                for (let i = 0; i < patchedMessages.length - 1; i++) {
+                    const current = patchedMessages[i];
+                    const next = patchedMessages[i + 1];
+                    // Check if a tool response comes before its corresponding tool call
+                    if (current.role === 'tool' && current.tool_call_id) {
+                        // Find the assistant message with this tool call
+                        const callIndex = patchedMessages.findIndex((m) => m.role === 'assistant' &&
+                            m.tool_calls?.some((tc) => tc.id === current.tool_call_id));
+                        if (callIndex === -1 || callIndex > i) {
+                            orderingErrors.push(`Tool response ${current.tool_call_id} appears before its tool call or call not found`);
+                        }
+                    }
+                    // Check if we have consecutive assistant messages with tool calls
+                    if (current.role === 'assistant' &&
+                        current.tool_calls &&
+                        next.role === 'assistant' &&
+                        next.tool_calls) {
+                        orderingWarnings.push(`Consecutive assistant messages with tool calls at indices ${i} and ${i + 1}`);
+                    }
+                }
+                if (orderingErrors.length > 0) {
+                    return `[Synthetic Order Check] Errors found: ${orderingErrors.join('; ')}`;
+                }
+                else if (orderingWarnings.length > 0) {
+                    return `[Synthetic Order Check] Warnings: ${orderingWarnings.join('; ')}`;
+                }
+                else {
+                    return '[Synthetic Order Check] No issues found';
+                }
+            });
+        }
         const parser = this.requiresTextToolCallParsing()
             ? new GemmaToolCallParser()
             : null;
@@ -573,24 +621,106 @@ export class OpenAIProvider extends BaseProvider {
         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';
+        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)}..., streaming: ${streamingEnabled}`);
-        }
-        // Build request params with exact order from original
-        const response = await this.openai.chat.completions.create({
-            model: this.currentModel,
-            messages: messages,
-            stream: streamingEnabled,
-            ...(streamingEnabled && 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
+                    ? { stream_options: finalStreamOptions }
+                    : {}),
+                tools: formattedTools,
+                tool_choice: this.getToolChoiceForFormat(tools),
+                ...this.modelParams,
+            });
+        }
+        catch (error) {
+            // Debug the error
+            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: ${error}`);
+            this.logger.error(() => `${errorLabel} Error type: ${error?.constructor?.name}`);
+            this.logger.error(() => `${errorLabel} Error status: ${errorStatus}`);
+            this.logger.error(() => `${errorLabel} Error 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 hasSyntheticMessages = cleanedMessages.some((msg) => msg.role === 'tool' &&
+                    msg.content === 'Tool execution cancelled by user');
+                const hasPendingToolCalls = cleanedMessages.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) => cleanedMessages
+                            .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:`);
+                this.logger.error(() => `${errorLabel} Has synthetic messages: ${hasSyntheticMessages}`);
+                this.logger.error(() => `${errorLabel} Has pending tool calls without responses: ${hasPendingToolCalls}`);
+                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(() => '[JSONResponse Error] 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(() => `${errorLabel} Re-throwing error (not a JSONResponse mutation)`);
+                // Re-throw other errors
+                throw error;
+            }
+        }
         let fullContent = '';
         const accumulatedToolCalls = [];
         let hasStreamedContent = false;
@@ -602,8 +732,129 @@ export class OpenAIProvider extends BaseProvider {
             // We need to buffer all chunks to detect and handle malformed streams
             // Some providers (like Cerebras) send message format instead of delta
             const allChunks = [];
-            for await (const chunk of response) {
-                allChunks.push(chunk);
+            this.logger.debug(() => '[Stream Detection] Starting to buffer chunks for corruption detection', {
+                provider: this.baseURL,
+                streamingEnabled,
+                isUsingQwen: this.isUsingQwen(),
+                currentModel: this.currentModel,
+            });
+            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);
+                }
+                this.logger.debug(() => `[Stream Buffering Complete] Collected ${allChunks.length} chunks`, {
+                    chunkCount: allChunks.length,
+                    hasContent: allChunks.some((c) => c.choices?.[0]?.delta?.content),
+                    hasToolCalls: allChunks.some((c) => c.choices?.[0]?.delta?.tool_calls),
+                });
+            }
+            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;
+                }
+                // Re-throw other errors
+                throw error;
             }
             // Check first chunk to see if we have malformed stream
             let detectedMalformedStream = false;
@@ -612,9 +863,7 @@ export class OpenAIProvider extends BaseProvider {
                 if (firstChunk.choices?.[0]?.message &&
                     !firstChunk.choices?.[0]?.delta) {
                     detectedMalformedStream = true;
-                    if (process.env.DEBUG) {
-                        console.log('[OpenAIProvider] Detected malformed stream (message instead of delta), using aggregation mode');
-                    }
+                    this.logger.debug(() => 'Detected malformed stream (message instead of delta), using aggregation mode');
                 }
             }
             // If we detected issues, aggregate everything
@@ -629,10 +878,22 @@ export class OpenAIProvider extends BaseProvider {
                         contentParts.push(message.content);
                     }
                     if (message?.tool_calls) {
-                        aggregatedToolCalls = 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 = 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
@@ -645,64 +906,72 @@ export class OpenAIProvider extends BaseProvider {
                 return;
             }
             // Process chunks normally - stream them as they come
+            this.logger.debug(() => `[Processing Chunks] Starting to process ${allChunks.length} buffered chunks`, {
+                isUsingQwen: this.isUsingQwen(),
+            });
+            let chunkIndex = 0;
             for (const chunk of allChunks) {
-                const cerebrasChunk = chunk;
-                // DEFENSIVE FIX: Some providers send full message format instead of delta in streaming
-                // This violates OpenAI spec but we handle it gracefully
+                chunkIndex++;
+                // 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 (cerebrasChunk.choices?.[0]?.message &&
-                    !cerebrasChunk.choices[0].delta) {
-                    if (process.env.DEBUG) {
-                        console.log('[OpenAIProvider] Converting malformed chunk from message to delta format');
-                    }
-                    // Convert full message format to delta format - create new object instead of modifying
-                    const message = cerebrasChunk.choices[0].message;
-                    const originalChunk = 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 = {
-                        ...originalChunk,
                         choices: [
                             {
                                 delta: {
-                                    content: message.content,
-                                    tool_calls: message.tool_calls?.map((tc, index) => ({
-                                        ...tc,
-                                        index,
-                                    })),
+                                    content: message?.content ?? undefined,
+                                    role: message?.role,
+                                    tool_calls: message?.tool_calls,
                                 },
-                                message: undefined, // Remove message field
                             },
                         ],
-                        usage: originalChunk.usage,
+                        usage: chunk.usage,
                     };
                 }
                 const delta = processedChunk.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:`, {
+                    if (this.isUsingQwen()) {
+                        this.logger.debug(() => `Chunk: ${JSON.stringify({
                             content: delta.content,
-                            contentLength: delta.content.length,
-                            isWhitespaceOnly: delta.content.trim() === '',
+                            contentLength: delta.content?.length ?? 0,
+                            isWhitespaceOnly: delta.content?.trim() === '',
                             chunkIndex: 0,
-                        });
+                        })}`);
                     }
                     // For text-based models, don't yield content chunks yet
-                    if (!parser) {
+                    if (!parser && delta.content) {
+                        this.logger.debug(() => `[Content Processing] Chunk ${chunkIndex}/${allChunks.length} has content`, {
+                            contentLength: delta.content.length,
+                            contentPreview: delta.content.substring(0, 50),
+                            isUsingQwen: this.isUsingQwen(),
+                            willBuffer: this.isUsingQwen() && delta.content.trim() === '',
+                        });
                         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(() => `[Whitespace Buffering] Buffered whitespace-only chunk (len=${delta.content?.length ?? 0}). pendingWhitespace now len=${pendingWhitespace?.length ?? 0}`, {
+                                    chunkIndex,
+                                    totalChunks: allChunks.length,
+                                    isLastChunk: chunkIndex === allChunks.length,
+                                    contentHex: Buffer.from(delta.content).toString('hex'),
+                                });
                                 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`);
-                                }
+                                this.logger.debug(() => `Flushing pending whitespace (len=${pendingWhitespace?.length ?? 0}) before non-empty chunk`);
                                 yield {
                                     role: ContentGeneratorRole.ASSISTANT,
                                     content: pendingWhitespace,
@@ -712,6 +981,10 @@ export class OpenAIProvider extends BaseProvider {
                                 pendingWhitespace = null;
                             }
                         }
+                        this.logger.debug(() => `[Yielding Content] Yielding chunk ${chunkIndex}/${allChunks.length}`, {
+                            contentLength: delta.content.length,
+                            hasStreamedContent,
+                        });
                         yield {
                             role: ContentGeneratorRole.ASSISTANT,
                             content: delta.content,
@@ -728,9 +1001,9 @@ export class OpenAIProvider extends BaseProvider {
                 // Check for usage data in the chunk
                 if (processedChunk.usage) {
                     usageData = {
-                        prompt_tokens: processedChunk.usage.prompt_tokens,
-                        completion_tokens: processedChunk.usage.completion_tokens,
-                        total_tokens: processedChunk.usage.total_tokens,
+                        prompt_tokens: processedChunk.usage.prompt_tokens || 0,
+                        completion_tokens: processedChunk.usage.completion_tokens || 0,
+                        total_tokens: processedChunk.usage.total_tokens || 0,
                     };
                 }
             }
@@ -746,6 +1019,7 @@ export class OpenAIProvider extends BaseProvider {
                 // 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',
@@ -772,9 +1046,7 @@ export class OpenAIProvider extends BaseProvider {
         }
         // 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,
@@ -815,35 +1087,161 @@ 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/number
+                                const fixedArgs = {};
+                                for (const [key, value] of Object.entries(parsedArgs)) {
+                                    if (typeof value === 'string') {
+                                        const trimmed = value.trim();
+                                        // Check if it's a stringified number (integer or float)
+                                        if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+                                            const numValue = trimmed.includes('.')
+                                                ? parseFloat(trimmed)
+                                                : parseInt(trimmed, 10);
+                                            fixedArgs[key] = numValue;
+                                            hasNestedStringification = true;
+                                            this.logger.debug(() => `[Qwen Fix] Fixed stringified number in property '${key}' for ${toolCall.function.name}: "${value}" -> ${numValue}`);
+                                        }
+                                        // Check if it looks like a stringified array or object
+                                        // Also check for Python-style dictionaries with single quotes
+                                        else if ((trimmed.startsWith('[') && trimmed.endsWith(']')) ||
+                                            (trimmed.startsWith('{') && trimmed.endsWith('}'))) {
+                                            try {
+                                                // Try to parse it as JSON
+                                                const nestedParsed = JSON.parse(value);
+                                                fixedArgs[key] = nestedParsed;
+                                                hasNestedStringification = true;
+                                                this.logger.debug(() => `[Qwen Fix] Fixed nested stringification in property '${key}' for ${toolCall.function.name}`);
+                                            }
+                                            catch {
+                                                // Try to convert Python-style to JSON (single quotes to double quotes)
+                                                try {
+                                                    const jsonified = value
+                                                        .replace(/'/g, '"')
+                                                        .replace(/: True/g, ': true')
+                                                        .replace(/: False/g, ': false')
+                                                        .replace(/: None/g, ': null');
+                                                    const nestedParsed = JSON.parse(jsonified);
+                                                    fixedArgs[key] = nestedParsed;
+                                                    hasNestedStringification = true;
+                                                    this.logger.debug(() => `[Qwen Fix] Fixed Python-style nested stringification in property '${key}' for ${toolCall.function.name}`);
+                                                }
+                                                catch {
+                                                    // Not valid JSON even after conversion, keep as string
+                                                    fixedArgs[key] = value;
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            fixedArgs[key] = value;
+                                        }
+                                    }
+                                    else {
+                                        fixedArgs[key] = value;
+                                    }
+                                }
+                                if (hasNestedStringification) {
+                                    this.logger.debug(() => `[Qwen Fix] Fixed nested double-stringification for ${toolCall.function.name}`);
+                                    return {
+                                        ...toolCall,
+                                        function: {
+                                            ...toolCall.function,
+                                            arguments: JSON.stringify(fixedArgs),
+                                        },
+                                    };
+                                }
+                            }
+                            catch (_e) {
+                                // If parsing fails, check for old-style double-stringification
+                                if (toolCall.function.arguments.startsWith('"') &&
+                                    toolCall.function.arguments.endsWith('"')) {
+                                    try {
+                                        // Old fix: entire arguments were double-stringified
+                                        const parsedArgs = JSON.parse(toolCall.function.arguments);
+                                        this.logger.debug(() => `[Qwen Fix] Fixed whole-argument double-stringification for ${toolCall.function.name}`);
+                                        return {
+                                            ...toolCall,
+                                            function: {
+                                                ...toolCall.function,
+                                                arguments: JSON.stringify(parsedArgs),
+                                            },
+                                        };
+                                    }
+                                    catch {
+                                        // Leave as-is if we can't parse
+                                    }
+                                }
+                            }
+                        }
+                        // 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
                 // 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;
+                this.logger.debug(() => '[Tool Call Handling] Deciding how to yield tool calls', {
+                    hasStreamedContent,
+                    isUsingQwen: this.isUsingQwen(),
+                    isCerebras,
+                    shouldOmitContent,
+                    fullContentLength: fullContent.length,
+                    toolCallCount: fixedToolCalls?.length || 0,
+                });
                 if (shouldOmitContent) {
-                    // Only yield tool calls with empty content to avoid duplication
+                    // Qwen: Send just a space (like Cerebras) to prevent stream stopping
                     yield {
                         role: ContentGeneratorRole.ASSISTANT,
-                        content: '',
-                        tool_calls: accumulatedToolCalls,
+                        content: ' ', // Single space instead of empty to keep stream alive
+                        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: accumulatedToolCalls,
+                        tool_calls: fixedToolCalls,
                         usage: usageData,
                     };
                 }
@@ -852,7 +1250,7 @@ export class OpenAIProvider extends BaseProvider {
                     yield {
                         role: ContentGeneratorRole.ASSISTANT,
                         content: fullContent || '',
-                        tool_calls: accumulatedToolCalls,
+                        tool_calls: fixedToolCalls,
                         usage: usageData,
                     };
                 }
@@ -870,9 +1268,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;
@@ -887,9 +1283,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();
@@ -900,16 +1294,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 = {
@@ -928,9 +1320,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
@@ -1013,9 +1403,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}`);
         });
     }
     /**
@@ -1045,14 +1433,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}`);
         }
     }
     /**
@@ -1092,9 +1476,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')) {