@jsonstudio/llms 0.6.147 → 0.6.198

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

@@ -3,7 +3,7 @@ import { resolveBridgePolicy, resolvePolicyActions } from '../shared/bridge-poli
 import { normalizeChatMessageContent } from '../shared/chat-output-normalizer.js';
 import { mapBridgeToolsToChat } from '../shared/tool-mapping.js';
 import { prepareGeminiToolsForBridge } from '../shared/gemini-tool-utils.js';
-import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta } from '../shared/responses-reasoning-registry.js';
+import { registerResponsesReasoning, consumeResponsesReasoning, registerResponsesOutputTextMeta, consumeResponsesOutputTextMeta, consumeResponsesPayloadSnapshot, registerResponsesPayloadSnapshot, consumeResponsesPassthrough, registerResponsesPassthrough } from '../shared/responses-reasoning-registry.js';
 function isObject(v) {
     return !!v && typeof v === 'object' && !Array.isArray(v);
 }
@@ -285,6 +285,20 @@ export function buildOpenAIChatFromGeminiResponse(payload) {
     if (preservedOutputMeta) {
         chatResp.__responses_output_text_meta = preservedOutputMeta;
     }
+    const payloadSnapshot = consumeResponsesPayloadSnapshot(chatResp.id);
+    if (payloadSnapshot) {
+        registerResponsesPayloadSnapshot(chatResp.id, payloadSnapshot);
+        if (typeof chatResp.request_id !== 'string') {
+            chatResp.request_id = chatResp.id;
+        }
+    }
+    const passthroughPayload = consumeResponsesPassthrough(chatResp.id);
+    if (passthroughPayload) {
+        registerResponsesPassthrough(chatResp.id, passthroughPayload);
+        if (typeof chatResp.request_id !== 'string') {
+            chatResp.request_id = chatResp.id;
+        }
+    }
     return chatResp;
 }
 export function buildGeminiFromOpenAIChat(chatResp) {

package/dist/conversion/compat/actions/auto-thinking.d.ts

@@ -0,0 +1,6 @@
+import type { JsonObject } from '../../hub/types/json.js';
+export interface AutoThinkingConfig {
+    modelPrefixes?: string[];
+    excludePrefixes?: string[];
+}
+export declare function applyAutoThinking(payload: JsonObject, config?: AutoThinkingConfig): JsonObject;

package/dist/conversion/compat/actions/auto-thinking.js

@@ -0,0 +1,25 @@
+export function applyAutoThinking(payload, config) {
+    if (!config) {
+        return payload;
+    }
+    const record = payload;
+    const modelId = typeof record.model === 'string' ? record.model.toLowerCase().trim() : '';
+    if (!modelId) {
+        return payload;
+    }
+    const prefixes = config.modelPrefixes ?? [];
+    const exclude = config.excludePrefixes ?? [];
+    const matches = prefixes.length === 0
+        ? true
+        : prefixes.some(prefix => modelId.startsWith(prefix.toLowerCase()));
+    const excluded = exclude.some(prefix => modelId.startsWith(prefix.toLowerCase()));
+    if (!matches || excluded) {
+        return payload;
+    }
+    const thinkingNode = record.thinking;
+    if (thinkingNode && typeof thinkingNode === 'object') {
+        return payload;
+    }
+    record.thinking = { type: 'enabled' };
+    return payload;
+}

package/dist/conversion/compat/actions/field-mapping.d.ts

@@ -0,0 +1,14 @@
+type MappingType = 'string' | 'number' | 'boolean' | 'object' | 'array';
+export interface FieldMapping {
+    sourcePath: string;
+    targetPath: string;
+    type: MappingType;
+    transform?: string;
+}
+export interface FieldMappingConfig {
+    incomingMappings: FieldMapping[];
+    outgoingMappings: FieldMapping[];
+}
+type UnknownRecord = Record<string, unknown>;
+export declare function applyFieldMappings(payload: UnknownRecord, mappings: FieldMapping[]): UnknownRecord;
+export {};

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

@@ -0,0 +1,155 @@
+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) {
+    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/qwen-transform.d.ts

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

package/dist/conversion/compat/actions/qwen-transform.js

@@ -0,0 +1,209 @@
+const MODEL_MAP = {
+    'gpt-3.5-turbo': 'qwen-turbo',
+    'gpt-4': 'qwen3-coder-plus',
+    'gpt-4-turbo': 'qwen3-coder-plus',
+    'gpt-4o': 'qwen3-coder-plus'
+};
+const FINISH_REASON_MAP = {
+    stop: 'stop',
+    length: 'length',
+    tool_calls: 'tool_calls',
+    content_filter: 'content_filter'
+};
+const isRecord = (value) => typeof value === 'object' && value !== null;
+export function applyQwenRequestTransform(payload) {
+    const cloned = structuredClone(payload);
+    const transformed = convertToQwenRequest(cloned);
+    return transformed;
+}
+export function applyQwenResponseTransform(payload) {
+    const cloned = structuredClone(payload);
+    const transformed = transformQwenResponseToOpenAI(cloned);
+    return transformed;
+}
+function convertToQwenRequest(request) {
+    const qwenRequest = {};
+    const mappedModel = mapModelName(typeof request.model === 'string' ? request.model : undefined);
+    if (mappedModel) {
+        qwenRequest.model = mappedModel;
+    }
+    if (Array.isArray(request.messages)) {
+        qwenRequest.messages = structuredClone(request.messages);
+        const normalizedMessages = request.messages
+            .map(message => normalizeMessage(message))
+            .filter((entry) => entry !== null);
+        if (normalizedMessages.length > 0) {
+            qwenRequest.input = normalizedMessages;
+        }
+    }
+    const parameters = extractParameters(request);
+    if (Object.keys(parameters).length > 0) {
+        qwenRequest.parameters = parameters;
+    }
+    if (typeof request.stream === 'boolean') {
+        qwenRequest.stream = request.stream;
+    }
+    if (isRecord(request.response_format)) {
+        qwenRequest.response_format = structuredClone(request.response_format);
+    }
+    if (typeof request.user === 'string') {
+        qwenRequest.user = request.user;
+    }
+    if (Array.isArray(request.tools)) {
+        qwenRequest.tools = sanitizeTools(request.tools);
+    }
+    if (isRecord(request.metadata)) {
+        qwenRequest.metadata = structuredClone(request.metadata);
+    }
+    return qwenRequest;
+}
+function sanitizeTools(tools) {
+    return tools.map(tool => {
+        if (!isRecord(tool)) {
+            return tool;
+        }
+        const normalized = {};
+        if (typeof tool.type === 'string') {
+            normalized.type = tool.type;
+        }
+        if (isRecord(tool.function)) {
+            normalized.function = structuredClone(tool.function);
+        }
+        return Object.keys(normalized).length > 0 ? normalized : tool;
+    });
+}
+function normalizeMessage(message) {
+    if (!isRecord(message)) {
+        return null;
+    }
+    const role = typeof message.role === 'string' ? message.role : 'user';
+    const content = normalizeMessageContent(message.content);
+    return { role, content };
+}
+function normalizeMessageContent(content) {
+    if (content === undefined || content === null) {
+        return [{ text: '' }];
+    }
+    if (typeof content === 'string') {
+        return [{ text: content }];
+    }
+    if (Array.isArray(content)) {
+        return content.map(chunk => normalizeContentChunk(chunk));
+    }
+    if (isRecord(content) && typeof content.text === 'string') {
+        return [{ text: content.text }];
+    }
+    return [{ text: JSON.stringify(content) }];
+}
+function normalizeContentChunk(chunk) {
+    if (typeof chunk === 'string') {
+        return { text: chunk };
+    }
+    if (isRecord(chunk)) {
+        if (typeof chunk.text === 'string') {
+            return { text: chunk.text };
+        }
+        return structuredClone(chunk);
+    }
+    return { text: String(chunk) };
+}
+function extractParameters(request) {
+    const parameters = {};
+    const numericFields = [
+        { key: 'temperature', target: 'temperature' },
+        { key: 'top_p', target: 'top_p' },
+        { key: 'frequency_penalty', target: 'frequency_penalty' },
+        { key: 'presence_penalty', target: 'presence_penalty' },
+        { key: 'max_tokens', target: 'max_output_tokens' }
+    ];
+    for (const field of numericFields) {
+        const value = request[field.key];
+        if (typeof value === 'number') {
+            parameters[field.target] = value;
+        }
+    }
+    if (request.stop !== undefined) {
+        const stops = Array.isArray(request.stop) ? request.stop : [request.stop];
+        const sequences = stops.filter(item => typeof item === 'string');
+        if (sequences.length > 0) {
+            parameters.stop_sequences = sequences;
+        }
+    }
+    if (typeof request.debug === 'boolean') {
+        parameters.debug = request.debug;
+    }
+    return parameters;
+}
+function transformQwenResponseToOpenAI(response) {
+    const data = isRecord(response.data) ? response.data : response;
+    const usage = isRecord(data.usage)
+        ? structuredClone(data.usage)
+        : {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0
+        };
+    const transformed = {
+        id: typeof data.id === 'string' ? data.id : `chatcmpl-${Date.now()}`,
+        object: 'chat.completion',
+        created: typeof data.created === 'number' ? data.created : Math.floor(Date.now() / 1000),
+        model: typeof data.model === 'string' ? data.model : 'qwen-turbo',
+        choices: transformChoices(data.choices),
+        usage,
+        _transformed: true,
+        _originalFormat: 'qwen',
+        _targetFormat: 'openai'
+    };
+    return transformed;
+}
+function transformChoices(rawChoices) {
+    if (!Array.isArray(rawChoices)) {
+        return [];
+    }
+    return rawChoices.map((choice, index) => {
+        const choiceObj = isRecord(choice) ? choice : {};
+        const messageObj = isRecord(choiceObj.message) ? choiceObj.message : {};
+        return {
+            index: typeof choiceObj.index === 'number' ? choiceObj.index : index,
+            message: {
+                role: typeof messageObj.role === 'string' ? messageObj.role : 'assistant',
+                content: typeof messageObj.content === 'string' ? messageObj.content : '',
+                tool_calls: transformToolCalls(messageObj.tool_calls)
+            },
+            finish_reason: transformFinishReason(typeof choiceObj.finish_reason === 'string' ? choiceObj.finish_reason : undefined)
+        };
+    });
+}
+function transformToolCalls(toolCalls) {
+    if (!Array.isArray(toolCalls)) {
+        return [];
+    }
+    return toolCalls.map((toolCall, index) => {
+        const toolCallObj = isRecord(toolCall) ? toolCall : {};
+        const fnObj = isRecord(toolCallObj.function) ? toolCallObj.function : {};
+        const id = typeof toolCallObj.id === 'string'
+            ? toolCallObj.id
+            : `call_${Date.now()}_${index}`;
+        const name = typeof fnObj.name === 'string' ? fnObj.name : '';
+        const args = typeof fnObj.arguments === 'string'
+            ? fnObj.arguments
+            : JSON.stringify(fnObj.arguments ?? {});
+        return {
+            id,
+            type: 'function',
+            function: { name, arguments: args }
+        };
+    });
+}
+function transformFinishReason(reason) {
+    if (!reason) {
+        return 'stop';
+    }
+    return FINISH_REASON_MAP[reason] ?? reason;
+}
+function mapModelName(model) {
+    if (!model) {
+        return undefined;
+    }
+    return MODEL_MAP[model] ?? model;
+}

package/dist/conversion/compat/actions/request-rules.d.ts

@@ -0,0 +1,24 @@
+import type { JsonObject } from '../../hub/types/json.js';
+export interface RequestRulesConfig {
+    tools?: {
+        function?: {
+            removeKeys?: string[];
+        };
+    };
+    messages?: {
+        assistantToolCalls?: {
+            function?: {
+                removeKeys?: string[];
+            };
+        };
+    };
+    topLevel?: {
+        conditional?: Array<{
+            when?: {
+                tools?: 'empty' | 'present';
+            };
+            remove?: string[];
+        }>;
+    };
+}
+export declare function applyRequestRules(payload: JsonObject, config?: RequestRulesConfig): JsonObject;

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

@@ -0,0 +1,63 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+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;
+}

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

@@ -0,0 +1,14 @@
+import type { JsonObject } from '../../hub/types/json.js';
+export interface ResponseBlacklistConfig {
+    paths?: string[];
+    keepCritical?: boolean;
+}
+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

@@ -0,0 +1,85 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isTraversable(value) {
+    return Array.isArray(value) || isRecord(value);
+}
+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;
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { JsonObject } from '../../hub/types/json.js';
+export interface ResponseNormalizeConfig {
+    finishReasonMap?: Record<string, string>;
+}
+export declare function normalizeResponsePayload(payload: JsonObject, config?: ResponseNormalizeConfig): JsonObject;