@jsonstudio/llms 0.6.141 → 0.6.187

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

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

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

@@ -0,0 +1,5 @@
+import type { JsonObject } from '../../hub/types/json.js';
+export interface ResponseValidateConfig {
+    strict?: boolean;
+}
+export declare function validateResponsePayload(payload: JsonObject, _config?: ResponseValidateConfig): void;

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

@@ -0,0 +1,76 @@
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+export function validateResponsePayload(payload, _config) {
+    const errors = [];
+    if (!payload.id || typeof payload.id !== 'string') {
+        errors.push('响应缺少有效的id字段');
+    }
+    if (!payload.created || typeof payload.created !== 'number') {
+        errors.push('响应缺少有效的created字段');
+    }
+    if (!payload.model || typeof payload.model !== 'string') {
+        errors.push('响应缺少有效的model字段');
+    }
+    if (!Array.isArray(payload.choices) || payload.choices.length === 0) {
+        errors.push('choices数组不能为空');
+    }
+    else {
+        payload.choices.forEach((choice, idx) => {
+            if (!isRecord(choice)) {
+                errors.push(`choices[${idx}]必须是对象`);
+                return;
+            }
+            if (!choice.message || typeof choice.message !== 'object') {
+                errors.push(`choices[${idx}].message字段必须是对象`);
+            }
+            else if (Array.isArray(choice.message.tool_calls)) {
+                choice.message.tool_calls.forEach((toolCall, tIdx) => {
+                    if (!isRecord(toolCall)) {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}]必须是对象`);
+                        return;
+                    }
+                    if (!toolCall.function || typeof toolCall.function !== 'object') {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function字段必须是对象`);
+                        return;
+                    }
+                    const fn = toolCall.function;
+                    if (typeof fn.name !== 'string') {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.name字段必须是字符串`);
+                    }
+                    if (typeof fn.arguments !== 'string') {
+                        errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.arguments字段必须是字符串`);
+                    }
+                    else {
+                        try {
+                            JSON.parse(fn.arguments);
+                        }
+                        catch {
+                            errors.push(`choices[${idx}].message.tool_calls[${tIdx}].function.arguments必须是有效JSON`);
+                        }
+                    }
+                });
+            }
+        });
+    }
+    if (payload.usage && typeof payload.usage === 'object') {
+        const usage = payload.usage;
+        const promptTokens = usage.prompt_tokens;
+        const completionTokens = usage.completion_tokens;
+        const totalTokens = usage.total_tokens;
+        if (!isNonNegativeNumber(promptTokens) ||
+            !isNonNegativeNumber(completionTokens) ||
+            !isNonNegativeNumber(totalTokens)) {
+            errors.push('usage字段的token必须是非负数');
+        }
+        else if (promptTokens + completionTokens !== totalTokens) {
+            errors.push('usage.total_tokens 应等于 prompt_tokens 与 completion_tokens 之和');
+        }
+    }
+    if (errors.length) {
+        const error = new Error(`GLM响应校验失败:\n${errors.join('\n')}`);
+        error.code = 'compat_response_validation_failed';
+        throw error;
+    }
+}
+function isNonNegativeNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+}

package/dist/conversion/compat/actions/snapshot.d.ts

@@ -0,0 +1,8 @@
+type Phase = 'compat-pre' | 'compat-post';
+export declare function writeCompatSnapshot(options: {
+    phase: Phase;
+    requestId?: string;
+    entryEndpoint?: string;
+    data: unknown;
+}): Promise<void>;
+export {};

package/dist/conversion/compat/actions/snapshot.js

@@ -0,0 +1,21 @@
+import { writeSnapshotViaHooks } from '../../shared/snapshot-hooks.js';
+const SNAPSHOT_FLAG = String(process.env.ROUTECODEX_SNAPSHOT ?? '').toLowerCase();
+const SNAPSHOT_ENABLED = SNAPSHOT_FLAG === '1' || SNAPSHOT_FLAG === 'true';
+export async function writeCompatSnapshot(options) {
+    if (!SNAPSHOT_ENABLED) {
+        return;
+    }
+    try {
+        const endpoint = options.entryEndpoint || '/v1/chat/completions';
+        await writeSnapshotViaHooks({
+            endpoint,
+            stage: options.phase,
+            requestId: options.requestId || 'unknown',
+            data: options.data,
+            verbosity: 'verbose'
+        });
+    }
+    catch {
+        // snapshots are best-effort
+    }
+}

package/dist/conversion/compat/actions/tool-schema.d.ts

@@ -0,0 +1,6 @@
+import type { JsonObject } from '../../hub/types/json.js';
+type UnknownRecord = Record<string, unknown>;
+export declare const sanitizeGLMToolsSchema: (data: UnknownRecord) => UnknownRecord;
+export declare const sanitizeGLMToolsSchemaInPlace: (data: UnknownRecord) => void;
+export declare function sanitizeToolSchema(payload: JsonObject, mode?: 'glm_shell'): JsonObject;
+export {};

package/dist/conversion/compat/actions/tool-schema.js

