@jsonstudio/llms 0.4.3 → 0.4.4

package/dist/sse/json-to-sse/sequencers/responses-sequencer.d.ts

@@ -1,40 +0,0 @@
-/**
- * Responses协议事件编排器
- * 负责将Responses响应数据转换为有序的SSE事件流
- */
-import { ResponsesResponse, ResponsesFunctionCallOutputItem, ResponsesSseEvent } from '../../types/index.js';
-import { ResponsesEventGeneratorContext, ResponsesEventGeneratorConfig } from '../event-generators/responses.js';
-export interface ResponsesSequencerConfig extends ResponsesEventGeneratorConfig {
-    enableValidation: boolean;
-    enableRecovery: boolean;
-    enableDelay: boolean;
-    maxOutputItems: number;
-    maxContentParts: number;
-    submittedToolOutputs?: ResponsesFunctionCallOutputItem[];
-}
-export declare const DEFAULT_RESPONSES_SEQUENCER_CONFIG: ResponsesSequencerConfig;
-/**
- * 主编排器：将Responses响应转换为有序的SSE事件流
- */
-export declare function sequenceResponse(response: ResponsesResponse, context: ResponsesEventGeneratorContext, config?: ResponsesSequencerConfig): AsyncGenerator<ResponsesSseEvent>;
-/**
- * 序列化Responses请求（用于请求→SSE转换）
- */
-export declare function sequenceRequest(request: any, context: ResponsesEventGeneratorContext, config?: ResponsesSequencerConfig): AsyncGenerator<ResponsesSseEvent>;
-/**
- * 创建Responses事件序列化器工厂
- */
-export declare function createResponsesSequencer(config?: Partial<ResponsesSequencerConfig>): {
-    /**
-     * 序列化响应
-     */
-    sequenceResponse(response: ResponsesResponse, requestId: string): AsyncGenerator<ResponsesSseEvent, void, any>;
-    /**
-     * 序列化请求
-     */
-    sequenceRequest(request: any, requestId: string): AsyncGenerator<ResponsesSseEvent, void, any>;
-    /**
-     * 获取当前配置
-     */
-    getConfig(): ResponsesSequencerConfig;
-};

package/dist/sse/registry/sse-codec-registry.d.ts

@@ -1,32 +0,0 @@
-import type { ResponsesFunctionCallOutputItem } from '../types/index.js';
-export type SseProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
-export type SseStreamLike = any;
-export type SseStreamInput = any;
-export interface JsonToSseContext {
-    requestId: string;
-    model?: string;
-    direction?: 'request' | 'response';
-    resumeToolOutputs?: ResponsesFunctionCallOutputItem[];
-}
-export interface SseToJsonContext {
-    requestId: string;
-    model?: string;
-    direction?: 'request' | 'response';
-}
-export interface NormalizeSseContext {
-    requestId: string;
-    protocol: SseProtocol;
-}
-export interface SseCodec {
-    protocol: SseProtocol;
-    convertJsonToSse(payload: unknown, context: JsonToSseContext): Promise<SseStreamLike>;
-    convertSseToJson(stream: SseStreamInput, context: SseToJsonContext): Promise<unknown>;
-    normalize?(stream: SseStreamInput, context: NormalizeSseContext): Promise<SseStreamInput>;
-}
-export declare class SseCodecRegistry {
-    private readonly codecs;
-    register(codec: SseCodec): void;
-    get(protocol: SseProtocol): SseCodec;
-    list(): SseCodec[];
-}
-export declare const defaultSseCodecRegistry: SseCodecRegistry;

package/dist/sse/shared/chat-serializer.d.ts

@@ -1,4 +0,0 @@
-import { PassThrough, Readable } from 'node:stream';
-import { ChatSseEvent } from '../types/index.js';
-export declare function serializeChatEventToSSE(evt: ChatSseEvent): string;
-export declare function toSSETextStream(objectEventStream: Readable): PassThrough;

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/index.d.ts

@@ -1,39 +0,0 @@
-/**
- * 事件序列化适配器模块导出
- * 提供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;
-};