@jsonstudio/llms 0.6.3685 → 0.6.3686

package/dist/conversion/compat/actions/antigravity-thought-signature-cache.js

@@ -1,28 +1,8 @@
 import { runRespInboundStage3CompatWithNative } from '../../../router/virtual-router/engine-selection/native-hub-pipeline-req-outbound-semantics.js';
-import { buildNativeReqOutboundCompatAdapterContext } from '../../hub/pipeline/compat/native-adapter-context.js';
-const PROFILE = 'chat:gemini-cli';
-const DEFAULT_PROVIDER_PROTOCOL = 'gemini-chat';
-const DEFAULT_ENTRY_ENDPOINT = '/v1/chat/completions';
-function buildGeminiCliResponseCompatInput(payload, adapterContext) {
-    const nativeContext = buildNativeReqOutboundCompatAdapterContext(adapterContext);
-    return {
-        payload,
-        adapterContext: {
-            ...nativeContext,
-            compatibilityProfile: PROFILE,
-            providerProtocol: nativeContext.providerProtocol ??
-                adapterContext?.providerProtocol ??
-                DEFAULT_PROVIDER_PROTOCOL,
-            entryEndpoint: nativeContext.entryEndpoint ??
-                adapterContext?.entryEndpoint ??
-                DEFAULT_ENTRY_ENDPOINT,
-        },
-        explicitProfile: PROFILE,
-    };
-}
+import { buildGeminiCliCompatInput } from './gemini-cli-request.js';
 export function cacheAntigravityThoughtSignatureFromGeminiResponse(payload, adapterContext) {
     if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
         return payload;
     }
-    return runRespInboundStage3CompatWithNative(buildGeminiCliResponseCompatInput(payload, adapterContext)).payload;
+    return runRespInboundStage3CompatWithNative(buildGeminiCliCompatInput(payload, adapterContext)).payload;
 }

package/dist/conversion/compat/actions/deepseek-web-response.js

@@ -103,6 +103,13 @@ export function applyDeepSeekWebResponseTransform(payload, adapterContext, confi
             reason: 'payload is not an object'
         });
     }
+    // Fail fast if response is missing required shape (choices array)
+    if (!Array.isArray(payload.choices)) {
+        // Allow business error format (code + msg) to pass through for separate handling
+        if (!('code' in payload && 'msg' in payload)) {
+            emitCompatError(new Error('[deepseek-web] invalid response: missing required "choices" array'), adapterContext, payload, { reason: 'missing required response shape' });
+        }
+    }
     if (isNativeDisabledByEnv()) {
         emitCompatError(makeNativeRequiredError('runRespInboundStage3CompatJson', 'native disabled'), adapterContext, payload, { reason: 'native disabled' });
     }

package/dist/conversion/compat/actions/field-mapping.js

