@jsonstudio/rcc 0.90.872 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/conversion/hub/process/chat-process-pending-tool-sync.js

@@ -1,5 +1,39 @@
 import { clearPendingServerToolInjection, loadPendingServerToolInjection } from '../../../servertool/pending-session.js';
 import { analyzePendingToolSync } from '../../../router/virtual-router/engine-selection/native-router-hotpath.js';
+const NON_BLOCKING_WARN_THROTTLE_MS = 60_000;
+const nonBlockingWarnByStage = new Map();
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function shouldLogNonBlockingStage(stage) {
+    const now = Date.now();
+    const lastAt = nonBlockingWarnByStage.get(stage) ?? 0;
+    if (now - lastAt < NON_BLOCKING_WARN_THROTTLE_MS) {
+        return false;
+    }
+    nonBlockingWarnByStage.set(stage, now);
+    return true;
+}
+function logPendingToolSyncNonBlockingError(stage, operation, error, details) {
+    if (!shouldLogNonBlockingStage(stage)) {
+        return;
+    }
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[pending-tool-sync] stage=${stage} operation=${operation} failed (non-blocking): ${formatUnknownError(error)}${suffix}`);
+    }
+    catch {
+        void 0;
+    }
+}
 function readString(value) {
     return typeof value === 'string' ? value : undefined;
 }
@@ -62,8 +96,10 @@ export async function maybeInjectPendingServerToolResultsAfterClientTools(reques
             await clearFn(loadedSessionId);
         }
     }
-    catch {
-        // best-effort
+    catch (error) {
+        logPendingToolSyncNonBlockingError('session_cleanup', 'clear_pending_server_tool_injection', error, {
+            sessionId: loadedSessionId
+        });
     }
     return { ...request, messages: nextMessages };
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/process/chat-process-request-sanitizer.js

@@ -1,4 +1,167 @@
 import { stripGenericMarkersFromRequest } from './chat-process-generic-marker-strip.js';
+const TEMPLATE_ASSISTANT_PATTERNS = [
+    /^i['’]m here to help\. what would you like me to do\??$/i,
+    /^i['’]m ready to help you with whatever you need\.[\s\S]*what would you like me to do\??$/i
+];
+function extractMessageText(content) {
+    if (typeof content === 'string') {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return '';
+    }
+    const parts = [];
+    for (const item of content) {
+        if (typeof item === 'string') {
+            if (item.trim()) {
+                parts.push(item.trim());
+            }
+            continue;
+        }
+        if (!item || typeof item !== 'object') {
+            continue;
+        }
+        const row = item;
+        const directKeys = ['text', 'output_text', 'input_text', 'content'];
+        for (const key of directKeys) {
+            const value = row[key];
+            if (typeof value === 'string' && value.trim()) {
+                parts.push(value.trim());
+            }
+        }
+    }
+    return parts.join(' ').trim();
+}
+function readNonEmptyString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeToolCalls(calls, messageIndex) {
+    const normalized = [];
+    const ids = [];
+    let autoSeq = 0;
+    for (const item of calls) {
+        if (!item || typeof item !== 'object') {
+            continue;
+        }
+        const call = { ...item };
+        const normalizedId = readNonEmptyString(call.id) ??
+            readNonEmptyString(call.call_id) ??
+            readNonEmptyString(call.tool_call_id) ??
+            `call_auto_${messageIndex}_${++autoSeq}`;
+        call.id = normalizedId;
+        delete call.call_id;
+        delete call.tool_call_id;
+        ids.push(normalizedId);
+        normalized.push(call);
+    }
+    return { normalized, ids };
+}
+function isTemplateAssistantText(text) {
+    const normalized = text.trim().replace(/\s+/g, ' ');
+    if (!normalized) {
+        return false;
+    }
+    return TEMPLATE_ASSISTANT_PATTERNS.some((pattern) => pattern.test(normalized));
+}
 export function sanitizeChatProcessRequest(request) {
-    return stripGenericMarkersFromRequest(request);
+    const sanitized = stripGenericMarkersFromRequest(request);
+    if (!Array.isArray(sanitized.messages) || !sanitized.messages.length) {
+        return sanitized;
+    }
+    let removedEmptyAssistantTurns = 0;
+    let removedTemplateAssistantTurns = 0;
+    let removedEmptyToolTurns = 0;
+    let removedOrphanToolTurns = 0;
+    let backfilledToolCallIds = 0;
+    const pendingToolCallIds = [];
+    const messages = [];
+    sanitized.messages.forEach((rawMessage, index) => {
+        const message = rawMessage;
+        if (!message || typeof message !== 'object') {
+            return;
+        }
+        const role = typeof message.role === 'string' ? message.role.toLowerCase().trim() : '';
+        if (role === 'assistant') {
+            const hasToolCalls = Array.isArray(message.tool_calls) && message.tool_calls.length > 0;
+            if (hasToolCalls) {
+                const { normalized, ids } = normalizeToolCalls(message.tool_calls, index);
+                if (ids.length > 0) {
+                    pendingToolCallIds.push(...ids);
+                }
+                messages.push({
+                    ...message,
+                    tool_calls: normalized
+                });
+                return;
+            }
+            const text = extractMessageText(message.content);
+            if (!text) {
+                removedEmptyAssistantTurns += 1;
+                return;
+            }
+            if (isTemplateAssistantText(text)) {
+                removedTemplateAssistantTurns += 1;
+                return;
+            }
+            messages.push(message);
+            return;
+        }
+        if (role === 'tool') {
+            const messageRecord = message;
+            const text = extractMessageText(message.content);
+            let toolCallId = readNonEmptyString(message.tool_call_id) ??
+                readNonEmptyString(messageRecord.call_id) ??
+                readNonEmptyString(messageRecord.id);
+            if (!toolCallId && pendingToolCallIds.length === 1) {
+                toolCallId = pendingToolCallIds.shift();
+                backfilledToolCallIds += 1;
+            }
+            else if (toolCallId) {
+                const pendingIndex = pendingToolCallIds.indexOf(toolCallId);
+                if (pendingIndex >= 0) {
+                    pendingToolCallIds.splice(pendingIndex, 1);
+                }
+            }
+            if (!toolCallId && !text) {
+                removedEmptyToolTurns += 1;
+                return;
+            }
+            if (!toolCallId) {
+                removedOrphanToolTurns += 1;
+                return;
+            }
+            messages.push({
+                ...message,
+                tool_call_id: toolCallId
+            });
+            return;
+        }
+        messages.push(message);
+    });
+    const removedAssistantTurns = removedEmptyAssistantTurns + removedTemplateAssistantTurns;
+    const removedToolTurns = removedEmptyToolTurns + removedOrphanToolTurns;
+    if (removedAssistantTurns <= 0 && removedToolTurns <= 0 && backfilledToolCallIds <= 0) {
+        return sanitized;
+    }
+    const metadata = {
+        ...sanitized.metadata,
+        chatProcessSanitizer: {
+            removedAssistantTurns,
+            removedEmptyAssistantTurns,
+            removedTemplateAssistantTurns,
+            removedToolTurns,
+            removedEmptyToolTurns,
+            removedOrphanToolTurns,
+            backfilledToolCallIds
+        }
+    };
+    return {
+        ...sanitized,
+        messages,
+        metadata
+    };
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/provider-response.js

@@ -259,6 +259,8 @@ export async function convertProviderResponse(options) {
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
         clientProtocol,
+        requestSemantics: options.requestSemantics,
+        adapterContext: options.context,
         stageRecorder: options.stageRecorder
     }), {
         mapCompletedDetails: (value) => ({
@@ -266,10 +268,31 @@ export async function convertProviderResponse(options) {
             hasPayload: Boolean(value.governedPayload)
         })
     });
+    const followupServertoolResult = isFollowup
+        ? await measureHubStage(requestId, 'resp_process.stage3_servertool_orchestration.post_governance', () => runRespProcessStage3ServerToolOrchestration({
+            payload: governanceResult.governedPayload,
+            adapterContext: options.context,
+            requestId: options.context.requestId,
+            entryEndpoint: options.entryEndpoint,
+            providerProtocol: options.providerProtocol,
+            allowFollowup: true,
+            stageRecorder: options.stageRecorder,
+            providerInvoker: options.providerInvoker,
+            reenterPipeline: options.reenterPipeline,
+            clientInjectDispatch: options.clientInjectDispatch
+        }), {
+            mapCompletedDetails: (value) => ({
+                executed: value.executed,
+                flowId: value.flowId
+            })
+        })
+        : null;
+    const finalizedInputPayload = followupServertoolResult?.payload && typeof followupServertoolResult.payload === 'object'
+        ? followupServertoolResult.payload
+        : governanceResult.governedPayload;
     const finalizeResult = await measureHubStage(requestId, 'resp_process.stage2_finalize', () => runRespProcessStage2Finalize({
-        payload: governanceResult.governedPayload,
+        payload: finalizedInputPayload,
         originalPayload: effectiveChatResponse,
-        skipServerToolStrip: isFollowup,
         entryEndpoint: options.entryEndpoint,
         requestId: options.context.requestId,
         wantsStream,
@@ -296,6 +319,8 @@ export async function convertProviderResponse(options) {
         requestId: clientFacingRequestId,
         adapterContext: options.context,
         requestSemantics: options.requestSemantics,
+        responseSemantics: finalizeResult.processedRequest?.semantics ??
+            (finalizeResult.finalizedPayload?.semantics),
         stageRecorder: options.stageRecorder
     }), {
         mapCompletedDetails: () => ({

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/response-mappers.d.ts

@@ -9,10 +9,14 @@ export interface ResponseMapper {
     }): Promise<ChatCompletionLike> | ChatCompletionLike;
 }
 export declare class OpenAIChatResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext, options?: {
+        requestSemantics?: ChatSemantics | JsonObject;
+    }): ChatCompletionLike;
 }
 export declare class ResponsesResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext, options?: {
+        requestSemantics?: ChatSemantics | JsonObject;
+    }): ChatCompletionLike;
 }
 export declare class AnthropicResponseMapper implements ResponseMapper {
     toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext, options?: {
@@ -20,5 +24,7 @@ export declare class AnthropicResponseMapper implements ResponseMapper {
     }): ChatCompletionLike;
 }
 export declare class GeminiResponseMapper implements ResponseMapper {
-    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext): ChatCompletionLike;
+    toChatCompletion(format: FormatEnvelope, _ctx: AdapterContext, options?: {
+        requestSemantics?: ChatSemantics | JsonObject;
+    }): ChatCompletionLike;
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/response-mappers.js

@@ -2,6 +2,7 @@ import { buildOpenAIChatFromGeminiResponse } from '../../codecs/gemini-openai-co
 import { buildChatResponseFromResponses } from '../../shared/responses-response-utils.js';
 import { buildOpenAIChatFromAnthropicMessage } from './response-runtime.js';
 import { resolveAliasMapFromRespSemanticsWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { restoreResponseContinuationSemanticsWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-node-result-semantics.js';
 function injectResponsesReasoningExtension(payload) {
     const choices = Array.isArray(payload.choices) ? payload.choices : [];
     const primary = choices[0] && typeof choices[0] === 'object' ? choices[0] : undefined;
@@ -47,27 +48,27 @@ function injectResponsesReasoningExtension(payload) {
     };
 }
 export class OpenAIChatResponseMapper {
-    toChatCompletion(format, _ctx) {
+    toChatCompletion(format, _ctx, options) {
         const payload = (format.payload ?? {});
         if (payload && typeof payload === 'object') {
             injectResponsesReasoningExtension(payload);
         }
-        return payload;
+        return restoreResponseContinuationSemanticsWithNative(payload, options?.requestSemantics, 'openai-chat');
     }
 }
 export class ResponsesResponseMapper {
-    toChatCompletion(format, _ctx) {
-        return buildChatResponseFromResponses(format.payload ?? {});
+    toChatCompletion(format, _ctx, options) {
+        return restoreResponseContinuationSemanticsWithNative(buildChatResponseFromResponses(format.payload ?? {}), options?.requestSemantics, 'openai-responses');
     }
 }
 export class AnthropicResponseMapper {
     toChatCompletion(format, _ctx, options) {
         const aliasMap = resolveAliasMapFromRespSemanticsWithNative(options?.requestSemantics);
-        return buildOpenAIChatFromAnthropicMessage(format.payload ?? {}, { aliasMap });
+        return restoreResponseContinuationSemanticsWithNative(buildOpenAIChatFromAnthropicMessage(format.payload ?? {}, { aliasMap }), options?.requestSemantics, 'anthropic-messages');
     }
 }
 export class GeminiResponseMapper {
-    toChatCompletion(format, _ctx) {
-        return buildOpenAIChatFromGeminiResponse(format.payload ?? {});
+    toChatCompletion(format, _ctx, options) {
+        return restoreResponseContinuationSemanticsWithNative(buildOpenAIChatFromGeminiResponse(format.payload ?? {}), options?.requestSemantics, 'gemini-chat');
     }
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/response/response-runtime-anthropic.js

@@ -1,9 +1,10 @@
 import { extractToolCallsFromReasoningText } from '../../shared/reasoning-tool-parser.js';
 import { deriveToolCallKey } from '../../shared/tool-call-utils.js';
 import { buildAnthropicResponseFromChatWithNative, resolveAnthropicChatCompletionOutcomeWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
-import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
+import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshotByAliases, registerResponsesPayloadSnapshot, consumeResponsesPassthroughByAliases, registerResponsesPassthrough } from '../../shared/responses-reasoning-registry.js';
 import { ProviderProtocolError } from '../../provider-protocol-error.js';
 import { applyReasoningPayload, createAnthropicToolNameResolver, flattenAnthropicContent, normalizeMessageReasoningPayload } from './response-runtime-anthropic-helpers.js';
+import { normalizeShellLikeToolInput } from '../../shared/anthropic-message-utils-core.js';
 import { applyAnthropicResponseInboundBridgePolicy, applyAnthropicResponseOutboundBridgePolicy } from './response-runtime-anthropic-policy.js';
 export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     const content = Array.isArray(payload?.content) ? payload.content : [];
@@ -215,17 +216,22 @@ export function buildOpenAIChatFromAnthropicMessage(payload, options) {
     if (preservedOutputMeta) {
         chatResponse.__responses_output_text_meta = preservedOutputMeta;
     }
-    const payloadSnapshot = consumeResponsesPayloadSnapshot(chatResponse.id);
+    const retentionAliases = [
+        chatResponse.id,
+        typeof payload?.request_id === 'string' ? payload.request_id : undefined,
+        typeof payload?.id === 'string' ? payload.id : undefined
+    ];
+    const payloadSnapshot = consumeResponsesPayloadSnapshotByAliases(retentionAliases);
     if (payloadSnapshot) {
-        registerResponsesPayloadSnapshot(chatResponse.id, payloadSnapshot);
+        registerResponsesPayloadSnapshot(chatResponse.id, payloadSnapshot, { clone: false });
         chatResponse.__responses_payload_snapshot = payloadSnapshot;
         if (typeof chatResponse.request_id !== 'string') {
             chatResponse.request_id = chatResponse.id;
         }
     }
-    const passthroughPayload = consumeResponsesPassthrough(chatResponse.id);
+    const passthroughPayload = consumeResponsesPassthroughByAliases(retentionAliases);
     if (passthroughPayload) {
-        registerResponsesPassthrough(chatResponse.id, passthroughPayload);
+        registerResponsesPassthrough(chatResponse.id, passthroughPayload, { clone: false });
         chatResponse.__responses_passthrough = passthroughPayload;
         if (typeof chatResponse.request_id !== 'string') {
             chatResponse.request_id = chatResponse.id;
@@ -241,6 +247,15 @@ export function buildAnthropicResponseFromChat(chatResponse, options) {
         applyAnthropicResponseOutboundBridgePolicy(message, chatResponse);
     }
     const sanitized = buildAnthropicResponseFromChatWithNative(chatResponse, aliasMap);
+    const contentBlocks = Array.isArray(sanitized.content)
+        ? sanitized.content
+        : [];
+    for (const block of contentBlocks) {
+        if (!block || block.type !== 'tool_use' || typeof block.name !== 'string') {
+            continue;
+        }
+        block.input = normalizeShellLikeToolInput(block.name, block.input);
+    }
     if (chatResponse?.__responses_reasoning) {
         registerResponsesReasoning(sanitized.id, chatResponse.__responses_reasoning);
     }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/snapshot-recorder.js

@@ -1,253 +1,7 @@
 import { createSnapshotWriter } from '../snapshot-utils.js';
 import { normalizeSnapshotStagePayloadWithNative } from '../../router/virtual-router/engine-selection/native-snapshot-hooks.js';
-const SNAPSHOT_STRING_PREVIEW_CHARS = 240;
-const SNAPSHOT_ARRAY_PREVIEW_ITEMS = 2;
-const FORMAT_PARSE_STAGE_NAMES = new Set([
-    'req_inbound_stage1_format_parse',
-    'chat_process.req.stage1.format_parse'
-]);
-const TOOL_GOVERNANCE_STAGE_NAMES = new Set([
-    'req_process_stage1_tool_governance',
-    'chat_process.req.stage4.tool_governance'
-]);
-function clipSnapshotString(value) {
-    const text = String(value ?? '');
-    return text.length > SNAPSHOT_STRING_PREVIEW_CHARS
-        ? `${text.slice(0, SNAPSHOT_STRING_PREVIEW_CHARS)}…`
-        : text;
-}
-function summarizeScalar(value) {
-    if (typeof value === 'string') {
-        return clipSnapshotString(value);
-    }
-    if (value === null ||
-        value === undefined ||
-        typeof value === 'number' ||
-        typeof value === 'boolean') {
-        return value;
-    }
-    return undefined;
-}
-function summarizeValuePreview(value, depth = 0) {
-    const scalar = summarizeScalar(value);
-    if (scalar !== undefined || value === null) {
-        return scalar;
-    }
-    if (Array.isArray(value)) {
-        if (depth >= 2) {
-            return { type: 'array', count: value.length };
-        }
-        const first = value.slice(0, SNAPSHOT_ARRAY_PREVIEW_ITEMS).map((entry) => summarizeValuePreview(entry, depth + 1));
-        const last = value.slice(-SNAPSHOT_ARRAY_PREVIEW_ITEMS).map((entry) => summarizeValuePreview(entry, depth + 1));
-        return {
-            type: 'array',
-            count: value.length,
-            first,
-            last
-        };
-    }
-    if (!value || typeof value !== 'object') {
-        return String(value);
-    }
-    const record = value;
-    const keys = Object.keys(record);
-    const preferredKeys = ['role', 'type', 'name', 'id', 'call_id', 'content', 'text', 'input', 'output', 'status'];
-    const preview = {};
-    for (const key of preferredKeys) {
-        if (key in record) {
-            preview[key] = summarizeValuePreview(record[key], depth + 1);
-        }
-    }
-    if (!Object.keys(preview).length) {
-        for (const key of keys.slice(0, 6)) {
-            preview[key] = summarizeValuePreview(record[key], depth + 1);
-        }
-    }
-    return {
-        type: 'object',
-        keys,
-        preview
-    };
-}
-function summarizeCollection(value) {
-    if (!Array.isArray(value)) {
-        return summarizeValuePreview(value);
-    }
-    return {
-        count: value.length,
-        preview: summarizeValuePreview(value)
-    };
-}
-function summarizeTools(value) {
-    if (!Array.isArray(value)) {
-        return summarizeValuePreview(value);
-    }
-    return {
-        count: value.length,
-        names: value
-            .map((tool) => {
-            if (!tool || typeof tool !== 'object') {
-                return null;
-            }
-            const node = tool;
-            if (typeof node.name === 'string' && node.name.trim()) {
-                return node.name.trim();
-            }
-            const fn = node.function;
-            if (fn && typeof fn === 'object' && typeof fn.name === 'string') {
-                return String(fn.name).trim();
-            }
-            return typeof node.type === 'string' ? node.type : null;
-        })
-            .filter((name) => Boolean(name))
-            .slice(0, 32)
-    };
-}
-function summarizeMetadata(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return summarizeValuePreview(value);
-    }
-    const metadata = value;
-    const summary = {};
-    for (const key of [
-        'requestId',
-        'clientRequestId',
-        'providerProtocol',
-        'endpoint',
-        'entryEndpoint',
-        'originalEndpoint',
-        'processMode',
-        'sessionId',
-        'conversationId',
-        'workdir',
-        'cwd',
-        'processedAt',
-        'stage',
-        'stream'
-    ]) {
-        if (key in metadata) {
-            summary[key] = summarizeValuePreview(metadata[key]);
-        }
-    }
-    if ('clientHeaders' in metadata) {
-        const headers = metadata.clientHeaders;
-        if (headers && typeof headers === 'object' && !Array.isArray(headers)) {
-            summary.clientHeaders = { keys: Object.keys(headers).sort() };
-        }
-        else {
-            summary.clientHeaders = summarizeValuePreview(headers);
-        }
-    }
-    if ('capturedContext' in metadata) {
-        summary.capturedContext = summarizeValuePreview(metadata.capturedContext);
-    }
-    if ('__rt' in metadata) {
-        summary.__rt = summarizeValuePreview(metadata.__rt);
-    }
-    if ('__raw_request_body' in metadata) {
-        const raw = metadata.__raw_request_body;
-        summary.__raw_request_body = {
-            omitted: true,
-            preview: summarizeValuePreview(raw, 1)
-        };
-    }
-    return summary;
-}
-function summarizeSemantics(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return summarizeValuePreview(value);
-    }
-    const semantics = value;
-    const summary = {};
-    if ('tools' in semantics) {
-        const tools = semantics.tools;
-        const toolsRecord = tools && typeof tools === 'object' && !Array.isArray(tools) ? tools : null;
-        summary.tools = toolsRecord
-            ? {
-                keys: Object.keys(toolsRecord).sort(),
-                toolNameAliasMap: summarizeValuePreview(toolsRecord.toolNameAliasMap, 1),
-                clientToolsRaw: summarizeTools(toolsRecord.clientToolsRaw)
-            }
-            : summarizeValuePreview(tools);
-    }
-    const responses = semantics.responses;
-    const responsesRecord = responses && typeof responses === 'object' && !Array.isArray(responses)
-        ? responses
-        : null;
-    if (responsesRecord) {
-        const context = responsesRecord.context;
-        const contextRecord = context && typeof context === 'object' && !Array.isArray(context)
-            ? context
-            : null;
-        summary.responses = contextRecord
-            ? {
-                context: {
-                    requestId: summarizeValuePreview(contextRecord.requestId),
-                    isChatPayload: summarizeValuePreview(contextRecord.isChatPayload),
-                    isResponsesPayload: summarizeValuePreview(contextRecord.isResponsesPayload),
-                    systemInstruction: summarizeValuePreview(contextRecord.systemInstruction),
-                    parameters: summarizeValuePreview(contextRecord.parameters, 1),
-                    input: summarizeCollection(contextRecord.input),
-                    __captured_tool_results: summarizeCollection(contextRecord.__captured_tool_results),
-                    toolsRaw: summarizeTools(contextRecord.toolsRaw),
-                    toolsNormalized: summarizeTools(contextRecord.toolsNormalized)
-                }
-            }
-            : summarizeValuePreview(responsesRecord);
-    }
-    return summary;
-}
-function buildFormatParseSnapshotSummary(payload) {
-    const envelope = payload.payload && typeof payload.payload === 'object' && !Array.isArray(payload.payload)
-        ? payload.payload
-        : null;
-    return {
-        __snapshot_summary: true,
-        stage: 'format_parse',
-        format: summarizeValuePreview(payload.format),
-        metadata: summarizeValuePreview(payload.metadata, 1),
-        payload: envelope
-            ? {
-                model: summarizeValuePreview(envelope.model),
-                include: summarizeValuePreview(envelope.include, 1),
-                stream: summarizeValuePreview(envelope.stream),
-                tool_choice: summarizeValuePreview(envelope.tool_choice),
-                max_output_tokens: summarizeValuePreview(envelope.max_output_tokens),
-                max_tokens: summarizeValuePreview(envelope.max_tokens),
-                input: summarizeCollection(envelope.input),
-                messages: summarizeCollection(envelope.messages),
-                tools: summarizeTools(envelope.tools)
-            }
-            : summarizeValuePreview(payload.payload, 1)
-    };
-}
-function buildToolGovernanceSnapshotSummary(payload) {
-    return {
-        __snapshot_summary: true,
-        stage: 'tool_governance',
-        model: summarizeValuePreview(payload.model),
-        stream: summarizeValuePreview(payload.stream),
-        tool_choice: summarizeValuePreview(payload.tool_choice),
-        parameters: summarizeValuePreview(payload.parameters, 1),
-        processed: summarizeValuePreview(payload.processed, 1),
-        processingMetadata: summarizeValuePreview(payload.processingMetadata, 1),
-        messages: summarizeCollection(payload.messages),
-        tools: summarizeTools(payload.tools),
-        metadata: summarizeMetadata(payload.metadata),
-        semantics: summarizeSemantics(payload.semantics)
-    };
-}
 export function trimSnapshotHotpathPayloadForNative(stage, payload) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        return payload;
-    }
-    const record = payload;
-    if (FORMAT_PARSE_STAGE_NAMES.has(stage)) {
-        return buildFormatParseSnapshotSummary(record);
-    }
-    if (TOOL_GOVERNANCE_STAGE_NAMES.has(stage)) {
-        return buildToolGovernanceSnapshotSummary(record);
-    }
+    void stage;
     return payload;
 }
 export class SnapshotStageRecorder {