@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,106 @@
+/**
+ * Chat SSE → JSON转换器
+ * 将SSE事件流聚合为ChatCompletion响应
+ */
+import { ChatCompletionResponse, ChatSseEvent, SseToChatJsonOptions, ChatEventStats, DEFAULT_CHAT_CONVERSION_CONFIG } from '../types/index.js';
+/**
+ * Chat SSE到JSON转换器
+ */
+export declare class ChatSseToJsonConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_CHAT_CONVERSION_CONFIG>);
+    /**
+     * 将SSE流转换为Chat Completion响应
+     */
+    convertSseToJson(sseStream: AsyncIterable<ChatSseEvent> | AsyncIterable<string | Buffer>, options: SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    /**
+     * 将SSE流转换为流式响应
+     */
+    aggregateSseStream(sseStream: AsyncIterable<ChatSseEvent> | AsyncIterable<string | Buffer>, options: SseToChatJsonOptions): AsyncGenerator<ChatCompletionResponse>;
+    /**
+     * 确保输入流转换为 ChatSseEvent 流
+     */
+    private ensureEventStream;
+    /**
+     * 将SSE文本块解析为Chat事件
+     */
+    private parseSseChunk;
+    /**
+     * 创建转换上下文
+     */
+    private createContext;
+    /**
+     * 处理SSE事件
+     */
+    private processSseEvent;
+    /**
+     * 处理chat_chunk事件
+     */
+    private processChatChunk;
+    /**
+     * 处理choice
+     */
+    private processChoice;
+    /**
+     * 创建choice构建器
+     */
+    private createChoiceBuilder;
+    /**
+     * 处理delta
+     */
+    private processDelta;
+    /**
+     * 处理tool_call delta
+     */
+    private processToolCallDelta;
+    /**
+     * 更新响应中的choice
+     */
+    private updateResponseChoice;
+    /**
+     * 处理done事件
+     */
+    private processDoneEvent;
+    /**
+     * 处理error事件
+     */
+    private processErrorEvent;
+    /**
+     * 构建部分响应
+     */
+    private buildPartialResponse;
+    /**
+     * 完成响应构建
+     */
+    private finalizeResponse;
+    /**
+     * 构建使用量信息
+     */
+    private buildUsageInfo;
+    /**
+     * 验证SSE事件
+     */
+    private validateSseEvent;
+    /**
+     * 验证Chat chunk
+     */
+    private validateChatChunk;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 获取转换统计
+     */
+    getStats(requestId: string): ChatEventStats | undefined;
+    /**
+     * 清理上下文
+     */
+    cleanup(requestId: string): void;
+    /**
+     * 清理所有上下文
+     */
+    cleanupAll(): void;
+}
+export declare const defaultChatSseToJsonConverter: ChatSseToJsonConverter;

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

