@jsonstudio/llms 0.6.2172 → 0.6.2979

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

@@ -1,11 +1,8 @@
 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();
+import { applyRespProcessToolGovernanceWithNative, stripOrphanFunctionCallsTagWithNative } from '../../../../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
 const TOOL_CALL_JSON_MARKER = /["']tool_calls["']\s*:/i;
 const SHELL_TOOL_NAME_ALIASES = {
     shell_command: 'exec_command',
@@ -94,7 +91,7 @@ function maybeHarvestEmptyToolCallsFromJsonContent(payload) {
     return payload;
 }
 function sanitizeResponseShapeBeforeGovernance(payload) {
-    return stripOrphanFunctionCallsTag(payload);
+    return stripOrphanFunctionCallsTagWithNative(payload);
 }
 export async function runRespProcessStage1ToolGovernance(options) {
     const canonicalInput = coerceToCanonicalChatCompletion(options.payload);
@@ -110,12 +107,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,13 @@
-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';
 export async function runRespProcessStage2Finalize(options) {
-    const finalized = (await finalizeOpenAIChatResponse(options.payload, {
-        requestId: options.requestId,
-        endpoint: options.entryEndpoint,
+    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
         });

package/dist/conversion/hub/policy/protocol-spec.js

@@ -1,155 +1,27 @@
 import { ANTHROPIC_ALLOWED_FIELDS, ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS, GEMINI_ALLOWED_FIELDS, OPENAI_CHAT_ALLOWED_FIELDS, OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS, OPENAI_RESPONSES_ALLOWED_FIELDS, OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS } from '../../shared/protocol-field-allowlists.js';
-const RESPONSES_SPEC = {
-    id: 'openai-responses',
-    providerOutbound: {
-        enforceEnabled: true,
-        allowedTopLevelKeys: OPENAI_RESPONSES_ALLOWED_FIELDS,
-        enforceAllowedTopLevelKeys: true,
-        forbidWrappers: [
-            {
-                code: 'forbid_wrapper',
-                path: 'parameters',
-                detail: 'Responses provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
-            },
-            {
-                code: 'forbid_wrapper',
-                path: 'request',
-                detail: 'Responses provider payload must not contain a nested request wrapper.'
-            }
-        ],
-        reservedKeyPrefixes: ['__', '_'],
-        flattenWrappers: [
-            {
-                wrapperKey: 'request',
-                onlyIfTargetMissing: true
-            },
-            {
-                wrapperKey: 'parameters',
-                onlyIfTargetMissing: true,
-                aliasKeys: {
-                    max_tokens: 'max_output_tokens'
-                },
-                allowKeys: [...OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS]
-            }
-        ]
-    },
-    toolSurface: {
-        expectedToolFormat: 'openai',
-        expectedHistoryCarrier: 'input'
-    }
-};
-const DEFAULT_SPEC = {
-    id: 'openai-chat',
-    providerOutbound: {
-        enforceEnabled: true,
-        allowedTopLevelKeys: OPENAI_CHAT_ALLOWED_FIELDS,
-        enforceAllowedTopLevelKeys: true,
-        forbidWrappers: [
-            {
-                code: 'forbid_wrapper',
-                path: 'parameters',
-                detail: 'OpenAI Chat provider payload must not contain a top-level parameters wrapper (expects flattened fields).'
-            },
-            {
-                code: 'forbid_wrapper',
-                path: 'request',
-                detail: 'OpenAI Chat provider payload must not contain a nested request wrapper.'
-            }
-        ],
-        reservedKeyPrefixes: ['__', '_'],
-        flattenWrappers: [
-            {
-                wrapperKey: 'request',
-                onlyIfTargetMissing: true
-            },
-            {
-                wrapperKey: 'parameters',
-                onlyIfTargetMissing: true,
-                aliasKeys: {
-                    max_output_tokens: 'max_tokens'
-                },
-                allowKeys: [...OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS]
-            }
-        ]
-    },
-    toolSurface: {
-        expectedToolFormat: 'openai',
-        expectedHistoryCarrier: 'messages'
-    }
+import { resolveHubProtocolSpecWithNative } from '../../../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+const ALLOWLISTS = {
+    openaiChatAllowedFields: OPENAI_CHAT_ALLOWED_FIELDS,
+    openaiChatParametersWrapperAllowKeys: OPENAI_CHAT_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    openaiResponsesAllowedFields: OPENAI_RESPONSES_ALLOWED_FIELDS,
+    openaiResponsesParametersWrapperAllowKeys: OPENAI_RESPONSES_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    anthropicAllowedFields: ANTHROPIC_ALLOWED_FIELDS,
+    anthropicParametersWrapperAllowKeys: ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS,
+    geminiAllowedFields: GEMINI_ALLOWED_FIELDS
 };
+function buildSpec(protocol) {
+    return resolveHubProtocolSpecWithNative({
+        protocol,
+        allowlists: ALLOWLISTS
+    });
+}
 export const HUB_PROTOCOL_SPECS = {
-    'openai-chat': DEFAULT_SPEC,
-    'openai-responses': RESPONSES_SPEC,
-    'anthropic-messages': {
-        id: 'anthropic-messages',
-        providerOutbound: {
-            enforceEnabled: true,
-            allowedTopLevelKeys: ANTHROPIC_ALLOWED_FIELDS,
-            enforceAllowedTopLevelKeys: true,
-            forbidWrappers: [
-                {
-                    code: 'forbid_wrapper',
-                    path: 'parameters',
-                    detail: 'Anthropic Messages provider payload must not contain a top-level parameters wrapper.'
-                },
-                {
-                    code: 'forbid_wrapper',
-                    path: 'request',
-                    detail: 'Anthropic Messages provider payload must not contain a nested request wrapper.'
-                }
-            ],
-            reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: [
-                {
-                    wrapperKey: 'request',
-                    onlyIfTargetMissing: true
-                },
-                {
-                    wrapperKey: 'parameters',
-                    onlyIfTargetMissing: true,
-                    aliasKeys: {
-                        max_output_tokens: 'max_tokens'
-                    },
-                    allowKeys: [...ANTHROPIC_PARAMETERS_WRAPPER_ALLOW_KEYS]
-                }
-            ]
-        },
-        toolSurface: {
-            expectedToolFormat: 'anthropic'
-        }
-    },
-    'gemini-chat': {
-        id: 'gemini-chat',
-        providerOutbound: {
-            enforceEnabled: true,
-            allowedTopLevelKeys: GEMINI_ALLOWED_FIELDS,
-            enforceAllowedTopLevelKeys: true,
-            forbidWrappers: [
-                {
-                    code: 'forbid_wrapper',
-                    path: 'parameters',
-                    detail: 'Gemini provider payload must not contain a top-level parameters wrapper.'
-                },
-                {
-                    code: 'forbid_wrapper',
-                    path: 'request',
-                    detail: 'Gemini provider payload must not contain a nested request wrapper.'
-                }
-            ],
-            reservedKeyPrefixes: ['__', '_'],
-            flattenWrappers: [
-                {
-                    wrapperKey: 'request',
-                    onlyIfTargetMissing: true
-                }
-            ]
-        },
-        toolSurface: {
-            expectedToolFormat: 'gemini'
-        }
-    }
+    'openai-chat': buildSpec('openai-chat'),
+    'openai-responses': buildSpec('openai-responses'),
+    'anthropic-messages': buildSpec('anthropic-messages'),
+    'gemini-chat': buildSpec('gemini-chat')
 };
 export function resolveHubProtocolSpec(protocol) {
     const normalized = (protocol || '').trim().toLowerCase();
-    return HUB_PROTOCOL_SPECS[normalized] ?? DEFAULT_SPEC;
+    return HUB_PROTOCOL_SPECS[normalized] ?? HUB_PROTOCOL_SPECS['openai-chat'];
 }

package/dist/conversion/hub/process/chat-process-anthropic-alias.d.ts

@@ -0,0 +1,2 @@
+import type { StandardizedRequest } from '../types/standardized.js';
+export declare function applyAnthropicToolAliasSemantics(request: StandardizedRequest, entryEndpoint: string): StandardizedRequest;

package/dist/conversion/hub/process/chat-process-anthropic-alias.js

@@ -0,0 +1,36 @@
+import { isJsonObject } from '../types/json.js';
+import { buildAnthropicToolAliasMapWithNative } from '../../../router/virtual-router/engine-selection/native-chat-process-governance-semantics.js';
+export function applyAnthropicToolAliasSemantics(request, entryEndpoint) {
+    try {
+        const endpoint = typeof entryEndpoint === 'string' ? entryEndpoint.trim().toLowerCase() : '';
+        if (!endpoint.includes('/v1/messages')) {
+            return request;
+        }
+        request.semantics = asObjectRecord(request.semantics);
+        const semantics = request.semantics;
+        const semanticsTools = asObjectRecord(semantics.tools);
+        semantics.tools = semanticsTools;
+        const hasAlias = isJsonObject(semanticsTools.toolNameAliasMap) ||
+            isJsonObject(semanticsTools.toolAliasMap);
+        if (hasAlias) {
+            return request;
+        }
+        const sourceTools = Array.isArray(semanticsTools.clientToolsRaw) && semanticsTools.clientToolsRaw.length
+            ? semanticsTools.clientToolsRaw
+            : request.tools;
+        const aliasMap = buildAnthropicToolAliasMapWithNative(sourceTools);
+        if (aliasMap) {
+            semanticsTools.toolNameAliasMap = aliasMap;
+        }
+    }
+    catch {
+        // best-effort: alias-map propagation must never block request handling
+    }
+    return request;
+}
+function asObjectRecord(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    return {};
+}

package/dist/conversion/hub/process/chat-process-clock-directive-parser.d.ts

@@ -0,0 +1,5 @@
+import { type ClockScheduleDirectiveCandidate } from '../../../router/virtual-router/engine-selection/native-chat-process-clock-directive-parser.js';
+import type { ClockScheduleDirective } from './chat-process-clock-directives.js';
+export declare function hydrateClockScheduleDirectiveCandidate(candidate: ClockScheduleDirectiveCandidate): ClockScheduleDirective | null;
+export declare function parseClockScheduleDirectiveCandidatePayload(payload: string): ClockScheduleDirectiveCandidate | null;
+export declare function parseClockScheduleDirectivePayload(payload: string): ClockScheduleDirective | null;