@jsonstudio/llms 0.6.633 → 0.6.749

package/dist/conversion/codecs/anthropic-openai-codec.js

@@ -80,11 +80,6 @@ export class AnthropicOpenAIConversionCodec {
         };
         const engine = new FilterEngine();
         engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
-        try {
-            const { ResponseToolArgumentsToonDecodeFilter } = await import('../../filters/index.js');
-            engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter());
-        }
-        catch { /* optional */ }
         engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
         engine.registerFilter(new ResponseFinishInvariantsFilter());
         let staged = await engine.run('response_pre', dto.data, resCtxBase);

package/dist/conversion/codecs/openai-openai-codec.js

@@ -88,12 +88,6 @@ export class OpenAIOpenAIConversionCodec {
         const engine = new FilterEngine();
         // Response-side filters (idempotent w.r.t existing logic)
         engine.registerFilter(new ResponseToolTextCanonicalizeFilter()); // response_pre
-        try {
-            const { ResponseToolArgumentsToonDecodeFilter, ResponseApplyPatchToonDecodeFilter } = await import('../../filters/index.js');
-            engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter()); // response_pre, runs before stringify
-            engine.registerFilter(new ResponseApplyPatchToonDecodeFilter()); // response_pre, runs before stringify
-        }
-        catch { /* optional */ }
         engine.registerFilter(new ResponseToolArgumentsStringifyFilter()); // response_post
         engine.registerFilter(new ResponseFinishInvariantsFilter()); // response_post
         // Load field map config (if present) and register transforms

package/dist/conversion/codecs/responses-openai-codec.js

@@ -147,14 +147,8 @@ export class ResponsesOpenAIConversionCodec {
             debug: { emit: () => { } }
         };
         const engine = new FilterEngine();
-        // Response-side filters：文本标准化 → TOON decode（可选）→ apply_patch 结构化补丁规范化 → shell/basics → finish_reason 不变式
+        // Response-side filters：文本标准化 → apply_patch 结构化补丁规范化 → shell/basics → finish_reason 不变式
         engine.registerFilter(new ResponseToolTextCanonicalizeFilter()); // response_pre
-        try {
-            const { ResponseToolArgumentsToonDecodeFilter, ResponseApplyPatchToonDecodeFilter } = await import('../../filters/index.js');
-            engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter()); // response_pre, runs before stringify
-            engine.registerFilter(new ResponseApplyPatchToonDecodeFilter()); // response_pre, runs before stringify
-        }
-        catch { /* optional */ }
         engine.registerFilter(new ResponseToolArgumentsStringifyFilter()); // response_post
         engine.registerFilter(new ResponseFinishInvariantsFilter()); // response_post
         let staged = await engine.run('response_pre', dto.data, resCtxBase);

package/dist/conversion/hub/node-support.js

