@jsonstudio/llms 0.6.2172 → 0.6.2979

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/tool-output-snapshot.d.ts

@@ -0,0 +1,10 @@
+import type { JsonObject } from '../../../../types/json.js';
+type ToolOutputItem = {
+    tool_call_id: string;
+    call_id: string;
+    output?: string;
+    name?: string;
+};
+export declare function buildToolOutputSnapshot(payload: JsonObject, providerProtocol?: string): Record<string, unknown>;
+export declare function collectToolOutputs(payload: JsonObject): ToolOutputItem[];
+export {};

package/dist/conversion/hub/pipeline/stages/req_inbound/req_inbound_stage3_context_capture/tool-output-snapshot.js

@@ -0,0 +1,12 @@
+import { buildReqInboundToolOutputSnapshotWithNative, collectReqInboundToolOutputsWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+export function buildToolOutputSnapshot(payload, providerProtocol) {
+    return buildReqInboundToolOutputSnapshotWithNative(payload, providerProtocol);
+}
+export function collectToolOutputs(payload) {
+    return collectReqInboundToolOutputsWithNative(payload).map((entry) => ({
+        tool_call_id: entry.tool_call_id,
+        call_id: entry.call_id,
+        ...(typeof entry.output === 'string' ? { output: entry.output } : {}),
+        ...(typeof entry.name === 'string' ? { name: entry.name } : {})
+    }));
+}

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/context-merge.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterContext, ChatEnvelope } from '../../../../types/chat-envelope.js';
+export declare function applyToolCallIdStyleMetadata(chatEnvelope: ChatEnvelope, adapterContext: AdapterContext, snapshot?: Record<string, unknown>): void;
+export declare function applyContextSnapshotToChatEnvelope(chatEnvelope: ChatEnvelope, snapshot: Record<string, unknown>): void;

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/context-merge.js