@@ -1,4 +1,155 @@
-import { applyFieldMappingsWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+const MODEL_PREFIX_NORMALIZATION = {
+    'gpt-': 'glm-'
+};
+const FINISH_REASON_MAP = {
+    tool_calls: 'tool_calls',
+    stop: 'stop',
+    length: 'length',
+    sensitive: 'content_filter',
+    network_error: 'error'
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 export function applyFieldMappings(payload, mappings) {
-    return applyFieldMappingsWithNative(payload, mappings);
+    const result = { ...payload };
+    for (const mapping of mappings) {
+        applySingleMapping(result, mapping);
+    }
+    return result;
+}
+function applySingleMapping(root, mapping) {
+    const sourceValue = getNestedProperty(root, mapping.sourcePath);
+    if (sourceValue === undefined) {
+        return;
+    }
+    const transformed = convertType(applyTransform(sourceValue, mapping.transform), mapping.type);
+    setNestedProperty(root, mapping.targetPath, transformed);
+}
+function applyTransform(value, transform) {
+    if (!transform) {
+        return value;
+    }
+    switch (transform) {
+        case 'timestamp':
+            return typeof value === 'number' ? value : Date.now();
+        case 'lowercase':
+            return typeof value === 'string' ? value.toLowerCase() : value;
+        case 'uppercase':
+            return typeof value === 'string' ? value.toUpperCase() : value;
+        case 'normalizeModelName':
+            if (typeof value === 'string') {
+                for (const [prefix, replacement] of Object.entries(MODEL_PREFIX_NORMALIZATION)) {
+                    if (value.startsWith(prefix)) {
+                        return value.replace(prefix, replacement);
+                    }
+                }
+            }
+            return value;
+        case 'normalizeFinishReason':
+            if (typeof value === 'string') {
+                return FINISH_REASON_MAP[value] ?? value;
+            }
+            return value;
+        default:
+            return value;
+    }
+}
+function convertType(value, targetType) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    switch (targetType) {
+        case 'string':
+            return String(value);
+        case 'number': {
+            const num = Number(value);
+            return Number.isNaN(num) ? 0 : num;
+        }
+        case 'boolean':
+            return Boolean(value);
+        case 'object':
+            return isRecord(value) ? value : {};
+        case 'array':
+            return Array.isArray(value) ? value : [value];
+        default:
+            return value;
+    }
+}
+function getNestedProperty(obj, pathExpression) {
+    const keys = pathExpression.split('.');
+    if (pathExpression.includes('[*]')) {
+        return getWildcardProperty(obj, keys);
+    }
+    return keys.reduce((current, key) => {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        return current[key];
+    }, obj);
+}
+function getWildcardProperty(obj, keys) {
+    const results = [];
+    const processWildcard = (current, keyIndex) => {
+        if (keyIndex >= keys.length) {
+            results.push(current);
+            return;
+        }
+        const key = keys[keyIndex];
+        if (key === '[*]') {
+            if (Array.isArray(current)) {
+                current.forEach(item => processWildcard(item, keyIndex + 1));
+            }
+            return;
+        }
+        if (isRecord(current) && current[key] !== undefined) {
+            processWildcard(current[key], keyIndex + 1);
+        }
+    };
+    processWildcard(obj, 0);
+    return results;
+}
+function setNestedProperty(obj, pathExpression, value) {
+    const keys = pathExpression.split('.');
+    if (pathExpression.includes('[*]')) {
+        setWildcardProperty(obj, keys, value);
+        return;
+    }
+    const lastKey = keys.pop();
+    if (!lastKey) {
+        return;
+    }
+    const target = keys.reduce((current, key) => {
+        if (!isRecord(current[key])) {
+            current[key] = {};
+        }
+        return current[key];
+    }, obj);
+    target[lastKey] = value;
+}
+function setWildcardProperty(obj, keys, value) {
+    const processSetWildcard = (current, keyIndex) => {
+        if (keyIndex >= keys.length - 1) {
+            const lastKey = keys[keys.length - 1].replace('[*]', '');
+            if (Array.isArray(current)) {
+                current.forEach(item => {
+                    if (isRecord(item)) {
+                        item[lastKey] = value;
+                    }
+                });
+            }
+            return;
+        }
+        const key = keys[keyIndex];
+        if (key === '[*]') {
+            if (Array.isArray(current)) {
+                current.forEach(item => processSetWildcard(item, keyIndex + 1));
+            }
+            return;
+        }
+        if (isRecord(current)) {
+            processSetWildcard(current[key], keyIndex + 1);
+        }
+    };
+    processSetWildcard(obj, 0);
 }

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

@@ -1,5 +1,95 @@
-import { buildNativeReqOutboundCompatAdapterContext } from '../../hub/pipeline/compat/native-adapter-context.js';
-import { stringifyLmstudioResponsesInputWithNative } from '../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
+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'").
@@ -20,5 +110,16 @@ export function stringifyLmstudioResponsesInput(payload, adapterContext) {
     if (!adapterContext || adapterContext.providerProtocol !== 'openai-responses') {
         return payload;
     }
-    return stringifyLmstudioResponsesInputWithNative(payload, buildNativeReqOutboundCompatAdapterContext(adapterContext));
+    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/hub/node-support.js

@@ -108,7 +108,7 @@ function deriveAdapterContext(context, fallbackProtocol) {
         (typeof metadata.providerProtocol === 'string' ? metadata.providerProtocol : undefined) ||
         fallbackProtocol;
     const streamingHint = metadata.stream === true ? 'force' : metadata.stream === false ? 'disable' : 'auto';
-    const toolCallIdStyle = normalizeToolCallIdStyleCandidate(requestContext.toolCallIdStyle);
+    const toolCallIdStyle = normalizeToolCallIdStyleCandidate(metadata.toolCallIdStyle);
     return {
         requestId: context.request.id,
         entryEndpoint: (typeof requestContext.entryEndpoint === 'string' ? requestContext.entryEndpoint : context.request.endpoint) ||

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

@@ -29,8 +29,7 @@ const ANTHROPIC_TOP_LEVEL_FIELDS = new Set([
     'metadata',
     'stream',
     'tool_choice',
-    'thinking',
-    'disable_parallel_tool_use'
+    'thinking'
 ]);
 const PASSTHROUGH_METADATA_PREFIX = 'rcc_passthrough_';
 const PASSTHROUGH_PARAMETERS = ['tool_choice'];
@@ -95,9 +94,6 @@ function collectParameters(payload) {
             params[key] = payload[key];
         }
     }
-    if (typeof payload.disable_parallel_tool_use === 'boolean') {
-        params.parallel_tool_calls = !payload.disable_parallel_tool_use;
-    }
     if (Array.isArray(payload.stop_sequences)) {
         params.stop = payload.stop_sequences;
     }
@@ -388,10 +384,6 @@ export class AnthropicSemanticMapper {
         }
         if (trimmedParameters) {
             for (const [key, value] of Object.entries(trimmedParameters)) {
-                if (key === 'parallel_tool_calls') {
-                    baseRequest.parallel_tool_calls = value;
-                    continue;
-                }
                 if (ANTHROPIC_TOP_LEVEL_FIELDS.has(key) || key === 'stop') {
                     if (key === 'messages' || key === 'tools') {
                         continue;

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

@@ -1,9 +1,8 @@
 import { isJsonObject, jsonClone } from '../../types/json.js';
 import { captureResponsesContext, buildChatRequestFromResponses, buildResponsesRequestFromChat } from '../../../responses/responses-openai-bridge.js';
+import { logHubStageTiming } from '../../pipeline/hub-stage-timing.js';
 import { maybeAugmentApplyPatchErrorContent } from './chat-mapper.js';
 import { mapReqInboundBridgeToolsToChatWithNative, mapReqInboundResumeToolOutputsDetailedWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-req-inbound-semantics.js';
-import { mapOpenaiChatToChatWithNative } from '../../../../router/virtual-router/engine-selection/native-hub-pipeline-semantic-mappers.js';
-import { runResponsesOpenAIRequestCodecWithNative } from '../../../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 const RESPONSES_PARAMETER_KEYS = [
     'model',
     'temperature',
@@ -392,35 +391,22 @@ function buildSubmitToolOutputsPayload(chat, ctx, responsesContext) {
 }
 export class ResponsesSemanticMapper {
     async toChat(format, ctx) {
+        const requestId = typeof ctx.requestId === 'string' && ctx.requestId.trim().length ? ctx.requestId : 'unknown';
         const payload = format.payload || {};
-        if (!isSubmitToolOutputsEndpoint(ctx)) {
-            const codecResult = runResponsesOpenAIRequestCodecWithNative(payload, { requestId: ctx.requestId });
-            const request = isJsonObject(codecResult.request)
-                ? codecResult.request
-                : undefined;
-            const responsesContext = isJsonObject(codecResult.context)
-                ? codecResult.context
-                : undefined;
-            if (request && responsesContext) {
-                const chatEnvelope = mapOpenaiChatToChatWithNative(request, ctx);
-                const missingFields = [];
-                const toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
-                if (toolOutputs?.length) {
-                    chatEnvelope.toolOutputs = toolOutputs;
-                }
-                if (missingFields.length) {
-                    const metadata = chatEnvelope.metadata && typeof chatEnvelope.metadata === 'object'
-                        ? chatEnvelope.metadata
-                        : { context: ctx };
-                    metadata.missingFields = missingFields;
-                    chatEnvelope.metadata = metadata;
-                }
-                chatEnvelope.semantics = attachResponsesSemantics(chatEnvelope.semantics, responsesContext, undefined);
-                return chatEnvelope;
-            }
-        }
+        logHubStageTiming(requestId, 'req_inbound.responses.capture_context', 'start');
+        const captureStart = Date.now();
         const responsesContext = captureResponsesContext(payload, { route: { requestId: ctx.requestId } });
+        logHubStageTiming(requestId, 'req_inbound.responses.capture_context', 'completed', {
+            elapsedMs: Date.now() - captureStart,
+            forceLog: true
+        });
+        logHubStageTiming(requestId, 'req_inbound.responses.build_chat_request', 'start');
+        const buildChatStart = Date.now();
         const { request, toolsNormalized } = buildChatRequestFromResponses(payload, responsesContext);
+        logHubStageTiming(requestId, 'req_inbound.responses.build_chat_request', 'completed', {
+            elapsedMs: Date.now() - buildChatStart,
+            forceLog: true
+        });
         const missingFields = [];
         const messages = normalizeMessages(request.messages, missingFields);
         let toolOutputs = mapToolOutputs(payload.tool_outputs, missingFields);
@@ -441,6 +427,7 @@ export class ResponsesSemanticMapper {
         };
     }
     async fromChat(chat, ctx) {
+        const requestId = typeof ctx.requestId === 'string' && ctx.requestId.trim().length ? ctx.requestId : 'unknown';
         const envelopeMetadata = chat.metadata && isJsonObject(chat.metadata) ? chat.metadata : undefined;
         const responsesContext = selectResponsesContextSnapshot(chat, envelopeMetadata);
         if (isSubmitToolOutputsEndpoint(ctx)) {
@@ -465,13 +452,19 @@ export class ResponsesSemanticMapper {
             messages: chat.messages,
             tools: chat.tools
         };
-        const originalSystemMessages = (chat.messages || [])
-            .filter((message) => Boolean(message && typeof message === 'object' && message.role === 'system'))
-            .map(message => serializeSystemContent(message))
-            .filter((content) => typeof content === 'string' && content.length > 0);
-        responsesContext.originalSystemMessages = originalSystemMessages;
-        const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext, {
-            routeToolCallIdStyle: ctx.toolCallIdStyle
+        if (!Array.isArray(responsesContext.originalSystemMessages) || responsesContext.originalSystemMessages.length === 0) {
+            const originalSystemMessages = (chat.messages || [])
+                .filter((message) => Boolean(message && typeof message === 'object' && message.role === 'system'))
+                .map(message => serializeSystemContent(message))
+                .filter((content) => typeof content === 'string' && content.length > 0);
+            responsesContext.originalSystemMessages = originalSystemMessages;
+        }
+        logHubStageTiming(requestId, 'req_outbound.responses.build_request', 'start');
+        const buildRequestStart = Date.now();
+        const responsesResult = buildResponsesRequestFromChat(requestShape, responsesContext);
+        logHubStageTiming(requestId, 'req_outbound.responses.build_request', 'completed', {
+            elapsedMs: Date.now() - buildRequestStart,
+            forceLog: true
         });
         const responses = responsesResult.request;
         if (chat.parameters && chat.parameters.stream !== undefined) {