@jsonstudio/llms 0.6.2172 → 0.6.3214

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

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

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

@@ -0,0 +1,69 @@
+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;
+    }
+}
+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);
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { AliasSelectionConfig, AliasSelectionStrategy } from '../types.js';
+type NativeAliasQueuePinPayload = {
+    queue: string[];
+    desiredOrder: string[];
+    excludedAliases: string[];
+    aliasBuckets: Record<string, string[]>;
+    candidateOrder: string[];
+    availabilityByAlias: Record<string, boolean>;
+};
+type NativeAliasQueuePinOutput = {
+    queue: string[];
+    selectedCandidates: string[];
+};
+export declare function resolveAliasSelectionStrategyWithNative(providerId: string, cfg: AliasSelectionConfig | undefined): AliasSelectionStrategy;
+export declare function pinAliasQueueWithNative(payload: NativeAliasQueuePinPayload): NativeAliasQueuePinOutput;
+export {};

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

@@ -0,0 +1,96 @@
+import { failNativeRequired } 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 parseAliasSelectionStrategy(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === 'none' || parsed === 'sticky-queue') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function parseAliasQueuePinOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (!Array.isArray(row.queue) || !Array.isArray(row.selectedCandidates)) {
+            return null;
+        }
+        const queue = row.queue.filter((v) => typeof v === 'string');
+        const selectedCandidates = row.selectedCandidates.filter((v) => typeof v === 'string');
+        return {
+            queue,
+            selectedCandidates
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveAliasSelectionStrategyWithNative(providerId, cfg) {
+    const capability = 'resolveAliasSelectionStrategyJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction('resolveAliasSelectionStrategyJson');
+    if (!fn) {
+        return fail();
+    }
+    const cfgJson = safeStringify(cfg ?? null);
+    if (!cfgJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(String(providerId || ''), cfgJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseAliasSelectionStrategy(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function pinAliasQueueWithNative(payload) {
+    const capability = 'pinAliasQueueJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction('pinAliasQueueJson');
+    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 = parseAliasQueuePinOutput(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-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>;

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

@@ -0,0 +1,86 @@
+import { failNativeRequired } 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 parseArrayPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return null;
+        return parsed.filter((entry) => typeof entry === 'string');
+    }
+    catch {
+        return null;
+    }
+}
+function parseRecordPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseRoutingInstructionKindsWithNative(request) {
+    const capability = 'parseRoutingInstructionKindsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const requestJson = safeStringify(request);
+    if (!requestJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(requestJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseArrayPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function cleanRoutingInstructionMarkersWithNative(request) {
+    const capability = 'cleanRoutingInstructionMarkersJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const requestJson = safeStringify(request);
+    if (!requestJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(requestJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordPayload(result);
+        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-virtual-router-stop-message-actions-semantics.d.ts

@@ -0,0 +1,6 @@
+export type NativeStopMessageActionPatch = {
+    applied: boolean;
+    set: Record<string, unknown>;
+    unset: string[];
+};
+export declare function applyStopMessageInstructionWithNative(instruction: unknown, state: unknown, nowMs: number): NativeStopMessageActionPatch;

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-actions-semantics.js

@@ -0,0 +1,85 @@
+import { failNativeRequired } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+const STOP_MESSAGE_FIELDS = new Set([
+    'stopMessageSource',
+    'stopMessageText',
+    'stopMessageMaxRepeats',
+    'stopMessageUsed',
+    'stopMessageUpdatedAt',
+    'stopMessageLastUsedAt',
+    'stopMessageStageMode',
+    'stopMessageAiMode',
+    'stopMessageAiSeedPrompt',
+    'stopMessageAiHistory'
+]);
+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 parseActionPatchPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (typeof row.applied !== 'boolean') {
+            return null;
+        }
+        const setRaw = row.set;
+        const unsetRaw = row.unset;
+        const normalizedSet = {};
+        if (setRaw && typeof setRaw === 'object' && !Array.isArray(setRaw)) {
+            for (const [key, value] of Object.entries(setRaw)) {
+                if (value !== undefined) {
+                    normalizedSet[key] = value;
+                }
+            }
+        }
+        const normalizedUnset = Array.isArray(unsetRaw)
+            ? unsetRaw.filter((key) => typeof key === 'string')
+            : [];
+        return {
+            applied: row.applied,
+            set: normalizedSet,
+            unset: Array.from(new Set(normalizedUnset))
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function applyStopMessageInstructionWithNative(instruction, state, nowMs) {
+    const capability = 'applyStopMessageInstructionJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const instructionJson = safeStringify(instruction);
+    const stateJson = safeStringify(state);
+    if (!instructionJson || !stateJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(instructionJson, stateJson, Math.floor(nowMs));
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseActionPatchPayload(result);
+        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-virtual-router-stop-message-semantics.d.ts

@@ -0,0 +1,9 @@
+export type StopMessageNativeParseOutput = {
+    kind: 'clear';
+} | {
+    kind: 'set';
+    text: string;
+    maxRepeats: number;
+    aiMode?: 'on' | 'off';
+};
+export declare function parseStopMessageInstructionWithNative(instruction: string): StopMessageNativeParseOutput | null;

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-semantics.js

@@ -0,0 +1,70 @@
+import { failNativeRequired } 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 normalizeMode(value) {
+    if (value !== 'on' && value !== 'off') {
+        return undefined;
+    }
+    return value;
+}
+function parseStopMessageNativePayload(raw) {
+    let parsed = null;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return null;
+    }
+    const kindRaw = parsed.kind;
+    if (kindRaw !== 'set' && kindRaw !== 'clear') {
+        return null;
+    }
+    const kind = kindRaw;
+    if (kind === 'clear') {
+        return { kind: 'clear' };
+    }
+    const text = typeof parsed.text === 'string' ? parsed.text : '';
+    const maxRepeats = typeof parsed.maxRepeats === 'number' && Number.isFinite(parsed.maxRepeats)
+        ? Math.floor(parsed.maxRepeats)
+        : 10;
+    if (!text || maxRepeats <= 0) {
+        return null;
+    }
+    const aiMode = normalizeMode(parsed.aiMode);
+    return {
+        kind: 'set',
+        text,
+        maxRepeats,
+        ...(aiMode ? { aiMode } : {})
+    };
+}
+export function parseStopMessageInstructionWithNative(instruction) {
+    const capability = 'parseStopMessageInstructionJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction('parseStopMessageInstructionJson');
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const result = fn(String(instruction || ''));
+        if (typeof result !== 'string') {
+            return fail('non-string result');
+        }
+        if (!result || result === 'null') {
+            return null;
+        }
+        const parsed = parseStopMessageNativePayload(result);
+        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-virtual-router-stop-message-state-semantics.d.ts

@@ -0,0 +1,2 @@
+export declare function serializeStopMessageStateWithNative(state: unknown): Record<string, unknown>;
+export declare function deserializeStopMessageStateWithNative(data: Record<string, unknown>, state: unknown): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-virtual-router-stop-message-state-semantics.js

@@ -0,0 +1,76 @@
+import { failNativeRequired } 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 parseRecordPayload(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function serializeStopMessageStateWithNative(state) {
+    const capability = 'serializeStopMessageStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const stateJson = safeStringify(state);
+    if (!stateJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(stateJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordPayload(result);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function deserializeStopMessageStateWithNative(data, state) {
+    const capability = 'deserializeStopMessageStateJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const dataJson = safeStringify(data);
+    const stateJson = safeStringify(state);
+    if (!dataJson || !stateJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const result = fn(dataJson, stateJson);
+        if (typeof result !== 'string' || !result) {
+            return fail('empty result');
+        }
+        const parsed = parseRecordPayload(result);
+        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/route-utils.js

@@ -63,7 +63,7 @@ export function buildRouteCandidates(requestedRoute, classificationCandidates, f
                 baseList.unshift('multimodal');
             }
         }
-        if (hasVisionTargets) {
+        if (hasVisionTargets && (!hasMultimodalTargets || forceVision)) {
             if (!baseList.includes('vision')) {
                 baseList.push('vision');
             }

package/dist/router/virtual-router/engine-selection/tier-selection-antigravity-session-lease.d.ts

@@ -0,0 +1,10 @@
+import type { SelectionDeps } from './selection-deps.js';
+export declare function isAntigravityGeminiModelKey(providerKey: string, deps: SelectionDeps): boolean;
+export declare function extractLeaseRuntimeKey(providerKey: string, deps: SelectionDeps): string | null;
+export declare function applyAntigravityAliasSessionLeases(targets: string[], deps: SelectionDeps, metadata: unknown): {
+    targets: string[];
+    blocked: number;
+    preferredPinned: boolean;
+    pinnedStrict: boolean;
+    preferredRuntimeKey?: string;
+};