@jsonstudio/llms 0.6.1643 → 0.6.1739

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;
+    }
+}

package/dist/conversion/compat/antigravity-session-signature.d.ts

@@ -23,7 +23,7 @@ export declare function getAntigravityRequestSessionMeta(requestId: string): {
 } | undefined;
 /**
  * Antigravity-Manager alignment: derive a stable session fingerprint for Gemini native requests.
- * - sha256(first user text parts joined), if len>10 and no "<system-reminder>"
+ * - sha256(first user text parts joined), if non-empty and no "<system-reminder>"
  * - else sha256(JSON body)
  * - sid = "sid-" + first 16 hex chars
  */

package/dist/conversion/compat/antigravity-session-signature.js

@@ -721,7 +721,7 @@ function findGeminiContentsNode(payload) {
 }
 /**
  * Antigravity-Manager alignment: derive a stable session fingerprint for Gemini native requests.
- * - sha256(first user text parts joined), if len>10 and no "<system-reminder>"
+ * - sha256(first user text parts joined), if non-empty and no "<system-reminder>"
  * - else sha256(JSON body)
  * - sid = "sid-" + first 16 hex chars
  */
@@ -747,9 +747,10 @@ export function extractAntigravityGeminiSessionId(payload) {
             }
         }
         const combined = texts.join(' ').trim();
-        // Antigravity-Manager alignment: always derive a stable session_id from the FIRST user message text,
-        // even if the prompt is short (avoid JSON fallback instability across tool loops / followups).
-        if (combined.length > 0) {
+        // RouteCodex signature persistence alignment:
+        // - Prefer the first user message text as the stable session anchor, even when short.
+        // - Skip system-reminder carrier messages (common in tool followups).
+        if (combined.length > 0 && !combined.includes('<system-reminder>')) {
             seed = combined;
             break;
         }

package/dist/conversion/compat/profiles/chat-iflow.json

@@ -81,6 +81,9 @@
           }
         }
       },
+      { "action": "iflow_kimi_history_media_placeholder" },
+      { "action": "iflow_kimi_cli_defaults" },
+      { "action": "iflow_kimi_thinking_reasoning_fill" },
       {
         "action": "field_map",
         "direction": "incoming",
@@ -114,6 +117,9 @@
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
       { "action": "dto_unwrap" },
+      { "action": "iflow_response_body_unwrap" },
+      { "action": "harvest_tool_calls_from_text" },
+      { "action": "strip_orphan_function_calls_tag" },
       {
         "action": "shape_filter",
         "target": "response",

package/dist/conversion/compat/profiles/chat-lmstudio.json

@@ -1,10 +1,13 @@
 {
   "id": "chat:lmstudio",
-  "protocol": "openai-chat",
+  "protocol": "",
   "request": {
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
       { "action": "dto_unwrap" },
+      { "action": "lmstudio_responses_input_stringify" },
+      { "action": "normalize_tool_call_ids" },
+      { "action": "lmstudio_responses_fc_ids" },
       {
         "action": "normalize_tool_choice",
         "path": "tool_choice",
@@ -18,6 +21,9 @@
     "mappings": [
       { "action": "snapshot", "phase": "compat-pre" },
       { "action": "dto_unwrap" },
+      { "action": "harvest_tool_calls_from_text" },
+      { "action": "strip_orphan_function_calls_tag" },
+      { "action": "normalize_tool_call_ids" },
       {
         "action": "set_default",
         "path": "object",

package/dist/conversion/hub/operation-table/operation-table-runner.js

@@ -12,7 +12,7 @@ const OUTBOUND_BRIDGE_SPECS = {
     'openai-chat': { protocol: 'openai-chat', stage: 'request_outbound', messages: 'format_payload_messages', includeCapturedToolResults: true },
     // Keep parity: openai-responses outbound actions should not touch normalized messages.
     'openai-responses': { protocol: 'openai-responses', stage: 'request_outbound', messages: 'none', moduleType: 'openai-responses' },
-    'anthropic-messages': { protocol: 'anthropic-messages', stage: 'request_outbound', messages: 'format_payload_messages', includeCapturedToolResults: true },
+    'anthropic-messages': { protocol: 'anthropic-messages', stage: 'request_outbound', messages: 'none', includeCapturedToolResults: true },
     // Keep parity with legacy gemini mapper: outbound hooks operate on ChatEnvelope.messages (not Gemini contents).
     'gemini-chat': { protocol: 'gemini-chat', stage: 'request_outbound', messages: 'chat_envelope', includeCapturedToolResults: true }
 };

package/dist/conversion/hub/operation-table/semantic-mappers/gemini-mapper.js

@@ -488,7 +488,7 @@ function buildFunctionResponseEntry(output, options) {
         }
     };
     if (includeCallId) {
-        part.functionResponse.id = output.tool_call_id;
+        part.functionResponse.id = sanitizeAntigravityToolCallId(output.tool_call_id);
     }
     return { role: 'user', parts: [part] };
 }
@@ -795,7 +795,7 @@ function buildGeminiRequestFromChat(chat, metadata) {
             const functionCall = { name, args: argsJson };
             const part = { functionCall };
             if (includeToolCallIds && typeof tc.id === 'string' && tc.id.trim().length) {
-                part.functionCall.id = String(tc.id).trim();
+                part.functionCall.id = sanitizeAntigravityToolCallId(String(tc.id));
             }
             // Antigravity-Manager alignment:
             // - Do NOT invent a dummy thoughtSignature in conversion.
@@ -1092,6 +1092,23 @@ function buildGeminiRequestFromChat(chat, metadata) {
     const compatRequest = applyClaudeThinkingToolSchemaCompat(request, adapterContext);
     return compatRequest;
 }
+function sanitizeAntigravityToolCallId(raw) {
+    const trimmed = typeof raw === 'string' ? raw.trim() : '';
+    if (!trimmed) {
+        return trimmed;
+    }
+    // Antigravity (Claude via Gemini) validates tool_use.id against: ^[a-zA-Z0-9_-]+$
+    // Preserve stable IDs when already valid; otherwise sanitize minimally.
+    if (/^[A-Za-z0-9_-]+$/.test(trimmed)) {
+        return trimmed;
+    }
+    const sanitized = trimmed
+        .replace(/[^A-Za-z0-9_-]/g, '_')
+        .replace(/_{2,}/g, '_')
+        .replace(/^_+/, '')
+        .replace(/_+$/, '');
+    return sanitized || `call_${Math.random().toString(36).slice(2, 10)}`;
+}
 function isPlainRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }