@jsonstudio/llms 0.6.1172 → 0.6.1397

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

@@ -1,6 +1,6 @@
 import { recordStage } from '../../../stages/utils.js';
 export async function runReqInboundStage1FormatParse(options) {
     const envelope = (await options.formatAdapter.parseRequest(options.rawRequest, options.adapterContext));
-    recordStage(options.stageRecorder, 'req_inbound_stage1_format_parse', envelope);
+    recordStage(options.stageRecorder, 'chat_process.req.stage1.format_parse', envelope);
     return envelope;
 }

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.d.ts

@@ -7,6 +7,13 @@ export interface ReqInboundStage2SemanticMapOptions {
     adapterContext: AdapterContext;
     formatEnvelope: FormatEnvelope<JsonObject>;
     semanticMapper: Pick<SemanticMapper, 'toChat'>;
+    /**
+     * Mappable cross-protocol semantics (e.g. /v1/responses submit resume) must be
+     * lifted into chat semantics before entering chat_process.
+     *
+     * This must never be stored in metadata/AdapterContext.
+     */
+    responsesResume?: JsonObject;
     stageRecorder?: StageRecorder;
 }
 export interface ReqInboundStage2SemanticMapResult {

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

@@ -2,6 +2,7 @@ import { chatEnvelopeToStandardized } from '../../../../standardized-bridge.js';
 import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
 import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
+import { isJsonObject, jsonClone } from '../../../../types/json.js';
 export async function runReqInboundStage2SemanticMap(options) {
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
     applyHubOperationTableInbound({
@@ -9,11 +10,74 @@ export async function runReqInboundStage2SemanticMap(options) {
         chatEnvelope,
         adapterContext: options.adapterContext
     });
+    // Semantic Gate (request): before entering chat_process, lift any mappable protocol semantics
+    // into ChatEnvelope.semantics. Do not persist these in metadata.
+    try {
+        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object') {
+            chatEnvelope.semantics = {};
+        }
+        const semantics = chatEnvelope.semantics;
+        if (!semantics.tools || !isJsonObject(semantics.tools)) {
+            semantics.tools = {};
+        }
+        const toolsNode = semantics.tools;
+        const rawTools = Array.isArray(options.formatEnvelope.payload?.tools)
+            ? (options.formatEnvelope.payload.tools ?? [])
+            : [];
+        if (rawTools.length && toolsNode.clientToolsRaw === undefined) {
+            toolsNode.clientToolsRaw = jsonClone(rawTools);
+        }
+        if (options.responsesResume && isJsonObject(options.responsesResume)) {
+            if (!semantics.responses || !isJsonObject(semantics.responses)) {
+                semantics.responses = {};
+            }
+            const responsesNode = semantics.responses;
+            if (responsesNode.resume === undefined) {
+                responsesNode.resume = jsonClone(options.responsesResume);
+            }
+            // If this is a Responses submit/resume hop, tool outputs may exist only in resume metadata.
+            // Lift them into canonical chat.toolOutputs so chat_process sees a single unified surface.
+            const hasDirectToolOutputs = Array.isArray(chatEnvelope.toolOutputs) && chatEnvelope.toolOutputs.length > 0;
+            if (!hasDirectToolOutputs) {
+                const detailed = Array.isArray(options.responsesResume.toolOutputsDetailed)
+                    ? options.responsesResume.toolOutputsDetailed
+                    : undefined;
+                if (detailed && detailed.length) {
+                    const mapped = detailed
+                        .map((entry, index) => {
+                        if (!entry || typeof entry !== 'object')
+                            return undefined;
+                        const callId = typeof entry.callId === 'string' && String(entry.callId).trim().length
+                            ? String(entry.callId).trim()
+                            : typeof entry.originalId === 'string' && String(entry.originalId).trim().length
+                                ? String(entry.originalId).trim()
+                                : `resume_tool_${index + 1}`;
+                        const outputText = typeof entry.outputText === 'string'
+                            ? entry.outputText
+                            : (() => { try {
+                                return JSON.stringify(entry.outputText ?? '');
+                            }
+                            catch {
+                                return String(entry.outputText ?? '');
+                            } })();
+                        return { tool_call_id: callId, content: outputText };
+                    })
+                        .filter(Boolean);
+                    if (mapped.length) {
+                        chatEnvelope.toolOutputs = mapped;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // fail-fast is enforced at chat_process entry; this gate is best-effort
+    }
     validateChatEnvelope(chatEnvelope, {
         stage: 'req_inbound',
         direction: 'request'
     });
-    recordStage(options.stageRecorder, 'req_inbound_stage2_semantic_map', chatEnvelope);
+    recordStage(options.stageRecorder, 'chat_process.req.stage2.semantic_map', chatEnvelope);
     const standardizedRequest = chatEnvelopeToStandardized(chatEnvelope, {
         adapterContext: options.adapterContext,
         endpoint: options.adapterContext.entryEndpoint,

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

@@ -1,26 +1,7 @@
 import { captureResponsesContext, buildChatRequestFromResponses } from '../../../../../responses/responses-openai-bridge.js';
+import { captureResponsesRequestContext } from '../../../../../shared/responses-conversation-store.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 {
@@ -37,7 +18,7 @@ export async function runReqInboundStage3ContextCapture(options) {
     const snapshot = context
         ? augmentContextSnapshot(context, fallbackSnapshot)
         : fallbackSnapshot;
-    recordStage(options.stageRecorder, 'req_inbound_stage3_context_capture', snapshot);
+    recordStage(options.stageRecorder, 'chat_process.req.stage3.context_capture', snapshot);
     return context ?? snapshot;
 }
 export function runChatContextCapture(options) {
@@ -73,6 +54,28 @@ export function captureResponsesContextSnapshot(options) {
     catch {
         // best-effort context capture
     }
+    // OpenAI Responses tool loop: store the request context keyed by requestId so that
+    // `/v1/responses/:id/submit_tool_outputs` can resume the conversation later.
+    //
+    // This must be done on the hub pipeline inbound path (not in host/provider), because:
+    // - the tool loop is a client-protocol behavior (/v1/responses), independent of providerProtocol;
+    // - providers must remain transport-only;
+    // - the host may later enhance requestId with providerKey/model for logging, which is handled via rebind.
+    try {
+        const requestId = typeof options.adapterContext.requestId === 'string' && options.adapterContext.requestId.trim().length
+            ? options.adapterContext.requestId
+            : undefined;
+        if (requestId) {
+            captureResponsesRequestContext({
+                requestId,
+                payload: options.rawRequest,
+                context: context
+            });
+        }
+    }
+    catch {
+        // best-effort: capture failures must not block the request path
+    }
     return context;
 }
 function captureChatContextSnapshot(options) {
@@ -306,7 +309,7 @@ function buildApplyPatchDiagnostics(output) {
         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>\" } 形式。';
+        return '\n\n[RouteCodex precheck] apply_patch 参数类型错误：检测到 JSON 对象（map），但客户端期望字符串。请先对参数做 JSON.stringify 再写入 arguments，或直接提供 { patch: "<统一 diff>" } 形式。';
     }
     return undefined;
 }

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -28,7 +28,7 @@ export async function runReqOutboundStage1SemanticMap(options) {
         formatEnvelope,
         adapterContext: options.adapterContext
     });
-    recordStage(options.stageRecorder, 'req_outbound_stage1_semantic_map', chatEnvelope);
+    recordStage(options.stageRecorder, 'chat_process.req.stage6.outbound.semantic_map', chatEnvelope);
     return { chatEnvelope, formatEnvelope };
 }
 function attachToolOutputsFromContext(chatEnvelope, snapshot) {

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.d.ts

@@ -5,7 +5,7 @@ import type { FormatAdapter, StageRecorder } from '../../../../format-adapters/i
 export interface ReqOutboundStage2FormatBuildOptions {
     formatEnvelope: FormatEnvelope<JsonObject>;
     adapterContext: AdapterContext;
-    formatAdapter: Pick<FormatAdapter, 'buildResponse'>;
+    formatAdapter: Pick<FormatAdapter, 'buildRequest'>;
     stageRecorder?: StageRecorder;
 }
 export declare function runReqOutboundStage2FormatBuild(options: ReqOutboundStage2FormatBuildOptions): Promise<JsonObject>;

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.js

@@ -1,9 +1,9 @@
 import { recordStage } from '../../../stages/utils.js';
 const PRIVATE_FIELD_PREFIX = '__rcc_';
 export async function runReqOutboundStage2FormatBuild(options) {
-    const payload = (await options.formatAdapter.buildResponse(options.formatEnvelope, options.adapterContext));
+    const payload = (await options.formatAdapter.buildRequest(options.formatEnvelope, options.adapterContext));
     stripPrivateFields(payload);
-    recordStage(options.stageRecorder, 'req_outbound_stage2_format_build', payload);
+    recordStage(options.stageRecorder, 'chat_process.req.stage7.outbound.format_build', payload);
     return payload;
 }
 function stripPrivateFields(value) {

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_thought_signature_inject/index.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+type ProviderPayload = JsonObject;
+export declare function runReqOutboundStage2ThoughtSignatureInject(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): Promise<ProviderPayload>;
+export {};

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_thought_signature_inject/index.js

@@ -0,0 +1,172 @@
+import { recordStage } from '../../../stages/utils.js';
+import { SKIP_THOUGHT_SIGNATURE, buildThoughtSignatureSessionKey, getCachedThoughtSignature, getLastThoughtSignature, shouldHandleThoughtSignature } from '../../../thought-signature/thought-signature-center.js';
+import { filterInvalidThinkingBlocks, removeTrailingUnsignedThinkingBlocks } from '../../../../../shared/thought-signature-validator.js';
+function isThinkingPart(part) {
+    if (part.thought === true)
+        return true;
+    const type = typeof part.type === 'string' ? String(part.type).toLowerCase() : '';
+    return type === 'thinking' || type === 'reasoning' || type === 'redacted_thinking';
+}
+function readThinkingText(part) {
+    const text = part.text ?? part.thinking;
+    if (typeof text === 'string' && text.trim())
+        return text.trim();
+    return undefined;
+}
+function hasSignedThinking(parts) {
+    return parts.some((part) => {
+        if (!isThinkingPart(part))
+            return false;
+        const sig = part.thoughtSignature ?? part.signature;
+        return typeof sig === 'string' && sig.trim().length >= 10;
+    });
+}
+function hasToolUse(parts) {
+    return parts.some((part) => {
+        if (part.functionCall || part.function_call)
+            return true;
+        if (part.type === 'tool_use' || part.type === 'tool_result')
+            return true;
+        return false;
+    });
+}
+function injectGeminiPayload(payload, sessionKey) {
+    const contents = Array.isArray(payload.contents) ? payload.contents : [];
+    for (const content of contents) {
+        const parts = Array.isArray(content.parts) ? content.parts : [];
+        if (!parts.length)
+            continue;
+        // Deep-filter invalid thinking parts before injection.
+        const cleanedParts = [];
+        for (const part of parts) {
+            if (!part || typeof part !== 'object') {
+                cleanedParts.push(part);
+                continue;
+            }
+            if (!isThinkingPart(part)) {
+                cleanedParts.push(part);
+                continue;
+            }
+            const text = readThinkingText(part);
+            const sig = part.thoughtSignature;
+            const sigValid = typeof sig === 'string' && sig.trim().length >= 10
+                ? true
+                : Boolean(sig && (!text || !String(text).trim().length));
+            if (sigValid) {
+                cleanedParts.push(part);
+            }
+            else if (text && text.trim()) {
+                cleanedParts.push({ text });
+            }
+        }
+        content.parts = cleanedParts;
+        const effectiveParts = cleanedParts;
+        const toolUsePresent = hasToolUse(effectiveParts);
+        let signedThinking = hasSignedThinking(effectiveParts);
+        for (const part of effectiveParts) {
+            if (!isThinkingPart(part))
+                continue;
+            const text = readThinkingText(part);
+            const sig = part.thoughtSignature;
+            if (typeof sig === 'string' && sig.trim()) {
+                continue;
+            }
+            const cached = text ? getCachedThoughtSignature(sessionKey, text) : undefined;
+            if (cached) {
+                part.thoughtSignature = cached;
+                signedThinking = true;
+            }
+            else if (text) {
+                part.thoughtSignature = SKIP_THOUGHT_SIGNATURE;
+            }
+        }
+        if (toolUsePresent && !signedThinking) {
+            const last = getLastThoughtSignature(sessionKey);
+            if (last) {
+                effectiveParts.unshift({ thought: true, text: last.text, thoughtSignature: last.signature });
+            }
+            else {
+                effectiveParts.unshift({ thought: true, text: '', thoughtSignature: SKIP_THOUGHT_SIGNATURE });
+            }
+        }
+    }
+}
+function injectAnthropicPayload(payload, sessionKey) {
+    const messages = Array.isArray(payload.messages) ? payload.messages : [];
+    for (const message of messages) {
+        if (message.role !== 'assistant')
+            continue;
+        const content = Array.isArray(message.content) ? message.content : [];
+        if (!content.length)
+            continue;
+        // Deep-filter invalid thinking blocks before injection.
+        const wrapper = { role: 'assistant', content: [...content] };
+        filterInvalidThinkingBlocks([wrapper]);
+        if (Array.isArray(wrapper.content)) {
+            removeTrailingUnsignedThinkingBlocks(wrapper.content);
+        }
+        message.content = wrapper.content;
+        const effectiveContent = Array.isArray(wrapper.content) ? wrapper.content : content;
+        const toolUsePresent = effectiveContent.some((block) => block && typeof block === 'object' && (block.type === 'tool_use' || block.type === 'tool_result'));
+        let signedThinking = effectiveContent.some((block) => {
+            if (!block || typeof block !== 'object')
+                return false;
+            const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+            if (type !== 'thinking' && type !== 'redacted_thinking')
+                return false;
+            const sig = block.signature;
+            return typeof sig === 'string' && sig.trim().length >= 10;
+        });
+        for (const block of effectiveContent) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+            if (type !== 'thinking' && type !== 'redacted_thinking')
+                continue;
+            const text = typeof block.thinking === 'string'
+                ? String(block.thinking).trim()
+                : typeof block.text === 'string'
+                    ? String(block.text).trim()
+                    : '';
+            const sig = block.signature;
+            if (typeof sig === 'string' && sig.trim())
+                continue;
+            const cached = text ? getCachedThoughtSignature(sessionKey, text) : undefined;
+            if (cached) {
+                block.signature = cached;
+                signedThinking = true;
+            }
+        }
+        if (toolUsePresent && !signedThinking) {
+            const last = getLastThoughtSignature(sessionKey);
+            if (last) {
+                effectiveContent.unshift({ type: 'thinking', thinking: last.text, signature: last.signature });
+            }
+            else {
+                effectiveContent.unshift({ type: 'thinking', thinking: '', signature: SKIP_THOUGHT_SIGNATURE });
+            }
+        }
+    }
+}
+export async function runReqOutboundStage2ThoughtSignatureInject(options) {
+    const { payload, adapterContext } = options;
+    if (!shouldHandleThoughtSignature(adapterContext)) {
+        return payload;
+    }
+    const sessionKey = buildThoughtSignatureSessionKey(adapterContext, payload);
+    if (!sessionKey) {
+        return payload;
+    }
+    const protocol = String(adapterContext.providerProtocol || '').toLowerCase();
+    if (protocol === 'gemini-chat') {
+        injectGeminiPayload(payload, sessionKey);
+    }
+    else if (protocol === 'anthropic-messages') {
+        injectAnthropicPayload(payload, sessionKey);
+    }
+    recordStage(options.stageRecorder, 'chat_process.req.stage7.thought_signature_inject', {
+        applied: true,
+        sessionKey
+    });
+    return payload;
+}

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -6,7 +6,7 @@ function pickCompatProfile(adapterContext) {
 export async function runReqOutboundStage3Compat(options) {
     const profile = pickCompatProfile(options.adapterContext);
     const result = applyRequestCompat(profile, options.payload, { adapterContext: options.adapterContext });
-    options.stageRecorder?.record('req_outbound_stage3_compat', {
+    options.stageRecorder?.record('chat_process.req.stage8.outbound.compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'
     });
@@ -15,7 +15,7 @@ export async function runReqOutboundStage3Compat(options) {
 export function runRespInboundStageCompatResponse(options) {
     const profile = pickCompatProfile(options.adapterContext);
     const result = applyResponseCompat(profile, options.payload, { adapterContext: options.adapterContext });
-    options.stageRecorder?.record('resp_inbound_stage_compat', {
+    options.stageRecorder?.record('chat_process.resp.stage3.compat', {
         applied: Boolean(result.appliedProfile),
         profile: result.appliedProfile || profile || 'passthrough'
     });

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.js

@@ -10,7 +10,7 @@ export async function runReqProcessStage1ToolGovernance(options) {
         requestId: options.requestId
     });
     if (result.processedRequest) {
-        recordStage(options.stageRecorder, 'req_process_stage1_tool_governance', result.processedRequest);
+        recordStage(options.stageRecorder, 'chat_process.req.stage4.tool_governance', result.processedRequest);
         // Best-effort: capture apply_patch execution failures reported by tool role messages.
         // This is for errorsamples collection only and must not affect runtime behavior.
         captureApplyPatchExecutionFailuresFromProcessedRequest(result.processedRequest);

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage2_route_select/index.js

@@ -5,7 +5,7 @@ export function runReqProcessStage2RouteSelect(options) {
     const result = options.routerEngine.route(options.request, options.metadataInput);
     applyTargetMetadata(options.normalizedMetadata, result.target, result.decision.routeName, previousModel);
     applyTargetToSubject(options.request, result.target, previousModel);
-    recordStage(options.stageRecorder, 'req_process_stage2_route_select', {
+    recordStage(options.stageRecorder, 'chat_process.req.stage5.route_select', {
         target: result.target,
         decision: result.decision,
         diagnostics: result.diagnostics

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

@@ -43,43 +43,43 @@ export async function runRespInboundStage1SseDecode(options) {
     // 某些 mock-provider / 捕获样本在 SSE 连接被异常终止时会携带 error 标记，
     // 即使仍保留 __sse_responses 流，也应视为上游异常并终止。
     if (wrapperError) {
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.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}`, {
+        throw new ProviderProtocolError(`[chat_process.resp.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',
+                phase: 'chat_process.resp.stage1.sse_decode',
                 requestId: options.adapterContext.requestId,
                 message: wrapperError
             }
         });
     }
     if (!stream) {
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: false
         });
         return { payload: options.payload, decodedFromSse: false };
     }
     if (!supportsSseProtocol(options.providerProtocol)) {
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: false,
             reason: 'protocol_unsupported',
             protocol: options.providerProtocol
         });
-        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Protocol ${options.providerProtocol} does not support SSE decoding`, {
+        throw new ProviderProtocolError(`[chat_process.resp.stage1.sse_decode] Protocol ${options.providerProtocol} does not support SSE decoding`, {
             code: 'SSE_DECODE_ERROR',
             protocol: options.providerProtocol,
             providerType: resolveProviderType(options.providerProtocol),
             details: {
-                phase: 'resp_inbound_stage1_sse_decode',
+                phase: 'chat_process.resp.stage1.sse_decode',
                 reason: 'protocol_unsupported'
             }
         });
@@ -90,7 +90,7 @@ export async function runRespInboundStage1SseDecode(options) {
             requestId: options.adapterContext.requestId,
             model: options.adapterContext.modelId
         }));
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: true,
             protocol: options.providerProtocol
@@ -99,18 +99,18 @@ export async function runRespInboundStage1SseDecode(options) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        recordStage(options.stageRecorder, 'resp_inbound_stage1_sse_decode', {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage1.sse_decode', {
             streamDetected: true,
             decoded: false,
             protocol: options.providerProtocol,
             error: message
         });
-        throw new ProviderProtocolError(`[resp_inbound_stage1_sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`, {
+        throw new ProviderProtocolError(`[chat_process.resp.stage1.sse_decode] Failed to decode SSE payload for protocol ${options.providerProtocol}: ${message}`, {
             code: 'SSE_DECODE_ERROR',
             protocol: options.providerProtocol,
             providerType: resolveProviderType(options.providerProtocol),
             details: {
-                phase: 'resp_inbound_stage1_sse_decode',
+                phase: 'chat_process.resp.stage1.sse_decode',
                 requestId: options.adapterContext.requestId,
                 message
             }

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

@@ -1,6 +1,6 @@
 import { recordStage } from '../../../stages/utils.js';
 export async function runRespInboundStage2FormatParse(options) {
     const envelope = (await options.formatAdapter.parseResponse(options.payload, options.adapterContext));
-    recordStage(options.stageRecorder, 'resp_inbound_stage2_format_parse', envelope);
+    recordStage(options.stageRecorder, 'chat_process.resp.stage2.format_parse', envelope);
     return envelope;
 }

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_semantic_map/index.d.ts

@@ -7,6 +7,7 @@ export interface RespInboundStage3SemanticMapOptions {
     adapterContext: AdapterContext;
     formatEnvelope: FormatEnvelope<JsonObject>;
     mapper: ResponseMapper;
+    requestSemantics?: JsonObject;
     stageRecorder?: StageRecorder;
 }
 export declare function runRespInboundStage3SemanticMap(options: RespInboundStage3SemanticMapOptions): Promise<ChatCompletionLike>;

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

@@ -1,6 +1,8 @@
 import { recordStage } from '../../../stages/utils.js';
 export async function runRespInboundStage3SemanticMap(options) {
-    const chatResponse = await options.mapper.toChatCompletion(options.formatEnvelope, options.adapterContext);
-    recordStage(options.stageRecorder, 'resp_inbound_stage3_semantic_map', chatResponse);
+    const chatResponse = await options.mapper.toChatCompletion(options.formatEnvelope, options.adapterContext, {
+        requestSemantics: options.requestSemantics
+    });
+    recordStage(options.stageRecorder, 'chat_process.resp.stage4.semantic_map_to_chat', chatResponse);
     return chatResponse;
 }

package/dist/conversion/hub/pipeline/stages/resp_inbound/resp_inbound_stage3_thought_signature_capture/index.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterContext } from '../../../../types/chat-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
+type ProviderPayload = JsonObject;
+export declare function runRespInboundStage3ThoughtSignatureCapture(options: {
+    payload: ProviderPayload;
+    adapterContext: AdapterContext;
+    stageRecorder?: StageRecorder;
+}): Promise<ProviderPayload>;
+export {};

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

@@ -0,0 +1,71 @@
+import { recordStage } from '../../../stages/utils.js';
+import { buildThoughtSignatureSessionKey, cacheThoughtSignature, shouldHandleThoughtSignature } from '../../../thought-signature/thought-signature-center.js';
+function captureGeminiPayload(payload, sessionKey) {
+    const candidates = Array.isArray(payload.candidates) ? payload.candidates : [];
+    for (const candidate of candidates) {
+        const content = candidate?.content;
+        if (!content || typeof content !== 'object')
+            continue;
+        const parts = Array.isArray(content.parts) ? content.parts : [];
+        if (!parts.length)
+            continue;
+        let buffer = '';
+        for (const part of parts) {
+            if (!part || typeof part !== 'object')
+                continue;
+            if (part.thought === true || String(part.type || '').toLowerCase() === 'thinking') {
+                const text = part.text ?? part.thinking;
+                if (typeof text === 'string' && text.trim()) {
+                    buffer += text;
+                }
+            }
+            const sig = part.thoughtSignature;
+            if (typeof sig === 'string' && sig.trim() && buffer.trim()) {
+                cacheThoughtSignature(sessionKey, buffer, sig);
+            }
+        }
+    }
+}
+function captureAnthropicPayload(payload, sessionKey) {
+    const content = Array.isArray(payload.content) ? payload.content : [];
+    if (!content.length)
+        return;
+    let buffer = '';
+    for (const block of content) {
+        if (!block || typeof block !== 'object')
+            continue;
+        const type = typeof block.type === 'string' ? String(block.type).toLowerCase() : '';
+        if (type === 'thinking' || type === 'redacted_thinking') {
+            const text = block.thinking ?? block.text;
+            if (typeof text === 'string' && text.trim()) {
+                buffer += text;
+            }
+        }
+        const sig = block.signature;
+        if (typeof sig === 'string' && sig.trim() && buffer.trim()) {
+            cacheThoughtSignature(sessionKey, buffer, sig);
+        }
+    }
+}
+export async function runRespInboundStage3ThoughtSignatureCapture(options) {
+    const { payload, adapterContext } = options;
+    if (!shouldHandleThoughtSignature(adapterContext)) {
+        return payload;
+    }
+    const sessionKey = buildThoughtSignatureSessionKey(adapterContext, payload);
+    if (!sessionKey) {
+        return payload;
+    }
+    const protocol = String(adapterContext.providerProtocol || '').toLowerCase();
+    if (protocol === 'gemini-chat') {
+        captureGeminiPayload(payload, sessionKey);
+    }
+    else if (protocol === 'anthropic-messages') {
+        captureAnthropicPayload(payload, sessionKey);
+    }
+    recordStage(options.stageRecorder, 'chat_process.resp.stage3.thought_signature_capture', {
+        applied: true,
+        sessionKey
+    });
+    return payload;
+}

package/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.d.ts

@@ -7,6 +7,7 @@ export interface RespOutboundStage1ClientRemapOptions {
     clientProtocol: ClientProtocol;
     requestId: string;
     adapterContext?: AdapterContext;
+    requestSemantics?: JsonObject;
     stageRecorder?: StageRecorder;
 }
 export declare function runRespOutboundStage1ClientRemap(options: RespOutboundStage1ClientRemapOptions): JsonObject;