@jsonstudio/llms 0.4.4 → 0.4.5

package/dist/sse/shared/reasoning-dispatcher.d.ts

@@ -0,0 +1,10 @@
+import type { ChatReasoningMode } from '../types/chat-types.js';
+export interface ReasoningDispatchResult {
+    channel?: string;
+    appendToContent?: string;
+}
+export interface ReasoningDispatchOptions {
+    mode?: ChatReasoningMode;
+    prefix?: string;
+}
+export declare function dispatchReasoning(input: string | undefined, options?: ReasoningDispatchOptions): ReasoningDispatchResult;

package/dist/sse/shared/reasoning-dispatcher.js

@@ -0,0 +1,25 @@
+function formatText(text, prefix) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return '';
+    if (!prefix)
+        return trimmed;
+    const needsSpace = !prefix.endsWith(' ') && !prefix.endsWith('\n');
+    return `${prefix}${needsSpace ? ' ' : ''}${trimmed}`;
+}
+export function dispatchReasoning(input, options) {
+    const trimmed = typeof input === 'string' ? input.trim() : '';
+    if (!trimmed.length) {
+        return {};
+    }
+    const mode = options?.mode ?? 'channel';
+    if (mode === 'drop') {
+        return {};
+    }
+    if (mode === 'text') {
+        return {
+            appendToContent: formatText(trimmed, options?.prefix)
+        };
+    }
+    return { channel: trimmed };
+}

package/dist/sse/shared/responses-output-normalizer.d.ts

@@ -0,0 +1,12 @@
+import type { ResponsesMessageItem, ResponsesOutputItem, ResponsesReasoningItem } from '../types/index.js';
+export interface ResponsesMessageNormalizationOptions {
+    requestId?: string;
+    outputIndex?: number;
+    extraReasoning?: string | string[];
+}
+export interface ResponsesMessageNormalizationResult {
+    message: ResponsesMessageItem;
+    reasoning?: ResponsesReasoningItem;
+}
+export declare function normalizeResponsesMessageItem(item: ResponsesMessageItem, options: ResponsesMessageNormalizationOptions): ResponsesMessageNormalizationResult;
+export declare function expandResponsesMessageItem(item: ResponsesMessageItem, options: ResponsesMessageNormalizationOptions): ResponsesOutputItem[];

package/dist/sse/shared/responses-output-normalizer.js

@@ -0,0 +1,45 @@
+import { normalizeMessageContentParts } from '../../conversion/shared/output-content-normalizer.js';
+export function normalizeResponsesMessageItem(item, options) {
+    const fallbackRequestId = typeof options.requestId === 'string' && options.requestId.trim().length
+        ? options.requestId.trim()
+        : 'message';
+    const fallbackIndex = typeof options.outputIndex === 'number' ? options.outputIndex : 0;
+    const baseId = typeof item.id === 'string' && item.id.trim().length
+        ? item.id.trim()
+        : `${fallbackRequestId}-message-${fallbackIndex}`;
+    const { normalizedParts, reasoningChunks } = normalizeMessageContentParts(item.content);
+    const additionalReasoning = options.extraReasoning;
+    if (additionalReasoning) {
+        const extras = Array.isArray(additionalReasoning) ? additionalReasoning : [additionalReasoning];
+        for (const entry of extras) {
+            if (typeof entry === 'string') {
+                const trimmed = entry.trim();
+                if (trimmed.length) {
+                    reasoningChunks.push(trimmed);
+                }
+            }
+        }
+    }
+    const normalizedContent = normalizedParts.length
+        ? normalizedParts
+        : [{ type: 'output_text', text: '' }];
+    const message = {
+        ...item,
+        id: baseId,
+        content: normalizedContent
+    };
+    let reasoning;
+    if (reasoningChunks.length) {
+        reasoning = {
+            id: `${baseId}_reasoning`,
+            type: 'reasoning',
+            summary: [],
+            content: reasoningChunks.map((text) => ({ type: 'reasoning_text', text }))
+        };
+    }
+    return { message, reasoning };
+}
+export function expandResponsesMessageItem(item, options) {
+    const { message, reasoning } = normalizeResponsesMessageItem(item, options);
+    return reasoning ? [message, reasoning] : [message];
+}

package/dist/sse/shared/serializers/anthropic-event-serializer.d.ts

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

package/dist/sse/shared/serializers/anthropic-event-serializer.js

