@jsonstudio/rcc 0.90.367 → 0.90.429

package/vendor/llmswitch-core/dist/sse/shared/serializers/chat-event-serializer.js

@@ -1,275 +0,0 @@
-/**
- * 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/vendor/llmswitch-core/dist/sse/shared/serializers/gemini-event-serializer.d.ts

@@ -1,2 +0,0 @@
-import type { GeminiSseEvent } from '../../types/index.js';
-export declare function serializeGeminiEventToSSE(event: GeminiSseEvent): string;

package/vendor/llmswitch-core/dist/sse/shared/serializers/gemini-event-serializer.js

@@ -1,5 +0,0 @@
-export function serializeGeminiEventToSSE(event) {
-    const payload = event.data ?? {};
-    const eventType = event.event ?? event.type ?? 'gemini.data';
-    return [`event: ${eventType}`, `data: ${JSON.stringify(payload)}`].join('\n') + '\n\n';
-}

package/vendor/llmswitch-core/dist/sse/shared/serializers/index.d.ts

@@ -1,42 +0,0 @@
-/**
- * 事件序列化适配器模块导出
- * 提供Chat和Responses协议的事件序列化功能
- */
-import { BatchSerializer } from './base-serializer.js';
-import type { 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 { serializeAnthropicEventToSSE } from './anthropic-event-serializer.js';
-export { serializeGeminiEventToSSE } from './gemini-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/vendor/llmswitch-core/dist/sse/shared/serializers/index.js

@@ -1,56 +0,0 @@
-/**
- * 事件序列化适配器模块导出
- * 提供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 { serializeAnthropicEventToSSE } from './anthropic-event-serializer.js';
-export { serializeGeminiEventToSSE } from './gemini-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/vendor/llmswitch-core/dist/sse/shared/serializers/responses-event-serializer.d.ts

@@ -1,131 +0,0 @@
-/**
- * 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.output_text.delta事件
-     */
-    private serializeOutputTextDelta;
-    /**
-     * 序列化response.output_text.done事件
-     */
-    private serializeOutputTextDone;
-    /**
-     * 序列化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;