@jsonstudio/llms 0.6.1462 → 0.6.1733

package/dist/conversion/compat/actions/iflow-response-body-unwrap.js

@@ -0,0 +1,140 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+function looksLikeKnownProviderResponseShape(value) {
+    if (!isRecord(value))
+        return false;
+    if (Array.isArray(value.choices))
+        return true; // openai-chat
+    if (Array.isArray(value.output) || value.object === 'response')
+        return true; // openai-responses
+    if (typeof value.type === 'string' && String(value.type).toLowerCase() === 'message' && Array.isArray(value.content)) {
+        return true; // anthropic-messages
+    }
+    if (Array.isArray(value.candidates))
+        return true; // gemini-chat
+    return false;
+}
+function stripJsonTextPrefix(text) {
+    let out = String(text || '').trimStart();
+    // anti-XSSI prefix: ")]}',\n{...}"
+    out = out.replace(/^\)\]\}',?\s*/u, '');
+    // single-line SSE-like wrapper sometimes returned as plain text
+    out = out.replace(/^data:\s*/iu, '');
+    return out;
+}
+function tryParseJsonRecord(text) {
+    try {
+        const trimmed = stripJsonTextPrefix(text).trim();
+        if (!trimmed)
+            return null;
+        if (trimmed.length > 10 * 1024 * 1024)
+            return null;
+        const first = trimmed.charAt(0);
+        const last = trimmed.charAt(trimmed.length - 1);
+        if ((first !== '{' && first !== '[') || (last !== '}' && last !== ']')) {
+            return null;
+        }
+        const parsed = JSON.parse(trimmed);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function tryParseJsonRecordFromMaybeSseText(text) {
+    if (typeof text !== 'string') {
+        return null;
+    }
+    const raw = stripJsonTextPrefix(text);
+    const direct = tryParseJsonRecord(raw);
+    if (direct) {
+        return direct;
+    }
+    // Multi-line SSE text occasionally shows up as a plain string inside iFlow envelopes.
+    // Best-effort: parse the last valid `data:` JSON object chunk.
+    if (raw.length > 10 * 1024 * 1024) {
+        return null;
+    }
+    const lines = raw.split(/\r?\n/u);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i]?.trim();
+        if (!line)
+            continue;
+        const lower = line.toLowerCase();
+        if (lower === 'data: [done]' || lower === '[done]')
+            continue;
+        const candidate = lower.startsWith('data:') ? line.slice(5).trim() : line;
+        const parsed = tryParseJsonRecord(candidate);
+        if (parsed) {
+            return parsed;
+        }
+    }
+    return null;
+}
+function tryUnwrapKnownShapeFromBody(value, depth) {
+    if (depth < 0)
+        return null;
+    if (looksLikeKnownProviderResponseShape(value)) {
+        return value;
+    }
+    if (isRecord(value)) {
+        // nested body/data wrappers
+        for (const key of ['data', 'body', 'response', 'payload', 'result']) {
+            const nested = value[key];
+            const unwrapped = tryUnwrapKnownShapeFromBody(nested, depth - 1);
+            if (unwrapped)
+                return unwrapped;
+        }
+        return null;
+    }
+    if (typeof value === 'string') {
+        const parsed = tryParseJsonRecord(value) ?? tryParseJsonRecordFromMaybeSseText(value);
+        if (!parsed)
+            return null;
+        return tryUnwrapKnownShapeFromBody(parsed, depth - 1);
+    }
+    return null;
+}
+/**
+ * iFlow compatibility: some iFlow backends wrap OpenAI-compatible payloads inside:
+ *   { status, msg, body, request_id }
+ * where `body` is the actual OpenAI-chat/Responses JSON (or a JSON string).
+ *
+ * This action unwraps `body` so hub semantic mapping and tool harvesting can proceed.
+ */
+export function unwrapIflowResponseBodyEnvelope(payload) {
+    try {
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+            return payload;
+        }
+        const root = structuredClone(payload);
+        // Only unwrap when it looks like the iFlow envelope.
+        if (!('body' in root) || !('status' in root) || !('msg' in root)) {
+            return root;
+        }
+        // If the root is already a known provider response, don't touch it.
+        if (looksLikeKnownProviderResponseShape(root)) {
+            return root;
+        }
+        const body = root.body;
+        const unwrapped = tryUnwrapKnownShapeFromBody(body, 6);
+        if (unwrapped) {
+            return unwrapped;
+        }
+        // Fallback: unwrap to `body` even when we can't yet recognize the nested shape.
+        // This avoids treating the iFlow envelope as the provider payload and improves
+        // downstream diagnostics / error handling.
+        if (isRecord(body)) {
+            return body;
+        }
+        if (typeof body === 'string') {
+            const parsed = tryParseJsonRecordFromMaybeSseText(body);
+            if (parsed) {
+                return parsed;
+            }
+        }
+        return root;
+    }
+    catch {
+        return payload;
+    }
+}