@@ -0,0 +1,9 @@
+export function serializeAnthropicEventToSSE(event) {
+    const payload = event.data ?? {};
+    const type = event.event ||
+        event.type ||
+        (typeof payload?.type === 'string'
+            ? payload.type
+            : 'message');
+    return [`event: ${type}`, `data: ${JSON.stringify(payload)}`].join('\n') + '\n\n';
+}

package/dist/sse/shared/serializers/gemini-event-serializer.d.ts

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

package/dist/sse/shared/serializers/gemini-event-serializer.js

@@ -0,0 +1,5 @@
+export function serializeGeminiEventToSSE(event) {
+    const payload = event.data ?? {};
+    const eventType = event.event ?? event.type ?? 'gemini.data';
+    return [`event: ${eventType}`, `data: ${JSON.stringify(payload)}`].join('\n') + '\n\n';
+}

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

@@ -0,0 +1,41 @@
+/**
+ * 事件序列化适配器模块导出
+ * 提供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 { serializeAnthropicEventToSSE } from './anthropic-event-serializer.js';
+export { serializeGeminiEventToSSE } from './gemini-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;
+};

package/dist/sse/shared/serializers/index.js

@@ -9,6 +9,8 @@ import { ResponsesEventSerializer, defaultResponsesEventSerializer } from './res
 export { defaultChatEventSerializer } from './chat-event-serializer.js';
 // Responses协议序列化器
 export { defaultResponsesEventSerializer } from './responses-event-serializer.js';
+export { serializeAnthropicEventToSSE } from './anthropic-event-serializer.js';
+export { serializeGeminiEventToSSE } from './gemini-event-serializer.js';
 /**
  * 创建序列化器工厂
  */

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

@@ -0,0 +1,127 @@
+/**
+ * 统一的SSE事件流写入器
+ * 处理backpressure、超时、心跳、错误处理等通用流管理逻辑
+ */
+import { PassThrough } from 'stream';
+import { BaseSseEvent } from '../types/core-interfaces.js';
+import { ChatSseEvent, ResponsesSseEvent, AnthropicSseEvent, GeminiSseEvent } from '../types/index.js';
+export interface StreamWriterConfig {
+    timeoutMs?: number;
+    enableHeartbeat?: boolean;
+    heartbeatIntervalMs?: number;
+    maxBufferSize?: number;
+    enableBackpressure?: boolean;
+    onEvent?: (event: BaseSseEvent) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+}
+export interface StreamWriterStats {
+    totalEvents: number;
+    bytesWritten: number;
+    startTime: number;
+    lastWriteTime: number;
+    errors: number;
+}
+/**
+ * 统一的SSE流写入器
+ */
+export declare class StreamWriter {
+    private stream;
+    private config;
+    private stats;
+    private heartbeatInterval?;
+    private isActive;
+    private writeQueue;
+    private isWriting;
+    constructor(stream: PassThrough, config?: StreamWriterConfig);
+    /**
+     * 设置心跳
+     */
+    private setupHeartbeat;
+    /**
+     * 设置错误处理
+     */
+    private setupErrorHandling;
+    /**
+     * 发送心跳事件
+     */
+    private sendHeartbeat;
+    /**
+     * 写入单个事件
+     */
+    private writeEvent;
+    /**
+     * 处理背压
+     */
+    private handleBackpressure;
+    /**
+     * 序列化Responses事件（临时实现，需要 ResponsesSerializer）
+     * TODO: 等Responses协议修复后，实现完整的ResponsesSerializer
+     * 当前为临时实现，仅用于避免编译错误
+     */
+    private serializeResponsesEvent;
+    /**
+     * 异步写入事件流
+     */
+    writeEventStream(events: AsyncIterable<BaseSseEvent>): Promise<void>;
+    /**
+     * 同步写入事件数组
+     */
+    writeEvents(events: BaseSseEvent[]): Promise<void>;
+    /**
+     * 写入Chat事件流
+     */
+    writeChatEvents(events: AsyncIterable<ChatSseEvent> | ChatSseEvent[]): Promise<void>;
+    /**
+     * 写入Responses事件流
+     */
+    writeResponsesEvents(events: AsyncIterable<ResponsesSseEvent> | ResponsesSseEvent[]): Promise<void>;
+    /**
+     * 写入Anthropic事件流
+     */
+    writeAnthropicEvents(events: AsyncIterable<AnthropicSseEvent> | AnthropicSseEvent[]): Promise<void>;
+    /**
+     * 写入Gemini事件流
+     */
+    writeGeminiEvents(events: AsyncIterable<GeminiSseEvent> | GeminiSseEvent[]): Promise<void>;
+    /**
+     * 完成流写入
+     */
+    complete(): void;
+    /**
+     * 中止流写入
+     */
+    abort(error?: Error): void;
+    /**
+     * 获取写入统计
+     */
+    getStats(): StreamWriterStats;
+    /**
+     * 检查流是否活跃
+     */
+    isStreamActive(): boolean;
+    /**
+     * 清理资源
+     */
+    private cleanup;
+    /**
+     * 获取底层流
+     */
+    getUnderlyingStream(): PassThrough;
+}
+/**
+ * 创建Chat流写入器工厂函数
+ */
+export declare function createChatStreamWriter(stream: PassThrough, config?: StreamWriterConfig): StreamWriter;
+/**
+ * 创建Responses流写入器工厂函数
+ */
+export declare function createResponsesStreamWriter(stream: PassThrough, config?: StreamWriterConfig): StreamWriter;
+/**
+ * 创建Anthropic流写入器工厂函数
+ */
+export declare function createAnthropicStreamWriter(stream: PassThrough, config?: StreamWriterConfig): StreamWriter;
+/**
+ * 创建Gemini流写入器工厂函数
+ */
+export declare function createGeminiStreamWriter(stream: PassThrough, config?: StreamWriterConfig): StreamWriter;

