@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,275 @@
+/**
+ * Chat协议事件序列化适配器
+ * 将内部ChatSseEvent对象转换为真实的SSE wire格式
+ */
+/**
+ * Chat协议SSE事件序列化器
+ * 负责将内部事件对象转换为符合SSE标准的文本格式
+ */
+export class ChatEventSerializer {
+    /**
+     * 将Chat事件序列化为SSE wire格式
+     */
+    serializeToWire(event) {
+        switch (event.type) {
+            case 'chat_chunk':
+                return this.serializeChatChunk(event);
+            case 'chat.done':
+                return this.serializeChatDone(event);
+            case 'chat.error':
+                return this.serializeChatError(event);
+            case 'chat.heartbeat':
+                return this.serializeHeartbeat(event);
+            default:
+                throw new Error(`Unsupported ChatSseEvent type: ${event.type}`);
+        }
+    }
+    /**
+     * 从SSE wire格式反序列化为Chat事件
+     */
+    deserializeFromWire(wireData) {
+        const lines = wireData.trim().split('\n');
+        let eventType = null;
+        let eventData = null;
+        for (const line of lines) {
+            if (line.startsWith('event:')) {
+                eventType = line.substring(6).trim();
+            }
+            else if (line.startsWith('data:')) {
+                eventData = line.substring(5).trim();
+            }
+        }
+        if (!eventType) {
+            throw new Error('Missing event type in SSE data');
+        }
+        switch (eventType) {
+            case 'chat_chunk':
+                return this.deserializeChatChunk(eventData, wireData);
+            case 'chat.done':
+                return this.deserializeChatDone(eventData, wireData);
+            case 'chat.error':
+                return this.deserializeChatError(eventData, wireData);
+            case 'chat.heartbeat':
+                return this.deserializeHeartbeat(eventData, wireData);
+            default:
+                throw new Error(`Unknown Chat event type: ${eventType}`);
+        }
+    }
+    /**
+     * 验证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;
+        }
+    }
+    /**
+     * 序列化Chat chunk事件
+     * 格式: event: chat_chunk\ndata: {...}\n\n
+     */
+    serializeChatChunk(event) {
+        const timestamp = event.timestamp ?? Date.now();
+        let wireEvent = `event: chat_chunk\n`;
+        wireEvent += `data: ${event.data}\n`;
+        wireEvent += `id: ${timestamp}\n`;
+        wireEvent += `\n`;
+        return wireEvent;
+    }
+    /**
+     * 序列化Chat完成事件
+     * 格式: event: chat.done\ndata: {"type":"done",...}\n\n
+     */
+    serializeChatDone(event) {
+        const timestamp = event.timestamp ?? Date.now();
+        let wireEvent = `event: chat.done\n`;
+        wireEvent += `data: ${event.data}\n`;
+        wireEvent += `id: ${timestamp}\n`;
+        wireEvent += `\n`;
+        return wireEvent;
+    }
+    /**
+     * 序列化Chat错误事件
+     */
+    serializeChatError(event) {
+        const timestamp = event.timestamp ?? Date.now();
+        let wireEvent = `event: chat.error\n`;
+        wireEvent += `data: ${event.data}\n`;
+        wireEvent += `id: ${timestamp}\n`;
+        wireEvent += `\n`;
+        return wireEvent;
+    }
+    /**
+     * 序列化心跳事件
+     */
+    serializeHeartbeat(event) {
+        const timestamp = event.timestamp ?? Date.now();
+        let wireEvent = `event: chat.heartbeat\n`;
+        wireEvent += `data: ${event.data || 'ping'}\n`;
+        wireEvent += `id: ${timestamp}\n`;
+        wireEvent += `\n`;
+        return wireEvent;
+    }
+    /**
+     * 反序列化Chat chunk事件
+     */
+    deserializeChatChunk(data, rawWireData) {
+        if (!data) {
+            throw new Error('Missing data for chat_chunk event');
+        }
+        return {
+            event: 'chat_chunk',
+            type: 'chat_chunk',
+            timestamp: this.extractTimestamp(rawWireData),
+            data,
+            protocol: 'chat',
+            direction: 'sse_to_json'
+        };
+    }
+    /**
+     * 反序列化Chat完成事件
+     */
+    deserializeChatDone(data, rawWireData) {
+        if (!data) {
+            throw new Error('Missing data for chat.done event');
+        }
+        return {
+            event: 'chat.done',
+            type: 'chat.done',
+            timestamp: this.extractTimestamp(rawWireData),
+            data,
+            protocol: 'chat',
+            direction: 'sse_to_json'
+        };
+    }
+    /**
+     * 反序列化Chat错误事件
+     */
+    deserializeChatError(data, rawWireData) {
+        if (!data) {
+            throw new Error('Missing data for chat.error event');
+        }
+        return {
+            event: 'error',
+            type: 'error',
+            timestamp: this.extractTimestamp(rawWireData),
+            data,
+            protocol: 'chat',
+            direction: 'sse_to_json'
+        };
+    }
+    /**
+     * 反序列化心跳事件
+     */
+    deserializeHeartbeat(data, rawWireData) {
+        return {
+            event: 'ping',
+            type: 'ping',
+            timestamp: this.extractTimestamp(rawWireData),
+            data: data || 'ping',
+            protocol: 'chat',
+            direction: 'sse_to_json'
+        };
+    }
+    /**
+     * 从wire数据中提取时间戳
+     */
+    extractTimestamp(wireData) {
+        const lines = wireData.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('id:')) {
+                const idValue = line.substring(3).trim();
+                const numeric = Number(idValue);
+                if (!Number.isNaN(numeric)) {
+                    return numeric;
+                }
+                const parsed = Date.parse(idValue);
+                if (!Number.isNaN(parsed)) {
+                    return parsed;
+                }
+            }
+        }
+        return Date.now();
+    }
+    /**
+     * 创建标准Chat chunk事件
+     */
+    static createChunkEvent(chunkData, timestamp) {
+        return {
+            event: 'chat_chunk',
+            type: 'chat_chunk',
+            timestamp: timestamp ?? Date.now(),
+            data: JSON.stringify(chunkData),
+            protocol: 'chat',
+            direction: 'json_to_sse'
+        };
+    }
+    /**
+     * 创建标准Chat完成事件
+     */
+    static createDoneEvent(requestId, totalEvents, timestamp) {
+        return {
+            event: 'chat.done',
+            type: 'chat.done',
+            timestamp: timestamp ?? Date.now(),
+            data: JSON.stringify({
+                type: 'done',
+                requestId,
+                totalEvents
+            }),
+            protocol: 'chat',
+            direction: 'json_to_sse'
+        };
+    }
+    /**
+     * 创建标准Chat错误事件
+     */
+    static createErrorEvent(error, requestId, timestamp) {
+        return {
+            event: 'error',
+            type: 'error',
+            timestamp: timestamp ?? Date.now(),
+            data: JSON.stringify({
+                type: 'error',
+                requestId,
+                error: {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack
+                }
+            }),
+            protocol: 'chat',
+            direction: 'json_to_sse'
+        };
+    }
+    /**
+     * 创建心跳事件
+     */
+    static createHeartbeatEvent(timestamp) {
+        return {
+            event: 'ping',
+            type: 'ping',
+            timestamp: timestamp ?? Date.now(),
+            data: 'ping',
+            protocol: 'chat',
+            direction: 'json_to_sse'
+        };
+    }
+}
+/**
+ * 默认Chat事件序列化器实例
+ */
+export const defaultChatEventSerializer = new ChatEventSerializer();

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

