@jsonstudio/llms 0.6.2172 → 0.6.2979

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

@@ -0,0 +1,284 @@
+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)), '../../../../');
+let cachedBinding;
+let cachedBindingCacheKey;
+const REQUIRED_NATIVE_EXPORTS = [
+    'analyzeChatProcessMediaJson',
+    'analyzeChatWebSearchIntentJson',
+    'extractWebSearchSemanticsHintJson',
+    'extractOutputSegmentsJson',
+    'analyzeContinueExecutionInjectionJson',
+    'analyzePendingToolSyncJson',
+    'appendToolParseDiagnosticTextJson',
+    'injectToolParseDiagnosticsJson',
+    'applyReqProcessToolGovernanceJson',
+    'applyHubOperationsJson',
+    'applyReqProcessRouteSelectionJson',
+    'applyReqOutboundContextSnapshotJson',
+    'applyClaudeThinkingToolSchemaCompatJson',
+    'applyOutboundStreamPreferenceJson',
+    'applyTargetMetadataJson',
+    'applyTargetToSubjectJson',
+    'applyStopMessageInstructionJson',
+    'attachPassthroughProviderInputAuditJson',
+    'augmentContextSnapshotJson',
+    'annotatePassthroughGovernanceSkipJson',
+    'buildAnthropicToolAliasMapJson',
+    'buildChatNodeResultMetadataJson',
+    'buildProcessedRequestFromChatResponseJson',
+    'applyChatProcessedRequestJson',
+    'buildChatProcessContextMetadataJson',
+    'buildChatProcessedDescriptorJson',
+    'applyClientPassthroughPatchJson',
+    'applyGovernedControlOperationsJson',
+    'applyGovernedMergeRequestJson',
+    'buildClockMarkerScheduleMessagesJson',
+    'buildClockReminderMessagesJson',
+    'buildClockReminderMetadataJson',
+    'buildFormatRequestJson',
+    'buildClockStandardToolAppendOperationsJson',
+    'buildClockToolAppendOperationsJson',
+    'buildResponsesPayloadFromChatJson',
+    'buildBridgeHistoryJson',
+    'applyBridgeNormalizeHistoryJson',
+    'applyBridgeCaptureToolResultsJson',
+    'applyBridgeNormalizeToolIdentifiersJson',
+    'applyBridgeEnsureToolPlaceholdersJson',
+    'buildContinueExecutionOperationsJson',
+    'buildDueReminderUserMessageJson',
+    'buildGovernedFilterPayloadJson',
+    'buildPassthroughAuditJson',
+    'buildGuardedClockScheduleItemJson',
+    'buildImageAttachmentMetadataJson',
+    'buildReviewOperationsJson',
+    'buildWebSearchToolAppendOperationsJson',
+    'clampResponsesInputItemIdJson',
+    'castGovernedToolsJson',
+    'collectToolOutputsJson',
+    'buildReqInboundToolOutputSnapshotJson',
+    'mapBridgeToolsToChatJson',
+    'captureReqInboundResponsesContextSnapshotJson',
+    'computeQuotaBucketsJson',
+    'deserializeStopMessageStateJson',
+    'detectProviderResponseShapeJson',
+    'extractClockReminderDirectivesJson',
+    'extractContextLengthDiagnosticsJson',
+    'encodeMetadataPassthroughJson',
+    'prepareGeminiToolsForBridgeJson',
+    'buildGeminiToolsFromBridgeJson',
+    'pickResponsesPersistedFieldsJson',
+    'convertResponsesOutputToInputItemsJson',
+    'extractAntigravityGeminiSessionIdJson',
+    'ensureBridgeOutputFieldsJson',
+    'lookupAntigravityPinnedAliasForSessionIdJson',
+    'unpinAntigravitySessionAliasForSessionIdJson',
+    'cacheAntigravitySessionSignatureJson',
+    'getAntigravityRequestSessionMetaJson',
+    'resetAntigravitySignatureCachesJson',
+    'coerceClientHeadersJson',
+    'extractSessionIdentifiersJson',
+    'extractTargetModelIdJson',
+    'extractClockScheduleDirectiveTextPartsJson',
+    'extractSseWrapperErrorJson',
+    'extractMetadataPassthroughJson',
+    'extractAdapterContextMetadataFieldsJson',
+    'evaluateResponsesHostPolicyJson',
+    'enforceChatBudgetJson',
+    'finalizeGovernedRequestJson',
+    'findLastUserMessageIndexJson',
+    'injectContinueExecutionDirectiveJson',
+    'injectTimeTagIntoMessagesJson',
+    'injectMcpToolsForChatJson',
+    'injectMcpToolsForResponsesJson',
+    'isStopMessageStateActiveJson',
+    'isContextLengthExceededSignalJson',
+    'isCompactionRequestJson',
+    'isShellLikeToolNameTokenJson',
+    'looksLikeJsonStreamPrefixJson',
+    'mapResumeToolOutputsDetailedJson',
+    'mergeContextToolOutputsJson',
+    'mergeToolCallsJson',
+    'mergeGovernanceSummaryIntoMetadataJson',
+    'findHeaderValueJson',
+    'normalizeAliasMapJson',
+    'normalizeMessageReasoningToolsJson',
+    'normalizeOpenaiMessageJson',
+    'normalizeOpenaiChatMessagesJson',
+    'normalizeOpenaiToolJson',
+    'normalizeOpenaiToolCallJson',
+    'normalizeChatResponseReasoningToolsJson',
+    'normalizeBridgeToolCallIdsJson',
+    'normalizeChatMessageContentJson',
+    'normalizeArgsBySchemaJson',
+    'normalizeFunctionCallIdJson',
+    'normalizeFunctionCallOutputIdJson',
+    'normalizeHeaderKeyJson',
+    'normalizeHubEndpointJson',
+    'normalizeOutputContentPartJson',
+    'normalizeToolSessionMessagesJson',
+    'updateToolSessionHistoryJson',
+    'normalizeContextCaptureLabelJson',
+    'normalizeContextToolsJson',
+    'normalizeDueInjectTextJson',
+    'normalizeProviderProtocolTokenJson',
+    'normalizeResponsesCallIdJson',
+    'normalizeMessageContentPartsJson',
+    'normalizeShellLikeToolCallsBeforeGovernanceJson',
+    'normalizeToolCallIdStyleCandidateJson',
+    'parseClockScheduleDirectiveCandidateJson',
+    'parseLenientJsonishJson',
+    'parseJsonObjectCandidateJson',
+    'parseProviderKeyJson',
+    'parseStopMessageInstructionJson',
+    'pinAliasQueueJson',
+    'planChatClockOperationsJson',
+    'planChatServertoolOrchestrationBundleJson',
+    'planChatWebSearchOperationsJson',
+    'planContinueExecutionOperationsJson',
+    'resolveAliasSelectionStrategyJson',
+    'resolveBridgePolicyJson',
+    'resolveBridgePolicyActionsJson',
+    'resolveAliasMapFromRespSemanticsJson',
+    'resolveClientInjectReadyJson',
+    'resolveClientToolsRawJson',
+    'resolveClientToolsRawFromRespSemanticsJson',
+    'resolveClockReminderFlowPlanJson',
+    'resolveClockConfigJson',
+    'resolveClockSessionScopeJson',
+    'resolveClockTimeTagFallbackLineJson',
+    'resolveCompatProfileJson',
+    'resolveHasActiveStopMessageForContinueExecutionJson',
+    'resolveHasInstructionRequestedPassthroughJson',
+    'resolveHubClientProtocolJson',
+    'resolveHubProtocolSpecJson',
+    'resolveOutboundStreamIntentJson',
+    'resolveProviderProtocolJson',
+    'resolveHubPolicyOverrideJson',
+    'resolveHubShadowCompareConfigJson',
+    'resolveApplyPatchToolModeFromToolsJson',
+    'resolveActiveProcessModeJson',
+    'resolveStopMessageRouterMetadataJson',
+    'resolveGovernanceContextJson',
+    'resolveStopMessageSessionScopeJson',
+    'ensureProtocolStateJson',
+    'getProtocolStateJson',
+    'readRuntimeMetadataJson',
+    'ensureRuntimeMetadataJson',
+    'cloneRuntimeMetadataJson',
+    'applyReqInboundSemanticLiftJson',
+    'pickHeaderJson',
+    'resolveReqOutboundContextMergePlanJson',
+    'runReqOutboundStage3CompatJson',
+    'runHubPipelineJson',
+    'findMappableSemanticsKeysJson',
+    'deriveToolCallKeyJson',
+    'extractToolCallsFromReasoningTextJson',
+    'mapReasoningContentToResponsesOutputJson',
+    'isImagePathJson',
+    'resolveServerToolFollowupSnapshotJson',
+    'resolveSseStreamModeJson',
+    'resolveSseProtocolFromMetadataJson',
+    'repairArgumentsToStringJsonishJson',
+    'sanitizeChatCompletionLikeJson',
+    'sanitizeFormatEnvelopeJson',
+    'sanitizeReasoningTaggedTextJson',
+    'sanitizeResponsesFunctionNameJson',
+    'selectToolCallIdStyleJson',
+    'serializeStopMessageStateJson',
+    'shouldAttachReqOutboundContextSnapshotJson',
+    'shouldReserveClockDueReminderJson',
+    'shouldRunHubChatProcessJson',
+    'splitAntigravityTargetsJson',
+    'stripOrphanFunctionCallsTagJson',
+    'stripClockClearDirectiveTextJson',
+    'stripChatProcessHistoricalImagesJson',
+    'stripPrivateFieldsJson'
+];
+function readNativePathFromEnv() {
+    const raw = String(process.env.ROUTECODEX_LLMS_ROUTER_NATIVE_PATH || process.env.RCC_LLMS_ROUTER_NATIVE_PATH || '').trim();
+    return raw || undefined;
+}
+function buildNativeBindingCacheKey(envPath) {
+    if (!envPath) {
+        return 'auto';
+    }
+    const resolved = path.isAbsolute(envPath) ? envPath : path.resolve(process.cwd(), envPath);
+    return `env:${resolved}`;
+}
+function resolveLoadPathForNode(resolvedPath) {
+    const ext = path.extname(resolvedPath).toLowerCase();
+    if (!ext || ext === '.node') {
+        return resolvedPath;
+    }
+    if (ext !== '.dylib' && ext !== '.so' && ext !== '.dll') {
+        return resolvedPath;
+    }
+    return resolvedPath.replace(/\.(dylib|so|dll)$/i, '.node');
+}
+function tryRequireFromPath(modulePath, options) {
+    try {
+        const resolved = path.isAbsolute(modulePath) ? modulePath : path.resolve(process.cwd(), modulePath);
+        const loadPath = resolveLoadPathForNode(resolved);
+        const loaded = require(loadPath);
+        if (!loaded || typeof loaded !== 'object') {
+            return null;
+        }
+        if (options?.requireComplete !== false && !hasCompleteNativeBinding(loaded, REQUIRED_NATIVE_EXPORTS)) {
+            return null;
+        }
+        return loaded;
+    }
+    catch {
+        return null;
+    }
+}
+function getWorkspaceNativeCandidates() {
+    return ['release', 'debug'].map((mode) => path.join(workspaceRoot, 'rust-core', 'target', mode, 'router_hotpath_napi.node'));
+}
+function getPackagedNativeCandidates() {
+    return [path.join(workspaceRoot, 'dist', 'native', 'router_hotpath_napi.node')];
+}
+export function loadNativeRouterHotpathBinding() {
+    const envPath = readNativePathFromEnv();
+    const cacheKey = buildNativeBindingCacheKey(envPath);
+    if (cachedBinding !== undefined && cachedBindingCacheKey === cacheKey) {
+        return cachedBinding;
+    }
+    cachedBindingCacheKey = cacheKey;
+    cachedBinding = undefined;
+    if (envPath) {
+        // Explicit env path is allowed to provide partial exports for focused test mocks.
+        // Missing capabilities still fail-fast at callsite via native-required checks.
+        cachedBinding = tryRequireFromPath(envPath, { requireComplete: false });
+        if (cachedBinding)
+            return cachedBinding;
+    }
+    for (const candidate of getWorkspaceNativeCandidates()) {
+        const loaded = tryRequireFromPath(candidate);
+        if (loaded) {
+            cachedBinding = loaded;
+            return cachedBinding;
+        }
+    }
+    for (const candidate of getPackagedNativeCandidates()) {
+        const loaded = tryRequireFromPath(candidate);
+        if (loaded) {
+            cachedBinding = loaded;
+            return cachedBinding;
+        }
+    }
+    cachedBinding = null;
+    return cachedBinding;
+}
+export function resolveNativeModuleUrlFromEnv() {
+    const modulePath = readNativePathFromEnv();
+    if (!modulePath) {
+        return undefined;
+    }
+    const normalized = path.isAbsolute(modulePath) ? modulePath : path.resolve(process.cwd(), modulePath);
+    return pathToFileURL(normalized).href;
+}

