@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,154 @@
+import { buildResponsesPayloadFromChat, runStandardChatRequestFilters } from '../index.js';
+import { captureResponsesContext, buildChatRequestFromResponses } from '../shared/responses-request-adapter.js';
+import { FilterEngine, ResponseToolTextCanonicalizeFilter, ResponseToolArgumentsStringifyFilter, ResponseFinishInvariantsFilter } from '../../filters/index.js';
+// Ported from root package (no behavior change). Types relaxed.
+export class ResponsesOpenAIConversionCodec {
+    dependencies;
+    id = 'responses-openai';
+    initialized = false;
+    ctxMap = new Map();
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async initialize() { this.initialized = true; }
+    async convertRequest(payload, profile, context) {
+        await this.ensureInit();
+        const dto = {
+            data: payload,
+            route: {
+                providerId: 'unknown',
+                modelId: (payload && typeof payload === 'object' && payload.model) ? String(payload.model) : 'unknown',
+                requestId: context.requestId ?? `req_${Date.now()}`,
+                timestamp: Date.now()
+            },
+            metadata: {
+                endpoint: context.endpoint ?? context.entryEndpoint,
+                entryEndpoint: context.entryEndpoint,
+                targetProtocol: profile.outgoingProtocol
+            },
+            debug: { enabled: false, stages: {} }
+        };
+        // Build context and convert to OpenAI Chat request
+        const ctx = captureResponsesContext(dto.data, dto);
+        let { request: chatRequest, toolsNormalized } = buildChatRequestFromResponses(dto.data, ctx);
+        // V3 专用：确保进入下游 Provider 的是“非流式 Chat”形状。
+        // Responses 入口的流式语义由 llmswitch-core/上层 SSE 合成处理；
+        // 这里显式移除 Chat 请求上的顶层 stream 标记，避免部分上游 Provider
+        // 因为 stream=true 直接切换到 SSE，而下游仍按 JSON 客户端解析。
+        try {
+            if (chatRequest && typeof chatRequest === 'object' && 'stream' in chatRequest) {
+                delete chatRequest.stream;
+            }
+        }
+        catch {
+            // best-effort：失败时保留原样，但不会阻断请求
+        }
+        if (toolsNormalized)
+            ctx.toolsNormalized = toolsNormalized;
+        // Capture tool results from Responses request input for pairing on response mapping
+        try {
+            const inputArr = Array.isArray(dto.data?.input) ? dto.data.input : [];
+            const results = [];
+            for (const it of inputArr) {
+                if (!it || typeof it !== 'object')
+                    continue;
+                const t = String(it.type || '').toLowerCase();
+                if (t === 'tool_result' || t === 'tool_message' || t === 'function_call_output') {
+                    const tool_call_id = it.tool_call_id || it.call_id || it.tool_use_id;
+                    let output = undefined;
+                    const rawOut = it.output;
+                    if (typeof rawOut === 'string')
+                        output = rawOut;
+                    else if (rawOut && typeof rawOut === 'object') {
+                        try {
+                            output = JSON.stringify(rawOut);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    results.push({ tool_call_id, output });
+                }
+            }
+            if (results.length > 0)
+                ctx.__captured_tool_results = results;
+        }
+        catch { /* ignore */ }
+        if (context.requestId)
+            this.ctxMap.set(context.requestId, ctx);
+        // 统一走 Chat 请求过滤链路，保证 /v1/responses 与 /v1/chat 在工具治理上的一致性
+        const ctxForFilters = {
+            ...context,
+            requestId: dto.route.requestId,
+            entryEndpoint: context.entryEndpoint ?? dto.metadata?.entryEndpoint ?? context.endpoint,
+            endpoint: context.endpoint ?? dto.metadata?.endpoint
+        };
+        return runStandardChatRequestFilters(chatRequest, profile, ctxForFilters);
+    }
+    async convertResponse(payload, _profile, context) {
+        await this.ensureInit();
+        // unwrap nested { data: {...} } wrappers until we reach an object
+        const unwrap = (obj) => {
+            let cur = obj;
+            const guard = new Set();
+            while (cur && typeof cur === 'object' && !Array.isArray(cur) && !guard.has(cur)) {
+                guard.add(cur);
+                if ('choices' in cur || 'id' in cur || 'object' in cur) {
+                    break;
+                }
+                if ('data' in cur && cur.data && typeof cur.data === 'object') {
+                    cur = cur.data;
+                    continue;
+                }
+                break;
+            }
+            return cur;
+        };
+        const unwrapped = unwrap(payload);
+        const dto = {
+            data: unwrapped,
+            metadata: {
+                requestId: context.requestId ?? `req_${Date.now()}`,
+                pipelineId: context.metadata?.pipelineId ?? 'conversion-router',
+                processingTime: 0,
+                stages: []
+            }
+        };
+        const ctx = context.requestId ? this.ctxMap.get(context.requestId) : undefined;
+        if (context.requestId)
+            this.ctxMap.delete(context.requestId);
+        // Run response-side filter pipeline与 Chat 通路保持一致（工具治理统一在 Chat canonical 上完成）
+        const resCtxBase = {
+            requestId: context.requestId ?? dto.metadata.requestId,
+            model: undefined,
+            endpoint: context.entryEndpoint || context.endpoint,
+            profile: 'openai-chat',
+            debug: { emit: () => { } }
+        };
+        const engine = new FilterEngine();
+        // Response-side filters：文本标准化 → TOON decode（可选）→ shell/basics → finish_reason 不变式
+        engine.registerFilter(new ResponseToolTextCanonicalizeFilter()); // response_pre
+        try {
+            const { ResponseToolArgumentsToonDecodeFilter } = await import('../../filters/index.js');
+            engine.registerFilter(new ResponseToolArgumentsToonDecodeFilter()); // response_pre, runs before stringify
+        }
+        catch { /* optional */ }
+        engine.registerFilter(new ResponseToolArgumentsStringifyFilter()); // response_post
+        engine.registerFilter(new ResponseFinishInvariantsFilter()); // response_post
+        let staged = await engine.run('response_pre', dto.data, resCtxBase);
+        staged = await engine.run('response_map', staged, resCtxBase);
+        staged = await engine.run('response_post', staged, resCtxBase);
+        const governedChat = staged;
+        // Convert provider chat response back to Responses payload using captured context（仅做形状映射）
+        const responsesJson = buildResponsesPayloadFromChat(governedChat, ctx);
+        // No fallback append here: pairing must be produced upstream or by standard bridge mapping.
+        // Debug snapshot after mapping to Responses JSON (non-stream)
+        try {
+            const { writeSnapshotViaHooks } = await import('../shared/snapshot-hooks.js');
+            await writeSnapshotViaHooks({ endpoint: '/v1/responses', stage: 'response_mapped_json', requestId: context.requestId || `req_${Date.now()}`, data: responsesJson, verbosity: 'verbose' });
+        }
+        catch { /* ignore */ }
+        return responsesJson;
+    }
+    async ensureInit() { if (!this.initialized)
+        await this.initialize(); }
+}

package/dist/conversion/config/config-manager.d.ts

@@ -0,0 +1,212 @@
+/**
+ * 配置管理模块
+ *
+ * 提供统一的配置读取、设置和管理功能
+ */
+/**
+ * 配置接口定义
+ */
+export interface ConversionConfig {
+    /** HTTP服务器配置 */
+    httpserver?: {
+        port: number;
+        host: string;
+    };
+    /** 虚拟路由器配置 */
+    virtualrouter?: {
+        inputProtocol?: string;
+        outputProtocol?: string;
+        providers?: Record<string, ProviderConfig>;
+        routing?: {
+            default?: string[];
+            [key: string]: string[];
+        };
+    };
+    /** 服务工具配置 */
+    serverTools?: {
+        replace?: Record<string, {
+            enabled: boolean;
+        }>;
+        enabled?: boolean;
+    };
+    /** 转换配置（V2/V3 版本切换相关） */
+    conversion?: {
+        /** 默认使用的转换版本 */
+        defaultVersion?: 'v2' | 'v3' | 'auto';
+        /** 允许附加自定义配置字段 */
+        [key: string]: unknown;
+    };
+}
+/**
+ * Provider 配置接口
+ */
+export interface ProviderConfig {
+    id: string;
+    enabled: boolean;
+    type: 'openai' | 'anthropic' | 'responses' | 'gemini' | 'custom';
+    baseUrl?: string;
+    apiKey?: string[];
+    auth?: {
+        type: 'apikey' | 'oauth';
+        apiKey?: string;
+    };
+    models?: Record<string, ModelConfig>;
+}
+/**
+ * 模型配置接口
+ */
+export interface ModelConfig {
+    supportsStreaming?: boolean;
+    compatibility?: {
+        type?: string;
+        config?: any;
+    };
+}
+/**
+ * 配置管理器类
+ */
+export declare class ConfigManager {
+    private static instance;
+    private config;
+    private constructor();
+    /**
+     * 获取单例实例
+     */
+    static getInstance(): ConfigManager;
+    /**
+     * 设置配置
+     *
+     * @param config 要设置的配置
+     * @param options 选项
+     */
+    static setConfig(config: Partial<ConversionConfig>, options?: {
+        merge?: boolean;
+        validate?: boolean;
+        save?: boolean;
+        source?: string;
+    }): void;
+    /**
+     * 获取配置
+     *
+     * @param path 指定配置路径（可选）
+     * @returns 配置对象
+     */
+    static getConfig(path?: string): Promise<ConversionConfig>;
+    /**
+     * 重新加载配置
+     */
+    static reloadConfig(): Promise<ConversionConfig>;
+    /**
+     * 验证配置
+     */
+    private validateConfig;
+    /**
+     * 深度合并对象（仅在内存中操作，不做任何持久化）
+     */
+    private deepMerge;
+    /**
+     * 获取配置摘要
+     */
+    static getConfigSummary(): {
+        totalProviders: number;
+        enabledProviders: string[];
+        outputProtocol: string;
+        inputProtocol: string;
+        routingDefaults: string[];
+        hasConversionConfig: boolean;
+    };
+    /**
+     * 获取 provider 配置
+     */
+    static getProviderConfig(providerName: string): ProviderConfig | null;
+    /**
+     * 检查 provider 是否可用
+     */
+    static isProviderEnabled(providerName: string): boolean;
+    /**
+     * 设置 provider 启用状态
+     */
+    static setProviderEnabled(providerName: string, enabled: boolean): void;
+    /**
+    /**
+     * 获取输出协议
+     */
+    static getOutputProtocol(): string;
+    /**
+     * 设置输出协议
+     */
+    static setOutputProtocol(protocol: string): void;
+    /**
+     * 获取输入协议
+     */
+    static getInputProtocol(): string;
+    /**
+     * 设置输入协议
+     */
+    static setInputProtocol(protocol: string): void;
+    /**
+   * 获取路由配置
+     */
+    static getRoutingConfig(): any;
+    /**
+   * 设置路由配置
+     */
+    static setRoutingConfig(routing: any): void;
+    /**
+   * 获取 V3 转换配置
+     */
+    static getConversionConfig(): any;
+    /**
+    * 设置 V3 转换配置
+     */
+    static setConversionConfig(conversion: any): void;
+}
+/**
+ * 便捷函数：设置配置
+ */
+export declare function setConfig(config: Partial<ConversionConfig>, options?: {
+    merge?: boolean;
+    validate?: boolean;
+    save?: boolean;
+    source?: string;
+}): void;
+/**
+ * 便捷函数：获取配置
+ */
+export declare function getConfig(path?: string): Promise<ConversionConfig>;
+/**
+ * 便捷函数：重新加载配置
+ */
+export declare function reloadConfig(): Promise<ConversionConfig>;
+/**
+ * 便捷函数：获取配置摘要
+ */
+export declare function getConfigSummary(): ReturnType<typeof ConfigManager.getConfigSummary>;
+/**
+ * 便捷函数：获取 Provider 配置
+ */
+export declare function getProviderConfig(providerName: string): ProviderConfig | null;
+/**
+ * 便捷函数：检查 Provider 状态
+ */
+export declare function isProviderEnabled(providerName: string): boolean;
+/**
+ * 便捷函数：设置 Provider 状态
+ */
+export declare function setProviderEnabled(providerName: string, enabled: boolean): void;
+/**
+ * 便捷函数：获取输出协议
+ */
+export declare function getOutputProtocol(): string;
+/**
+ * 便捷函数：设置输出协议
+ */
+export declare function setOutputProtocol(protocol: string): void;
+/**
+ * 便捷函数：获取输入协议
+ */
+export declare function getInputProtocol(): string;
+/**
+ * 便捷函数：设置输入协议
+ */
+export declare function setInputProtocol(protocol: string): void;

package/dist/conversion/config/config-manager.js

@@ -0,0 +1,310 @@
+/**
+ * 配置管理模块
+ *
+ * 提供统一的配置读取、设置和管理功能
+ */
+/**
+ * 配置管理器类
+ */
+export class ConfigManager {
+    static instance;
+    config = null;
+    constructor() {
+        // 不在构造函数中建立任何默认配置，必须由外部显式调用 setConfig
+        // 注入配置，避免 llmswitch-core 内部产生隐式默认行为。
+    }
+    /**
+     * 获取单例实例
+     */
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+     * 设置配置
+     *
+     * @param config 要设置的配置
+     * @param options 选项
+     */
+    static setConfig(config, options = {}) {
+        const manager = ConfigManager.getInstance();
+        try {
+            // 合并配置
+            const base = manager.config ?? {};
+            manager.config = options.merge === false
+                ? { ...base, ...config }
+                : manager.deepMerge(base, config);
+            // 验证配置
+            if (options.validate !== false) {
+                manager.validateConfig(manager.config);
+            }
+            console.log(`Config updated successfully (source: ${options.source || 'manual'})`);
+        }
+        catch (error) {
+            console.error('Failed to set config:', error);
+            throw new Error(`Failed to set config: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * 获取配置
+     *
+     * @param path 指定配置路径（可选）
+     * @returns 配置对象
+     */
+    static async getConfig(path) {
+        const manager = ConfigManager.getInstance();
+        // 为保持签名兼容，保留 path 参数但忽略它；
+        // 真正的配置加载应由上层完成后通过 setConfig 注入。
+        if (!manager.config) {
+            throw new Error('Conversion config has not been initialized. Use ConfigManager.setConfig() before getConfig().');
+        }
+        return manager.config;
+    }
+    /**
+     * 重新加载配置
+     */
+    static async reloadConfig() {
+        // 不再尝试从磁盘重载配置，仅简单委托给 getConfig，
+        // 由外部在调用前决定是否需要更新内存中的配置快照。
+        return ConfigManager.getConfig();
+    }
+    /**
+     * 验证配置
+     */
+    validateConfig(config) {
+        if (!config) {
+            throw new Error('Config cannot be null');
+        }
+        // 验证虚拟路由器配置
+        if (config.virtualrouter) {
+            if (!config.virtualrouter.outputProtocol) {
+                throw new Error('virtualrouter.outputProtocol is required');
+            }
+            if (!config.virtualrouter.providers) {
+                throw new Error('virtualrouter.providers is required');
+            }
+            // 验证每个 provider 配置
+            for (const [name, provider] of Object.entries(config.virtualrouter.providers)) {
+                if (!provider.id) {
+                    throw new Error(`Provider ${name} missing id`);
+                }
+                if (typeof provider.type !== 'string') {
+                    throw new Error(`Provider ${name} type must be a string`);
+                }
+            }
+        }
+    }
+    /**
+     * 深度合并对象（仅在内存中操作，不做任何持久化）
+     */
+    deepMerge(target, source) {
+        if (!source)
+            return target;
+        const result = { ...target };
+        for (const key in source) {
+            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                result[key] = this.deepMerge(result[key] || {}, source[key]);
+            }
+            else {
+                result[key] = source[key];
+            }
+        }
+        return result;
+    }
+    /**
+     * 获取配置摘要
+     */
+    static getConfigSummary() {
+        const manager = ConfigManager.getInstance();
+        const config = manager.config || {};
+        const providers = config.virtualrouter?.providers || {};
+        const enabled = Object.entries(providers)
+            .filter(([_, provider]) => provider.enabled)
+            .map(([name, _]) => name);
+        return {
+            totalProviders: Object.keys(providers).length,
+            enabledProviders: enabled,
+            outputProtocol: config.virtualrouter?.outputProtocol || 'unknown',
+            inputProtocol: config.virtualrouter?.inputProtocol || 'unknown',
+            routingDefaults: config.virtualrouter?.routing?.default || [],
+            hasConversionConfig: !!config.conversion
+        };
+    }
+    /**
+     * 获取 provider 配置
+     */
+    static getProviderConfig(providerName) {
+        const manager = ConfigManager.getInstance();
+        return manager.config?.virtualrouter?.providers?.[providerName] || null;
+    }
+    /**
+     * 检查 provider 是否可用
+     */
+    static isProviderEnabled(providerName) {
+        const provider = ConfigManager.getProviderConfig(providerName);
+        return provider?.enabled || false;
+    }
+    /**
+     * 设置 provider 启用状态
+     */
+    static setProviderEnabled(providerName, enabled) {
+        const manager = ConfigManager.getInstance();
+        if (!manager.config || !manager.config.virtualrouter?.providers?.[providerName]) {
+            return;
+        }
+        manager.config.virtualrouter.providers[providerName].enabled = enabled;
+    }
+    /**
+    /**
+     * 获取输出协议
+     */
+    static getOutputProtocol() {
+        const manager = ConfigManager.getInstance();
+        return manager.config?.virtualrouter?.outputProtocol || 'openai';
+    }
+    /**
+     * 设置输出协议
+     */
+    static setOutputProtocol(protocol) {
+        const manager = ConfigManager.getInstance();
+        if (!manager.config) {
+            manager.config = {};
+        }
+        if (!manager.config.virtualrouter) {
+            manager.config.virtualrouter = {};
+        }
+        manager.config.virtualrouter.outputProtocol = protocol;
+        console.log(`Output protocol changed to: ${protocol}`);
+    }
+    /**
+     * 获取输入协议
+     */
+    static getInputProtocol() {
+        const manager = ConfigManager.getInstance();
+        return manager.config?.virtualrouter?.inputProtocol || 'openai';
+    }
+    /**
+     * 设置输入协议
+     */
+    static setInputProtocol(protocol) {
+        const manager = ConfigManager.getInstance();
+        if (!manager.config) {
+            manager.config = {};
+        }
+        if (!manager.config.virtualrouter) {
+            manager.config.virtualrouter = {};
+        }
+        manager.config.virtualrouter.inputProtocol = protocol;
+        console.log(`Input protocol changed to: ${protocol}`);
+    }
+    /**
+   * 获取路由配置
+     */
+    static getRoutingConfig() {
+        const manager = ConfigManager.getInstance();
+        return manager.config?.virtualrouter?.routing || {};
+    }
+    /**
+   * 设置路由配置
+     */
+    static setRoutingConfig(routing) {
+        const manager = ConfigManager.getInstance();
+        if (!manager.config) {
+            manager.config = {};
+        }
+        if (!manager.config.virtualrouter) {
+            manager.config.virtualrouter = {};
+        }
+        manager.config.virtualrouter.routing = routing;
+        console.log('Routing config updated');
+    }
+    /**
+   * 获取 V3 转换配置
+     */
+    static getConversionConfig() {
+        const manager = ConfigManager.getInstance();
+        return manager.config?.conversion || {};
+    }
+    /**
+    * 设置 V3 转换配置
+     */
+    static setConversionConfig(conversion) {
+        const manager = ConfigManager.getInstance();
+        if (!manager.config) {
+            manager.config = {};
+        }
+        if (!manager.config.conversion) {
+            manager.config.conversion = {};
+        }
+        manager.config.conversion = manager.deepMerge(manager.config.conversion, conversion);
+        console.log('Conversion config updated');
+    }
+}
+/**
+ * 便捷函数：设置配置
+ */
+export function setConfig(config, options) {
+    ConfigManager.setConfig(config, options);
+}
+/**
+ * 便捷函数：获取配置
+ */
+export async function getConfig(path) {
+    return ConfigManager.getConfig(path);
+}
+/**
+ * 便捷函数：重新加载配置
+ */
+export async function reloadConfig() {
+    return ConfigManager.reloadConfig();
+}
+/**
+ * 便捷函数：获取配置摘要
+ */
+export function getConfigSummary() {
+    return ConfigManager.getConfigSummary();
+}
+/**
+ * 便捷函数：获取 Provider 配置
+ */
+export function getProviderConfig(providerName) {
+    return ConfigManager.getProviderConfig(providerName);
+}
+/**
+ * 便捷函数：检查 Provider 状态
+ */
+export function isProviderEnabled(providerName) {
+    return ConfigManager.isProviderEnabled(providerName);
+}
+/**
+ * 便捷函数：设置 Provider 状态
+ */
+export function setProviderEnabled(providerName, enabled) {
+    ConfigManager.setProviderEnabled(providerName, enabled);
+}
+/**
+ * 便捷函数：获取输出协议
+ */
+export function getOutputProtocol() {
+    return ConfigManager.getOutputProtocol();
+}
+/**
+ * 便捷函数：设置输出协议
+ */
+export function setOutputProtocol(protocol) {
+    ConfigManager.setOutputProtocol(protocol);
+}
+/**
+ * 便捷函数：获取输入协议
+ */
+export function getInputProtocol() {
+    return ConfigManager.getInputProtocol();
+}
+/**
+ * 便捷函数：设置输入协议
+ */
+export function setInputProtocol(protocol) {
+    ConfigManager.setInputProtocol(protocol);
+}

package/dist/conversion/conversion-v3/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export { V3ToStandardNodeAdapter } from './v3-to-standard-adapter.js';
+export type { V3ToStandardAdapterOptions } from './v3-to-standard-adapter.js';

package/dist/conversion/conversion-v3/adapters/index.js

@@ -0,0 +1 @@
+export { V3ToStandardNodeAdapter } from './v3-to-standard-adapter.js';