@jsonstudio/llms 0.6.2979 → 0.6.3238

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

@@ -0,0 +1,194 @@
+import { ProviderHealthManager } from './health-manager.js';
+import { ProviderRegistry } from './provider-registry.js';
+import { RouteLoadBalancer } from './load-balancer.js';
+import { RoutingClassifier } from './classifier.js';
+import { ContextAdvisor } from './context-advisor.js';
+import { getStatsCenter } from '../../telemetry/stats-center.js';
+import { loadRoutingInstructionStateSync, saveRoutingInstructionStateAsync, saveRoutingInstructionStateSync } from './sticky-session-store.js';
+import { resolveStickyKey as resolveStickyKeyImpl, resolveSessionScope as resolveSessionScopeImpl } from './engine/routing-state/keys.js';
+import { RouteAnalytics } from './engine/route-analytics.js';
+import { StickySessionManager } from './engine/sticky-session-manager.js';
+import { CooldownManager } from './engine/cooldown-manager.js';
+import { routeRequest } from './engine-legacy/routing.js';
+import { updateDeps as updateDepsImpl, initialize as initializeImpl } from './engine-legacy/config.js';
+import { handleProviderError as handleProviderErrorImpl, handleProviderFailure as handleProviderFailureImpl, handleProviderSuccess as handleProviderSuccessImpl, buildHealthSnapshot as buildHealthSnapshotImpl, persistHealthSnapshot as persistHealthSnapshotImpl, markProviderCooldown as markProviderCooldownImpl, clearProviderCooldown as clearProviderCooldownImpl, isProviderCoolingDown as isProviderCoolingDownImpl, getProviderCooldownRemainingMs as getProviderCooldownRemainingMsImpl, restoreHealthFromStore as restoreHealthFromStoreImpl } from './engine-legacy/health.js';
+import { getStopMessageState as getStopMessageStateImpl, getPreCommandState as getPreCommandStateImpl, getStatus as getStatusImpl } from './engine-legacy/state-accessors.js';
+import { selectProvider as selectProviderImpl, selectFromCandidates as selectFromCandidatesImpl, selectFromStickyPool as selectFromStickyPoolImpl, extractExcludedProviderKeySet as extractExcludedProviderKeySetImpl } from './engine-legacy/selection-core.js';
+import { parseDirectProviderModel as parseDirectProviderModelImpl, shouldFallbackDirectModelForMedia as shouldFallbackDirectModelForMediaImpl } from './engine-legacy/direct-model.js';
+import { normalizeRouteAlias as normalizeRouteAliasImpl, buildRouteCandidates as buildRouteCandidatesImpl, reorderForInlineVision as reorderForInlineVisionImpl, reorderForPreferredModel as reorderForPreferredModelImpl, routeSupportsModel as routeSupportsModelImpl, routeSupportsInlineVision as routeSupportsInlineVisionImpl, sortByPriority as sortByPriorityImpl, routeWeight as routeWeightImpl, routeHasForceFlag as routeHasForceFlagImpl, routeHasTargets as routeHasTargetsImpl, hasPrimaryPool as hasPrimaryPoolImpl, sortRoutePools as sortRoutePoolsImpl, flattenPoolTargets as flattenPoolTargetsImpl } from './engine-legacy/route-utils.js';
+import { resolveSelectionPenalty as resolveSelectionPenaltyImpl, resolveInstructionProcessModeForSelection as resolveInstructionProcessModeForSelectionImpl, resolveInstructionTarget as resolveInstructionTargetImpl, filterCandidatesByRoutingState as filterCandidatesByRoutingStateImpl, buildStickyRouteCandidatesFromFiltered as buildStickyRouteCandidatesFromFilteredImpl } from './engine-legacy/selection-state.js';
+export class VirtualRouterEngine {
+    routing = {};
+    providerRegistry = new ProviderRegistry();
+    healthManager = new ProviderHealthManager();
+    loadBalancer = new RouteLoadBalancer();
+    classifier = new RoutingClassifier({});
+    contextAdvisor = new ContextAdvisor();
+    contextRouting;
+    routeAnalytics = new RouteAnalytics();
+    stickySessionManager = new StickySessionManager();
+    cooldownManager;
+    antigravityLeasePersistence = { loadedOnce: false, loadedMtimeMs: null, flushTimer: null };
+    debug = console; // thin hook; host may monkey-patch for colored logging
+    healthConfig = null;
+    statsCenter = getStatsCenter();
+    // Derived flags from VirtualRouterConfig/routing used by process / response layers.
+    webSearchForce = false;
+    healthStore;
+    routingStateStore = {
+        loadSync: loadRoutingInstructionStateSync,
+        saveAsync: saveRoutingInstructionStateAsync,
+        saveSync: saveRoutingInstructionStateSync
+    };
+    routingInstructionState = new Map();
+    quotaView;
+    /**
+     * Backward-compatible test/debug surface used by existing regression scripts.
+     * Keep this as a read-only view over StickySessionManager storage.
+     */
+    get antigravitySessionAliasStore() {
+        return this.stickySessionManager.getAllStores().sessionAliasStore;
+    }
+    constructor(deps) {
+        this.cooldownManager = new CooldownManager({
+            healthStore: deps?.healthStore,
+            healthConfig: this.healthConfig,
+            quotaView: deps?.quotaView
+        });
+        if (deps?.healthStore) {
+            this.healthStore = deps.healthStore;
+        }
+        if (deps?.routingStateStore) {
+            this.routingStateStore = deps.routingStateStore;
+        }
+        if (deps?.quotaView) {
+            this.quotaView = deps.quotaView;
+        }
+    }
+    updateDeps(deps) {
+        updateDepsImpl(this, deps);
+    }
+    initialize(config) {
+        initializeImpl(this, config);
+    }
+    route(request, metadata) {
+        return routeRequest(this, request, metadata);
+    }
+    getStopMessageState(metadata) {
+        return getStopMessageStateImpl(this, metadata);
+    }
+    getPreCommandState(metadata) {
+        return getPreCommandStateImpl(this, metadata);
+    }
+    handleProviderFailure(event) {
+        handleProviderFailureImpl(this, event);
+    }
+    handleProviderError(event) {
+        handleProviderErrorImpl(this, event);
+    }
+    handleProviderSuccess(event) {
+        handleProviderSuccessImpl(this, event);
+    }
+    getStatus() {
+        return getStatusImpl(this);
+    }
+    normalizeRouteAlias(routeName) {
+        return normalizeRouteAliasImpl(routeName);
+    }
+    buildRouteCandidates(requestedRoute, classificationCandidates, features) {
+        return buildRouteCandidatesImpl(this, requestedRoute, classificationCandidates, features);
+    }
+    reorderForInlineVision(routeNames) {
+        return reorderForInlineVisionImpl(this, routeNames);
+    }
+    reorderForPreferredModel(routeNames, modelId) {
+        return reorderForPreferredModelImpl(this, routeNames, modelId);
+    }
+    routeSupportsModel(routeName, modelId) {
+        return routeSupportsModelImpl(this, routeName, modelId);
+    }
+    routeSupportsInlineVision(routeName) {
+        return routeSupportsInlineVisionImpl(this, routeName);
+    }
+    sortByPriority(routeNames) {
+        return sortByPriorityImpl(routeNames);
+    }
+    routeWeight(routeName) {
+        return routeWeightImpl(routeName);
+    }
+    routeHasForceFlag(routeName) {
+        return routeHasForceFlagImpl(this, routeName);
+    }
+    routeHasTargets(pools) {
+        return routeHasTargetsImpl(this, pools);
+    }
+    hasPrimaryPool(pools) {
+        return hasPrimaryPoolImpl(this, pools);
+    }
+    sortRoutePools(pools) {
+        return sortRoutePoolsImpl(this, pools);
+    }
+    flattenPoolTargets(pools) {
+        return flattenPoolTargetsImpl(this, pools);
+    }
+    markProviderCooldown(providerKey, cooldownMs) {
+        markProviderCooldownImpl(this, providerKey, cooldownMs);
+    }
+    clearProviderCooldown(providerKey) {
+        clearProviderCooldownImpl(this, providerKey);
+    }
+    isProviderCoolingDown(providerKey) {
+        return isProviderCoolingDownImpl(this, providerKey);
+    }
+    getProviderCooldownRemainingMs(providerKey) {
+        return getProviderCooldownRemainingMsImpl(this, providerKey);
+    }
+    restoreHealthFromStore() {
+        restoreHealthFromStoreImpl(this);
+    }
+    buildHealthSnapshot() {
+        return buildHealthSnapshotImpl(this);
+    }
+    persistHealthSnapshot() {
+        persistHealthSnapshotImpl(this);
+    }
+    parseDirectProviderModel(model) {
+        return parseDirectProviderModelImpl(this, model);
+    }
+    shouldFallbackDirectModelForMedia(direct, features) {
+        return shouldFallbackDirectModelForMediaImpl(this, direct, features);
+    }
+    selectProvider(requestedRoute, metadata, classification, features, routingState) {
+        return selectProviderImpl(this, requestedRoute, metadata, classification, features, routingState);
+    }
+    selectFromCandidates(routes, metadata, classification, features, state, requiredProviderKeys, allowAliasRotation) {
+        return selectFromCandidatesImpl(this, routes, metadata, classification, features, state, requiredProviderKeys, allowAliasRotation);
+    }
+    selectFromStickyPool(stickyKeySet, metadata, features, state, allowAliasRotation) {
+        return selectFromStickyPoolImpl(this, stickyKeySet, metadata, features, state, allowAliasRotation);
+    }
+    extractExcludedProviderKeySet(metadata) {
+        return extractExcludedProviderKeySetImpl(this, metadata);
+    }
+    resolveSelectionPenalty(providerKey) {
+        return resolveSelectionPenaltyImpl(this, providerKey);
+    }
+    resolveInstructionProcessModeForSelection(providerKey, routingState) {
+        return resolveInstructionProcessModeForSelectionImpl(this, providerKey, routingState);
+    }
+    resolveInstructionTarget(target) {
+        return resolveInstructionTargetImpl(this, target);
+    }
+    buildStickyRouteCandidatesFromFiltered(filteredCandidates, stickyKeySet) {
+        return buildStickyRouteCandidatesFromFilteredImpl(this, filteredCandidates, stickyKeySet);
+    }
+    filterCandidatesByRoutingState(routes, state) {
+        return filterCandidatesByRoutingStateImpl(this, routes, state);
+    }
+    resolveStickyKey(metadata) {
+        return resolveStickyKeyImpl(metadata);
+    }
+    resolveSessionScope(metadata) {
+        return resolveSessionScopeImpl(metadata);
+    }
+}

package/dist/router/virtual-router/engine-logging.d.ts

@@ -19,6 +19,7 @@ export type StopMessageRuntimeSummary = {
 };
 export type VirtualRouterHitRecord = {
     timestampMs: number;
+    requestId?: string;
     routeName: string;
     poolId?: string;
     providerKey: string;
@@ -34,6 +35,7 @@ export type VirtualRouterHitEventMeta = {
     entryEndpoint?: string;
 };
 export declare function createVirtualRouterHitRecord(input: {
+    requestId?: string;
     routeName: string;
     poolId?: string;
     providerKey: string;

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

@@ -65,6 +65,7 @@ export function createVirtualRouterHitRecord(input) {
         timestampMs: typeof input.timestampMs === 'number' && Number.isFinite(input.timestampMs)
             ? input.timestampMs
             : Date.now(),
+        ...(input.requestId ? { requestId: input.requestId } : {}),
         routeName: input.routeName,
         ...(input.poolId ? { poolId: input.poolId } : {}),
         providerKey: input.providerKey,
@@ -249,6 +250,8 @@ export function formatVirtualRouterHit(record) {
         const { providerLabel, resolvedModel } = describeTargetProvider(record.providerKey, record.modelId);
         const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
         const targetLabel = `${routeLabel} -> ${providerLabel}${resolvedModel ? '.' + resolvedModel : ''}`;
+        const requestId = typeof record.requestId === 'string' ? record.requestId : '';
+        const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
         const stickyText = formatStickyScope(record.stickyScope);
         const stickyLabel = stickyText ? ` ${stickyColor}[sticky:${stickyText}]${reset}` : '';
         const reasonLabel = record.hitReason ? ` reason=${record.hitReason}` : '';
@@ -276,7 +279,7 @@ export function formatVirtualRouterHit(record) {
             }
             stopLabel = ` ${stopColor}[stopMessage:${parts.join(' ')}]${reset}`;
         }
-        return `${prefix} ${timeLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${requestTokenLabel}${penaltyLabel}${stopLabel}${reset}`;
+        return `${prefix} ${timeLabel}${requestLabel} ${routeColor}${targetLabel}${stickyLabel}${reasonLabel}${requestTokenLabel}${penaltyLabel}${stopLabel}${reset}`;
     }
     catch {
         const now = new Date(record.timestampMs);
@@ -284,6 +287,8 @@ export function formatVirtualRouterHit(record) {
         const routeLabel = record.poolId ? `${record.routeName}/${record.poolId}` : record.routeName;
         const stickyText = formatStickyScope(record.stickyScope);
         const stickyLabel = stickyText ? ` [sticky:${stickyText}]` : '';
+        const requestId = typeof record.requestId === 'string' ? record.requestId : '';
+        const requestLabel = requestId && !requestId.includes('unknown') ? ` req=${requestId}` : '';
         const requestTokenLabel = typeof record.requestTokens === 'number' && Number.isFinite(record.requestTokens)
             ? ` reqTokens=${Math.max(0, Math.round(record.requestTokens))}`
             : '';
@@ -298,6 +303,6 @@ export function formatVirtualRouterHit(record) {
             const left = stop.remaining >= 0 ? String(stop.remaining) : 'n/a';
             stopLabel = ` [stopMessage:${safeText} mode=${stop.mode} round=${rounds} active=${stop.active ? 'yes' : 'no'} left=${left}]`;
         }
-        return `[virtual-router-hit] ${timestamp} ${routeLabel} -> ${record.providerKey}${record.modelId ? '.' + record.modelId : ''}${stickyLabel}${record.hitReason ? ` reason=${record.hitReason}` : ''}${requestTokenLabel}${penaltyLabel}${stopLabel}`;
+        return `[virtual-router-hit] ${timestamp}${requestLabel} ${routeLabel} -> ${record.providerKey}${record.modelId ? '.' + record.modelId : ''}${stickyLabel}${record.hitReason ? ` reason=${record.hitReason}` : ''}${requestTokenLabel}${penaltyLabel}${stopLabel}`;
     }
 }

package/dist/router/virtual-router/engine-selection/key-parsing.js

@@ -13,9 +13,6 @@ export function extractKeyAlias(providerKey) {
     return normalizeAliasDescriptor(alias);
 }
 export function normalizeAliasDescriptor(alias) {
-    if (/^\d+-/.test(alias)) {
-        return alias.replace(/^\d+-/, '');
-    }
     return alias;
 }
 export function extractKeyIndex(providerKey) {

package/dist/router/virtual-router/engine-selection/native-chat-request-filter-semantics.d.ts

@@ -0,0 +1 @@
+export declare function buildGovernedFilterPayloadWithNativeFallback(request: unknown): Record<string, unknown>;

package/dist/router/virtual-router/engine-selection/native-chat-request-filter-semantics.js

@@ -0,0 +1,54 @@
+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 parseOutputRecord(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function buildGovernedFilterPayloadWithNativeFallback(request) {
+    const capability = 'buildGovernedFilterPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const requestJson = safeStringify(request);
+    if (!requestJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(requestJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseOutputRecord(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-hub-bridge-policy-semantics.d.ts

@@ -47,6 +47,15 @@ export interface NativeProtocolSpec {
     providerOutbound: NativeProviderOutboundPolicySpec;
     toolSurface: NativeToolSurfaceSpec;
 }
+export interface NativeHubProtocolAllowlists {
+    openaiChatAllowedFields: string[];
+    openaiChatParametersWrapperAllowKeys: string[];
+    openaiResponsesAllowedFields: string[];
+    openaiResponsesParametersWrapperAllowKeys: string[];
+    anthropicAllowedFields: string[];
+    anthropicParametersWrapperAllowKeys: string[];
+    geminiAllowedFields: string[];
+}
 export declare function resolveHubProtocolSpecWithNative(input: {
     protocol?: string;
     allowlists: {
@@ -59,4 +68,5 @@ export declare function resolveHubProtocolSpecWithNative(input: {
         geminiAllowedFields: readonly string[];
     };
 }): NativeProtocolSpec;
+export declare function resolveHubProtocolAllowlistsWithNative(): NativeHubProtocolAllowlists;
 export {};

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

@@ -298,6 +298,50 @@ function parseProtocolSpec(raw) {
         return null;
     }
 }
+function parseStringArrayValue(value) {
+    if (!Array.isArray(value)) {
+        return null;
+    }
+    const out = value.filter((entry) => typeof entry === 'string');
+    return out;
+}
+function parseHubProtocolAllowlists(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const openaiChatAllowedFields = parseStringArrayValue(row.openaiChatAllowedFields);
+        const openaiChatParametersWrapperAllowKeys = parseStringArrayValue(row.openaiChatParametersWrapperAllowKeys);
+        const openaiResponsesAllowedFields = parseStringArrayValue(row.openaiResponsesAllowedFields);
+        const openaiResponsesParametersWrapperAllowKeys = parseStringArrayValue(row.openaiResponsesParametersWrapperAllowKeys);
+        const anthropicAllowedFields = parseStringArrayValue(row.anthropicAllowedFields);
+        const anthropicParametersWrapperAllowKeys = parseStringArrayValue(row.anthropicParametersWrapperAllowKeys);
+        const geminiAllowedFields = parseStringArrayValue(row.geminiAllowedFields);
+        if (!openaiChatAllowedFields ||
+            !openaiChatParametersWrapperAllowKeys ||
+            !openaiResponsesAllowedFields ||
+            !openaiResponsesParametersWrapperAllowKeys ||
+            !anthropicAllowedFields ||
+            !anthropicParametersWrapperAllowKeys ||
+            !geminiAllowedFields) {
+            return null;
+        }
+        return {
+            openaiChatAllowedFields,
+            openaiChatParametersWrapperAllowKeys,
+            openaiResponsesAllowedFields,
+            openaiResponsesParametersWrapperAllowKeys,
+            anthropicAllowedFields,
+            anthropicParametersWrapperAllowKeys,
+            geminiAllowedFields
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export function resolveHubProtocolSpecWithNative(input) {
     const capability = 'resolveHubProtocolSpecJson';
     const fail = (reason) => failNativeRequired(capability, reason);
@@ -336,3 +380,26 @@ export function resolveHubProtocolSpecWithNative(input) {
         return fail(reason);
     }
 }
+export function resolveHubProtocolAllowlistsWithNative() {
+    const capability = 'resolveHubProtocolAllowlistsJson';
+    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 = parseHubProtocolAllowlists(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-hub-pipeline-governance-semantics.d.ts

@@ -0,0 +1,30 @@
+export interface NativeToolGovernanceRules {
+    maxNameLength?: number;
+    allowedCharacters?: unknown;
+    forceCase?: 'lower' | 'upper';
+    defaultName?: string;
+    trimWhitespace?: boolean;
+    onViolation?: 'truncate' | 'reject';
+}
+export interface NativeToolGovernanceRuleNode {
+    request?: NativeToolGovernanceRules;
+    response?: NativeToolGovernanceRules;
+}
+export type NativeToolGovernanceRegistry = Record<string, NativeToolGovernanceRuleNode>;
+export declare function resolveDefaultToolGovernanceRulesWithNative(): NativeToolGovernanceRegistry;
+export declare function governRequestWithNative(input: {
+    request: Record<string, unknown>;
+    protocol?: string;
+    registry?: NativeToolGovernanceRegistry;
+}): {
+    request: Record<string, unknown>;
+    summary: Record<string, unknown>;
+};
+export declare function governResponseWithNative(input: {
+    payload: Record<string, unknown>;
+    protocol?: string;
+    registry?: NativeToolGovernanceRegistry;
+}): {
+    payload: Record<string, unknown>;
+    summary: Record<string, unknown>;
+};

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

@@ -0,0 +1,202 @@
+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 normalizeAllowedCharactersToken(value) {
+    if (typeof value === 'string') {
+        const token = value.trim();
+        return token || undefined;
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const row = value;
+    if (typeof row.source === 'string' && row.source.trim()) {
+        return row.source.trim();
+    }
+    return undefined;
+}
+function normalizeRulesForNative(rules) {
+    if (!rules || typeof rules !== 'object') {
+        return undefined;
+    }
+    const normalizedAllowed = normalizeAllowedCharactersToken(rules.allowedCharacters);
+    return {
+        ...rules,
+        ...(normalizedAllowed ? { allowedCharacters: normalizedAllowed } : {})
+    };
+}
+function normalizeRegistryForNative(registry) {
+    if (!registry || typeof registry !== 'object') {
+        return undefined;
+    }
+    const out = {};
+    for (const [protocol, node] of Object.entries(registry)) {
+        out[protocol] = {
+            request: normalizeRulesForNative(node?.request),
+            response: normalizeRulesForNative(node?.response)
+        };
+    }
+    return out;
+}
+function parseRegistry(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function readNativeErrorReason(value) {
+    if (value instanceof Error) {
+        const text = value.message.trim();
+        return text || String(value);
+    }
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const row = value;
+    const message = typeof row.message === 'string' ? row.message.trim() : '';
+    if (message) {
+        return message;
+    }
+    return undefined;
+}
+export function resolveDefaultToolGovernanceRulesWithNative() {
+    const capability = 'resolveDefaultToolGovernanceRulesJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    try {
+        const raw = fn();
+        const errorReason = readNativeErrorReason(raw);
+        if (errorReason) {
+            return fail(errorReason);
+        }
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRegistry(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function governRequestWithNative(input) {
+    const capability = 'governRequestJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const normalizedInput = {
+        ...input,
+        registry: normalizeRegistryForNative(input.registry)
+    };
+    const inputJson = safeStringify(normalizedInput);
+    if (!inputJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(inputJson);
+        const errorReason = readNativeErrorReason(raw);
+        if (errorReason) {
+            return fail(errorReason);
+        }
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return fail('invalid payload');
+        }
+        const row = parsed;
+        if (!row.request || typeof row.request !== 'object' || Array.isArray(row.request)) {
+            return fail('invalid request payload');
+        }
+        if (!row.summary || typeof row.summary !== 'object' || Array.isArray(row.summary)) {
+            return fail('invalid summary payload');
+        }
+        return {
+            request: row.request,
+            summary: row.summary
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function governResponseWithNative(input) {
+    const capability = 'governToolNameResponseJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const normalizedInput = {
+        ...input,
+        registry: normalizeRegistryForNative(input.registry)
+    };
+    const inputJson = safeStringify(normalizedInput);
+    if (!inputJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(inputJson);
+        const errorReason = readNativeErrorReason(raw);
+        if (errorReason) {
+            return fail(errorReason);
+        }
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return fail('invalid payload');
+        }
+        const row = parsed;
+        if (!row.payload || typeof row.payload !== 'object' || Array.isArray(row.payload)) {
+            return fail('invalid response payload');
+        }
+        if (!row.summary || typeof row.summary !== 'object' || Array.isArray(row.summary)) {
+            return fail('invalid summary payload');
+        }
+        return {
+            payload: row.payload,
+            summary: row.summary
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

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

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