@@ -0,0 +1,540 @@
+/**
+ * Chat SSE → JSON转换器
+ * 将SSE事件流聚合为ChatCompletion响应
+ */
+import { DEFAULT_CHAT_CONVERSION_CONFIG, CHAT_CONVERSION_ERROR_CODES } from '../types/index.js';
+import { TimeUtils, ErrorUtils } from '../shared/utils.js';
+/**
+ * Chat SSE到JSON转换器
+ */
+export class ChatSseToJsonConverter {
+    config = DEFAULT_CHAT_CONVERSION_CONFIG;
+    contexts = new Map();
+    constructor(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    /**
+     * 将SSE流转换为Chat Completion响应
+     */
+    async convertSseToJson(sseStream, options) {
+        const context = this.createContext(options);
+        this.contexts.set(options.requestId, context);
+        try {
+            // 处理SSE流
+            for await (const event of this.ensureEventStream(sseStream)) {
+                await this.processSseEvent(event, context);
+            }
+            // 验证并返回最终响应
+            return this.finalizeResponse(context);
+        }
+        catch (error) {
+            context.eventStats.errorCount++;
+            options.onError?.(error);
+            throw ErrorUtils.wrapError(error, 'SSE to JSON conversion failed');
+        }
+        finally {
+            this.cleanup(options.requestId);
+        }
+    }
+    /**
+     * 将SSE流转换为流式响应
+     */
+    async *aggregateSseStream(sseStream, options) {
+        const context = this.createContext(options);
+        this.contexts.set(options.requestId, context);
+        try {
+            for await (const event of this.ensureEventStream(sseStream)) {
+                await this.processSseEvent(event, context);
+                // 每处理完一个chunk就生成部分响应
+                const partialResponse = this.buildPartialResponse(context);
+                if (partialResponse) {
+                    options.onPartialResponse?.(partialResponse);
+                    yield partialResponse;
+                }
+            }
+            // 返回最终响应
+            const finalResponse = this.finalizeResponse(context);
+            options.onCompletion?.(finalResponse);
+            yield finalResponse;
+        }
+        catch (error) {
+            context.eventStats.errorCount++;
+            options.onError?.(error);
+            throw ErrorUtils.wrapError(error, 'SSE stream aggregation failed');
+        }
+        finally {
+            this.cleanup(options.requestId);
+        }
+    }
+    /**
+     * 确保输入流转换为 ChatSseEvent 流
+     */
+    async *ensureEventStream(source) {
+        let textBuffer = '';
+        for await (const chunk of source) {
+            if (typeof chunk === 'string' || Buffer.isBuffer(chunk)) {
+                const normalizedChunk = (typeof chunk === 'string' ? chunk : chunk.toString())
+                    .replace(/\r\n/g, '\n');
+                textBuffer += normalizedChunk;
+                let delimiterIndex = textBuffer.indexOf('\n\n');
+                while (delimiterIndex !== -1) {
+                    const rawEvent = textBuffer.slice(0, delimiterIndex);
+                    textBuffer = textBuffer.slice(delimiterIndex + 2);
+                    const trimmed = rawEvent.trim();
+                    if (trimmed) {
+                        yield this.parseSseChunk(trimmed);
+                    }
+                    delimiterIndex = textBuffer.indexOf('\n\n');
+                }
+            }
+            else if (chunk?.event) {
+                yield chunk;
+            }
+            else {
+                throw ErrorUtils.createError('Unsupported SSE chunk format', CHAT_CONVERSION_ERROR_CODES.PARSE_ERROR, { chunk });
+            }
+        }
+        const trailing = textBuffer.trim();
+        if (trailing) {
+            yield this.parseSseChunk(trailing);
+        }
+    }
+    /**
+     * 将SSE文本块解析为Chat事件
+     */
+    parseSseChunk(chunk) {
+        const lines = chunk.trim().split('\n');
+        let eventType;
+        let dataValue = '';
+        for (const line of lines) {
+            if (line.startsWith('event:')) {
+                eventType = line.substring(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                dataValue = line.substring(5).trim();
+            }
+        }
+        if (!eventType) {
+            throw ErrorUtils.createError('SSE event type is required', CHAT_CONVERSION_ERROR_CODES.VALIDATION_ERROR, { chunk });
+        }
+        return {
+            event: eventType,
+            type: eventType,
+            timestamp: TimeUtils.now(),
+            data: dataValue,
+            protocol: 'chat',
+            direction: 'sse_to_json'
+        };
+    }
+    /**
+     * 创建转换上下文
+     */
+    createContext(options) {
+        return {
+            requestId: options.requestId,
+            model: options.model,
+            options: { ...DEFAULT_CHAT_CONVERSION_CONFIG, ...options },
+            startTime: TimeUtils.now(),
+            aggregatedChunks: [],
+            currentResponse: {
+                id: '',
+                object: 'chat.completion',
+                created: 0,
+                model: options.model,
+                choices: []
+            },
+            choiceIndexMap: new Map(),
+            toolCallIndexMap: new Map(),
+            eventStats: {
+                totalChunks: 0,
+                totalTokens: 0,
+                totalChoices: 0,
+                totalToolCalls: 0,
+                startTime: TimeUtils.now(),
+                tokenRate: 0,
+                chunkRate: 0,
+                errorCount: 0,
+                retryCount: 0
+            },
+            isCompleted: false
+        };
+    }
+    /**
+     * 处理SSE事件
+     */
+    async processSseEvent(event, context) {
+        try {
+            // 验证事件格式
+            if (context.options.validateChunks) {
+                this.validateSseEvent(event);
+            }
+            context.eventStats.totalChunks++;
+            context.options.onEvent?.(event);
+            switch (event.event) {
+                case 'chat_chunk':
+                    await this.processChatChunk(event, context);
+                    break;
+                case 'chat.done':
+                    await this.processDoneEvent(event, context);
+                    break;
+                case 'error':
+                    await this.processErrorEvent(event, context);
+                    break;
+                case 'ping':
+                    // 心跳事件，忽略处理
+                    break;
+                default:
+                    throw ErrorUtils.createError(`Unknown SSE event type: ${event.event}`, CHAT_CONVERSION_ERROR_CODES.PARSE_ERROR, { event });
+            }
+            // 更新统计
+            this.updateStats(context);
+        }
+        catch (error) {
+            context.eventStats.errorCount++;
+            throw ErrorUtils.wrapError(error, `Failed to process SSE event: ${event.event}`);
+        }
+    }
+    /**
+     * 处理chat_chunk事件
+     */
+    async processChatChunk(event, context) {
+        try {
+            const chunk = JSON.parse(event.data);
+            // 验证chunk格式
+            if (context.options.validateChunks) {
+                this.validateChatChunk(chunk);
+            }
+            context.aggregatedChunks.push(chunk);
+            // 初始化响应结构（如果是第一个chunk）
+            if (!context.currentResponse.id && chunk.id) {
+                context.currentResponse.id = chunk.id;
+                context.currentResponse.object = 'chat.completion';
+                context.currentResponse.created = chunk.created;
+                context.currentResponse.model = chunk.model;
+            }
+            // 处理choices
+            if (chunk.choices && Array.isArray(chunk.choices)) {
+                for (const choice of chunk.choices) {
+                    await this.processChoice(choice, context);
+                }
+            }
+        }
+        catch (error) {
+            throw ErrorUtils.wrapError(error, 'Failed to parse chat_chunk');
+        }
+    }
+    /**
+     * 处理choice
+     */
+    async processChoice(choice, context) {
+        const choiceIndex = choice.index || 0;
+        // 获取或创建choice构建器
+        let choiceBuilder = context.choiceIndexMap.get(choiceIndex);
+        if (!choiceBuilder) {
+            choiceBuilder = this.createChoiceBuilder(choiceIndex);
+            context.choiceIndexMap.set(choiceIndex, choiceBuilder);
+            context.currentResponse.choices?.push({
+                index: choiceIndex,
+                message: {},
+                finish_reason: null,
+                logprobs: choice.logprobs
+            });
+        }
+        // 处理delta
+        if (choice.delta) {
+            await this.processDelta(choice.delta, choiceBuilder, context);
+        }
+        // 处理finish_reason
+        if (choice.finish_reason) {
+            choiceBuilder.finishReason = choice.finish_reason;
+            choiceBuilder.isCompleted = true;
+        }
+        // 更新响应中的choice
+        this.updateResponseChoice(choiceIndex, choiceBuilder, context);
+    }
+    /**
+     * 创建choice构建器
+     */
+    createChoiceBuilder(index) {
+        return {
+            index,
+            delta: {},
+            finishReason: null,
+            logprobs: null,
+            messageBuilder: {
+                role: undefined,
+                content: '',
+                name: undefined,
+                functionCall: undefined,
+                toolCalls: [],
+                toolCallId: undefined,
+                isCompleted: false
+            },
+            isCompleted: false,
+            accumulatedContent: '',
+            toolCallBuilders: new Map()
+        };
+    }
+    /**
+     * 处理delta
+     */
+    async processDelta(delta, choiceBuilder, context) {
+        const messageBuilder = choiceBuilder.messageBuilder;
+        // 处理role
+        if (delta.role) {
+            messageBuilder.role = delta.role;
+        }
+        // 处理reasoning
+        if (delta.reasoning) {
+            messageBuilder.content += delta.reasoning;
+            choiceBuilder.accumulatedContent += delta.reasoning;
+        }
+        // 处理content
+        if (delta.content) {
+            messageBuilder.content += delta.content;
+            choiceBuilder.accumulatedContent += delta.content;
+        }
+        // 处理function_call
+        if (delta.function_call) {
+            if (delta.function_call.name) {
+                messageBuilder.functionCall = {
+                    ...messageBuilder.functionCall,
+                    name: delta.function_call.name
+                };
+            }
+            if (delta.function_call.arguments) {
+                messageBuilder.functionCall = {
+                    ...messageBuilder.functionCall,
+                    arguments: (messageBuilder.functionCall?.arguments || '') + delta.function_call.arguments
+                };
+            }
+        }
+        // 处理tool_calls
+        if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
+            for (const toolCallDelta of delta.tool_calls) {
+                await this.processToolCallDelta(toolCallDelta, choiceBuilder, context);
+            }
+        }
+        // 合并delta到choiceBuilder
+        choiceBuilder.delta = { ...choiceBuilder.delta, ...delta };
+    }
+    /**
+     * 处理tool_call delta
+     */
+    async processToolCallDelta(toolCallDelta, choiceBuilder, context) {
+        const toolCallIndex = toolCallDelta.index;
+        // 获取或创建tool_call构建器
+        let toolCallBuilder = choiceBuilder.toolCallBuilders.get(toolCallIndex);
+        if (!toolCallBuilder) {
+            toolCallBuilder = {
+                index: toolCallIndex,
+                id: '',
+                type: 'function',
+                function: {
+                    name: '',
+                    arguments: ''
+                },
+                isCompleted: false,
+                accumulatedArguments: ''
+            };
+            choiceBuilder.toolCallBuilders.set(toolCallIndex, toolCallBuilder);
+        }
+        // 更新tool_call构建器
+        if (toolCallDelta.id) {
+            toolCallBuilder.id = toolCallDelta.id;
+        }
+        if (toolCallDelta.type) {
+            toolCallBuilder.type = toolCallDelta.type;
+        }
+        if (toolCallDelta.function) {
+            if (toolCallDelta.function.name) {
+                toolCallBuilder.function.name = toolCallDelta.function.name;
+            }
+            if (toolCallDelta.function.arguments) {
+                toolCallBuilder.function.arguments += toolCallDelta.function.arguments;
+                toolCallBuilder.accumulatedArguments += toolCallDelta.function.arguments;
+            }
+        }
+        // 标记完成（当arguments不为空且id存在时）
+        if (toolCallBuilder.id && toolCallBuilder.function.arguments) {
+            toolCallBuilder.isCompleted = true;
+        }
+    }
+    /**
+     * 更新响应中的choice
+     */
+    updateResponseChoice(choiceIndex, choiceBuilder, context) {
+        const responseChoice = context.currentResponse.choices?.[choiceIndex];
+        if (!responseChoice)
+            return;
+        const messageBuilder = choiceBuilder.messageBuilder;
+        // 构建message
+        const message = {
+            role: messageBuilder.role || 'assistant'
+        };
+        if (messageBuilder.content) {
+            message.content = messageBuilder.content;
+        }
+        if (messageBuilder.functionCall) {
+            message.function_call = messageBuilder.functionCall;
+        }
+        // 构建tool_calls
+        const toolCalls = [];
+        for (const [_, toolCallBuilder] of choiceBuilder.toolCallBuilders) {
+            if (toolCallBuilder.id) {
+                toolCalls.push({
+                    id: toolCallBuilder.id,
+                    type: toolCallBuilder.type || 'function',
+                    function: toolCallBuilder.function
+                });
+            }
+        }
+        if (toolCalls.length > 0) {
+            message.tool_calls = toolCalls;
+        }
+        responseChoice.message = message;
+        responseChoice.finish_reason = choiceBuilder.finishReason;
+        context.eventStats.totalToolCalls += toolCalls.length;
+    }
+    /**
+     * 处理done事件
+     */
+    async processDoneEvent(event, context) {
+        context.isCompleted = true;
+        // 解析done事件数据（如果有的话）
+        try {
+            const doneData = JSON.parse(event.data);
+            if (doneData.totalTokens) {
+                context.eventStats.totalTokens = doneData.totalTokens;
+            }
+        }
+        catch (e) {
+            // 忽略解析错误
+        }
+    }
+    /**
+     * 处理error事件
+     */
+    async processErrorEvent(event, context) {
+        try {
+            const errorData = JSON.parse(event.data);
+            const error = new Error(errorData.error || 'Unknown SSE error');
+            error.code = errorData.code || 'SSE_ERROR';
+            throw ErrorUtils.createError(error.message, CHAT_CONVERSION_ERROR_CODES.STREAM_ERROR, { errorData, event });
+        }
+        catch (parseError) {
+            throw ErrorUtils.createError(`SSE error event: ${event.data}`, CHAT_CONVERSION_ERROR_CODES.STREAM_ERROR, { event });
+        }
+    }
+    /**
+     * 构建部分响应
+     */
+    buildPartialResponse(context) {
+        const choices = context.currentResponse.choices || [];
+        if (choices.length === 0)
+            return null;
+        return {
+            id: context.currentResponse.id || '',
+            object: 'chat.completion',
+            created: context.currentResponse.created || 0,
+            model: context.currentResponse.model,
+            choices: choices.map(choice => ({
+                ...choice,
+                // 确保message对象存在
+                message: choice.message || { role: 'assistant', content: '' }
+            }))
+        };
+    }
+    /**
+     * 完成响应构建
+     */
+    finalizeResponse(context) {
+        const choices = context.currentResponse.choices || [];
+        // 确保所有choices都已完成
+        for (const choice of choices) {
+            if (!choice.finish_reason) {
+                choice.finish_reason = 'stop';
+            }
+        }
+        // 构建usage信息
+        const usage = this.buildUsageInfo(context);
+        context.eventStats.totalChoices = choices.length;
+        context.eventStats.endTime = TimeUtils.now();
+        context.eventStats.duration = (context.eventStats.endTime - context.eventStats.startTime) / 1000;
+        return {
+            id: context.currentResponse.id || `chat_${context.requestId}`,
+            object: 'chat.completion',
+            created: context.currentResponse.created || Math.floor(Date.now() / 1000),
+            model: context.currentResponse.model,
+            choices,
+            usage: usage || undefined
+        };
+    }
+    /**
+     * 构建使用量信息
+     */
+    buildUsageInfo(context) {
+        // 这里可以基于token计数来计算usage
+        // 暂时返回null，后续可以实现更精确的token计数
+        return null;
+    }
+    /**
+     * 验证SSE事件
+     */
+    validateSseEvent(event) {
+        if (!event.event) {
+            throw ErrorUtils.createError('SSE event type is required', CHAT_CONVERSION_ERROR_CODES.VALIDATION_ERROR, { event });
+        }
+        if (!event.data) {
+            throw ErrorUtils.createError('SSE event data is required', CHAT_CONVERSION_ERROR_CODES.VALIDATION_ERROR, { event });
+        }
+        const validEvents = ['chat_chunk', 'chat.done', 'error', 'ping'];
+        if (!validEvents.includes(event.event)) {
+            throw ErrorUtils.createError(`Invalid SSE event type: ${event.event}`, CHAT_CONVERSION_ERROR_CODES.VALIDATION_ERROR, { event });
+        }
+    }
+    /**
+     * 验证Chat chunk
+     */
+    validateChatChunk(chunk) {
+        if (!chunk.object || chunk.object !== 'chat.completion.chunk') {
+            throw ErrorUtils.createError('Invalid chat completion chunk object', CHAT_CONVERSION_ERROR_CODES.PARSE_ERROR, { chunk });
+        }
+        if (!Array.isArray(chunk.choices)) {
+            throw ErrorUtils.createError('Chunk choices must be an array', CHAT_CONVERSION_ERROR_CODES.PARSE_ERROR, { chunk });
+        }
+    }
+    /**
+     * 更新统计信息
+     */
+    updateStats(context) {
+        const now = TimeUtils.now();
+        const duration = (now - context.eventStats.startTime) / 1000;
+        context.eventStats.duration = duration;
+        context.eventStats.chunkRate = context.eventStats.totalChunks / duration;
+        context.eventStats.tokenRate = context.eventStats.totalTokens / duration;
+    }
+    /**
+     * 获取转换统计
+     */
+    getStats(requestId) {
+        const context = this.contexts.get(requestId);
+        return context?.eventStats;
+    }
+    /**
+     * 清理上下文
+     */
+    cleanup(requestId) {
+        this.contexts.delete(requestId);
+    }
+    /**
+     * 清理所有上下文
+     */
+    cleanupAll() {
+        this.contexts.clear();
+    }
+}
+// 创建默认转换器实例
+export const defaultChatSseToJsonConverter = new ChatSseToJsonConverter();

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

@@ -0,0 +1,6 @@
+/**
+ * SSE→JSON转换模块导出
+ */
+export { ChatSseToJsonConverter, defaultChatSseToJsonConverter } from './chat-sse-to-json-converter.js';
+export { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from './responses-sse-to-json-converter.js';
+export type { SseToChatJsonOptions, SseToChatJsonContext, ChatEventStats, SseToResponsesJsonOptions, SseToResponsesJsonContext, ResponsesEventStats } from '../types/index.js';

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

@@ -0,0 +1,7 @@
+/**
+ * SSE→JSON转换模块导出
+ */
+// Chat协议转换器
+export { ChatSseToJsonConverter, defaultChatSseToJsonConverter } from './chat-sse-to-json-converter.js';
+// Responses协议转换器（重构版本）
+export { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from './responses-sse-to-json-converter.js';