package/dist/sse/shared/writer.js

@@ -2,7 +2,7 @@
  * 统一的SSE事件流写入器
  * 处理backpressure、超时、心跳、错误处理等通用流管理逻辑
  */
-import { defaultResponsesEventSerializer } from './serializers/index.js';
+import { defaultResponsesEventSerializer, serializeAnthropicEventToSSE, serializeGeminiEventToSSE } from './serializers/index.js';
 import { TimeUtils } from './utils.js';
 import { serializeChatEventToSSE } from './chat-serializer.js';
 /**
@@ -92,12 +92,24 @@ export class StreamWriter {
             else if (event && event.protocol === 'responses') {
                 serialized = this.serializeResponsesEvent(event);
             }
+            else if (event && event.protocol === 'anthropic-messages') {
+                serialized = serializeAnthropicEventToSSE(event);
+            }
+            else if (event && event.protocol === 'gemini-chat') {
+                serialized = serializeGeminiEventToSSE(event);
+            }
             else {
                 // 兜底处理：尝试通过事件字段识别
                 const eventField = event.event;
                 if (eventField === 'chat_chunk' || eventField === 'chat.done' || eventField === 'error' || eventField === 'ping') {
                     serialized = serializeChatEventToSSE(event);
                 }
+                else if (eventField === 'message_start' || eventField === 'content_block_start') {
+                    serialized = serializeAnthropicEventToSSE(event);
+                }
+                else if (eventField === 'gemini.data' || eventField === 'gemini.done') {
+                    serialized = serializeGeminiEventToSSE(event);
+                }
                 else {
                     serialized = this.serializeResponsesEvent(event);
                 }
@@ -195,6 +207,18 @@ export class StreamWriter {
     async writeResponsesEvents(events) {
         await this.writeEventStream(events);
     }
+    /**
+     * 写入Anthropic事件流
+     */
+    async writeAnthropicEvents(events) {
+        await this.writeEventStream(events);
+    }
+    /**
+     * 写入Gemini事件流
+     */
+    async writeGeminiEvents(events) {
+        await this.writeEventStream(events);
+    }
     /**
      * 完成流写入
      */
@@ -266,3 +290,15 @@ export function createChatStreamWriter(stream, config = {}) {
 export function createResponsesStreamWriter(stream, config = {}) {
     return new StreamWriter(stream, config);
 }
+/**
+ * 创建Anthropic流写入器工厂函数
+ */
+export function createAnthropicStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}
+/**
+ * 创建Gemini流写入器工厂函数
+ */
+export function createGeminiStreamWriter(stream, config = {}) {
+    return new StreamWriter(stream, config);
+}

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