@@ -0,0 +1,91 @@
+const SHELL_COMMAND_DESCRIPTION = 'Shell command argv tokens. Use ["bash","-lc","<cmd>"] form.';
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const ensureStringArray = (value) => {
+    if (Array.isArray(value) && value.every(item => typeof item === 'string')) {
+        return [...value];
+    }
+    return [];
+};
+const sanitizeShellCommandProperty = (properties) => {
+    const candidate = properties.command;
+    if (isRecord(candidate)) {
+        const command = { ...candidate };
+        delete command.oneOf;
+        command.type = 'array';
+        command.items = { type: 'string' };
+        if (typeof command.description !== 'string' || command.description.length === 0) {
+            command.description = SHELL_COMMAND_DESCRIPTION;
+        }
+        properties.command = command;
+        return;
+    }
+    properties.command = {
+        description: SHELL_COMMAND_DESCRIPTION,
+        type: 'array',
+        items: { type: 'string' }
+    };
+};
+const sanitizeToolFunction = (toolFn, isShell) => {
+    const fn = { ...toolFn };
+    if ('strict' in fn) {
+        delete fn.strict;
+    }
+    if (!fn.parameters || !isRecord(fn.parameters)) {
+        return fn;
+    }
+    const params = { ...fn.parameters };
+    if (isShell) {
+        if (params.properties && isRecord(params.properties)) {
+            params.properties = { ...params.properties };
+        }
+        else {
+            params.properties = {};
+        }
+        sanitizeShellCommandProperty(params.properties);
+        const required = ensureStringArray(params.required);
+        if (!required.includes('command')) {
+            required.push('command');
+        }
+        params.required = required;
+        params.type = typeof params.type === 'string' ? params.type : 'object';
+        params.additionalProperties = typeof params.additionalProperties === 'boolean'
+            ? params.additionalProperties
+            : false;
+    }
+    fn.parameters = params;
+    return fn;
+};
+const sanitizeToolDefinition = (tool) => {
+    const sanitized = { ...tool };
+    if (!sanitized.function || !isRecord(sanitized.function)) {
+        return sanitized;
+    }
+    const fn = sanitizeToolFunction(sanitized.function, sanitized.function.name === 'shell');
+    sanitized.function = fn;
+    return sanitized;
+};
+export const sanitizeGLMToolsSchema = (data) => {
+    const toolsValue = data.tools;
+    if (!Array.isArray(toolsValue)) {
+        return data;
+    }
+    const sanitizedTools = toolsValue.map(tool => (isRecord(tool) ? sanitizeToolDefinition(tool) : tool));
+    return {
+        ...data,
+        tools: sanitizedTools
+    };
+};
+export const sanitizeGLMToolsSchemaInPlace = (data) => {
+    const toolsValue = data.tools;
+    if (!Array.isArray(toolsValue)) {
+        return;
+    }
+    const sanitized = sanitizeGLMToolsSchema(data);
+    data.tools = sanitized.tools;
+};
+export function sanitizeToolSchema(payload, mode = 'glm_shell') {
+    if (mode === 'glm_shell') {
+        return sanitizeGLMToolsSchema(payload);
+    }
+    return payload;
+}

package/dist/conversion/compat/actions/universal-shape-filter.d.ts

@@ -0,0 +1,74 @@
+import type { AdapterContext } from '../../hub/types/chat-envelope.js';
+import type { JsonObject } from '../../hub/types/json.js';
+type RequestMessagesRule = {
+    when?: {
+        role?: 'system' | 'user' | 'assistant' | 'tool';
+        hasToolCalls?: boolean;
+    };
+    action: 'drop' | 'keep' | 'set';
+    set?: Record<string, unknown>;
+};
+export interface FilterConfig {
+    request: {
+        allowTopLevel: string[];
+        messages: {
+            allowedRoles: string[];
+            assistantWithToolCallsContentNull?: boolean;
+            toolContentStringify?: boolean;
+            suppressAssistantToolCalls?: boolean;
+        };
+        tools?: {
+            normalize?: boolean;
+            forceToolChoiceAuto?: boolean;
+        };
+        assistantToolCalls?: {
+            functionArgumentsType?: 'object' | 'string';
+        };
+        messagesRules?: RequestMessagesRule[];
+    };
+    response: {
+        allowTopLevel: string[];
+        choices: {
+            required?: boolean;
+            message: {
+                allow: string[];
+                roleDefault?: string;
+                contentNullWhenToolCalls?: boolean;
+                tool_calls?: {
+                    function?: {
+                        nameRequired?: boolean;
+                        argumentsType?: 'object' | 'string';
+                    };
+                };
+            };
+            finish_reason?: string[];
+        };
+        usage?: {
+            allow: string[];
+        };
+    };
+}
+export declare class UniversalShapeFilter {
+    private readonly cfg;
+    constructor(config: FilterConfig);
+    applyRequestFilter(payload: JsonObject): JsonObject;
+    applyResponseFilter(payload: JsonObject, ctx?: AdapterContext): JsonObject;
+    private shallowPick;
+    private toObjectArgs;
+    private toStringArgs;
+    private normalizeToolContent;
+    private normalizeRequestMessages;
+    private normalizeSingleMessage;
+    private normalizeAssistantToolCalls;
+    private applyMessageRules;
+    private pairToolResults;
+    private normalizeTools;
+    private normalizeSingleTool;
+    private normalizeToolParameters;
+    private enforceShellSchema;
+    private cleanupToolChoice;
+    private normalizeResponseChoice;
+    private normalizeResponseMessage;
+    private normalizeResponseToolCalls;
+}
+export {};