@jsonstudio/llms 0.6.3379 → 0.6.3405

package/dist/conversion/compat/actions/claude-thinking-tools.d.ts

@@ -1,15 +1,2 @@
 import type { JsonObject } from '../../hub/types/json.js';
-import type { AdapterContext } from '../../hub/types/chat-envelope.js';
-/**
- * Compat for Claude models routed via antigravity on gemini-chat.
- *
- * Anthropic requires tools[*].custom.input_schema to be valid JSON Schema draft 2020-12.
- * We currently send OpenAI-style parameters which may not fully conform, causing upstream
- * invalid_request_error on tools.N.custom.input_schema.
- *
- * For safety, when we detect the antigravity.*.claude-* path over gemini-chat,
- * we aggressively simplify Gemini functionDeclarations[*].parameters to a minimal
- * but valid object schema, letting RouteCodex govern tool semantics while keeping
- * Anthropic's schema validator happy.
- */
-export declare function applyClaudeThinkingToolSchemaCompat(payload: JsonObject, adapterContext?: AdapterContext): JsonObject;
+export declare function applyClaudeThinkingToolSchemaCompat(payload: JsonObject): JsonObject;

package/dist/conversion/compat/actions/claude-thinking-tools.js

@@ -1,72 +1,4 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
-/**
- * Compat for Claude models routed via antigravity on gemini-chat.
- *
- * Anthropic requires tools[*].custom.input_schema to be valid JSON Schema draft 2020-12.
- * We currently send OpenAI-style parameters which may not fully conform, causing upstream
- * invalid_request_error on tools.N.custom.input_schema.
- *
- * For safety, when we detect the antigravity.*.claude-* path over gemini-chat,
- * we aggressively simplify Gemini functionDeclarations[*].parameters to a minimal
- * but valid object schema, letting RouteCodex govern tool semantics while keeping
- * Anthropic's schema validator happy.
- */
-export function applyClaudeThinkingToolSchemaCompat(payload, adapterContext) {
-    const modelRaw = payload.model;
-    const modelId = typeof modelRaw === 'string' ? modelRaw.trim() : '';
-    // Only apply on Claude models.
-    // Upstream Anthropic enforces strict JSON Schema 2020-12 on custom.input_schema for these models.
-    if (!modelId.startsWith('claude-')) {
-        return payload;
-    }
-    const root = structuredClone(payload);
-    // Support both shapes:
-    // - Provider envelope: { model, request: { tools, ... } }
-    // - Gemini mapper request: { model, tools, ... }
-    const requestNode = isRecord(root.request)
-        ? root.request
-        : root;
-    const toolsRaw = requestNode.tools;
-    if (!Array.isArray(toolsRaw)) {
-        return root;
-    }
-    const nextTools = [];
-    for (const entry of toolsRaw) {
-        if (!isRecord(entry)) {
-            nextTools.push(entry);
-            continue;
-        }
-        const decls = Array.isArray(entry.functionDeclarations)
-            ? entry.functionDeclarations
-            : undefined;
-        if (!decls || !decls.length) {
-            // Non functionDeclarations-based tools (e.g. googleSearch) are left as-is.
-            nextTools.push(entry);
-            continue;
-        }
-        const nextDecls = [];
-        for (const fn of decls) {
-            if (!isRecord(fn)) {
-                nextDecls.push(fn);
-                continue;
-            }
-            const fnCopy = { ...fn };
-            // Replace parameters with a minimal, always-valid object schema.
-            fnCopy.parameters = {
-                type: 'object',
-                properties: {},
-                additionalProperties: true
-            };
-            // Drop strict flag to avoid upstream schema incompatibilities.
-            if (Object.prototype.hasOwnProperty.call(fnCopy, 'strict')) {
-                delete fnCopy.strict;
-            }
-            nextDecls.push(fnCopy);
-        }
-        nextTools.push({
-            functionDeclarations: nextDecls
-        });
-    }
-    requestNode.tools = nextTools;
-    return root;
+import { applyClaudeThinkingToolSchemaCompatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
+export function applyClaudeThinkingToolSchemaCompat(payload) {
+    return applyClaudeThinkingToolSchemaCompatWithNative(payload);
 }

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

@@ -1,10 +1,2 @@
 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

@@ -1,59 +1,4 @@
-import { normalizeFunctionCallId, normalizeFunctionCallOutputId, normalizeResponsesCallId } from '../../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.
- */
+import { enforceLmstudioResponsesFcToolCallIdsWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 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;
-    }
+    return enforceLmstudioResponsesFcToolCallIdsWithNative(payload);
 }

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

@@ -1,11 +1,2 @@
 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

@@ -1,140 +1,10 @@
-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.
- */
+import { normalizeToolCallIdsWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 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);
-            }
+    const normalized = normalizeToolCallIdsWithNative(root);
+    for (const key of Object.keys(root)) {
+        if (!(key in normalized)) {
+            delete root[key];
         }
     }
