@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/response/provider-response-converter.js

@@ -0,0 +1,249 @@
+import { OpenAIResponseInputNode } from '../nodes/response/openai-response-input-node.js';
+import { AnthropicResponseInputNode } from '../nodes/response/anthropic-response-input-node.js';
+import { ResponsesResponseInputNode } from '../nodes/response/responses-response-input-node.js';
+import { ResponseProcessNode } from '../nodes/process/response-process-node.js';
+import { AnthropicOutputNode } from '../nodes/output/anthropic-output-node.js';
+import { OpenAIOutputNode } from '../nodes/output/openai-output-node.js';
+import { ResponsesOutputNode } from '../nodes/output/responses-output-node.js';
+import { SSEOutputNode } from '../nodes/sse/sse-output-node.js';
+import { NodeType } from '../types/index.js';
+export class ProviderResponseConverter {
+    responseProcessNode;
+    sseOutputNode;
+    responseInputCache = new Map();
+    outputNodeCache = new Map();
+    constructor() {
+        this.responseProcessNode = new ResponseProcessNode('response-process', buildNodeConfig({
+            id: 'response-process',
+            type: NodeType.PROCESS,
+            name: 'Response Process Node',
+            inputFormat: 'openai-chat',
+            outputFormat: 'processed-chat'
+        }));
+        this.sseOutputNode = new SSEOutputNode('response-sse-output', buildNodeConfig({
+            id: 'response-sse-output',
+            type: NodeType.OUTPUT,
+            name: 'Response SSE Output Node',
+            inputFormat: 'processed-chat',
+            outputFormat: 'sse-or-json'
+        }));
+    }
+    async convert(options) {
+        const clientType = inferClientType(options.entryEndpoint);
+        const passthroughStream = extractSseStream(options.providerResponse);
+        if (options.wantsStream && passthroughStream) {
+            return { __sse_responses: passthroughStream };
+        }
+        const responseInput = this.getResponseInputNode(options.providerType);
+        const context = this.buildBaseContext(options);
+        await this.runNode(responseInput, context);
+        await this.runNode(this.responseProcessNode, context);
+        const outputNode = this.getOutputNode(clientType);
+        const outputResult = await this.runNode(outputNode, context);
+        const outputData = (outputResult.data ?? context.data);
+        const sseResult = await this.runNode(this.sseOutputNode, context);
+        const finalData = (sseResult.data ?? context.data);
+        if (finalData?.__sse_responses) {
+            return { __sse_responses: finalData.__sse_responses };
+        }
+        const envelope = (finalData?.conversionResponse ?? outputData?.conversionResponse);
+        if (envelope) {
+            const maybeData = envelope.data;
+            return maybeData ?? envelope;
+        }
+        if (finalData?.response && typeof finalData.response === 'object') {
+            return finalData.response;
+        }
+        if (outputData?.outputData && typeof outputData.outputData === 'object') {
+            return outputData.outputData;
+        }
+        if (finalData?.outputData && typeof finalData.outputData === 'object') {
+            return finalData.outputData;
+        }
+        return outputData ?? context.data;
+    }
+    getResponseInputNode(provider) {
+        if (this.responseInputCache.has(provider)) {
+            return this.responseInputCache.get(provider);
+        }
+        let node;
+        if (provider === 'anthropic') {
+            node = new AnthropicResponseInputNode('anthropic-response-input', buildNodeConfig({
+                id: 'anthropic-response-input',
+                type: NodeType.INPUT,
+                name: 'Anthropic Response Input',
+                inputFormat: 'anthropic-messages',
+                outputFormat: 'openai-chat'
+            }));
+        }
+        else if (provider === 'responses') {
+            node = new ResponsesResponseInputNode('responses-response-input', buildNodeConfig({
+                id: 'responses-response-input',
+                type: NodeType.INPUT,
+                name: 'Responses Response Input',
+                inputFormat: 'openai-responses',
+                outputFormat: 'openai-chat'
+            }));
+        }
+        else {
+            node = new OpenAIResponseInputNode('openai-response-input', buildNodeConfig({
+                id: 'openai-response-input',
+                type: NodeType.INPUT,
+                name: 'OpenAI Response Input',
+                inputFormat: 'openai-chat',
+                outputFormat: 'openai-chat'
+            }));
+        }
+        this.responseInputCache.set(provider, node);
+        return node;
+    }
+    getOutputNode(client) {
+        if (this.outputNodeCache.has(client)) {
+            return this.outputNodeCache.get(client);
+        }
+        let node;
+        if (client === 'anthropic') {
+            node = new AnthropicOutputNode(buildNodeConfig({
+                id: 'anthropic-output',
+                type: NodeType.OUTPUT,
+                name: 'Anthropic Output Node',
+                inputFormat: 'processed-chat',
+                outputFormat: 'anthropic-messages'
+            }));
+        }
+        else if (client === 'responses') {
+            node = new ResponsesOutputNode(buildNodeConfig({
+                id: 'responses-output',
+                type: NodeType.OUTPUT,
+                name: 'Responses Output Node',
+                inputFormat: 'processed-chat',
+                outputFormat: 'openai-responses'
+            }));
+        }
+        else {
+            node = new OpenAIOutputNode(buildNodeConfig({
+                id: 'openai-output',
+                type: NodeType.OUTPUT,
+                name: 'OpenAI Output Node',
+                inputFormat: 'processed-chat',
+                outputFormat: 'openai-chat'
+            }));
+        }
+        this.outputNodeCache.set(client, node);
+        return node;
+    }
+    buildBaseContext(options) {
+        const metadata = {
+            ...(options.metadata || {}),
+            direction: 'response',
+            stage: 'outbound',
+            entryEndpoint: options.entryEndpoint,
+            originalRequest: options.originalRequest ?? undefined,
+            stream: options.wantsStream,
+            clientStream: options.wantsStream,
+            inboundStream: options.wantsStream
+        };
+        const endpoint = options.entryEndpoint.includes('#response')
+            ? options.entryEndpoint
+            : `${options.entryEndpoint}#response`;
+        return {
+            request: {
+                id: options.requestId,
+                timestamp: Date.now(),
+                endpoint,
+                payload: options.providerResponse,
+                context: { metadata },
+                options: {
+                    streamingFormat: options.wantsStream ? 'sse' : 'json'
+                }
+            },
+            data: { payload: options.providerResponse },
+            pipeline: {
+                currentNode: 'response-input',
+                previousResults: [],
+                isPassthrough: false,
+                startTime: Date.now()
+            },
+            nodeConfig: {
+                id: 'response-input',
+                type: NodeType.INPUT,
+                name: 'Response Input',
+                inputFormat: endpoint,
+                outputFormat: 'openai-chat',
+                rules: [],
+                validation: {
+                    strict: false,
+                    required: [],
+                    optional: []
+                },
+                timeout: 30_000,
+                options: {}
+            }
+        };
+    }
+    async runNode(node, context) {
+        context.nodeConfig = node.config;
+        context.pipeline.currentNode = node.id;
+        const result = await node.execute(context);
+        context.pipeline.previousResults.push(result);
+        if (!result.success) {
+            const err = result.error;
+            const message = err instanceof Error
+                ? err.message
+                : (err && typeof err === 'object' && 'message' in err)
+                    ? String(err.message)
+                    : `Node ${node.id} failed`;
+            throw new Error(message);
+        }
+        if (result.data && typeof result.data === 'object') {
+            context.data = {
+                ...(context.data || {}),
+                ...result.data
+            };
+        }
+        return result;
+    }
+}
+function buildNodeConfig(options) {
+    return {
+        id: options.id,
+        type: options.type,
+        name: options.name,
+        description: `${options.name} (provider-response)`,
+        inputFormat: options.inputFormat,
+        outputFormat: options.outputFormat,
+        rules: [],
+        validation: {
+            strict: false,
+            required: [],
+            optional: []
+        },
+        timeout: 30_000,
+        options: {}
+    };
+}
+function inferClientType(endpoint) {
+    const lowered = endpoint.toLowerCase();
+    if (lowered.includes('/v1/messages'))
+        return 'anthropic';
+    if (lowered.includes('/v1/responses'))
+        return 'responses';
+    return 'openai';
+}
+function extractSseStream(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return undefined;
+    }
+    const direct = payload.__sse_responses || payload.__sse_stream;
+    if (direct && typeof direct.pipe === 'function') {
+        return direct;
+    }
+    const nested = payload.data;
+    if (nested && typeof nested === 'object') {
+        const inner = nested.__sse_responses || nested.__sse_stream;
+        if (inner && typeof inner.pipe === 'function') {
+            return inner;
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,140 @@
+/**
+ * SSE双向转换模块统一导出
+ * 支持Chat和Responses协议的JSON↔SSE双向转换
+ */
+import type { ChatCompletionResponse, ChatJsonToSseOptions, ResponsesJsonToSseOptions, ResponsesResponse, SseToChatJsonOptions, SseToResponsesJsonOptions } from './types/index.js';
+import type { AnthropicMessageResponse } from './types/anthropic-types.js';
+import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
+import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+export { ChatJsonToSseConverter } from './json-to-sse/index.js';
+export { ChatSseToJsonConverter } from './sse-to-json/index.js';
+export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
+export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+export * from './shared/utils.js';
+export * from './types/index.js';
+/**
+ * 工厂函数：创建Chat协议转换器
+ */
+export declare function createChatConverters(): {
+    jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+    sseToJson: ChatSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+};
+/**
+ * 工厂函数：创建Responses协议转换器
+ */
+export declare function createResponsesConverters(): {
+    jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+    sseToJson: ResponsesSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+};
+/**
+ * 工厂函数：创建Anthropic协议转换器
+ */
+export declare function createAnthropicConverters(): {
+    jsonToSse: AnthropicJsonToSseConverterCtor;
+    sseToJson: AnthropicSseToJsonConverterCtor;
+    roundTrip(input: AnthropicMessageResponse, options: {
+        requestId: string;
+        model: string;
+    }): Promise<AnthropicMessageResponse>;
+};
+/**
+ * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
+ */
+export declare function createBidirectionalConverters(): {
+    chat: {
+        jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+        sseToJson: ChatSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    };
+    responses: {
+        jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+        sseToJson: ResponsesSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    };
+    anthropic: {
+        jsonToSse: AnthropicJsonToSseConverterCtor;
+        sseToJson: AnthropicSseToJsonConverterCtor;
+        roundTrip(input: AnthropicMessageResponse, options: {
+            requestId: string;
+            model: string;
+        }): Promise<AnthropicMessageResponse>;
+    };
+    /**
+     * 自动检测协议类型并执行转换
+     */
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+};
+/**
+ * 默认转换器实例
+ */
+export declare const chatConverters: {
+    jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+    sseToJson: ChatSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+};
+export declare const responsesConverters: {
+    jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+    sseToJson: ResponsesSseToJsonConverterCtor;
+    /**
+     * 执行完整的回环测试
+     */
+    roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+};
+export declare const bidirectionalConverters: {
+    chat: {
+        jsonToSse: import("./json-to-sse/chat-json-to-sse-converter.js").ChatJsonToSseConverterRefactored;
+        sseToJson: ChatSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ChatCompletionResponse, options: ChatJsonToSseOptions & SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    };
+    responses: {
+        jsonToSse: import("./json-to-sse/responses-json-to-sse-converter.js").ResponsesJsonToSseConverterRefactored;
+        sseToJson: ResponsesSseToJsonConverterCtor;
+        /**
+         * 执行完整的回环测试
+         */
+        roundTrip(input: ResponsesResponse, options: ResponsesJsonToSseOptions & SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    };
+    anthropic: {
+        jsonToSse: AnthropicJsonToSseConverterCtor;
+        sseToJson: AnthropicSseToJsonConverterCtor;
+        roundTrip(input: AnthropicMessageResponse, options: {
+            requestId: string;
+            model: string;
+        }): Promise<AnthropicMessageResponse>;
+    };
+    /**
+     * 自动检测协议类型并执行转换
+     */
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+};
+export declare const anthropicConverters: {
+    jsonToSse: AnthropicJsonToSseConverterCtor;
+    sseToJson: AnthropicSseToJsonConverterCtor;
+    roundTrip(input: AnthropicMessageResponse, options: {
+        requestId: string;
+        model: string;
+    }): Promise<AnthropicMessageResponse>;
+};
+export { defaultSseCodecRegistry, SseCodecRegistry, type SseCodec, type SseProtocol, type JsonToSseContext, type SseToJsonContext, type NormalizeSseContext } from './registry/sse-codec-registry.js';

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

@@ -0,0 +1,115 @@
+/**
+ * SSE双向转换模块统一导出
+ * 支持Chat和Responses协议的JSON↔SSE双向转换
+ */
+import { ChatJsonToSseConverter as ChatJsonToSseConverterCtor } from './json-to-sse/index.js';
+import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { ResponsesJsonToSseConverter as ResponsesJsonToSseConverterCtor } from './json-to-sse/index.js';
+import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
+import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+// Chat协议转换器
+export { ChatJsonToSseConverter } from './json-to-sse/index.js';
+export { ChatSseToJsonConverter } from './sse-to-json/index.js';
+// Responses协议转换器
+export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
+export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+// 共享工具导出
+export * from './shared/utils.js';
+// 序列化器暂时禁用以专注核心SSE转换功能
+// export * from './shared/serializers/index.js';
+// 类型导出
+export * from './types/index.js';
+/**
+ * 工厂函数：创建Chat协议转换器
+ */
+export function createChatConverters() {
+    const jsonToSse = new ChatJsonToSseConverterCtor();
+    const sseToJson = new ChatSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        /**
+         * 执行完整的回环测试
+         */
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建Responses协议转换器
+ */
+export function createResponsesConverters() {
+    const jsonToSse = new ResponsesJsonToSseConverterCtor();
+    const sseToJson = new ResponsesSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        /**
+         * 执行完整的回环测试
+         */
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建Anthropic协议转换器
+ */
+export function createAnthropicConverters() {
+    const jsonToSse = new AnthropicJsonToSseConverterCtor();
+    const sseToJson = new AnthropicSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
+ */
+export function createBidirectionalConverters() {
+    const chat = createChatConverters();
+    const responses = createResponsesConverters();
+    const anthropic = createAnthropicConverters();
+    return {
+        chat,
+        responses,
+        anthropic,
+        /**
+         * 自动检测协议类型并执行转换
+         */
+        async autoConvert(input, options = {}) {
+            // 根据输入数据的结构自动检测协议类型
+            if (input.object === 'chat.completion') {
+                return await chat.roundTrip(input, options);
+            }
+            else if (input.object === 'response') {
+                return await responses.roundTrip(input, options);
+            }
+            else if (input.type === 'message') {
+                return await anthropic.roundTrip(input, options);
+            }
+            else {
+                throw new Error(`无法识别的协议类型: ${input.object}`);
+            }
+        }
+    };
+}
+/**
+ * 默认转换器实例
+ */
+export const chatConverters = createChatConverters();
+export const responsesConverters = createResponsesConverters();
+export const bidirectionalConverters = createBidirectionalConverters();
+export const anthropicConverters = createAnthropicConverters();
+export { defaultSseCodecRegistry, SseCodecRegistry } from './registry/sse-codec-registry.js';

package/dist/conversion/conversion-v3/sse/json-to-sse/anthropic-json-to-sse-converter.d.ts

@@ -0,0 +1,11 @@
+import type { AnthropicMessageResponse, AnthropicJsonToSseOptions } from '../types/anthropic-types.js';
+/**
+ * Minimal Anthropic JSON → SSE converter (v3)
+ * - Emits a compact but spec-aligned event sequence for text content.
+ * - Tool use blocks: emits content_block_start (tool_use), input_json_delta (whole), content_block_stop.
+ *
+ * NOTE: This converter purposely avoids any tool governance. It only maps shapes/fields.
+ */
+export declare class AnthropicJsonToSseConverter {
+    convertResponseToJsonToSse(payload: AnthropicMessageResponse, options: AnthropicJsonToSseOptions): Promise<import('node:stream').Readable>;
+}

package/dist/conversion/conversion-v3/sse/json-to-sse/anthropic-json-to-sse-converter.js

@@ -0,0 +1,79 @@
+import { PassThrough } from 'node:stream';
+/**
+ * Minimal Anthropic JSON → SSE converter (v3)
+ * - Emits a compact but spec-aligned event sequence for text content.
+ * - Tool use blocks: emits content_block_start (tool_use), input_json_delta (whole), content_block_stop.
+ *
+ * NOTE: This converter purposely avoids any tool governance. It only maps shapes/fields.
+ */
+export class AnthropicJsonToSseConverter {
+    async convertResponseToJsonToSse(payload, options) {
+        const stream = new PassThrough();
+        const write = (event, data) => {
+            stream.write(`event: ${event}\n`);
+            stream.write(`data: ${JSON.stringify(data)}\n\n`);
+        };
+        const messageId = payload.id || `msg_${Date.now()}`;
+        const model = payload.model || options.model || 'unknown';
+        // 1) message_start
+        write('message_start', {
+            type: 'message_start',
+            message: { id: messageId, type: 'message', role: 'assistant', model }
+        });
+        // 2) Iterate content blocks
+        let index = 0;
+        for (const block of payload.content || []) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const type = block.type;
+            if (type === 'text') {
+                write('content_block_start', {
+                    type: 'content_block_start',
+                    index,
+                    content_block: { type: 'text' }
+                });
+                const text = String(block.text || '');
+                if (text) {
+                    write('content_block_delta', {
+                        type: 'content_block_delta',
+                        index,
+                        delta: { type: 'text_delta', text }
+                    });
+                }
+                write('content_block_stop', { type: 'content_block_stop', index });
+                index += 1;
+            }
+            else if (type === 'tool_use') {
+                const id = String(block.id || `call_${Math.random().toString(36).slice(2, 10)}`);
+                const name = String(block.name || 'unknown_tool');
+                const input = block.input ?? {};
+                write('content_block_start', {
+                    type: 'content_block_start',
+                    index,
+                    content_block: { type: 'tool_use', id, name }
+                });
+                try {
+                    const partial_json = JSON.stringify(input);
+                    write('content_block_delta', {
+                        type: 'content_block_delta',
+                        index,
+                        delta: { type: 'input_json_delta', partial_json }
+                    });
+                }
+                catch {
+                    // best-effort: skip delta on stringify error
+                }
+                write('content_block_stop', { type: 'content_block_stop', index });
+                index += 1;
+            }
+        }
+        // 3) message_delta (stop_reason hint)
+        const stop_reason = payload.stop_reason || 'end_turn';
+        write('message_delta', { type: 'message_delta', delta: { stop_reason } });
+        // 4) message_stop
+        write('message_stop', { type: 'message_stop' });
+        // DONE
+        stream.end();
+        return stream;
+    }
+}

package/dist/conversion/conversion-v3/sse/json-to-sse/chat-json-to-sse-converter.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Chat JSON → SSE转换器（重构版本）
+ * 使用函数化架构：事件生成 + 序列化 + 写入分离
+ */
+import { ChatCompletionRequest, ChatCompletionResponse, ChatJsonToSseContext, ChatJsonToSseOptions, ChatSseEventStream, DEFAULT_CHAT_CONVERSION_CONFIG } from '../types/index.js';
+/**
+ * 重构后的Chat JSON到SSE转换器
+ * 采用函数化架构，专注于编排而非具体业务逻辑
+ */
+export declare class ChatJsonToSseConverterRefactored {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_CHAT_CONVERSION_CONFIG>);
+    /**
+     * 将Chat Completion请求转换为SSE流
+     */
+    convertRequestToJsonToSse(request: ChatCompletionRequest, options: ChatJsonToSseOptions): Promise<ChatSseEventStream>;
+    /**
+     * 将Chat Completion响应转换为SSE流
+     */
+    convertResponseToJsonToSse(response: ChatCompletionResponse, options: ChatJsonToSseOptions): Promise<ChatSseEventStream>;
+    /**
+     * 使用函数化架构处理请求转换
+     */
+    private processRequestToSseWithFunctions;
+    /**
+     * 使用函数化架构处理响应转换
+     */
+    private processResponseToSseWithFunctions;
+    /**
+     * 验证请求格式
+     */
+    private validateRequest;
+    /**
+     * 验证响应格式
+     */
+    private validateResponse;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 包装错误
+     */
+    private wrapError;
+    /**
+     * 处理流错误
+     */
+    private handleStreamError;
+    /**
+     * 完成流
+     */
+    private completeStream;
+    /**
+     * 中止流
+     */
+    private abortStream;
+    /**
+     * 创建请求上下文
+     */
+    private createRequestContext;
+    /**
+     * 创建响应上下文
+     */
+    private createResponseContext;
+    /**
+     * 获取上下文
+     */
+    getContext(requestId: string): ChatJsonToSseContext | undefined;
+    /**
+     * 清理上下文
+     */
+    clearContext(requestId: string): void;
+    /**
+     * 获取所有活跃的上下文
+     */
+    getActiveContexts(): Map<string, ChatJsonToSseContext>;
+}
+export declare const ChatJsonToSseConverter: typeof ChatJsonToSseConverterRefactored;