@vybestack/llxprt-code-core 0.7.0-nightly.251218.3619c584b → 0.7.0-nightly.251218.47baadc14

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

@@ -25,7 +25,6 @@ import * as net from 'net';
 import { isKimiModel, isMistralModel, getToolIdStrategy, } from '../../tools/ToolIdStrategy.js';
 import { BaseProvider, } from '../BaseProvider.js';
 import { DebugLogger } from '../../debug/index.js';
-import { flushRuntimeAuthScope, } from '../../auth/precedence.js';
 import { ToolFormatter } from '../../tools/ToolFormatter.js';
 import { convertToolsToOpenAI } from './schemaConverter.js';
 import { GemmaToolCallParser } from '../../parsers/TextToolCallParser.js';
@@ -37,12 +36,15 @@ import { resolveRuntimeAuthToken } from '../utils/authToken.js';
 import { filterOpenAIRequestParams } from './openaiRequestParams.js';
 import { ensureJsonSafe } from '../../utils/unicodeUtils.js';
 import { ToolCallPipeline } from './ToolCallPipeline.js';
-import { buildToolResponsePayload } from '../utils/toolResponsePayload.js';
+import { buildToolResponsePayload, EMPTY_TOOL_RESULT_PLACEHOLDER, } from '../utils/toolResponsePayload.js';
 import { isLocalEndpoint } from '../utils/localEndpoint.js';
 import { filterThinkingForContext, thinkingToReasoningField, extractThinkingBlocks, } from '../reasoning/reasoningUtils.js';
 import { shouldDumpSDKContext, dumpSDKContext, } from '../utils/dumpSDKContext.js';
 import { extractCacheMetrics } from '../utils/cacheMetricsExtractor.js';
+const MAX_TOOL_RESPONSE_CHARS = 1024;
+const MAX_TOOL_RESPONSE_RETRY_CHARS = 512;
 const TOOL_ARGS_PREVIEW_LENGTH = 500;