@@ -0,0 +1,30 @@
+import { selectToolCallIdStyleWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-inbound-outbound-semantics.js';
+import { applyReqOutboundContextSnapshotWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+export function applyToolCallIdStyleMetadata(chatEnvelope, adapterContext, snapshot) {
+    const metadata = chatEnvelope.metadata || (chatEnvelope.metadata = { context: adapterContext });
+    const current = typeof metadata.toolCallIdStyle === 'string'
+        ? String(metadata.toolCallIdStyle).trim()
+        : '';
+    const resolved = selectToolCallIdStyleWithNative(adapterContext, snapshot ?? {}, current || undefined);
+    if (!resolved) {
+        return;
+    }
+    // Always honor the route-selected AdapterContext toolCallIdStyle when present.
+    // This prevents cross-provider leakage (e.g. LM Studio "preserve" contaminating OpenAI "fc").
+    if (!current || current !== resolved) {
+        metadata.toolCallIdStyle = resolved;
+    }
+}
+export function applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot) {
+    const hasExistingTools = Array.isArray(chatEnvelope.tools) && chatEnvelope.tools.length > 0;
+    const patch = applyReqOutboundContextSnapshotWithNative({
+        chatEnvelope: chatEnvelope,
+        snapshot
+    });
+    if (Array.isArray(patch.toolOutputs) && patch.toolOutputs.length) {
+        chatEnvelope.toolOutputs = patch.toolOutputs;
+    }
+    if (!hasExistingTools && Array.isArray(patch.tools) && patch.tools.length) {
+        chatEnvelope.tools = patch.tools;
+    }
+}

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage1_semantic_map/index.js

@@ -1,19 +1,21 @@
-import { standardizedToChatEnvelope } from '../../../../standardized-bridge.js';
-import { validateChatEnvelope } from '../../../../../shared/chat-envelope-validator.js';
 import { applyHubOperationTableOutboundPostMap, applyHubOperationTableOutboundPreMap } from '../../../../operation-table/operation-table-runner.js';
 import { recordStage } from '../../../stages/utils.js';
+import { applyContextSnapshotToChatEnvelope, applyToolCallIdStyleMetadata } from './context-merge.js';
+import { shouldAttachReqOutboundContextSnapshotWithNative, standardizedToChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+import { validateChatEnvelopeWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
 export async function runReqOutboundStage1SemanticMap(options) {
-    const chatEnvelope = standardizedToChatEnvelope(options.request, {
+    const chatEnvelope = standardizedToChatEnvelopeWithNative({
+        request: options.request,
         adapterContext: options.adapterContext
     });
     applyToolCallIdStyleMetadata(chatEnvelope, options.adapterContext, options.contextSnapshot);
-    if (options.contextSnapshot && options.contextMetadataKey) {
+    const shouldAttachContextSnapshot = shouldAttachReqOutboundContextSnapshotWithNative(Boolean(options.contextSnapshot), options.contextMetadataKey);
+    if (shouldAttachContextSnapshot && options.contextSnapshot && options.contextMetadataKey) {
         const snapshot = options.contextSnapshot;
         chatEnvelope.metadata[options.contextMetadataKey] = snapshot;
-        attachToolOutputsFromContext(chatEnvelope, snapshot);
-        attachToolsFromContext(chatEnvelope, snapshot);
+        applyContextSnapshotToChatEnvelope(chatEnvelope, snapshot);
     }
-    validateChatEnvelope(chatEnvelope, {
+    validateChatEnvelopeWithNative(chatEnvelope, {
         stage: 'req_outbound',
         direction: 'request'
     });
@@ -31,125 +33,3 @@ export async function runReqOutboundStage1SemanticMap(options) {
     recordStage(options.stageRecorder, 'chat_process.req.stage6.outbound.semantic_map', chatEnvelope);
     return { chatEnvelope, formatEnvelope };
 }
-function attachToolOutputsFromContext(chatEnvelope, snapshot) {
-    const outputsRaw = snapshot?.tool_outputs;
-    if (!Array.isArray(outputsRaw) || !outputsRaw.length) {
-        return;
-    }
-    const normalized = outputsRaw
-        .map((entry) => normalizeToolOutput(entry))
-        .filter((entry) => Boolean(entry));
-    if (!normalized.length) {
-        return;
-    }
-    const existing = Array.isArray(chatEnvelope.toolOutputs) ? chatEnvelope.toolOutputs.slice() : [];
-    const known = new Set(existing.map((entry) => entry.tool_call_id).filter(Boolean));
-    for (const entry of normalized) {
-        if (entry.tool_call_id && !known.has(entry.tool_call_id)) {
-            existing.push(entry);
-            known.add(entry.tool_call_id);
-        }
-    }
-    if (existing.length) {
-        chatEnvelope.toolOutputs = existing;
-    }
-}
-function attachToolsFromContext(chatEnvelope, snapshot) {
-    if (Array.isArray(chatEnvelope.tools) && chatEnvelope.tools.length) {
-        return;
-    }
-    const normalized = snapshot?.toolsNormalized ?? snapshot?.tools;
-    if (!Array.isArray(normalized) || !normalized.length) {
-        return;
-    }
-    const tools = normalized
-        .map((entry) => normalizeToolDefinition(entry))
-        .filter((entry) => Boolean(entry));
-    if (tools.length) {
-        chatEnvelope.tools = tools;
-    }
-}
-function normalizeToolDefinition(entry) {
-    if (!entry || typeof entry !== 'object') {
-        return undefined;
-    }
-    const record = entry;
-    if (record.type !== 'function') {
-        return undefined;
-    }
-    const fn = record.function;
-    if (!fn || typeof fn !== 'object') {
-        return undefined;
-    }
-    const fnRecord = fn;
-    const name = typeof fnRecord.name === 'string' && fnRecord.name.trim().length ? fnRecord.name.trim() : undefined;
-    if (!name) {
-        return undefined;
-    }
-    return {
-        type: 'function',
-        function: {
-            name,
-            description: typeof fnRecord.description === 'string' ? fnRecord.description : undefined,
-            parameters: (fnRecord.parameters ?? { type: 'object', properties: {} }),
-            strict: typeof fnRecord.strict === 'boolean' ? fnRecord.strict : undefined
-        }
-    };
-}
-function normalizeToolOutput(entry) {
-    if (!entry || typeof entry !== 'object') {
-        return undefined;
-    }
-    const record = entry;
-    const toolCallId = typeof record.tool_call_id === 'string' && record.tool_call_id.trim().length
-        ? record.tool_call_id.trim()
-        : typeof record.call_id === 'string' && record.call_id.trim().length
-            ? record.call_id.trim()
-            : undefined;
-    if (!toolCallId) {
-        return undefined;
-    }
-    let content = '';
-    const rawOutput = 'output' in record ? record.output : record.content;
-    if (typeof rawOutput === 'string') {
-        content = rawOutput;
-    }
-    else if (rawOutput !== undefined) {
-        try {
-            content = JSON.stringify(rawOutput);
-        }
-        catch {
-            content = String(rawOutput);
-        }
-    }
-    const name = typeof record.name === 'string' && record.name.trim().length ? record.name.trim() : undefined;
-    return {
-        tool_call_id: toolCallId,
-        content,
-        name
-    };
-}
-function applyToolCallIdStyleMetadata(chatEnvelope, adapterContext, snapshot) {
-    const metadata = chatEnvelope.metadata || (chatEnvelope.metadata = { context: adapterContext });
-    const current = typeof metadata.toolCallIdStyle === 'string'
-        ? String(metadata.toolCallIdStyle).trim()
-        : '';
-    const resolved = selectToolCallIdStyle(adapterContext, snapshot);
-    if (!resolved) {
-        return;
-    }
-    // Always honor the route-selected AdapterContext toolCallIdStyle when present.
-    // This prevents cross-provider leakage (e.g. LM Studio "preserve" contaminating OpenAI "fc").
-    if (!current || current !== resolved) {
-        metadata.toolCallIdStyle = resolved;
-    }
-}
-function selectToolCallIdStyle(adapterContext, snapshot) {
-    if (adapterContext && typeof adapterContext.toolCallIdStyle === 'string' && adapterContext.toolCallIdStyle.trim().length) {
-        return adapterContext.toolCallIdStyle;
-    }
-    if (snapshot && typeof snapshot.toolCallIdStyle === 'string' && snapshot.toolCallIdStyle.trim().length) {
-        return String(snapshot.toolCallIdStyle);
-    }
-    return undefined;
-}

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.d.ts

@@ -1,11 +1,8 @@
-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 ReqOutboundStage2FormatBuildOptions {
     formatEnvelope: FormatEnvelope<JsonObject>;
-    adapterContext: AdapterContext;
-    formatAdapter: Pick<FormatAdapter, 'buildRequest'>;
     stageRecorder?: StageRecorder;
 }
 export declare function runReqOutboundStage2FormatBuild(options: ReqOutboundStage2FormatBuildOptions): Promise<JsonObject>;

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage2_format_build/index.js

@@ -1,29 +1,12 @@
 import { recordStage } from '../../../stages/utils.js';
-const PRIVATE_FIELD_PREFIX = '__rcc_';
+import { stripPrivateFieldsWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { buildReqOutboundFormatPayloadWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
 export async function runReqOutboundStage2FormatBuild(options) {
-    const payload = (await options.formatAdapter.buildRequest(options.formatEnvelope, options.adapterContext));
-    stripPrivateFields(payload);
-    recordStage(options.stageRecorder, 'chat_process.req.stage7.outbound.format_build', payload);
-    return payload;
-}
-function stripPrivateFields(value) {
-    if (!value) {
-        return;
-    }
-    if (Array.isArray(value)) {
-        value.forEach((entry) => stripPrivateFields(entry));
-        return;
-    }
-    if (typeof value !== 'object') {
-        return;
-    }
-    const record = value;
-    for (const key of Object.keys(record)) {
-        const child = record[key];
-        if (typeof key === 'string' && key.startsWith(PRIVATE_FIELD_PREFIX)) {
-            delete record[key];
-            continue;
-        }
-        stripPrivateFields(child);
-    }
+    const payload = buildReqOutboundFormatPayloadWithNative({
+        formatEnvelope: options.formatEnvelope,
+        protocol: options.formatEnvelope.protocol
+    });
+    const stripped = stripPrivateFieldsWithNative(payload);
+    recordStage(options.stageRecorder, 'chat_process.req.stage7.outbound.format_build', stripped);
+    return stripped;
 }

package/dist/conversion/hub/pipeline/stages/req_outbound/req_outbound_stage3_compat/index.js

@@ -1,27 +1,45 @@
-import { applyRequestCompat, applyResponseCompat } from '../../../compat/compat-engine.js';
-import { resolveCompatProfileForContext } from '../../../compat/compat-profile-resolver.js';
+import { buildNativeReqOutboundCompatAdapterContext } from '../../../compat/native-adapter-context.js';
+import { resolveCompatProfileWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-edge-stage-semantics.js';
+import { runReqOutboundStage3CompatWithNative, runRespInboundStage3CompatWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+const RATE_LIMIT_ERROR = 'ERR_COMPAT_RATE_LIMIT_DETECTED';
 function pickCompatProfile(adapterContext) {
     const candidate = adapterContext.compatibilityProfile;
-    if (typeof candidate === 'string' && candidate.trim()) {
-        return candidate.trim();
-    }
-    return resolveCompatProfileForContext(adapterContext);
+    const explicit = typeof candidate === 'string' && candidate.trim() ? candidate.trim() : undefined;
+    return resolveCompatProfileWithNative(adapterContext, explicit);
 }
 export async function runReqOutboundStage3Compat(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyRequestCompat(profile, options.payload, { adapterContext: options.adapterContext });
+    const nativeCompat = runReqOutboundStage3CompatWithNative({
+        payload: options.payload,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options.adapterContext),
+        explicitProfile: profile
+    });
+    const effectiveProfile = nativeCompat.appliedProfile ?? profile;
+    const appliedProfile = nativeCompat.appliedProfile;
     options.stageRecorder?.record('chat_process.req.stage8.outbound.compat', {
-        applied: Boolean(result.appliedProfile),
-        profile: result.appliedProfile || profile || 'passthrough'
+        applied: Boolean(appliedProfile),
+        profile: appliedProfile || effectiveProfile || 'passthrough'
     });
-    return result.payload;
+    return nativeCompat.payload;
 }
 export function runRespInboundStageCompatResponse(options) {
     const profile = pickCompatProfile(options.adapterContext);
-    const result = applyResponseCompat(profile, options.payload, { adapterContext: options.adapterContext });
+    const nativeCompat = runRespInboundStage3CompatWithNative({
+        payload: options.payload,
+        adapterContext: buildNativeReqOutboundCompatAdapterContext(options.adapterContext),
+        explicitProfile: profile
+    });
+    const effectiveProfile = nativeCompat.appliedProfile ?? profile;
+    const appliedProfile = nativeCompat.appliedProfile;
+    if (nativeCompat.nativeApplied === true && nativeCompat.rateLimitDetected === true) {
+        const err = new Error('Provider returned rate limit notice');
+        err.code = RATE_LIMIT_ERROR;
+        err.statusCode = 429;
+        throw err;
+    }
     options.stageRecorder?.record('chat_process.resp.stage3.compat', {
-        applied: Boolean(result.appliedProfile),
-        profile: result.appliedProfile || profile || 'passthrough'
+        applied: Boolean(appliedProfile),
+        profile: appliedProfile || effectiveProfile || 'passthrough'
     });
-    return result.payload;
+    return nativeCompat.payload;
 }

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.d.ts

@@ -1,6 +1,6 @@
 import type { StageRecorder } from '../../../../format-adapters/index.js';
 import type { ProcessedRequest, StandardizedRequest } from '../../../../types/standardized.js';
-import { runHubChatProcess } from '../../../../process/chat-process.js';
+import type { HubProcessNodeResult } from '../../../../process/chat-process.js';
 export interface ReqProcessStage1ToolGovernanceOptions {
     request: StandardizedRequest;
     rawPayload: Record<string, unknown>;
@@ -11,6 +11,6 @@ export interface ReqProcessStage1ToolGovernanceOptions {
 }
 export interface ReqProcessStage1ToolGovernanceResult {
     processedRequest?: ProcessedRequest;
-    nodeResult?: Awaited<ReturnType<typeof runHubChatProcess>>['nodeResult'];
+    nodeResult?: HubProcessNodeResult;
 }
 export declare function runReqProcessStage1ToolGovernance(options: ReqProcessStage1ToolGovernanceOptions): Promise<ReqProcessStage1ToolGovernanceResult>;

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage1_tool_governance/index.js

@@ -1,19 +1,59 @@
-import { runHubChatProcess } from '../../../../process/chat-process.js';
 import { recordStage } from '../../../stages/utils.js';
 import { captureApplyPatchExecutionFailuresFromProcessedRequest } from '../../../../../../tools/apply-patch/execution-capturer.js';
+import { applyReqProcessToolGovernanceWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
+import { maybeInjectClockRemindersAndApplyDirectives } from '../../../../process/chat-process-clock-reminders.js';
+function isRecord(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function parseProcessedRequest(value) {
+    if (!isRecord(value)) {
+        throw new Error('native req_process_stage1_tool_governance returned invalid processedRequest');
+    }
+    if (typeof value.model !== 'string' || !Array.isArray(value.messages) || !isRecord(value.parameters) || !isRecord(value.metadata)) {
+        throw new Error('native req_process_stage1_tool_governance returned malformed processedRequest envelope');
+    }
+    if (!isRecord(value.processed) || !isRecord(value.processingMetadata)) {
+        throw new Error('native req_process_stage1_tool_governance missing processed/processingMetadata');
+    }
+    return value;
+}
+function parseNodeResult(value) {
+    if (!isRecord(value) || typeof value.success !== 'boolean' || !isRecord(value.metadata)) {
+        throw new Error('native req_process_stage1_tool_governance returned invalid nodeResult');
+    }
+    const errorValue = value.error;
+    if (errorValue !== undefined && (!isRecord(errorValue) || typeof errorValue.message !== 'string')) {
+        throw new Error('native req_process_stage1_tool_governance returned invalid nodeResult.error');
+    }
+    return value;
+}
 export async function runReqProcessStage1ToolGovernance(options) {
-    const result = await runHubChatProcess({
+    const nativeResult = applyReqProcessToolGovernanceWithNative({
         request: options.request,
         rawPayload: options.rawPayload,
         metadata: options.metadata,
         entryEndpoint: options.entryEndpoint,
         requestId: options.requestId
     });
-    if (result.processedRequest) {
-        recordStage(options.stageRecorder, 'chat_process.req.stage4.tool_governance', result.processedRequest);
-        // Best-effort: capture apply_patch execution failures reported by tool role messages.
-        // This is for errorsamples collection only and must not affect runtime behavior.
-        captureApplyPatchExecutionFailuresFromProcessedRequest(result.processedRequest);
+    let processedRequest = parseProcessedRequest(nativeResult.processedRequest);
+    const nodeResult = parseNodeResult(nativeResult.nodeResult);
+    processedRequest = await maybeInjectClockRemindersAndApplyDirectives(processedRequest, options.metadata, options.requestId);
+    const nodeResultMetadata = nodeResult.metadata && typeof nodeResult.metadata === 'object'
+        ? nodeResult.metadata
+        : null;
+    const dataProcessed = nodeResultMetadata?.dataProcessed && typeof nodeResultMetadata.dataProcessed === 'object'
+        ? nodeResultMetadata.dataProcessed
+        : null;
+    if (dataProcessed) {
+        dataProcessed.messages = Array.isArray(processedRequest.messages) ? processedRequest.messages.length : 0;
+        dataProcessed.tools = Array.isArray(processedRequest.tools) ? processedRequest.tools.length : 0;
     }
-    return result;
+    recordStage(options.stageRecorder, 'chat_process.req.stage4.tool_governance', processedRequest);
+    // Best-effort: capture apply_patch execution failures reported by tool role messages.
+    // This is for errorsamples collection only and must not affect runtime behavior.
+    captureApplyPatchExecutionFailuresFromProcessedRequest(processedRequest);
+    return {
+        processedRequest,
+        nodeResult
+    };
 }

package/dist/conversion/hub/pipeline/stages/req_process/req_process_stage2_route_select/index.js

@@ -1,10 +1,25 @@
 import { recordStage } from '../../../stages/utils.js';
-import { applyTargetMetadata, applyTargetToSubject } from '../../../target-utils.js';
+import { applyReqProcessRouteSelectionWithNative } from '../../../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-process-semantics.js';
+function replaceRecordInPlace(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 runReqProcessStage2RouteSelect(options) {
     const previousModel = typeof options.request.model === 'string' ? options.request.model : undefined;
     const result = options.routerEngine.route(options.request, options.metadataInput);
-    applyTargetMetadata(options.normalizedMetadata, result.target, result.decision.routeName, previousModel);
-    applyTargetToSubject(options.request, result.target, previousModel);
+    const nativeApplied = applyReqProcessRouteSelectionWithNative({
+        request: options.request,
+        normalizedMetadata: options.normalizedMetadata,
+        target: result.target,
+        routeName: result.decision.routeName,
+        originalModel: previousModel
+    });
+    replaceRecordInPlace(options.request, nativeApplied.request);
+    replaceRecordInPlace(options.normalizedMetadata, nativeApplied.normalizedMetadata);
     recordStage(options.stageRecorder, 'chat_process.req.stage5.route_select', {
         target: result.target,
         decision: result.decision,