package/dist/conversion/compat/actions/lmstudio-responses-fc-ids.d.ts

@@ -0,0 +1,10 @@
+import type { JsonObject } from '../../hub/types/json.js';
+/**
+ * LM Studio compat:
+ * Some LM Studio OpenAI-Responses endpoints accept tool-call items but are picky about ids:
+ * - `call_id` should remain `call_*` (used to link tool outputs)
+ * - `id` for `function_call` / `function_call_output` should be `fc_*` (OpenAI Responses convention)
+ *
+ * We apply this in compat (profile: chat:lmstudio) to keep provider layer transport-only.
+ */
+export declare function enforceLmstudioResponsesFcToolCallIds(payload: JsonObject): JsonObject;

package/dist/conversion/compat/actions/lmstudio-responses-fc-ids.js

@@ -0,0 +1,59 @@
+import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../../shared/bridge-id-utils.js';
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeToCallId(raw, fallback) {
+    const rawStr = typeof raw === 'string' ? raw.trim() : '';
+    return normalizeResponsesCallId({ callId: rawStr || undefined, fallback });
+}
+/**
+ * LM Studio compat:
+ * Some LM Studio OpenAI-Responses endpoints accept tool-call items but are picky about ids:
+ * - `call_id` should remain `call_*` (used to link tool outputs)
+ * - `id` for `function_call` / `function_call_output` should be `fc_*` (OpenAI Responses convention)
+ *
+ * We apply this in compat (profile: chat:lmstudio) to keep provider layer transport-only.
+ */
+export function enforceLmstudioResponsesFcToolCallIds(payload) {
+    try {
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+            return payload;
+        }
+        const root = structuredClone(payload);
+        const input = root.input;
+        if (!Array.isArray(input) || input.length === 0) {
+            return root;
+        }
+        let callCounter = 0;
+        for (const item of input) {
+            if (!isRecord(item))
+                continue;
+            const type = typeof item.type === 'string' ? item.type.trim().toLowerCase() : '';
+            if (type !== 'function_call' && type !== 'function_call_output') {
+                continue;
+            }
+            const rawCallId = (item.call_id ?? item.tool_call_id ?? item.id);
+            const callId = normalizeToCallId(rawCallId, `call_${++callCounter}`);
+            item.call_id = callId;
+            if (type === 'function_call') {
+                const normalizedItemId = normalizeFunctionCallId({
+                    callId,
+                    fallback: `fc_${callId}`
+                });
+                item.id = normalizedItemId;
+                continue;
+            }
+            // function_call_output
+            const normalizedOutputId = normalizeFunctionCallOutputId({
+                callId,
+                fallback: typeof item.id === 'string' && item.id.trim().length ? item.id.trim() : `fc_tool_${callCounter}`
+            });
+            item.id = normalizedOutputId;
+        }
+        root.input = input;
+        return root;
+    }
+    catch {
+        return payload;
+    }
+}

