@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,73 @@
+/**
+ * SSE事件解析器
+ * 负责将SSE文本帧解析为标准化的SSE事件对象
+ */
+import { BaseSseEvent } from '../../types/index.js';
+export interface SseParserConfig {
+    enableStrictValidation: boolean;
+    enableEventRecovery: boolean;
+    maxEventSize: number;
+    allowedEventTypes: Set<string>;
+}
+export interface SseParseResult {
+    success: boolean;
+    event?: BaseSseEvent;
+    error?: string;
+    rawData: string;
+}
+export declare const DEFAULT_SSE_PARSER_CONFIG: SseParserConfig;
+/**
+ * SSE原始事件数据
+ */
+export interface RawSseEvent {
+    id?: string;
+    event: string;
+    data: string;
+    retry?: string;
+    timestamp?: number;
+}
+/**
+ * 将原始SSE行组装为事件
+ */
+export declare function assembleSseEvent(lines: string[]): RawSseEvent | null;
+/**
+ * 解析SSE事件文本为标准化事件对象
+ */
+export declare function parseSseEvent(sseText: string, config?: SseParserConfig): SseParseResult;
+/**
+ * 解析SSE流（处理多事件数据）
+ */
+export declare function parseSseStream(sseData: string, config?: SseParserConfig): Generator<SseParseResult>;
+/**
+ * 流式解析SSE数据
+ */
+export declare function parseSseStreamAsync(asyncSseData: AsyncIterable<string>, config?: SseParserConfig): AsyncGenerator<SseParseResult>;
+/**
+ * 创建SSE解析器工厂
+ */
+export declare function createSseParser(config?: Partial<SseParserConfig>): {
+    /**
+     * 解析单个事件
+     */
+    parseEvent(sseText: string): SseParseResult;
+    /**
+     * 解析多事件流
+     */
+    parseStream(sseData: string): Generator<SseParseResult>;
+    /**
+     * 异步解析流
+     */
+    parseStreamAsync(asyncSseData: AsyncIterable<string>): AsyncGenerator<SseParseResult>;
+    /**
+     * 获取当前配置
+     */
+    getConfig(): SseParserConfig;
+    /**
+     * 添加允许的事件类型
+     */
+    addEventType(eventType: string): void;
+    /**
+     * 移除允许的事件类型
+     */
+    removeEventType(eventType: string): void;
+};

package/dist/conversion/conversion-v3/sse/sse-to-json/parsers/sse-parser.js

