@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/route-aware-responses-continuation.js

@@ -0,0 +1,143 @@
+import { materializeLatestResponsesContinuationByScope, resumeLatestResponsesContinuationByScope } from '../../shared/responses-conversation-store.js';
+import { extractSessionIdentifiersFromMetadata } from './session-identifiers.js';
+import { buildChatRequestFromResponses, captureResponsesContext } from '../../shared/responses-request-adapter.js';
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    return value;
+}
+function readText(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function hasExplicitPreviousResponseId(rawRequest) {
+    return Boolean(readText(rawRequest.previous_response_id));
+}
+function cloneSemantics(request) {
+    const semantics = request.semantics;
+    return asRecord(semantics) ? { ...semantics } : {};
+}
+export function resolveRouteAwareResponsesContinuation(args) {
+    if (args.entryProtocol !== 'openai-responses') {
+        return args.request;
+    }
+    const rawRequestRecord = asRecord(args.rawRequest);
+    if (!rawRequestRecord || hasExplicitPreviousResponseId(args.rawRequest)) {
+        return args.request;
+    }
+    if (!Array.isArray(rawRequestRecord.input) || rawRequestRecord.input.length === 0) {
+        return args.request;
+    }
+    const { sessionId, conversationId } = extractSessionIdentifiersFromMetadata(args.normalizedMetadata);
+    if (!sessionId && !conversationId) {
+        return args.request;
+    }
+    if (args.outboundProtocol !== 'openai-responses') {
+        const materialized = materializeLatestResponsesContinuationByScope({
+            payload: rawRequestRecord,
+            sessionId,
+            conversationId,
+            requestId: args.requestId
+        });
+        const materializedPayload = asRecord(materialized?.payload);
+        if (!materializedPayload) {
+            return args.request;
+        }
+        const context = captureResponsesContext(materializedPayload, {
+            route: { requestId: args.requestId }
+        });
+        const rebuilt = buildChatRequestFromResponses(materializedPayload, context).request;
+        const rebuiltMessages = Array.isArray(rebuilt.messages)
+            ? rebuilt.messages
+            : undefined;
+        if (!rebuiltMessages?.length) {
+            return args.request;
+        }
+        const currentModel = typeof args.request.model === 'string' ? args.request.model : undefined;
+        const rebuiltModel = typeof rebuilt.model === 'string' ? rebuilt.model : undefined;
+        const nextModel = currentModel ?? rebuiltModel;
+        if (!nextModel) {
+            return args.request;
+        }
+        const nextSemantics = cloneSemantics(args.request);
+        const currentResponses = asRecord(nextSemantics.responses);
+        const currentResume = asRecord(currentResponses?.resume);
+        nextSemantics.responses = {
+            ...(currentResponses ?? {}),
+            resume: {
+                ...(currentResume ?? {}),
+                ...(asRecord(materialized?.meta) ?? {}),
+                ...(sessionId ? { sessionId } : {}),
+                ...(conversationId ? { conversationId } : {})
+            }
+        };
+        return {
+            ...args.request,
+            // Preserve the already route-selected model; do not let stored responses payload
+            // restore the original client model before provider payload build.
+            model: nextModel,
+            messages: rebuiltMessages,
+            ...(Array.isArray(rebuilt.tools) ? { tools: rebuilt.tools } : {}),
+            semantics: nextSemantics
+        };
+    }
+    const restored = resumeLatestResponsesContinuationByScope({
+        payload: rawRequestRecord,
+        sessionId,
+        conversationId,
+        requestId: args.requestId
+    });
+    const restoredPayload = asRecord(restored?.payload);
+    const restoredMeta = asRecord(restored?.meta);
+    const restoredFromResponseId = readText(restoredMeta?.restoredFromResponseId)
+        ?? readText(restoredPayload?.previous_response_id);
+    const previousRequestId = readText(restoredMeta?.previousRequestId);
+    const deltaInput = Array.isArray(restoredPayload?.input)
+        ? restoredPayload?.input
+        : undefined;
+    if (!restoredFromResponseId || !deltaInput) {
+        return args.request;
+    }
+    const nextSemantics = cloneSemantics(args.request);
+    const currentResponses = asRecord(nextSemantics.responses);
+    const currentResume = asRecord(currentResponses?.resume);
+    nextSemantics.responses = {
+        ...(currentResponses ?? {}),
+        resume: {
+            ...(currentResume ?? {}),
+            ...(restoredMeta ?? {}),
+            deltaInput
+        }
+    };
+    const currentContinuation = asRecord(nextSemantics.continuation);
+    const currentResumeFrom = asRecord(currentContinuation?.resumeFrom);
+    nextSemantics.continuation = {
+        ...(currentContinuation ?? {}),
+        ...(previousRequestId
+            ? {
+                chainId: readText(currentContinuation?.chainId) ?? previousRequestId,
+                stickyScope: readText(currentContinuation?.stickyScope) ?? 'request_chain',
+                stateOrigin: readText(currentContinuation?.stateOrigin) ?? 'openai-responses',
+                restored: true
+            }
+            : {}),
+        resumeFrom: {
+            ...(currentResumeFrom ?? {}),
+            protocol: readText(currentResumeFrom?.protocol) ?? 'openai-responses',
+            ...(previousRequestId
+                ? {
+                    requestId: readText(currentResumeFrom?.requestId) ?? previousRequestId
+                }
+                : {}),
+            previousResponseId: restoredFromResponseId
+        }
+    };
+    return {
+        ...args.request,
+        semantics: nextSemantics
+    };
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/index.js

@@ -6,6 +6,8 @@ import { validateChatEnvelopeWithNative } from "../../../../../../router/virtual
 import { chatEnvelopeToStandardizedWithNative } from "../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js";
 import { normalizeReqInboundShellLikeToolCallsWithNative } from "../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics-tools.js";
 import { fixApplyPatchToolCallsWithNative } from "../../../../../../router/virtual-router/engine-selection/native-compat-action-semantics.js";
+import { applyAnthropicToolAliasSemantics, normalizeAnthropicToolAliasMap } from "../../../../process/chat-process-anthropic-alias.js";
+import { buildAnthropicToolAliasMapWithNative } from "../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js";
 import { isHubStageTimingDetailEnabled, logHubStageTiming, } from "../../../hub-stage-timing.js";
 function buildSlimResponsesContextForSemantics(context) {
     if (!context || typeof context !== "object" || Array.isArray(context)) {
@@ -133,6 +135,41 @@ export async function runReqInboundStage2SemanticMap(options) {
         requestId: options.adapterContext.requestId,
     });
     logHubStageTiming(requestId, "req_inbound.stage2_to_standardized", "completed", { elapsedMs: Date.now() - stdStart });
+    applyAnthropicToolAliasSemantics(standardizedRequest, options.adapterContext.entryEndpoint);
+    if (typeof options.adapterContext.entryEndpoint === "string" &&
+        options.adapterContext.entryEndpoint.trim().toLowerCase().includes("/v1/messages")) {
+        const semantics = isJsonObject(standardizedRequest.semantics)
+            ? standardizedRequest.semantics
+            : {};
+        const toolsNode = isJsonObject(semantics.tools)
+            ? semantics.tools
+            : {};
+        const normalizedExistingAliasMap = normalizeAnthropicToolAliasMap(isJsonObject(toolsNode.toolNameAliasMap)
+            ? toolsNode.toolNameAliasMap
+            : undefined);
+        if (normalizedExistingAliasMap) {
+            toolsNode.toolNameAliasMap = normalizedExistingAliasMap;
+            standardizedRequest.semantics = {
+                ...semantics,
+                tools: toolsNode,
+            };
+        }
+        const hasAliasMap = isJsonObject(toolsNode.toolNameAliasMap) ||
+            isJsonObject(toolsNode.toolAliasMap);
+        const rawTools = Array.isArray(options.formatEnvelope.payload?.tools)
+            ? options.formatEnvelope.payload.tools
+            : undefined;
+        if (!hasAliasMap && rawTools && rawTools.length > 0) {
+            const aliasMap = normalizeAnthropicToolAliasMap(buildAnthropicToolAliasMapWithNative(rawTools));
+            if (aliasMap && Object.keys(aliasMap).length > 0) {
+                toolsNode.toolNameAliasMap = aliasMap;
+                standardizedRequest.semantics = {
+                    ...semantics,
+                    tools: toolsNode,
+                };
+            }
+        }
+    }
     // Ensure responses semantics (context) survive into standardized request for VirtualRouter parsing.
     if (chatEnvelope.semantics && typeof chatEnvelope.semantics === "object") {
         const envelopeSemantics = chatEnvelope.semantics;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/semantic-lift.js

@@ -2,12 +2,24 @@ import { isJsonObject } from '../../../../types/json.js';
 import { applyReqInboundSemanticLiftWithNative, mapReqInboundResumeToolOutputsDetailedWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 export function liftReqInboundSemantics(options) {
     const normalizedResponsesResume = options.responsesResume && isJsonObject(options.responsesResume) ? options.responsesResume : undefined;
+    const formatRecord = options.formatEnvelope;
+    const protocol = typeof options.formatEnvelope.protocol === 'string' && options.formatEnvelope.protocol.trim().length
+        ? options.formatEnvelope.protocol
+        : typeof formatRecord.format === 'string' && String(formatRecord.format).trim().length
+            ? String(formatRecord.format)
+            : options.adapterContext.providerProtocol;
     const lifted = applyReqInboundSemanticLiftWithNative({
         chatEnvelope: options.chatEnvelope,
         payload: options.formatEnvelope.payload,
-        protocol: options.formatEnvelope.protocol,
+        protocol,
         entryEndpoint: options.adapterContext.entryEndpoint,
-        responsesResume: normalizedResponsesResume
+        responsesResume: normalizedResponsesResume,
+        sessionId: typeof options.adapterContext.sessionId === 'string'
+            ? String(options.adapterContext.sessionId)
+            : undefined,
+        conversationId: typeof options.adapterContext.conversationId === 'string'
+            ? String(options.adapterContext.conversationId)
+            : undefined
     });
     replaceEnvelope(options.chatEnvelope, lifted);
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/responses-context-snapshot.d.ts

@@ -5,4 +5,7 @@ export interface ResponsesContextCaptureOptions {
     rawRequest: JsonObject;
     adapterContext: AdapterContext;
 }
+export declare function persistResponsesConversationRequestContext(options: ResponsesContextCaptureOptions & {
+    context: ResponsesRequestContext;
+}): void;
 export declare function captureResponsesContextSnapshot(options: ResponsesContextCaptureOptions): ResponsesRequestContext;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/responses-context-snapshot.js

@@ -1,5 +1,26 @@
 import { captureResponsesRequestContext } from '../../../../../shared/responses-conversation-store.js';
 import { captureReqInboundResponsesContextSnapshotWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+function readNormalizedToken(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+export function persistResponsesConversationRequestContext(options) {
+    const requestId = readNormalizedToken(options.adapterContext.requestId);
+    if (!requestId) {
+        return;
+    }
+    // captureResponsesRequestContext already best-effort wraps store failures.
+    captureResponsesRequestContext({
+        requestId,
+        payload: options.rawRequest,
+        context: options.context,
+        sessionId: readNormalizedToken(options.adapterContext.sessionId),
+        conversationId: readNormalizedToken(options.adapterContext.conversationId)
+    });
+}
 export function captureResponsesContextSnapshot(options) {
     const context = captureReqInboundResponsesContextSnapshotWithNative({
         rawRequest: options.rawRequest,
@@ -13,16 +34,6 @@ export function captureResponsesContextSnapshot(options) {
     // - 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.
-    const requestId = typeof options.adapterContext.requestId === 'string' && options.adapterContext.requestId.trim().length
-        ? options.adapterContext.requestId
-        : undefined;
-    if (requestId) {
-        // captureResponsesRequestContext already best-effort wraps store failures.
-        captureResponsesRequestContext({
-            requestId,
-            payload: options.rawRequest,
-            context: context
-        });
-    }
+    persistResponsesConversationRequestContext({ ...options, context });
     return context;
 }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/chat-process-semantics-bridge.js

@@ -1,17 +1,74 @@
 import { resolveAliasMapFromRespSemanticsWithNative, resolveClientToolsRawFromRespSemanticsWithNative, normalizeAliasMapWithNative, resolveClientToolsRawWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { buildAnthropicToolAliasMapWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
 // Three-stage contract:
 // inbound -> chat_process -> outbound
 // This module is the outbound-side bridge that consumes chat_process semantics
 // and remaps client-facing tool semantics without mutating chat_process internals.
 export function resolveAliasMapFromSemantics(semantics) {
-    return resolveAliasMapFromRespSemanticsWithNative(semantics);
+    const nativeResolved = resolveAliasMapFromRespSemanticsWithNative(semantics);
+    if (nativeResolved && Object.keys(nativeResolved).length > 0) {
+        return finalizeAliasMap(nativeResolved);
+    }
+    const toolsNode = asJsonRecord(semantics?.tools);
+    const anthropicNode = asJsonRecord(semantics?.anthropic);
+    const directCandidates = [
+        toolsNode?.toolNameAliasMap,
+        toolsNode?.toolAliasMap,
+        anthropicNode?.toolNameAliasMap,
+        anthropicNode?.toolAliasMap
+    ];
+    for (const candidate of directCandidates) {
+        const normalized = normalizeAliasMap(candidate);
+        if (normalized && Object.keys(normalized).length > 0) {
+            return finalizeAliasMap(normalized);
+        }
+    }
+    const rawCandidates = [
+        anthropicNode?.clientToolsRaw,
+        toolsNode?.clientToolsRaw,
+        resolveClientToolsRawFromSemantics(semantics)
+    ];
+    for (const candidate of rawCandidates) {
+        const built = buildAnthropicToolAliasMapWithNative(candidate);
+        const normalized = normalizeAliasMap(built);
+        if (normalized && Object.keys(normalized).length > 0) {
+            return finalizeAliasMap(normalized);
+        }
+    }
+    return undefined;
 }
 export function normalizeAliasMap(candidate) {
     return normalizeAliasMapWithNative(candidate);
 }
 export function resolveClientToolsRawFromSemantics(semantics) {
-    return resolveClientToolsRawFromRespSemanticsWithNative(semantics);
+    const nativeResolved = resolveClientToolsRawFromRespSemanticsWithNative(semantics);
+    if (nativeResolved && nativeResolved.length > 0) {
+        return nativeResolved;
+    }
+    const toolsNode = asJsonRecord(semantics?.tools);
+    const anthropicNode = asJsonRecord(semantics?.anthropic);
+    return (resolveClientToolsRaw(toolsNode?.clientToolsRaw) ??
+        resolveClientToolsRaw(anthropicNode?.clientToolsRaw));
 }
 export function resolveClientToolsRaw(candidate) {
     return resolveClientToolsRawWithNative(candidate);
 }
+function asJsonRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function finalizeAliasMap(aliasMap) {
+    const next = { ...aliasMap };
+    const shellAlias = next.shell_command ??
+        next.exec_command ??
+        next.shell ??
+        next.bash;
+    if (typeof shellAlias === 'string' && shellAlias.trim().length > 0) {
+        next.shell_command = next.shell_command ?? shellAlias;
+        next.exec_command = next.exec_command ?? shellAlias;
+        next.shell = next.shell ?? shellAlias;
+        next.bash = next.bash ?? shellAlias;
+    }
+    return next;
+}

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/client-remap-protocol-switch.d.ts

@@ -5,5 +5,6 @@ export interface ClientRemapProtocolSwitchOptions {
     clientProtocol: ClientProtocol;
     requestId: string;
     requestSemantics?: JsonObject;
+    responseSemantics?: JsonObject;
 }
 export declare function buildClientPayloadForProtocol(options: ClientRemapProtocolSwitchOptions): JsonObject;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/client-remap-protocol-switch.js

@@ -3,6 +3,7 @@ import { normalizeArgsBySchema } from '../../../../../args-mapping.js';
 import { normalizeResponsesToolCallIds } from '../../../../../shared/responses-tool-utils.js';
 import { isShellToolName } from '../../../../../../tools/tool-description-utils.js';
 import { applyClientPassthroughPatchWithNative, buildResponsesPayloadFromChatWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.js';
+import { normalizeOpenaiChatReasoningOutboundWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 import { resolveAliasMapFromSemantics, resolveClientToolsRawFromSemantics } from './chat-process-semantics-bridge.js';
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
@@ -283,7 +284,7 @@ export function buildClientPayloadForProtocol(options) {
     let clientPayload;
     const toolsRaw = resolveClientToolsRawFromSemantics(options.requestSemantics);
     if (options.clientProtocol === 'openai-chat') {
-        clientPayload = options.payload;
+        clientPayload = normalizeOpenaiChatReasoningOutboundWithNative(options.payload);
     }
     else if (options.clientProtocol === 'anthropic-messages') {
         clientPayload = buildAnthropicResponseFromChat(options.payload, {
@@ -293,6 +294,7 @@ export function buildClientPayloadForProtocol(options) {
     else {
         clientPayload = buildResponsesPayloadFromChatWithNative(options.payload, {
             requestId: options.requestId,
+            responseSemantics: options.responseSemantics,
             ...(toolsRaw ? { toolsRaw } : {})
         });
     }

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.d.ts

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

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_outbound/resp_outbound_stage1_client_remap/index.js

@@ -18,7 +18,8 @@ export function runRespOutboundStage1ClientRemap(options) {
         payload: options.payload,
         clientProtocol,
         requestId: options.requestId,
-        requestSemantics: options.requestSemantics
+        requestSemantics: options.requestSemantics,
+        responseSemantics: options.responseSemantics
     });
     logHubStageTiming(options.requestId, 'resp_outbound.stage1_build_client_payload', 'completed', {
         elapsedMs: Date.now() - buildStart,

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.d.ts

@@ -7,6 +7,8 @@ export interface RespProcessStage1ToolGovernanceOptions {
     entryEndpoint: string;
     requestId: string;
     clientProtocol: ClientProtocol;
+    requestSemantics?: JsonObject;
+    adapterContext?: Record<string, unknown>;
     stageRecorder?: StageRecorder;
 }
 export interface RespProcessStage1ToolGovernanceResult {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -2,11 +2,63 @@ import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pi
 import { recordStage } from '../../../stages/utils.js';
 import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
 import { applyRespProcessToolGovernanceWithNative, prepareRespProcessToolGovernancePayloadWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function collectToolNamesFromCandidate(candidate, out) {
+    if (!Array.isArray(candidate)) {
+        return;
+    }
+    for (const tool of candidate) {
+        if (typeof tool === 'string') {
+            const name = tool.trim();
+            if (name) {
+                out.add(name);
+            }
+            continue;
+        }
+        const row = asRecord(tool);
+        const functionBag = asRecord(row?.function);
+        const name = (typeof functionBag?.name === 'string' ? functionBag.name.trim() : '')
+            || (typeof row?.name === 'string' ? row.name.trim() : '');
+        if (name) {
+            out.add(name);
+        }
+    }
+}
+function resolveRequestedToolNames(options) {
+    const names = new Set();
+    const requestSemantics = asRecord(options.requestSemantics);
+    const semanticsTools = asRecord(requestSemantics?.tools);
+    collectToolNamesFromCandidate(requestSemantics?.tools, names);
+    collectToolNamesFromCandidate(semanticsTools?.clientToolsRaw, names);
+    collectToolNamesFromCandidate(semanticsTools?.baselineTools, names);
+    const capturedChatRequest = asRecord(options.adapterContext?.capturedChatRequest);
+    collectToolNamesFromCandidate(capturedChatRequest?.tools, names);
+    return Array.from(names);
+}
+function attachRequestedToolNames(payload, requestedToolNames) {
+    if (!requestedToolNames.length) {
+        return payload;
+    }
+    const governance = asRecord(payload.__rcc_tool_governance) ?? {};
+    return {
+        ...payload,
+        __rcc_tool_governance: {
+            ...governance,
+            requestedToolNames
+        }
+    };
+}
 export async function runRespProcessStage1ToolGovernance(options) {
     const forceDetailLog = isHubStageTimingDetailEnabled();
+    const requestedToolNames = resolveRequestedToolNames(options);
+    const governancePayload = attachRequestedToolNames(options.payload, requestedToolNames);
     logHubStageTiming(options.requestId, 'resp_process.stage1_prepare_native', 'start');
     const prepareStart = Date.now();
-    const preparedNative = prepareRespProcessToolGovernancePayloadWithNative(options.payload);
+    const preparedNative = prepareRespProcessToolGovernancePayloadWithNative(governancePayload);
     const preparedPayload = preparedNative.preparedPayload;
     logHubStageTiming(options.requestId, 'resp_process.stage1_prepare_native', 'completed', {
         elapsedMs: Date.now() - prepareStart,

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.js

@@ -15,8 +15,11 @@ export async function runRespProcessStage2Finalize(options) {
         requestId: options.requestId
     }));
     // Strip executed servertool calls before returning to client (single source of truth).
+    // This must also run for internal servertool followups: reasoning.stop/review/clock
+    // handlers append tool_outputs first, and skipping this strip leaks consumed internal
+    // tool_calls into client required_action/output surfaces.
     const stripSource = options.originalPayload ?? options.payload;
-    if (!options.skipServerToolStrip && stripSource && typeof stripSource === 'object') {
+    if (stripSource && typeof stripSource === 'object') {
         finalized = filterOutExecutedServerToolCalls(finalized, stripSource);
     }
     logHubStageTiming(options.requestId, 'resp_process.stage2_native_finalize', 'completed', {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.d.ts

@@ -29,6 +29,7 @@ export interface RespProcessStage3ServerToolOrchestrationOptions {
     requestId: string;
     entryEndpoint: string;
     providerProtocol: ProviderProtocol;
+    allowFollowup?: boolean;
     stageRecorder?: StageRecorder;
     providerInvoker?: ProviderInvoker;
     reenterPipeline?: ReenterPipeline;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.js

@@ -4,6 +4,22 @@ import { recordStage } from '../../../stages/utils.js';
 import { isHubStageTimingDetailEnabled, logHubStageTiming } from '../../../hub-stage-timing.js';
 export async function runRespProcessStage3ServerToolOrchestration(options) {
     const forceDetailLog = isHubStageTimingDetailEnabled();
+    const runtimeMeta = options.adapterContext &&
+        typeof options.adapterContext === 'object' &&
+        !Array.isArray(options.adapterContext)
+        ? options.adapterContext.__rt
+        : undefined;
+    if (runtimeMeta?.serverToolFollowup === true && options.allowFollowup !== true) {
+        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
+            executed: false,
+            skipReason: 'followup_bypass',
+            inputShape: detectProviderResponseShapeWithNative(options.payload)
+        });
+        return {
+            payload: options.payload,
+            executed: false
+        };
+    }
     const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline) || Boolean(options.clientInjectDispatch);
     const inputShape = detectProviderResponseShapeWithNative(options.payload);
     if (!hasServerToolSupport) {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/policy/policy-engine.js

@@ -1,5 +1,9 @@
 import { resolveHubProtocolSpec } from './protocol-spec.js';
 import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { loadCompatProfileRegistry, getPolicyOverrides } from '../../compat/profile-registry/registry.js';
+import { shouldSkipPolicy } from '../../compat/profile-registry/policy-overrides.js';
+// Load compat registry at module level for config-driven policy overrides
+const policyCompatRegistry = loadCompatProfileRegistry();
 let hubPolicyRuntime = undefined;
 export function setHubPolicyRuntimePolicy(policy) {
     hubPolicyRuntime = policy;
@@ -212,8 +216,11 @@ export function recordHubPolicyObservation(options) {
         return;
     }
     const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
-    if (compatibilityProfile === 'chat:deepseek-web' || compatibilityProfile === 'chat:qwenchat-web') {
-        return;
+    if (compatibilityProfile) {
+        const overrides = getPolicyOverrides(policyCompatRegistry, compatibilityProfile);
+        if (shouldSkipPolicy(overrides, 'observe')) {
+            return;
+        }
     }
     if (!shouldSample(effectivePolicy?.sampleRate)) {
         return;
@@ -247,8 +254,11 @@ export function applyHubProviderOutboundPolicy(options) {
     }
     const normalizedProviderProtocol = normalizeHubProviderProtocol(options.providerProtocol);
     const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
-    if (compatibilityProfile === 'chat:deepseek-web' || compatibilityProfile === 'chat:qwenchat-web') {
-        return options.payload;
+    if (compatibilityProfile) {
+        const overrides = getPolicyOverrides(policyCompatRegistry, compatibilityProfile);
+        if (shouldSkipPolicy(overrides, 'enforce')) {
+            return options.payload;
+        }
     }
     const result = applyProviderOutboundPolicy(normalizedProviderProtocol, options.payload);
     if (!result.changed) {

package/node_modules/@jsonstudio/llms/dist/conversion/hub/process/chat-process-anthropic-alias.d.ts

@@ -1,2 +1,3 @@
 import type { StandardizedRequest } from '../types/standardized.js';
+export declare function normalizeAnthropicToolAliasMap(aliasMap?: Record<string, unknown>): Record<string, string> | undefined;
 export declare function applyAnthropicToolAliasSemantics(request: StandardizedRequest, entryEndpoint: string): StandardizedRequest;

package/node_modules/@jsonstudio/llms/dist/conversion/hub/process/chat-process-anthropic-alias.js

@@ -1,5 +1,33 @@
 import { isJsonObject } from '../types/json.js';
 import { buildAnthropicToolAliasMapWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function normalizeAnthropicToolAliasMap(aliasMap) {
+    if (!aliasMap || typeof aliasMap !== 'object') {
+        return undefined;
+    }
+    const next = {};
+    for (const [key, value] of Object.entries(aliasMap)) {
+        if (typeof key !== 'string' || typeof value !== 'string') {
+            continue;
+        }
+        const normalizedKey = key.trim().toLowerCase();
+        const normalizedValue = value.trim();
+        if (!normalizedKey || !normalizedValue) {
+            continue;
+        }
+        next[normalizedKey] = normalizedValue;
+    }
+    const shellAlias = next.shell_command ??
+        next.bash ??
+        next.shell ??
+        next.exec_command;
+    if (shellAlias) {
+        next.shell_command = shellAlias;
+        next.bash = shellAlias;
+        next.shell = shellAlias;
+        next.exec_command = shellAlias;
+    }
+    return Object.keys(next).length > 0 ? next : undefined;
+}
 export function applyAnthropicToolAliasSemantics(request, entryEndpoint) {
     try {
         const endpoint = typeof entryEndpoint === 'string' ? entryEndpoint.trim().toLowerCase() : '';
@@ -18,7 +46,7 @@ export function applyAnthropicToolAliasSemantics(request, entryEndpoint) {
         const sourceTools = Array.isArray(semanticsTools.clientToolsRaw) && semanticsTools.clientToolsRaw.length
             ? semanticsTools.clientToolsRaw
             : request.tools;
-        const aliasMap = buildAnthropicToolAliasMapWithNative(sourceTools);
+        const aliasMap = normalizeAnthropicToolAliasMap(buildAnthropicToolAliasMapWithNative(sourceTools));
         if (aliasMap) {
             semanticsTools.toolNameAliasMap = aliasMap;
         }