package/dist/conversion/compat/actions/lmstudio-responses-input-stringify.d.ts

@@ -0,0 +1,14 @@
+import type { JsonObject } from '../../hub/types/json.js';
+import type { AdapterContext } from '../../hub/types/chat-envelope.js';
+/**
+ * Legacy compatibility shim:
+ * Some older LM Studio builds rejected the array form of `input` ("Invalid type for 'input'").
+ * Convert canonical Responses input items into a single `input` string.
+ *
+ * ⚠️ Default is OFF (modern LM Studio accepts array input). Enable only if you hit that legacy error:
+ * - `LLMSWITCH_LMSTUDIO_STRINGIFY_INPUT=1`
+ * - or `ROUTECODEX_LMSTUDIO_STRINGIFY_INPUT=1`
+ *
+ * This is applied via compat profile `chat:lmstudio` and only when `providerProtocol === 'openai-responses'`.
+ */
+export declare function stringifyLmstudioResponsesInput(payload: JsonObject, adapterContext?: AdapterContext): JsonObject;

package/dist/conversion/compat/actions/lmstudio-responses-input-stringify.js

@@ -0,0 +1,125 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function extractTextParts(content) {
+    const out = [];
+    if (typeof content === 'string' && content.trim().length) {
+        out.push(content.trim());
+        return out;
+    }
+    if (!Array.isArray(content)) {
+        return out;
+    }
+    for (const part of content) {
+        if (!isRecord(part))
+            continue;
+        const type = typeof part.type === 'string' ? String(part.type).trim().toLowerCase() : '';
+        const text = typeof part.text === 'string'
+            ? part.text
+            : typeof part.content === 'string'
+                ? String(part.content)
+                : undefined;
+        if (typeof text === 'string' && text.trim().length) {
+            out.push(text.trim());
+            continue;
+        }
+        // OpenAI Responses content parts often use { type: 'input_text'|'output_text', text: '...' }.
+        if ((type === 'input_text' || type === 'output_text') && typeof part.text === 'string') {
+            const t = String(part.text).trim();
+            if (t.length)
+                out.push(t);
+        }
+    }
+    return out;
+}
+function stringifyInputItems(input) {
+    if (!Array.isArray(input))
+        return null;
+    const chunks = [];
+    for (const item of input) {
+        if (!isRecord(item))
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).trim().toLowerCase() : '';
+        const roleCandidate = typeof item.role === 'string' ? String(item.role).trim() : '';
+        const messageNode = isRecord(item.message) ? item.message : undefined;
+        const nestedRoleCandidate = messageNode && typeof messageNode.role === 'string' ? String(messageNode.role).trim() : '';
+        // OpenAI Responses supports message-like items without an explicit `type` field:
+        // { role: 'user'|'assistant'|'system', content: [...] }
+        if (type === 'message' || (!type && (roleCandidate || nestedRoleCandidate))) {
+            const role = roleCandidate ||
+                nestedRoleCandidate ||
+                'user';
+            const contentNode = item.content !== undefined ? item.content : messageNode?.content;
+            const parts = extractTextParts(contentNode);
+            if (parts.length) {
+                chunks.push(`${role}: ${parts.join('\n')}`);
+            }
+            continue;
+        }
+        if (type === 'function_call') {
+            const name = typeof item.name === 'string' ? String(item.name).trim() : 'tool';
+            const args = typeof item.arguments === 'string'
+                ? String(item.arguments)
+                : (() => {
+                    try {
+                        return JSON.stringify(item.arguments ?? null);
+                    }
+                    catch {
+                        return String(item.arguments ?? '');
+                    }
+                })();
+            chunks.push(`assistant tool_call ${name}: ${args}`);
+            continue;
+        }
+        if (type === 'function_call_output') {
+            const output = typeof item.output === 'string'
+                ? String(item.output)
+                : (() => {
+                    try {
+                        return JSON.stringify(item.output ?? null);
+                    }
+                    catch {
+                        return String(item.output ?? '');
+                    }
+                })();
+            chunks.push(`tool_output: ${output}`);
+            continue;
+        }
+    }
+    if (!chunks.length)
+        return '';
+    return chunks.join('\n\n');
+}
+/**
+ * Legacy compatibility shim:
+ * Some older LM Studio builds rejected the array form of `input` ("Invalid type for 'input'").
+ * Convert canonical Responses input items into a single `input` string.
+ *
+ * ⚠️ Default is OFF (modern LM Studio accepts array input). Enable only if you hit that legacy error:
+ * - `LLMSWITCH_LMSTUDIO_STRINGIFY_INPUT=1`
+ * - or `ROUTECODEX_LMSTUDIO_STRINGIFY_INPUT=1`
+ *
+ * This is applied via compat profile `chat:lmstudio` and only when `providerProtocol === 'openai-responses'`.
+ */
+export function stringifyLmstudioResponsesInput(payload, adapterContext) {
+    const enabled = process.env.LLMSWITCH_LMSTUDIO_STRINGIFY_INPUT === '1' ||
+        process.env.ROUTECODEX_LMSTUDIO_STRINGIFY_INPUT === '1';
+    if (!enabled) {
+        return payload;
+    }
+    if (!adapterContext || adapterContext.providerProtocol !== 'openai-responses') {
+        return payload;
+    }
+    const record = payload;
+    const input = record.input;
+    if (!Array.isArray(input)) {
+        return payload;
+    }
+    const flattened = stringifyInputItems(input);
+    if (flattened === null) {
+        return payload;
+    }
+    const instructions = typeof record.instructions === 'string' ? record.instructions.trim() : '';
+    record.input = instructions.length ? `${instructions}\n\n${flattened}`.trim() : flattened;
+    return payload;
+}

