@jsonstudio/llms 0.6.795 → 0.6.938

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

@@ -0,0 +1,158 @@
+/**
+ * 基础事件序列化器接口
+ * 定义统一的序列化/反序列化规范
+ */
+/**
+ * 通用事件序列化器接口
+ * @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

@@ -0,0 +1,82 @@
+/**
+ * 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/gemini-event-serializer.d.ts

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

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

@@ -2,7 +2,8 @@
  * 事件序列化适配器模块导出
  * 提供Chat和Responses协议的事件序列化功能
  */
-import { BatchSerializer, EventSerializer, SerializationOptions } from './base-serializer.js';
+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';

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

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

@@ -0,0 +1,51 @@
+/**
+ * 序列化器相关类型定义
+ */
+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;
+}

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

@@ -0,0 +1,254 @@
+/**
+ * 共享工具函数
+ * 提供JSON↔SSE双向转换中常用的工具函数
+ */
+import { Readable } from 'stream';
+/**
+ * 字符串工具
+ */
+export declare class StringUtils {
+    /**
+     * 安全地将值转换为字符串
+     */
+    static safeStringify(value: unknown): string;
+    /**
+     * 安全地解析JSON字符串
+     */
+    static safeParse<T = any>(text: string): T | null;
+    /**
+     * 检查字符串是否为空或只包含空白字符
+     */
+    static isEmpty(str: string): boolean;
+    /**
+     * 检查字符串是否为有效的JSON
+     */
+    static isValidJson(str: string): boolean;
+    /**
+     * 截断字符串到指定长度
+     */
+    static truncate(str: string, maxLength: number, suffix?: string): string;
+    /**
+     * 生成随机字符串
+     */
+    static random(length?: number): string;
+    /**
+     * 分割字符串为块
+     */
+    static chunkString(text: string, chunkSize: number, boundary: RegExp): string[];
+}
+/**
+ * 对象工具
+ */
+export declare class ObjectUtils {
+    /**
+     * 深度冻结对象
+     */
+    static deepFreeze<T>(obj: T): T;
+    /**
+     * 深度克隆对象
+     */
+    static deepClone<T>(obj: T): T;
+    /**
+     * 安全地获取嵌套对象属性
+     */
+    static get(obj: any, path: string, defaultValue?: any): any;
+    /**
+     * 安全地设置嵌套对象属性
+     */
+    static set(obj: any, path: string, value: any): void;
+    /**
+     * 检查对象是否为空
+     */
+    static isEmpty(obj: any): boolean;
+    /**
+     * 合并对象
+     */
+    static merge<T extends Record<string, any>>(target: T, source: Partial<T>): T;
+}
+/**
+ * 数组工具
+ */
+export declare class ArrayUtils {
+    /**
+     * 数组去重
+     */
+    static unique<T>(arr: T[]): T[];
+    /**
+     * 分组数组
+     */
+    static groupBy<T, K extends string | number>(arr: T[], keyFn: (item: T) => K): Record<K, T[]>;
+    /**
+     * 分块数组
+     */
+    static chunk<T>(arr: T[], size: number): T[][];
+    /**
+     * 扁平化数组
+     */
+    static flatten<T>(arr: (T | T[])[]): T[];
+    /**
+     * 找到数组中的差异
+     */
+    static diff<T>(arr1: T[], arr2: T[]): {
+        added: T[];
+        removed: T[];
+        common: T[];
+    };
+}
+/**
+ * 时间工具
+ */
+export declare class TimeUtils {
+    /**
+     * 获取当前时间戳（毫秒）
+     */
+    static now(): number;
+    /**
+     * 获取当前时间戳（秒）
+     */
+    static nowSeconds(): number;
+    /**
+     * 格式化时间戳
+     */
+    static formatTimestamp(timestamp: number, format?: string): string;
+    /**
+     * 延迟指定时间
+     */
+    static delay(ms: number): Promise<void>;
+    /**
+     * 带超时的Promise
+     */
+    static timeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
+}
+/**
+ * 验证工具
+ */
+export declare class ValidationUtils {
+    /**
+     * 检查值是否为对象
+     */
+    static isObject(value: unknown): value is Record<string, unknown>;
+    /**
+     * 检查值是否为有效的ID
+     */
+    static isValidId(value: string, pattern: RegExp): boolean;
+    /**
+     * 验证序列号
+     */
+    static isValidSequenceNumber(value: number, max?: number): boolean;
+    /**
+     * 验证时间戳
+     */
+    static isValidTimestamp(value: number): boolean;
+    /**
+     * 验证JSON结构
+     */
+    static validateJsonStructure(obj: any, schema: any): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+/**
+ * 流工具
+ */
+export declare class StreamUtils {
+    /**
+     * 创建可读流
+     */
+    static createReadable<T>(data: T[]): Readable;
+    /**
+     * 将异步生成器转换为流
+     */
+    static asyncGeneratorToStream<T>(generator: AsyncGenerator<T>): Readable;
+    /**
+     * 将流转换为数组
+     */
+    static streamToArray<T>(stream: Readable): Promise<T[]>;
+    /**
+     * 管道流超时
+     */
+    static pipeWithTimeout<T>(source: Readable, destination: NodeJS.WritableStream, timeoutMs: number): Promise<void>;
+}
+/**
+ * ID生成工具
+ */
+export declare class IdUtils {
+    /**
+     * 生成请求ID
+     */
+    static generateRequestId(): string;
+    /**
+     * 生成响应ID
+     */
+    static generateResponseId(): string;
+    /**
+     * 生成推理项目ID
+     */
+    static generateReasoningId(): string;
+    /**
+     * 生成函数调用ID
+     */
+    static generateFunctionCallId(): string;
+    /**
+     * 生成工具调用ID
+     */
+    static generateToolCallId(): string;
+    /**
+     * 生成消息ID
+     */
+    static generateMessageId(): string;
+}
+/**
+ * 错误处理工具
+ */
+export declare class ErrorUtils {
+    /**
+     * 创建标准错误
+     */
+    static createError(message: string, code: string, context?: any): Error & {
+        code: string;
+        context?: any;
+    };
+    /**
+     * 包装错误
+     */
+    static wrapError(error: unknown, context?: string): Error;
+    /**
+     * 判断是否为超时错误
+     */
+    static isTimeoutError(error: Error): boolean;
+    /**
+     * 判断是否为网络错误
+     */
+    static isNetworkError(error: Error): boolean;
+}
+/**
+ * 正则表达式模式
+ */
+export declare const REGEX_PATTERNS: {
+    readonly WORD_BOUNDARY: RegExp;
+};
+/**
+ * 性能监控工具
+ */
+export declare class PerformanceUtils {
+    /**
+     * 创建性能计时器
+     */
+    static createTimer(): () => number;
+    /**
+     * 测量函数执行时间
+     */
+    static measureTime<T>(fn: () => T | Promise<T>): Promise<{
+        result: T;
+        duration: number;
+    }>;
+    /**
+     * 创建内存使用快照
+     */
+    static createMemorySnapshot(): {
+        rss: number;
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+    };
+}

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

@@ -3,8 +3,8 @@
  * 处理backpressure、超时、心跳、错误处理等通用流管理逻辑
  */
 import { PassThrough } from 'stream';
-import { BaseSseEvent } from '../types/core-interfaces.js';
-import { ChatSseEvent, ResponsesSseEvent, AnthropicSseEvent, GeminiSseEvent } from '../types/index.js';
+import type { BaseSseEvent } from '../types/core-interfaces.js';
+import type { ChatSseEvent, ResponsesSseEvent, AnthropicSseEvent, GeminiSseEvent } from '../types/index.js';
 export interface StreamWriterConfig {
     timeoutMs?: number;
     enableHeartbeat?: boolean;

package/dist/sse/sse-to-json/anthropic-sse-to-json-converter.d.ts

@@ -1,4 +1,4 @@
-import { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/index.js';
+import type { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/index.js';
 export declare class AnthropicSseToJsonConverter {
     private config;
     private contexts;