@jsonstudio/llms 0.6.147 → 0.6.187

package/dist/conversion/responses/responses-host-policy.d.ts

@@ -0,0 +1,6 @@
+import type { ResponsesRequestContext } from './responses-openai-bridge.js';
+export interface ResponsesHostPolicyResult {
+    shouldStripHostManagedFields: boolean;
+    targetProtocol: string;
+}
+export declare function evaluateResponsesHostPolicy(context?: ResponsesRequestContext, targetProtocol?: string): ResponsesHostPolicyResult;

package/dist/conversion/responses/responses-host-policy.js

@@ -0,0 +1,14 @@
+export function evaluateResponsesHostPolicy(context, targetProtocol) {
+    const protocol = typeof targetProtocol === 'string' && targetProtocol.trim()
+        ? targetProtocol
+        : (typeof context?.targetProtocol === 'string' && context.targetProtocol.trim()
+            ? context.targetProtocol
+            : 'responses');
+    const normalized = protocol.toLowerCase();
+    const shouldStrip = normalized !== 'openai-responses' &&
+        normalized !== 'responses';
+    return {
+        shouldStripHostManagedFields: shouldStrip,
+        targetProtocol: normalized
+    };
+}

package/dist/conversion/responses/responses-openai-bridge.js

@@ -1,4 +1,5 @@
 import { ensureBridgeInstructions } from '../shared/bridge-instructions.js';
+import { evaluateResponsesHostPolicy } from './responses-host-policy.js';
 import { convertMessagesToBridgeInput, convertBridgeInputToChatMessages } from '../shared/bridge-message-utils.js';
 import { createToolCallIdTransformer, enforceToolCallIdStyle, resolveToolCallIdStyle, stripInternalToolingMetadata, sanitizeResponsesFunctionName } from '../shared/responses-tool-utils.js';
 import { mapBridgeToolsToChat, mapChatToolsToBridge } from '../shared/tool-mapping.js';
@@ -8,6 +9,7 @@ import { normalizeMessageReasoningTools } from '../shared/reasoning-tool-normali
 import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
 import { buildResponsesOutputFromChat } from '../shared/responses-output-builder.js';
