@jsonstudio/llms 0.4.2

package/dist/conversion/conversion-v3/sse/shared/writer.js

@@ -0,0 +1,268 @@
+/**
+ * 统一的SSE事件流写入器
+ * 处理backpressure、超时、心跳、错误处理等通用流管理逻辑
+ */
+import { defaultResponsesEventSerializer } from './serializers/index.js';
+import { TimeUtils } from './utils.js';
+import { serializeChatEventToSSE } from './chat-serializer.js';
+/**
+ * 统一的SSE流写入器
+ */
+export class StreamWriter {
+    stream;
+    config;
+    stats;
+    heartbeatInterval;
+    isActive = true;
+    writeQueue = [];
+    isWriting = false;
+    constructor(stream, config = {}) {
+        this.stream = stream;
+        this.config = {
+            timeoutMs: config.timeoutMs || 30000,
+            enableHeartbeat: config.enableHeartbeat ?? false,
+            heartbeatIntervalMs: config.heartbeatIntervalMs || 15000,
+            maxBufferSize: config.maxBufferSize || 1000,
+            enableBackpressure: config.enableBackpressure ?? true,
+            onEvent: config.onEvent || (() => { }),
+            onError: config.onError || (() => { }),
+            onComplete: config.onComplete || (() => { })
+        };
+        this.stats = {
+            totalEvents: 0,
+            bytesWritten: 0,
+            startTime: TimeUtils.now(),
+            lastWriteTime: 0,
+            errors: 0
+        };
+        this.setupHeartbeat();
+        this.setupErrorHandling();
+    }
+    /**
+     * 设置心跳
+     */
+    setupHeartbeat() {
+        if (!this.config.enableHeartbeat)
+            return;
+        this.heartbeatInterval = setInterval(() => {
+            if (this.isActive) {
+                this.sendHeartbeat();
+            }
+        }, this.config.heartbeatIntervalMs);
+    }
+    /**
+     * 设置错误处理
+     */
+    setupErrorHandling() {
+        this.stream.on('error', (error) => {
+            this.stats.errors++;
+            this.config.onError(error);
+        });
+        this.stream.on('close', () => {
+            this.cleanup();
+            this.config.onComplete();
+        });
+    }
+    /**
+     * 发送心跳事件
+     */
+    sendHeartbeat() {
+        const heartbeatEvent = {
+            type: 'heartbeat',
+            timestamp: TimeUtils.now(),
+            data: '',
+            sequenceNumber: -1
+        };
+        this.writeEvent(heartbeatEvent);
+    }
+    /**
+     * 写入单个事件
+     */
+    async writeEvent(event) {
+        if (!this.isActive)
+            return;
+        try {
+            // 触发事件回调
+            this.config.onEvent(event);
+            // 序列化事件 - 使用协议标识进行类型识别
+            let serialized;
+            if (event && event.protocol === 'chat') {
+                serialized = serializeChatEventToSSE(event);
+            }
+            else if (event && event.protocol === 'responses') {
+                serialized = this.serializeResponsesEvent(event);
+            }
+            else {
+                // 兜底处理：尝试通过事件字段识别
+                const eventField = event.event;
+                if (eventField === 'chat_chunk' || eventField === 'chat.done' || eventField === 'error' || eventField === 'ping') {
+                    serialized = serializeChatEventToSSE(event);
+                }
+                else {
+                    serialized = this.serializeResponsesEvent(event);
+                }
+            }
+            const needsBackpressure = this.config.enableBackpressure && !this.stream.write(serialized);
+            if (needsBackpressure) {
+                await this.handleBackpressure();
+            }
+            // 更新统计
+            this.stats.totalEvents++;
+            this.stats.bytesWritten += Buffer.byteLength(serialized, 'utf8');
+            this.stats.lastWriteTime = TimeUtils.now();
+        }
+        catch (error) {
+            this.stats.errors++;
+            this.config.onError(error);
+        }
+    }
+    /**
+     * 处理背压
+     */
+    async handleBackpressure() {
+        return new Promise((resolve) => {
+            const checkDrain = () => {
+                if (this.stream.writableLength < this.config.maxBufferSize) {
+                    this.stream.removeListener('drain', checkDrain);
+                    resolve();
+                }
+            };
+            this.stream.on('drain', checkDrain);
+        });
+    }
+    /**
+     * 序列化Responses事件（临时实现，需要 ResponsesSerializer）
+     * TODO: 等Responses协议修复后，实现完整的ResponsesSerializer
+     * 当前为临时实现，仅用于避免编译错误
+     */
+    serializeResponsesEvent(event) {
+        try {
+            if (typeof event.type === 'string' && event.type.startsWith('response.')) {
+                return defaultResponsesEventSerializer.serializeToWire(event);
+            }
+        }
+        catch {
+            // ignore and fallback
+        }
+        const rawData = event.data;
+        const dataPayload = typeof rawData === 'string'
+            ? rawData
+            : JSON.stringify({
+                type: event.type,
+                ...(rawData ?? {})
+            });
+        return `event: ${event.type}\ndata: ${dataPayload}\n\n`;
+    }
+    /**
+     * 异步写入事件流
+     */
+    async writeEventStream(events) {
+        if (!this.isActive)
+            return;
+        try {
+            for await (const event of events) {
+                if (!this.isActive)
+                    break;
+                await this.writeEvent(event);
+            }
+        }
+        catch (error) {
+            this.stats.errors++;
+            this.config.onError(error);
+        }
+    }
+    /**
+     * 同步写入事件数组
+     */
+    async writeEvents(events) {
+        if (!this.isActive)
+            return;
+        for (const event of events) {
+            if (!this.isActive)
+                break;
+            await this.writeEvent(event);
+        }
+    }
+    /**
+     * 写入Chat事件流
+     */
+    async writeChatEvents(events) {
+        await this.writeEventStream(events);
+    }
+    /**
+     * 写入Responses事件流
+     */
+    async writeResponsesEvents(events) {
+        await this.writeEventStream(events);
+    }
+    /**
+     * 完成流写入
+     */
+    complete() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        // 确保所有数据都写入完成
+        if (this.stream.writable) {
+            this.stream.end();
+        }
+    }
+    /**
+     * 中止流写入
+     */
+    abort(error) {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        if (error) {
+            this.stats.errors++;
+            this.config.onError(error);
+        }
+        if (this.stream.writable) {
+            this.stream.destroy(error);
+        }
+    }
+    /**
+     * 获取写入统计
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            duration: TimeUtils.now() - this.stats.startTime
+        };
+    }
+    /**
+     * 检查流是否活跃
+     */
+    isStreamActive() {
+        return this.isActive && this.stream.writable;
+    }
+    /**
+     * 清理资源
+     */
+    cleanup() {
+        this.isActive = false;
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+    }
+    /**
+     * 获取底层流
+     */
+    getUnderlyingStream() {
+        return this.stream;
+    }
+}
+/**
+ * 创建Chat流写入器工厂函数
+ */
+export function createChatStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}
+/**
+ * 创建Responses流写入器工厂函数
+ */
+export function createResponsesStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}

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

