@jsonstudio/llms 0.4.2 → 0.4.4

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

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

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

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

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