package/dist/router/virtual-router/engine-selection/native-router-hotpath-policy.d.ts

@@ -0,0 +1,5 @@
+export declare function isNativeDisabledByEnv(): boolean;
+export declare function isNativeRequiredByEnv(): boolean;
+export declare function hasCompleteNativeBinding(binding: unknown, requiredExports: readonly string[]): boolean;
+export declare function makeNativeRequiredError(capability: string, reason?: string): Error;
+export declare function failNativeRequired<T>(capability: string, reason?: string): T;

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

@@ -0,0 +1,18 @@
+export function isNativeDisabledByEnv() {
+    return false;
+}
+export function isNativeRequiredByEnv() {
+    return true;
+}
+export function hasCompleteNativeBinding(binding, requiredExports) {
+    if (!binding || typeof binding !== 'object')
+        return false;
+    const row = binding;
+    return requiredExports.every((key) => typeof row[key] === 'function');
+}
+export function makeNativeRequiredError(capability, reason) {
+    return new Error(`[virtual-router-native-hotpath] native ${capability} is required but unavailable${reason ? `: ${reason}` : ''}`);
+}
+export function failNativeRequired(capability, reason) {
+    throw makeNativeRequiredError(capability, reason);
+}

package/dist/router/virtual-router/engine-selection/native-router-hotpath-quota-buckets.d.ts