package/dist/conversion/compat/actions/normalize-tool-call-ids.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject } from '../../hub/types/json.js';
+/**
+ * Normalize tool-call identifiers across OpenAI-compatible payload variants.
+ *
+ * Goal: field-level normalization only (no rewriting/rehashing IDs):
+ * - Mirror `call_id` ↔ `tool_call_id` when one side is missing.
+ * - For Responses `input` / `output` function_call items, ensure `id` and `call_id` are aligned.
+ *
+ * This is intended to live in compatibility profiles (per-provider), not in host/provider code.
+ */
+export declare function normalizeToolCallIdsInPlace(root: JsonObject): void;

package/dist/conversion/compat/actions/normalize-tool-call-ids.js

@@ -0,0 +1,140 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function ensureRecord(parent, key) {
+    const existing = parent[key];
+    if (isRecord(existing)) {
+        return existing;
+    }
+    const next = {};
+    parent[key] = next;
+    return next;
+}
+function pickString(...candidates) {
+    for (const c of candidates) {
+        if (typeof c === 'string' && c.trim().length) {
+            return c.trim();
+        }
+    }
+    return undefined;
+}
+function normalizeResponsesInputItem(item) {
+    const type = typeof item.type === 'string' ? item.type : '';
+    if (type === 'function_call') {
+        const id = pickString(item.id);
+        const callId = pickString(item.call_id);
+        if (callId && !id) {
+            item.id = callId;
+        }
+        else if (id && !callId) {
+            item.call_id = id;
+        }
+        return;
+    }
+    if (type === 'function_call_output' || type === 'tool_result' || type === 'tool_message') {
+        const id = pickString(item.id);
+        const callId = pickString(item.call_id);
+        const toolCallId = pickString(item.tool_call_id);
+        const resolvedCall = pickString(callId, toolCallId);
+        if (resolvedCall && !callId) {
+            item.call_id = resolvedCall;
+        }
+        if (id && !callId && !toolCallId) {
+            // Some upstreams only provide an id for tool output items; mirror it to both fields.
+            item.call_id = id;
+            item.tool_call_id = id;
+        }
+    }
+}
+function normalizeResponsesOutputItem(item) {
+    const type = typeof item.type === 'string' ? item.type : '';
+    if (type === 'function_call') {
+        const id = pickString(item.id, item.item_id);
+        const callId = pickString(item.call_id);
+        if (callId && !id) {
+            item.id = callId;
+        }
+        else if (id && !callId) {
+            item.call_id = id;
+        }
+    }
+}
+function normalizeToolOutputsArray(toolOutputs) {
+    if (!Array.isArray(toolOutputs))
+        return;
+    for (const entry of toolOutputs) {
+        if (!isRecord(entry))
+            continue;
+        const toolCallId = pickString(entry.tool_call_id);
+        const callId = pickString(entry.call_id);
+        const resolved = pickString(toolCallId, callId, entry.id);
+        if (resolved) {
+            entry.tool_call_id = resolved;
+            entry.call_id = resolved;
+        }
+    }
+}
+function normalizeChatMessages(messages) {
+    if (!Array.isArray(messages))
+        return;
+    for (const msg of messages) {
+        if (!isRecord(msg))
+            continue;
+        // chat tool message uses tool_call_id; mirror to call_id for downstream consumers that only look at call_id.
+        const toolCallId = pickString(msg.tool_call_id);
+        const callId = pickString(msg.call_id);
+        const resolved = pickString(toolCallId, callId);
+        if (resolved) {
+            msg.tool_call_id = resolved;
+            msg.call_id = resolved;
+        }
+        const toolCalls = msg.tool_calls;
+        if (Array.isArray(toolCalls)) {
+            for (const call of toolCalls) {
+                if (!isRecord(call))
+                    continue;
+                const id = pickString(call.id);
+                const callId2 = pickString(call.call_id);
+                if (id && !callId2) {
+                    call.call_id = id;
+                }
+                else if (callId2 && !id) {
+                    call.id = callId2;
+                }
+            }
+        }
+    }
+}
+/**
+ * Normalize tool-call identifiers across OpenAI-compatible payload variants.
+ *
+ * Goal: field-level normalization only (no rewriting/rehashing IDs):
+ * - Mirror `call_id` ↔ `tool_call_id` when one side is missing.
+ * - For Responses `input` / `output` function_call items, ensure `id` and `call_id` are aligned.
+ *
+ * This is intended to live in compatibility profiles (per-provider), not in host/provider code.
+ */
+export function normalizeToolCallIdsInPlace(root) {
+    const record = root;
+    // Responses request
+    if (Array.isArray(record.input)) {
+        for (const item of record.input) {
+            if (isRecord(item)) {
+                normalizeResponsesInputItem(item);
+            }
+        }
+    }
+    // Responses submit_tool_outputs request (common alias)
+    normalizeToolOutputsArray(record.tool_outputs);
+    normalizeToolOutputsArray(record.toolOutputs);
+    // Responses response
+    if (Array.isArray(record.output)) {
+        for (const item of record.output) {
+            if (isRecord(item)) {
+                normalizeResponsesOutputItem(item);
+            }
+        }
+    }
+    // Chat request/response
+    normalizeChatMessages(record.messages);
+}

