@jsonstudio/llms 0.6.3275 → 0.6.3405

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

@@ -38,6 +38,20 @@ function parseOutput(raw) {
         return null;
     }
 }
+function parseEnsureMessagesArrayOutput(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return null;
+        }
+        const row = parsed;
+        const messages = Array.isArray(row.messages) ? row.messages : [];
+        return { messages };
+    }
+    catch {
+        return null;
+    }
+}
 function parseBridgeHistoryOutput(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -68,6 +82,14 @@ function parseBridgeHistoryOutput(raw) {
         return null;
     }
 }
+function parseBridgeInputToChatOutput(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 parseBridgeActionState(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -517,6 +539,180 @@ export function applyBridgeEnsureToolPlaceholdersWithNative(input) {
         return fail(reason);
     }
 }
+export function convertBridgeInputToChatMessagesWithNative(input) {
+    const capability = 'convertBridgeInputToChatMessagesJson';
+    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,
+        tools: input.tools,
+        toolResultFallbackText: input.toolResultFallbackText,
+        normalizeFunctionName: input.normalizeFunctionName
+    });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseBridgeInputToChatOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function coerceBridgeRoleWithNative(role) {
+    const capability = 'coerceBridgeRoleJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ role });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function serializeToolOutputWithNative(input) {
+    const capability = 'serializeToolOutputJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ output: input.output });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string') {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' || parsed === null ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function serializeToolArgumentsWithNative(input) {
+    const capability = 'serializeToolArgumentsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ args: input.args });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = JSON.parse(raw);
+        return typeof parsed === 'string' ? parsed : fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function ensureMessagesArrayWithNative(input) {
+    const capability = 'ensureMessagesArrayJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ state: input.state });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseEnsureMessagesArrayOutput(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
+export function harvestToolsWithNative(input) {
+    const capability = 'harvestToolsJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ signal: input.signal, context: input.context });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        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 (!Array.isArray(row.deltaEvents)) {
+            return fail('invalid payload');
+        }
+        return row;
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function ensureBridgeOutputFieldsWithNative(input) {
     const capability = 'ensureBridgeOutputFieldsJson';
     const fail = (reason) => failNativeRequired(capability, reason);

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

@@ -13,6 +13,7 @@ export interface NativeReqInboundChatToStandardizedInput {
     endpoint: string;
     requestId?: string;
 }
+export declare function pruneChatRequestPayloadWithNative(payload: Record<string, unknown>, preserveStreamField?: boolean): Record<string, unknown>;
 export declare function sanitizeReqInboundFormatEnvelopeWithNative<T>(candidate: unknown): T;
 export declare function mapReqInboundResumeToolOutputsDetailedWithNative(responsesResume: unknown): Array<{
     tool_call_id: string;

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

@@ -87,6 +87,33 @@ function replaceRecord(target, source) {
     }
     Object.assign(target, source);
 }
+export function pruneChatRequestPayloadWithNative(payload, preserveStreamField = false) {
+    const capability = 'pruneChatRequestPayloadJson';
+    const fail = (reason) => failNativeRequired(capability, reason);
+    if (isNativeDisabledByEnv()) {
+        return fail('native disabled');
+    }
+    const fn = readNativeFunction(capability);
+    if (!fn) {
+        return fail();
+    }
+    const payloadJson = safeStringify({ payload, preserveStreamField });
+    if (!payloadJson) {
+        return fail('json stringify failed');
+    }
+    try {
+        const raw = fn(payloadJson);
+        if (typeof raw !== 'string' || !raw) {
+            return fail('empty result');
+        }
+        const parsed = parseRecord(raw);
+        return parsed ?? fail('invalid payload');
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error ?? 'unknown');
+        return fail(reason);
+    }
+}
 export function sanitizeReqInboundFormatEnvelopeWithNative(candidate) {
     return sanitizeFormatEnvelopeWithNative(candidate);
 }

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

@@ -51,6 +51,33 @@ const REQUIRED_NATIVE_EXPORTS = [
     'applyBridgeCaptureToolResultsJson',
     'applyBridgeNormalizeToolIdentifiersJson',
     'applyBridgeEnsureToolPlaceholdersJson',
+    'convertBridgeInputToChatMessagesJson',
+    'coerceBridgeRoleJson',
+    'harvestToolsJson',
+    'serializeToolArgumentsJson',
+    'pruneChatRequestPayloadJson',
+    'enforceToolCallIdStyleJson',
+    'transformToolCallIdJson',
+    'createToolCallIdTransformerJson',
+    'extractToolCallIdJson',
+    'normalizeIdValueJson',
+    'extractStreamingToolCallsJson',
+    'chunkStringJson',
+    'flattenByCommaJson',
+    'packShellArgsJson',
+    'splitCommandStringJson',
+    'repairFindMetaJson',
+    'removeTrailingUnsignedThinkingBlocksJson',
+    'filterInvalidThinkingBlocksJson',
+    'sanitizeThinkingBlockJson',
+    'hasValidThoughtSignatureJson',
+    'serializeToolOutputJson',
+    'ensureMessagesArrayJson',
+    'normalizeReasoningInChatPayloadJson',
+    'normalizeReasoningInResponsesPayloadJson',
+    'normalizeReasoningInGeminiPayloadJson',
+    'normalizeReasoningInAnthropicPayloadJson',
+    'normalizeReasoningInOpenAIPayloadJson',
     'buildContinueExecutionOperationsJson',
     'buildDueReminderUserMessageJson',
     'buildGovernedFilterPayloadJson',
@@ -67,8 +94,15 @@ const REQUIRED_NATIVE_EXPORTS = [
     'mapOpenaiChatToChatJson',
     'mapOpenaiChatFromChatJson',
     'mapChatToolsToBridgeJson',
+    'bridgeToolToChatDefinitionJson',
+    'chatToolToBridgeDefinitionJson',
+    'mapBridgeToolsToChatWithOptionsJson',
+    'mapChatToolsToBridgeWithOptionsJson',
+    'collectToolCallsFromResponsesJson',
+    'resolveFinishReasonJson',
     'captureReqInboundResponsesContextSnapshotJson',
     'computeQuotaBucketsJson',
+    'extractReasoningSegmentsJson',
     'deserializeStopMessageStateJson',
     'detectProviderResponseShapeJson',
     'extractClockReminderDirectivesJson',
@@ -135,6 +169,15 @@ const REQUIRED_NATIVE_EXPORTS = [
     'normalizeChatResponseReasoningToolsJson',
     'normalizeBridgeToolCallIdsJson',
     'normalizeChatMessageContentJson',
+    'validateResponsePayloadJson',
+    'normalizeResponsePayloadJson',
+    'applyResponseBlacklistJson',
+    'normalizeToolCallIdsJson',
+    'normalizeResponsesToolCallIdsJson',
+    'resolveToolCallIdStyleJson',
+    'stripInternalToolingMetadataJson',
+    'enforceLmstudioResponsesFcToolCallIdsJson',
+    'applyRequestRulesJson',
     'normalizeArgsBySchemaJson',
     'normalizeToolsJson',
     'normalizeFunctionCallIdJson',
@@ -206,6 +249,8 @@ const REQUIRED_NATIVE_EXPORTS = [
     'deriveToolCallKeyJson',
     'extractToolCallsFromReasoningTextJson',
     'mapReasoningContentToResponsesOutputJson',
+    'validateToolArgumentsJson',
+    'repairToolCallsJson',
     'isImagePathJson',
     'resolveServerToolFollowupSnapshotJson',
     'resolveSseStreamModeJson',

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

@@ -4,10 +4,56 @@ export declare function extractToolCallsFromReasoningTextWithNative(text: string
     cleanedText: string;
     toolCalls: Array<Record<string, unknown>>;
 };
-export declare function mapChatToolsToBridgeWithNative(rawTools: unknown): Array<Record<string, unknown>>;
+export declare function extractReasoningSegmentsWithNative(source: string): {
+    text: string;
+    segments: string[];
+};
+export declare function normalizeAssistantTextToToolCallsWithNative(message: Record<string, unknown>, options?: Record<string, unknown>): Record<string, unknown>;
+export declare function normalizeReasoningInChatPayloadWithNative(payload: unknown): unknown;
+export declare function normalizeReasoningInResponsesPayloadWithNative(payload: unknown, options?: Record<string, unknown>): unknown;
+export declare function normalizeReasoningInGeminiPayloadWithNative(payload: unknown): unknown;
+export declare function normalizeReasoningInAnthropicPayloadWithNative(payload: unknown): unknown;
+export declare function normalizeReasoningInOpenAIPayloadWithNative(payload: unknown): unknown;
+export declare function bridgeToolToChatDefinitionWithNative(tool: Record<string, unknown>, options?: {
+    sanitizeMode?: string;
+}): Record<string, unknown> | null;
+export declare function chatToolToBridgeDefinitionWithNative(tool: Record<string, unknown>, options?: {
+    sanitizeMode?: string;
+}): Record<string, unknown> | null;
+export declare function mapBridgeToolsToChatWithNative(rawTools: unknown, options?: {
+    sanitizeMode?: string;
+}): Array<Record<string, unknown>>;
+export declare function mapChatToolsToBridgeWithNative(rawTools: unknown, options?: {
+    sanitizeMode?: string;
+}): Array<Record<string, unknown>>;
+export declare function collectToolCallsFromResponsesWithNative(response: Record<string, unknown>): Array<Record<string, unknown>>;
+export declare function resolveFinishReasonWithNative(response: Record<string, unknown>, toolCalls: Array<Record<string, unknown>>): string;
+export declare function hasValidThoughtSignatureWithNative(block: unknown, options?: Record<string, unknown>): boolean;
+export declare function sanitizeThinkingBlockWithNative(block: unknown): Record<string, unknown>;
+export declare function filterInvalidThinkingBlocksWithNative(messages: unknown, options?: Record<string, unknown>): unknown[];
+export declare function removeTrailingUnsignedThinkingBlocksWithNative(blocks: unknown, options?: Record<string, unknown>): unknown[];
 export declare function sanitizeReasoningTaggedTextWithNative(text: string): string;
 export declare function ensureBridgeInstructionsWithNative(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function repairFindMetaWithNative(script: string): string;
+export declare function splitCommandStringWithNative(input: string): string[];
+export declare function packShellArgsWithNative(input: Record<string, unknown>): Record<string, unknown>;
+export declare function flattenByCommaWithNative(items: string[]): string[];
+export declare function chunkStringWithNative(s: string, minParts?: number, maxParts?: number, targetChunk?: number): string[];
 export declare function deriveToolCallKeyWithNative(call: Record<string, unknown> | null | undefined): string | null;
+export declare function normalizeIdValueWithNative(value: unknown, forceGenerate?: boolean): string;
+export declare function extractToolCallIdWithNative(obj: unknown): string | undefined;
+export declare function createToolCallIdTransformerWithNative(style: string): Record<string, unknown>;
+export declare function transformToolCallIdWithNative(state: Record<string, unknown>, id: string): {
+    id: string;
+    state: Record<string, unknown>;
+};
+export declare function enforceToolCallIdStyleWithNative(messages: unknown[], state: Record<string, unknown>): {
+    messages: unknown[];
+    state: Record<string, unknown>;
+};
+export declare function normalizeResponsesToolCallIdsWithNative(payload: unknown): Record<string, unknown> | null;
+export declare function resolveToolCallIdStyleWithNative(metadata: unknown): string;
+export declare function stripInternalToolingMetadataWithNative(metadata: unknown): Record<string, unknown> | null;
 export declare function buildProviderProtocolErrorWithNative(input: {
     message: string;
     code: string;
@@ -76,7 +122,30 @@ export declare function mapReasoningContentToResponsesOutputWithNative(reasoning
     type: 'reasoning';
     content: string;
 }>;
+export declare function validateToolArgumentsWithNative(toolName: string | undefined, args: unknown): {
+    repaired: string;
+    success: boolean;
+    error?: string;
+};
+export declare function repairToolCallsWithNative(toolCalls: Array<{
+    name?: string;
+    arguments?: unknown;
+}>): Array<{
+    name?: string;
+    arguments: string;
+}>;
 export declare function isImagePathWithNative(pathValue: unknown): boolean;
+export declare function extractStreamingToolCallsWithNative(input: {
+    buffer: string;
+    text: string;
+    idPrefix: string;
+    idCounter: number;
+    nowMs: number;
+}): {
+    buffer: string;
+    idCounter: number;
+    toolCalls: Array<Record<string, unknown>>;
+};
 export declare function isCompactionRequestWithNative(payload: unknown): boolean;
 export declare function encodeMetadataPassthroughWithNative(parameters: unknown, prefix: string, keys: readonly string[]): Record<string, string> | undefined;
 export declare function extractMetadataPassthroughWithNative(metadataField: unknown, prefix: string, keys: readonly string[]): {