@office-ai/aioncli-core 0.18.6 → 0.18.7

package/dist/src/core/openaiContentGenerator.d.ts

@@ -13,6 +13,7 @@ export declare class OpenAIContentGenerator implements ContentGenerator {
     private model;
     private config;
     private streamingToolCalls;
+    private streamingReasoningDetails;
     constructor(apiKey: string, model: string, config: Config);
     /**
      * Hook for subclasses to customize error handling behavior
@@ -52,11 +53,35 @@ export declare class OpenAIContentGenerator implements ContentGenerator {
      * Check if the current model is a DeepSeek Reasoner model
      */
     private isDeepSeekReasonerModel;
+    /**
+     * Check if the current model is a Gemini reasoning model (Gemini 3, 2.5 series)
+     * These models require reasoning_details/thought_signature for tool calls
+     */
+    private isGeminiReasoningModel;
+    /**
+     * Validate thoughtSignature to prevent "Corrupted thought signature" errors.
+     * Valid thoughtSignature should have properly encrypted data (long base64 strings).
+     * Invalid ones may contain short UUIDs or corrupted data.
+     *
+     * 验证 thoughtSignature 以防止 "Corrupted thought signature" 错误。
+     * 有效的 thoughtSignature 应该包含正确加密的数据（长 base64 字符串）。
+     * 无效的可能包含短 UUID 或损坏的数据。
+     */
+    private isValidThoughtSignature;
     /**
      * Add reasoning_content field to assistant messages for DeepSeek Reasoner compatibility.
      * DeepSeek Reasoner models require reasoning_content field in assistant messages during tool calls.
      */
     private addReasoningContentForDeepSeek;
+    /**
+     * Filter out REASONING_DETAILS_MARKER from text to prevent it from leaking
+     * into messages sent to the model. This can happen when AionUI includes
+     * conversation history that contains the marker.
+     *
+     * 过滤文本中的 REASONING_DETAILS_MARKER，防止其泄露到发送给模型的消息中。
+     * 这种情况可能发生在 AionUI 包含含有 marker 的对话历史时。
+     */
+    private filterReasoningDetailsMarker;
     /**
      * 清理消息历史中的孤立工具调用，防止 OpenAI API 报错。
      * 同时对相同 tool_call_id 的工具响应进行去重，防止不接受重复响应的 API 返回 400 错误。

package/dist/src/core/openaiContentGenerator.js

@@ -9,11 +9,15 @@ import { logApiResponse } from '../telemetry/loggers.js';
 import { toContents } from '../code_assist/converter.js';
 import { ApiResponseEvent } from '../telemetry/types.js';
 import { safeJsonParse } from '../utils/safeJsonParse.js';
+// Special marker for reasoning_details in Part text
+const REASONING_DETAILS_MARKER = '__OPENROUTER_REASONING_DETAILS__:';
 export class OpenAIContentGenerator {
     client;
     model;
     config;
     streamingToolCalls = new Map();
+    // Store reasoning_details for OpenRouter reasoning models (Gemini 3 Pro, etc.)
+    streamingReasoningDetails = null;
     constructor(apiKey, model, config) {
         this.model = model;
         this.config = config;
@@ -163,7 +167,17 @@ export class OpenAIContentGenerator {
             else if (request.config?.tools) {
                 createParams.tools = await this.convertGeminiToolsToOpenAI(request.config.tools);
             }
-            // console.log('createParams', createParams);
+            // Enable reasoning for Gemini 3 models on OpenRouter
+            // This ensures reasoning_details are returned and can be preserved
+            const baseURL = this.client?.baseURL || '';
+            const isOpenRouter = baseURL.includes('openrouter.ai');
+            if (isOpenRouter && this.isGeminiReasoningModel()) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createParams.reasoning = {
+                    // Use 'high' effort for reliable reasoning token generation
+                    effort: 'high',
+                };
+            }
             const completion = (await this.client.chat.completions.create(createParams));
             // Check if this was a JSON schema request
             const isJsonSchemaRequest = !!(request.config?.responseJsonSchema &&
@@ -276,7 +290,17 @@ export class OpenAIContentGenerator {
             else if (request.config?.tools) {
                 createParams.tools = await this.convertGeminiToolsToOpenAI(request.config.tools);
             }
-            // console.log('createParams', createParams);
+            // Enable reasoning for Gemini 3 models on OpenRouter
+            // This ensures reasoning_details are returned and can be preserved
+            const baseURL = this.client?.baseURL || '';
+            const isOpenRouter = baseURL.includes('openrouter.ai');
+            if (isOpenRouter && this.isGeminiReasoningModel()) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                createParams.reasoning = {
+                    // Use 'high' effort for reliable reasoning token generation
+                    effort: 'high',
+                };
+            }
             const stream = (await this.client.chat.completions.create(createParams));
             // Check if this was a JSON schema request
             const isJsonSchemaRequest = !!(request.config?.responseJsonSchema &&
@@ -412,8 +436,9 @@ export class OpenAIContentGenerator {
         }
     }
     async *streamGenerator(stream, isJsonSchemaRequest = false) {
-        // Reset the accumulator for each new stream
+        // Reset the accumulators for each new stream
         this.streamingToolCalls.clear();
+        this.streamingReasoningDetails = null;
         for await (const chunk of stream) {
             yield this.convertStreamChunkToGeminiFormat(chunk, isJsonSchemaRequest);
         }
@@ -732,15 +757,47 @@ export class OpenAIContentGenerator {
                     const functionCalls = [];
                     const functionResponses = [];
                     const textParts = [];
+                    let reasoningDetails = null;
                     for (const part of content.parts || []) {
                         if (typeof part === 'string') {
-                            textParts.push(part);
+                            // Filter out any leaked reasoning_details marker from string parts
+                            const cleanedString = this.filterReasoningDetailsMarker(part);
+                            if (cleanedString) {
+                                textParts.push(cleanedString);
+                            }
                         }
                         else if ('text' in part && part.text) {
-                            textParts.push(part.text);
+                            // Check for special reasoning_details marker (OpenRouter reasoning models)
+                            if (part.thought &&
+                                part.text.startsWith(REASONING_DETAILS_MARKER)) {
+                                try {
+                                    reasoningDetails = JSON.parse(part.text.slice(REASONING_DETAILS_MARKER.length));
+                                }
+                                catch {
+                                    // Invalid JSON, ignore
+                                }
+                            }
+                            else if (!part.thought) {
+                                // Only include non-thought text parts, filter out any leaked markers
+                                const cleanedText = this.filterReasoningDetailsMarker(part.text);
+                                if (cleanedText) {
+                                    textParts.push(cleanedText);
+                                }
+                            }
                         }
                         else if ('functionCall' in part && part.functionCall) {
                             functionCalls.push(part.functionCall);
+                            // Check for thoughtSignature on the Part (Gemini format)
+                            // This is required for OpenRouter/Gemini reasoning models
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            const partAny = part;
+                            if (partAny.thoughtSignature && !reasoningDetails) {
+                                // Only use the first thoughtSignature (parallel calls only have one)
+                                // Validate thoughtSignature before using it to prevent "Corrupted thought signature" errors
+                                if (this.isValidThoughtSignature(partAny.thoughtSignature)) {
+                                    reasoningDetails = partAny.thoughtSignature;
+                                }
+                            }
                         }
                         else if ('functionResponse' in part && part.functionResponse) {
                             functionResponses.push(part.functionResponse);
@@ -768,11 +825,16 @@ export class OpenAIContentGenerator {
                                 arguments: JSON.stringify(fc.args || {}),
                             },
                         }));
-                        messages.push({
+                        const assistantMessage = {
                             role: 'assistant',
                             content: textParts.join('\n') || null,
                             tool_calls: toolCalls,
-                        });
+                        };
+                        // Add reasoning_details if present (required for OpenRouter reasoning models)
+                        if (reasoningDetails) {
+                            assistantMessage.reasoning_details = reasoningDetails;
+                        }
+                        messages.push(assistantMessage);
                     }
                     // Handle regular text messages
                     else {
@@ -781,7 +843,12 @@ export class OpenAIContentGenerator {
                             : 'user';
                         const text = textParts.join('\n');
                         if (text) {
-                            messages.push({ role, content: text });
+                            const message = { role, content: text };
+                            // Add reasoning_details if present and this is an assistant message
+                            if (role === 'assistant' && reasoningDetails) {
+                                message.reasoning_details = reasoningDetails;
+                            }
+                            messages.push(message);
                         }
                     }
                 }
@@ -789,7 +856,10 @@ export class OpenAIContentGenerator {
         }
         else if (request.contents) {
             if (typeof request.contents === 'string') {
-                messages.push({ role: 'user', content: request.contents });
+                const cleanedContent = this.filterReasoningDetailsMarker(request.contents);
+                if (cleanedContent) {
+                    messages.push({ role: 'user', content: cleanedContent });
+                }
             }
             else if ('role' in request.contents && 'parts' in request.contents) {
                 const content = request.contents;
@@ -797,7 +867,10 @@ export class OpenAIContentGenerator {
                 const text = content.parts
                     ?.map((p) => typeof p === 'string' ? p : 'text' in p ? p.text : '')
                     .join('\n') || '';
-                messages.push({ role, content: text });
+                const cleanedText = this.filterReasoningDetailsMarker(text);
+                if (cleanedText) {
+                    messages.push({ role, content: cleanedText });
+                }
             }
         }
         // Clean up orphaned tool calls and merge consecutive assistant messages
@@ -817,6 +890,67 @@ export class OpenAIContentGenerator {
         return (modelName.includes('deepseek-reasoner') ||
             modelName.includes('deepseek-r1'));
     }
+    /**
+     * Check if the current model is a Gemini reasoning model (Gemini 3, 2.5 series)
+     * These models require reasoning_details/thought_signature for tool calls
+     */
+    isGeminiReasoningModel() {
+        const modelName = this.model.toLowerCase();
+        return (modelName.includes('gemini-3') ||
+            modelName.includes('gemini-2.5') ||
+            modelName.includes('gemini-exp') ||
+            modelName.includes('gemini-2.0-flash-thinking'));
+    }
+    /**
+     * Validate thoughtSignature to prevent "Corrupted thought signature" errors.
+     * Valid thoughtSignature should have properly encrypted data (long base64 strings).
+     * Invalid ones may contain short UUIDs or corrupted data.
+     *
+     * 验证 thoughtSignature 以防止 "Corrupted thought signature" 错误。
+     * 有效的 thoughtSignature 应该包含正确加密的数据（长 base64 字符串）。
+     * 无效的可能包含短 UUID 或损坏的数据。
+     */
+    isValidThoughtSignature(thoughtSignature) {
+        if (!thoughtSignature) {
+            return false;
+        }
+        // thoughtSignature can be an array of signature objects or a single object
+        const signatures = Array.isArray(thoughtSignature)
+            ? thoughtSignature
+            : [thoughtSignature];
+        for (const sig of signatures) {
+            if (typeof sig !== 'object' || sig === null) {
+                continue;
+            }
+            const sigObj = sig;
+            const data = sigObj['data'];
+            // Check if data field exists and is a string
+            if (typeof data !== 'string') {
+                return false;
+            }
+            // Valid encrypted data should be significantly longer than a UUID (36 chars)
+            // A UUID in base64 is about 48 chars. Valid reasoning data is typically 100+ chars.
+            // We use 64 as a threshold to filter out UUID-like corrupted data.
+            const MIN_VALID_DATA_LENGTH = 64;
+            if (data.length < MIN_VALID_DATA_LENGTH) {
+                return false;
+            }
+            // Additional check: valid data should start with certain prefixes (Ci, Ev, etc.)
+            // which are common in Google's encrypted reasoning data
+            const validPrefixes = ['Ci', 'Ev', 'Ch', 'Co'];
+            const hasValidPrefix = validPrefixes.some((prefix) => data.startsWith(prefix));
+            if (!hasValidPrefix) {
+                // Check if it looks like a base64-encoded UUID (starts with ZT, ND, etc.)
+                // These are typically invalid
+                const uuidBase64Prefixes = ['ZT', 'ND', 'MW', 'Yz', 'OD'];
+                const looksLikeUuid = uuidBase64Prefixes.some((prefix) => data.startsWith(prefix));
+                if (looksLikeUuid && data.length < 100) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
     /**
      * Add reasoning_content field to assistant messages for DeepSeek Reasoner compatibility.
      * DeepSeek Reasoner models require reasoning_content field in assistant messages during tool calls.
@@ -834,6 +968,23 @@ export class OpenAIContentGenerator {
             return message;
         });
     }
+    /**
+     * Filter out REASONING_DETAILS_MARKER from text to prevent it from leaking
+     * into messages sent to the model. This can happen when AionUI includes
+     * conversation history that contains the marker.
+     *
+     * 过滤文本中的 REASONING_DETAILS_MARKER，防止其泄露到发送给模型的消息中。
+     * 这种情况可能发生在 AionUI 包含含有 marker 的对话历史时。
+     */
+    filterReasoningDetailsMarker(text) {
+        if (!text.includes(REASONING_DETAILS_MARKER)) {
+            return text;
+        }
+        // Remove lines containing the marker (typically: "Assistant: __OPENROUTER_REASONING_DETAILS__:[...]")
+        const lines = text.split('\n');
+        const filteredLines = lines.filter((line) => !line.includes(REASONING_DETAILS_MARKER));
+        return filteredLines.join('\n').trim();
+    }
     /**
      * 清理消息历史中的孤立工具调用，防止 OpenAI API 报错。
      * 同时对相同 tool_call_id 的工具响应进行去重，防止不接受重复响应的 API 返回 400 错误。
@@ -1018,17 +1169,48 @@ export class OpenAIContentGenerator {
                     }
                     else {
                         // Regular tool call handling
-                        parts.push({
+                        // Include thoughtSignature if present (required for Gemini reasoning models)
+                        // Note: thoughtSignature is a SIBLING of functionCall in the Part, not inside it
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const functionCallPart = {
                             functionCall: {
                                 id: toolCall.id,
                                 name: toolCall.function.name,
                                 args,
                             },
-                        });
+                        };
+                        // Check for thought_signature in the tool call (OpenRouter/Gemini)
+                        // Validate before attaching to prevent "Corrupted thought signature" errors
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const toolCallAny = toolCall;
+                        const thoughtSig = toolCallAny.thought_signature ||
+                            toolCallAny.thoughtSignature ||
+                            toolCallAny.function?.thought_signature;
+                        if (thoughtSig && this.isValidThoughtSignature(thoughtSig)) {
+                            functionCallPart.thoughtSignature = thoughtSig;
+                        }
+                        parts.push(functionCallPart);
                     }
                 }
             }
         }
+        // Handle reasoning_details from OpenRouter reasoning models (Gemini 3 Pro, etc.)
+        // Only preserve reasoning_details when there are functionCall parts (for multi-turn tool calls)
+        // For text-only responses, reasoning_details is not needed
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const messageReasoningDetails = choice.message?.reasoning_details;
+        // Validate reasoning_details before attaching to prevent "Corrupted thought signature" errors
+        if (messageReasoningDetails &&
+            this.isValidThoughtSignature(messageReasoningDetails)) {
+            // Attach reasoning_details to the FIRST functionCall Part as thoughtSignature
+            // This is required for Gemini API to process tool calls correctly
+            const firstFunctionCallPart = parts.find((p) => 'functionCall' in p);
+            if (firstFunctionCallPart && !firstFunctionCallPart.thoughtSignature) {
+                firstFunctionCallPart.thoughtSignature = messageReasoningDetails;
+            }
+            // For text-only responses, we don't need to preserve reasoning_details
+            // as they are only required for multi-turn tool calls
+        }
         response.responseId = openaiResponse.id;
         response.createTime = openaiResponse.created
             ? openaiResponse.created.toString()
@@ -1072,6 +1254,8 @@ export class OpenAIContentGenerator {
         return response;
     }
     convertStreamChunkToGeminiFormat(chunk, isJsonSchemaRequest = false) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const chunkAny = chunk;
         const choice = chunk.choices?.[0];
         const response = new GenerateContentResponse();
         if (choice) {
@@ -1080,6 +1264,18 @@ export class OpenAIContentGenerator {
             if (choice.delta?.content) {
                 parts.push({ text: choice.delta.content });
             }
+            // Capture reasoning_details from OpenRouter reasoning models (Gemini 3 Pro, etc.)
+            // Check multiple possible locations where it might be returned
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const choiceAny = choice;
+            const deltaReasoningDetails = choiceAny.delta?.reasoning_details ||
+                choiceAny.reasoning_details ||
+                chunkAny.reasoning_details;
+            // Validate reasoning_details before storing to prevent corrupted data propagation
+            if (deltaReasoningDetails &&
+                this.isValidThoughtSignature(deltaReasoningDetails)) {
+                this.streamingReasoningDetails = deltaReasoningDetails;
+            }
             // Handle tool calls - only accumulate during streaming, emit when complete
             if (choice.delta?.tool_calls) {
                 for (const toolCall of choice.delta.tool_calls) {
@@ -1100,6 +1296,16 @@ export class OpenAIContentGenerator {
                     if (toolCall.function?.arguments) {
                         accumulatedCall.arguments += toolCall.function.arguments;
                     }
+                    // Capture thought_signature for OpenRouter/Gemini reasoning models
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const toolCallAny = toolCall;
+                    if (toolCallAny.thought_signature) {
+                        accumulatedCall.thought_signature = toolCallAny.thought_signature;
+                    }
+                    else if (toolCallAny.function?.thought_signature) {
+                        accumulatedCall.thought_signature =
+                            toolCallAny.function.thought_signature;
+                    }
                 }
             }
             // Only emit function calls when streaming is complete (finish_reason is present)
@@ -1120,18 +1326,41 @@ export class OpenAIContentGenerator {
                         }
                         else {
                             // Regular tool call handling
-                            parts.push({
+                            // Include thoughtSignature if present (required for Gemini reasoning models)
+                            // Note: thoughtSignature is a SIBLING of functionCall in the Part, not inside it
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            const functionCallPart = {
                                 functionCall: {
                                     id: accumulatedCall.id,
                                     name: accumulatedCall.name,
                                     args,
                                 },
-                            });
+                            };
+                            // Add thoughtSignature as sibling of functionCall (Gemini format)
+                            // For the FIRST functionCall, attach the reasoning_details as thoughtSignature
+                            // Validate before attaching to prevent "Corrupted thought signature" errors
+                            if (accumulatedCall.thought_signature &&
+                                this.isValidThoughtSignature(accumulatedCall.thought_signature)) {
+                                functionCallPart.thoughtSignature =
+                                    accumulatedCall.thought_signature;
+                            }
+                            else if (this.streamingReasoningDetails &&
+                                parts.filter((p) => 'functionCall' in p).length === 0) {
+                                // Only attach to the first functionCall (for parallel calls)
+                                // Note: streamingReasoningDetails is already validated when stored
+                                functionCallPart.thoughtSignature =
+                                    this.streamingReasoningDetails;
+                            }
+                            parts.push(functionCallPart);
                         }
                     }
                 }
                 // Clear all accumulated tool calls
                 this.streamingToolCalls.clear();
+                // Clear reasoning_details after processing
+                // For text-only responses, we don't need to preserve reasoning_details
+                // as they are only required for multi-turn tool calls
+                this.streamingReasoningDetails = null;
             }
             response.candidates = [
                 {