@jsonstudio/llms 0.6.3405 → 0.6.3539

package/dist/router/virtual-router/engine-selection/native-hub-bridge-action-semantics.d.ts

@@ -28,6 +28,83 @@ export interface NativeBridgeHistoryOutput {
     latestUserInstruction?: string;
     originalSystemMessages: string[];
 }
+export interface NativeNormalizeBridgeHistorySeedOutput {
+    input: unknown[];
+    combinedSystemInstruction?: string;
+    latestUserInstruction?: string;
+    originalSystemMessages: string[];
+}
+export interface NativeResolveResponsesBridgeToolsInput {
+    originalTools?: Array<Record<string, unknown>>;
+    chatTools?: Array<Record<string, unknown>>;
+    hasServerSideWebSearch?: boolean;
+    passthroughKeys?: string[];
+    request?: Record<string, unknown>;
+}
+export interface NativeResolveResponsesBridgeToolsOutput {
+    mergedTools?: Array<Record<string, unknown>>;
+    request?: Record<string, unknown>;
+}
+export interface NativeResolveResponsesRequestBridgeDecisionsInput {
+    context?: Record<string, unknown>;
+    requestMetadata?: Record<string, unknown>;
+    envelopeMetadata?: Record<string, unknown>;
+    bridgeMetadata?: Record<string, unknown>;
+    extraBridgeHistory?: Record<string, unknown>;
+}
+export interface NativeResolveResponsesRequestBridgeDecisionsOutput {
+    forceWebSearch: boolean;
+    toolCallIdStyle?: 'fc' | 'preserve';
+    historySeed?: NativeBridgeHistoryOutput;
+}
+export interface NativeFilterBridgeInputForUpstreamInput {
+    input: unknown[];
+    allowToolCallId?: boolean;
+}
+export interface NativeFilterBridgeInputForUpstreamOutput {
+    input: Array<Record<string, unknown>>;
+}
+export interface NativePrepareResponsesRequestEnvelopeInput {
+    request: Record<string, unknown>;
+    contextSystemInstruction?: unknown;
+    extraSystemInstruction?: unknown;
+    metadataSystemInstruction?: unknown;
+    combinedSystemInstruction?: unknown;
+    reasoningInstructionSegments?: unknown;
+    contextParameters?: unknown;
+    chatParameters?: unknown;
+    metadataParameters?: unknown;
+    contextStream?: unknown;
+    metadataStream?: unknown;
+    chatStream?: unknown;
+    chatParametersStream?: unknown;
+    contextInclude?: unknown;
+    metadataInclude?: unknown;
+    contextStore?: unknown;
+    metadataStore?: unknown;
+    stripHostFields?: boolean;
+    contextToolChoice?: unknown;
+    metadataToolChoice?: unknown;
+    contextParallelToolCalls?: unknown;
+    metadataParallelToolCalls?: unknown;
+    contextResponseFormat?: unknown;
+    metadataResponseFormat?: unknown;
+    contextServiceTier?: unknown;
+    metadataServiceTier?: unknown;
+    contextTruncation?: unknown;
+    metadataTruncation?: unknown;
+    contextMetadata?: unknown;
+    metadataMetadata?: unknown;
+}
+export interface NativePrepareResponsesRequestEnvelopeOutput {
+    request: Record<string, unknown>;
+}
+export interface NativeAppendLocalImageBlockOnLatestUserInputInput {
+    messages: unknown[];
+}
+export interface NativeAppendLocalImageBlockOnLatestUserInputOutput {
+    messages: Array<Record<string, unknown>>;
+}
 export interface NativeApplyBridgeNormalizeHistoryInput {
     messages: unknown[];
     tools?: Array<Record<string, unknown>>;
@@ -173,6 +250,12 @@ export interface NativeHarvestToolsOutput {
 export declare function normalizeBridgeToolCallIdsWithNative(input: NativeBridgeToolCallIdsInput): NativeBridgeToolCallIdsOutput;
 export declare function applyBridgeNormalizeToolIdentifiersWithNative(input: NativeApplyBridgeNormalizeToolIdentifiersInput): NativeBridgeToolCallIdsOutput;
 export declare function buildBridgeHistoryWithNative(input: NativeBridgeHistoryInput): NativeBridgeHistoryOutput;
+export declare function normalizeBridgeHistorySeedWithNative(seed: Record<string, unknown>): NativeNormalizeBridgeHistorySeedOutput;
+export declare function resolveResponsesBridgeToolsWithNative(input: NativeResolveResponsesBridgeToolsInput): NativeResolveResponsesBridgeToolsOutput;
+export declare function resolveResponsesRequestBridgeDecisionsWithNative(input: NativeResolveResponsesRequestBridgeDecisionsInput): NativeResolveResponsesRequestBridgeDecisionsOutput;
+export declare function filterBridgeInputForUpstreamWithNative(input: NativeFilterBridgeInputForUpstreamInput): NativeFilterBridgeInputForUpstreamOutput;
+export declare function prepareResponsesRequestEnvelopeWithNative(input: NativePrepareResponsesRequestEnvelopeInput): NativePrepareResponsesRequestEnvelopeOutput;
+export declare function appendLocalImageBlockOnLatestUserInputWithNative(input: NativeAppendLocalImageBlockOnLatestUserInputInput): NativeAppendLocalImageBlockOnLatestUserInputOutput;
 export declare function applyBridgeNormalizeHistoryWithNative(input: NativeApplyBridgeNormalizeHistoryInput): NativeApplyBridgeNormalizeHistoryOutput;
 export declare function applyBridgeCaptureToolResultsWithNative(input: NativeApplyBridgeCaptureToolResultsInput): NativeApplyBridgeCaptureToolResultsOutput;
 export declare function applyBridgeEnsureToolPlaceholdersWithNative(input: NativeApplyBridgeEnsureToolPlaceholdersInput): NativeApplyBridgeEnsureToolPlaceholdersOutput;

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

@@ -82,6 +82,91 @@ function parseBridgeHistoryOutput(raw) {
         return null;
     }
 }
+function parseNormalizeBridgeHistorySeedOutput(raw) {
+    return parseBridgeHistoryOutput(raw);
+}
+function parseResolveResponsesBridgeToolsOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const output = {};
+        if (Array.isArray(row.mergedTools)) {
+            output.mergedTools = row.mergedTools.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+        }
+        if (row.request && typeof row.request === 'object' && !Array.isArray(row.request)) {
+            output.request = row.request;
+        }
+        return output;
+    }
+    catch {
+        return null;
+    }
+}
+function parseResolveResponsesRequestBridgeDecisionsOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (typeof row.forceWebSearch !== 'boolean') {
+            return null;
+        }
+        const output = {
+            forceWebSearch: row.forceWebSearch
+        };
+        if (row.toolCallIdStyle === 'fc' || row.toolCallIdStyle === 'preserve') {
+            output.toolCallIdStyle = row.toolCallIdStyle;
+        }
+        if (row.historySeed && typeof row.historySeed === 'object' && !Array.isArray(row.historySeed)) {
+            const serialized = JSON.stringify(row.historySeed);
+            const parsedHistory = parseBridgeHistoryOutput(serialized);
+            if (!parsedHistory) {
+                return null;
+            }
+            output.historySeed = parsedHistory;
+        }
+        return output;
+    }
+    catch {
+        return null;
+    }
+}
+function parseFilterBridgeInputForUpstreamOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        if (!Array.isArray(row.input)) {
+            return null;
+        }
+        const input = row.input.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+        return { input };
+    }
+    catch {
+        return null;
+    }
+}
+function parsePrepareResponsesRequestEnvelopeOutput(raw) {
+    const parsed = parseRecord(raw);
+    if (!parsed || !parsed.request || typeof parsed.request !== 'object' || Array.isArray(parsed.request)) {
+        return null;
+    }
+    return { request: parsed.request };
+}
+function parseAppendLocalImageBlockOnLatestUserInputOutput(raw) {
+    const parsed = parseRecord(raw);
+    if (!parsed || !Array.isArray(parsed.messages)) {
+        return null;
+    }
+    const messages = parsed.messages.filter((entry) => Boolean(entry) && typeof entry === 'object' && !Array.isArray(entry));
+    return { messages };
+}
 function parseBridgeInputToChatOutput(raw) {
     const parsed = parseRecord(raw);
     if (!parsed || !Array.isArray(parsed.messages)) {
@@ -443,6 +528,216 @@ export function buildBridgeHistoryWithNative(input) {
         return fail(reason);
     }
 }
+export function normalizeBridgeHistorySeedWithNative(seed) {
+    const capability = 'normalizeBridgeHistorySeedJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify(seed);
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseNormalizeBridgeHistorySeedOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resolveResponsesBridgeToolsWithNative(input) {
+    const capability = 'resolveResponsesBridgeToolsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        originalTools: input.originalTools,
+        chatTools: input.chatTools,
+        hasServerSideWebSearch: input.hasServerSideWebSearch,
+        passthroughKeys: input.passthroughKeys,
+        request: input.request
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseResolveResponsesBridgeToolsOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function resolveResponsesRequestBridgeDecisionsWithNative(input) {
+    const capability = 'resolveResponsesRequestBridgeDecisionsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        context: input.context,
+        requestMetadata: input.requestMetadata,
+        envelopeMetadata: input.envelopeMetadata,
+        bridgeMetadata: input.bridgeMetadata,
+        extraBridgeHistory: input.extraBridgeHistory
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseResolveResponsesRequestBridgeDecisionsOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function filterBridgeInputForUpstreamWithNative(input) {
+    const capability = 'filterBridgeInputForUpstreamJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        input: input.input,
+        allowToolCallId: input.allowToolCallId
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseFilterBridgeInputForUpstreamOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function prepareResponsesRequestEnvelopeWithNative(input) {
+    const capability = 'prepareResponsesRequestEnvelopeJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        request: input.request,
+        contextSystemInstruction: input.contextSystemInstruction,
+        extraSystemInstruction: input.extraSystemInstruction,
+        metadataSystemInstruction: input.metadataSystemInstruction,
+        combinedSystemInstruction: input.combinedSystemInstruction,
+        reasoningInstructionSegments: input.reasoningInstructionSegments,
+        contextParameters: input.contextParameters,
+        chatParameters: input.chatParameters,
+        metadataParameters: input.metadataParameters,
+        contextStream: input.contextStream,
+        metadataStream: input.metadataStream,
+        chatStream: input.chatStream,
+        chatParametersStream: input.chatParametersStream,
+        contextInclude: input.contextInclude,
+        metadataInclude: input.metadataInclude,
+        contextStore: input.contextStore,
+        metadataStore: input.metadataStore,
+        stripHostFields: input.stripHostFields,
+        contextToolChoice: input.contextToolChoice,
+        metadataToolChoice: input.metadataToolChoice,
+        contextParallelToolCalls: input.contextParallelToolCalls,
+        metadataParallelToolCalls: input.metadataParallelToolCalls,
+        contextResponseFormat: input.contextResponseFormat,
+        metadataResponseFormat: input.metadataResponseFormat,
+        contextServiceTier: input.contextServiceTier,
+        metadataServiceTier: input.metadataServiceTier,
+        contextTruncation: input.contextTruncation,
+        metadataTruncation: input.metadataTruncation,
+        contextMetadata: input.contextMetadata,
+        metadataMetadata: input.metadataMetadata
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parsePrepareResponsesRequestEnvelopeOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function appendLocalImageBlockOnLatestUserInputWithNative(input) {
+    const capability = 'appendLocalImageBlockOnLatestUserInputJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({
+        messages: input.messages
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseAppendLocalImageBlockOnLatestUserInputOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function applyBridgeNormalizeHistoryWithNative(input) {
     const capability = 'applyBridgeNormalizeHistoryJson';
     const fail = (reason) => failNativeRequired(capability, reason);

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.d.ts

@@ -52,6 +52,7 @@ export interface NativeReqOutboundCompatAdapterContextInput {
     routeId?: string;
     capturedChatRequest?: JsonObject;
     deepseek?: Record<string, unknown>;
+    claudeCode?: Record<string, unknown>;
     estimatedInputTokens?: number;
     modelId?: string;
     clientModelId?: string;

package/dist/router/virtual-router/engine-selection/native-hub-pipeline-resp-semantics.d.ts

@@ -16,6 +16,13 @@ export declare function normalizeResponsesUsageWithNative(usageRaw: unknown): un
 export declare function buildResponsesPayloadFromChatWithNative(payload: unknown, context?: {
     requestId?: string;
     toolsRaw?: unknown[];
+    metadata?: Record<string, unknown>;
+    parallelToolCalls?: unknown;
+    toolChoice?: unknown;
+    include?: unknown;
+    store?: unknown;
+    stripHostManagedFields?: boolean;
+    sourceForRetention?: Record<string, unknown>;
 }): Record<string, unknown>;
 export declare function looksLikeJsonStreamPrefixWithNative(firstChunkText: string): boolean;
 export declare function parseJsonObjectCandidateWithNative(rawText: string, maxBytes: number): Record<string, unknown> | null;

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

@@ -529,7 +529,14 @@ export function buildResponsesPayloadFromChatWithNative(payload, context = {}) {
     const payloadJson = safeStringify(payload);
     const contextJson = safeStringify({
         requestId: context.requestId,
-        toolsRaw: Array.isArray(context.toolsRaw) ? context.toolsRaw : []
+        toolsRaw: Array.isArray(context.toolsRaw) ? context.toolsRaw : [],
+        metadata: context.metadata,
+        parallelToolCalls: context.parallelToolCalls,
+        toolChoice: context.toolChoice,
+        include: context.include,
+        store: context.store,
+        stripHostManagedFields: context.stripHostManagedFields,
+        sourceForRetention: context.sourceForRetention
     });
     if (!payloadJson || !contextJson) {
         return fail('json stringify failed');