package/dist/conversion/compat/actions/strip-orphan-function-calls-tag.d.ts

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

package/dist/conversion/compat/actions/strip-orphan-function-calls-tag.js

@@ -0,0 +1,152 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+const ORPHAN_TAG_RE = /^\s*(?:[•*+-]\s*)?<\/?\s*function_calls\s*\/?\s*>\s*$/i;
+function stripOrphanTagLines(text) {
+    const raw = String(text ?? '');
+    if (!raw)
+        return { text: raw, changed: false };
+    const lines = raw.split(/\r?\n/);
+    const kept = [];
+    let changed = false;
+    for (const line of lines) {
+        if (ORPHAN_TAG_RE.test(line)) {
+            changed = true;
+            continue;
+        }
+        kept.push(line);
+    }
+    return { text: kept.join('\n'), changed };
+}
+function stripInMessageInPlace(message) {
+    let changed = false;
+    const content = message.content;
+    if (typeof content === 'string') {
+        const res = stripOrphanTagLines(content);
+        if (res.changed) {
+            message.content = res.text;
+            changed = true;
+        }
+    }
+    else if (Array.isArray(content)) {
+        const next = content.map((part) => {
+            if (typeof part === 'string') {
+                const res = stripOrphanTagLines(part);
+                if (res.changed)
+                    changed = true;
+                return res.text;
+            }
+            if (!isRecord(part))
+                return part;
+            const p = { ...part };
+            if (typeof p.text === 'string') {
+                const res = stripOrphanTagLines(p.text);
+                if (res.changed) {
+                    p.text = res.text;
+                    changed = true;
+                }
+            }
+            if (typeof p.content === 'string') {
+                const res = stripOrphanTagLines(p.content);
+                if (res.changed) {
+                    p.content = res.text;
+                    changed = true;
+                }
+            }
+            return p;
+        });
+        if (changed) {
+            message.content = next;
+        }
+    }
+    for (const key of ['reasoning', 'thinking', 'reasoning_content']) {
+        const raw = message[key];
+        if (typeof raw === 'string' && raw.trim().length) {
+            const res = stripOrphanTagLines(raw);
+            if (res.changed) {
+                message[key] = res.text;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+function stripInChatPayloadInPlace(root) {
+    const choices = Array.isArray(root.choices) ? root.choices : [];
+    if (!choices.length)
+        return false;
+    let changed = false;
+    for (const choice of choices) {
+        if (!isRecord(choice))
+            continue;
+        const message = choice.message;
+        if (!isRecord(message))
+            continue;
+        const role = typeof message.role === 'string' ? String(message.role).trim().toLowerCase() : 'assistant';
+        if (role !== 'assistant')
+            continue;
+        if (stripInMessageInPlace(message)) {
+            changed = true;
+            choice.message = message;
+        }
+    }
+    return changed;
+}
+function stripInResponsesPayloadInPlace(root) {
+    const output = Array.isArray(root.output) ? root.output : [];
+    if (!output.length)
+        return false;
+    let changed = false;
+    for (const item of output) {
+        if (!isRecord(item))
+            continue;
+        const type = typeof item.type === 'string' ? String(item.type).trim().toLowerCase() : '';
+        if (type !== 'message')
+            continue;
+        const role = typeof item.role === 'string' ? String(item.role).trim().toLowerCase() : 'assistant';
+        if (role !== 'assistant')
+            continue;
+        const content = Array.isArray(item.content) ? item.content : [];
+        if (content.length) {
+            const next = content.map((part) => {
+                if (!isRecord(part))
+                    return part;
+                const p = { ...part };
+                for (const key of ['text', 'content', 'value']) {
+                    if (typeof p[key] === 'string' && String(p[key]).trim().length) {
+                        const res = stripOrphanTagLines(String(p[key]));
+                        if (res.changed) {
+                            p[key] = res.text;
+                            changed = true;
+                        }
+                    }
+                }
+                return p;
+            });
+            if (changed) {
+                item.content = next;
+            }
+        }
+        if (typeof item.output_text === 'string' && String(item.output_text).trim().length) {
+            const res = stripOrphanTagLines(String(item.output_text));
+            if (res.changed) {
+                item.output_text = res.text;
+                changed = true;
+            }
+        }
+    }
+    return changed;
+}
+export function stripOrphanFunctionCallsTag(payload) {
+    try {
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+            return payload;
+        }
+        const root = structuredClone(payload);
+        const changed = stripInChatPayloadInPlace(root) || stripInResponsesPayloadInPlace(root);
+        return (changed ? root : payload);
+    }
+    catch {
+        return payload;
+    }
+}