@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/sse/shared/constants.d.ts

@@ -1,272 +0,0 @@
-/**
- * 共享常量定义
- * 定义JSON↔SSE双向转换中使用的常量
- */
-export declare const PROTOCOL_TYPES: {
-    readonly CHAT: "chat";
-    readonly RESPONSES: "responses";
-};
-export declare const CONVERSION_DIRECTIONS: {
-    readonly JSON_TO_SSE: "json_to_sse";
-    readonly SSE_TO_JSON: "sse_to_json";
-};
-export declare const TIMEOUT_CONSTANTS: {
-    readonly DEFAULT_TIMEOUT_MS: 30000;
-    readonly HEARTBEAT_INTERVAL_MS: 15000;
-    readonly INACTIVITY_TIMEOUT_MS: 60000;
-    readonly EVENT_PROCESSING_TIMEOUT_MS: 5000;
-    readonly CHUNK_TIMEOUT_MS: 10000;
-    readonly TOTAL_TIMEOUT_MS: 300000;
-};
-export declare const CHUNK_CONSTANTS: {
-    readonly DEFAULT_CHUNK_SIZE: 12;
-    readonly DEFAULT_DELAY_MS: 8;
-    readonly REASONING_CHUNK_SIZE: 24;
-    readonly TEXT_CHUNK_SIZE: 12;
-    readonly FUNCTION_CALL_CHUNK_SIZE: 24;
-    readonly MAX_CHUNK_SIZE: 1024;
-    readonly MIN_CHUNK_SIZE: 1;
-};
-export declare const BUFFER_CONSTANTS: {
-    readonly DEFAULT_BUFFER_SIZE: 1000;
-    readonly MAX_BUFFER_SIZE: 10000;
-    readonly HIGH_WATER_MARK: 8000;
-    readonly LOW_WATER_MARK: 2000;
-    readonly BACKPRESSURE_THRESHOLD: 0.8;
-};
-export declare const RETRY_CONSTANTS: {
-    readonly DEFAULT_MAX_RETRIES: 3;
-    readonly INITIAL_DELAY_MS: 1000;
-    readonly MAX_DELAY_MS: 30000;
-    readonly BACKOFF_MULTIPLIER: 2;
-    readonly JITTER_FACTOR: 0.1;
-};
-export declare const VALIDATION_CONSTANTS: {
-    readonly MAX_SEQUENCE_NUMBER: 10000;
-    readonly MAX_OUTPUT_ITEMS: 100;
-    readonly MAX_CONTENT_PARTS: 1000;
-    readonly MAX_TOOL_CALLS: 50;
-    readonly MAX_MESSAGE_LENGTH: 1000000;
-    readonly MAX_ARGUMENTS_LENGTH: 100000;
-};
-export declare const ERROR_CODES: {
-    readonly TIMEOUT: "TIMEOUT";
-    readonly INVALID_INPUT: "INVALID_INPUT";
-    readonly PARSE_ERROR: "PARSE_ERROR";
-    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
-    readonly STREAM_ERROR: "STREAM_ERROR";
-    readonly CHAT_TIMEOUT: "CHAT_TIMEOUT";
-    readonly CHAT_INVALID_CHUNK: "CHAT_INVALID_CHUNK";
-    readonly CHAT_SEQUENCE_ERROR: "CHAT_SEQUENCE_ERROR";
-    readonly CHAT_TOOL_CALL_ERROR: "CHAT_TOOL_CALL_ERROR";
-    readonly CHAT_PARSE_ERROR: "CHAT_PARSE_ERROR";
-    readonly CHAT_VALIDATION_ERROR: "CHAT_VALIDATION_ERROR";
-    readonly CHAT_STREAM_ERROR: "CHAT_STREAM_ERROR";
-    readonly RESPONSES_TIMEOUT: "RESPONSES_TIMEOUT";
-    readonly RESPONSES_INVALID_EVENT: "RESPONSES_INVALID_EVENT";
-    readonly RESPONSES_SEQUENCE_ERROR: "RESPONSES_SEQUENCE_ERROR";
-    readonly RESPONSES_OUTPUT_ITEM_ERROR: "RESPONSES_OUTPUT_ITEM_ERROR";
-    readonly RESPONSES_CONTENT_PART_ERROR: "RESPONSES_CONTENT_PART_ERROR";
-    readonly RESPONSES_PARSE_ERROR: "RESPONSES_PARSE_ERROR";
-    readonly RESPONSES_VALIDATION_ERROR: "RESPONSES_VALIDATION_ERROR";
-    readonly RESPONSES_STREAM_ERROR: "RESPONSES_STREAM_ERROR";
-};
-export declare const STREAM_STATUS: {
-    readonly IDLE: "idle";
-    readonly STARTING: "starting";
-    readonly ACTIVE: "active";
-    readonly PAUSED: "paused";
-    readonly COMPLETING: "completing";
-    readonly COMPLETED: "completed";
-    readonly ERROR: "error";
-    readonly TIMEOUT: "timeout";
-    readonly ABORTED: "aborted";
-};
-export declare const CHAT_EVENT_TYPES: {
-    readonly CHUNK: "chat_chunk";
-    readonly DONE: "chat.done";
-    readonly ERROR: "error";
-    readonly PING: "ping";
-};
-export declare const RESPONSES_EVENT_TYPES: {
-    readonly RESPONSE_CREATED: "response.created";
-    readonly RESPONSE_IN_PROGRESS: "response.in_progress";
-    readonly RESPONSE_COMPLETED: "response.completed";
-    readonly RESPONSE_REQUIRED_ACTION: "response.required_action";
-    readonly RESPONSE_DONE: "response.done";
-    readonly OUTPUT_ITEM_ADDED: "response.output_item.added";
-    readonly OUTPUT_ITEM_DONE: "response.output_item.done";
-    readonly CONTENT_PART_ADDED: "response.content_part.added";
-    readonly CONTENT_PART_DONE: "response.content_part.done";
-    readonly OUTPUT_TEXT_DELTA: "response.output_text.delta";
-    readonly OUTPUT_TEXT_DONE: "response.output_text.done";
-    readonly REASONING_TEXT_DELTA: "response.reasoning_text.delta";
-    readonly REASONING_TEXT_DONE: "response.reasoning_text.done";
-    readonly FUNCTION_CALL_ARGUMENTS_DELTA: "response.function_call_arguments.delta";
-    readonly FUNCTION_CALL_ARGUMENTS_DONE: "response.function_call_arguments.done";
-};
-export declare const OUTPUT_ITEM_TYPES: {
-    readonly REASONING: "reasoning";
-    readonly MESSAGE: "message";
-    readonly FUNCTION_CALL: "function_call";
-    readonly SYSTEM_MESSAGE: "system_message";
-    readonly FUNCTION_CALL_OUTPUT: "function_call_output";
-};
-export declare const CONTENT_PART_TYPES: {
-    readonly REASONING_TEXT: "reasoning_text";
-    readonly REASONING_SIGNATURE: "reasoning_signature";
-    readonly REASONING_IMAGE: "reasoning_image";
-    readonly OUTPUT_TEXT: "output_text";
-    readonly INPUT_TEXT: "input_text";
-    readonly INPUT_IMAGE: "input_image";
-    readonly COMMENTARY: "commentary";
-};
-export declare const TOOL_CALL_TYPES: {
-    readonly FUNCTION: "function";
-};
-export declare const RESPONSE_STATUS: {
-    readonly IN_PROGRESS: "in_progress";
-    readonly REQUIRES_ACTION: "requires_action";
-    readonly COMPLETED: "completed";
-    readonly FAILED: "failed";
-    readonly INCOMPLETE: "incomplete";
-};
-export declare const FINISH_REASONS: {
-    readonly STOP: "stop";
-    readonly LENGTH: "length";
-    readonly TOOL_CALLS: "tool_calls";
-    readonly CONTENT_FILTER: "content_filter";
-    readonly FUNCTION_CALL: "function_call";
-};
-export declare const REQUIRED_ACTION_TYPES: {
-    readonly SUBMIT_TOOL_OUTPUTS: "submit_tool_outputs";
-    readonly RUN_PARALLEL_TOOLS: "run_parallel_tools";
-};
-export declare const DEFAULT_CONFIG: {
-    readonly TIMEOUT_MS: 30000;
-    readonly HEARTBEAT_INTERVAL_MS: 15000;
-    readonly CHUNK_SIZE: 12;
-    readonly DELAY_MS: 8;
-    readonly VALIDATION_MODE: "basic";
-    readonly DEBUG_MODE: false;
-    readonly CHAT: {
-        readonly TIMEOUT_MS: 30000;
-        readonly HEARTBEAT_INTERVAL_MS: 15000;
-        readonly CHUNK_DELAY_MS: 10;
-        readonly MAX_TOKENS_PER_CHUNK: 100;
-        readonly VALIDATE_CHUNKS: true;
-        readonly STRICT_MODE: false;
-        readonly VALIDATE_TOOL_CALLS: true;
-        readonly MAX_CONCURRENT_CHOICES: 10;
-        readonly MAX_CONCURRENT_TOOL_CALLS: 50;
-    };
-    readonly RESPONSES: {
-        readonly TIMEOUT_MS: 30000;
-        readonly HEARTBEAT_INTERVAL_MS: 15000;
-        readonly REASONING_CHUNK_SIZE: 24;
-        readonly TEXT_CHUNK_SIZE: 12;
-        readonly FUNCTION_CALL_CHUNK_SIZE: 24;
-        readonly ENABLE_EVENT_VALIDATION: true;
-        readonly ENABLE_SEQUENCE_VALIDATION: true;
-        readonly STRICT_MODE: false;
-        readonly VALIDATE_OUTPUT_ITEMS: true;
-        readonly MAX_CONCURRENT_OUTPUT_ITEMS: 10;
-        readonly MAX_CONCURRENT_CONTENT_PARTS: 50;
-    };
-};
-export declare const ENV_KEYS: {
-    readonly SSE_DEFAULT_TIMEOUT_MS: "SSE_DEFAULT_TIMEOUT_MS";
-    readonly SSE_HEARTBEAT_INTERVAL_MS: "SSE_HEARTBEAT_INTERVAL_MS";
-    readonly SSE_INACTIVITY_TIMEOUT_MS: "SSE_INACTIVITY_TIMEOUT_MS";
-    readonly SSE_EVENT_PROCESSING_TIMEOUT_MS: "SSE_EVENT_PROCESSING_TIMEOUT_MS";
-    readonly SSE_DEFAULT_CHUNK_SIZE: "SSE_DEFAULT_CHUNK_SIZE";
-    readonly SSE_DEFAULT_DELAY_MS: "SSE_DEFAULT_DELAY_MS";
-    readonly SSE_REASONING_CHUNK_SIZE: "SSE_REASONING_CHUNK_SIZE";
-    readonly SSE_TEXT_CHUNK_SIZE: "SSE_TEXT_CHUNK_SIZE";
-    readonly SSE_ARGS_CHUNK_SIZE: "SSE_ARGS_CHUNK_SIZE";
-    readonly SSE_ARGS_DELAY_MS: "SSE_ARGS_DELAY_MS";
-    readonly SSE_MAX_BUFFER_SIZE: "SSE_MAX_BUFFER_SIZE";
-    readonly SSE_HIGH_WATER_MARK: "SSE_HIGH_WATER_MARK";
-    readonly SSE_LOW_WATER_MARK: "SSE_LOW_WATER_MARK";
-    readonly SSE_ENABLE_VALIDATION: "SSE_ENABLE_VALIDATION";
-    readonly SSE_ENABLE_SEQUENCE_VALIDATION: "SSE_ENABLE_SEQUENCE_VALIDATION";
-    readonly SSE_MAX_SEQUENCE_NUMBER: "SSE_MAX_SEQUENCE_NUMBER";
-    readonly SSE_STRICT_MODE: "SSE_STRICT_MODE";
-    readonly SSE_DEBUG_EVENTS: "SSE_DEBUG_EVENTS";
-    readonly SSE_DEBUG_MODE: "SSE_DEBUG_MODE";
-    readonly SSE_LOG_LEVEL: "SSE_LOG_LEVEL";
-    readonly SSE_ENABLE_METRICS: "SSE_ENABLE_METRICS";
-    readonly RCC_STREAM_HEARTBEAT: "RCC_STREAM_HEARTBEAT";
-    readonly RCC_STREAM_PRE_HEARTBEAT: "RCC_STREAM_PRE_HEARTBEAT";
-    readonly RCC_RESP_GENERIC_ONMESSAGE: "RCC_RESP_GENERIC_ONMESSAGE";
-    readonly LMSTUDIO_BASE_URL: "LMSTUDIO_BASEURL";
-    readonly LMSTUDIO_API_KEY: "LMSTUDIO_API_KEY";
-};
-export declare const HTTP_STATUS_CODES: {
-    readonly OK: 200;
-    readonly BAD_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly FORBIDDEN: 403;
-    readonly NOT_FOUND: 404;
-    readonly METHOD_NOT_ALLOWED: 405;
-    readonly TIMEOUT: 408;
-    readonly TOO_MANY_REQUESTS: 429;
-    readonly INTERNAL_SERVER_ERROR: 500;
-    readonly BAD_GATEWAY: 502;
-    readonly SERVICE_UNAVAILABLE: 503;
-    readonly GATEWAY_TIMEOUT: 504;
-};
-export declare const CONTENT_TYPES: {
-    readonly JSON: "application/json";
-    readonly SSE: "text/event-stream";
-    readonly TEXT: "text/plain";
-    readonly HTML: "text/html";
-};
-export declare const SSE_FIELDS: {
-    readonly EVENT: "event";
-    readonly DATA: "data";
-    readonly ID: "id";
-    readonly RETRY: "retry";
-};
-export declare const STANDARD_SSE_EVENTS: {
-    readonly OPEN: "open";
-    readonly MESSAGE: "message";
-    readonly ERROR: "error";
-    readonly CLOSE: "close";
-};
-export declare const CACHE_PREFIXES: {
-    readonly CONVERSION: "conversion:";
-    readonly VALIDATION: "validation:";
-    readonly METRICS: "metrics:";
-    readonly CONFIG: "config:";
-};
-export declare const METRIC_NAMES: {
-    readonly CONVERSION_REQUESTS_TOTAL: "conversion_requests_total";
-    readonly CONVERSION_ERRORS_TOTAL: "conversion_errors_total";
-    readonly EVENTS_PROCESSED_TOTAL: "events_processed_total";
-    readonly TIMEOUTS_TOTAL: "timeouts_total";
-    readonly CONVERSION_DURATION_SECONDS: "conversion_duration_seconds";
-    readonly EVENT_PROCESSING_DURATION_SECONDS: "event_processing_duration_seconds";
-    readonly BUFFER_SIZE_BYTES: "buffer_size_bytes";
-    readonly ACTIVE_CONVERSIONS: "active_conversions";
-    readonly BUFFER_UTILIZATION_RATIO: "buffer_utilization_ratio";
-    readonly ERROR_RATE: "error_rate";
-};
-export declare const LOG_LEVELS: {
-    readonly DEBUG: "debug";
-    readonly INFO: "info";
-    readonly WARN: "warn";
-    readonly ERROR: "error";
-};
-export declare const REGEX_PATTERNS: {
-    readonly WORD_BOUNDARY: RegExp;
-    readonly SENTENCE_BOUNDARY: RegExp;
-    readonly PARAGRAPH_BOUNDARY: RegExp;
-    readonly JSON_STRING: RegExp;
-    readonly SSE_LINE: RegExp;
-    readonly SSE_DATA_LINE: RegExp;
-    readonly REQUEST_ID: RegExp;
-    readonly RESPONSE_ID: RegExp;
-    readonly ITEM_ID: RegExp;
-    readonly CALL_ID: RegExp;
-};

