@jsonstudio/llms 0.6.2979 → 0.6.3238

package/dist/conversion/args-mapping.js

@@ -0,0 +1,8 @@
+import { normalizeArgsBySchemaWithNative, normalizeToolsWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function normalizeArgsBySchema(input, schema) {
+    return normalizeArgsBySchemaWithNative(input, schema);
+}
+// Tools normalizer (OpenAI-like)
+export function normalizeTools(tools) {
+    return normalizeToolsWithNative(tools);
+}

package/dist/conversion/{shared/bridge-actions.js → bridge-actions.js}

@@ -1,4 +1,4 @@
-import { applyBridgeCaptureToolResultsWithNative, applyBridgeEnsureToolPlaceholdersWithNative, applyBridgeNormalizeHistoryWithNative, applyBridgeNormalizeToolIdentifiersWithNative, applyBridgeEnsureSystemInstructionWithNative, applyBridgeInjectSystemInstructionWithNative, applyBridgeMetadataActionWithNative, applyBridgeReasoningExtractWithNative, applyBridgeResponsesOutputReasoningWithNative, ensureBridgeOutputFieldsWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
+import { applyBridgeCaptureToolResultsWithNative, applyBridgeEnsureToolPlaceholdersWithNative, applyBridgeNormalizeHistoryWithNative, applyBridgeNormalizeToolIdentifiersWithNative, applyBridgeEnsureSystemInstructionWithNative, applyBridgeInjectSystemInstructionWithNative, applyBridgeMetadataActionWithNative, applyBridgeReasoningExtractWithNative, applyBridgeResponsesOutputReasoningWithNative, ensureBridgeOutputFieldsWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 const registry = new Map();
 export function registerBridgeAction(name, action) {
     registry.set(name, action);
@@ -117,6 +117,7 @@ const extractReasoningAction = (ctx) => {
 registerBridgeAction('messages.inject-system-instruction', injectSystemInstructionAction);
 registerBridgeAction('reasoning.extract', extractReasoningAction);
 registerBridgeAction('tools.ensure-response-placeholders', ensureToolResponsePlaceholders);
+// (intentionally no-op: capture handled in responses-format normalization)
 const ensureSystemInstructionAction = (ctx) => {
     const messages = ensureMessagesArray(ctx.state);
     const normalized = applyBridgeEnsureSystemInstructionWithNative({

package/dist/conversion/{shared/bridge-id-utils.js → bridge-id-utils.js}

@@ -1,4 +1,4 @@
-import { clampResponsesInputItemIdWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { clampResponsesInputItemIdWithNative, normalizeFunctionCallIdWithNative, normalizeFunctionCallOutputIdWithNative, normalizeResponsesCallIdWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 export function normalizeFunctionCallId(options) {
     return normalizeFunctionCallIdWithNative(options);
 }

package/dist/conversion/{shared/bridge-instructions.js → bridge-instructions.js}

@@ -1,4 +1,4 @@
-import { sanitizeReasoningTaggedTextWithNative } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { sanitizeReasoningTaggedTextWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
 function collectTextFromBlocks(blocks) {
     const parts = [];
     for (const block of blocks) {

package/dist/conversion/{shared/bridge-message-utils.d.ts → bridge-message-utils.d.ts}

@@ -1,4 +1,4 @@
-import type { BridgeInputItem } from './bridge-message-types.js';
+import type { BridgeInputItem } from './types/bridge-message-types.js';
 export declare function coerceBridgeRole(role: unknown): string;
 export declare function serializeToolArguments(argsStringOrObj: unknown, _functionName: string | undefined, _tools: unknown): string;
 export declare function serializeToolOutput(entry: BridgeInputItem): string | null;

package/dist/conversion/{shared/bridge-message-utils.js → bridge-message-utils.js}

@@ -1,5 +1,6 @@
-import { normalizeChatMessageContent } from './chat-output-normalizer.js';
-import { normalizeFunctionCallIdWithNative as normalizeFunctionCallId, normalizeFunctionCallOutputIdWithNative as normalizeFunctionCallOutputId, repairArgumentsToStringWithNative as repairToolArguments } from '../../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { normalizeChatMessageContent } from './shared/chat-output-normalizer.js';
+import { normalizeFunctionCallIdWithNative as normalizeFunctionCallId, repairArgumentsToStringWithNative as repairToolArguments } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+import { buildBridgeHistoryWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-action-semantics.js';
 function ensureAssistantToolCallIdentity(call, fallbackId) {
     const resolved = (typeof call.id === 'string' && call.id.trim().length ? call.id.trim() : undefined) ??
         (typeof call.tool_call_id === 'string' && call.tool_call_id.trim().length
@@ -141,153 +142,8 @@ function extractUserTextFromEntry(entry) {
 }
 export function convertMessagesToBridgeInput(options) {
     const { messages, tools } = options;
-    const input = [];
-    const systemParts = [];
-    const originalSystemMessages = [];
-    let latestUserInstruction = null;
-    const pendingToolCallIds = [];
-    const knownToolCallIds = new Set();
-    for (const m of messages) {
-        if (!m || typeof m !== 'object')
-            continue;
-        const role = coerceBridgeRole(m.role || 'user');
-        const content = m.content;
-        const collectedText = collectText(content);
-        const mediaBlocks = extractMediaBlocksFromContent(content);
-        const text = role === 'system' ? collectedText : collectedText.trim();
-        if (role === 'system') {
-            if (collectedText && collectedText.length) {
-                originalSystemMessages.push(collectedText);
-                systemParts.push(collectedText);
-            }
-            continue;
-        }
-        if (role === 'tool') {
-            const rawToolId = m.tool_call_id ||
-                m.call_id ||
-                m.tool_use_id ||
-                m.id ||
-                undefined;
-            let callId = typeof rawToolId === 'string' && rawToolId.trim().length ? rawToolId.trim() : undefined;
-            if (callId && knownToolCallIds.has(callId)) {
-                const idx = pendingToolCallIds.indexOf(callId);
-                if (idx >= 0)
-                    pendingToolCallIds.splice(idx, 1);
-            }
-            if (!callId && pendingToolCallIds.length) {
-                callId = pendingToolCallIds.shift();
-            }
-            if (!callId) {
-                callId = normalizeFunctionCallId({
-                    callId,
-                    fallback: `fc_call_${input.length + 1}`
-                });
-            }
-            knownToolCallIds.add(callId);
-            const normalizedId = normalizeFunctionCallOutputId({
-                callId,
-                fallback: `fc_tool_${input.length + 1}`
-            });
-            const entry = {
-                type: 'function_call_output',
-                id: normalizedId,
-                call_id: callId,
-                output: typeof text === 'string' ? text : ''
-            };
-            input.push(entry);
-            continue;
-        }
-        const toolCalls = Array.isArray(m.tool_calls) ? m.tool_calls : [];
-        if (toolCalls.length) {
-            for (const tc of toolCalls) {
-                try {
-                    const rawIdCandidate = (typeof tc?.id === 'string' && tc.id.trim().length ? tc.id.trim() : undefined) ??
-                        (typeof tc?.call_id === 'string' && tc.call_id.trim().length ? tc.call_id.trim() : undefined);
-                    const callId = rawIdCandidate ?? normalizeFunctionCallId({
-                        callId: rawIdCandidate,
-                        fallback: `fc_call_${input.length + 1}`
-                    });
-                    const fn = tc?.function || {};
-                    const name = typeof fn?.name === 'string' ? String(fn.name) : 'tool';
-                    const argsRaw = fn?.arguments;
-                    const args = typeof argsRaw === 'string'
-                        ? argsRaw
-                        : serializeToolArguments(argsRaw, name, tools);
-                    const entry = {
-                        type: 'function_call',
-                        id: callId,
-                        call_id: callId,
-                        name,
-                        arguments: args
-                    };
-                    input.push(entry);
-                    knownToolCallIds.add(callId);
-                    pendingToolCallIds.push(callId);
-                }
-                catch {
-                    // ignore malformed tool_call
-                }
-            }
-            continue;
-        }
-        if (typeof text === 'string' || mediaBlocks.length) {
-            const tRole = role === 'assistant' ? 'output_text' : 'input_text';
-            const blocks = [];
-            if (typeof text === 'string' && text.length) {
-                blocks.push({ type: tRole, text });
-            }
-            for (const media of mediaBlocks) {
-                const block = media.kind === 'video'
-                    ? {
-                        type: 'input_video',
-                        video_url: media.url
-                    }
-                    : {
-                        type: 'input_image',
-                        image_url: media.url
-                    };
-                if (media.detail) {
-                    block.detail = media.detail;
-                }
-                ;
-                blocks.push(block);
-            }
-            if (blocks.length) {
-                const entry = {
-                    role,
-                    content: blocks
-                };
-                input.push(entry);
-            }
-            if (role === 'user') {
-                const trimmed = typeof text === 'string' ? text.trim() : '';
-                if (trimmed.length) {
-                    latestUserInstruction = trimmed;
-                }
-            }
-        }
-    }
-    if (!latestUserInstruction) {
-        for (let i = input.length - 1; i >= 0; i -= 1) {
-            const entry = input[i];
-            const roleSource = entry?.role ?? entry?.message?.role;
-            const role = typeof roleSource === 'string' ? roleSource.toLowerCase() : '';
-            if (role !== 'user')
-                continue;
-            const text = extractUserTextFromEntry(entry);
-            if (text) {
-                latestUserInstruction = text;
-                break;
-            }
-        }
-    }
-    const combinedSystemInstruction = systemParts.join('\n\n').trim();
-    return {
-        input,
-        combinedSystemInstruction: combinedSystemInstruction.length ? combinedSystemInstruction : undefined,
-        latestUserInstruction: latestUserInstruction || undefined,
-        originalSystemMessages
-    };
+    const native = buildBridgeHistoryWithNative({ messages, tools });
+    return native;
 }
 function defaultNormalizeFunctionName(raw) {
     if (typeof raw !== 'string')

package/dist/conversion/{shared/bridge-metadata.js → bridge-metadata.js}

@@ -1,5 +1,5 @@
 export const BRIDGE_RAW_SYSTEM_METADATA_KEY = '__rcc_raw_system';
-import { normalizeProviderProtocolTokenWithNative } from '../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
+import { normalizeProviderProtocolTokenWithNative } from '../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
 export function resolveBridgeMetadataNativeProtocol() {
     return normalizeProviderProtocolTokenWithNative('openai-responses') ?? 'openai-responses';
 }

package/dist/conversion/{shared/bridge-policies.js → bridge-policies.js}

@@ -1,4 +1,4 @@
-import { resolveBridgePolicyActionsWithNative, resolveBridgePolicyWithNative } from '../../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
+import { resolveBridgePolicyActionsWithNative, resolveBridgePolicyWithNative } from '../router/virtual-router/engine-selection/native-hub-bridge-policy-semantics.js';
 export function resolveBridgePolicy(options) {
     const resolved = resolveBridgePolicyWithNative(options);
     if (!resolved) {

package/dist/conversion/codecs/gemini-openai-codec.js

@@ -1,10 +1,10 @@
-import { createBridgeActionState, runBridgeActionPipeline } from '../shared/bridge-actions.js';
-import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-policies.js';
+import { createBridgeActionState, runBridgeActionPipeline } from '../bridge-actions.js';
+import { resolveBridgePolicy, resolvePolicyActions } from '../bridge-policies.js';
 import { normalizeChatMessageContent } from '../shared/chat-output-normalizer.js';
 import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
 import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
-import { ProviderProtocolError } from '../shared/errors.js';
+import { ProviderProtocolError } from '../provider-protocol-error.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -431,10 +431,18 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     if (toolOutputs.length > 0) {
         chatResp.tool_outputs = toolOutputs;
     }
+    const localReasoning = reasoningParts.length
+        ? {
+            content: reasoningParts.map((text) => ({ type: 'reasoning_text', text }))
+        }
+        : undefined;
     const preservedReasoning = consumeResponsesReasoning(chatResp.id);
-    if (preservedReasoning && preservedReasoning.length) {
+    if (preservedReasoning) {
         chatResp.__responses_reasoning = preservedReasoning;
     }
+    else if (localReasoning) {
+        chatResp.__responses_reasoning = localReasoning;
+    }
     const preservedOutputMeta = consumeResponsesOutputTextMeta(chatResp.id);
     if (preservedOutputMeta) {
         chatResp.__responses_output_text_meta = preservedOutputMeta;
@@ -521,9 +529,20 @@ export function buildGeminiFromOpenAIChat(chatResp) {
     if (contentText && contentText.length) {
         parts.push({ text: contentText });
     }
-    const reasoningText = typeof msg?.reasoning_content === 'string' && msg.reasoning_content.trim().length
-        ? String(msg.reasoning_content).trim()
-        : undefined;
+    const preservedReasoning = chatResp?.__responses_reasoning;
+    const preservedContent = Array.isArray(preservedReasoning?.content)
+        ? preservedReasoning?.content?.map((entry) => String(entry.text ?? '')).filter((text) => text.trim().length > 0)
+        : [];
+    const preservedSummary = Array.isArray(preservedReasoning?.summary)
+        ? preservedReasoning?.summary?.map((entry) => String(entry.text ?? '')).filter((text) => text.trim().length > 0)
+        : [];
+    const reasoningText = preservedContent.length > 0
+        ? preservedContent.join('\n')
+        : (preservedSummary.length > 0
+            ? preservedSummary.join('\n')
+            : (typeof msg?.reasoning_content === 'string' && msg.reasoning_content.trim().length
+                ? String(msg.reasoning_content).trim()
+                : undefined));
     if (reasoningText) {
         parts.push({ reasoning: reasoningText });
     }
@@ -613,7 +632,7 @@ export function buildGeminiFromOpenAIChat(chatResp) {
     }
     if (Object.keys(usageMetadata).length > 0)
         out.usageMetadata = usageMetadata;
-    if (Array.isArray(chatResp?.__responses_reasoning)) {
+    if (chatResp?.__responses_reasoning) {
         registerResponsesReasoning(responseId, chatResp.__responses_reasoning);
     }
     if (chatResp?.__responses_output_text_meta) {

package/dist/conversion/codecs/responses-openai-codec.js

@@ -160,7 +160,7 @@ export class ResponsesOpenAIConversionCodec {
         // No fallback append here: pairing must be produced upstream or by standard bridge mapping.
         // Debug snapshot after mapping to Responses JSON (non-stream)
         try {
-            const { writeSnapshotViaHooks } = await import('../shared/snapshot-hooks.js');
+            const { writeSnapshotViaHooks } = await import('../snapshot-utils.js');
             await writeSnapshotViaHooks({
                 endpoint: '/v1/responses',
                 stage: 'response_mapped_json',

package/dist/conversion/{shared/compaction-detect.d.ts → compaction-detect.d.ts}

@@ -1,2 +1,2 @@
-import type { JsonObject } from '../hub/types/json.js';
+import type { JsonObject } from './hub/types/json.js';
 export declare function isCompactionRequest(payload: JsonObject): boolean;

package/dist/conversion/compaction-detect.js

@@ -0,0 +1,4 @@
+import { isCompactionRequestWithNative } from '../router/virtual-router/engine-selection/native-shared-conversion-semantics.js';
+export function isCompactionRequest(payload) {
+    return isCompactionRequestWithNative(payload);
+}

package/dist/conversion/compat/actions/apply-patch-fixer.js

@@ -1,5 +1,5 @@
-import { registerBridgeAction } from '../../shared/bridge-actions.js';
-import { ensureMessagesArray } from '../../shared/bridge-message-utils.js';
+import { registerBridgeAction } from '../../bridge-actions.js';
+import { ensureMessagesArray } from '../../bridge-message-utils.js';
 import { validateToolCall } from '../../../tools/tool-registry.js';
 const fixApplyPatchAction = (ctx) => {
     const messages = ensureMessagesArray(ctx.state);

package/dist/conversion/compat/actions/deepseek-web-response.d.ts

@@ -3,7 +3,6 @@ import type { JsonObject } from '../../hub/types/json.js';
 import { type TextMarkupNormalizeOptions } from '../../shared/text-markup-normalizer.js';
 export interface DeepSeekWebResponseConfig {
     strictToolRequired?: boolean;
-    textToolFallback?: boolean;
     textNormalizer?: TextMarkupNormalizeOptions;
 }
 export declare function applyDeepSeekWebResponseTransform(payload: JsonObject, adapterContext?: AdapterContext, config?: DeepSeekWebResponseConfig): JsonObject;