@@ -0,0 +1,25 @@
+export type QuotaBucketInputEntry = {
+    key: string;
+    order: number;
+    hasQuota: boolean;
+    inPool: boolean;
+    cooldownUntil?: number;
+    blacklistUntil?: number;
+    priorityTier?: number;
+    selectionPenalty?: number;
+};
+type QuotaBucketOutputEntry = {
+    key: string;
+    penalty: number;
+    order: number;
+};
+export type QuotaBucketResult = {
+    priorities: number[];
+    buckets: Map<number, QuotaBucketOutputEntry[]>;
+};
+type HotpathMode = 'auto' | 'native-only';
+export declare function buildQuotaBuckets(entries: QuotaBucketInputEntry[], nowMs: number): QuotaBucketResult;
+export declare function buildQuotaBucketsWithMode(entries: QuotaBucketInputEntry[], nowMs: number, mode: HotpathMode | string): QuotaBucketResult;
+export declare function getNativeRouterHotpathSource(): 'native' | 'unavailable';
+export declare function resolveNativeModuleUrlFromEnv(): string | undefined;
+export {};

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

@@ -0,0 +1,85 @@
+import { loadNativeRouterHotpathBinding, resolveNativeModuleUrlFromEnv as resolveNativeModuleUrlFromEnvInLoader } from './native-router-hotpath-loader.js';
+function coerceNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function parseNativePayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.priorities) || !Array.isArray(parsed.buckets)) {
+            return null;
+        }
+        const buckets = new Map();
+        for (const tier of parsed.buckets) {
+            const priority = coerceNumber(tier.priority);
+            if (priority === undefined) {
+                continue;
+            }
+            const entriesRaw = Array.isArray(tier.entries)
+                ? tier.entries
+                : [];
+            const entries = [];
+            for (const item of entriesRaw) {
+                if (!item || typeof item !== 'object' || Array.isArray(item)) {
+                    continue;
+                }
+                const row = item;
+                const key = typeof row.key === 'string' ? row.key : '';
+                const penalty = coerceNumber(row.penalty) ?? 0;
+                const order = coerceNumber(row.order) ?? 0;
+                if (!key) {
+                    continue;
+                }
+                entries.push({ key, penalty, order });
+            }
+            buckets.set(priority, entries);
+        }
+        const priorities = parsed.priorities
+            .map((value) => coerceNumber(value))
+            .filter((value) => value !== undefined)
+            .sort((a, b) => a - b);
+        return { priorities, buckets };
+    }
+    catch {
+        return null;
+    }
+}
+function computeQuotaBucketsNative(entries, nowMs) {
+    const binding = loadNativeRouterHotpathBinding();
+    const fn = binding?.computeQuotaBucketsJson;
+    if (typeof fn !== 'function') {
+        return null;
+    }
+    try {
+        const resultJson = fn(JSON.stringify(entries), nowMs);
+        if (typeof resultJson !== 'string' || !resultJson) {
+            return null;
+        }
+        return parseNativePayload(resultJson);
+    }
+    catch {
+        return null;
+    }
+}
+export function buildQuotaBuckets(entries, nowMs) {
+    return buildQuotaBucketsWithMode(entries, nowMs, 'auto');
+}
+export function buildQuotaBucketsWithMode(entries, nowMs, mode) {
+    if (mode !== 'auto' && mode !== 'native-only') {
+        throw new Error(`[virtual-router-native-hotpath] unsupported hotpath mode: ${String(mode)}`);
+    }
+    const nativeResult = computeQuotaBucketsNative(entries, nowMs);
+    if (nativeResult) {
+        return nativeResult;
+    }
+    throw new Error('[virtual-router-native-hotpath] native router hotpath is required but unavailable');
+}
+export function getNativeRouterHotpathSource() {
+    const binding = loadNativeRouterHotpathBinding();
+    if (typeof binding?.computeQuotaBucketsJson === 'function') {
+        return 'native';
+    }
+    return 'unavailable';
+}
+export function resolveNativeModuleUrlFromEnv() {
+    return resolveNativeModuleUrlFromEnvInLoader();
+}

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

