@jsonstudio/llms 0.6.3214 → 0.6.3271

package/dist/router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js

@@ -68,6 +68,40 @@ function parseBridgeHistoryOutput(raw) {
         return null;
     }
 }
+function parseBridgeActionState(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (!Array.isArray(row.messages)) {
+            return null;
+        }
+        const output = {
+            messages: row.messages
+        };
+        if (row.requiredAction && typeof row.requiredAction === 'object' && !Array.isArray(row.requiredAction)) {
+            output.requiredAction = row.requiredAction;
+        }
+        if (Array.isArray(row.capturedToolResults)) {
+            output.capturedToolResults = row.capturedToolResults.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+        }
+        if (row.rawRequest && typeof row.rawRequest === 'object' && !Array.isArray(row.rawRequest)) {
+            output.rawRequest = row.rawRequest;
+        }
+        if (row.rawResponse && typeof row.rawResponse === 'object' && !Array.isArray(row.rawResponse)) {
+            output.rawResponse = row.rawResponse;
+        }
+        if (row.metadata && typeof row.metadata === 'object' && !Array.isArray(row.metadata)) {
+            output.metadata = row.metadata;
+        }
+        return output;
+    }
+    catch {
+        return null;
+    }
+}
 function parseApplyBridgeNormalizeHistoryOutput(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -673,6 +707,43 @@ export function applyBridgeEnsureSystemInstructionWithNative(input) {
         return fail(reason);
     }
 }
