@jsonstudio/llms 0.6.473 → 0.6.568

package/dist/conversion/hub/pipeline/compat/compat-pipeline-executor.js

@@ -15,6 +15,7 @@ import { applyGeminiWebSearchCompat } from '../../../compat/actions/gemini-web-s
 import { applyIflowWebSearchRequestTransform } from '../../../compat/actions/iflow-web-search.js';
 import { applyGlmImageContentTransform } from '../../../compat/actions/glm-image-content.js';
 import { applyGlmVisionPromptTransform } from '../../../compat/actions/glm-vision-prompt.js';
+import { applyClaudeThinkingToolSchemaCompat } from '../../../compat/actions/claude-thinking-tools.js';
 const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 const INTERNAL_STATE = Symbol('compat.internal_state');
 export function runRequestCompatPipeline(profileId, payload, options) {
@@ -177,6 +178,11 @@ function applyMapping(root, mapping, state) {
                 replaceRoot(root, applyIflowWebSearchRequestTransform(root, state.adapterContext));
             }
             break;
+        case 'claude_thinking_tool_schema':
+            if (state.direction === 'request') {
+                replaceRoot(root, applyClaudeThinkingToolSchemaCompat(root, state.adapterContext));
+            }
+            break;
         case 'glm_image_content':
             if (state.direction === 'request') {
                 replaceRoot(root, applyGlmImageContentTransform(root));

package/dist/conversion/hub/pipeline/compat/compat-types.d.ts

@@ -108,6 +108,8 @@ export type MappingInstruction = {
     action: 'gemini_web_search_request';
 } | {
     action: 'iflow_web_search_request';
+} | {
+    action: 'claude_thinking_tool_schema';
 };
 export type FilterInstruction = {
     action: 'rate_limit_text';

package/dist/conversion/hub/pipeline/hub-pipeline.d.ts

@@ -1,10 +1,15 @@
 import { Readable } from 'node:stream';
 import type { StandardizedRequest, ProcessedRequest } from '../types/standardized.js';
 import type { JsonObject } from '../types/json.js';
-import type { VirtualRouterConfig, RoutingDecision, RoutingDiagnostics, TargetMetadata } from '../../../router/virtual-router/types.js';
+import type { VirtualRouterConfig, RoutingDecision, RoutingDiagnostics, TargetMetadata, VirtualRouterHealthStore } from '../../../router/virtual-router/types.js';
 import { type HubProcessNodeResult } from '../process/chat-process.js';
 export interface HubPipelineConfig {
     virtualRouter: VirtualRouterConfig;
+    /**
+     * 可选：供 VirtualRouterEngine 使用的健康状态持久化存储。
+     * 当提供时，VirtualRouterEngine 将在初始化时恢复上一次快照，并在 cooldown/熔断变化时调用 persistSnapshot。
+     */
+    healthStore?: VirtualRouterHealthStore;
 }
 export interface HubPipelineRequestMetadata extends Record<string, unknown> {
     entryEndpoint?: string;

package/dist/conversion/hub/pipeline/hub-pipeline.js

@@ -28,7 +28,9 @@ export class HubPipeline {
     unsubscribeProviderErrors;
     constructor(config) {
         this.config = config;
-        this.routerEngine = new VirtualRouterEngine();
+        this.routerEngine = new VirtualRouterEngine({
+            healthStore: config.healthStore
+        });
         this.routerEngine.initialize(config.virtualRouter);
         try {
             this.unsubscribeProviderErrors = providerErrorCenter.subscribe((event) => {
@@ -122,6 +124,8 @@ export class HubPipeline {
             ? normalizedMeta.responsesResume
             : undefined;
         const stdMetadata = workingRequest?.metadata;
+        const hasImageAttachment = (stdMetadata?.hasImageAttachment === true || stdMetadata?.hasImageAttachment === 'true') ||
+            (normalizedMeta?.hasImageAttachment === true || normalizedMeta?.hasImageAttachment === 'true');
         const serverToolRequired = stdMetadata?.webSearchEnabled === true ||
             stdMetadata?.serverToolRequired === true;
         const sessionIdentifiers = extractSessionIdentifiersFromMetadata(normalized.metadata);
@@ -240,22 +244,26 @@ export class HubPipeline {
         }
         // 为响应侧 servertool/web_search 提供一次性 Chat 请求快照，便于在 Hub 内部实现
         // 第三跳（将工具结果注入消息历史后重新调用主模型）。
+        //
+        // 注意：这里不再根据 processMode(passthrough/chat) 做分支判断——即使某些
+        // route 将 processMode 标记为 passthrough，我们仍然需要保留一次规范化后的
+        // Chat 请求快照，供 stopMessage / gemini_empty_reply_continue 等被动触发型
+        // servertool 在响应阶段使用。
         let capturedChatRequest;
-        if (normalized.processMode !== 'passthrough') {
-            try {
-                capturedChatRequest = JSON.parse(JSON.stringify({
-                    model: workingRequest.model,
-                    messages: workingRequest.messages,
-                    tools: workingRequest.tools,
-                    parameters: workingRequest.parameters
-                }));
-            }
-            catch {
-                capturedChatRequest = undefined;
-            }
+        try {
+            capturedChatRequest = JSON.parse(JSON.stringify({
+                model: workingRequest.model,
+                messages: workingRequest.messages,
+                tools: workingRequest.tools,
+                parameters: workingRequest.parameters
+            }));
+        }
+        catch {
+            capturedChatRequest = undefined;
         }
         const metadata = {
             ...normalized.metadata,
+            ...(hasImageAttachment ? { hasImageAttachment: true } : {}),
             ...(capturedChatRequest ? { capturedChatRequest } : {}),
             entryEndpoint: normalized.entryEndpoint,
             providerProtocol: outboundProtocol,
@@ -382,6 +390,25 @@ export class HubPipeline {
             adapterContext.serverToolFollowup = metadata
                 .serverToolFollowup;
         }
+        const sessionId = typeof metadata.sessionId === 'string'
+            ? metadata.sessionId.trim()
+            : '';
+        if (sessionId) {
+            adapterContext.sessionId = sessionId;
+        }
+        const conversationId = typeof metadata.conversationId === 'string'
+            ? metadata.conversationId.trim()
+            : '';
+        if (conversationId) {
+            adapterContext.conversationId = conversationId;
+        }
+        const responsesResume = metadata.responsesResume &&
+            typeof metadata.responsesResume === 'object'
+            ? metadata.responsesResume
+            : undefined;
+        if (responsesResume) {
+            adapterContext.responsesResume = responsesResume;
+        }
         if (target?.compatibilityProfile && typeof target.compatibilityProfile === 'string') {
             adapterContext.compatibilityProfile = target.compatibilityProfile;
         }

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/index.js

@@ -98,6 +98,21 @@ function collectToolOutputs(payload) {
         if (!id) {
             return;
         }
+        // 针对 apply_patch 工具的失败结果做醒目日志，便于监控
+        try {
+            const name = typeof entry.name === 'string' ? entry.name.trim() : undefined;
+            const output = typeof entry.output === 'string' ? entry.output : undefined;
+            if (name === 'apply_patch' &&
+                output &&
+                output.toLowerCase().includes('apply_patch verification failed')) {
+                const firstLine = output.split('\n')[0] ?? output;
+                // eslint-disable-next-line no-console
+                console.error(`\x1b[31m[apply_patch][tool_error] tool_call_id=${id} ${firstLine}\x1b[0m`);
+            }
+        }
+        catch {
+            // logging best-effort
+        }
         if (seen.has(id)) {
             return;
         }

package/dist/conversion/hub/process/chat-process.js

@@ -1,6 +1,7 @@
 import { runChatRequestToolFilters } from '../../shared/tool-filter-pipeline.js';
 import { ToolGovernanceEngine } from '../tool-governance/index.js';
 import { detectLastAssistantToolCategory } from '../../../router/virtual-router/tool-signals.js';
+import { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
     const startTime = Date.now();
@@ -72,6 +73,12 @@ async function applyRequestToolGovernance(request, context) {
             governanceTimestamp: Date.now()
         }
     };
+    // 清理历史图片：仅保留「最新一条 user 消息」中的图片分段，
+    // 避免历史对话中的图片在后续多轮工具 / 普通对话中继续作为多模态负载发给不支持图片的模型。
+    merged = {
+        ...merged,
+        messages: stripHistoricalImageAttachments(merged.messages)
+    };
     if (containsImageAttachment(merged.messages)) {
         if (!merged.metadata) {
             merged.metadata = {
@@ -205,30 +212,114 @@ function castSingleTool(tool) {
         }
     };
 }
-function containsImageAttachment(messages) {
-    if (!Array.isArray(messages)) {
-        return false;
+function stripHistoricalImageAttachments(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return messages;
+    }
+    // 找到最新一条 user 消息，仅允许该消息保留图片分段；
+    // 更早的 user 消息中若存在图片，则移除其 image* 分段，保留纯文本与非图片内容。
+    let latestUserIndex = -1;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (candidate && typeof candidate === 'object' && candidate.role === 'user') {
+            latestUserIndex = idx;
+            break;
+        }
+    }
+    if (latestUserIndex < 0) {
+        return messages;
     }
-    for (const message of messages) {
+    let changed = false;
+    const next = messages.slice();
+    for (let idx = 0; idx < messages.length; idx += 1) {
+        if (idx === latestUserIndex) {
+            continue;
+        }
+        const message = messages[idx];
         if (!message || typeof message !== 'object') {
             continue;
         }
+        if (message.role !== 'user') {
+            continue;
+        }
         const content = message.content;
-        if (!Array.isArray(content)) {
+        if (!Array.isArray(content) || !content.length) {
             continue;
         }
+        const filtered = [];
+        let removed = false;
         for (const part of content) {
-            if (!part || typeof part !== 'object') {
-                continue;
-            }
-            const typeValue = part.type;
-            if (typeof typeValue !== 'string') {
-                continue;
-            }
-            const normalized = typeValue.toLowerCase();
-            if (normalized.includes('image')) {
-                return true;
+            if (part && typeof part === 'object' && !Array.isArray(part)) {
+                const typeValue = part.type;
+                if (typeof typeValue === 'string' && typeValue.toLowerCase().includes('image')) {
+                    removed = true;
+                    continue;
+                }
             }
+            filtered.push(part);
+        }
+        if (removed) {
+            const cloned = {
+                ...message,
+                content: filtered
+            };
+            next[idx] = cloned;
+            changed = true;
+        }
+    }
+    return changed ? next : messages;
+}
+function containsImageAttachment(messages) {
+    if (!Array.isArray(messages) || !messages.length) {
+        return false;
+    }
+    // 仅检查当前请求中「最新一条 user 消息」是否携带图片，避免历史对话中的图片导致后续轮次反复触发。
+    let latestUser;
+    for (let idx = messages.length - 1; idx >= 0; idx -= 1) {
+        const candidate = messages[idx];
+        if (candidate && typeof candidate === 'object' && candidate.role === 'user') {
+            latestUser = candidate;
+            break;
+        }
+    }
+    if (!latestUser) {
+        return false;
+    }
+    const content = latestUser.content;
+    if (!Array.isArray(content)) {
+        return false;
+    }
+    for (const part of content) {
+        if (!part || typeof part !== 'object') {
+            continue;
+        }
+        const typeValue = part.type;
+        if (typeof typeValue !== 'string') {
+            continue;
+        }
+        const normalized = typeValue.toLowerCase();
+        if (!normalized.includes('image')) {
+            continue;
+        }
+        const record = part;
+        let imageCandidate = '';
+        if (typeof record.image_url === 'string') {
+            imageCandidate = record.image_url;
+        }
+        else if (record.image_url && typeof record.image_url.url === 'string') {
+            imageCandidate = record.image_url.url ?? '';
+        }
+        else if (typeof record.url === 'string') {
+            imageCandidate = record.url;
+        }
+        else if (typeof record.uri === 'string') {
+            imageCandidate = record.uri;
+        }
+        else if (typeof record.data === 'string') {
+            imageCandidate = record.data;
+        }
+        if (imageCandidate.trim().length > 0) {
+            return true;
         }
     }
     return false;
@@ -251,17 +342,7 @@ function castCustomTool(tool) {
         function: {
             name: 'apply_patch',
             description,
-            parameters: {
-                type: 'object',
-                properties: {
-                    patch: {
-                        type: 'string',
-                        description: 'Unified diff patch content (FREEFORM, not JSON)'
-                    }
-                },
-                required: ['patch'],
-                additionalProperties: false
-            },
+            parameters: ensureApplyPatchSchema(),
             strict: true
         }
     };

package/dist/conversion/hub/semantic-mappers/anthropic-mapper.js

@@ -200,6 +200,14 @@ export class AnthropicSemanticMapper {
         return chatEnvelope;
     }
     async fromChat(chat, ctx) {
+        // Ensure tool_use / tool_result ordering and per-session history for /v1/messages style entrypoints.
+        try {
+            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
+            await applyToolSessionCompat(chat, ctx);
+        }
+        catch {
+            // best-effort compat; do not block outbound mapping
+        }
         const model = chat.parameters?.model;
         if (typeof model !== 'string' || !model.trim()) {
             throw new Error('ChatEnvelope.parameters.model is required for anthropic-messages outbound conversion');

package/dist/conversion/hub/semantic-mappers/gemini-mapper.js

@@ -6,6 +6,7 @@ import { encodeMetadataPassthrough, extractMetadataPassthrough } from '../../sha
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge, buildGeminiToolsFromBridge } from '../../shared/gemini-tool-utils.js';
 import { ensureProtocolState, getProtocolState } from '../../shared/protocol-state.js';
+import { applyClaudeThinkingToolSchemaCompat } from '../../compat/actions/claude-thinking-tools.js';
 const GENERATION_CONFIG_KEYS = [
     { source: 'temperature', target: 'temperature' },
     { source: 'topP', target: 'top_p' },
@@ -285,6 +286,14 @@ function appendChatContentToGeminiParts(message, targetParts) {
 function buildGeminiRequestFromChat(chat, metadata) {
     const contents = [];
     const emittedToolOutputs = new Set();
+    const adapterContext = metadata?.context;
+    const rawProviderId = adapterContext?.providerId;
+    const normalizedProviderId = typeof rawProviderId === 'string' ? rawProviderId.toLowerCase() : '';
+    const providerIdPrefix = normalizedProviderId.split('.')[0];
+    // 保持对通用 gemini-cli 的保护（避免上游直接执行 functionCall），
+    // 但对于 antigravity.* 明确允许通过 Gemini functionCall 协议执行工具，
+    // 以便完整打通 tools → functionCall → functionResponse 链路。
+    const omitFunctionCallPartsForCli = providerIdPrefix === 'gemini-cli';
     for (const message of chat.messages) {
         if (!message || typeof message !== 'object')
             continue;
@@ -303,10 +312,15 @@ function buildGeminiRequestFromChat(chat, metadata) {
             parts: []
         };
         appendChatContentToGeminiParts(message, entry.parts);
-        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        const toolCalls = Array.isArray(message.tool_calls)
+            ? message.tool_calls
+            : [];
         for (const tc of toolCalls) {
             if (!tc || typeof tc !== 'object')
                 continue;
+            if (omitFunctionCallPartsForCli) {
+                continue;
+            }
             const fn = tc.function || {};
             const name = typeof fn.name === 'string' ? fn.name : undefined;
             if (!name)
@@ -323,7 +337,8 @@ function buildGeminiRequestFromChat(chat, metadata) {
             else {
                 argsStruct = fn.arguments ?? {};
             }
-            const part = { functionCall: { name, args: cloneAsJsonValue(argsStruct) } };
+            const functionCall = { name, args: cloneAsJsonValue(argsStruct) };
+            const part = { functionCall };
             if (typeof tc.id === 'string') {
                 part.functionCall.id = tc.id;
             }
@@ -385,13 +400,6 @@ function buildGeminiRequestFromChat(chat, metadata) {
     if (Object.keys(generationConfig).length) {
         request.generationConfig = generationConfig;
     }
-    if (metadata?.extraFields && isJsonObject(metadata.extraFields)) {
-        for (const [key, value] of Object.entries(metadata.extraFields)) {
-            if (request[key] === undefined) {
-                request[key] = value;
-            }
-        }
-    }
     if (metadata?.providerMetadata && isJsonObject(metadata.providerMetadata)) {
         request.metadata = jsonClone(metadata.providerMetadata);
     }
@@ -413,7 +421,10 @@ function buildGeminiRequestFromChat(chat, metadata) {
             request.metadata[key] = value;
         }
     }
-    return request;
+    // Apply claude-thinking compat directly at Gemini mapping time to ensure it is always active
+    // for antigravity.*.claude-sonnet-4-5-thinking, regardless of compatibilityProfile wiring.
+    const compatRequest = applyClaudeThinkingToolSchemaCompat(request, adapterContext);
+    return compatRequest;
 }
 function buildGenerationConfigFromParameters(parameters) {
     const config = {};
@@ -570,6 +581,13 @@ export class GeminiSemanticMapper {
         };
     }
     async fromChat(chat, ctx) {
+        try {
+            const { applyToolSessionCompat } = await import('../tool-session-compat.js');
+            await applyToolSessionCompat(chat, ctx);
+        }
+        catch {
+            // best-effort compat; do not block outbound mapping
+        }
         const envelopePayload = buildGeminiRequestFromChat(chat, chat.metadata);
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'gemini-chat' });

package/dist/conversion/hub/semantic-mappers/responses-mapper.js

@@ -53,6 +53,41 @@ function mapToolOutputs(entries, missing) {
     });
     return outputs.length ? outputs : undefined;
 }
+function deriveResumeToolOutputs(ctx) {
+    if (!ctx || typeof ctx !== 'object') {
+        return undefined;
+    }
+    const resume = ctx.responsesResume;
+    if (!resume || typeof resume !== 'object') {
+        return undefined;
+    }
+    const detailed = Array.isArray(resume.toolOutputsDetailed)
+        ? resume.toolOutputsDetailed
+        : undefined;
+    if (!detailed || detailed.length === 0) {
+        return undefined;
+    }
+    const outputs = [];
+    detailed.forEach((entry, index) => {
+        if (!entry || typeof entry !== 'object') {
+            return;
+        }
+        const callIdRaw = typeof entry.callId === 'string' && entry.callId.trim().length
+            ? entry.callId.trim()
+            : typeof entry.originalId === 'string' && entry.originalId.trim().length
+                ? entry.originalId.trim()
+                : `resume_tool_${index}`;
+        if (!callIdRaw) {
+            return;
+        }
+        const outputText = typeof entry.outputText === 'string' ? entry.outputText : '';
+        outputs.push({
+            tool_call_id: callIdRaw,
+            content: outputText
+        });
+    });
+    return outputs.length ? outputs : undefined;
+}
 function collectParameters(payload, streamHint) {
     const params = {};
     for (const key of RESPONSES_PARAMETER_KEYS) {
@@ -169,16 +204,30 @@ export class ResponsesSemanticMapper {
         const { request, toolsNormalized } = buildChatRequestFromResponses(payload, responsesContext);
         const missingFields = [];
         const messages = normalizeMessages(request.messages, missingFields);
-        const toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
+        let toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
+        if (!toolOutputs || toolOutputs.length === 0) {
+            const resumeToolOutputs = deriveResumeToolOutputs(ctx);
+            if (resumeToolOutputs && resumeToolOutputs.length) {
+                toolOutputs = resumeToolOutputs;
+            }
+        }
         const parameters = collectParameters(payload, responsesContext.stream);
         const metadata = { context: ctx };
         try {
             const bridgePolicy = resolveBridgePolicy({ protocol: 'openai-responses', moduleType: 'openai-responses' });
             const actions = resolvePolicyActions(bridgePolicy, 'request_inbound');
             if (actions?.length) {
+                const capturedToolResults = Array.isArray(toolOutputs)
+                    ? toolOutputs.map((entry) => ({
+                        tool_call_id: entry.tool_call_id,
+                        output: entry.content,
+                        name: entry.name
+                    }))
+                    : undefined;
                 const actionState = createBridgeActionState({
                     rawRequest: payload,
-                    metadata: metadata
+                    metadata: metadata,
+                    capturedToolResults
                 });
                 runBridgeActionPipeline({
                     stage: 'request_inbound',

package/dist/conversion/hub/tool-session-compat.d.ts

@@ -0,0 +1,26 @@
+import type { ChatEnvelope } from './types/chat-envelope.js';
+import type { AdapterContext } from './types/chat-envelope.js';
+type ToolHistoryStatus = 'ok' | 'error' | 'unknown';
+export interface ToolHistoryMessageRecord {
+    role: 'user' | 'assistant' | 'tool';
+    tool_use?: {
+        id: string;
+        name?: string;
+    };
+    tool_result?: {
+        id: string;
+        name?: string;
+        status: ToolHistoryStatus;
+    };
+    ts: string;
+}
+export interface ToolSessionHistory {
+    lastMessages: ToolHistoryMessageRecord[];
+    pendingToolUses: Record<string, {
+        name?: string;
+        ts: string;
+    }>;
+    updatedAt: string;
+}
+export declare function applyToolSessionCompat(chat: ChatEnvelope, ctx: AdapterContext): Promise<void>;
+export {};