@vybestack/llxprt-code-core 0.7.0-nightly.251218.472c013d2 → 0.7.0-nightly.251219.3619c584b

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

@@ -25,6 +25,7 @@ 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';
@@ -36,15 +37,12 @@ import { resolveRuntimeAuthToken } from '../utils/authToken.js';
 import { filterOpenAIRequestParams } from './openaiRequestParams.js';
 import { ensureJsonSafe } from '../../utils/unicodeUtils.js';
 import { ToolCallPipeline } from './ToolCallPipeline.js';
-import { buildToolResponsePayload, EMPTY_TOOL_RESULT_PLACEHOLDER, } from '../utils/toolResponsePayload.js';
+import { buildToolResponsePayload } 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();
@@ -52,6 +50,38 @@ 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
@@ -827,39 +857,6 @@ 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));
@@ -911,107 +908,6 @@ 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.
      *
@@ -1266,7 +1162,6 @@ 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) {
@@ -1294,12 +1189,7 @@ 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 = 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}'`);
-        }
+        const messages = this.buildMessagesWithReasoning(contents, options, detectedFormat);
         // 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);
@@ -1494,22 +1384,11 @@ export class OpenAIProvider extends BaseProvider {
         // Bucket failover callback for 429 errors
         // @plan PLAN-20251213issue686 Bucket failover integration for OpenAIProvider
         const onPersistent429Callback = async () => {
-            // 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;
+            const { result, client } = await this.handleBucketFailoverOnPersistent429(options, logger);
+            if (client) {
+                failoverClient = client;
+            }
+            return result;
         };
         // Use failover client if bucket failover happened, otherwise use original client
         const executeRequest = () => {
@@ -1568,7 +1447,7 @@ export class OpenAIProvider extends BaseProvider {
                     }
                     if (!compressedOnce &&
                         this.shouldCompressToolMessages(error, logger) &&
-                        this.compressToolMessages(requestBody.messages, MAX_TOOL_RESPONSE_RETRY_CHARS, logger)) {
+                        this.compressToolMessages(requestBody.messages, 512, logger)) {
                         compressedOnce = true;
                         logger.warn(() => `[OpenAIProvider] Retrying request after compressing tool responses due to provider 400`);
                         continue;
@@ -2472,8 +2351,6 @@ 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();
@@ -2486,13 +2363,7 @@ 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 = 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}'`);
-        }
+        const messages = this.buildMessagesWithReasoning(contents, options, detectedFormat);
         // 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);
@@ -2643,22 +2514,11 @@ export class OpenAIProvider extends BaseProvider {
         // Bucket failover callback for 429 errors - tools mode
         // @plan PLAN-20251213issue686 Bucket failover integration for OpenAIProvider
         const onPersistent429CallbackTools = async () => {
-            // 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;
+            const { result, client } = await this.handleBucketFailoverOnPersistent429(options, logger);
+            if (client) {
+                failoverClientTools = client;
+            }
+            return result;
         };
         if (streamingEnabled) {
             // Streaming mode - use retry loop with compression support
@@ -2707,7 +2567,7 @@ export class OpenAIProvider extends BaseProvider {
                     // Tool message compression logic
                     if (!compressedOnce &&
                         this.shouldCompressToolMessages(error, logger) &&
-                        this.compressToolMessages(requestBody.messages, MAX_TOOL_RESPONSE_RETRY_CHARS, logger)) {
+                        this.compressToolMessages(requestBody.messages, 512, logger)) {
                         compressedOnce = true;
                         logger.warn(() => `[OpenAIProvider] Retrying streaming request after compressing tool responses due to provider 400`);
                         continue;
@@ -2790,7 +2650,7 @@ export class OpenAIProvider extends BaseProvider {
                     // Tool message compression logic
                     if (!compressedOnce &&
                         this.shouldCompressToolMessages(error, logger) &&
-                        this.compressToolMessages(requestBody.messages, MAX_TOOL_RESPONSE_RETRY_CHARS, logger)) {
+                        this.compressToolMessages(requestBody.messages, 512, logger)) {
                         compressedOnce = true;
                         logger.warn(() => `[OpenAIProvider] Retrying request after compressing tool responses due to provider 400`);
                         continue;