+export function runBridgeActionPipelineWithNative(input) {
+    const capability = 'runBridgeActionPipelineJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        stage: input.stage,
+        actions: input.actions,
+        protocol: input.protocol,
+        moduleType: input.moduleType,
+        requestId: input.requestId,
+        state: input.state
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseBridgeActionState(raw);
+        if (!parsed) {
+            return null;
+        }
+        return parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function normalizeMessageReasoningToolsWithNative(message, idPrefix) {
     const capability = 'normalizeMessageReasoningToolsJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.d.ts

@@ -20,3 +20,11 @@ export declare function governRequestWithNative(input: {
     request: Record<string, unknown>;
     summary: Record<string, unknown>;
 };
+export declare function governResponseWithNative(input: {
+    payload: Record<string, unknown>;
+    protocol?: string;
+    registry?: NativeToolGovernanceRegistry;
+}): {
+    payload: Record<string, unknown>;
+    summary: Record<string, unknown>;
+};

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-governance-semantics.js

@@ -152,3 +152,51 @@ export function governRequestWithNative(input) {
         return fail(reason);
     }
 }
+export function governResponseWithNative(input) {
+    const capability = 'governToolNameResponseJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const normalizedInput = {
+        ...input,
+        registry: normalizeRegistryForNative(input.registry)
+    };
+    const inputJson = safeStringify(normalizedInput);
+    if (!inputJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(inputJson);
+        const errorReason = readNativeErrorReason(raw);
+        if (errorReason) {
+            return fail(errorReason);
+        }
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return fail('invalid payload');
+        }
+        const row = parsed;
+        if (!row.payload || typeof row.payload !== 'object' || Array.isArray(row.payload)) {
+            return fail('invalid response payload');
+        }
+        if (!row.summary || typeof row.summary !== 'object' || Array.isArray(row.summary)) {
+            return fail('invalid summary payload');
+        }
+        return {
+            payload: row.payload,
+            summary: row.summary
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.d.ts

@@ -29,6 +29,7 @@ export declare function resolveReqInboundServerToolFollowupSnapshotWithNative(ad
 export declare function augmentReqInboundContextSnapshotWithNative(context: Record<string, unknown>, fallbackSnapshot: Record<string, unknown>): Record<string, unknown>;
 export declare function normalizeReqInboundToolCallIdStyleWithNative(value: unknown): 'fc' | 'preserve' | undefined;
 export declare function mapReqInboundBridgeToolsToChatWithNative(rawTools: unknown): Array<Record<string, unknown>>;
+export declare function mapChatToolsToBridgeWithNative(rawTools: unknown): Array<Record<string, unknown>>;
 export declare function captureReqInboundResponsesContextSnapshotWithNative(input: {
     rawRequest: Record<string, unknown>;
     requestId?: string;

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js

@@ -339,6 +339,36 @@ export function mapReqInboundBridgeToolsToChatWithNative(rawTools) {
         return fail(reason);
     }
 }
+export function mapChatToolsToBridgeWithNative(rawTools) {
+    const capability = 'mapChatToolsToBridgeJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(Array.isArray(rawTools) ? rawTools : []);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseArray(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        return parsed.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function captureReqInboundResponsesContextSnapshotWithNative(input) {
     const capability = 'captureReqInboundResponsesContextSnapshotJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.d.ts

@@ -0,0 +1,2 @@
+export declare function mapOpenaiChatToChatWithNative(payload: Record<string, unknown> | null | undefined, adapterContext: Record<string, unknown> | null | undefined): Record<string, unknown>;
+export declare function mapOpenaiChatFromChatWithNative(chatEnvelope: Record<string, unknown> | null | undefined, adapterContext: Record<string, unknown> | null | undefined): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.js

@@ -0,0 +1,83 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function readNativeFunction(name) {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.[name];
+    return typeof fn === 'function' ? fn : null;
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseRecord(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function mapOpenaiChatToChatWithNative(payload, adapterContext) {
+    const capability = 'mapOpenaiChatToChatJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? {});
+    const contextJson = safeStringify(adapterContext ?? {});
+    if (!payloadJson || !contextJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson, contextJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function mapOpenaiChatFromChatWithNative(chatEnvelope, adapterContext) {
+    const capability = 'mapOpenaiChatFromChatJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const chatJson = safeStringify(chatEnvelope ?? {});
+    const contextJson = safeStringify(adapterContext ?? {});
+    if (!chatJson || !contextJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(chatJson, contextJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-router-hotpath-loader.js

@@ -29,6 +29,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'augmentContextSnapshotJson',
     'annotatePassthroughGovernanceSkipJson',
     'buildAnthropicToolAliasMapJson',
+    'buildAnthropicResponseFromChatJson',
     'buildChatNodeResultMetadataJson',
     'buildProcessedRequestFromChatResponseJson',
     'applyChatProcessedRequestJson',
@@ -63,6 +64,9 @@ const REQUIRED_NATIVE_EXPORTS = [
     'collectToolOutputsJson',
     'buildReqInboundToolOutputSnapshotJson',
     'mapBridgeToolsToChatJson',
+    'mapOpenaiChatToChatJson',
+    'mapOpenaiChatFromChatJson',
+    'mapChatToolsToBridgeJson',
     'captureReqInboundResponsesContextSnapshotJson',
     'computeQuotaBucketsJson',
     'deserializeStopMessageStateJson',
@@ -103,11 +107,15 @@ const REQUIRED_NATIVE_EXPORTS = [
     'enforceChatBudgetJson',
     'resolveBudgetForModelJson',
     'finalizeGovernedRequestJson',
+    'governResponseJson',
+    'governToolNameResponseJson',
     'findLastUserMessageIndexJson',
     'injectContinueExecutionDirectiveJson',
     'injectTimeTagIntoMessagesJson',
     'injectMcpToolsForChatJson',
     'injectMcpToolsForResponsesJson',
+    'mapOpenaiChatToChatJson',
+    'mapOpenaiChatFromChatJson',
     'isStopMessageStateActiveJson',
     'isContextLengthExceededSignalJson',
     'isCompactionRequestJson',
@@ -137,6 +145,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'normalizeToolSessionMessagesJson',
     'updateToolSessionHistoryJson',
     'normalizeContextCaptureLabelJson',
+    'normalizeSnapshotStagePayloadJson',
     'normalizeContextToolsJson',
     'normalizeDueInjectTextJson',
     'normalizeProviderProtocolTokenJson',
@@ -202,9 +211,11 @@ const REQUIRED_NATIVE_EXPORTS = [
     'resolveSseStreamModeJson',
     'resolveSseProtocolFromMetadataJson',
     'repairArgumentsToStringJsonishJson',
+    'runBridgeActionPipelineJson',
     'sanitizeChatCompletionLikeJson',
     'sanitizeFormatEnvelopeJson',
     'sanitizeReasoningTaggedTextJson',
+    'ensureBridgeInstructionsJson',
     'sanitizeResponsesFunctionNameJson',
     'shouldRecordSnapshotsJson',
     'writeSnapshotViaHooksJson',

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.d.ts

@@ -4,7 +4,9 @@ export declare function extractToolCallsFromReasoningTextWithNative(text: string
     cleanedText: string;
     toolCalls: Array<Record<string, unknown>>;
 };
+export declare function mapChatToolsToBridgeWithNative(rawTools: unknown): Array<Record<string, unknown>>;
 export declare function sanitizeReasoningTaggedTextWithNative(text: string): string;
+export declare function ensureBridgeInstructionsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
 export declare function deriveToolCallKeyWithNative(call: Record<string, unknown> | null | undefined): string | null;
 export declare function buildProviderProtocolErrorWithNative(input: {
     message: string;

package/dist/router/virtual-router/engine-selection/native-shared-conversion-semantics.js

@@ -80,6 +80,10 @@ function parseToolCallLiteArray(raw) {
     }
     return out;
 }
+function parseArray(raw) {
+    const parsed = parseJson(raw);
+    return Array.isArray(parsed) ? parsed : null;
+}
 export function parseLenientJsonishWithNative(value) {
     const capability = 'parseLenientJsonishJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -156,6 +160,36 @@ export function extractToolCallsFromReasoningTextWithNative(text, idPrefix) {
         return fail(reason);
     }
 }
+export function mapChatToolsToBridgeWithNative(rawTools) {
+    const capability = 'mapChatToolsToBridgeJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(Array.isArray(rawTools) ? rawTools : []);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseArray(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        return parsed.filter((entry) => !!entry && typeof entry === 'object' && !Array.isArray(entry));
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function sanitizeReasoningTaggedTextWithNative(text) {
     const capability = 'sanitizeReasoningTaggedTextJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -178,6 +212,33 @@ export function sanitizeReasoningTaggedTextWithNative(text) {
         return fail(reason);
     }
 }
+export function ensureBridgeInstructionsWithNative(payload) {
+    const capability = 'ensureBridgeInstructionsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? {});
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function deriveToolCallKeyWithNative(call) {
     const capability = 'deriveToolCallKeyJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-snapshot-hooks.d.ts

@@ -1,2 +1,3 @@
 export declare function shouldRecordSnapshotsWithNative(): boolean;
 export declare function writeSnapshotViaHooksWithNative(options: Record<string, unknown>): void;
+export declare function normalizeSnapshotStagePayloadWithNative(stage: string, payload: unknown): unknown;

package/dist/router/virtual-router/engine-selection/native-snapshot-hooks.js

@@ -22,6 +22,14 @@ function parseBoolean(raw) {
         return null;
     }
 }
+function parseJsonValue(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
 export function shouldRecordSnapshotsWithNative() {
     const capability = 'shouldRecordSnapshotsJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -67,3 +75,35 @@ export function writeSnapshotViaHooksWithNative(options) {
         return fail(reason);
     }
 }
+export function normalizeSnapshotStagePayloadWithNative(stage, payload) {
+    if (payload === undefined || payload === null) {
+        return null;
+    }
+    const capability = 'normalizeSnapshotStagePayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload);
+    if (!payloadJson) {
+        // Preserve non-JSON payloads (e.g. circular structures).
+        return payload;
+    }
+    const stageToken = typeof stage === 'string' ? stage : '';
+    try {
+        const raw = fn(stageToken, payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseJsonValue(raw);
+        return parsed === null ? fail('invalid payload') : parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine.js

@@ -6,6 +6,8 @@ import { cleanRoutingInstructionMarkersWithNative, parseRoutingInstructionKindsW
 import { getLatestUserTextFromResponsesContext, hasLatestUserRoutingInstructionMarker, hasRoutingInstructionMarkerInResponsesContext } from './engine-legacy/helpers.js';
 import { ProviderRegistry } from './provider-registry.js';
 import { resolveStopMessageScope } from './engine/routing-state/store.js';
+import { loadRoutingInstructionStateSync } from './sticky-session-store.js';
+import { mergeStopMessageFromPersisted } from './stop-message-state-sync.js';
 export class VirtualRouterEngine {
     nativeProxy;
     registry;
@@ -80,7 +82,9 @@ export class VirtualRouterEngine {
     }
     getStopMessageState(metadata) {
         const raw = this.nativeProxy.getStopMessageState(JSON.stringify(metadata));
-        return JSON.parse(raw);
+        const snapshot = JSON.parse(raw);
+        const scope = resolveStopMessageScope(metadata);
+        return mergeStopMessageSnapshotWithPersisted(snapshot, scope);
     }
     getPreCommandState(metadata) {
         const raw = this.nativeProxy.getPreCommandState(JSON.stringify(metadata));
@@ -114,6 +118,59 @@ function normalizeNativeVirtualRouterError(error) {
     }
     return error instanceof Error ? error : new Error(message || 'Virtual router error');
 }
+function mergeStopMessageSnapshotWithPersisted(snapshot, scope) {
+    if (!scope) {
+        return snapshot;
+    }
+    let persisted = null;
+    try {
+        persisted = loadRoutingInstructionStateSync(scope);
+    }
+    catch {
+        return snapshot;
+    }
+    if (!persisted) {
+        return snapshot;
+    }
+    const persistedText = typeof persisted.stopMessageText === 'string' ? persisted.stopMessageText.trim() : '';
+    if (!snapshot && !persistedText) {
+        return snapshot;
+    }
+    const existing = {
+        stopMessageSource: snapshot?.stopMessageSource,
+        stopMessageText: snapshot?.stopMessageText,
+        stopMessageMaxRepeats: snapshot?.stopMessageMaxRepeats,
+        stopMessageUsed: snapshot?.stopMessageUsed,
+        stopMessageUpdatedAt: snapshot?.stopMessageUpdatedAt,
+        stopMessageLastUsedAt: snapshot?.stopMessageLastUsedAt,
+        stopMessageStageMode: snapshot?.stopMessageStageMode,
+        stopMessageAiMode: snapshot?.stopMessageAiMode,
+        stopMessageAiSeedPrompt: snapshot?.stopMessageAiSeedPrompt,
+        stopMessageAiHistory: snapshot?.stopMessageAiHistory
+    };
+    const merged = mergeStopMessageFromPersisted(existing, persisted);
+    const base = snapshot ?? {
+        stopMessageMaxRepeats: typeof merged.stopMessageMaxRepeats === 'number' && Number.isFinite(merged.stopMessageMaxRepeats)
+            ? merged.stopMessageMaxRepeats
+            : 0
+    };
+    const mergedMaxRepeats = typeof merged.stopMessageMaxRepeats === 'number' && Number.isFinite(merged.stopMessageMaxRepeats)
+        ? merged.stopMessageMaxRepeats
+        : base.stopMessageMaxRepeats;
+    return {
+        ...base,
+        stopMessageSource: merged.stopMessageSource,
+        stopMessageText: merged.stopMessageText,
+        stopMessageMaxRepeats: mergedMaxRepeats,
+        stopMessageUsed: merged.stopMessageUsed,
+        stopMessageUpdatedAt: merged.stopMessageUpdatedAt,
+        stopMessageLastUsedAt: merged.stopMessageLastUsedAt,
+        stopMessageStageMode: merged.stopMessageStageMode,
+        stopMessageAiMode: merged.stopMessageAiMode,
+        stopMessageAiSeedPrompt: merged.stopMessageAiSeedPrompt,
+        stopMessageAiHistory: merged.stopMessageAiHistory
+    };
+}
 function extractNativeErrorMessage(error) {
     if (typeof error === 'string') {
         return error;

package/dist/router/virtual-router/types.d.ts

@@ -46,7 +46,7 @@ export interface ProviderAuthConfig {
 }
 export interface DeepSeekCompatRuntimeOptions {
     strictToolRequired?: boolean;
-    textToolFallback?: boolean;
+    toolProtocol?: 'native' | 'text';
 }
 export interface ProviderProfile {
     providerKey: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.3214",
+  "version": "0.6.3271",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",