+const TEXTUAL_TOOL_REPLAY_MODELS = new Set(['openrouter/polaris-alpha']);
 export class OpenAIProvider extends BaseProvider {
     textToolParser = new GemmaToolCallParser();
     toolCallPipeline = new ToolCallPipeline();
@@ -50,38 +52,6 @@ export class OpenAIProvider extends BaseProvider {
     getLogger() {
         return new DebugLogger('llxprt:provider:openai');
     }
-    async handleBucketFailoverOnPersistent429(options, logger) {
-        const failoverHandler = options.runtime?.config?.getBucketFailoverHandler();
-        if (!failoverHandler || !failoverHandler.isEnabled()) {
-            return { result: null };
-        }
-        logger.debug(() => 'Attempting bucket failover on persistent 429');
-        const success = await failoverHandler.tryFailover();
-        if (!success) {
-            logger.debug(() => 'Bucket failover failed - no more buckets available');
-            return { result: false };
-        }
-        const previousAuthToken = options.resolved.authToken;
-        try {
-            // Clear runtime-scoped auth cache so subsequent auth resolution can pick up the new bucket.
-            if (typeof options.runtime?.runtimeId === 'string') {
-                flushRuntimeAuthScope(options.runtime.runtimeId);
-            }
-            // Force re-resolution of the auth token after bucket failover.
-            options.resolved.authToken = '';
-            const refreshedAuthToken = await this.getAuthTokenForPrompt();
-            options.resolved.authToken = refreshedAuthToken;
-            // Rebuild client with fresh credentials from new bucket
-            const client = await this.getClient(options);
-            logger.debug(() => `Bucket failover successful, new bucket: ${failoverHandler.getCurrentBucket()}`);
-            return { result: true, client };
-        }
-        catch (error) {
-            options.resolved.authToken = previousAuthToken;
-            logger.debug(() => `Bucket failover auth refresh failed: ${error instanceof Error ? error.message : String(error)}`);
-            return { result: false };
-        }
-    }
     /**
      * @plan:PLAN-20251023-STATELESS-HARDENING.P08
      * @requirement:REQ-SP4-003
@@ -857,6 +827,39 @@ export class OpenAIProvider extends BaseProvider {
         }
         return JSON.stringify({ value: parameters });
     }
+    determineToolReplayMode(model) {
+        if (!model) {
+            return 'native';
+        }
+        const normalized = model.toLowerCase();
+        if (TEXTUAL_TOOL_REPLAY_MODELS.has(normalized)) {
+            return 'textual';
+        }
+        return 'native';
+    }
+    describeToolCallForText(block) {
+        const normalizedArgs = this.normalizeToolCallArguments(block.parameters);
+        const preview = normalizedArgs.length > MAX_TOOL_RESPONSE_CHARS
+            ? `${normalizedArgs.slice(0, MAX_TOOL_RESPONSE_CHARS)}… [truncated ${normalizedArgs.length - MAX_TOOL_RESPONSE_CHARS} chars]`
+            : normalizedArgs;
+        const callId = block.id ? ` ${this.normalizeToOpenAIToolId(block.id)}` : '';
+        return `[TOOL CALL${callId ? ` ${callId}` : ''}] ${block.name ?? 'unknown_tool'} args=${preview}`;
+    }
+    describeToolResponseForText(block, config) {
+        const payload = buildToolResponsePayload(block, config);
+        const header = `[TOOL RESULT] ${payload.toolName ?? block.toolName ?? 'unknown_tool'} (${payload.status ?? 'unknown'})`;
+        const bodyParts = [];
+        if (payload.error) {
+            bodyParts.push(`error: ${payload.error}`);
+        }
+        if (payload.result && payload.result !== EMPTY_TOOL_RESULT_PLACEHOLDER) {
+            bodyParts.push(payload.result);
+        }
+        if (payload.limitMessage) {
+            bodyParts.push(payload.limitMessage);
+        }
+        return bodyParts.length > 0 ? `${header}\n${bodyParts.join('\n')}` : header;
+    }
     buildToolResponseContent(block, config) {
         const payload = buildToolResponsePayload(block, config);
         return ensureJsonSafe(JSON.stringify(payload));
@@ -908,6 +911,107 @@ export class OpenAIProvider extends BaseProvider {
         });
         return modified;
     }
+    /**
+     * Convert IContent array to OpenAI ChatCompletionMessageParam array
+     */
+    convertToOpenAIMessages(contents, mode = 'native', config) {
+        const messages = [];
+        for (const content of contents) {
+            if (content.speaker === 'human') {
+                // Convert human messages to user messages
+                const textBlocks = content.blocks.filter((b) => b.type === 'text');
+                const text = textBlocks.map((b) => b.text).join('\n');
+                if (text) {
+                    messages.push({
+                        role: 'user',
+                        content: text,
+                    });
+                }
+            }
+            else if (content.speaker === 'ai') {
+                // Convert AI messages
+                const textBlocks = content.blocks.filter((b) => b.type === 'text');
+                const text = textBlocks.map((b) => b.text).join('\n');
+                const toolCalls = content.blocks.filter((b) => b.type === 'tool_call');
+                if (toolCalls.length > 0) {
+                    if (mode === 'textual') {
+                        const segments = [];
+                        if (text) {
+                            segments.push(text);
+                        }
+                        for (const tc of toolCalls) {
+                            segments.push(this.describeToolCallForText(tc));
+                        }
+                        const combined = segments.join('\n\n').trim();
+                        if (combined) {
+                            messages.push({
+                                role: 'assistant',
+                                content: combined,
+                            });
+                        }
+                    }
+                    else {
+                        // Assistant message with tool calls
+                        // CRITICAL for Mistral API compatibility (#760):
+                        // When tool_calls are present, we must NOT include a content property at all
+                        // (not even null). Mistral's OpenAI-compatible API requires this.
+                        // See: https://docs.mistral.ai/capabilities/function_calling
+                        messages.push({
+                            role: 'assistant',
+                            tool_calls: toolCalls.map((tc) => ({
+                                id: this.normalizeToOpenAIToolId(tc.id),
+                                type: 'function',
+                                function: {
+                                    name: tc.name,
+                                    arguments: this.normalizeToolCallArguments(tc.parameters),
+                                },
+                            })),
+                        });
+                    }
+                }
+                else if (textBlocks.length > 0) {
+                    // Plain assistant message
+                    messages.push({
+                        role: 'assistant',
+                        content: text,
+                    });
+                }
+            }
+            else if (content.speaker === 'tool') {
+                // Convert tool responses
+                const toolResponses = content.blocks.filter((b) => b.type === 'tool_response');
+                if (mode === 'textual') {
+                    const segments = toolResponses
+                        .map((tr) => this.describeToolResponseForText(tr, config))
+                        .filter(Boolean);
+                    if (segments.length > 0) {
+                        messages.push({
+                            role: 'user',
+                            content: segments.join('\n\n'),
+                        });
+                    }
+                }
+                else {
+                    for (const tr of toolResponses) {
+                        // CRITICAL for Mistral API compatibility (#760):
+                        // Tool messages must include a name field matching the function name.
+                        // See: https://docs.mistral.ai/capabilities/function_calling
+                        // Note: The OpenAI SDK types don't include name, but Mistral requires it.
+                        // We use a type assertion to add this required field.
+                        messages.push({
+                            role: 'tool',
+                            content: this.buildToolResponseContent(tr, config),
+                            tool_call_id: this.normalizeToOpenAIToolId(tr.callId),
+                            name: tr.toolName,
+                        });
+                    }
+                }
+            }
+        }
+        // Validate tool message sequence to prevent API errors
+        // This ensures each tool message has a corresponding tool_calls in previous message
+        return this.validateToolMessageSequence(messages);
+    }
     /**
      * Build messages with optional reasoning_content based on settings.
      *
@@ -1162,6 +1266,7 @@ export class OpenAIProvider extends BaseProvider {
     async *generateLegacyChatCompletionImpl(options, toolFormatter, client, logger) {
         const { contents, tools, metadata } = options;
         const model = options.resolved.model || this.getDefaultModel();
+        const toolReplayMode = this.determineToolReplayMode(model);
         const abortSignal = metadata?.abortSignal;
         const ephemeralSettings = options.invocation?.ephemerals ?? {};
         if (logger.enabled) {
@@ -1189,7 +1294,12 @@ export class OpenAIProvider extends BaseProvider {
         // Convert IContent to OpenAI messages format
         // Use buildMessagesWithReasoning for reasoning-aware message building
         // Pass detectedFormat so that Kimi K2 tool IDs are generated correctly
-        const messages = this.buildMessagesWithReasoning(contents, options, detectedFormat);
+        const messages = toolReplayMode === 'native'
+            ? this.buildMessagesWithReasoning(contents, options, detectedFormat)
+            : this.convertToOpenAIMessages(contents, toolReplayMode, options.config ?? options.runtime?.config ?? this.globalConfig);
+        if (logger.enabled && toolReplayMode !== 'native') {
+            logger.debug(() => `[OpenAIProvider] Using textual tool replay mode for model '${model}'`);
+        }
         // Convert Gemini format tools to OpenAI format using the schema converter
         // This ensures required fields are always present in tool schemas
         let formattedTools = convertToolsToOpenAI(tools);
@@ -1384,11 +1494,22 @@ export class OpenAIProvider extends BaseProvider {
         // Bucket failover callback for 429 errors
         // @plan PLAN-20251213issue686 Bucket failover integration for OpenAIProvider
         const onPersistent429Callback = async () => {
-            const { result, client } = await this.handleBucketFailoverOnPersistent429(options, logger);
-            if (client) {
-                failoverClient = client;
-            }
-            return result;
+            // Try to get the bucket failover handler from runtime context config
+            const failoverHandler = options.runtime?.config?.getBucketFailoverHandler();
+            if (failoverHandler && failoverHandler.isEnabled()) {
+                logger.debug(() => 'Attempting bucket failover on persistent 429');
+                const success = await failoverHandler.tryFailover();
+                if (success) {
+                    // Rebuild client with fresh credentials from new bucket
+                    failoverClient = await this.getClient(options);
+                    logger.debug(() => `Bucket failover successful, new bucket: ${failoverHandler.getCurrentBucket()}`);
+                    return true; // Signal retry with new bucket
+                }
+                logger.debug(() => 'Bucket failover failed - no more buckets available');
+                return false; // No more buckets, stop retrying
+            }
+            // No bucket failover configured
+            return null;
         };
         // Use failover client if bucket failover happened, otherwise use original client
         const executeRequest = () => {
@@ -1447,7 +1568,7 @@ export class OpenAIProvider extends BaseProvider {
                     }
                     if (!compressedOnce &&
                         this.shouldCompressToolMessages(error, logger) &&
-                        this.compressToolMessages(requestBody.messages, 512, logger)) {
+                        this.compressToolMessages(requestBody.messages, MAX_TOOL_RESPONSE_RETRY_CHARS, logger)) {
                         compressedOnce = true;
                         logger.warn(() => `[OpenAIProvider] Retrying request after compressing tool responses due to provider 400`);
                         continue;
@@ -2351,6 +2472,8 @@ export class OpenAIProvider extends BaseProvider {
                 metadataKeys: Object.keys(metadata ?? {}),
             });
         }
+        // Determine tool replay mode for model compatibility (e.g., polaris-alpha)
+        const toolReplayMode = this.determineToolReplayMode(model);
         // Detect the tool format to use BEFORE building messages
         // This is needed so that Kimi K2 tool IDs can be generated in the correct format
         const detectedFormat = this.detectToolFormat();
@@ -2363,7 +2486,13 @@ export class OpenAIProvider extends BaseProvider {
         // Convert IContent to OpenAI messages format
         // Use buildMessagesWithReasoning for reasoning-aware message building
         // Pass detectedFormat so that Kimi K2 tool IDs are generated correctly
-        const messages = this.buildMessagesWithReasoning(contents, options, detectedFormat);
+        const messages = toolReplayMode === 'native'
+            ? this.buildMessagesWithReasoning(contents, options, detectedFormat)
+            : this.convertToOpenAIMessages(contents, toolReplayMode, options.config ?? options.runtime?.config ?? this.globalConfig);
+        // Log tool replay mode usage for debugging
+        if (logger.enabled && toolReplayMode !== 'native') {
+            logger.debug(() => `[OpenAIProvider] Using textual tool replay mode for model '${model}'`);
+        }
         // Convert Gemini format tools to OpenAI format using the schema converter
         // This ensures required fields are always present in tool schemas
         let formattedTools = convertToolsToOpenAI(tools);
@@ -2514,11 +2643,22 @@ export class OpenAIProvider extends BaseProvider {
         // Bucket failover callback for 429 errors - tools mode
         // @plan PLAN-20251213issue686 Bucket failover integration for OpenAIProvider
         const onPersistent429CallbackTools = async () => {
-            const { result, client } = await this.handleBucketFailoverOnPersistent429(options, logger);
-            if (client) {
-                failoverClientTools = client;
-            }
-            return result;
+            // Try to get the bucket failover handler from runtime context config
+            const failoverHandler = options.runtime?.config?.getBucketFailoverHandler();
+            if (failoverHandler && failoverHandler.isEnabled()) {
+                logger.debug(() => 'Attempting bucket failover on persistent 429');
+                const success = await failoverHandler.tryFailover();
+                if (success) {
+                    // Rebuild client with fresh credentials from new bucket
+                    failoverClientTools = await this.getClient(options);
+                    logger.debug(() => `Bucket failover successful, new bucket: ${failoverHandler.getCurrentBucket()}`);
+                    return true; // Signal retry with new bucket
+                }
+                logger.debug(() => 'Bucket failover failed - no more buckets available');
+                return false; // No more buckets, stop retrying
+            }
+            // No bucket failover configured
+            return null;
         };
         if (streamingEnabled) {
             // Streaming mode - use retry loop with compression support
@@ -2567,7 +2707,7 @@ export class OpenAIProvider extends BaseProvider {
                     // Tool message compression logic
                     if (!compressedOnce &&
                         this.shouldCompressToolMessages(error, logger) &&
-                        this.compressToolMessages(requestBody.messages, 512, logger)) {
+                        this.compressToolMessages(requestBody.messages, MAX_TOOL_RESPONSE_RETRY_CHARS, logger)) {
                         compressedOnce = true;
                         logger.warn(() => `[OpenAIProvider] Retrying streaming request after compressing tool responses due to provider 400`);
                         continue;
@@ -2650,7 +2790,7 @@ export class OpenAIProvider extends BaseProvider {
                     // Tool message compression logic
                     if (!compressedOnce &&
                         this.shouldCompressToolMessages(error, logger) &&
-                        this.compressToolMessages(requestBody.messages, 512, logger)) {
+                        this.compressToolMessages(requestBody.messages, MAX_TOOL_RESPONSE_RETRY_CHARS, logger)) {
                         compressedOnce = true;
                         logger.warn(() => `[OpenAIProvider] Retrying request after compressing tool responses due to provider 400`);
                         continue;