@@ -34,8 +34,9 @@ export async function runHubInboundConversion(options) {
 }
 export async function runHubOutboundConversion(options) {
     const adapterContext = deriveAdapterContext(options.nodeContext, options.protocol);
-    const providerEndpoint = resolveEndpointForProtocol(adapterContext.providerProtocol);
-    const stageRecorder = maybeCreateStageRecorder(adapterContext, options.nodeContext.request.endpoint, providerEndpoint);
+    // Snapshots must be grouped by the client-facing entry endpoint, not by the provider protocol.
+    // A /v1/responses request routed to an anthropic upstream is still a responses *entry* request.
+    const stageRecorder = maybeCreateStageRecorder(adapterContext, options.nodeContext.request.endpoint);
     const { outbound } = createProtocolPlans(options.protocol);
     const chatEnvelope = standardizedToChatEnvelope(options.request, { adapterContext });
     const payload = await runOutboundPipeline({
@@ -46,12 +47,12 @@ export async function runHubOutboundConversion(options) {
     });
     return payload;
 }
-function maybeCreateStageRecorder(adapterContext, defaultEndpoint, override) {
+function maybeCreateStageRecorder(adapterContext, defaultEndpoint) {
     const flag = process.env.ROUTECODEX_HUB_SNAPSHOTS;
     if (flag && flag.trim() === '0') {
         return undefined;
     }
-    const endpoint = override || defaultEndpoint || adapterContext.entryEndpoint || '/v1/chat/completions';
+    const endpoint = defaultEndpoint || adapterContext.entryEndpoint || '/v1/chat/completions';
     return createSnapshotRecorder(adapterContext, endpoint);
 }
 function resolveEndpointForProtocol(protocol) {

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

@@ -1,7 +1,7 @@
 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, VirtualRouterHealthStore } from '../../../router/virtual-router/types.js';
+import type { VirtualRouterConfig, RoutingDecision, RoutingDiagnostics, TargetMetadata, VirtualRouterHealthStore, ProviderQuotaView } from '../../../router/virtual-router/types.js';
 import { type HubProcessNodeResult } from '../process/chat-process.js';
 export interface HubPipelineConfig {
     virtualRouter: VirtualRouterConfig;
@@ -10,6 +10,19 @@ export interface HubPipelineConfig {
      * 当提供时，VirtualRouterEngine 将在初始化时恢复上一次快照，并在 cooldown/熔断变化时调用 persistSnapshot。
      */
     healthStore?: VirtualRouterHealthStore;
+    /**
+     * 可选：路由状态存储，用于持久化 sticky routing / stopMessage 等指令状态。
+     */
+    routingStateStore?: {
+        loadSync(key: string): unknown;
+        saveAsync(key: string, state: unknown): void;
+    };
+    /**
+     * 可选：配额视图。若提供，VirtualRouterEngine 将在路由过程中参考
+     * provider 的 quota 状态（inPool/priorityTier/cooldownUntil/blacklistUntil）
+     * 过滤目标并按优先级分层调度。
+     */
+    quotaView?: ProviderQuotaView;
 }
 export interface HubPipelineRequestMetadata extends Record<string, unknown> {
     entryEndpoint?: string;

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

@@ -24,6 +24,7 @@ import { runReqOutboundStage2FormatBuild } from './stages/req_outbound/req_outbo
 import { runReqOutboundStage3Compat } from './stages/req_outbound/req_outbound_stage3_compat/index.js';
 import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js';
 import { computeRequestTokens } from '../../../router/virtual-router/token-estimator.js';
+import { isCompactionRequest } from '../../shared/compaction-detect.js';
 export class HubPipeline {
     routerEngine;
     config;
@@ -31,7 +32,9 @@ export class HubPipeline {
     constructor(config) {
         this.config = config;
         this.routerEngine = new VirtualRouterEngine({
-            healthStore: config.healthStore
+            healthStore: config.healthStore,
+            routingStateStore: config.routingStateStore,
+            quotaView: config.quotaView
         });
         this.routerEngine.initialize(config.virtualRouter);
         try {
@@ -58,9 +61,13 @@ export class HubPipeline {
     async executeRequestStagePipeline(normalized, hooks) {
         const formatAdapter = hooks.createFormatAdapter();
         const semanticMapper = hooks.createSemanticMapper();
+        const rawRequest = this.asJsonObject(normalized.payload);
+        if (isCompactionRequest(rawRequest)) {
+            normalized.metadata = normalized.metadata || {};
+            normalized.metadata.compactionRequest = true;
+        }
         const inboundAdapterContext = this.buildAdapterContext(normalized);
         const inboundRecorder = this.maybeCreateStageRecorder(inboundAdapterContext, normalized.entryEndpoint);
-        const rawRequest = this.asJsonObject(normalized.payload);
         const inboundStart = Date.now();
         const formatEnvelope = await runReqInboundStage1FormatParse({
             rawRequest,
@@ -143,6 +150,15 @@ export class HubPipeline {
         const serverToolRequired = stdMetadata?.webSearchEnabled === true ||
             stdMetadata?.serverToolRequired === true;
         const sessionIdentifiers = extractSessionIdentifiersFromMetadata(normalized.metadata);
+        // 将从 metadata / clientHeaders 中解析出的会话标识同步回 normalized.metadata，
+        // 便于后续 AdapterContext（响应侧 servertool）也能访问到相同的 sessionId /
+        // conversationId，用于 sticky-session 相关逻辑（例如 stopMessage）。
+        if (sessionIdentifiers.sessionId && normalized.metadata && typeof normalized.metadata === 'object') {
+            normalized.metadata.sessionId = sessionIdentifiers.sessionId;
+        }
+        if (sessionIdentifiers.conversationId && normalized.metadata && typeof normalized.metadata === 'object') {
+            normalized.metadata.conversationId = sessionIdentifiers.conversationId;
+        }
         const metadataInput = {
             requestId: normalized.id,
             entryEndpoint: normalized.entryEndpoint,
@@ -164,6 +180,10 @@ export class HubPipeline {
             normalizedMetadata: normalized.metadata,
             stageRecorder: inboundRecorder
         });
+        const stopMessageState = this.routerEngine.getStopMessageState(metadataInput);
+        if (stopMessageState && normalized.metadata && typeof normalized.metadata === 'object') {
+            normalized.metadata.stopMessageState = stopMessageState;
+        }
         // Emit virtual router hit log for debugging (orange [virtual-router] ...)
         try {
             const routeName = routing.decision?.routeName;
@@ -193,8 +213,10 @@ export class HubPipeline {
         const outboundFormatAdapter = protocolSwitch ? outboundHooks.createFormatAdapter() : formatAdapter;
         const outboundContextMetadataKey = protocolSwitch ? outboundHooks.contextMetadataKey : hooks.contextMetadataKey;
         const outboundContextSnapshot = protocolSwitch ? undefined : contextSnapshot;
-        const outboundEndpoint = resolveEndpointForProviderProtocol(outboundAdapterContext.providerProtocol);
-        const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, outboundEndpoint);
+        // Snapshots must be grouped by entry endpoint (client-facing protocol), not by provider protocol.
+        // Otherwise one request would be split across multiple folders (e.g. openai-responses + anthropic-messages),
+        // which breaks codex-samples correlation.
+        const outboundRecorder = this.maybeCreateStageRecorder(outboundAdapterContext, normalized.entryEndpoint);
         const outboundStart = Date.now();
         let providerPayload;
         const outboundStage1 = await runReqOutboundStage1SemanticMap({
@@ -239,22 +261,25 @@ export class HubPipeline {
         // route 将 processMode 标记为 passthrough，我们仍然需要保留一次规范化后的
         // Chat 请求快照，供 stopMessage / gemini_empty_reply_continue 等被动触发型
         // servertool 在响应阶段使用。
-        let capturedChatRequest;
-        try {
-            capturedChatRequest = JSON.parse(JSON.stringify({
-                model: workingRequest.model,
-                messages: workingRequest.messages,
-                tools: workingRequest.tools,
-                parameters: workingRequest.parameters
-            }));
-        }
-        catch {
-            capturedChatRequest = undefined;
-        }
+        //
+        // 之前这里通过 JSON.stringify/parse 做深拷贝，但在部分 Responses/Gemini
+        // 场景下，workingRequest 上携带的 metadata 可能包含无法安全序列化的字段，
+        // 导致克隆过程抛错、capturedChatRequest 被静默丢弃，从而让响应侧的
+        // stop_message_auto 等 ServerTool 无法获取上一跳的 Chat 请求。
+        //
+        // 对于 capturedChatRequest，我们只需要一个“可读快照”，不会在后续流程中
+        // 对其做就地修改，因此可以直接使用浅拷贝结构，避免序列化失败导致整段
+        // 逻辑失效。
+        const capturedChatRequest = {
+            model: workingRequest.model,
+            messages: Array.isArray(workingRequest.messages) ? [...workingRequest.messages] : workingRequest.messages,
+            tools: workingRequest.tools,
+            parameters: workingRequest.parameters
+        };
         const metadata = {
             ...normalized.metadata,
             ...(hasImageAttachment ? { hasImageAttachment: true } : {}),
-            ...(capturedChatRequest ? { capturedChatRequest } : {}),
+            capturedChatRequest,
             entryEndpoint: normalized.entryEndpoint,
             providerProtocol: outboundProtocol,
             stream: normalized.stream,
@@ -369,6 +394,18 @@ export class HubPipeline {
             streamingHint,
             toolCallIdStyle
         };
+        const clientRequestId = typeof metadata.clientRequestId === 'string'
+            ? metadata.clientRequestId.trim()
+            : '';
+        if (clientRequestId) {
+            adapterContext.clientRequestId = clientRequestId;
+        }
+        const groupRequestId = typeof metadata.groupRequestId === 'string'
+            ? metadata.groupRequestId.trim()
+            : '';
+        if (groupRequestId) {
+            adapterContext.groupRequestId = groupRequestId;
+        }
         if (typeof metadata.originalModelId === 'string') {
             adapterContext.originalModelId = metadata.originalModelId;
         }
@@ -379,7 +416,8 @@ export class HubPipeline {
             adapterContext.modelId = metadata.assignedModelId;
         }
         // 将 serverToolFollowup 等 ServerTool 相关标记从 normalized.metadata 透传到 AdapterContext，
-        // 便于响应侧的 convertProviderResponse 正确识别“二跳/内部跳转”并跳过 servertool 编排。
+        // 便于响应侧的 convertProviderResponse / 各 ServerTool handler 识别“二跳/内部跳转”，
+        // 再由具体 handler 决定是否在 followup 响应中继续生效（例如 stopMessage 多轮续写）。
         if (Object.prototype.hasOwnProperty.call(metadata, 'serverToolFollowup')) {
             adapterContext.serverToolFollowup = metadata
                 .serverToolFollowup;
@@ -396,6 +434,28 @@ export class HubPipeline {
         if (conversationId) {
             adapterContext.conversationId = conversationId;
         }
+        const stopMessageState = metadata.stopMessageState;
+        if (stopMessageState && typeof stopMessageState === 'object') {
+            adapterContext.stopMessageState = stopMessageState;
+        }
+        const compactionRequest = metadata.compactionRequest;
+        if (compactionRequest === true ||
+            (typeof compactionRequest === 'string' && compactionRequest.trim().toLowerCase() === 'true')) {
+            adapterContext.compactionRequest = true;
+        }
+        const clientConnectionState = metadata.clientConnectionState;
+        if (clientConnectionState && typeof clientConnectionState === 'object' && !Array.isArray(clientConnectionState)) {
+            const stateRecord = clientConnectionState;
+            adapterContext.clientConnectionState = clientConnectionState;
+            if (typeof stateRecord.disconnected === 'boolean') {
+                adapterContext.clientDisconnected = stateRecord.disconnected;
+            }
+        }
+        const clientDisconnectedRaw = metadata.clientDisconnected;
+        if (clientDisconnectedRaw === true ||
+            (typeof clientDisconnectedRaw === 'string' && clientDisconnectedRaw.trim().toLowerCase() === 'true')) {
+            adapterContext.clientDisconnected = true;
+        }
         const responsesResume = metadata.responsesResume &&
             typeof metadata.responsesResume === 'object'
             ? metadata.responsesResume
@@ -403,6 +463,10 @@ export class HubPipeline {
         if (responsesResume) {
             adapterContext.responsesResume = responsesResume;
         }
+        const serverToolLoopState = metadata.serverToolLoopState;
+        if (serverToolLoopState && typeof serverToolLoopState === 'object' && !Array.isArray(serverToolLoopState)) {
+            adapterContext.serverToolLoopState = serverToolLoopState;
+        }
         // 透传 gemini_empty_reply_continue 的重试计数，便于在多次空回复后终止自动续写。
         const emptyReplyCount = metadata.geminiEmptyReplyCount;
         if (typeof emptyReplyCount === 'number' && Number.isFinite(emptyReplyCount)) {

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

@@ -2,9 +2,9 @@ export function extractSessionIdentifiersFromMetadata(metadata) {
     const directSession = normalizeIdentifier(metadata?.sessionId);
     const directConversation = normalizeIdentifier(metadata?.conversationId);
     const headers = coerceClientHeaders(metadata?.clientHeaders);
-    const sessionId = directSession ||
+    let sessionId = directSession ||
         (headers ? pickHeader(headers, ['session_id', 'session-id', 'x-session-id', 'anthropic-session-id']) : undefined);
-    const conversationId = directConversation ||
+    let conversationId = directConversation ||
         (headers
             ? pickHeader(headers, [
                 'conversation_id',
@@ -14,6 +14,11 @@ export function extractSessionIdentifiersFromMetadata(metadata) {
                 'openai-conversation-id'
             ])
             : undefined);
+    if (!sessionId || !conversationId) {
+        const fallback = deriveIdentifiersFromRawPayload(metadata);
+        sessionId = sessionId || fallback.sessionId;
+        conversationId = conversationId || fallback.conversationId || fallback.sessionId;
+    }
     return {
         ...(sessionId ? { sessionId } : {}),
         ...(conversationId ? { conversationId } : {})
@@ -74,3 +79,128 @@ function normalizeIdentifier(value) {
     const trimmed = value.trim();
     return trimmed || undefined;
 }
+const SESSION_TOKEN_REGEX = /session[_:\-\s]?([0-9a-f]{8,}(?:-[0-9a-f]{4,}){0,5})/i;
+const CONVERSATION_TOKEN_REGEX = /conversation[_:\-\s]?([0-9a-f]{8,}(?:-[0-9a-f]{4,}){0,5})/i;
+const SESSION_FIELD_KEYS = ['sessionid', 'session_id', 'session-id', 'anthropic-session-id'];
+const CONVERSATION_FIELD_KEYS = ['conversationid', 'conversation_id', 'conversation-id', 'anthropic-conversation-id', 'openai-conversation-id'];
+function deriveIdentifiersFromRawPayload(metadata) {
+    if (!metadata || typeof metadata !== 'object') {
+        return {};
+    }
+    const raw = metadata.__raw_request_body;
+    const targets = [];
+    let rawUserMetadataSession;
+    if (raw !== undefined) {
+        targets.push(raw);
+        if (typeof raw === 'object' && raw !== null) {
+            const rawRecord = raw;
+            rawUserMetadataSession = extractSessionIdFromUserMetadata(rawRecord);
+            if (rawRecord.metadata) {
+                targets.push(rawRecord.metadata);
+            }
+            if (rawRecord.rawText) {
+                targets.push(rawRecord.rawText);
+            }
+            if (rawRecord.events) {
+                targets.push(rawRecord.events);
+            }
+        }
+    }
+    let sessionId;
+    let conversationId;
+    if (rawUserMetadataSession) {
+        sessionId = rawUserMetadataSession;
+        conversationId = rawUserMetadataSession;
+    }
+    for (const candidate of targets) {
+        if (!sessionId) {
+            sessionId = findIdentifier(candidate, SESSION_FIELD_KEYS, SESSION_TOKEN_REGEX);
+        }
+        if (!conversationId) {
+            conversationId = findIdentifier(candidate, CONVERSATION_FIELD_KEYS, CONVERSATION_TOKEN_REGEX);
+        }
+        if (sessionId && conversationId) {
+            break;
+        }
+    }
+    if (!sessionId && conversationId) {
+        sessionId = conversationId;
+    }
+    else if (sessionId && !conversationId) {
+        conversationId = sessionId;
+    }
+    return {
+        ...(sessionId ? { sessionId } : {}),
+        ...(conversationId ? { conversationId } : {})
+    };
+}
+function extractSessionIdFromUserMetadata(raw) {
+    const metadataNode = raw.metadata;
+    if (!metadataNode || typeof metadataNode !== 'object') {
+        return undefined;
+    }
+    const userId = metadataNode.user_id;
+    if (typeof userId !== 'string') {
+        return undefined;
+    }
+    const trimmed = userId.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const match = trimmed.match(SESSION_TOKEN_REGEX);
+    if (match && match[1]) {
+        return match[1];
+    }
+    return undefined;
+}
+function findIdentifier(source, preferredKeys, regex) {
+    if (source === undefined || source === null) {
+        return undefined;
+    }
+    if (typeof source === 'string') {
+        const trimmed = source.trim();
+        if (!trimmed) {
+            return undefined;
+        }
+        const match = trimmed.match(regex);
+        if (match && match[1]) {
+            return match[1];
+        }
+        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+            try {
+                const parsed = JSON.parse(trimmed);
+                return findIdentifier(parsed, preferredKeys, regex);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    if (Array.isArray(source)) {
+        for (const entry of source) {
+            const candidate = findIdentifier(entry, preferredKeys, regex);
+            if (candidate) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    if (typeof source === 'object') {
+        const record = source;
+        for (const [key, value] of Object.entries(record)) {
+            const lowered = typeof key === 'string' ? key.toLowerCase() : '';
+            if (preferredKeys.includes(lowered)) {
+                const normalized = normalizeIdentifier(value);
+                if (normalized) {
+                    return normalized;
+                }
+            }
+            const fromNested = findIdentifier(value, preferredKeys, regex);
+            if (fromNested) {
+                return fromNested;
+            }
+        }
+    }
+    return undefined;
+}

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

@@ -1,6 +1,26 @@
 import { captureResponsesContext, buildChatRequestFromResponses } from '../../../../../responses/responses-openai-bridge.js';
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage3ContextCapture(options) {
+    // 对由 server-side 工具触发的二跳/内部跳转请求（例如 stopMessage followup），
+    // 跳过工具输出扫描与 apply_patch 诊断日志，避免在内部流中重复放大客户端已收到的
+    // 工具错误信息。此类请求的工具治理在 chat-process 阶段完成，这里仅保留最小快照。
+    try {
+        const ctx = options.adapterContext;
+        const followupFlag = ctx?.serverToolFollowup;
+        const isFollowup = followupFlag === true ||
+            (typeof followupFlag === 'string' && followupFlag.trim().toLowerCase() === 'true');
+        if (isFollowup) {
+            const snapshot = {
+                providerProtocol: options.adapterContext.providerProtocol ?? 'unknown',
+                tool_outputs: []
+            };
+            recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
+            return snapshot;
+        }
+    }
+    catch {
+        // best-effort: 若检测 serverToolFollowup 失败，则继续走通用路径
+    }
     let context;
     if (options.captureContext) {
         try {
@@ -104,23 +124,6 @@ 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) {
-                const lower = output.toLowerCase();
-                if (lower.includes('apply_patch verification failed') ||
-                    lower.includes('failed to parse function arguments')) {
-                    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;
         }
@@ -254,6 +257,7 @@ function readResponsesInputToolOutputs(payload) {
     })
         .filter((entry) => Boolean(entry));
 }
+const loggedApplyPatchErrorIds = new Set();
 function normalizeToolOutputEntry(entry) {
     if (!entry || typeof entry !== 'object') {
         return undefined;
@@ -299,10 +303,10 @@ function buildApplyPatchDiagnostics(output) {
         return undefined;
     }
     if (output.includes('missing field `input`')) {
-        return '\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 或 { toon: \"<*** Begin Patch ... *** End Patch>\" } 形态。请将统一 diff 文本同时填入 \"patch\" 和 \"input\"，或改用 toon 形态。';
+        return '\n\n[RouteCodex precheck] apply_patch 参数解析失败：缺少字段 "input"。当前 RouteCodex 期望 { input, patch } 形态，并且两个字段都应包含完整统一 diff 文本。';
     }
     if (output.includes('invalid type: map, expected a string')) {
-        return '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: \"<统一 diff>\" } / { toon: \"<*** Begin Patch ... *** End Patch>\" }。';
+        return '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: \"<统一 diff>\" } 形式。';
     }
     return undefined;
 }

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage1_sse_decode/index.js

@@ -1,6 +1,31 @@
 import { defaultSseCodecRegistry } from '../../../../../../sse/index.js';
 import { recordStage } from '../../../stages/utils.js';
 import { ProviderProtocolError } from '../../../../../shared/errors.js';
+function extractSseWrapperError(payload) {
+    return findSseWrapperError(payload, 2);
+}
+function findSseWrapperError(record, depth) {
+    if (!record || typeof record !== 'object' || depth < 0) {
+        return undefined;
+    }
+    const mode = record.mode;
+    const errVal = record.error;
+    if (mode === 'sse' && typeof errVal === 'string' && errVal.trim()) {
+        return errVal.trim();
+    }
+    const nestedKeys = ['body', 'data', 'payload', 'response'];
+    for (const key of nestedKeys) {
+        const nested = record[key];
+        if (!nested || typeof nested !== 'object' || Array.isArray(nested)) {
+            continue;
+        }
+        const found = findSseWrapperError(nested, depth - 1);
+        if (found) {
+            return found;
+        }
+    }
+    return undefined;
+}
 function resolveProviderType(protocol) {
     if (protocol === 'openai-chat')
         return 'openai';
@@ -13,7 +38,29 @@ function resolveProviderType(protocol) {
     return undefined;
 }
 export async function runRespInboundStage1SseDecode(options) {
+    const wrapperError = extractSseWrapperError(options.payload);
     const stream = extractSseStream(options.payload);
+    // 某些 mock-provider / 捕获样本在 SSE 连接被异常终止时会携带 error 标记，
+    // 即使仍保留 __sse_responses 流，也应视为上游异常并终止。
+    if (wrapperError) {
+        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+            streamDetected: Boolean(stream),
+            decoded: false,
+            protocol: options.providerProtocol,
+            reason: 'sse_wrapper_error',
+            error: wrapperError
+        });
+        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Upstream SSE terminated: ${wrapperError}`, {
+            code: 'SSE_DECODE_ERROR',
+            protocol: options.providerProtocol,
+            providerType: resolveProviderType(options.providerProtocol),
+            details: {
+                phase: 'resp_inbound_stage1_sse_decode',
+                requestId: options.adapterContext.requestId,
+                message: wrapperError
+            }
+        });
+    }
     if (!stream) {
         recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
             streamDetected: false

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -1,4 +1,5 @@
 import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
+import { normalizeApplyPatchToolCallsOnResponse } from '../../../../../shared/tool-governor.js';
 import { ToolGovernanceEngine } from '../../../../tool-governance/index.js';
 import { recordStage } from '../../../stages/utils.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
@@ -8,11 +9,12 @@ export async function runRespProcessStage1ToolGovernance(options) {
         requestId: options.requestId,
         profile: 'openai-chat'
     });
-    const { payload: governed, summary } = toolGovernanceEngine.governResponse(filtered, options.clientProtocol);
+    const patched = normalizeApplyPatchToolCallsOnResponse(filtered);
+    const { payload: governed, summary } = toolGovernanceEngine.governResponse(patched, options.clientProtocol);
     recordStage(options.stageRecorder, 'resp_process_stage1_tool_governance', {
         summary,
         applied: summary?.applied,
-        filteredPayload: filtered,
+        filteredPayload: patched,
         governedPayload: governed
     });
     return { governedPayload: governed };

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 { ensureApplyPatchSchema } from '../../shared/tool-mapping.js';
+import { normalizeApplyPatchToolCallsOnRequest } from '../../shared/tool-governor.js';
 import { isJsonObject } from '../types/json.js';
 const toolGovernanceEngine = new ToolGovernanceEngine();
 export async function runHubChatProcess(options) {
@@ -79,6 +80,7 @@ async function applyRequestToolGovernance(request, context) {
         ...merged,
         messages: stripHistoricalImageAttachments(merged.messages)
     };
+    merged = normalizeApplyPatchToolCallsOnRequest(merged);
     if (containsImageAttachment(merged.messages)) {
         if (!merged.metadata) {
             merged.metadata = {

package/dist/conversion/hub/response/provider-response.js

@@ -85,7 +85,12 @@ function resolveChatReasoningMode(_entryEndpoint) {
 export async function convertProviderResponse(options) {
     const clientProtocol = resolveClientProtocol(options.entryEndpoint);
     const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
-    const skipServerTools = isServerToolFollowup(options.context) || !hasServerToolSupport;
+    // 是否跳过 ServerTool 编排：
+    // - 仅在当前 Provider 完全不支持 ServerTool（没有 invoker/reenterPipeline）时跳过；
+    // - 对于 serverToolFollowup=true 的二/三跳请求，也允许再次进入 ServerTool 流程，
+    //   由具体 handler（例如 gemini_empty_reply_continue / iflow_model_error_retry 等）
+    //   自行通过 serverToolFollowup 标记决定是否生效。
+    const skipServerTools = !hasServerToolSupport;
     // 对于由 server-side 工具触发的内部跳转（二跳/三跳），统一禁用 SSE 聚合输出，
     // 始终返回完整的 ChatCompletion JSON，便于在 llms 内部直接解析，而不是拿到
     // __sse_responses 可读流。

package/dist/conversion/hub/snapshot-recorder.js

@@ -5,9 +5,16 @@ export class SnapshotStageRecorder {
     writer;
     constructor(options) {
         this.options = options;
+        const contextAny = options.context;
         this.writer = createSnapshotWriter({
             requestId: options.context.requestId,
-            endpoint: options.endpoint
+            endpoint: options.endpoint,
+            providerKey: typeof options.context.providerId === 'string' ? options.context.providerId : undefined,
+            groupRequestId: typeof contextAny.clientRequestId === 'string'
+                ? contextAny.clientRequestId
+                : typeof contextAny.groupRequestId === 'string'
+                    ? contextAny.groupRequestId
+                    : undefined
         });
     }
     record(stage, payload) {

package/dist/conversion/pipeline/codecs/v2/shared/openai-chat-helpers.js

@@ -43,13 +43,6 @@ export async function canonicalizeOpenAIChatResponse(payload, context, options)
     };
     const engine = new FilterEngine();
     engine.registerFilter(new ResponseToolTextCanonicalizeFilter());
-    try {
-        const { ResponseToolArgumentsToonDecodeFilter } = await import('../../../../../filters/index.js');
-        engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter());
-    }
-    catch {
-        // optional decode filter
-    }
     engine.registerFilter(new ResponseToolArgumentsStringifyFilter());
     engine.registerFilter(new ResponseFinishInvariantsFilter());
     const stage1 = await engine.run('response_pre', dto.data, filterContext);