@@ -0,0 +1,59 @@
+export { buildQuotaBuckets, buildQuotaBucketsWithMode, getNativeRouterHotpathSource, resolveNativeModuleUrlFromEnv, type QuotaBucketInputEntry, type QuotaBucketResult } from './native-router-hotpath-quota-buckets.js';
+export declare function splitAntigravityTargets(targets: string[]): {
+    nonAntigravity: string[];
+    hasAntigravity: boolean;
+    source: 'native';
+};
+export declare function analyzePendingToolSync(messages: unknown[], afterToolCallIds: string[]): {
+    ready: boolean;
+    insertAt: number;
+    source: 'native';
+};
+export declare function analyzeContinueExecutionInjection(messages: unknown[], marker: string, targetText: string): {
+    hasDirective: boolean;
+    source: 'native';
+};
+export declare function stripClockClearDirectiveText(text: string): {
+    hadClear: boolean;
+    next: string;
+    source: 'native';
+};
+export declare function analyzeChatProcessMedia(messages: unknown[]): {
+    stripIndices: number[];
+    containsCurrentTurnImage: boolean;
+    source: 'native';
+};
+export declare function stripChatProcessHistoricalImages(messages: unknown[], placeholderText: string): {
+    changed: boolean;
+    messages: unknown[];
+    source: 'native';
+};
+export declare function analyzeChatWebSearchIntent(messages: unknown[]): {
+    hasIntent: boolean;
+    googlePreferred: boolean;
+    source: 'native';
+};
+export declare function analyzeProviderKey(providerKey: string): {
+    providerId: string | null;
+    alias: string | null;
+    keyIndex?: number;
+    source: 'native';
+};
+export declare function extractAntigravityGeminiSessionIdWithNative(payload: unknown): string;
+export declare function lookupAntigravityPinnedAliasForSessionIdWithNative(sessionId: string, options?: {
+    hydrate?: boolean;
+}): string | undefined;
+export declare function unpinAntigravitySessionAliasForSessionIdWithNative(sessionId: string): boolean;
+export declare function cacheAntigravitySessionSignatureWithNative(input: {
+    aliasKey: string;
+    sessionId: string;
+    signature: string;
+    messageCount?: number;
+}): boolean;
+export declare function getAntigravityRequestSessionMetaWithNative(requestId: string): {
+    aliasKey?: string;
+    sessionId?: string;
+    messageCount?: number;
+};
+export declare function resetAntigravitySignatureCachesWithNative(): boolean;
+export declare function loadNativeRouterHotpathBindingForInternalUse(): unknown;

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

