@jsonstudio/rcc 0.90.872 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/conversion/shared/openai-message-normalize.js

@@ -1,6 +1,26 @@
 import { injectMcpToolsForChat } from '../mcp-injection.js';
 import { normalizeOpenaiChatMessagesWithNative, normalizeOpenaiMessageWithNative, normalizeOpenaiToolCallWithNative, normalizeOpenaiToolWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 import { enforceChatBudgetWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logNormalizeNonBlocking(stage, error, details = {}) {
+    try {
+        const detailSuffix = Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[openai-message-normalize] ${stage} failed (non-blocking): ${formatUnknownError(error)}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 // Message normalization utilities for OpenAI chat payloads (renamed to avoid confusion
 // with the deprecated "openai-normalizer" module entry). This file contains the
 // previously-implemented logic from openai-normalize.ts.
@@ -87,18 +107,29 @@ export function normalizeChatRequest(request) {
                                 extractFromOutput(parsed?.output ?? parsed);
                             }
                         }
-                        catch {
-                            // ignore
+                        catch (error) {
+                            logNormalizeNonBlocking('mcp_injection.parse_tool_message_content', error, {
+                                toolRole: String(m?.role ?? ''),
+                                toolName: String(m?.name ?? '')
+                            });
                         }
                     }
                 }
-                catch { /* ignore */ }
+                catch (error) {
+                    logNormalizeNonBlocking('mcp_injection.scan_tool_messages', error, {
+                        messageCount: Array.isArray(normalized.messages) ? normalized.messages.length : 0
+                    });
+                }
                 const discovered = Array.from(known);
                 const currentTools = Array.isArray(normalized.tools) ? normalized.tools : [];
                 normalized.tools = injectMcpToolsForChat(currentTools, discovered);
             }
         }
-        catch { /* ignore MCP injection */ }
+        catch (error) {
+            logNormalizeNonBlocking('mcp_injection.apply', error, {
+                model: String(normalized?.model ?? '')
+            });
+        }
     }
     // 工具消息文本化 + 最后一轮 call 结果一致化 + 空 assistant 回合清理（native）
     try {
@@ -107,7 +138,11 @@ export function normalizeChatRequest(request) {
             normalized.messages = normalizeOpenaiChatMessagesWithNative(msgs);
         }
     }
-    catch { /* ignore message normalization */ }
+    catch (error) {
+        logNormalizeNonBlocking('chat_messages.normalize_native', error, {
+            model: String(normalized?.model ?? '')
+        });
+    }
     // 注意：不合并/删除多条 system（与 统一标准，避免高风险修改）。
     // 基于“载荷预算”（配置驱动）进行裁剪，统一走 native。
     try {
@@ -124,7 +159,11 @@ export function normalizeChatRequest(request) {
             normalized = enforceChatBudgetWithNative(normalized, allowed, sysLimit);
         }
     }
-    catch { /* ignore budget enforcement */ }
+    catch (error) {
+        logNormalizeNonBlocking('chat_budget.enforce_native', error, {
+            model: String(normalized?.model ?? '')
+        });
+    }
     // Do not invoke legacy tooling stage here; codecs perform canonicalization
     return normalized;
 }

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-conversation-store.d.ts