-    // Chat request/response
-    normalizeChatMessages(record.messages);
+    Object.assign(root, normalized);
 }

package/dist/conversion/compat/actions/request-rules.js

@@ -1,63 +1,4 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+import { applyRequestRulesWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 export function applyRequestRules(payload, config) {
-    if (!config) {
-        return payload;
-    }
-    const cloned = { ...payload };
-    const toolRule = config.tools?.['function'];
-    if (toolRule?.removeKeys && Array.isArray(cloned.tools)) {
-        for (const toolEntry of cloned.tools) {
-            if (!isRecord(toolEntry)) {
-                continue;
-            }
-            const fnNode = toolEntry.function;
-            if (!isRecord(fnNode)) {
-                continue;
-            }
-            for (const key of toolRule.removeKeys) {
-                delete fnNode[key];
-            }
-        }
-    }
-    const assistantRule = config.messages?.assistantToolCalls?.['function'];
-    if (Array.isArray(cloned.messages) && assistantRule?.removeKeys) {
-        for (const message of cloned.messages) {
-            if (!isRecord(message) || !Array.isArray(message.tool_calls)) {
-                continue;
-            }
-            for (const callEntry of message.tool_calls) {
-                if (!isRecord(callEntry)) {
-                    continue;
-                }
-                const fnNode = callEntry.function;
-                if (!isRecord(fnNode)) {
-                    continue;
-                }
-                for (const key of assistantRule.removeKeys) {
-                    delete fnNode[key];
-                }
-            }
-        }
-    }
-    if (Array.isArray(config.topLevel?.conditional)) {
-        for (const rule of config.topLevel.conditional) {
-            if (!rule)
-                continue;
-            if (rule.when?.tools === 'empty') {
-                if (Array.isArray(cloned.tools) && cloned.tools.length === 0) {
-                    for (const field of rule.remove || []) {
-                        delete cloned[field];
-                    }
-                }
-            }
-            if (rule.when?.tools === 'present') {
-                if (Array.isArray(cloned.tools) && cloned.tools.length > 0) {
-                    for (const field of rule.remove || []) {
-                        delete cloned[field];
-                    }
-                }
-            }
-        }
-    }
-    return cloned;
+    return applyRequestRulesWithNative(payload, (config ?? {}));
 }

package/dist/conversion/compat/actions/response-blacklist.d.ts

@@ -5,10 +5,6 @@ export interface ResponseBlacklistConfig {
 }
 export declare class ResponseBlacklistSanitizer {
     private readonly cfg;
-    private readonly criticalPaths;
     constructor(config: ResponseBlacklistConfig);
-    private isCritical;
-    private unwrapPayload;
-    private deleteByPath;
     apply(payload: JsonObject): JsonObject;
 }

package/dist/conversion/compat/actions/response-blacklist.js

@@ -1,85 +1,10 @@
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function isTraversable(value) {
-    return Array.isArray(value) || isRecord(value);
-}
+import { applyResponseBlacklistWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 export class ResponseBlacklistSanitizer {
     cfg;
-    criticalPaths = new Set([
-        'status',
-        'output',
-        'output_text',
-        'required_action',
-        'choices[].message.content',
-        'choices[].message.tool_calls',
-        'choices[].finish_reason'
-    ]);
     constructor(config) {
         this.cfg = config;
     }
-    isCritical(pathStr) {
-        if (!this.cfg.keepCritical) {
-            return false;
-        }
-        return this.criticalPaths.has(pathStr);
-    }
-    unwrapPayload(payload) {
-        if (!isRecord(payload)) {
-            return {};
-        }
-        const rootCandidate = payload.data;
-        return isRecord(rootCandidate) ? rootCandidate : payload;
-    }
-    deleteByPath(obj, pathStr) {
-        const tokens = pathStr.split('.');
-        const recurse = (current, idx) => {
-            if (!isTraversable(current) || idx >= tokens.length) {
-                return;
-            }
-            const token = tokens[idx];
-            const isArrayWildcard = token.endsWith('[]');
-            const key = isArrayWildcard ? token.slice(0, -2) : token;
-            if (idx === tokens.length - 1) {
-                if (!isArrayWildcard && isRecord(current) && Object.prototype.hasOwnProperty.call(current, key)) {
-                    delete current[key];
-                }
-                return;
-            }
-            if (isArrayWildcard) {
-                if (isRecord(current)) {
-                    const arr = current[key];
-                    if (Array.isArray(arr)) {
-                        for (const item of arr) {
-                            recurse(item, idx + 1);
-                        }
-                    }
-                }
-            }
-            else if (isRecord(current)) {
-                recurse(current[key], idx + 1);
-            }
-        };
-        recurse(obj, 0);
-    }
     apply(payload) {
-        const out = isRecord(payload) ? payload : {};
-        try {
-            const root = this.unwrapPayload(out);
-            const configPaths = Array.isArray(this.cfg?.paths) ? this.cfg.paths ?? [] : [];
-            for (const p of configPaths) {
-                if (typeof p !== 'string' || !p) {
-                    continue;
-                }
-                if (this.isCritical(p)) {
-                    continue;
-                }
-                this.deleteByPath(root, p);
-            }
-            return out;
-        }
-        catch {
-            return out;
-        }
+        return applyResponseBlacklistWithNative(payload, this.cfg);
     }
 }

package/dist/conversion/compat/actions/response-normalize.js

@@ -1,121 +1,4 @@
-const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+import { normalizeResponsePayloadWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 export function normalizeResponsePayload(payload, config) {
-    const normalized = { ...payload };
-    if (isRecord(normalized.usage)) {
-        normalized.usage = normalizeUsageFields(normalized.usage);
-    }
-    if (typeof normalized.created_at === 'number') {
-        normalized.created = normalized.created_at;
-        delete normalized.created_at;
-    }
-    if (Array.isArray(normalized.choices)) {
-        normalized.choices = normalizeChoices(normalized.choices, config);
-    }
-    return normalized;
-}
-function normalizeUsageFields(usage) {
-    const normalizedUsage = { ...usage };
-    const fieldMappings = {
-        input_tokens: 'prompt_tokens',
-        output_tokens: 'completion_tokens',
-        total_input_tokens: 'prompt_tokens',
-        total_output_tokens: 'completion_tokens'
-    };
-    for (const [glmField, standardField] of Object.entries(fieldMappings)) {
-        const value = normalizedUsage[glmField];
-        if (typeof value === 'number') {
-            normalizedUsage[standardField] = value;
-            delete normalizedUsage[glmField];
-        }
-    }
-    const promptTokens = typeof normalizedUsage.prompt_tokens === 'number' ? normalizedUsage.prompt_tokens : 0;
-    const completionTokens = typeof normalizedUsage.completion_tokens === 'number'
-        ? normalizedUsage.completion_tokens
-        : 0;
-    normalizedUsage.prompt_tokens = promptTokens;
-    normalizedUsage.completion_tokens = completionTokens;
-    if (typeof normalizedUsage.total_tokens !== 'number') {
-        normalizedUsage.total_tokens = promptTokens + completionTokens;
-    }
-    return normalizedUsage;
-}
-function normalizeChoices(choices, config) {
-    const map = config?.finishReasonMap || {};
-    return choices.map((choice, idx) => {
-        if (!isRecord(choice)) {
-            return choice;
-        }
-        const normalizedChoice = {
-            index: typeof choice.index === 'number' ? choice.index : idx,
-            ...choice
-        };
-        if (typeof normalizedChoice.finish_reason === 'string') {
-            normalizedChoice.finish_reason = map[normalizedChoice.finish_reason] ?? normalizedChoice.finish_reason;
-        }
-        if (isRecord(normalizedChoice.message)) {
-            normalizedChoice.message = normalizeChoiceMessage(normalizedChoice.message);
-        }
-        return normalizedChoice;
-    });
-}
-function normalizeChoiceMessage(message) {
-    const normalizedMessage = { ...message };
-    if (normalizedMessage.content !== undefined && typeof normalizedMessage.content !== 'string') {
-        normalizedMessage.content = normalizeMessageContent(normalizedMessage.content);
-    }
-    if (Array.isArray(normalizedMessage.tool_calls)) {
-        normalizedMessage.tool_calls = normalizeToolCalls(normalizedMessage.tool_calls);
-    }
-    return normalizedMessage;
-}
-function normalizeMessageContent(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (Array.isArray(content)) {
-        return content.map(item => (typeof item === 'string' ? item : JSON.stringify(item))).join('');
-    }
-    if (isRecord(content)) {
-        return JSON.stringify(content);
-    }
-    return String(content ?? '');
-}
-function normalizeToolCalls(toolCalls) {
-    return toolCalls.map(toolCall => {
-        if (!isRecord(toolCall)) {
-            return toolCall;
-        }
-        const normalizedToolCall = { ...toolCall };
-        const func = normalizedToolCall.function;
-        if (isRecord(func) && func.arguments !== undefined) {
-            func.arguments = normalizeToolArguments(func.arguments);
-            normalizedToolCall.function = func;
-        }
-        return normalizedToolCall;
-    });
-}
-function normalizeToolArguments(args) {
-    let normalized = '';
-    if (typeof args === 'string') {
-        normalized = args;
-    }
-    else {
-        try {
-            normalized = JSON.stringify(args ?? {});
-        }
-        catch {
-            normalized = String(args ?? '');
-        }
-    }
-    const trimmed = normalized.trim();
-    if (!trimmed.length) {
-        return '';
-    }
-    try {
-        const parsed = JSON.parse(trimmed);
-        return JSON.stringify(parsed);
-    }
-    catch {
-        return trimmed;
-    }
+    return normalizeResponsePayloadWithNative(payload, (config ?? {}));
 }