@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/conversion-v3/sse/shared/serializers/base-serializer.d.ts

@@ -1,158 +0,0 @@
-/**
- * 基础事件序列化器接口
- * 定义统一的序列化/反序列化规范
- */
-/**
- * 通用事件序列化器接口
- * @template TEvent 事件类型
- */
-export interface EventSerializer<TEvent> {
-    /**
-     * 将事件对象序列化为SSE wire格式字符串
-     * @param event 要序列化的事件对象
-     * @returns SSE wire格式的字符串
-     */
-    serializeToWire(event: TEvent): string;
-    /**
-     * 从SSE wire格式字符串反序列化为事件对象
-     * @param wireData SSE wire格式的字符串
-     * @returns 反序列化后的事件对象
-     */
-    deserializeFromWire(wireData: string): TEvent;
-    /**
-     * 验证SSE wire格式是否有效
-     * @param wireData 要验证的SSE wire格式字符串
-     * @returns 格式是否有效
-     */
-    validateWireFormat(wireData: string): boolean;
-}
-/**
- * 序列化选项配置
- */
-export interface SerializationOptions {
-    /**
-     * 是否包含时间戳
-     */
-    includeTimestamp?: boolean;
-    /**
-     * 是否包含事件ID
-     */
-    includeEventId?: boolean;
-    /**
-     * 自定义事件ID生成器
-     */
-    eventIdGenerator?: () => string;
-    /**
-     * JSON序列化配置
-     */
-    jsonReplacer?: (key: string, value: any) => any;
-    /**
-     * JSON反序列化配置
-     */
-    jsonReviver?: (key: string, value: any) => any;
-}
-/**
- * 基础事件序列化器抽象类
- * 提供通用的序列化功能实现
- */
-export declare abstract class BaseEventSerializer<TEvent> implements EventSerializer<TEvent> {
-    protected options: SerializationOptions;
-    constructor(options?: SerializationOptions);
-    /**
-     * 序列化事件为SSE wire格式
-     */
-    serializeToWire(event: TEvent): string;
-    /**
-     * 从SSE wire格式反序列化事件
-     */
-    deserializeFromWire(wireData: string): TEvent;
-    /**
-     * 验证SSE wire格式
-     */
-    validateWireFormat(wireData: string): boolean;
-    /**
-     * 生成当前时间戳
-     */
-    protected generateTimestamp(): string;
-    /**
-     * 序列化数据
-     */
-    protected serializeData(data: any): string;
-    /**
-     * 反序列化数据
-     */
-    protected deserializeData(dataStr: string): any;
-    /**
-     * 从事件对象中提取事件类型
-     */
-    protected abstract extractEventType(event: TEvent): string;
-    /**
-     * 从事件对象中提取事件数据
-     */
-    protected abstract extractEventData(event: TEvent): any;
-    /**
-     * 从事件对象中提取时间戳
-     */
-    protected extractTimestamp(event: TEvent): string | null;
-    /**
-     * 从事件对象中提取事件ID
-     */
-    protected extractEventId(event: TEvent): string | null;
-    /**
-     * 创建事件对象
-     */
-    protected abstract createEvent(eventType: string, eventData: any, timestamp?: string | null, eventId?: string | null): TEvent;
-}
-/**
- * 序列化错误类
- */
-export declare class SerializationError extends Error {
-    readonly cause?: Error;
-    readonly eventData?: any;
-    constructor(message: string, cause?: Error, eventData?: any);
-}
-/**
- * 序列化结果
- */
-export interface SerializationResult {
-    /**
-     * 序列化后的SSE wire格式字符串
-     */
-    wireData: string;
-    /**
-     * 序列化统计信息
-     */
-    stats: {
-        /**
-         * 序列化耗时（毫秒）
-         */
-        duration: number;
-        /**
-         * 序列化数据大小（字节）
-         */
-        size: number;
-        /**
-         * 是否成功
-         */
-        success: boolean;
-        /**
-         * 错误信息（如果有）
-         */
-        error?: string;
-    };
-}
-/**
- * 批量序列化工具
- */
-export declare class BatchSerializer<TEvent> {
-    private serializer;
-    constructor(serializer: EventSerializer<TEvent>);
-    /**
-     * 批量序列化事件
-     */
-    serializeBatch(events: TEvent[]): Promise<SerializationResult[]>;
-    /**
-     * 批量反序列化事件
-     */
-    deserializeBatch(wireDataArray: string[]): Promise<TEvent[]>;
-}