@@ -0,0 +1,13 @@
+import type { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/anthropic-types.js';
+/**
+ * Minimal Anthropic SSE → JSON converter (v3)
+ *
+ * Aggregates a subset of Anthropic events into a single message object:
+ * - message_start → capture id/model
+ * - content_block_start/delta/stop → build text/tool_use blocks
+ * - message_delta → stop_reason hint
+ * - message_stop → finalize
+ */
+export declare class AnthropicSseToJsonConverter {
+    convertSseToJson(sseStream: AsyncIterable<string | Buffer>, _options: SseToAnthropicJsonOptions): Promise<AnthropicMessageResponse>;
+}

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

@@ -0,0 +1,139 @@
+function isStringOrBuffer(v) {
+    return typeof v === 'string' || Buffer.isBuffer(v);
+}
+/**
+ * Minimal Anthropic SSE → JSON converter (v3)
+ *
+ * Aggregates a subset of Anthropic events into a single message object:
+ * - message_start → capture id/model
+ * - content_block_start/delta/stop → build text/tool_use blocks
+ * - message_delta → stop_reason hint
+ * - message_stop → finalize
+ */
+export class AnthropicSseToJsonConverter {
+    async convertSseToJson(sseStream, _options) {
+        const state = { content: [], role: 'assistant', current: null };
+        let buffer = '';
+        const flushEvent = (event) => {
+            const t = String(event?.event || '').trim();
+            const data = event?.data;
+            if (!t)
+                return;
+            if (t === 'message_start') {
+                state.id = data?.message?.id || state.id;
+                state.model = data?.message?.model || state.model;
+                state.role = data?.message?.role || 'assistant';
+                return;
+            }
+            if (t === 'content_block_start') {
+                const cb = data?.content_block;
+                if (cb?.type === 'text') {
+                    state.current = { index: Number(data?.index || 0), kind: 'text' };
+                }
+                else if (cb?.type === 'tool_use') {
+                    state.current = {
+                        index: Number(data?.index || 0),
+                        kind: 'tool_use',
+                        id: String(cb?.id || `call_${Math.random().toString(36).slice(2, 10)}`),
+                        name: String(cb?.name || 'unknown_tool'),
+                        json: ''
+                    };
+                }
+                return;
+            }
+            if (t === 'content_block_delta') {
+                if (!state.current)
+                    return;
+                const d = data?.delta;
+                if (state.current.kind === 'text' && d?.type === 'text_delta' && typeof d?.text === 'string') {
+                    const last = state.content[state.content.length - 1];
+                    if (last && last.type === 'text') {
+                        last.text += d.text;
+                    }
+                    else {
+                        state.content.push({ type: 'text', text: d.text });
+                    }
+                }
+                else if (state.current.kind === 'tool_use' && d?.type === 'input_json_delta') {
+                    state.current.json = (state.current.json || '') + String(d?.partial_json || '');
+                }
+                return;
+            }
+            if (t === 'content_block_stop') {
+                if (!state.current)
+                    return;
+                if (state.current.kind === 'tool_use') {
+                    let input = {};
+                    try {
+                        input = state.current.json ? JSON.parse(state.current.json) : {};
+                    }
+                    catch {
+                        input = { _raw: state.current.json };
+                    }
+                    state.content.push({ type: 'tool_use', id: state.current.id, name: state.current.name, input });
+                }
+                state.current = null;
+                return;
+            }
+            if (t === 'message_delta') {
+                const r = data?.delta?.stop_reason;
+                if (r)
+                    state.stop_reason = r;
+                return;
+            }
+            if (t === 'message_stop') {
+                // finalize
+                return;
+            }
+        };
+        // very small SSE line parser (event/data/id); compatible with our Generators
+        let current = {};
+        const pushCurrent = () => {
+            if (Object.keys(current).length) {
+                flushEvent(current);
+                current = {};
+            }
+        };
+        for await (const chunk of sseStream) {
+            const text = isStringOrBuffer(chunk) ? chunk.toString() : String(chunk);
+            buffer += text;
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const raw of lines) {
+                const line = raw.trim();
+                if (!line) {
+                    pushCurrent();
+                    continue;
+                }
+                if (line.startsWith('event:')) {
+                    current.event = line.slice(6).trim();
+                    continue;
+                }
+                if (line.startsWith('data:')) {
+                    const data = line.slice(5).trim();
+                    try {
+                        current.data = JSON.parse(data);
+                    }
+                    catch {
+                        current.data = { raw: data };
+                    }
+                    continue;
+                }
+                if (line.startsWith('id:')) {
+                    current.id = line.slice(3).trim();
+                    continue;
+                }
+            }
+        }
+        // flush tail
+        pushCurrent();
+        return {
+            id: state.id || `msg_${Date.now()}`,
+            type: 'message',
+            role: state.role || 'assistant',
+            model: state.model || 'unknown',
+            content: state.content,
+            stop_reason: state.stop_reason || 'end_turn'
+        };
+    }
+}