@@ -3,6 +3,8 @@ interface CaptureContextArgs {
     requestId?: string;
     payload: AnyRecord;
     context: AnyRecord;
+    sessionId?: string;
+    conversationId?: string;
 }
 interface RecordResponseArgs {
     requestId?: string;
@@ -15,15 +17,26 @@ interface ResumeResult {
     payload: AnyRecord;
     meta: AnyRecord;
 }
+interface RestoreByScopeArgs {
+    payload: AnyRecord;
+    sessionId?: string;
+    conversationId?: string;
+    requestId?: string;
+}
 declare class ResponsesConversationStore {
     private requestMap;
     private responseIndex;
+    private scopeIndex;
     rebindRequestId(oldId: string | undefined, newId: string | undefined): void;
     captureRequestContext(args: CaptureContextArgs): void;
     recordResponse(args: RecordResponseArgs): void;
     resumeConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
     clearRequest(requestId?: string): void;
+    resumeLatestContinuationByScope(args: RestoreByScopeArgs): ResumeResult | null;
+    materializeLatestContinuationByScope(args: RestoreByScopeArgs): ResumeResult | null;
     private cleanupEntry;
+    private attachEntryScopes;
+    private detachEntry;
     private prune;
 }
 declare const store: ResponsesConversationStore;
@@ -32,4 +45,6 @@ export declare function recordResponsesResponse(args: RecordResponseArgs): void;
 export declare function resumeResponsesConversation(responseId: string, submitPayload: AnyRecord, options?: ResumeOptions): ResumeResult;
 export declare function clearResponsesConversationByRequestId(requestId?: string): void;
 export declare function rebindResponsesConversationRequestId(oldId?: string, newId?: string): void;
+export declare function resumeLatestResponsesContinuationByScope(args: RestoreByScopeArgs): ResumeResult | null;
+export declare function materializeLatestResponsesContinuationByScope(args: RestoreByScopeArgs): ResumeResult | null;
 export { store as responsesConversationStore };

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-conversation-store.js

@@ -1,5 +1,5 @@
 import { ProviderProtocolError } from '../provider-protocol-error.js';
-import { convertResponsesOutputToInputItemsWithNative, pickResponsesPersistedFieldsWithNative, prepareResponsesConversationEntryWithNative, resumeResponsesConversationPayloadWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { convertResponsesOutputToInputItemsWithNative, materializeResponsesContinuationPayloadWithNative, pickResponsesPersistedFieldsWithNative, prepareResponsesConversationEntryWithNative, restoreResponsesContinuationPayloadWithNative, resumeResponsesConversationPayloadWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 const TTL_MS = 1000 * 60 * 30; // 30min
 function isRecord(value) {
     return Boolean(value && typeof value === 'object' && !Array.isArray(value));
@@ -14,13 +14,35 @@ function assertResponsesConversationStoreNativeAvailable() {
     if (typeof pickResponsesPersistedFieldsWithNative !== 'function' ||
         typeof convertResponsesOutputToInputItemsWithNative !== 'function' ||
         typeof prepareResponsesConversationEntryWithNative !== 'function' ||
+        typeof materializeResponsesContinuationPayloadWithNative !== 'function' ||
+        typeof restoreResponsesContinuationPayloadWithNative !== 'function' ||
         typeof resumeResponsesConversationPayloadWithNative !== 'function') {
         throw new Error('[responses-conversation-store] native bindings unavailable');
     }
 }
+function readScopeToken(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function buildScopeKeys(scope) {
+    const keys = [];
+    const sessionId = readScopeToken(scope.sessionId);
+    const conversationId = readScopeToken(scope.conversationId);
+    if (sessionId) {
+        keys.push(`session:${sessionId}`);
+    }
+    if (conversationId) {
+        keys.push(`conversation:${conversationId}`);
+    }
+    return [...new Set(keys)];
+}
 class ResponsesConversationStore {
     requestMap = new Map();
     responseIndex = new Map();
+    scopeIndex = new Map();
     rebindRequestId(oldId, newId) {
         if (!oldId || !newId || oldId === newId) {
             return;
@@ -39,12 +61,20 @@ class ResponsesConversationStore {
             return;
         this.prune();
         assertResponsesConversationStoreNativeAvailable();
+        const existing = this.requestMap.get(requestId);
+        if (existing) {
+            this.detachEntry(existing);
+        }
         const prepared = prepareResponsesConversationEntryWithNative(payload, context);
+        const scopeKeys = buildScopeKeys(args);
         const entry = {
             requestId,
             basePayload: isRecord(prepared.basePayload) ? prepared.basePayload : pickPersistedFields(payload),
             input: Array.isArray(prepared.input) ? prepared.input : [],
             tools: Array.isArray(prepared.tools) ? prepared.tools : undefined,
+            sessionId: readScopeToken(args.sessionId),
+            conversationId: readScopeToken(args.conversationId),
+            scopeKeys,
             createdAt: Date.now(),
             updatedAt: Date.now()
         };
@@ -58,6 +88,9 @@ class ResponsesConversationStore {
         const responseId = typeof response.id === 'string' ? response.id : undefined;
         if (!responseId)
             return;
+        if (entry.lastResponseId) {
+            this.responseIndex.delete(entry.lastResponseId);
+        }
         const assistantBlocks = convertOutputToInputItems(response);
         if (assistantBlocks.length) {
             entry.input.push(...assistantBlocks);
@@ -65,6 +98,7 @@ class ResponsesConversationStore {
         entry.lastResponseId = responseId;
         entry.updatedAt = Date.now();
         this.responseIndex.set(responseId, entry);
+        this.attachEntryScopes(entry);
     }
     resumeConversation(responseId, submitPayload, options) {
         if (typeof responseId !== 'string' || !responseId.trim()) {
@@ -124,23 +158,86 @@ class ResponsesConversationStore {
         const entry = this.requestMap.get(requestId);
         if (!entry)
             return;
-        this.requestMap.delete(requestId);
-        if (entry.lastResponseId) {
-            this.responseIndex.delete(entry.lastResponseId);
+        this.detachEntry(entry);
+    }
+    resumeLatestContinuationByScope(args) {
+        this.prune();
+        const scopeKeys = buildScopeKeys(args);
+        for (const scopeKey of scopeKeys) {
+            const entry = this.scopeIndex.get(scopeKey);
+            if (!entry || !entry.lastResponseId) {
+                continue;
+            }
+            assertResponsesConversationStoreNativeAvailable();
+            const restored = restoreResponsesContinuationPayloadWithNative({
+                requestId: entry.requestId,
+                basePayload: entry.basePayload,
+                input: entry.input,
+                tools: entry.tools,
+                lastResponseId: entry.lastResponseId
+            }, args.payload, args.requestId, scopeKey);
+            if (!restored) {
+                continue;
+            }
+            return {
+                payload: restored.payload,
+                meta: restored.meta
+            };
+        }
+        return null;
+    }
+    materializeLatestContinuationByScope(args) {
+        this.prune();
+        const scopeKeys = buildScopeKeys(args);
+        for (const scopeKey of scopeKeys) {
+            const entry = this.scopeIndex.get(scopeKey);
+            if (!entry) {
+                continue;
+            }
+            assertResponsesConversationStoreNativeAvailable();
+            const materialized = materializeResponsesContinuationPayloadWithNative({
+                requestId: entry.requestId,
+                basePayload: entry.basePayload,
+                input: entry.input,
+                tools: entry.tools,
+                lastResponseId: entry.lastResponseId
+            }, args.payload, args.requestId, scopeKey);
+            if (!materialized) {
+                continue;
+            }
+            return {
+                payload: materialized.payload,
+                meta: materialized.meta
+            };
         }
+        return null;
     }
     cleanupEntry(entry, responseId) {
         this.responseIndex.delete(responseId);
+        this.detachEntry(entry);
+    }
+    attachEntryScopes(entry) {
+        for (const key of entry.scopeKeys) {
+            this.scopeIndex.set(key, entry);
+        }
+    }
+    detachEntry(entry) {
         this.requestMap.delete(entry.requestId);
+        if (entry.lastResponseId) {
+            this.responseIndex.delete(entry.lastResponseId);
+        }
+        for (const key of entry.scopeKeys) {
+            const current = this.scopeIndex.get(key);
+            if (current === entry) {
+                this.scopeIndex.delete(key);
+            }
+        }
     }
     prune() {
         const now = Date.now();
-        for (const [requestId, entry] of this.requestMap.entries()) {
+        for (const [, entry] of this.requestMap.entries()) {
             if (now - entry.updatedAt > TTL_MS) {
-                this.requestMap.delete(requestId);
-                if (entry.lastResponseId) {
-                    this.responseIndex.delete(entry.lastResponseId);
-                }
+                this.detachEntry(entry);
             }
         }
         for (const [respId, entry] of this.responseIndex.entries()) {
@@ -148,10 +245,38 @@ class ResponsesConversationStore {
                 this.responseIndex.delete(respId);
             }
         }
+        for (const [scopeKey, entry] of this.scopeIndex.entries()) {
+            if (!this.requestMap.has(entry.requestId)) {
+                this.scopeIndex.delete(scopeKey);
+            }
+        }
     }
 }
 const store = new ResponsesConversationStore();
 const RESPONSES_DEBUG = (process.env.ROUTECODEX_RESPONSES_DEBUG || '').trim() === '1';
+const RESPONSES_WARN_THROTTLE_MS = 60_000;
+const responsesWarnAt = new Map();
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error ?? 'unknown');
+}
+function logResponsesStoreNonBlockingError(stage, error, details) {
+    const now = Date.now();
+    const lastAt = responsesWarnAt.get(stage) ?? 0;
+    if (now - lastAt < RESPONSES_WARN_THROTTLE_MS) {
+        return;
+    }
+    responsesWarnAt.set(stage, now);
+    try {
+        const detailSuffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[responses-store] ${stage} failed (non-blocking): ${formatUnknownError(error)}${detailSuffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 export function captureResponsesRequestContext(args) {
     try {
         if (RESPONSES_DEBUG) {
@@ -159,8 +284,12 @@ export function captureResponsesRequestContext(args) {
         }
         store.captureRequestContext(args);
     }
-    catch {
-        /* ignore capture failures */
+    catch (error) {
+        logResponsesStoreNonBlockingError('capture', error, {
+            requestId: args.requestId,
+            sessionId: args.sessionId,
+            conversationId: args.conversationId
+        });
     }
 }
 export function recordResponsesResponse(args) {
@@ -170,8 +299,11 @@ export function recordResponsesResponse(args) {
         }
         store.recordResponse(args);
     }
-    catch {
-        /* ignore */
+    catch (error) {
+        logResponsesStoreNonBlockingError('record', error, {
+            requestId: args.requestId,
+            responseId: args.response?.id
+        });
     }
 }
 export function resumeResponsesConversation(responseId, submitPayload, options) {
@@ -192,4 +324,16 @@ export function rebindResponsesConversationRequestId(oldId, newId) {
     }
     store.rebindRequestId(oldId, newId);
 }
+export function resumeLatestResponsesContinuationByScope(args) {
+    if (RESPONSES_DEBUG) {
+        console.log('[responses-store] resume-by-scope', args.sessionId, args.conversationId);
+    }
+    return store.resumeLatestContinuationByScope(args);
+}
+export function materializeLatestResponsesContinuationByScope(args) {
+    if (RESPONSES_DEBUG) {
+        console.log('[responses-store] materialize-by-scope', args.sessionId, args.conversationId);
+    }
+    return store.materializeLatestContinuationByScope(args);
+}
 export { store as responsesConversationStore };

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-reasoning-registry.d.ts

@@ -18,7 +18,13 @@ export declare function registerResponsesReasoning(id: unknown, reasoning: Respo
 export declare function consumeResponsesReasoning(id: unknown): ResponsesReasoningPayload | 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 registerResponsesPayloadSnapshot(id: unknown, snapshot: Record<string, unknown> | undefined, options?: {
+    clone?: boolean;
+}): 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 consumeResponsesPayloadSnapshotByAliases(ids: unknown[]): Record<string, unknown> | undefined;
+export declare function registerResponsesPassthrough(id: unknown, payload: Record<string, unknown> | undefined, options?: {
+    clone?: boolean;
+}): void;
 export declare function consumeResponsesPassthrough(id: unknown): Record<string, unknown> | undefined;
+export declare function consumeResponsesPassthroughByAliases(ids: unknown[]): Record<string, unknown> | undefined;

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-reasoning-registry.js

@@ -1,5 +1,41 @@
 import { parseLenientJsonishWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+const DEFAULT_RESPONSES_METADATA_TTL_MS = 10 * 60 * 1000;
+const DEFAULT_RESPONSES_METADATA_MAX_ENTRIES = 2048;
 const registry = new Map();
+function readPositiveIntegerFromEnv(raw, fallback) {
+    const parsed = Number.parseInt(String(raw ?? '').trim(), 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveRegistryTtlMs() {
+    return readPositiveIntegerFromEnv(process.env.ROUTECODEX_RESPONSES_METADATA_TTL_MS
+        ?? process.env.RCC_RESPONSES_METADATA_TTL_MS, DEFAULT_RESPONSES_METADATA_TTL_MS);
+}
+function resolveRegistryMaxEntries() {
+    return readPositiveIntegerFromEnv(process.env.ROUTECODEX_RESPONSES_METADATA_MAX_ENTRIES
+        ?? process.env.RCC_RESPONSES_METADATA_MAX_ENTRIES, DEFAULT_RESPONSES_METADATA_MAX_ENTRIES);
+}
+function pruneRegistry(nowMs) {
+    const ttlMs = resolveRegistryTtlMs();
+    const staleIds = [];
+    for (const [id, entry] of registry.entries()) {
+        if (nowMs - entry.lastTouchedAtMs >= ttlMs) {
+            staleIds.push(id);
+        }
+    }
+    for (const id of staleIds) {
+        registry.delete(id);
+    }
+    const maxEntries = resolveRegistryMaxEntries();
+    if (registry.size <= maxEntries) {
+        return;
+    }
+    const overflow = Array.from(registry.entries())
+        .sort((a, b) => a[1].lastTouchedAtMs - b[1].lastTouchedAtMs)
+        .slice(0, Math.max(0, registry.size - maxEntries));
+    for (const [id] of overflow) {
+        registry.delete(id);
+    }
+}
 function collapseReasoningSegments(segments) {
     const cleaned = segments.map((text) => text.trim()).filter((text) => text.length > 0);
     const merged = [];
@@ -24,11 +60,15 @@ function collapseReasoningSegments(segments) {
     return merged;
 }
 function ensureEntry(id) {
+    const nowMs = Date.now();
+    pruneRegistry(nowMs);
     let entry = registry.get(id);
     if (!entry) {
-        entry = {};
+        entry = { lastTouchedAtMs: nowMs };
         registry.set(id, entry);
+        return entry;
     }
+    entry.lastTouchedAtMs = nowMs;
     return entry;
 }
 function pruneEntry(id) {
@@ -37,7 +77,9 @@ function pruneEntry(id) {
         return;
     if (!entry.reasoning && !entry.outputText && !entry.payloadSnapshot && !entry.passthroughPayload) {
         registry.delete(id);
+        return;
     }
+    entry.lastTouchedAtMs = Date.now();
 }
 function cloneSnapshot(snapshot) {
     try {
@@ -61,6 +103,48 @@ function cloneSnapshot(snapshot) {
         return undefined;
     }
 }
+function normalizeResponseRegistryAliases(ids) {
+    const normalized = new Set();
+    for (const candidate of ids) {
+        if (typeof candidate !== 'string') {
+            continue;
+        }
+        const trimmed = candidate.trim();
+        if (!trimmed) {
+            continue;
+        }
+        normalized.add(trimmed);
+    }
+    return Array.from(normalized);
+}
+function consumeRetentionByAliases(ids, field) {
+    const aliases = normalizeResponseRegistryAliases(ids);
+    if (!aliases.length) {
+        return undefined;
+    }
+    pruneRegistry(Date.now());
+    let matchedValue;
+    for (const alias of aliases) {
+        const entry = registry.get(alias);
+        const candidate = entry?.[field];
+        if (candidate && typeof candidate === 'object' && !Array.isArray(candidate)) {
+            matchedValue = candidate;
+            break;
+        }
+    }
+    if (!matchedValue) {
+        return undefined;
+    }
+    for (const alias of aliases) {
+        const entry = registry.get(alias);
+        if (!entry?.[field]) {
+            continue;
+        }
+        entry[field] = undefined;
+        pruneEntry(alias);
+    }
+    return cloneSnapshot(matchedValue) ?? matchedValue;
+}
 export function registerResponsesReasoning(id, reasoning) {
     if (typeof id !== 'string')
         return;
@@ -100,6 +184,7 @@ export function registerResponsesReasoning(id, reasoning) {
 export function consumeResponsesReasoning(id) {
     if (typeof id !== 'string')
         return undefined;
+    pruneRegistry(Date.now());
     const entry = registry.get(id);
     if (!entry?.reasoning)
         return undefined;
@@ -127,6 +212,7 @@ export function registerResponsesOutputTextMeta(id, meta) {
 export function consumeResponsesOutputTextMeta(id) {
     if (typeof id !== 'string')
         return undefined;
+    pruneRegistry(Date.now());
     const entry = registry.get(id);
     if (!entry?.outputText)
         return undefined;
@@ -139,20 +225,21 @@ export function consumeResponsesOutputTextMeta(id) {
     pruneEntry(id);
     return value;
 }
-export function registerResponsesPayloadSnapshot(id, snapshot) {
+export function registerResponsesPayloadSnapshot(id, snapshot, options) {
     if (typeof id !== 'string')
         return;
     if (!snapshot || typeof snapshot !== 'object')
         return;
-    const clone = cloneSnapshot(snapshot);
-    if (!clone)
+    const retained = options?.clone === false ? snapshot : cloneSnapshot(snapshot);
+    if (!retained)
         return;
     const entry = ensureEntry(id);
-    entry.payloadSnapshot = clone;
+    entry.payloadSnapshot = retained;
 }
 export function consumeResponsesPayloadSnapshot(id) {
     if (typeof id !== 'string')
         return undefined;
+    pruneRegistry(Date.now());
     const entry = registry.get(id);
     if (!entry?.payloadSnapshot)
         return undefined;
@@ -161,20 +248,24 @@ export function consumeResponsesPayloadSnapshot(id) {
     pruneEntry(id);
     return clone;
 }
-export function registerResponsesPassthrough(id, payload) {
+export function consumeResponsesPayloadSnapshotByAliases(ids) {
+    return consumeRetentionByAliases(ids, 'payloadSnapshot');
+}
+export function registerResponsesPassthrough(id, payload, options) {
     if (typeof id !== 'string')
         return;
     if (!payload || typeof payload !== 'object')
         return;
-    const clone = cloneSnapshot(payload);
-    if (!clone)
+    const retained = options?.clone === false ? payload : cloneSnapshot(payload);
+    if (!retained)
         return;
     const entry = ensureEntry(id);
-    entry.passthroughPayload = clone;
+    entry.passthroughPayload = retained;
 }
 export function consumeResponsesPassthrough(id) {
     if (typeof id !== 'string')
         return undefined;
+    pruneRegistry(Date.now());
     const entry = registry.get(id);
     if (!entry?.passthroughPayload)
         return undefined;
@@ -183,3 +274,6 @@ export function consumeResponsesPassthrough(id) {
     pruneEntry(id);
     return clone;
 }
+export function consumeResponsesPassthroughByAliases(ids) {
+    return consumeRetentionByAliases(ids, 'passthroughPayload');
+}

package/node_modules/@jsonstudio/llms/dist/conversion/shared/responses-response-utils.js

@@ -49,7 +49,7 @@ function registerPassthroughSnapshot(payload) {
     if (id.length)
         ids.add(id);
     for (const candidate of ids) {
-        registerResponsesPassthrough(candidate, payload);
+        registerResponsesPassthrough(candidate, payload, { clone: false });
     }
 }
 function cloneSnapshot(value) {
@@ -119,15 +119,15 @@ export function buildChatResponseFromResponses(payload) {
     const requestId = typeof chat.request_id === 'string'
         ? chat.request_id
         : (typeof response.request_id === 'string' ? response.request_id : undefined);
-    if (id) {
-        registerResponsesPayloadSnapshot(id, response);
-    }
-    if (requestId) {
-        registerResponsesPayloadSnapshot(requestId, response);
-    }
-    const snapshot = cloneSnapshot(response);
-    if (snapshot) {
-        chat.__responses_payload_snapshot = snapshot;
+    const inlineSnapshot = chat.__responses_payload_snapshot;
+    const retainedSnapshot = inlineSnapshot && typeof inlineSnapshot === 'object' && !Array.isArray(inlineSnapshot)
+        ? inlineSnapshot
+        : response;
+    if (retainedSnapshot) {
+        chat.__responses_payload_snapshot = retainedSnapshot;
+        for (const candidate of new Set([id, requestId].filter((value) => typeof value === 'string' && value.length > 0))) {
+            registerResponsesPayloadSnapshot(candidate, retainedSnapshot, { clone: false });
+        }
     }
     return chat;
 }