@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage1_tool_governance/index.js

@@ -1,18 +1,30 @@
 import { runChatResponseToolFilters } from '../../../../../shared/tool-filter-pipeline.js';
-import { normalizeApplyPatchToolCallsOnResponse } from '../../../../../shared/tool-governor.js';
 import { buildChatResponseFromResponses } from '../../../../../shared/responses-response-utils.js';
 import { normalizeAssistantTextToToolCalls } from '../../../../../shared/text-markup-normalizer.js';
-import { stripOrphanFunctionCallsTag } from '../../../../../compat/actions/strip-orphan-function-calls-tag.js';
-import { ToolGovernanceEngine } from '../../../../tool-governance/index.js';
 import { recordStage } from '../../../stages/utils.js';
-const toolGovernanceEngine = new ToolGovernanceEngine();
-const TOOL_CALL_JSON_MARKER = /["']tool_calls["']\s*:/i;
+import { applyRespProcessToolGovernanceWithNative, stripOrphanFunctionCallsTagWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
 const SHELL_TOOL_NAME_ALIASES = {
     shell_command: 'exec_command',
     shell: 'exec_command',
     bash: 'exec_command',
     terminal: 'exec_command'
 };
+/**
+ * Unified text-to-tool-calls harvest config.
+ * Shared across all providers via chat process tool governance.
+ */
+const DEFAULT_TEXT_NORMALIZER_CONFIG = {
+    jsonToolRepair: {
+        toolNameAliases: SHELL_TOOL_NAME_ALIASES,
+        argumentAliases: {
+            exec_command: {
+                cmd: ['cmd', 'command', 'input.command', 'script'],
+                command: ['cmd', 'command', 'input.command', 'script'],
+                workdir: ['workdir', 'cwd', 'input.cwd']
+            }
+        }
+    }
+};
 function isCanonicalChatCompletion(payload) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return false;
@@ -45,7 +57,11 @@ function coerceToCanonicalChatCompletion(payload) {
     }
     return payload;
 }
-function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
+/**
+ * Harvest tool calls from assistant text content when native tool_calls are missing or empty.
+ * This is the single entry point for text-based tool call extraction across all providers.
+ */
+function harvestToolCallsFromText(payload) {
     if (!payload || typeof payload !== 'object') {
         return payload;
     }
@@ -53,6 +69,7 @@ function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
     if (!choices.length) {
         return payload;
     }
+    let changed = false;
     for (const choice of choices) {
         if (!choice || typeof choice !== 'object' || Array.isArray(choice)) {
             continue;
@@ -61,45 +78,38 @@ function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
         if (!message || typeof message !== 'object' || Array.isArray(message)) {
             continue;
         }
-        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
-        if (!toolCalls || toolCalls.length !== 0) {
-            continue;
-        }
-        const content = typeof message.content === 'string' ? String(message.content).trim() : '';
-        if (!content || !TOOL_CALL_JSON_MARKER.test(content)) {
+        // Skip if already has native tool_calls
+        const existingToolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : undefined;
+        if (existingToolCalls && existingToolCalls.length > 0) {
             continue;
         }
-        const normalized = normalizeAssistantTextToToolCalls(message, {
-            jsonToolRepair: {
-                toolNameAliases: SHELL_TOOL_NAME_ALIASES,
-                argumentAliases: {
-                    exec_command: {
-                        cmd: ['cmd', 'command', 'input.command', 'script'],
-                        command: ['cmd', 'command', 'input.command', 'script'],
-                        workdir: ['workdir', 'cwd', 'input.cwd']
-                    }
-                }
+        // Try to harvest from text content
+        const normalized = normalizeAssistantTextToToolCalls(message, DEFAULT_TEXT_NORMALIZER_CONFIG);
+        const harvestedCalls = Array.isArray(normalized.tool_calls)
+            ? normalized.tool_calls
+            : [];
+        if (harvestedCalls.length > 0) {
+            choice.message = normalized;
+            changed = true;
+            // Update finish_reason if needed
+            const finish = typeof choice.finish_reason === 'string'
+                ? String(choice.finish_reason).trim().toLowerCase()
+                : '';
+            if (!finish || finish === 'stop') {
+                choice.finish_reason = 'tool_calls';
             }
-        });
-        const repairedCalls = Array.isArray(normalized.tool_calls) ? normalized.tool_calls : [];
-        if (!repairedCalls.length) {
-            continue;
-        }
-        choice.message = normalized;
-        const finish = typeof choice.finish_reason === 'string' ? String(choice.finish_reason).trim().toLowerCase() : '';
-        if (!finish || finish === 'stop') {
-            choice.finish_reason = 'tool_calls';
         }
     }
-    return payload;
+    return changed ? payload : payload;
 }
 function sanitizeResponseShapeBeforeGovernance(payload) {
-    return stripOrphanFunctionCallsTag(payload);
+    return stripOrphanFunctionCallsTagWithNative(payload);
 }
 export async function runRespProcessStage1ToolGovernance(options) {
     const canonicalInput = coerceToCanonicalChatCompletion(options.payload);
     const shapeSanitizedInput = sanitizeResponseShapeBeforeGovernance(canonicalInput);
-    maybeHarvestEmptyToolCallsFromJsonContent(shapeSanitizedInput);
+    // Single entry point for text-to-tool-calls harvest across all providers
+    harvestToolCallsFromText(shapeSanitizedInput);
     recordStage(options.stageRecorder, 'chat_process.resp.stage6.canonicalize_chat_completion', {
         converted: canonicalInput !== options.payload,
         shapeSanitized: shapeSanitizedInput !== canonicalInput,
@@ -110,12 +120,17 @@ export async function runRespProcessStage1ToolGovernance(options) {
         requestId: options.requestId,
         profile: 'openai-chat'
     });
-    const patched = normalizeApplyPatchToolCallsOnResponse(filtered);
-    const { payload: governed, summary } = toolGovernanceEngine.governResponse(patched, options.clientProtocol);
+    const patchedNative = applyRespProcessToolGovernanceWithNative({
+        payload: filtered,
+        clientProtocol: options.clientProtocol,
+        entryEndpoint: options.entryEndpoint,
+        requestId: options.requestId
+    });
+    const governed = patchedNative.governedPayload;
     recordStage(options.stageRecorder, 'chat_process.resp.stage7.tool_governance', {
-        summary,
-        applied: summary?.applied,
-        filteredPayload: patched,
+        summary: patchedNative.summary,
+        applied: patchedNative.summary?.applied === true,
+        filteredPayload: filtered,
         governedPayload: governed
     });
     return { governedPayload: governed };

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage2_finalize/index.js

@@ -1,12 +1,25 @@
-import { finalizeOpenAIChatResponse } from '../../../../../shared/openai-finalizer.js';
 import { buildProcessedRequestFromChatResponse } from '../../../../response/chat-response-utils.js';
 import { recordStage } from '../../../stages/utils.js';
+import { finalizeRespProcessChatResponseWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+import { normalizeReasoningInChatPayload } from '../../../../../shared/reasoning-normalizer.js';
 export async function runRespProcessStage2Finalize(options) {
-    const finalized = (await finalizeOpenAIChatResponse(options.payload, {
-        requestId: options.requestId,
-        endpoint: options.entryEndpoint,
+    const endpoint = (options.entryEndpoint || '').toLowerCase();
+    const wantsAnthropicReasoning = endpoint.includes('/v1/messages');
+    const shouldNormalize = (options.reasoningMode && options.reasoningMode !== 'keep') || wantsAnthropicReasoning;
+    if (shouldNormalize) {
+        try {
+            normalizeReasoningInChatPayload(options.payload);
+        }
+        catch {
+            // best-effort inline reasoning extraction
+        }
+    }
+    const finalized = (await finalizeRespProcessChatResponseWithNative({
+        payload: options.payload,
         stream: options.wantsStream,
-        reasoningMode: options.reasoningMode
+        reasoningMode: options.reasoningMode,
+        endpoint: options.entryEndpoint,
+        requestId: options.requestId
     }));
     const processedRequest = buildProcessedRequestFromChatResponse(finalized, {
         stream: options.wantsStream

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.d.ts

@@ -14,6 +14,15 @@ type ReenterPipeline = (options: {
     __sse_responses?: NodeJS.ReadableStream;
     format?: string;
 }>;
+type ClientInjectDispatch = (options: {
+    entryEndpoint: string;
+    requestId: string;
+    body?: JsonObject;
+    metadata?: JsonObject;
+}) => Promise<{
+    ok: boolean;
+    reason?: string;
+}>;
 export interface RespProcessStage3ServerToolOrchestrationOptions {
     payload: ChatCompletionLike;
     adapterContext: AdapterContext;
@@ -23,12 +32,13 @@ export interface RespProcessStage3ServerToolOrchestrationOptions {
     stageRecorder?: StageRecorder;
     providerInvoker?: ProviderInvoker;
     reenterPipeline?: ReenterPipeline;
+    clientInjectDispatch?: ClientInjectDispatch;
 }
 export interface RespProcessStage3ServerToolOrchestrationResult {
     payload: ChatCompletionLike;
     executed: boolean;
     flowId?: string;
-    skipReason?: 'no_servertool_support' | 'missing_reenter_pipeline';
+    skipReason?: 'no_servertool_support';
 }
 export declare function runRespProcessStage3ServerToolOrchestration(options: RespProcessStage3ServerToolOrchestrationOptions): Promise<RespProcessStage3ServerToolOrchestrationResult>;
 export {};

package/dist/conversion/hub/pipeline/stages/resp_process/resp_process_stage3_servertool_orchestration/index.js

@@ -1,26 +1,14 @@
 import { runServerToolOrchestration } from '../../../../../../servertool/engine.js';
+import { detectProviderResponseShapeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-servertool-orchestration-semantics.js';
 import { recordStage } from '../../../stages/utils.js';
-function detectProviderResponseShape(payload) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
-        return 'unknown';
-    const p = payload;
-    if (Array.isArray(p.choices))
-        return 'openai-chat';
-    if ((typeof p.object === 'string' && p.object === 'response') || Array.isArray(p.output))
-        return 'openai-responses';
-    if (Array.isArray(p.content) || typeof p.stop_reason === 'string')
-        return 'anthropic-messages';
-    if (Array.isArray(p.candidates))
-        return 'gemini-chat';
-    return 'unknown';
-}
 export async function runRespProcessStage3ServerToolOrchestration(options) {
-    const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline);
+    const hasServerToolSupport = Boolean(options.providerInvoker) || Boolean(options.reenterPipeline) || Boolean(options.clientInjectDispatch);
+    const inputShape = detectProviderResponseShapeWithNative(options.payload);
     if (!hasServerToolSupport) {
         recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
             executed: false,
             skipReason: 'no_servertool_support',
-            inputShape: detectProviderResponseShape(options.payload)
+            inputShape
         });
         return {
             payload: options.payload,
@@ -28,18 +16,6 @@ export async function runRespProcessStage3ServerToolOrchestration(options) {
             skipReason: 'no_servertool_support'
         };
     }
-    if (!options.reenterPipeline) {
-        recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
-            executed: false,
-            skipReason: 'missing_reenter_pipeline',
-            inputShape: detectProviderResponseShape(options.payload)
-        });
-        return {
-            payload: options.payload,
-            executed: false,
-            skipReason: 'missing_reenter_pipeline'
-        };
-    }
     const orchestration = await runServerToolOrchestration({
         chat: options.payload,
         adapterContext: options.adapterContext,
@@ -48,15 +24,17 @@ export async function runRespProcessStage3ServerToolOrchestration(options) {
         providerProtocol: options.providerProtocol,
         stageRecorder: options.stageRecorder,
         providerInvoker: options.providerInvoker,
-        reenterPipeline: options.reenterPipeline
+        reenterPipeline: options.reenterPipeline,
+        clientInjectDispatch: options.clientInjectDispatch
     });
     if (orchestration.executed) {
         const outputPayload = orchestration.chat;
+        const outputShape = detectProviderResponseShapeWithNative(outputPayload);
         recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
             executed: true,
             flowId: orchestration.flowId,
-            inputShape: detectProviderResponseShape(options.payload),
-            outputShape: detectProviderResponseShape(outputPayload)
+            inputShape,
+            outputShape
         });
         return {
             payload: outputPayload,
@@ -66,7 +44,7 @@ export async function runRespProcessStage3ServerToolOrchestration(options) {
     }
     recordStage(options.stageRecorder, 'chat_process.resp.stage5.servertool_orchestration', {
         executed: false,
-        inputShape: detectProviderResponseShape(options.payload)
+        inputShape
     });
     return {
         payload: options.payload,

package/dist/conversion/hub/pipeline/stages/utils.js

@@ -1,9 +1,25 @@
+import { parseLenientJsonishWithNative } from '../../../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+function normalizeRecordPayload(payload) {
+    if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+        return payload;
+    }
+    try {
+        const nativeParsed = parseLenientJsonishWithNative(payload);
+        if (nativeParsed && typeof nativeParsed === 'object' && !Array.isArray(nativeParsed)) {
+            return nativeParsed;
+        }
+    }
+    catch {
+        // native normalization is best-effort
+    }
+    return {};
+}
 export function recordStage(recorder, stageId, payload) {
     if (!recorder) {
         return;
     }
     try {
-        recorder.record(stageId, (payload ?? {}));
+        recorder.record(stageId, normalizeRecordPayload(payload));
     }
     catch {
         // Snapshot failures should not block the pipeline.

package/dist/conversion/hub/pipeline/target-utils.js

@@ -1,103 +1,26 @@
-import { ensureRuntimeMetadata } from '../../shared/runtime-metadata.js';
+import { applyTargetMetadataWithNative, applyTargetToSubjectWithNative, extractTargetModelIdWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-target-semantics.js';
+function replaceRecord(target, source) {
+    for (const key of Object.keys(target)) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) {
+            delete target[key];
+        }
+    }
+    Object.assign(target, source);
+}
 export function applyTargetMetadata(metadata, target, routeName, originalModel) {
     if (!metadata || typeof metadata !== 'object') {
         return;
     }
-    metadata.routeName = routeName;
-    metadata.pipelineId = target.providerKey;
-    metadata.target = target;
-    metadata.providerKey = target.providerKey;
-    metadata.providerType = target.providerType;
-    metadata.modelId = target.modelId;
-    metadata.processMode = target.processMode || 'chat';
-    if (target.forceWebSearch === true || target.forceVision === true) {
-        const rt = ensureRuntimeMetadata(metadata);
-        if (target.forceWebSearch === true) {
-            rt.forceWebSearch = true;
-        }
-        if (target.forceVision === true) {
-            rt.forceVision = true;
-        }
-    }
-    if (target.responsesConfig?.toolCallIdStyle) {
-        metadata.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
-    }
-    if (target.streaming) {
-        metadata.targetStreaming = target.streaming;
-    }
-    if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
-        const trimmed = originalModel.trim();
-        if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {
-            metadata.originalModelId = trimmed;
-        }
-        if (typeof metadata.clientModelId !== 'string' || !metadata.clientModelId) {
-            metadata.clientModelId = trimmed;
-        }
-    }
-    if (typeof target.modelId === 'string' && target.modelId.trim()) {
-        metadata.assignedModelId = target.modelId.trim();
-    }
+    const updated = applyTargetMetadataWithNative(metadata, target, routeName, originalModel);
+    replaceRecord(metadata, updated);
 }
 export function applyTargetToSubject(subject, target, originalModel) {
     if (!subject || typeof subject !== 'object') {
         return;
     }
-    const newModel = extractModelFromTarget(target);
-    if (!newModel) {
-        return;
-    }
-    subject.model = newModel;
-    if (subject.parameters && typeof subject.parameters === 'object') {
-        subject.parameters = {
-            ...subject.parameters,
-            model: newModel
-        };
-    }
-    else {
-        subject.parameters = { model: newModel };
-    }
-    const metadata = (subject.metadata && typeof subject.metadata === 'object'
-        ? subject.metadata
-        : { originalEndpoint: '/v1/chat/completions' });
-    metadata.providerKey = target.providerKey;
-    metadata.providerType = target.providerType;
-    metadata.processMode = target.processMode || 'chat';
-    subject.metadata = metadata;
-    const subjectMeta = metadata;
-    if (target.responsesConfig?.toolCallIdStyle) {
-        subjectMeta.toolCallIdStyle = target.responsesConfig.toolCallIdStyle;
-    }
-    if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
-        const trimmed = originalModel.trim();
-        if (typeof subjectMeta.originalModelId !== 'string' || !subjectMeta.originalModelId) {
-            subjectMeta.originalModelId = trimmed;
-        }
-        if (typeof subjectMeta.clientModelId !== 'string' || !subjectMeta.clientModelId) {
-            subjectMeta.clientModelId = trimmed;
-        }
-    }
-    subjectMeta.assignedModelId = newModel;
+    const updated = applyTargetToSubjectWithNative(subject, target, originalModel);
+    replaceRecord(subject, updated);
 }
 export function extractModelFromTarget(target) {
-    if (!target || typeof target.providerKey !== 'string') {
-        return null;
-    }
-    if (typeof target.modelId === 'string' && target.modelId.trim()) {
-        return target.modelId.trim();
-    }
-    if (typeof target.runtimeKey === 'string' && target.runtimeKey.length) {
-        const prefix = `${target.runtimeKey}.`;
-        if (target.providerKey.startsWith(prefix)) {
-            const candidate = target.providerKey.slice(prefix.length).trim();
-            if (candidate.length) {
-                return candidate;
-            }
-        }
-    }
-    const firstDot = target.providerKey.indexOf('.');
-    if (firstDot <= 0 || firstDot === target.providerKey.length - 1) {
-        return null;
-    }
-    const fallback = target.providerKey.slice(firstDot + 1).trim();
-    return fallback.length ? fallback : null;
+    return extractTargetModelIdWithNative(target);
 }

package/dist/conversion/hub/pipelines/inbound.js

@@ -1,3 +1,4 @@
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 function recordStage(recorder, stage, payload) {
     if (!recorder)
         return;
@@ -11,8 +12,9 @@ function recordStage(recorder, stage, payload) {
 function ensureFormatEnvelope(envelope, rawRequest, plan, context) {
     if (envelope)
         return envelope;
+    const normalizedProtocol = normalizeProviderProtocolTokenWithNative(plan.protocol || context.providerProtocol);
     return {
-        protocol: plan.protocol || context.providerProtocol,
+        protocol: normalizedProtocol ?? plan.protocol ?? context.providerProtocol,
         direction: 'request',
         payload: rawRequest
     };

package/dist/conversion/hub/pipelines/outbound.js

@@ -1,3 +1,4 @@
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 function recordStage(recorder, stage, payload) {
     if (!recorder)
         return;
@@ -12,6 +13,7 @@ export async function runOutboundPipeline(options) {
     const { chat, context, plan, stageRecorder } = options;
     if (!plan)
         throw new Error('Outbound plan is required');
+    normalizeProviderProtocolTokenWithNative(plan.protocol || context.providerProtocol);
     if (plan.passthrough?.mode === 'protocol') {
         if (!plan.passthrough.factory) {
             throw new Error('Outbound passthrough requires factory');

package/dist/conversion/hub/policy/policy-engine.js

@@ -1,4 +1,5 @@
 import { resolveHubProtocolSpec } from './protocol-spec.js';
+import { normalizeProviderProtocolTokenWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 let hubPolicyRuntime = undefined;
 export function setHubPolicyRuntimePolicy(policy) {
     hubPolicyRuntime = policy;
@@ -41,6 +42,9 @@ function isGeminiCliPayload(payload) {
         typeof record.requestId === 'string' ||
         hasGeminiCliRequestWrapper(payload));
 }
+function normalizeHubProviderProtocol(providerProtocol) {
+    return normalizeProviderProtocolTokenWithNative(providerProtocol) ?? providerProtocol;
+}
 function extendGeminiAllowlistIfNeeded(providerProtocol, payload, allowedTopLevelKeys) {
     if (providerProtocol !== 'gemini-chat') {
         return allowedTopLevelKeys;
@@ -214,11 +218,12 @@ export function recordHubPolicyObservation(options) {
     if (!shouldSample(effectivePolicy?.sampleRate)) {
         return;
     }
+    const normalizedProviderProtocol = normalizeHubProviderProtocol(options.providerProtocol);
     try {
         const phase = options.phase ?? 'provider_outbound';
         const observation = observeProviderPayload({
             phase,
-            providerProtocol: options.providerProtocol,
+            providerProtocol: normalizedProviderProtocol,
             payload: options.payload
         });
         if (observation.summary.totalViolations <= 0) {
@@ -240,18 +245,19 @@ export function applyHubProviderOutboundPolicy(options) {
     if (mode !== 'enforce') {
         return options.payload;
     }
+    const normalizedProviderProtocol = normalizeHubProviderProtocol(options.providerProtocol);
     const compatibilityProfile = typeof options.compatibilityProfile === 'string' ? options.compatibilityProfile.trim().toLowerCase() : '';
     if (compatibilityProfile === 'chat:deepseek-web') {
         return options.payload;
     }
-    const result = applyProviderOutboundPolicy(options.providerProtocol, options.payload);
+    const result = applyProviderOutboundPolicy(normalizedProviderProtocol, options.payload);
     if (!result.changed) {
         return options.payload;
     }
     try {
         options.stageRecorder?.record('hub_policy.enforce.provider_outbound', {
             requestId: options.requestId,
-            providerProtocol: options.providerProtocol,
+            providerProtocol: normalizedProviderProtocol,
             removedTopLevelKeys: result.removedTopLevelKeys,
             flattenedWrappers: result.flattenedWrappers
         });