+import { consumeResponsesPayloadSnapshot, consumeResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -257,12 +259,20 @@ export function buildResponsesRequestFromChat(payload, ctx, extras) {
     else if (metadataExtraFields?.include !== undefined && out.include === undefined) {
         out.include = metadataExtraFields.include;
     }
-    if (ctx?.store !== undefined && out.store === undefined) {
+    const stripHostFields = shouldStripHostManagedFields(ctx);
+    if (stripHostFields) {
+        delete out.store;
+    }
+    else if (ctx?.store !== undefined && out.store === undefined) {
         out.store = ctx.store;
     }
     else if (metadataExtraFields?.store !== undefined && out.store === undefined) {
         out.store = metadataExtraFields.store;
     }
+    else if (out.store === undefined) {
+        // Chat 入口无 store 概念，但 Responses provider 仍要求显式声明。
+        out.store = false;
+    }
     if (ctx?.toolChoice !== undefined && out.tool_choice === undefined) {
         out.tool_choice = ctx.toolChoice;
     }
@@ -433,6 +443,17 @@ export function buildResponsesPayloadFromChat(payload, context) {
     const response = unwrapData(payload);
     if (!response || typeof response !== 'object')
         return payload;
+    const snapshotKey = resolveSnapshotLookupKey(response, context);
+    if (snapshotKey) {
+        const passthrough = consumeResponsesPassthrough(snapshotKey);
+        if (passthrough) {
+            return passthrough;
+        }
+        const snapshot = consumeResponsesPayloadSnapshot(snapshotKey);
+        if (snapshot) {
+            return snapshot;
+        }
+    }
     if (response.object === 'response' && Array.isArray(response.output)) {
         return response;
     }
@@ -499,10 +520,22 @@ export function buildResponsesPayloadFromChat(payload, context) {
         out.required_action = outputBuild.requiredAction;
     // Do not inject captured tool results here; keep Chat back-half behavior standard.
     if (context) {
-        for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include', 'store']) {
+        for (const k of ['metadata', 'parallel_tool_calls', 'tool_choice', 'include']) {
             if (context[k] !== undefined)
                 out[k] = context[k];
         }
+        if (!shouldStripHostManagedFields(context) && context.store !== undefined) {
+            out.store = context.store;
+        }
+    }
+    if (typeof response.request_id === 'string') {
+        out.request_id = response.request_id;
+    }
+    else if (typeof response.id === 'string') {
+        out.request_id = response.id;
+    }
+    else if (typeof context?.requestId === 'string') {
+        out.request_id = context.requestId;
     }
     if (out.metadata) {
         stripInternalToolingMetadata(out.metadata);
@@ -524,6 +557,22 @@ function unwrapData(value) {
     }
     return current;
 }
+function resolveSnapshotLookupKey(response, context) {
+    if (typeof response?.request_id === 'string') {
+        return response.request_id;
+    }
+    if (typeof context?.requestId === 'string') {
+        return context.requestId;
+    }
+    if (typeof response?.id === 'string') {
+        return response.id;
+    }
+    return undefined;
+}
+function shouldStripHostManagedFields(context) {
+    const result = evaluateResponsesHostPolicy(context, typeof context?.targetProtocol === 'string' ? context?.targetProtocol : undefined);
+    return result.shouldStripHostManagedFields;
+}
 export function extractRequestIdFromResponse(response) {
     if (response && typeof response === 'object' && 'metadata' in response && response.metadata && typeof response.metadata === 'object') {
         const meta = response.metadata;

package/dist/conversion/shared/anthropic-message-utils.js

@@ -336,6 +336,12 @@ export function buildOpenAIChatFromAnthropic(payload) {
         request.top_p = body.top_p;
     if (typeof body.stream === 'boolean')
         request.stream = body.stream;
+    if (typeof body.id === 'string') {
+        request.request_id = body.id;
+    }
+    else if (typeof body.request_id === 'string') {
+        request.request_id = body.request_id;
+    }
     if ('tool_choice' in body)
         request.tool_choice = body.tool_choice;
     const normalizedTools = mapAnthropicToolsToChat(body.tools);

package/dist/conversion/shared/bridge-actions.js

@@ -540,7 +540,7 @@ const captureToolResultsAction = (ctx) => {
             name: typeof entry?.name === 'string' ? entry.name : undefined
         }));
     }
-    if ((ctx.stage === 'request_outbound' || ctx.stage === 'response_outbound') &&
+    if (ctx.stage === 'request_outbound' &&
         Array.isArray(ctx.state.capturedToolResults) &&
         ctx.state.capturedToolResults.length) {
         const metadata = ensureMetadataRecord(ctx.state);

package/dist/conversion/shared/bridge-policies.js

@@ -232,7 +232,6 @@ const ANTHROPIC_POLICY = {
         ],
         outbound: [
             reasoningAction('anthropic_reasoning'),
-            { name: 'tools.capture-results' },
             toolCallNormalizationAction('anthropic_tool_call'),
             { name: 'metadata.extra-fields', options: { allowedKeys: ANTHROPIC_ALLOWED_FIELDS } }
         ]

package/dist/conversion/shared/responses-conversation-store.js

@@ -205,29 +205,16 @@ class ResponsesConversationStore {
     }
     resumeConversation(responseId, submitPayload, options) {
         if (typeof responseId !== 'string' || !responseId.trim()) {
-            raiseResumeError('Responses conversation requires valid response_id', {
-                code: 'RESPONSES_RESUME_MISSING_ID',
-                status: 422,
-                origin: 'client'
-            });
+            throw new Error('Responses conversation requires valid response_id');
         }
         this.prune();
         const entry = this.responseIndex.get(responseId);
         if (!entry) {
-            raiseResumeError('Responses conversation expired or not found', {
-                code: 'RESPONSES_RESUME_NOT_FOUND',
-                status: 500,
-                origin: 'server',
-                details: { responseId }
-            });
+            throw new Error('Responses conversation expired or not found');
         }
         const toolOutputs = Array.isArray(submitPayload.tool_outputs) ? submitPayload.tool_outputs : [];
         if (!toolOutputs.length) {
-            raiseResumeError('tool_outputs array is required when submitting Responses tool results', {
-                code: 'RESPONSES_RESUME_MISSING_OUTPUTS',
-                status: 422,
-                origin: 'client'
-            });
+            throw new Error('tool_outputs array is required when submitting Responses tool results');
         }
         const mergedInput = coerceInputArray(entry.input);
         const normalizedOutputs = normalizeSubmittedToolOutputs(toolOutputs);
@@ -294,16 +281,6 @@ class ResponsesConversationStore {
 }
 const store = new ResponsesConversationStore();
 const RESPONSES_DEBUG = (process.env.ROUTECODEX_RESPONSES_DEBUG || '').trim() === '1';
-function raiseResumeError(message, options) {
-    const err = new Error(message);
-    err.code = options?.code ?? 'RESPONSES_RESUME_ERROR';
-    err.status = options?.status;
-    err.origin = options?.origin;
-    if (options?.details) {
-        err.details = options.details;
-    }
-    throw err;
-}
 export function captureResponsesRequestContext(args) {
     try {
         if (RESPONSES_DEBUG) {

package/dist/conversion/shared/responses-reasoning-registry.d.ts

@@ -6,3 +6,7 @@ export declare function registerResponsesReasoning(id: unknown, segments: string
 export declare function consumeResponsesReasoning(id: unknown): string[] | undefined;
 export declare function registerResponsesOutputTextMeta(id: unknown, meta: ResponsesOutputTextMeta | undefined): void;
 export declare function consumeResponsesOutputTextMeta(id: unknown): ResponsesOutputTextMeta | undefined;
+export declare function registerResponsesPayloadSnapshot(id: unknown, snapshot: Record<string, unknown> | undefined): void;
+export declare function consumeResponsesPayloadSnapshot(id: unknown): Record<string, unknown> | undefined;
+export declare function registerResponsesPassthrough(id: unknown, payload: Record<string, unknown> | undefined): void;
+export declare function consumeResponsesPassthrough(id: unknown): Record<string, unknown> | undefined;

package/dist/conversion/shared/responses-reasoning-registry.js

@@ -11,10 +11,27 @@ function pruneEntry(id) {
     const entry = registry.get(id);
     if (!entry)
         return;
-    if (!entry.reasoning && !entry.outputText) {
+    if (!entry.reasoning && !entry.outputText && !entry.payloadSnapshot && !entry.passthroughPayload) {
         registry.delete(id);
     }
 }
+function cloneSnapshot(snapshot) {
+    try {
+        const structuredCloneImpl = globalThis.structuredClone;
+        if (typeof structuredCloneImpl === 'function') {
+            return structuredCloneImpl(snapshot);
+        }
+    }
+    catch {
+        /* ignore structuredClone failures */
+    }
+    try {
+        return JSON.parse(JSON.stringify(snapshot));
+    }
+    catch {
+        return undefined;
+    }
+}
 export function registerResponsesReasoning(id, segments) {
     if (typeof id !== 'string')
         return;
@@ -59,3 +76,47 @@ export function consumeResponsesOutputTextMeta(id) {
     pruneEntry(id);
     return value;
 }
+export function registerResponsesPayloadSnapshot(id, snapshot) {
+    if (typeof id !== 'string')
+        return;
+    if (!snapshot || typeof snapshot !== 'object')
+        return;
+    const clone = cloneSnapshot(snapshot);
+    if (!clone)
+        return;
+    const entry = ensureEntry(id);
+    entry.payloadSnapshot = clone;
+}
+export function consumeResponsesPayloadSnapshot(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.payloadSnapshot)
+        return undefined;
+    const clone = cloneSnapshot(entry.payloadSnapshot) ?? entry.payloadSnapshot;
+    entry.payloadSnapshot = undefined;
+    pruneEntry(id);
+    return clone;
+}
+export function registerResponsesPassthrough(id, payload) {
+    if (typeof id !== 'string')
+        return;
+    if (!payload || typeof payload !== 'object')
+        return;
+    const clone = cloneSnapshot(payload);
+    if (!clone)
+        return;
+    const entry = ensureEntry(id);
+    entry.passthroughPayload = clone;
+}
+export function consumeResponsesPassthrough(id) {
+    if (typeof id !== 'string')
+        return undefined;
+    const entry = registry.get(id);
+    if (!entry?.passthroughPayload)
+        return undefined;
+    const clone = cloneSnapshot(entry.passthroughPayload) ?? entry.passthroughPayload;
+    entry.passthroughPayload = undefined;
+    pruneEntry(id);
+    return clone;
+}

package/dist/conversion/shared/responses-response-utils.js

@@ -4,6 +4,7 @@ import { extractOutputSegments } from './output-content-normalizer.js';
 import { sanitizeReasoningTaggedText } from './reasoning-utils.js';
 import { createBridgeActionState, runBridgeActionPipeline } from './bridge-actions.js';
 import { resolveBridgePolicy, resolvePolicyActions } from './bridge-policies.js';
+import { registerResponsesPayloadSnapshot, registerResponsesPassthrough } from './responses-reasoning-registry.js';
 function selectCallId(entry) {
     const candidates = [
         entry?.call_id,
@@ -153,13 +154,27 @@ function collectRawReasoningSegments(response) {
     }
     return segments;
 }
+function registerPassthroughSnapshot(payload) {
+    const ids = new Set();
+    const requestId = typeof payload?.request_id === 'string' ? payload.request_id.trim() : '';
+    const id = typeof payload?.id === 'string' ? payload.id.trim() : '';
+    if (requestId.length)
+        ids.add(requestId);
+    if (id.length)
+        ids.add(id);
+    for (const candidate of ids) {
+        registerResponsesPassthrough(candidate, payload);
+    }
+}
 export function buildChatResponseFromResponses(payload) {
     if (!payload || typeof payload !== 'object')
         return payload;
     const response = unwrapResponsesResponse(payload);
     if (!response) {
-        if (Array.isArray(payload.choices))
+        if (Array.isArray(payload.choices)) {
+            registerPassthroughSnapshot(payload);
             return payload;
+        }
         return payload;
     }
     const id = typeof response.id === 'string' ? response.id : `resp_${Date.now()}`;
@@ -235,5 +250,12 @@ export function buildChatResponseFromResponses(payload) {
     if (usage !== undefined) {
         chat.usage = usage;
     }
+    const requestId = typeof response.request_id === 'string'
+        ? response.request_id
+        : (typeof response.id === 'string' ? response.id : undefined);
+    if (requestId) {
+        chat.request_id = requestId;
+    }
+    registerResponsesPayloadSnapshot(id, response);
     return chat;
 }

package/dist/conversion/shared/tool-canonicalizer.d.ts

@@ -0,0 +1,2 @@
+export declare function canonicalizeChatResponseTools(payload: unknown): unknown;
+export default canonicalizeChatResponseTools;

package/dist/conversion/shared/tool-filter-pipeline.js

@@ -1,5 +1,6 @@
 import { FilterEngine } from '../../filters/index.js';
 import { loadFieldMapConfig } from '../../filters/utils/fieldmap-loader.js';
+import { normalizeChatResponseReasoningTools } from './reasoning-tool-normalizer.js';
 import { createSnapshotWriter } from './snapshot-utils.js';
 const REQUEST_FILTER_STAGES = [
     'request_pre',
@@ -191,6 +192,16 @@ export async function runChatResponseToolFilters(chatJson, options = {}) {
         snapshot(stage, payload);
     };
     recordStage('resp_process_tool_filters_input', chatJson);
+    try {
+        if (chatJson && typeof chatJson === 'object') {
+            normalizeChatResponseReasoningTools(chatJson, {
+                idPrefixBase: 'reasoning_choice'
+            });
+        }
+    }
+    catch {
+        // best-effort; do not block response flow on reasoning parsing issues
+    }
     const engine = new FilterEngine();
     const registeredStages = new Set();
     const register = (filter) => {