@jsonstudio/llms 0.6.2172 → 0.6.3214

package/dist/router/virtual-router/engine-selection/native-chat-process-web-search-intent-semantics.js

@@ -0,0 +1,49 @@
+import { failNativeRequired, isNativeDisabledByEnv } from './native-router-hotpath-policy.js';
+import { loadNativeRouterHotpathBindingForInternalUse } from './native-router-hotpath.js';
+function parseHint(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null) {
+            return undefined;
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const hint = {};
+        if (row.force === true) {
+            hint.force = true;
+        }
+        if (row.disable === true) {
+            hint.disable = true;
+        }
+        return Object.keys(hint).length ? hint : undefined;
+    }
+    catch {
+        return null;
+    }
+}
+export function extractWebSearchSemanticsHintWithNative(semantics) {
+    const capability = 'extractWebSearchSemanticsHintJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const binding = loadNativeRouterHotpathBindingForInternalUse();
+    const fn = binding?.extractWebSearchSemanticsHintJson;
+    if (typeof fn !== 'function') {
+        return fail();
+    }
+    try {
+        const raw = fn(JSON.stringify(semantics ?? null));
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseHint(raw);
+        return parsed === null ? fail('invalid payload') : parsed;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}

package/dist/router/virtual-router/engine-selection/native-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-action-semantics.d.ts

@@ -0,0 +1,134 @@
+export interface NativeBridgeToolCallIdsInput {
+    messages: unknown[];
+    rawRequest?: Record<string, unknown>;
+    capturedToolResults?: Array<Record<string, unknown>>;
+    idPrefix?: string;
+}
+export interface NativeBridgeToolCallIdsOutput {
+    messages: unknown[];
+    rawRequest?: Record<string, unknown>;
+    capturedToolResults?: Array<Record<string, unknown>>;
+}
+export interface NativeApplyBridgeNormalizeToolIdentifiersInput {
+    stage: 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+    protocol?: string;
+    moduleType?: string;
+    messages: unknown[];
+    rawRequest?: Record<string, unknown>;
+    capturedToolResults?: Array<Record<string, unknown>>;
+    idPrefix?: string;
+}
+export interface NativeBridgeHistoryInput {
+    messages: unknown[];
+    tools?: Array<Record<string, unknown>>;
+}
+export interface NativeBridgeHistoryOutput {
+    input: unknown[];
+    combinedSystemInstruction?: string;
+    latestUserInstruction?: string;
+    originalSystemMessages: string[];
+}
+export interface NativeApplyBridgeNormalizeHistoryInput {
+    messages: unknown[];
+    tools?: Array<Record<string, unknown>>;
+}
+export interface NativeApplyBridgeNormalizeHistoryOutput {
+    messages: unknown[];
+    bridgeHistory?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeCaptureToolResultsInput {
+    stage: 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+    capturedToolResults?: Array<Record<string, unknown>>;
+    rawRequest?: Record<string, unknown>;
+    rawResponse?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeCaptureToolResultsOutput {
+    capturedToolResults?: Array<Record<string, unknown>>;
+    metadata?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeEnsureToolPlaceholdersInput {
+    stage: 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+    messages: unknown[];
+    capturedToolResults?: Array<Record<string, unknown>>;
+    rawRequest?: Record<string, unknown>;
+    rawResponse?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeEnsureToolPlaceholdersOutput {
+    messages: unknown[];
+    toolOutputs?: Array<Record<string, unknown>>;
+}
+export interface NativeEnsureBridgeOutputFieldsInput {
+    messages: unknown[];
+    toolFallback?: string;
+    assistantFallback?: string;
+}
+export interface NativeEnsureBridgeOutputFieldsOutput {
+    messages: unknown[];
+}
+export interface NativeApplyBridgeMetadataActionInput {
+    actionName: string;
+    stage: 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+    options?: Record<string, unknown>;
+    rawRequest?: Record<string, unknown>;
+    rawResponse?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeMetadataActionOutput {
+    rawRequest?: Record<string, unknown>;
+    rawResponse?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeReasoningExtractInput {
+    messages: unknown[];
+    dropFromContent?: boolean;
+    idPrefixBase?: string;
+}
+export interface NativeApplyBridgeReasoningExtractOutput {
+    messages: unknown[];
+}
+export interface NativeApplyBridgeResponsesOutputReasoningInput {
+    messages: unknown[];
+    rawResponse?: Record<string, unknown>;
+    idPrefix?: string;
+}
+export interface NativeApplyBridgeResponsesOutputReasoningOutput {
+    messages: unknown[];
+}
+export interface NativeApplyBridgeInjectSystemInstructionInput {
+    stage: 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+    options?: Record<string, unknown>;
+    messages: unknown[];
+    rawRequest?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeInjectSystemInstructionOutput {
+    messages: unknown[];
+}
+export interface NativeApplyBridgeEnsureSystemInstructionInput {
+    stage: 'request_inbound' | 'request_outbound' | 'response_inbound' | 'response_outbound';
+    messages: unknown[];
+    metadata?: Record<string, unknown>;
+}
+export interface NativeApplyBridgeEnsureSystemInstructionOutput {
+    messages: unknown[];
+    metadata?: Record<string, unknown>;
+}
+export interface NativeNormalizeMessageReasoningToolsOutput {
+    message: Record<string, unknown>;
+    toolCallsAdded: number;
+    cleanedReasoning?: string;
+}
+export declare function normalizeBridgeToolCallIdsWithNative(input: NativeBridgeToolCallIdsInput): NativeBridgeToolCallIdsOutput;
+export declare function applyBridgeNormalizeToolIdentifiersWithNative(input: NativeApplyBridgeNormalizeToolIdentifiersInput): NativeBridgeToolCallIdsOutput;
+export declare function buildBridgeHistoryWithNative(input: NativeBridgeHistoryInput): NativeBridgeHistoryOutput;
+export declare function applyBridgeNormalizeHistoryWithNative(input: NativeApplyBridgeNormalizeHistoryInput): NativeApplyBridgeNormalizeHistoryOutput;
+export declare function applyBridgeCaptureToolResultsWithNative(input: NativeApplyBridgeCaptureToolResultsInput): NativeApplyBridgeCaptureToolResultsOutput;
+export declare function applyBridgeEnsureToolPlaceholdersWithNative(input: NativeApplyBridgeEnsureToolPlaceholdersInput): NativeApplyBridgeEnsureToolPlaceholdersOutput;
+export declare function ensureBridgeOutputFieldsWithNative(input: NativeEnsureBridgeOutputFieldsInput): NativeEnsureBridgeOutputFieldsOutput;
+export declare function applyBridgeMetadataActionWithNative(input: NativeApplyBridgeMetadataActionInput): NativeApplyBridgeMetadataActionOutput;
+export declare function applyBridgeReasoningExtractWithNative(input: NativeApplyBridgeReasoningExtractInput): NativeApplyBridgeReasoningExtractOutput;
+export declare function applyBridgeResponsesOutputReasoningWithNative(input: NativeApplyBridgeResponsesOutputReasoningInput): NativeApplyBridgeResponsesOutputReasoningOutput;
+export declare function applyBridgeInjectSystemInstructionWithNative(input: NativeApplyBridgeInjectSystemInstructionInput): NativeApplyBridgeInjectSystemInstructionOutput;
+export declare function applyBridgeEnsureSystemInstructionWithNative(input: NativeApplyBridgeEnsureSystemInstructionInput): NativeApplyBridgeEnsureSystemInstructionOutput;
+export declare function normalizeMessageReasoningToolsWithNative(message: Record<string, unknown>, idPrefix?: string): NativeNormalizeMessageReasoningToolsOutput;
+export declare function normalizeChatResponseReasoningToolsWithNative(response: Record<string, unknown>, idPrefixBase?: string): Record<string, unknown>;