@@ -0,0 +1,39 @@
+/**
+ * 事件序列化适配器模块导出
+ * 提供Chat和Responses协议的事件序列化功能
+ */
+import { BatchSerializer, EventSerializer, SerializationOptions } from './base-serializer.js';
+import { ChatEventSerializer } from './chat-event-serializer.js';
+import { ResponsesEventSerializer } from './responses-event-serializer.js';
+export type { SerializationOptions, ChatSerializationOptions, ResponsesSerializationOptions, EventSerializer, ChatEventSerializer, ResponsesEventSerializer } from './types.js';
+export type { BaseEventSerializer, SerializationError, SerializationResult, BatchSerializer } from './base-serializer.js';
+export { defaultChatEventSerializer } from './chat-event-serializer.js';
+export { defaultResponsesEventSerializer } from './responses-event-serializer.js';
+/**
+ * 创建序列化器工厂
+ */
+export declare class SerializerFactory {
+    /**
+     * 创建Chat协议序列化器
+     */
+    static createChatSerializer(options?: SerializationOptions): ChatEventSerializer;
+    /**
+     * 创建Responses协议序列化器
+     */
+    static createResponsesSerializer(options?: SerializationOptions): ResponsesEventSerializer;
+    /**
+     * 根据协议类型创建序列化器
+     */
+    static createSerializer(protocol: 'chat' | 'responses', options?: SerializationOptions): EventSerializer<any>;
+    /**
+     * 创建批量序列化器
+     */
+    static createBatchSerializer<TEvent>(serializer: EventSerializer<TEvent>): BatchSerializer<TEvent>;
+}
+/**
+ * 默认序列化器实例
+ */
+export declare const defaultSerializers: {
+    chat: ChatEventSerializer;
+    responses: ResponsesEventSerializer;
+};

package/dist/conversion/conversion-v3/sse/shared/serializers/index.js

