@jsonstudio/llms 0.4.2 → 0.4.4

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

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

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

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