package/dist/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/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;

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

@@ -1,123 +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.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;

package/dist/sse/shared/serializers/types.d.ts

@@ -1,51 +0,0 @@
-/**
- * 序列化器相关类型定义
- */
-export interface SerializationOptions {
-    /** 是否启用格式化 */
-    pretty?: boolean;
-    /** 是否启用压缩 */
-    compress?: boolean;
-    /** 字符编码 */
-    encoding?: 'utf8' | 'ascii' | 'base64';
-    /** 自定义分隔符 */
-    delimiter?: string;
-}
-export interface ChatSerializationOptions extends SerializationOptions {
-    /** 是否包含系统指纹 */
-    includeSystemFingerprint?: boolean;
-    /** 是否包含logprobs */
-    includeLogprobs?: boolean;
-    /** 自定义事件映射 */
-    eventMapping?: Record<string, string>;
-}
-export interface ResponsesSerializationOptions extends SerializationOptions {
-    /** 是否包含元数据 */
-    includeMetadata?: boolean;
-    /** 是否包含统计信息 */
-    includeStats?: boolean;
-    /** 自定义事件过滤 */
-    eventFilter?: (event: any) => boolean;
-}
-export interface EventSerializer<TOptions extends SerializationOptions = SerializationOptions> {
-    /** 序列化单个事件 */
-    serialize(event: any, options?: TOptions): string;
-    /** 反序列化单个事件 */
-    deserialize(data: string, options?: TOptions): any;
-    /** 批量序列化 */
-    serializeBatch(events: any[], options?: TOptions): string[];
-    /** 批量反序列化 */
-    deserializeBatch(data: string[], options?: TOptions): any[];
-}
-export interface ChatEventSerializer extends EventSerializer<ChatSerializationOptions> {
-    /** 序列化Chat Completion Chunk */
-    serializeChatChunk(chunk: any, options?: ChatSerializationOptions): string;
-    /** 反序列化Chat Completion Chunk */
-    deserializeChatChunk(data: string, options?: ChatSerializationOptions): any;
-}
-export interface ResponsesEventSerializer extends EventSerializer<ResponsesSerializationOptions> {
-    /** 序列化Responses事件 */
-    serializeResponsesEvent(event: any, options?: ResponsesSerializationOptions): string;
-    /** 反序列化Responses事件 */
-    deserializeResponsesEvent(data: string, options?: ResponsesSerializationOptions): any;
-}