@jsonstudio/llms 0.4.2

package/dist/sse/index.js

@@ -0,0 +1,115 @@
+/**
+ * SSE双向转换模块统一导出
+ * 支持Chat和Responses协议的JSON↔SSE双向转换
+ */
+import { ChatJsonToSseConverter as ChatJsonToSseConverterCtor } from './json-to-sse/index.js';
+import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { ResponsesJsonToSseConverter as ResponsesJsonToSseConverterCtor } from './json-to-sse/index.js';
+import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
+import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
+import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+// Chat协议转换器
+export { ChatJsonToSseConverter } from './json-to-sse/index.js';
+export { ChatSseToJsonConverter } from './sse-to-json/index.js';
+// Responses协议转换器
+export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
+export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+// 共享工具导出
+export * from './shared/utils.js';
+// 序列化器暂时禁用以专注核心SSE转换功能
+// export * from './shared/serializers/index.js';
+// 类型导出
+export * from './types/index.js';
+/**
+ * 工厂函数：创建Chat协议转换器
+ */
+export function createChatConverters() {
+    const jsonToSse = new ChatJsonToSseConverterCtor();
+    const sseToJson = new ChatSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        /**
+         * 执行完整的回环测试
+         */
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建Responses协议转换器
+ */
+export function createResponsesConverters() {
+    const jsonToSse = new ResponsesJsonToSseConverterCtor();
+    const sseToJson = new ResponsesSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        /**
+         * 执行完整的回环测试
+         */
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建Anthropic协议转换器
+ */
+export function createAnthropicConverters() {
+    const jsonToSse = new AnthropicJsonToSseConverterCtor();
+    const sseToJson = new AnthropicSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
+/**
+ * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
+ */
+export function createBidirectionalConverters() {
+    const chat = createChatConverters();
+    const responses = createResponsesConverters();
+    const anthropic = createAnthropicConverters();
+    return {
+        chat,
+        responses,
+        anthropic,
+        /**
+         * 自动检测协议类型并执行转换
+         */
+        async autoConvert(input, options = {}) {
+            // 根据输入数据的结构自动检测协议类型
+            if (input.object === 'chat.completion') {
+                return await chat.roundTrip(input, options);
+            }
+            else if (input.object === 'response') {
+                return await responses.roundTrip(input, options);
+            }
+            else if (input.type === 'message') {
+                return await anthropic.roundTrip(input, options);
+            }
+            else {
+                throw new Error(`无法识别的协议类型: ${input.object}`);
+            }
+        }
+    };
+}
+/**
+ * 默认转换器实例
+ */
+export const chatConverters = createChatConverters();
+export const responsesConverters = createResponsesConverters();
+export const bidirectionalConverters = createBidirectionalConverters();
+export const anthropicConverters = createAnthropicConverters();
+export { defaultSseCodecRegistry, SseCodecRegistry } from './registry/sse-codec-registry.js';

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

@@ -0,0 +1,11 @@
+import type { AnthropicMessageResponse, AnthropicJsonToSseOptions } from '../types/anthropic-types.js';
+/**
+ * Minimal Anthropic JSON → SSE converter (v3)
+ * - Emits a compact but spec-aligned event sequence for text content.
+ * - Tool use blocks: emits content_block_start (tool_use), input_json_delta (whole), content_block_stop.
+ *
+ * NOTE: This converter purposely avoids any tool governance. It only maps shapes/fields.
+ */
+export declare class AnthropicJsonToSseConverter {
+    convertResponseToJsonToSse(payload: AnthropicMessageResponse, options: AnthropicJsonToSseOptions): Promise<import('node:stream').Readable>;
+}

package/dist/sse/json-to-sse/anthropic-json-to-sse-converter.js

@@ -0,0 +1,79 @@
+import { PassThrough } from 'node:stream';
+/**
+ * Minimal Anthropic JSON → SSE converter (v3)
+ * - Emits a compact but spec-aligned event sequence for text content.
+ * - Tool use blocks: emits content_block_start (tool_use), input_json_delta (whole), content_block_stop.
+ *
+ * NOTE: This converter purposely avoids any tool governance. It only maps shapes/fields.
+ */
+export class AnthropicJsonToSseConverter {
+    async convertResponseToJsonToSse(payload, options) {
+        const stream = new PassThrough();
+        const write = (event, data) => {
+            stream.write(`event: ${event}\n`);
+            stream.write(`data: ${JSON.stringify(data)}\n\n`);
+        };
+        const messageId = payload.id || `msg_${Date.now()}`;
+        const model = payload.model || options.model || 'unknown';
+        // 1) message_start
+        write('message_start', {
+            type: 'message_start',
+            message: { id: messageId, type: 'message', role: 'assistant', model }
+        });
+        // 2) Iterate content blocks
+        let index = 0;
+        for (const block of payload.content || []) {
+            if (!block || typeof block !== 'object')
+                continue;
+            const type = block.type;
+            if (type === 'text') {
+                write('content_block_start', {
+                    type: 'content_block_start',
+                    index,
+                    content_block: { type: 'text' }
+                });
+                const text = String(block.text || '');
+                if (text) {
+                    write('content_block_delta', {
+                        type: 'content_block_delta',
+                        index,
+                        delta: { type: 'text_delta', text }
+                    });
+                }
+                write('content_block_stop', { type: 'content_block_stop', index });
+                index += 1;
+            }
+            else if (type === 'tool_use') {
+                const id = String(block.id || `call_${Math.random().toString(36).slice(2, 10)}`);
+                const name = String(block.name || 'unknown_tool');
+                const input = block.input ?? {};
+                write('content_block_start', {
+                    type: 'content_block_start',
+                    index,
+                    content_block: { type: 'tool_use', id, name }
+                });
+                try {
+                    const partial_json = JSON.stringify(input);
+                    write('content_block_delta', {
+                        type: 'content_block_delta',
+                        index,
+                        delta: { type: 'input_json_delta', partial_json }
+                    });
+                }
+                catch {
+                    // best-effort: skip delta on stringify error
+                }
+                write('content_block_stop', { type: 'content_block_stop', index });
+                index += 1;
+            }
+        }
+        // 3) message_delta (stop_reason hint)
+        const stop_reason = payload.stop_reason || 'end_turn';
+        write('message_delta', { type: 'message_delta', delta: { stop_reason } });
+        // 4) message_stop
+        write('message_stop', { type: 'message_stop' });
+        // DONE
+        stream.end();
+        return stream;
+    }
+}

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

@@ -0,0 +1,79 @@
+/**
+ * Chat JSON → SSE转换器（重构版本）
+ * 使用函数化架构：事件生成 + 序列化 + 写入分离
+ */
+import { ChatCompletionRequest, ChatCompletionResponse, ChatJsonToSseContext, ChatJsonToSseOptions, ChatSseEventStream, DEFAULT_CHAT_CONVERSION_CONFIG } from '../types/index.js';
+/**
+ * 重构后的Chat JSON到SSE转换器
+ * 采用函数化架构，专注于编排而非具体业务逻辑
+ */
+export declare class ChatJsonToSseConverterRefactored {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_CHAT_CONVERSION_CONFIG>);
+    /**
+     * 将Chat Completion请求转换为SSE流
+     */
+    convertRequestToJsonToSse(request: ChatCompletionRequest, options: ChatJsonToSseOptions): Promise<ChatSseEventStream>;
+    /**
+     * 将Chat Completion响应转换为SSE流
+     */
+    convertResponseToJsonToSse(response: ChatCompletionResponse, options: ChatJsonToSseOptions): Promise<ChatSseEventStream>;
+    /**
+     * 使用函数化架构处理请求转换
+     */
+    private processRequestToSseWithFunctions;
+    /**
+     * 使用函数化架构处理响应转换
+     */
+    private processResponseToSseWithFunctions;
+    /**
+     * 验证请求格式
+     */
+    private validateRequest;
+    /**
+     * 验证响应格式
+     */
+    private validateResponse;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 包装错误
+     */
+    private wrapError;
+    /**
+     * 处理流错误
+     */
+    private handleStreamError;
+    /**
+     * 完成流
+     */
+    private completeStream;
+    /**
+     * 中止流
+     */
+    private abortStream;
+    /**
+     * 创建请求上下文
+     */
+    private createRequestContext;
+    /**
+     * 创建响应上下文
+     */
+    private createResponseContext;
+    /**
+     * 获取上下文
+     */
+    getContext(requestId: string): ChatJsonToSseContext | undefined;
+    /**
+     * 清理上下文
+     */
+    clearContext(requestId: string): void;
+    /**
+     * 获取所有活跃的上下文
+     */
+    getActiveContexts(): Map<string, ChatJsonToSseContext>;
+}
+export declare const ChatJsonToSseConverter: typeof ChatJsonToSseConverterRefactored;

package/dist/sse/json-to-sse/chat-json-to-sse-converter.js

@@ -0,0 +1,296 @@
+/**
+ * Chat JSON → SSE转换器（重构版本）
+ * 使用函数化架构：事件生成 + 序列化 + 写入分离
+ */
+import { PassThrough } from 'stream';
+import { DEFAULT_CHAT_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { createChatSequencer } from './sequencers/chat-sequencer.js';
+import { createChatStreamWriter } from '../shared/writer.js';
+/**
+ * 重构后的Chat JSON到SSE转换器
+ * 采用函数化架构，专注于编排而非具体业务逻辑
+ */
+export class ChatJsonToSseConverterRefactored {
+    config = DEFAULT_CHAT_CONVERSION_CONFIG;
+    contexts = new Map();
+    constructor(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    /**
+     * 将Chat Completion请求转换为SSE流
+     */
+    async convertRequestToJsonToSse(request, options) {
+        // 1. 创建上下文
+        const context = this.createRequestContext(request, options);
+        this.contexts.set(options.requestId, context);
+        // 2. 创建底层流
+        const stream = new PassThrough({ objectMode: true });
+        // 3. 创建SSE事件流接口
+        const sseStream = Object.assign(stream, {
+            protocol: 'chat',
+            direction: 'json_to_sse',
+            requestId: options.requestId,
+            getStats: () => context.eventStats,
+            getConfig: () => this.config,
+            complete: () => this.completeStream(context, stream),
+            abort: (error) => this.abortStream(context, stream, error)
+        });
+        // 4. 启动异步转换过程（使用函数化架构）
+        this.processRequestToSseWithFunctions(request, context, stream).catch(error => {
+            this.handleStreamError(context, error, stream);
+        });
+        return sseStream;
+    }
+    /**
+     * 将Chat Completion响应转换为SSE流
+     */
+    async convertResponseToJsonToSse(response, options) {
+        // 1. 创建上下文
+        const context = this.createResponseContext(response, options);
+        this.contexts.set(options.requestId, context);
+        // 2. 创建底层流
+        const stream = new PassThrough({ objectMode: true });
+        // 3. 创建SSE事件流接口
+        const sseStream = Object.assign(stream, {
+            protocol: 'chat',
+            direction: 'json_to_sse',
+            requestId: options.requestId,
+            getStats: () => context.eventStats,
+            getConfig: () => this.config,
+            complete: () => this.completeStream(context, stream),
+            abort: (error) => this.abortStream(context, stream, error)
+        });
+        // 4. 启动异步转换过程（使用函数化架构）
+        this.processResponseToSseWithFunctions(response, context, stream).catch(error => {
+            this.handleStreamError(context, error, stream);
+        });
+        return sseStream;
+    }
+    /**
+     * 使用函数化架构处理请求转换
+     */
+    async processRequestToSseWithFunctions(request, context, stream) {
+        try {
+            // 1. 验证请求
+            this.validateRequest(request);
+            // 2. 创建流写入器
+            const writer = createChatStreamWriter(stream, {
+                onEvent: (event) => this.updateStats(context, event),
+                onError: (error) => this.handleStreamError(context, error, stream)
+            });
+            // 3. 创建事件序列化器
+            const sequencer = createChatSequencer({
+                chunkSize: context.options.maxTokensPerChunk || this.config.maxTokensPerChunk,
+                chunkDelayMs: context.options.chunkDelayMs || this.config.defaultChunkDelayMs,
+                enableDelay: !!context.options.chunkDelayMs
+            });
+            // 4. 生成事件序列并写入流
+            const eventStream = sequencer.sequenceRequest(request, context.model, context.requestId);
+            await writer.writeChatEvents(eventStream);
+            // 5. 完成流
+            writer.complete();
+        }
+        catch (error) {
+            throw this.wrapError('REQUEST_CONVERSION_ERROR', error, context.requestId);
+        }
+    }
+    /**
+     * 使用函数化架构处理响应转换
+     */
+    async processResponseToSseWithFunctions(response, context, stream) {
+        try {
+            // 1. 验证响应
+            this.validateResponse(response);
+            // 2. 创建流写入器
+            const writer = createChatStreamWriter(stream, {
+                onEvent: (event) => this.updateStats(context, event),
+                onError: (error) => this.handleStreamError(context, error, stream)
+            });
+            // 3. 创建事件序列化器
+            const sequencer = createChatSequencer({
+                chunkSize: context.options.maxTokensPerChunk || this.config.maxTokensPerChunk,
+                chunkDelayMs: context.options.chunkDelayMs || this.config.defaultChunkDelayMs,
+                enableDelay: !!context.options.chunkDelayMs
+            });
+            // 4. 生成事件序列并写入流
+            const eventStream = sequencer.sequenceResponse(response, context.model, context.requestId);
+            await writer.writeChatEvents(eventStream);
+            // 5. 完成流
+            writer.complete();
+        }
+        catch (error) {
+            throw this.wrapError('RESPONSE_CONVERSION_ERROR', error, context.requestId);
+        }
+    }
+    /**
+     * 验证请求格式
+     */
+    validateRequest(request) {
+        // 最小校验，避免依赖不存在的 ValidationUtils 方法
+        if (!request || typeof request !== 'object' || !Array.isArray(request.messages) || !request.model) {
+            throw new Error('Invalid ChatCompletionRequest format');
+        }
+    }
+    /**
+     * 验证响应格式
+     */
+    validateResponse(response) {
+        if (!response || typeof response !== 'object' || !Array.isArray(response.choices) || !response.model) {
+            throw new Error('Invalid ChatCompletionResponse format');
+        }
+    }
+    /**
+     * 更新统计信息
+     */
+    updateStats(context, event) {
+        // 尽量兼容 event/event.type 两种字段
+        const et = (event && (event.event || event.type)) || 'unknown';
+        if (typeof context.eventStats.totalEvents === 'number')
+            context.eventStats.totalEvents++;
+        if (context.eventStats.eventTypes) {
+            context.eventStats.eventTypes[et] = (context.eventStats.eventTypes[et] || 0) + 1;
+        }
+        if (et === 'error' || et === 'chat.error') {
+            context.eventStats.errorCount++;
+        }
+        // 更新时间戳
+        if (et === 'chat_chunk') {
+            context.eventStats.totalChunks++;
+            try {
+                const chunkObj = typeof event?.data === 'string' ? JSON.parse(event.data) : event?.data;
+                const choice = chunkObj?.choices?.[0];
+                const deltaContent = choice?.delta?.content;
+                if (typeof deltaContent === 'string') {
+                    context.eventStats.totalTokens += deltaContent.length;
+                }
+            }
+            catch { /* ignore parse errors */ }
+        }
+        if (typeof event?.timestamp === 'number')
+            context.eventStats.lastEventTime = event.timestamp;
+    }
+    /**
+     * 包装错误
+     */
+    wrapError(code, originalError, requestId) {
+        return ErrorUtils.createError(`${code}: ${originalError.message}`, code, { requestId, originalError });
+    }
+    /**
+     * 处理流错误
+     */
+    handleStreamError(context, error, stream) {
+        context.eventStats.errorCount++;
+        const wrappedError = this.wrapError('STREAM_ERROR', error, context.requestId);
+        if (stream.writable) {
+            stream.destroy(wrappedError);
+        }
+    }
+    /**
+     * 完成流
+     */
+    completeStream(context, stream) {
+        context.eventStats.endTime = Date.now();
+        context.eventStats.duration = context.eventStats.endTime - context.eventStats.startTime;
+        if (stream.writable) {
+            stream.end();
+        }
+    }
+    /**
+     * 中止流
+     */
+    abortStream(context, stream, error) {
+        context.eventStats.endTime = Date.now();
+        context.eventStats.duration = context.eventStats.endTime - context.eventStats.startTime;
+        if (error) {
+            context.eventStats.errorCount++;
+        }
+        if (stream.writable) {
+            stream.destroy(error);
+        }
+    }
+    /**
+     * 创建请求上下文
+     */
+    createRequestContext(request, options) {
+        const eventStats = {
+            totalChunks: 0,
+            totalTokens: 0,
+            totalChoices: 0,
+            totalToolCalls: 0,
+            startTime: Date.now(),
+            tokenRate: 0,
+            chunkRate: 0,
+            errorCount: 0,
+            retryCount: 0,
+            totalEvents: 0,
+            eventTypes: {}
+        };
+        return {
+            requestId: options.requestId,
+            model: request.model,
+            chatRequest: request,
+            options,
+            startTime: Date.now(),
+            sequenceCounter: 0,
+            choiceIndexCounter: 0,
+            toolCallIndexCounter: 0,
+            currentChunk: {},
+            isStreaming: true,
+            eventStats
+        };
+    }
+    /**
+     * 创建响应上下文
+     */
+    createResponseContext(response, options) {
+        const eventStats = {
+            totalChunks: 0,
+            totalTokens: 0,
+            totalChoices: 0,
+            totalToolCalls: 0,
+            startTime: Date.now(),
+            tokenRate: 0,
+            chunkRate: 0,
+            errorCount: 0,
+            retryCount: 0,
+            totalEvents: 0,
+            eventTypes: {}
+        };
+        return {
+            requestId: options.requestId,
+            model: response.model,
+            chatRequest: {},
+            options,
+            startTime: Date.now(),
+            sequenceCounter: 0,
+            choiceIndexCounter: 0,
+            toolCallIndexCounter: 0,
+            currentChunk: {},
+            isStreaming: true,
+            eventStats
+        };
+    }
+    /**
+     * 获取上下文
+     */
+    getContext(requestId) {
+        return this.contexts.get(requestId);
+    }
+    /**
+     * 清理上下文
+     */
+    clearContext(requestId) {
+        this.contexts.delete(requestId);
+    }
+    /**
+     * 获取所有活跃的上下文
+     */
+    getActiveContexts() {
+        return new Map(this.contexts);
+    }
+}
+// 为了向后兼容，导出原有名称
+export const ChatJsonToSseConverter = ChatJsonToSseConverterRefactored;

package/dist/sse/json-to-sse/event-generators/chat.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Chat协议事件生成器
+ * 提供纯函数，将Chat响应数据转换为SSE事件对象，不处理流写入
+ */
+import { ChatSseEvent, ChatToolCall } from '../../types/index.js';
+export interface ChatEventGeneratorConfig {
+    chunkSize: number;
+    chunkDelayMs: number;
+    enableIdGeneration: boolean;
+    enableTimestampGeneration: boolean;
+}
+export interface ChatEventGeneratorContext {
+    model: string;
+    requestId: string;
+    choiceIndex: number;
+    toolCallIndexCounter: number;
+    contentIndexCounter: Map<string, number>;
+}
+export declare const DEFAULT_CHAT_EVENT_GENERATOR_CONFIG: ChatEventGeneratorConfig;
+/**
+ * 创建默认上下文
+ */
+export declare function createDefaultContext(model: string, requestId: string): ChatEventGeneratorContext;
+/**
+ * 构建role delta事件
+ */
+export declare function buildRoleDelta(role: string, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent[];
+/**
+ * 构建reasoning delta事件
+ */
+export declare function buildReasoningDeltas(reasoning: string, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): Generator<ChatSseEvent>;
+/**
+ * 构建content delta事件
+ */
+export declare function buildContentDeltas(content: string, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): Generator<ChatSseEvent>;
+/**
+ * 构建tool_call开始事件
+ */
+export declare function buildToolCallStart(toolCall: ChatToolCall, toolCallIndex: number, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;
+/**
+ * 构建tool_call arguments delta事件
+ */
+export declare function buildToolCallArgsDeltas(args: string, toolCallIndex: number, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): Generator<ChatSseEvent>;
+/**
+ * 构建finish_reason事件
+ */
+export declare function buildFinishEvent(finishReason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call', context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;
+/**
+ * 构建done事件
+ */
+export declare function buildDoneEvent(context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;
+/**
+ * 构建error事件
+ */
+export declare function buildErrorEvent(error: Error, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;