@@ -0,0 +1,11 @@
+import { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/index.js';
+export declare class AnthropicSseToJsonConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof this.config>);
+    convertSseToJson(sseStream: AsyncIterable<string | Buffer>, options: SseToAnthropicJsonOptions): Promise<AnthropicMessageResponse>;
+    private createContext;
+    private chunkStrings;
+    private updateStats;
+    private wrapError;
+}

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

@@ -1,139 +1,104 @@
-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
- */
+import { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { createSseParser } from './parsers/sse-parser.js';
+import { createAnthropicResponseBuilder } from './builders/anthropic-response-builder.js';
 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 };
+    config = {
+        enableEventValidation: true,
+        strictMode: false,
+        ...DEFAULT_ANTHROPIC_CONVERSION_CONFIG
+    };
+    contexts = new Map();
+    constructor(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    async convertSseToJson(sseStream, options) {
+        const context = this.createContext(options);
+        this.contexts.set(options.requestId, context);
+        const parser = createSseParser({
+            enableStrictValidation: this.config.enableEventValidation,
+            enableEventRecovery: !this.config.strictMode,
+            allowedEventTypes: new Set([
+                'message_start',
+                'content_block_start',
+                'content_block_delta',
+                'content_block_stop',
+                'message_delta',
+                'message_stop'
+            ])
+        });
+        const builder = createAnthropicResponseBuilder({
+            reasoningMode: options.reasoningMode ?? this.config.reasoningMode,
+            reasoningTextPrefix: options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+        });
+        try {
+            for await (const result of parser.parseStreamAsync(this.chunkStrings(sseStream))) {
+                if (!result.success || !result.event) {
+                    if (this.config.strictMode) {
+                        throw new Error(result.error || 'Failed to parse Anthropic SSE event');
                     }
                     continue;
                 }
-                if (line.startsWith('id:')) {
-                    current.id = line.slice(3).trim();
+                if (result.event.protocol !== 'anthropic-messages') {
                     continue;
                 }
+                builder.processEvent(result.event);
+                this.updateStats(context, result.event);
+            }
+            const outcome = builder.getResult();
+            if (!outcome.success || !outcome.response) {
+                throw outcome.error || new Error('Anthropic SSE conversion incomplete');
             }
+            context.isCompleted = true;
+            context.eventStats.endTime = Date.now();
+            return outcome.response;
         }
-        // flush tail
-        pushCurrent();
+        catch (error) {
+            context.eventStats.errors = (context.eventStats.errors ?? 0) + 1;
+            throw this.wrapError('ANTHROPIC_SSE_TO_JSON_FAILED', error, options.requestId);
+        }
+        finally {
+            this.contexts.delete(options.requestId);
+        }
+    }
+    createContext(options) {
         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'
+            requestId: options.requestId,
+            model: options.model,
+            startTime: Date.now(),
+            eventStats: {
+                totalEvents: 0,
+                contentBlocks: 0,
+                toolUseBlocks: 0,
+                thinkingBlocks: 0,
+                textBlocks: 0,
+                errors: 0,
+                startTime: Date.now()
+            },
+            isCompleted: false
         };
     }
+    async *chunkStrings(stream) {
+        for await (const chunk of stream) {
+            yield typeof chunk === 'string' ? chunk : chunk.toString();
+        }
+    }
+    updateStats(context, event) {
+        context.eventStats.totalEvents += 1;
+        if (event.type === 'content_block_start') {
+            context.eventStats.contentBlocks += 1;
+            const blockType = event.data?.content_block?.type;
+            if (blockType === 'tool_use')
+                context.eventStats.toolUseBlocks += 1;
+            if (blockType === 'thinking')
+                context.eventStats.thinkingBlocks += 1;
+            if (blockType === 'text')
+                context.eventStats.textBlocks += 1;
+        }
+    }
+    wrapError(code, error, requestId) {
+        return ErrorUtils.createError(error.message, code, { requestId });
+    }
 }

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

@@ -0,0 +1,16 @@
+import { AnthropicMessageResponse, AnthropicSseEvent } from '../../types/index.js';
+import type { ChatReasoningMode } from '../../types/chat-types.js';
+interface BuilderOptions {
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface AnthropicBuilderResult {
+    success: boolean;
+    response?: AnthropicMessageResponse;
+    error?: Error;
+}
+export declare function createAnthropicResponseBuilder(options?: BuilderOptions): {
+    processEvent(event: AnthropicSseEvent): boolean;
+    getResult(): AnthropicBuilderResult;
+};
+export {};