@jsonstudio/llms 0.6.2979 → 0.6.3238

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

@@ -1,9 +1,10 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
 import { hasCompleteNativeBinding } from './native-router-hotpath-policy.js';
 const require = createRequire(import.meta.url);
-const workspaceRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../');
+const workspaceRoot = resolvePackageRoot(path.dirname(fileURLToPath(import.meta.url)));
 let cachedBinding;
 let cachedBindingCacheKey;
 const REQUIRED_NATIVE_EXPORTS = [
@@ -39,6 +40,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'buildClockMarkerScheduleMessagesJson',
     'buildClockReminderMessagesJson',
     'buildClockReminderMetadataJson',
+    'buildProviderProtocolErrorJson',
     'buildFormatRequestJson',
     'buildClockStandardToolAppendOperationsJson',
     'buildClockToolAppendOperationsJson',
@@ -61,6 +63,8 @@ const REQUIRED_NATIVE_EXPORTS = [
     'collectToolOutputsJson',
     'buildReqInboundToolOutputSnapshotJson',
     'mapBridgeToolsToChatJson',
+    'mapOpenaiChatToChatJson',
+    'mapOpenaiChatFromChatJson',
     'captureReqInboundResponsesContextSnapshotJson',
     'computeQuotaBucketsJson',
     'deserializeStopMessageStateJson',
@@ -85,10 +89,24 @@ const REQUIRED_NATIVE_EXPORTS = [
     'extractClockScheduleDirectiveTextPartsJson',
     'extractSseWrapperErrorJson',
     'extractMetadataPassthroughJson',
+    'extractJsonToolCallsFromTextJson',
+    'extractXmlToolCallsFromTextJson',
+    'extractSimpleXmlToolsFromTextJson',
+    'extractParameterXmlToolsFromTextJson',
+    'extractInvokeToolsFromTextJson',
+    'extractToolNamespaceXmlBlocksFromTextJson',
+    'extractApplyPatchCallsFromTextJson',
+    'extractBareExecCommandFromTextJson',
+    'extractExecuteBlocksFromTextJson',
+    'extractExploredListDirectoryCallsFromTextJson',
+    'extractQwenToolCallTokensFromTextJson',
     'extractAdapterContextMetadataFieldsJson',
     'evaluateResponsesHostPolicyJson',
     'enforceChatBudgetJson',
+    'resolveBudgetForModelJson',
     'finalizeGovernedRequestJson',
+    'governResponseJson',
+    'governToolNameResponseJson',
     'findLastUserMessageIndexJson',
     'injectContinueExecutionDirectiveJson',
     'injectTimeTagIntoMessagesJson',
@@ -114,6 +132,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'normalizeBridgeToolCallIdsJson',
     'normalizeChatMessageContentJson',
     'normalizeArgsBySchemaJson',
+    'normalizeToolsJson',
     'normalizeFunctionCallIdJson',
     'normalizeFunctionCallOutputIdJson',
     'normalizeHeaderKeyJson',
@@ -122,6 +141,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'normalizeToolSessionMessagesJson',
     'updateToolSessionHistoryJson',
     'normalizeContextCaptureLabelJson',
+    'normalizeSnapshotStagePayloadJson',
     'normalizeContextToolsJson',
     'normalizeDueInjectTextJson',
     'normalizeProviderProtocolTokenJson',
@@ -133,6 +153,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'parseLenientJsonishJson',
     'parseJsonObjectCandidateJson',
     'parseProviderKeyJson',
+    'parseRoutingInstructionKindsJson',
     'parseStopMessageInstructionJson',
     'pinAliasQueueJson',
     'planChatClockOperationsJson',
@@ -155,6 +176,7 @@ const REQUIRED_NATIVE_EXPORTS = [
     'resolveHasInstructionRequestedPassthroughJson',
     'resolveHubClientProtocolJson',
     'resolveHubProtocolSpecJson',
+    'resolveHubProtocolAllowlistsJson',
     'resolveOutboundStreamIntentJson',
     'resolveProviderProtocolJson',
     'resolveHubPolicyOverrideJson',
@@ -164,9 +186,11 @@ const REQUIRED_NATIVE_EXPORTS = [
     'resolveStopMessageRouterMetadataJson',
     'resolveGovernanceContextJson',
     'resolveStopMessageSessionScopeJson',
+    'VirtualRouterEngineProxy',
     'ensureProtocolStateJson',
     'getProtocolStateJson',
     'readRuntimeMetadataJson',
+    'resolveDefaultToolGovernanceRulesJson',
     'ensureRuntimeMetadataJson',
     'cloneRuntimeMetadataJson',
     'applyReqInboundSemanticLiftJson',
@@ -187,6 +211,8 @@ const REQUIRED_NATIVE_EXPORTS = [
     'sanitizeFormatEnvelopeJson',
     'sanitizeReasoningTaggedTextJson',
     'sanitizeResponsesFunctionNameJson',
+    'shouldRecordSnapshotsJson',
+    'writeSnapshotViaHooksJson',
     'selectToolCallIdStyleJson',
     'serializeStopMessageStateJson',
     'shouldAttachReqOutboundContextSnapshotJson',
@@ -196,8 +222,23 @@ const REQUIRED_NATIVE_EXPORTS = [
     'stripOrphanFunctionCallsTagJson',
     'stripClockClearDirectiveTextJson',
     'stripChatProcessHistoricalImagesJson',
-    'stripPrivateFieldsJson'
+    'stripPrivateFieldsJson',
+    'cleanRoutingInstructionMarkersJson'
 ];
+function resolvePackageRoot(startDir) {
+    let current = startDir;
+    for (let i = 0; i < 10; i += 1) {
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return path.resolve(startDir, '../../../../');
+}
 function readNativePathFromEnv() {
     const raw = String(process.env.ROUTECODEX_LLMS_ROUTER_NATIVE_PATH || process.env.RCC_LLMS_ROUTER_NATIVE_PATH || '').trim();
     return raw || undefined;

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

@@ -6,6 +6,69 @@ export declare function extractToolCallsFromReasoningTextWithNative(text: string
 };
 export declare function sanitizeReasoningTaggedTextWithNative(text: string): string;
 export declare function deriveToolCallKeyWithNative(call: Record<string, unknown> | null | undefined): string | null;
+export declare function buildProviderProtocolErrorWithNative(input: {
+    message: string;
+    code: string;
+    protocol?: string;
+    providerType?: string;
+    category?: string;
+    details?: Record<string, unknown>;
+}): Record<string, unknown>;
+export declare function extractJsonToolCallsFromTextWithNative(text: string, options?: Record<string, unknown>): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractXMLToolCallsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractSimpleXmlToolsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractParameterXmlToolsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractInvokeToolsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractToolNamespaceXmlBlocksFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractApplyPatchCallsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractBareExecCommandFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractExecuteBlocksFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractExploredListDirectoryCallsFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
+export declare function extractQwenToolCallTokensFromTextWithNative(text: string): Array<{
+    id?: string;
+    name: string;
+    args: string;
+}> | null;
 export declare function mergeToolCallsWithNative(existing: Array<Record<string, unknown>> | undefined, additions: Array<Record<string, unknown>> | undefined): Array<Record<string, unknown>>;
 export declare function mapReasoningContentToResponsesOutputWithNative(reasoningContent: unknown): Array<{
     type: 'reasoning';
@@ -32,6 +95,7 @@ export declare function normalizeArgsBySchemaWithNative(input: unknown, schema:
     value?: Record<string, unknown>;
     errors?: string[];
 };
+export declare function normalizeToolsWithNative(tools: unknown): Array<Record<string, unknown>>;
 export declare function extractOutputSegmentsWithNative(source: Record<string, unknown> | undefined, itemsKey?: string): {
     textParts: string[];
     reasoningParts: string[];
@@ -60,6 +124,17 @@ export declare function buildGeminiToolsFromBridgeWithNative(defs: unknown, mode
 export declare function pickResponsesPersistedFieldsWithNative(payload: unknown): Record<string, unknown>;
 export declare function convertResponsesOutputToInputItemsWithNative(response: unknown): Array<Record<string, unknown>>;
 export declare function enforceChatBudgetWithNative(chat: unknown, allowedBytes: number, systemTextLimit: number): unknown;
+export declare function resolveBudgetForModelWithNative(modelId: string, fallback: {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+} | null | undefined): {
+    maxBytes: number;
+    safetyRatio: number;
+    allowedBytes: number;
+    source: string;
+};
 export declare function injectMcpToolsForResponsesWithNative(tools: unknown[] | undefined, discoveredServers: string[]): unknown[];
 export declare function normalizeFunctionCallIdWithNative(input: {
     callId?: string;

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

@@ -61,6 +61,25 @@ function parseReasoningItems(raw) {
     }
     return out;
 }
+function parseToolCallLiteArray(raw) {
+    const parsed = parseJson(raw);
+    if (!Array.isArray(parsed)) {
+        return null;
+    }
+    const out = [];
+    for (const entry of parsed) {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            return null;
+        }
+        const row = entry;
+        if (typeof row.name !== 'string' || typeof row.args !== 'string') {
+            return null;
+        }
+        const id = typeof row.id === 'string' && row.id.trim().length ? row.id : undefined;
+        out.push({ id, name: row.name, args: row.args });
+    }
+    return out;
+}
 export function parseLenientJsonishWithNative(value) {
     const capability = 'parseLenientJsonishJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -189,6 +208,128 @@ export function deriveToolCallKeyWithNative(call) {
         return fail(reason);
     }
 }
+export function buildProviderProtocolErrorWithNative(input) {
+    const capability = 'buildProviderProtocolErrorJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        message: input.message,
+        code: input.code,
+        protocol: input.protocol,
+        providerType: input.providerType,
+        category: input.category,
+        details: input.details
+    });
+    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);
+    }
+}
+function parseToolCallResult(raw) {
+    if (!raw || raw === 'null') {
+        return null;
+    }
+    return parseToolCallLiteArray(raw);
+}
+function callTextMarkupExtractor(capability, payload) {
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(payload ?? null);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string') {
+            return fail('invalid payload');
+        }
+        const parsed = parseToolCallResult(raw);
+        return parsed ?? null;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function extractJsonToolCallsFromTextWithNative(text, options) {
+    return callTextMarkupExtractor('extractJsonToolCallsFromTextJson', {
+        text: String(text ?? ''),
+        options: options ?? null
+    });
+}
+export function extractXMLToolCallsFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractXmlToolCallsFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractSimpleXmlToolsFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractSimpleXmlToolsFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractParameterXmlToolsFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractParameterXmlToolsFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractInvokeToolsFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractInvokeToolsFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractToolNamespaceXmlBlocksFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractToolNamespaceXmlBlocksFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractApplyPatchCallsFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractApplyPatchCallsFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractBareExecCommandFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractBareExecCommandFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractExecuteBlocksFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractExecuteBlocksFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractExploredListDirectoryCallsFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractExploredListDirectoryCallsFromTextJson', {
+        text: String(text ?? '')
+    });
+}
+export function extractQwenToolCallTokensFromTextWithNative(text) {
+    return callTextMarkupExtractor('extractQwenToolCallTokensFromTextJson', {
+        text: String(text ?? '')
+    });
+}
 export function mergeToolCallsWithNative(existing, additions) {
     const capability = 'mergeToolCallsJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -613,6 +754,33 @@ export function normalizeArgsBySchemaWithNative(input, schema) {
         return fail(reason);
     }
 }
+export function normalizeToolsWithNative(tools) {
+    const capability = 'normalizeToolsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const toolsJson = safeStringify(tools ?? null);
+    if (!toolsJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(toolsJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseJson(raw);
+        return Array.isArray(parsed) ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function extractOutputSegmentsWithNative(source, itemsKey = 'output') {
     const capability = 'extractOutputSegmentsJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -1037,6 +1205,43 @@ export function enforceChatBudgetWithNative(chat, allowedBytes, systemTextLimit)
         return fail(reason);
     }
 }
+export function resolveBudgetForModelWithNative(modelId, fallback) {
+    const capability = 'resolveBudgetForModelJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const fallbackJson = safeStringify(fallback ?? null);
+    if (!fallbackJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(String(modelId ?? ''), fallbackJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        if (!parsed) {
+            return fail('invalid payload');
+        }
+        const maxBytes = Number(parsed.maxBytes);
+        const safetyRatio = Number(parsed.safetyRatio);
+        const allowedBytes = Number(parsed.allowedBytes);
+        const source = typeof parsed.source === 'string' ? parsed.source : 'unknown';
+        if (!Number.isFinite(maxBytes) || !Number.isFinite(safetyRatio) || !Number.isFinite(allowedBytes)) {
+            return fail('invalid payload');
+        }
+        return { maxBytes, safetyRatio, allowedBytes, source };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function injectMcpToolsForResponsesWithNative(tools, discoveredServers) {
     const capability = 'injectMcpToolsForResponsesJson';
     const fail = (reason) => failNativeRequired(capability, reason);

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

@@ -0,0 +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

@@ -0,0 +1,109 @@
+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 parseBoolean(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'boolean' ? parsed : null;
+    }
+    catch {
+        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);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const raw = fn();
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseBoolean(raw);
+        return parsed === null ? fail('invalid payload') : parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function writeSnapshotViaHooksWithNative(options) {
+    const capability = 'writeSnapshotViaHooksJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(options ?? null);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        fn(payloadJson);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        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-selection/native-virtual-router-engine-proxy.d.ts

@@ -0,0 +1,16 @@
+export interface NativeVirtualRouterEngineProxy {
+    initialize(configJson: string): void;
+    updateDeps(deps: object): void;
+    updateVirtualRouterConfig(configJson: string): void;
+    route(requestJson: string, metadataJson: string): string;
+    getStopMessageState(metadataJson: string): string;
+    getPreCommandState(metadataJson: string): string;
+    markProviderCooldown(providerKey: string, cooldownMs?: number): void;
+    clearProviderCooldown(providerKey: string): void;
+    handleProviderFailure(eventJson: string): void;
+    handleProviderError(eventJson: string): void;
+    handleProviderSuccess(eventJson: string): void;
+    getStatus(): string;
+    readonly antigravitySessionAliasStore: unknown;
+}
+export declare function createVirtualRouterEngineProxy(engine?: object): NativeVirtualRouterEngineProxy;

package/dist/router/virtual-router/engine-selection/native-virtual-router-engine-proxy.js

@@ -0,0 +1,14 @@
+import { failNativeRequired } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function resolveProxyConstructor() {
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const ctor = binding?.VirtualRouterEngineProxy;
+    if (typeof ctor !== 'function') {
+        return failNativeRequired('VirtualRouterEngineProxy', 'missing native proxy constructor');
+    }
+    return ctor;
+}
+export function createVirtualRouterEngineProxy(engine) {
+    const Ctor = resolveProxyConstructor();
+    return new Ctor(engine);
+}

package/dist/router/virtual-router/engine-selection/native-virtual-router-routing-instructions-semantics.d.ts

@@ -0,0 +1,2 @@
+export declare function parseRoutingInstructionKindsWithNative(request: unknown): string[];
+export declare function cleanRoutingInstructionMarkersWithNative(request: Record<string, unknown>): Record<string, unknown>;