@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -1,249 +0,0 @@
-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

@@ -1,140 +0,0 @@
-/**
- * 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

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,79 +0,0 @@
-/**
- * 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;