@@ -0,0 +1,54 @@
+/**
+ * 事件序列化适配器模块导出
+ * 提供Chat和Responses协议的事件序列化功能
+ */
+import { BatchSerializer } from './base-serializer.js';
+import { ChatEventSerializer, defaultChatEventSerializer } from './chat-event-serializer.js';
+import { ResponsesEventSerializer, defaultResponsesEventSerializer } from './responses-event-serializer.js';
+// Chat协议序列化器
+export { defaultChatEventSerializer } from './chat-event-serializer.js';
+// Responses协议序列化器
+export { defaultResponsesEventSerializer } from './responses-event-serializer.js';
+/**
+ * 创建序列化器工厂
+ */
+export class SerializerFactory {
+    /**
+     * 创建Chat协议序列化器
+     */
+    static createChatSerializer(options) {
+        return new ChatEventSerializer();
+    }
+    /**
+     * 创建Responses协议序列化器
+     */
+    static createResponsesSerializer(options) {
+        return new ResponsesEventSerializer();
+    }
+    /**
+     * 根据协议类型创建序列化器
+     */
+    static createSerializer(protocol, options) {
+        switch (protocol) {
+            case 'chat':
+                return this.createChatSerializer(options);
+            case 'responses':
+                return this.createResponsesSerializer(options);
+            default:
+                throw new Error(`Unsupported protocol: ${protocol}`);
+        }
+    }
+    /**
+     * 创建批量序列化器
+     */
+    static createBatchSerializer(serializer) {
+        return new BatchSerializer(serializer);
+    }
+}
+/**
+ * 默认序列化器实例
+ */
+export const defaultSerializers = {
+    chat: defaultChatEventSerializer,
+    responses: defaultResponsesEventSerializer
+};

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

@@ -0,0 +1,123 @@
+/**
+ * Responses协议事件序列化适配器
+ * 将内部ResponsesSseEvent对象转换为真实的SSE wire格式
+ */
+import type { ResponsesSseEvent } from '../../types/responses-types.js';
+import type { EventSerializer } from './base-serializer.js';
+/**
+ * Responses协议SSE事件序列化器
+ * 负责将内部事件对象转换为符合LMStudio/官方SDK习惯的SSE格式
+ */
+export declare class ResponsesEventSerializer implements EventSerializer<ResponsesSseEvent> {
+    /**
+     * 将Responses事件序列化为SSE wire格式
+     */
+    serializeToWire(event: ResponsesSseEvent): string;
+    /**
+     * 从SSE wire格式反序列化为Responses事件
+     */
+    deserializeFromWire(wireData: string): ResponsesSseEvent;
+    /**
+     * 验证SSE wire格式
+     */
+    validateWireFormat(wireData: string): boolean;
+    private decorate;
+    /**
+     * 序列化response.created事件
+     * 格式: event: response.created\ndata: {"response": {...}}\n\n
+     */
+    private serializeResponseCreated;
+    /**
+     * 序列化response.in_progress事件
+     */
+    private serializeResponseInProgress;
+    /**
+     * 序列化response.reasoning_text.delta事件
+     */
+    private serializeReasoningTextDelta;
+    /**
+     * 序列化response.reasoning_text.done事件
+     */
+    private serializeReasoningTextDone;
+    /**
+     * 序列化response.content_part.added事件
+     */
+    private serializeContentPartAdded;
+    /**
+     * 序列化response.content_part.done事件
+     */
+    private serializeContentPartDone;
+    /**
+     * 序列化response.output_item.added事件
+     */
+    private serializeOutputItemAdded;
+    /**
+     * 序列化response.output_item.done事件
+     */
+    private serializeOutputItemDone;
+    /**
+     * 序列化response.function_call_arguments.delta事件
+     */
+    private serializeFunctionCallArgumentsDelta;
+    /**
+     * 序列化response.function_call_arguments.done事件
+     */
+    private serializeFunctionCallArgumentsDone;
+    /**
+     * 序列化response.required_action事件
+     */
+    private serializeRequiredAction;
+    /**
+     * 序列化response.completed事件
+     */
+    private serializeResponseCompleted;
+    /**
+     * 序列化response.done事件
+     */
+    private serializeResponseDone;
+    /**
+     * 序列化response.error事件
+     */
+    private serializeResponseError;
+    /**
+     * 序列化response.cancelled事件
+     */
+    private serializeResponseCancelled;
+    /**
+     * 构建标准SSE事件格式
+     */
+    private buildSSEEvent;
+    /**
+     * 创建标准response.created事件
+     */
+    static createResponseCreatedEvent(response: any, timestamp?: number): ResponsesSseEvent;
+    /**
+     * 创建标准response.in_progress事件
+     */
+    static createResponseInProgressEvent(timestamp?: number): ResponsesSseEvent;
+    /**
+     * 创建标准response.completed事件
+     */
+    static createResponseCompletedEvent(responseId: string, status: string, usage?: any, timestamp?: number): ResponsesSseEvent;
+    /**
+     * 创建标准response.required_action事件
+     */
+    static createRequiredActionEvent(toolCalls: any[], timestamp?: number): ResponsesSseEvent;
+    /**
+     * 创建标准response.done事件
+     */
+    static createResponseDoneEvent(requestId: string, totalEvents: number, timestamp?: number): ResponsesSseEvent;
+    /**
+     * 创建标准response.error事件
+     */
+    static createResponseErrorEvent(error: Error, requestId: string, timestamp?: number): ResponsesSseEvent;
+    private buildEventPayload;
+    /**
+     * 解析 wire 中的时间戳字符串
+     */
+    private parseTimestamp;
+}
+/**
+ * 默认Responses事件序列化器实例
+ */
+export declare const defaultResponsesEventSerializer: ResponsesEventSerializer;