@@ -0,0 +1,332 @@
+/**
+ * SSE事件解析器
+ * 负责将SSE文本帧解析为标准化的SSE事件对象
+ */
+// 默认配置
+export const DEFAULT_SSE_PARSER_CONFIG = {
+    enableStrictValidation: true,
+    enableEventRecovery: true,
+    maxEventSize: 64 * 1024, // 64KB
+    allowedEventTypes: new Set([
+        // Chat事件类型
+        'chunk',
+        'done',
+        'error',
+        'heartbeat',
+        // Responses事件类型 - canonical格式
+        'response.created',
+        'response.in_progress',
+        'response.output_item.added',
+        'response.content_part.added',
+        'response.output_text.delta',
+        'response.reasoning_text.delta',
+        'response.reasoning_signature.delta',
+        'response.reasoning_image.delta',
+        'response.content_part.done',
+        'response.output_item.done',
+        'response.function_call_arguments.delta',
+        'response.function_call_arguments.done',
+        'response.required_action',
+        'response.completed',
+        'response.done',
+        'response.error',
+        'response.cancelled',
+        // Legacy内部事件类型（向后兼容）
+        'response.start',
+        'output_item.start',
+        'content_part.start',
+        'content_part.delta',
+        'function_call.start',
+        'function_call.delta',
+        'function_call.done',
+        'reasoning.start',
+        'reasoning.delta',
+        'reasoning.done',
+        'required_action'
+    ])
+};
+/**
+ * 解析单行SSE数据
+ */
+function parseSseLine(line) {
+    if (!line || line.trim() === '') {
+        return {};
+    }
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) {
+        return { field: line, value: '' };
+    }
+    const field = line.substring(0, colonIndex).trim();
+    let value = line.substring(colonIndex + 1).trim();
+    // 标准SSE：冒号后可选空格
+    if (line[colonIndex + 1] === ' ') {
+        value = line.substring(colonIndex + 2);
+    }
+    return { field, value };
+}
+/**
+ * 将原始SSE行组装为事件
+ */
+export function assembleSseEvent(lines) {
+    if (lines.length === 0)
+        return null;
+    const event = {
+        event: 'message', // 默认事件类型
+        data: ''
+    };
+    for (const line of lines) {
+        const { field, value } = parseSseLine(line);
+        if (!field)
+            continue;
+        switch (field) {
+            case 'id':
+                event.id = value;
+                break;
+            case 'event':
+                event.event = value;
+                break;
+            case 'data':
+                event.data = event.data ? event.data + '\n' + value : value;
+                break;
+            case 'retry':
+                event.retry = value;
+                break;
+            case 'timestamp':
+                event.timestamp = parseInt(value, 10);
+                break;
+            // 忽略其他字段
+        }
+    }
+    return event;
+}
+/**
+ * 解析JSON数据
+ */
+function safeJsonParse(data) {
+    try {
+        // 处理特殊的[DONE]标记
+        if (data === '[DONE]') {
+            return '[DONE]';
+        }
+        return JSON.parse(data);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON data: ${error.message}`);
+    }
+}
+/**
+ * 验证事件类型
+ */
+function validateEventType(eventType, config) {
+    if (!config.enableStrictValidation) {
+        return true;
+    }
+    return config.allowedEventTypes.has(eventType);
+}
+/**
+ * 创建基础事件对象
+ */
+function createBaseEvent(rawEvent, config, rawData) {
+    const baseEvent = {
+        type: rawEvent.event,
+        timestamp: rawEvent.timestamp || Date.now(),
+        data: null,
+        sequenceNumber: typeof rawEvent.id === 'string' ? Number(rawEvent.id) : 0
+    };
+    // 解析数据字段
+    try {
+        if (rawEvent.data) {
+            baseEvent.data = safeJsonParse(rawEvent.data);
+            if (baseEvent.data && typeof baseEvent.data.sequence_number === 'number') {
+                baseEvent.sequenceNumber = baseEvent.data.sequence_number;
+            }
+        }
+    }
+    catch (error) {
+        if (config.enableEventRecovery) {
+            baseEvent.data = { error: 'Invalid JSON', raw: rawEvent.data };
+            baseEvent.type = 'error';
+        }
+        else {
+            throw error;
+        }
+    }
+    return baseEvent;
+}
+/**
+ * 创建Chat特定事件
+ */
+function createChatEvent(baseEvent) {
+    return {
+        type: baseEvent.type,
+        event: baseEvent.type,
+        timestamp: baseEvent.timestamp,
+        data: baseEvent.data,
+        sequenceNumber: baseEvent.sequenceNumber,
+        protocol: 'chat',
+        direction: 'sse_to_json'
+    };
+}
+/**
+ * 创建Responses特定事件
+ */
+function createResponsesEvent(baseEvent) {
+    return {
+        type: baseEvent.type,
+        timestamp: baseEvent.timestamp,
+        data: baseEvent.data,
+        sequenceNumber: baseEvent.sequenceNumber,
+        protocol: 'responses',
+        direction: 'sse_to_json'
+    };
+}
+/**
+ * 检测事件协议类型
+ */
+function detectEventType(eventType) {
+    // Chat协议事件类型
+    const chatEventTypes = new Set(['chunk', 'done', 'error', 'heartbeat']);
+    if (chatEventTypes.has(eventType)) {
+        return 'chat';
+    }
+    // Responses协议事件类型（以点分隔或特定关键词）
+    if (eventType.includes('.') ||
+        eventType.startsWith('response') ||
+        eventType.startsWith('output') ||
+        eventType.startsWith('content') ||
+        eventType.startsWith('function') ||
+        eventType.startsWith('reasoning')) {
+        return 'responses';
+    }
+    // 默认为Responses协议
+    return 'responses';
+}
+/**
+ * 解析SSE事件文本为标准化事件对象
+ */
+export function parseSseEvent(sseText, config = DEFAULT_SSE_PARSER_CONFIG) {
+    const result = {
+        success: false,
+        rawData: sseText
+    };
+    try {
+        // 分割为行
+        const lines = sseText.split('\n').map(line => line.trim()).filter(line => line !== '');
+        // 组装原始事件
+        const rawEvent = assembleSseEvent(lines);
+        if (!rawEvent) {
+            result.error = 'Invalid SSE event format';
+            return result;
+        }
+        // 验证事件大小
+        if (config.enableStrictValidation && sseText.length > config.maxEventSize) {
+            result.error = `Event size ${sseText.length} exceeds maximum ${config.maxEventSize}`;
+            return result;
+        }
+        // 验证事件类型
+        if (!validateEventType(rawEvent.event, config)) {
+            result.error = `Invalid event type: ${rawEvent.event}`;
+            return result;
+        }
+        // 创建基础事件
+        const baseEvent = createBaseEvent(rawEvent, config, sseText);
+        // 创建协议特定事件
+        const protocol = detectEventType(rawEvent.event);
+        if (protocol === 'chat') {
+            result.event = createChatEvent(baseEvent);
+        }
+        else {
+            result.event = createResponsesEvent(baseEvent);
+        }
+        result.success = true;
+    }
+    catch (error) {
+        result.error = error.message;
+    }
+    return result;
+}
+/**
+ * 解析SSE流（处理多事件数据）
+ */
+export function* parseSseStream(sseData, config = DEFAULT_SSE_PARSER_CONFIG) {
+    // SSE事件由双换行分隔
+    const events = sseData.split('\n\n').filter(event => event.trim() !== '');
+    for (const eventData of events) {
+        const result = parseSseEvent(eventData, config);
+        if (result.success || config.enableEventRecovery) {
+            yield result;
+        }
+    }
+}
+/**
+ * 流式解析SSE数据
+ */
+export async function* parseSseStreamAsync(asyncSseData, config = DEFAULT_SSE_PARSER_CONFIG) {
+    let buffer = '';
+    for await (const chunk of asyncSseData) {
+        buffer += chunk;
+        // 查找完整的事件边界
+        while (true) {
+            const eventEnd = buffer.indexOf('\n\n');
+            if (eventEnd === -1)
+                break;
+            const eventData = buffer.substring(0, eventEnd);
+            buffer = buffer.substring(eventEnd + 2);
+            const result = parseSseEvent(eventData, config);
+            if (result.success || config.enableEventRecovery) {
+                yield result;
+            }
+        }
+    }
+    // 处理剩余数据
+    if (buffer.trim() !== '') {
+        const result = parseSseEvent(buffer, config);
+        if (result.success || config.enableEventRecovery) {
+            yield result;
+        }
+    }
+}
+/**
+ * 创建SSE解析器工厂
+ */
+export function createSseParser(config) {
+    const finalConfig = { ...DEFAULT_SSE_PARSER_CONFIG, ...config };
+    return {
+        /**
+         * 解析单个事件
+         */
+        parseEvent(sseText) {
+            return parseSseEvent(sseText, finalConfig);
+        },
+        /**
+         * 解析多事件流
+         */
+        *parseStream(sseData) {
+            yield* parseSseStream(sseData, finalConfig);
+        },
+        /**
+         * 异步解析流
+         */
+        async *parseStreamAsync(asyncSseData) {
+            yield* parseSseStreamAsync(asyncSseData, finalConfig);
+        },
+        /**
+         * 获取当前配置
+         */
+        getConfig() {
+            return { ...finalConfig };
+        },
+        /**
+         * 添加允许的事件类型
+         */
+        addEventType(eventType) {
+            finalConfig.allowedEventTypes.add(eventType);
+        },
+        /**
+         * 移除允许的事件类型
+         */
+        removeEventType(eventType) {
+            finalConfig.allowedEventTypes.delete(eventType);
+        }
+    };
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Responses SSE → JSON转换器（重构版本）
+ * 使用函数化架构：解析 + 构建 + 验证分离
+ */
+import { ResponsesResponse, SseToResponsesJsonContext, SseToResponsesJsonOptions, ResponsesSseEventStream } from '../types/index.js';
+/**
+ * 重构后的Responses SSE到JSON转换器
+ * 采用函数化架构，专注于编排而非具体业务逻辑
+ */
+export declare class ResponsesSseToJsonConverterRefactored {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof this.config>);
+    /**
+     * 将SSE流转换为Responses响应
+     */
+    convertSseToJson(sseStream: ResponsesSseEventStream, options: SseToResponsesJsonOptions): Promise<ResponsesResponse>;
+    /**
+     * 创建可读流
+     */
+    private createReadableStream;
+    /**
+     * 将异步可迭代对象转换为流
+     */
+    private convertAsyncIterableToStream;
+    /**
+     * 将事件对象序列化为SSE格式（简单实现）
+     */
+    private serializeEventToSSE;
+    /**
+     * 验证序列号
+     */
+    private validateSequenceNumber;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 包装错误
+     */
+    private wrapError;
+    /**
+     * 创建上下文
+     */
+    private createContext;
+    /**
+     * 获取上下文
+     */
+    getContext(requestId: string): SseToResponsesJsonContext | undefined;
+    /**
+     * 清理上下文
+     */
+    clearContext(requestId: string): void;
+    /**
+     * 获取所有活跃的上下文
+     */
+    getActiveContexts(): Map<string, SseToResponsesJsonContext>;
+}
+export declare const ResponsesSseToJsonConverter: typeof ResponsesSseToJsonConverterRefactored;