package/dist/conversion/conversion-v3/sse/sse-to-json/builders/response-builder.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Responses响应构建器
+ * 负责状态机和事件聚合，从SSE事件构建完整的Responses响应对象
+ */
+import { ResponsesSseEvent, ResponsesResponse } from '../../types/index.js';
+export type ResponseBuilderState = 'initial' | 'building' | 'completed' | 'error';
+export interface ResponseBuilderConfig {
+    enableStrictValidation: boolean;
+    enableEventRecovery: boolean;
+    maxOutputItems: number;
+    maxContentParts: number;
+    maxSequenceGaps: number;
+}
+export interface OutputItemState {
+    id: string;
+    type: string;
+    status: 'in_progress' | 'completed';
+    contentParts: any[];
+    currentContentIndex: number;
+    accumulatedContent: any[];
+    hasContentPartAdded: boolean;
+    isTextInProgress: boolean;
+    callId?: string;
+    name?: string;
+    arguments?: string;
+    role?: string;
+    startTime: number;
+    lastEventTime: number;
+}
+export declare const DEFAULT_RESPONSE_BUILDER_CONFIG: ResponseBuilderConfig;
+/**
+ * Responses响应构建器
+ */
+export declare class ResponsesResponseBuilder {
+    private state;
+    private response;
+    private outputItemBuilders;
+    private lastSequenceNumber;
+    private config;
+    private error?;
+    constructor(config?: Partial<ResponseBuilderConfig>);
+    /**
+     * 处理SSE事件
+     */
+    processEvent(event: ResponsesSseEvent): boolean;
+    /**
+     * 验证序列号
+     */
+    private validateSequenceNumber;
+    /**
+     * 处理response.start事件
+     */
+    private handleResponseStart;
+    private handleResponseCreated;
+    private handleResponseInProgress;
+    /**
+     * 处理output_item.start事件
+     */
+    private handleOutputItemStart;
+    private mapOutputItemAdded;
+    /**
+     * 处理content_part.start事件
+     */
+    private handleContentPartStart;
+    private mapContentPartAdded;
+    /**
+     * 处理content_part.delta事件
+     */
+    private handleContentPartDelta;
+    private mapOutputTextDelta;
+    /**
+     * 处理content_part.done事件
+     */
+    private handleContentPartDone;
+    private mapContentPartDone;
+    /**
+     * 处理function_call.start事件
+     */
+    private handleFunctionCallStart;
+    /**
+     * 处理function_call.delta事件
+     */
+    private handleFunctionCallDelta;
+    private mapFunctionCallDelta;
+    /**
+     * 处理function_call.done事件
+     */
+    private handleFunctionCallDone;
+    private mapFunctionCallDone;
+    /**
+     * 处理reasoning.start事件
+     */
+    private handleReasoningStart;
+    /**
+     * 处理reasoning.delta事件
+     */
+    private handleReasoningDelta;
+    private mapReasoningDelta;
+    private mapReasoningDone;
+    /**
+     * 处理reasoning.done事件
+     */
+    private handleReasoningDone;
+    /**
+     * 处理output_item.done事件
+     */
+    private handleOutputItemDone;
+    /**
+     * 处理required_action事件
+     */
+    private handleRequiredAction;
+    /**
+     * 处理response.done事件
+     */
+    private handleResponseDone;
+    /**
+     * 处理错误事件
+     */
+    private handleError;
+    private handleResponseCompleted;
+    /**
+     * 构建输出项列表
+     */
+    private buildOutputItems;
+    /**
+     * 构建消息项
+     */
+    private buildMessageItem;
+    /**
+     * 构建函数调用项
+     */
+    private buildFunctionCallItem;
+    /**
+     * 构建推理项
+     */
+    private buildReasoningItem;
+    /**
+     * 获取构建结果
+     */
+    getResult(): {
+        success: boolean;
+        response?: ResponsesResponse;
+        error?: Error;
+    };
+    /**
+     * 获取当前状态
+     */
+    getState(): ResponseBuilderState;
+    /**
+     * 重置构建器
+     */
+    reset(): void;
+    /**
+     * 获取输出项构建器
+     */
+    getOutputItemBuilders(): Map<string, OutputItemState>;
+    /**
+     * 获取最后序列号
+     */
+    getLastSequenceNumber(): number;
+}
+/**
+ * 创建响应构建器工厂
+ */
+export declare function createResponseBuilder(config?: Partial<ResponseBuilderConfig>): ResponsesResponseBuilder;