@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/hub/pipeline/session-identifiers.js

@@ -1,206 +1,16 @@
+import { coerceClientHeadersWithNative, extractSessionIdentifiersFromMetadataWithNative, findHeaderValueWithNative, normalizeHeaderKeyWithNative, pickHeaderWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-session-identifiers-semantics.js';
 export function extractSessionIdentifiersFromMetadata(metadata) {
-    const directSession = normalizeIdentifier(metadata?.sessionId);
-    const directConversation = normalizeIdentifier(metadata?.conversationId);
-    const headers = coerceClientHeaders(metadata?.clientHeaders);
-    let sessionId = directSession ||
-        (headers ? pickHeader(headers, ['session_id', 'session-id', 'x-session-id', 'anthropic-session-id']) : undefined);
-    let conversationId = directConversation ||
-        (headers
-            ? pickHeader(headers, [
-                'conversation_id',
-                'conversation-id',
-                'x-conversation-id',
-                'anthropic-conversation-id',
-                'openai-conversation-id'
-            ])
-            : undefined);
-    if (!sessionId || !conversationId) {
-        const fallback = deriveIdentifiersFromRawPayload(metadata);
-        sessionId = sessionId || fallback.sessionId;
-        conversationId = conversationId || fallback.conversationId || fallback.sessionId;
-    }
-    return {
-        ...(sessionId ? { sessionId } : {}),
-        ...(conversationId ? { conversationId } : {})
-    };
+    return extractSessionIdentifiersFromMetadataWithNative(metadata);
 }
 export function coerceClientHeaders(raw) {
-    if (!raw || typeof raw !== 'object') {
-        return undefined;
-    }
-    const normalized = {};
-    for (const [key, value] of Object.entries(raw)) {
-        if (typeof value === 'string' && value.trim()) {
-            normalized[key] = value;
-        }
-    }
-    return Object.keys(normalized).length ? normalized : undefined;
+    return coerceClientHeadersWithNative(raw);
 }
 export function pickHeader(headers, candidates) {
-    for (const name of candidates) {
-        const value = findHeaderValue(headers, name);
-        if (value) {
-            return value;
-        }
-    }
-    return undefined;
+    return pickHeaderWithNative(headers, candidates);
 }
 export function findHeaderValue(headers, target) {
-    const lowered = typeof target === 'string' ? target.toLowerCase() : '';
-    if (!lowered) {
-        return undefined;
-    }
-    const normalizedTarget = normalizeHeaderKey(lowered);
-    for (const [key, value] of Object.entries(headers)) {
-        if (typeof value !== 'string') {
-            continue;
-        }
-        const trimmed = value.trim();
-        if (!trimmed) {
-            continue;
-        }
-        const loweredKey = key.toLowerCase();
-        if (loweredKey === lowered) {
-            return trimmed;
-        }
-        if (normalizeHeaderKey(loweredKey) === normalizedTarget) {
-            return trimmed;
-        }
-    }
-    return undefined;
+    return findHeaderValueWithNative(headers, target);
 }
 export function normalizeHeaderKey(value) {
-    return value.replace(/[\s_-]+/g, '');
-}
-function normalizeIdentifier(value) {
-    if (typeof value !== 'string') {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed || undefined;
-}
-const SESSION_TOKEN_REGEX = /session[_:\-\s]?([0-9a-f]{8,}(?:-[0-9a-f]{4,}){0,5})/i;
-const CONVERSATION_TOKEN_REGEX = /conversation[_:\-\s]?([0-9a-f]{8,}(?:-[0-9a-f]{4,}){0,5})/i;
-const SESSION_FIELD_KEYS = ['sessionid', 'session_id', 'session-id', 'anthropic-session-id'];
-const CONVERSATION_FIELD_KEYS = ['conversationid', 'conversation_id', 'conversation-id', 'anthropic-conversation-id', 'openai-conversation-id'];
-function deriveIdentifiersFromRawPayload(metadata) {
-    if (!metadata || typeof metadata !== 'object') {
-        return {};
-    }
-    const raw = metadata.__raw_request_body;
-    const targets = [];
-    let rawUserMetadataSession;
-    if (raw !== undefined) {
-        targets.push(raw);
-        if (typeof raw === 'object' && raw !== null) {
-            const rawRecord = raw;
-            rawUserMetadataSession = extractSessionIdFromUserMetadata(rawRecord);
-            if (rawRecord.metadata) {
-                targets.push(rawRecord.metadata);
-            }
-            if (rawRecord.rawText) {
-                targets.push(rawRecord.rawText);
-            }
-            if (rawRecord.events) {
-                targets.push(rawRecord.events);
-            }
-        }
-    }
-    let sessionId;
-    let conversationId;
-    if (rawUserMetadataSession) {
-        sessionId = rawUserMetadataSession;
-        conversationId = rawUserMetadataSession;
-    }
-    for (const candidate of targets) {
-        if (!sessionId) {
-            sessionId = findIdentifier(candidate, SESSION_FIELD_KEYS, SESSION_TOKEN_REGEX);
-        }
-        if (!conversationId) {
-            conversationId = findIdentifier(candidate, CONVERSATION_FIELD_KEYS, CONVERSATION_TOKEN_REGEX);
-        }
-        if (sessionId && conversationId) {
-            break;
-        }
-    }
-    if (!sessionId && conversationId) {
-        sessionId = conversationId;
-    }
-    else if (sessionId && !conversationId) {
-        conversationId = sessionId;
-    }
-    return {
-        ...(sessionId ? { sessionId } : {}),
-        ...(conversationId ? { conversationId } : {})
-    };
-}
-function extractSessionIdFromUserMetadata(raw) {
-    const metadataNode = raw.metadata;
-    if (!metadataNode || typeof metadataNode !== 'object') {
-        return undefined;
-    }
-    const userId = metadataNode.user_id;
-    if (typeof userId !== 'string') {
-        return undefined;
-    }
-    const trimmed = userId.trim();
-    if (!trimmed) {
-        return undefined;
-    }
-    const match = trimmed.match(SESSION_TOKEN_REGEX);
-    if (match && match[1]) {
-        return match[1];
-    }
-    return undefined;
-}
-function findIdentifier(source, preferredKeys, regex) {
-    if (source === undefined || source === null) {
-        return undefined;
-    }
-    if (typeof source === 'string') {
-        const trimmed = source.trim();
-        if (!trimmed) {
-            return undefined;
-        }
-        const match = trimmed.match(regex);
-        if (match && match[1]) {
-            return match[1];
-        }
-        if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
-            try {
-                const parsed = JSON.parse(trimmed);
-                return findIdentifier(parsed, preferredKeys, regex);
-            }
-            catch {
-                return undefined;
-            }
-        }
-        return undefined;
-    }
-    if (Array.isArray(source)) {
-        for (const entry of source) {
-            const candidate = findIdentifier(entry, preferredKeys, regex);
-            if (candidate) {
-                return candidate;
-            }
-        }
-        return undefined;
-    }
-    if (typeof source === 'object') {
-        const record = source;
-        for (const [key, value] of Object.entries(record)) {
-            const lowered = typeof key === 'string' ? key.toLowerCase() : '';
-            if (preferredKeys.includes(lowered)) {
-                const normalized = normalizeIdentifier(value);
-                if (normalized) {
-                    return normalized;
-                }
-            }
-            const fromNested = findIdentifier(value, preferredKeys, regex);
-            if (fromNested) {
-                return fromNested;
-            }
-        }
-    }
-    return undefined;
+    return normalizeHeaderKeyWithNative(value);
 }

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

@@ -1,11 +1,10 @@
 import type { AdapterContext } from '../../../../types/chat-envelope.js';
 import type { FormatEnvelope } from '../../../../types/format-envelope.js';
 import type { JsonObject } from '../../../../types/json.js';
-import type { FormatAdapter, StageRecorder } from '../../../../format-adapters/index.js';
+import type { StageRecorder } from '../../../../format-adapters/index.js';
 export interface ReqInboundStage1FormatParseOptions {
     rawRequest: JsonObject;
     adapterContext: AdapterContext;
-    formatAdapter: Pick<FormatAdapter, 'parseRequest'>;
     stageRecorder?: StageRecorder;
 }
 export declare function runReqInboundStage1FormatParse(options: ReqInboundStage1FormatParseOptions): Promise<FormatEnvelope<JsonObject>>;

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

@@ -1,6 +1,42 @@
 import { recordStage } from '../../../stages/utils.js';
+import { sanitizeReqInboundFormatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { parseReqInboundFormatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { normalizeReasoningInAnthropicPayload, normalizeReasoningInChatPayload, normalizeReasoningInGeminiPayload, normalizeReasoningInResponsesPayload } from '../../../../../shared/reasoning-normalizer.js';
+function resolveProtocolToken(adapterContext) {
+    const candidate = typeof adapterContext.providerProtocol === 'string' && adapterContext.providerProtocol.trim().length
+        ? adapterContext.providerProtocol.trim().toLowerCase()
+        : '';
+    if (candidate === 'openai-chat' || candidate === 'openai-responses' || candidate === 'anthropic-messages' || candidate === 'gemini-chat') {
+        return candidate;
+    }
+    return 'openai-chat';
+}
+function applyReasoningNormalization(rawRequest, protocol) {
+    if (protocol === 'openai-responses') {
+        normalizeReasoningInResponsesPayload(rawRequest, {
+            includeInput: true,
+            includeInstructions: true
+        });
+        return;
+    }
+    if (protocol === 'anthropic-messages') {
+        normalizeReasoningInAnthropicPayload(rawRequest);
+        return;
+    }
+    if (protocol === 'gemini-chat') {
+        normalizeReasoningInGeminiPayload(rawRequest);
+        return;
+    }
+    normalizeReasoningInChatPayload(rawRequest);
+}
 export async function runReqInboundStage1FormatParse(options) {
-    const envelope = (await options.formatAdapter.parseRequest(options.rawRequest, options.adapterContext));
+    const protocol = resolveProtocolToken(options.adapterContext);
+    applyReasoningNormalization(options.rawRequest, protocol);
+    const envelopeRaw = parseReqInboundFormatEnvelopeWithNative({
+        rawRequest: options.rawRequest,
+        protocol
+    });
+    const envelope = sanitizeReqInboundFormatEnvelopeWithNative(envelopeRaw);
     recordStage(options.stageRecorder, 'chat_process.req.stage1.format_parse', envelope);
     return envelope;
 }

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

@@ -1,6 +1,6 @@
 import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
 import type { FormatEnvelope } from '../../../../types/format-envelope.js';
-import type { JsonObject } from '../../../../types/json.js';
+import { type JsonObject } from '../../../../types/json.js';
 import type { SemanticMapper, StageRecorder } from '../../../../format-adapters/index.js';
 import type { StandardizedRequest } from '../../../../types/standardized.js';
 export interface ReqInboundStage2SemanticMapOptions {

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

@@ -1,11 +1,24 @@
-import { chatEnvelopeToStandardized } from '../../../../standardized-bridge.js';
-import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
-import { buildAnthropicToolAliasMap } from '../../../../../shared/anthropic-message-utils.js';
+import { isJsonObject, jsonClone } from '../../../../types/json.js';
 import { applyHubOperationTableInbound } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
-import { isJsonObject, jsonClone } from '../../../../types/json.js';
+import { liftReqInboundSemantics } from './semantic-lift.js';
+import { validateChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { chatEnvelopeToStandardizedWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 export async function runReqInboundStage2SemanticMap(options) {
     const chatEnvelope = await options.semanticMapper.toChat(options.formatEnvelope, options.adapterContext);
+    const preservedResponsesContext = (() => {
+        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object') {
+            return undefined;
+        }
+        const semantics = chatEnvelope.semantics;
+        const responsesNode = isJsonObject(semantics.responses)
+            ? semantics.responses
+            : undefined;
+        const contextNode = responsesNode && isJsonObject(responsesNode.context)
+            ? responsesNode.context
+            : undefined;
+        return contextNode ? jsonClone(contextNode) : undefined;
+    })();
     applyHubOperationTableInbound({
         formatEnvelope: options.formatEnvelope,
         chatEnvelope,
@@ -13,95 +26,70 @@ export async function runReqInboundStage2SemanticMap(options) {
     });
     // Semantic Gate (request): before entering chat_process, lift any mappable protocol semantics
     // into ChatEnvelope.semantics. Do not persist these in metadata.
-    try {
-        if (!chatEnvelope.semantics || typeof chatEnvelope.semantics !== 'object') {
-            chatEnvelope.semantics = {};
-        }
-        const semantics = chatEnvelope.semantics;
-        if (!semantics.tools || !isJsonObject(semantics.tools)) {
-            semantics.tools = {};
-        }
-        const toolsNode = semantics.tools;
-        const rawTools = Array.isArray(options.formatEnvelope.payload?.tools)
-            ? (options.formatEnvelope.payload.tools ?? [])
-            : [];
-        if (rawTools.length && toolsNode.clientToolsRaw === undefined) {
-            toolsNode.clientToolsRaw = jsonClone(rawTools);
-        }
-        // /v1/messages tool names are case-sensitive to the client (e.g. Bash/Glob/Read).
-        // Capture an alias map here (from the *raw* client tools) so later response remap
-        // can convert canonical tool calls (e.g. shell_command/glob/read) back to the
-        // original client tool names.
-        try {
-            const protocol = String(options.formatEnvelope?.protocol || '').toLowerCase();
-            const endpoint = String(options.adapterContext?.entryEndpoint || '').toLowerCase();
-            const shouldCapture = protocol === 'anthropic-messages' || endpoint.includes('/v1/messages');
-            const hasAliasMap = isJsonObject(toolsNode.toolNameAliasMap) || isJsonObject(toolsNode.toolAliasMap);
-            if (shouldCapture && !hasAliasMap && rawTools.length) {
-                const aliasMap = buildAnthropicToolAliasMap(rawTools);
-                if (aliasMap) {
-                    toolsNode.toolNameAliasMap = jsonClone(aliasMap);
-                }
-            }
-        }
-        catch {
-            // best-effort: never block request handling due to alias map propagation failures
+    liftReqInboundSemantics({
+        chatEnvelope,
+        formatEnvelope: options.formatEnvelope,
+        adapterContext: options.adapterContext,
+        responsesResume: options.responsesResume
+    });
+    if (preservedResponsesContext) {
+        const currentSemantics = chatEnvelope.semantics;
+        if (!currentSemantics || typeof currentSemantics !== 'object') {
+            chatEnvelope.semantics = { responses: { context: jsonClone(preservedResponsesContext) } };
         }
-        if (options.responsesResume && isJsonObject(options.responsesResume)) {
-            if (!semantics.responses || !isJsonObject(semantics.responses)) {
-                semantics.responses = {};
-            }
-            const responsesNode = semantics.responses;
-            if (responsesNode.resume === undefined) {
-                responsesNode.resume = jsonClone(options.responsesResume);
-            }
-            // If this is a Responses submit/resume hop, tool outputs may exist only in resume metadata.
-            // Lift them into canonical chat.toolOutputs so chat_process sees a single unified surface.
-            const hasDirectToolOutputs = Array.isArray(chatEnvelope.toolOutputs) && chatEnvelope.toolOutputs.length > 0;
-            if (!hasDirectToolOutputs) {
-                const detailed = Array.isArray(options.responsesResume.toolOutputsDetailed)
-                    ? options.responsesResume.toolOutputsDetailed
-                    : undefined;
-                if (detailed && detailed.length) {
-                    const mapped = detailed
-                        .map((entry, index) => {
-                        if (!entry || typeof entry !== 'object')
-                            return undefined;
-                        const callId = typeof entry.callId === 'string' && String(entry.callId).trim().length
-                            ? String(entry.callId).trim()
-                            : typeof entry.originalId === 'string' && String(entry.originalId).trim().length
-                                ? String(entry.originalId).trim()
-                                : `resume_tool_${index + 1}`;
-                        const outputText = typeof entry.outputText === 'string'
-                            ? entry.outputText
-                            : (() => { try {
-                                return JSON.stringify(entry.outputText ?? '');
-                            }
-                            catch {
-                                return String(entry.outputText ?? '');
-                            } })();
-                        return { tool_call_id: callId, content: outputText };
-                    })
-                        .filter(Boolean);
-                    if (mapped.length) {
-                        chatEnvelope.toolOutputs = mapped;
+        else {
+            const semantics = currentSemantics;
+            const responsesNode = isJsonObject(semantics.responses)
+                ? semantics.responses
+                : {};
+            if (!isJsonObject(responsesNode.context)) {
+                chatEnvelope.semantics = {
+                    ...semantics,
+                    responses: {
+                        ...responsesNode,
+                        context: jsonClone(preservedResponsesContext)
                     }
-                }
+                };
             }
         }
     }
-    catch {
-        // fail-fast is enforced at chat_process entry; this gate is best-effort
-    }
-    validateChatEnvelope(chatEnvelope, {
+    validateChatEnvelopeWithNative(chatEnvelope, {
         stage: 'req_inbound',
         direction: 'request'
     });
     recordStage(options.stageRecorder, 'chat_process.req.stage2.semantic_map', chatEnvelope);
-    const standardizedRequest = chatEnvelopeToStandardized(chatEnvelope, {
+    const standardizedRequest = chatEnvelopeToStandardizedWithNative({
+        chatEnvelope: chatEnvelope,
         adapterContext: options.adapterContext,
         endpoint: options.adapterContext.entryEndpoint,
         requestId: options.adapterContext.requestId
     });
+    // Ensure responses semantics (context) survive into standardized request for VirtualRouter parsing.
+    if (chatEnvelope.semantics && typeof chatEnvelope.semantics === 'object') {
+        const envelopeSemantics = chatEnvelope.semantics;
+        const existing = standardizedRequest.semantics;
+        if (!existing || typeof existing !== 'object') {
+            standardizedRequest.semantics = jsonClone(envelopeSemantics);
+        }
+        else {
+            const existingObj = existing;
+            const envelopeResponses = isJsonObject(envelopeSemantics.responses)
+                ? envelopeSemantics.responses
+                : undefined;
+            const envelopeContext = envelopeResponses && isJsonObject(envelopeResponses.context)
+                ? envelopeResponses.context
+                : undefined;
+            if (envelopeContext) {
+                const nextResponses = {
+                    ...(isJsonObject(existingObj.responses) ? existingObj.responses : {}),
+                    context: jsonClone(envelopeContext)
+                };
+                standardizedRequest.semantics = {
+                    ...existingObj,
+                    responses: nextResponses
+                };
+            }
+        }
+    }
     return { chatEnvelope, standardizedRequest };
 }

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/semantic-lift.d.ts

@@ -0,0 +1,14 @@
+import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
+import type { FormatEnvelope } from '../../../../types/format-envelope.js';
+import type { JsonObject } from '../../../../types/json.js';
+export interface ReqInboundSemanticLiftOptions {
+    chatEnvelope: ChatEnvelope;
+    formatEnvelope: FormatEnvelope<JsonObject>;
+    adapterContext: AdapterContext;
+    responsesResume?: JsonObject;
+}
+export declare function liftReqInboundSemantics(options: ReqInboundSemanticLiftOptions): void;
+export declare function mapResumeToolOutputsDetailed(responsesResume: JsonObject): Array<{
+    tool_call_id: string;
+    content: string;
+}>;

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage2_semantic_map/semantic-lift.js

@@ -0,0 +1,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 lifted = applyReqInboundSemanticLiftWithNative({
+        chatEnvelope: options.chatEnvelope,
+        payload: options.formatEnvelope.payload,
+        protocol: options.formatEnvelope.protocol,
+        entryEndpoint: options.adapterContext.entryEndpoint,
+        responsesResume: normalizedResponsesResume
+    });
+    replaceEnvelope(options.chatEnvelope, lifted);
+}
+export function mapResumeToolOutputsDetailed(responsesResume) {
+    return mapReqInboundResumeToolOutputsDetailedWithNative(responsesResume);
+}
+function replaceEnvelope(target, source) {
+    for (const key of Object.keys(target)) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) {
+            delete target[key];
+        }
+    }
+    Object.assign(target, source);
+}

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/archive/shell-like-tool-call-normalization-fallback.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../../../../../types/json.js';
+export declare function normalizeShellLikeToolCallsBeforeGovernanceFallback(payload: JsonObject): void;

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/archive/shell-like-tool-call-normalization-fallback.js

@@ -0,0 +1,157 @@
+import { isShellLikeToolNameTokenWithNative } from '../../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+const SHELL_LIKE_TOOL_NAMES = new Set(['exec_command', 'shell_command', 'shell', 'bash', 'terminal']);
+function readTrimmedString(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function readStringArrayCommand(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const tokens = value
+        .map((item) => (item == null ? '' : String(item).trim()))
+        .filter((item) => item.length > 0);
+    return tokens.length ? tokens.join(' ') : undefined;
+}
+function parseJsonRecord(value) {
+    if (isRecord(value)) {
+        return value;
+    }
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readCommandFromArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    const direct = readTrimmedString(args.cmd) ??
+        readTrimmedString(args.command) ??
+        readTrimmedString(args.script) ??
+        readTrimmedString(args.toon) ??
+        readStringArrayCommand(args.cmd) ??
+        readStringArrayCommand(args.command);
+    if (direct) {
+        return direct;
+    }
+    if (!input) {
+        return undefined;
+    }
+    return (readTrimmedString(input.cmd) ??
+        readTrimmedString(input.command) ??
+        readTrimmedString(input.script) ??
+        readStringArrayCommand(input.cmd) ??
+        readStringArrayCommand(input.command));
+}
+function readWorkdirFromArgs(args) {
+    const input = isRecord(args.input) ? args.input : undefined;
+    return (readTrimmedString(args.workdir) ??
+        readTrimmedString(args.cwd) ??
+        readTrimmedString(args.workDir) ??
+        readTrimmedString(input?.workdir) ??
+        readTrimmedString(input?.cwd));
+}
+function collectRequestedToolNames(payload) {
+    const names = new Set();
+    const root = payload;
+    const tools = Array.isArray(root.tools) ? root.tools : [];
+    for (const tool of tools) {
+        if (!isRecord(tool))
+            continue;
+        const fn = isRecord(tool.function) ? tool.function : undefined;
+        const name = readTrimmedString(fn?.name) ?? readTrimmedString(tool.name);
+        if (name) {
+            names.add(name);
+        }
+    }
+    return names;
+}
+function resolveShellLikeToolName(rawName, requestedToolNames) {
+    if (requestedToolNames.size === 0) {
+        return rawName;
+    }
+    if (requestedToolNames.has(rawName)) {
+        return rawName;
+    }
+    if (requestedToolNames.has('exec_command')) {
+        return 'exec_command';
+    }
+    if (requestedToolNames.has('shell_command')) {
+        return 'shell_command';
+    }
+    return rawName;
+}
+export function normalizeShellLikeToolCallsBeforeGovernanceFallback(payload) {
+    const root = payload;
+    const messages = Array.isArray(root.messages) ? root.messages : [];
+    if (!messages.length) {
+        return;
+    }
+    const requestedToolNames = collectRequestedToolNames(payload);
+    for (const message of messages) {
+        if (!isRecord(message))
+            continue;
+        const role = readTrimmedString(message.role)?.toLowerCase();
+        if (role !== 'assistant')
+            continue;
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        if (!toolCalls.length)
+            continue;
+        for (const call of toolCalls) {
+            if (!isRecord(call))
+                continue;
+            const fn = isRecord(call.function) ? call.function : undefined;
+            if (!fn)
+                continue;
+            const rawName = readTrimmedString(fn.name);
+            if (!rawName)
+                continue;
+            const isShellLike = isShellLikeToolNameTokenWithNative(rawName);
+            if (!isShellLike)
+                continue;
+            const resolvedName = resolveShellLikeToolName(rawName, requestedToolNames);
+            if (resolvedName !== rawName) {
+                fn.name = resolvedName;
+            }
+            const parsedArgs = parseJsonRecord(fn.arguments);
+            const args = parsedArgs ?? {};
+            const cmd = readCommandFromArgs(args);
+            if (!cmd) {
+                continue;
+            }
+            const nextArgs = {
+                ...args,
+                cmd,
+                command: cmd
+            };
+            const workdir = readWorkdirFromArgs(args);
+            if (workdir) {
+                nextArgs.workdir = workdir;
+            }
+            if (Object.prototype.hasOwnProperty.call(nextArgs, 'toon')) {
+                delete nextArgs.toon;
+            }
+            try {
+                fn.arguments = JSON.stringify(nextArgs);
+            }
+            catch {
+                fn.arguments = JSON.stringify({ cmd, command: cmd, ...(workdir ? { workdir } : {}) });
+            }
+        }
+    }
+}