package/dist/conversion/conversion-v3/sse/shared/serializers/base-serializer.js

@@ -1,210 +0,0 @@
-/**
- * 基础事件序列化器接口
- * 定义统一的序列化/反序列化规范
- */
-/**
- * 基础事件序列化器抽象类
- * 提供通用的序列化功能实现
- */
-export class BaseEventSerializer {
-    options;
-    constructor(options = {}) {
-        this.options = {
-            includeTimestamp: true,
-            includeEventId: true,
-            ...options
-        };
-    }
-    /**
-     * 序列化事件为SSE wire格式
-     */
-    serializeToWire(event) {
-        const lines = [];
-        // 添加事件类型
-        const eventType = this.extractEventType(event);
-        lines.push(`event: ${eventType}`);
-        // 添加事件数据
-        const data = this.extractEventData(event);
-        if (data !== null && data !== undefined) {
-            const dataStr = this.serializeData(data);
-            lines.push(`data: ${dataStr}`);
-        }
-        // 添加时间戳
-        if (this.options.includeTimestamp) {
-            const timestamp = this.extractTimestamp(event) || this.generateTimestamp();
-            lines.push(`id: ${timestamp}`);
-        }
-        // 添加事件ID（如果与时间戳不同）
-        if (this.options.includeEventId && this.options.includeTimestamp) {
-            const eventId = this.extractEventId(event) || this.options.eventIdGenerator?.();
-            if (eventId) {
-                lines.push(`id: ${eventId}`);
-            }
-        }
-        // SSE事件以空行结束
-        lines.push('');
-        return lines.join('\n');
-    }
-    /**
-     * 从SSE wire格式反序列化事件
-     */
-    deserializeFromWire(wireData) {
-        const lines = wireData.trim().split('\n');
-        let eventType = null;
-        let eventData = null;
-        let eventId = null;
-        let timestamp = null;
-        for (const line of lines) {
-            if (line.startsWith('event:')) {
-                eventType = line.substring(6).trim();
-            }
-            else if (line.startsWith('data:')) {
-                const dataStr = line.substring(5).trim();
-                eventData = this.deserializeData(dataStr);
-            }
-            else if (line.startsWith('id:')) {
-                const idValue = line.substring(3).trim();
-                // 第一个id通常是时间戳，第二个是事件ID
-                if (!timestamp) {
-                    timestamp = idValue;
-                }
-                else {
-                    eventId = idValue;
-                }
-            }
-        }
-        if (!eventType) {
-            throw new Error('Missing event type in SSE data');
-        }
-        return this.createEvent(eventType, eventData, timestamp, eventId);
-    }
-    /**
-     * 验证SSE wire格式
-     */
-    validateWireFormat(wireData) {
-        try {
-            const lines = wireData.trim().split('\n');
-            let hasEvent = false;
-            let hasData = false;
-            for (const line of lines) {
-                if (line.startsWith('event:')) {
-                    hasEvent = true;
-                }
-                else if (line.startsWith('data:')) {
-                    hasData = true;
-                }
-            }
-            return hasEvent && hasData;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * 生成当前时间戳
-     */
-    generateTimestamp() {
-        return new Date().toISOString();
-    }
-    /**
-     * 序列化数据
-     */
-    serializeData(data) {
-        if (typeof data === 'string') {
-            return data;
-        }
-        return JSON.stringify(data, this.options.jsonReplacer);
-    }
-    /**
-     * 反序列化数据
-     */
-    deserializeData(dataStr) {
-        try {
-            return JSON.parse(dataStr, this.options.jsonReviver);
-        }
-        catch {
-            return dataStr;
-        }
-    }
-    /**
-     * 从事件对象中提取时间戳
-     */
-    extractTimestamp(event) {
-        return null;
-    }
-    /**
-     * 从事件对象中提取事件ID
-     */
-    extractEventId(event) {
-        return null;
-    }
-}
-/**
- * 序列化错误类
- */
-export class SerializationError extends Error {
-    cause;
-    eventData;
-    constructor(message, cause, eventData) {
-        super(message);
-        this.cause = cause;
-        this.eventData = eventData;
-        this.name = 'SerializationError';
-    }
-}
-/**
- * 批量序列化工具
- */
-export class BatchSerializer {
-    serializer;
-    constructor(serializer) {
-        this.serializer = serializer;
-    }
-    /**
-     * 批量序列化事件
-     */
-    async serializeBatch(events) {
-        const results = [];
-        for (const event of events) {
-            const startTime = Date.now();
-            let wireData;
-            let error;
-            try {
-                wireData = this.serializer.serializeToWire(event);
-            }
-            catch (e) {
-                error = e instanceof Error ? e.message : String(e);
-                wireData = '';
-            }
-            results.push({
-                wireData,
-                stats: {
-                    duration: Date.now() - startTime,
-                    size: new Blob([wireData]).size,
-                    success: !error,
-                    error
-                }
-            });
-        }
-        return results;
-    }
-    /**
-     * 批量反序列化事件
-     */
-    async deserializeBatch(wireDataArray) {
-        const events = [];
-        for (const wireData of wireDataArray) {
-            try {
-                if (this.serializer.validateWireFormat(wireData)) {
-                    const event = this.serializer.deserializeFromWire(wireData);
-                    events.push(event);
-                }
-            }
-            catch (e) {
-                // 跳过无法反序列化的事件，或者可以选择抛出错误
-                console.warn('Failed to deserialize event:', e);
-            }
-        }
-        return events;
-    }
-}

package/dist/conversion/conversion-v3/sse/shared/serializers/chat-event-serializer.d.ts

@@ -1,82 +0,0 @@
-/**
- * Chat协议事件序列化适配器
- * 将内部ChatSseEvent对象转换为真实的SSE wire格式
- */
-import type { ChatSseEvent } from '../../types/chat-types.js';
-import type { EventSerializer } from './base-serializer.js';
-/**
- * Chat协议SSE事件序列化器
- * 负责将内部事件对象转换为符合SSE标准的文本格式
- */
-export declare class ChatEventSerializer implements EventSerializer<ChatSseEvent> {
-    /**
-     * 将Chat事件序列化为SSE wire格式
-     */
-    serializeToWire(event: ChatSseEvent): string;
-    /**
-     * 从SSE wire格式反序列化为Chat事件
-     */
-    deserializeFromWire(wireData: string): ChatSseEvent;
-    /**
-     * 验证SSE wire格式
-     */
-    validateWireFormat(wireData: string): boolean;
-    /**
-     * 序列化Chat chunk事件
-     * 格式: event: chat_chunk\ndata: {...}\n\n
-     */
-    private serializeChatChunk;
-    /**
-     * 序列化Chat完成事件
-     * 格式: event: chat.done\ndata: {"type":"done",...}\n\n
-     */
-    private serializeChatDone;
-    /**
-     * 序列化Chat错误事件
-     */
-    private serializeChatError;
-    /**
-     * 序列化心跳事件
-     */
-    private serializeHeartbeat;
-    /**
-     * 反序列化Chat chunk事件
-     */
-    private deserializeChatChunk;
-    /**
-     * 反序列化Chat完成事件
-     */
-    private deserializeChatDone;
-    /**
-     * 反序列化Chat错误事件
-     */
-    private deserializeChatError;
-    /**
-     * 反序列化心跳事件
-     */
-    private deserializeHeartbeat;
-    /**
-     * 从wire数据中提取时间戳
-     */
-    private extractTimestamp;
-    /**
-     * 创建标准Chat chunk事件
-     */
-    static createChunkEvent(chunkData: any, timestamp?: number): ChatSseEvent;
-    /**
-     * 创建标准Chat完成事件
-     */
-    static createDoneEvent(requestId: string, totalEvents: number, timestamp?: number): ChatSseEvent;
-    /**
-     * 创建标准Chat错误事件
-     */
-    static createErrorEvent(error: Error, requestId: string, timestamp?: number): ChatSseEvent;
-    /**
-     * 创建心跳事件
-     */
-    static createHeartbeatEvent(timestamp?: number): ChatSseEvent;
-}
-/**
- * 默认Chat事件序列化器实例
- */
-export declare const defaultChatEventSerializer: ChatEventSerializer;