@jsonstudio/llms 0.6.2172 → 0.6.3214

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

@@ -0,0 +1,320 @@
+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 = resolvePackageRoot(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',
+    'buildProviderProtocolErrorJson',
+    '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',
+    'extractJsonToolCallsFromTextJson',
+    'extractXmlToolCallsFromTextJson',
+    'extractSimpleXmlToolsFromTextJson',
+    'extractParameterXmlToolsFromTextJson',
+    'extractInvokeToolsFromTextJson',
+    'extractToolNamespaceXmlBlocksFromTextJson',
+    'extractApplyPatchCallsFromTextJson',
+    'extractBareExecCommandFromTextJson',
+    'extractExecuteBlocksFromTextJson',
+    'extractExploredListDirectoryCallsFromTextJson',
+    'extractQwenToolCallTokensFromTextJson',
+    'extractAdapterContextMetadataFieldsJson',
+    'evaluateResponsesHostPolicyJson',
+    'enforceChatBudgetJson',
+    'resolveBudgetForModelJson',
+    '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',
+    'normalizeToolsJson',
+    'normalizeFunctionCallIdJson',
+    'normalizeFunctionCallOutputIdJson',
+    'normalizeHeaderKeyJson',
+    'normalizeHubEndpointJson',
+    'normalizeOutputContentPartJson',
+    'normalizeToolSessionMessagesJson',
+    'updateToolSessionHistoryJson',
+    'normalizeContextCaptureLabelJson',
+    'normalizeContextToolsJson',
+    'normalizeDueInjectTextJson',
+    'normalizeProviderProtocolTokenJson',
+    'normalizeResponsesCallIdJson',
+    'normalizeMessageContentPartsJson',
+    'normalizeShellLikeToolCallsBeforeGovernanceJson',
+    'normalizeToolCallIdStyleCandidateJson',
+    'parseClockScheduleDirectiveCandidateJson',
+    'parseLenientJsonishJson',
+    'parseJsonObjectCandidateJson',
+    'parseProviderKeyJson',
+    'parseRoutingInstructionKindsJson',
+    'parseStopMessageInstructionJson',
+    'pinAliasQueueJson',
+    'planChatClockOperationsJson',
+    'planChatServertoolOrchestrationBundleJson',
+    'planChatWebSearchOperationsJson',
+    'planContinueExecutionOperationsJson',
+    'resolveAliasSelectionStrategyJson',
+    'resolveBridgePolicyJson',
+    'resolveBridgePolicyActionsJson',
+    'resolveAliasMapFromRespSemanticsJson',
+    'resolveClientInjectReadyJson',
+    'resolveClientToolsRawJson',
+    'resolveClientToolsRawFromRespSemanticsJson',
+    'resolveClockReminderFlowPlanJson',
+    'resolveClockConfigJson',
+    'resolveClockSessionScopeJson',
+    'resolveClockTimeTagFallbackLineJson',
+    'resolveCompatProfileJson',
+    'resolveHasActiveStopMessageForContinueExecutionJson',
+    'resolveHasInstructionRequestedPassthroughJson',
+    'resolveHubClientProtocolJson',
+    'resolveHubProtocolSpecJson',
+    'resolveHubProtocolAllowlistsJson',
+    'resolveOutboundStreamIntentJson',
+    'resolveProviderProtocolJson',
+    'resolveHubPolicyOverrideJson',
+    'resolveHubShadowCompareConfigJson',
+    'resolveApplyPatchToolModeFromToolsJson',
+    'resolveActiveProcessModeJson',
+    'resolveStopMessageRouterMetadataJson',
+    'resolveGovernanceContextJson',
+    'resolveStopMessageSessionScopeJson',
+    'VirtualRouterEngineProxy',
+    'ensureProtocolStateJson',
+    'getProtocolStateJson',
+    'readRuntimeMetadataJson',
+    'resolveDefaultToolGovernanceRulesJson',
+    'ensureRuntimeMetadataJson',
+    'cloneRuntimeMetadataJson',
+    'applyReqInboundSemanticLiftJson',
+    'pickHeaderJson',
+    'resolveReqOutboundContextMergePlanJson',
+    'runReqOutboundStage3CompatJson',
+    'runHubPipelineJson',
+    'findMappableSemanticsKeysJson',
+    'deriveToolCallKeyJson',
+    'extractToolCallsFromReasoningTextJson',
+    'mapReasoningContentToResponsesOutputJson',
+    'isImagePathJson',
+    'resolveServerToolFollowupSnapshotJson',
+    'resolveSseStreamModeJson',
+    'resolveSseProtocolFromMetadataJson',
+    'repairArgumentsToStringJsonishJson',
+    'sanitizeChatCompletionLikeJson',
+    'sanitizeFormatEnvelopeJson',
+    'sanitizeReasoningTaggedTextJson',
+    'sanitizeResponsesFunctionNameJson',
+    'shouldRecordSnapshotsJson',
+    'writeSnapshotViaHooksJson',
+    'selectToolCallIdStyleJson',
+    'serializeStopMessageStateJson',
+    'shouldAttachReqOutboundContextSnapshotJson',
+    'shouldReserveClockDueReminderJson',
+    'shouldRunHubChatProcessJson',
+    'splitAntigravityTargetsJson',
+    'stripOrphanFunctionCallsTagJson',
+    'stripClockClearDirectiveTextJson',
+    'stripChatProcessHistoricalImagesJson',
+    '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;
+}
+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();
+}