@@ -0,0 +1,117 @@
+import { parseAntigravityPinnedAliasLookupPayload, parseAntigravityPinnedAliasUnpinPayload, parseAntigravityCacheSignaturePayload, parseAntigravityRequestSessionMetaPayload, parseAntigravitySessionIdPayload, parseClockClearDirectivePayload, parseChatProcessMediaAnalysisPayload, parseChatProcessMediaStripPayload, parseChatWebSearchIntentPayload, parseContinueExecutionInjectionPayload, parsePendingToolSyncPayload, parseProviderKeyPayload } from './native-router-hotpath-analysis.js';
+import { isNativeDisabledByEnv, makeNativeRequiredError } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBinding } from './native-router-hotpath-loader.js';
+export { buildQuotaBuckets, buildQuotaBucketsWithMode, getNativeRouterHotpathSource, resolveNativeModuleUrlFromEnv } from './native-router-hotpath-quota-buckets.js';
+function parseAntigravitySplitPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || !Array.isArray(parsed.nonAntigravity) || typeof parsed.hasAntigravity !== 'boolean') {
+            return null;
+        }
+        const nonAntigravity = parsed.nonAntigravity.filter((value) => typeof value === 'string');
+        return {
+            nonAntigravity,
+            hasAntigravity: parsed.hasAntigravity
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function toErrorReason(error) {
+    return error instanceof Error ? error.message : String(error ?? 'unknown');
+}
+function requireNativeFunction(capability, exportName) {
+    if (isNativeDisabledByEnv()) {
+        throw makeNativeRequiredError(capability, 'native disabled');
+    }
+    const binding = loadNativeRouterHotpathBinding();
+    const fn = binding?.[exportName];
+    if (typeof fn !== 'function') {
+        throw makeNativeRequiredError(capability);
+    }
+    return fn;
+}
+function callNativeJson(capability, exportName, args, parse) {
+    const fn = requireNativeFunction(capability, exportName);
+    let raw;
+    try {
+        raw = fn(...args);
+    }
+    catch (error) {
+        throw makeNativeRequiredError(capability, toErrorReason(error));
+    }
+    if (typeof raw !== 'string' || !raw) {
+        throw makeNativeRequiredError(capability, 'empty result');
+    }
+    const parsed = parse(raw);
+    if (!parsed) {
+        throw makeNativeRequiredError(capability, 'invalid payload');
+    }
+    return parsed;
+}
+export function splitAntigravityTargets(targets) {
+    const parsed = callNativeJson('splitAntigravityTargetsJson', 'splitAntigravityTargetsJson', [JSON.stringify(targets)], parseAntigravitySplitPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzePendingToolSync(messages, afterToolCallIds) {
+    const parsed = callNativeJson('analyzePendingToolSyncJson', 'analyzePendingToolSyncJson', [JSON.stringify(messages), JSON.stringify(afterToolCallIds)], parsePendingToolSyncPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeContinueExecutionInjection(messages, marker, targetText) {
+    const normalizedMarker = typeof marker === 'string' ? marker.trim() : '';
+    const normalizedTargetText = typeof targetText === 'string' ? targetText.trim() : '';
+    const parsed = callNativeJson('analyzeContinueExecutionInjectionJson', 'analyzeContinueExecutionInjectionJson', [JSON.stringify(messages), normalizedMarker, normalizedTargetText], parseContinueExecutionInjectionPayload);
+    return { ...parsed, source: 'native' };
+}
+export function stripClockClearDirectiveText(text) {
+    const parsed = callNativeJson('stripClockClearDirectiveTextJson', 'stripClockClearDirectiveTextJson', [String(text || '')], parseClockClearDirectivePayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeChatProcessMedia(messages) {
+    const parsed = callNativeJson('analyzeChatProcessMediaJson', 'analyzeChatProcessMediaJson', [JSON.stringify(messages)], parseChatProcessMediaAnalysisPayload);
+    return { ...parsed, source: 'native' };
+}
+export function stripChatProcessHistoricalImages(messages, placeholderText) {
+    const parsed = callNativeJson('stripChatProcessHistoricalImagesJson', 'stripChatProcessHistoricalImagesJson', [JSON.stringify(messages), String(placeholderText || '[Image omitted]')], parseChatProcessMediaStripPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeChatWebSearchIntent(messages) {
+    const parsed = callNativeJson('analyzeChatWebSearchIntentJson', 'analyzeChatWebSearchIntentJson', [JSON.stringify(messages)], parseChatWebSearchIntentPayload);
+    return { ...parsed, source: 'native' };
+}
+export function analyzeProviderKey(providerKey) {
+    const parsed = callNativeJson('parseProviderKeyJson', 'parseProviderKeyJson', [String(providerKey || '')], parseProviderKeyPayload);
+    return { ...parsed, source: 'native' };
+}
+export function extractAntigravityGeminiSessionIdWithNative(payload) {
+    const parsed = callNativeJson('extractAntigravityGeminiSessionIdJson', 'extractAntigravityGeminiSessionIdJson', [JSON.stringify(payload ?? null)], parseAntigravitySessionIdPayload);
+    return parsed.sessionId;
+}
+export function lookupAntigravityPinnedAliasForSessionIdWithNative(sessionId, options) {
+    const parsed = callNativeJson('lookupAntigravityPinnedAliasForSessionIdJson', 'lookupAntigravityPinnedAliasForSessionIdJson', [JSON.stringify({ sessionId: String(sessionId || ''), hydrate: options?.hydrate !== false })], parseAntigravityPinnedAliasLookupPayload);
+    return parsed.alias;
+}
+export function unpinAntigravitySessionAliasForSessionIdWithNative(sessionId) {
+    const parsed = callNativeJson('unpinAntigravitySessionAliasForSessionIdJson', 'unpinAntigravitySessionAliasForSessionIdJson', [JSON.stringify({ sessionId: String(sessionId || '') })], parseAntigravityPinnedAliasUnpinPayload);
+    return parsed.changed;
+}
+export function cacheAntigravitySessionSignatureWithNative(input) {
+    const parsed = callNativeJson('cacheAntigravitySessionSignatureJson', 'cacheAntigravitySessionSignatureJson', [JSON.stringify({
+            aliasKey: String(input.aliasKey || ''),
+            sessionId: String(input.sessionId || ''),
+            signature: String(input.signature || ''),
+            messageCount: typeof input.messageCount === 'number' ? Math.floor(input.messageCount) : undefined
+        })], parseAntigravityCacheSignaturePayload);
+    return parsed.ok;
+}
+export function getAntigravityRequestSessionMetaWithNative(requestId) {
+    return callNativeJson('getAntigravityRequestSessionMetaJson', 'getAntigravityRequestSessionMetaJson', [JSON.stringify({ requestId: String(requestId || '') })], parseAntigravityRequestSessionMetaPayload);
+}
+export function resetAntigravitySignatureCachesWithNative() {
+    const parsed = callNativeJson('resetAntigravitySignatureCachesJson', 'resetAntigravitySignatureCachesJson', ['{}'], parseAntigravityCacheSignaturePayload);
+    return parsed.ok;
+}
+export function loadNativeRouterHotpathBindingForInternalUse() {
+    return loadNativeRouterHotpathBinding();
+}

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

@@ -0,0 +1,76 @@
+export declare function parseLenientJsonishWithNative(value: unknown): unknown;
+export declare function repairArgumentsToStringWithNative(value: unknown): string;
+export declare function extractToolCallsFromReasoningTextWithNative(text: string, idPrefix?: string): {
+    cleanedText: string;
+    toolCalls: Array<Record<string, unknown>>;
+};
+export declare function sanitizeReasoningTaggedTextWithNative(text: string): string;
+export declare function deriveToolCallKeyWithNative(call: Record<string, unknown> | null | undefined): 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';
+    content: string;
+}>;
+export declare function isImagePathWithNative(pathValue: unknown): boolean;
+export declare function isCompactionRequestWithNative(payload: unknown): boolean;
+export declare function encodeMetadataPassthroughWithNative(parameters: unknown, prefix: string, keys: readonly string[]): Record<string, string> | undefined;
+export declare function extractMetadataPassthroughWithNative(metadataField: unknown, prefix: string, keys: readonly string[]): {
+    metadata?: Record<string, unknown>;
+    passthrough?: Record<string, unknown>;
+};
+export declare function ensureProtocolStateWithNative(metadata: Record<string, unknown>, protocol: string): {
+    metadata: Record<string, unknown>;
+    node: Record<string, unknown>;
+};
+export declare function getProtocolStateWithNative(metadata: Record<string, unknown> | undefined, protocol: string): Record<string, unknown> | undefined;
+export declare function readRuntimeMetadataWithNative(carrier: Record<string, unknown> | null | undefined): Record<string, unknown> | undefined;
+export declare function ensureRuntimeMetadataCarrierWithNative(carrier: Record<string, unknown>): Record<string, unknown>;
+export declare function cloneRuntimeMetadataWithNative(carrier: Record<string, unknown> | null | undefined): Record<string, unknown> | undefined;
+export declare function injectMcpToolsForChatWithNative(tools: unknown[] | undefined, discoveredServers: string[]): unknown[];
+export declare function normalizeArgsBySchemaWithNative(input: unknown, schema: unknown): {
+    ok: boolean;
+    value?: Record<string, unknown>;
+    errors?: string[];
+};
+export declare function extractOutputSegmentsWithNative(source: Record<string, unknown> | undefined, itemsKey?: string): {
+    textParts: string[];
+    reasoningParts: string[];
+};
+export declare function normalizeContentPartWithNative(part: unknown, reasoningCollector: string[]): {
+    normalized: Record<string, unknown> | null;
+    reasoningCollector: string[];
+};
+export declare function normalizeMessageContentPartsWithNative(parts: unknown, reasoningCollector: string[]): {
+    normalizedParts: Array<Record<string, unknown>>;
+    reasoningChunks: string[];
+};
+export declare function normalizeChatMessageContentWithNative(content: unknown): {
+    contentText?: string;
+    reasoningText?: string;
+};
+export declare function normalizeOpenaiMessageWithNative(message: unknown, disableShellCoerce: boolean): unknown;
+export declare function normalizeOpenaiToolWithNative(tool: unknown): unknown;
+export declare function normalizeOpenaiChatMessagesWithNative(messages: unknown): unknown[];
+export declare function normalizeOpenaiToolCallWithNative(toolCall: unknown, disableShellCoerce: boolean): unknown;
+export declare function prepareGeminiToolsForBridgeWithNative(rawTools: unknown, missing: unknown[]): {
+    defs?: Array<Record<string, unknown>>;
+    missing: Array<Record<string, unknown>>;
+};
+export declare function buildGeminiToolsFromBridgeWithNative(defs: unknown, mode?: 'antigravity' | 'default'): Array<Record<string, unknown>> | undefined;
+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 injectMcpToolsForResponsesWithNative(tools: unknown[] | undefined, discoveredServers: string[]): unknown[];
+export declare function normalizeFunctionCallIdWithNative(input: {
+    callId?: string;
+    fallback?: string;
+}): string;
+export declare function normalizeFunctionCallOutputIdWithNative(input: {
+    callId?: string;
+    fallback?: string;
+}): string;
+export declare function normalizeResponsesCallIdWithNative(input: {
+    callId?: string;
+    fallback?: string;
+}): string;
+export declare function clampResponsesInputItemIdWithNative(rawValue: unknown): string | undefined;