@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,268 +0,0 @@
-/**
- * 统一的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

@@ -1,13 +0,0 @@
-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

@@ -1,139 +0,0 @@
-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

@@ -1,165 +0,0 @@
-/**
- * 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;