@jsonstudio/llms 0.4.3 → 0.4.5

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 {};

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

@@ -0,0 +1,151 @@
+import { dispatchReasoning } from '../../shared/reasoning-dispatcher.js';
+export function createAnthropicResponseBuilder(options) {
+    const state = {
+        content: [],
+        role: 'assistant',
+        completed: false
+    };
+    const flushCurrent = () => {
+        if (!state.currentBlock)
+            return;
+        const block = state.currentBlock;
+        if (block.kind === 'text' && block.buffer) {
+            state.content.push({ type: 'text', text: block.buffer });
+        }
+        else if (block.kind === 'thinking' && block.buffer) {
+            const decision = dispatchReasoning(block.buffer, {
+                mode: options?.reasoningMode,
+                prefix: options?.reasoningTextPrefix
+            });
+            if (decision.appendToContent) {
+                state.content.push({ type: 'text', text: decision.appendToContent });
+            }
+            if (decision.channel) {
+                state.content.push({ type: 'thinking', text: decision.channel });
+            }
+        }
+        else if (block.kind === 'tool_use') {
+            let input = {};
+            try {
+                input = block.buffer ? JSON.parse(block.buffer) : {};
+            }
+            catch {
+                input = { _raw: block.buffer };
+            }
+            state.content.push({
+                type: 'tool_use',
+                id: block.id,
+                name: block.name,
+                input
+            });
+        }
+        else if (block.kind === 'tool_result') {
+            state.content.push({
+                type: 'tool_result',
+                tool_use_id: block.tool_use_id,
+                content: block.content,
+                is_error: block.is_error
+            });
+        }
+        state.currentBlock = undefined;
+    };
+    return {
+        processEvent(event) {
+            switch (event.type) {
+                case 'message_start': {
+                    const payload = event.data?.message;
+                    if (payload) {
+                        state.id = payload.id || state.id;
+                        state.model = payload.model || state.model;
+                        state.role = payload.role || state.role;
+                    }
+                    break;
+                }
+                case 'content_block_start': {
+                    const payload = event.data?.content_block;
+                    const index = event.data?.index ?? 0;
+                    if (!payload)
+                        break;
+                    if (payload.type === 'text') {
+                        state.currentBlock = { kind: 'text', buffer: '', index };
+                    }
+                    else if (payload.type === 'thinking') {
+                        state.currentBlock = { kind: 'thinking', buffer: '', index };
+                    }
+                    else if (payload.type === 'tool_use') {
+                        state.currentBlock = {
+                            kind: 'tool_use',
+                            id: payload.id,
+                            name: payload.name,
+                            buffer: '',
+                            index
+                        };
+                    }
+                    else if (payload.type === 'tool_result') {
+                        state.currentBlock = {
+                            kind: 'tool_result',
+                            tool_use_id: payload.tool_use_id,
+                            content: payload.content,
+                            is_error: payload.is_error,
+                            index
+                        };
+                    }
+                    break;
+                }
+                case 'content_block_delta': {
+                    if (!state.currentBlock)
+                        break;
+                    const delta = event.data?.delta;
+                    if (!delta)
+                        break;
+                    if ((state.currentBlock.kind === 'text' || state.currentBlock.kind === 'thinking') && typeof delta.text === 'string') {
+                        state.currentBlock.buffer += delta.text;
+                    }
+                    else if (state.currentBlock.kind === 'tool_use' && typeof delta.partial_json === 'string') {
+                        state.currentBlock.buffer += delta.partial_json;
+                    }
+                    break;
+                }
+                case 'content_block_stop': {
+                    flushCurrent();
+                    break;
+                }
+                case 'message_delta': {
+                    const delta = event.data?.delta;
+                    if (delta?.stop_reason) {
+                        state.stopReason = delta.stop_reason;
+                    }
+                    if (delta?.usage) {
+                        state.usage = delta.usage;
+                    }
+                    break;
+                }
+                case 'message_stop': {
+                    state.completed = true;
+                    flushCurrent();
+                    break;
+                }
+                default:
+                    break;
+            }
+            return true;
+        },
+        getResult() {
+            if (!state.completed) {
+                return { success: false, error: new Error('Anthropic SSE stream incomplete') };
+            }
+            return {
+                success: true,
+                response: {
+                    id: state.id || `msg_${Date.now()}`,
+                    type: 'message',
+                    role: state.role || 'assistant',
+                    model: state.model || 'unknown',
+                    content: state.content,
+                    usage: state.usage,
+                    stop_reason: state.stopReason ?? 'end_turn'
+                }
+            };
+        }
+    };
+}

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

@@ -123,7 +123,7 @@ export declare class ResponsesResponseBuilder {
      */
     private buildOutputItems;
     /**
-     * 构建消息项
+     * 构建消息项并根据需要拆分reasoning
      */
     private buildMessageItem;
     /**

package/dist/sse/sse-to-json/builders/response-builder.js

@@ -2,6 +2,7 @@
  * Responses响应构建器
  * 负责状态机和事件聚合，从SSE事件构建完整的Responses响应对象
  */
+import { normalizeResponsesMessageItem } from '../../shared/responses-output-normalizer.js';
 // 默认配置
 export const DEFAULT_RESPONSE_BUILDER_CONFIG = {
     enableStrictValidation: true,
@@ -594,7 +595,8 @@ export class ResponsesResponseBuilder {
      * 处理错误事件
      */
     handleError(event) {
-        const msg = event.data?.error?.message;
+        const payload = event.data;
+        const msg = typeof payload?.error?.message === 'string' ? payload.error.message : undefined;
         // 容错：若无有效错误消息或当前响应已标记 completed，则将错误降级为非致命告警
         const status = this.response?.status;
         if (!msg || status === 'completed' || this.config.enableEventRecovery) {
@@ -635,8 +637,14 @@ export class ResponsesResponseBuilder {
             let outputItem;
             switch (state.type) {
                 case 'message':
-                    outputItem = this.buildMessageItem(state);
-                    break;
+                    {
+                        const { message, reasoning } = this.buildMessageItem(state);
+                        if (reasoning) {
+                            outputItems.push(reasoning);
+                        }
+                        outputItem = message;
+                        break;
+                    }
                 case 'function_call':
                     outputItem = this.buildFunctionCallItem(state);
                     break;
@@ -648,19 +656,33 @@ export class ResponsesResponseBuilder {
             }
             outputItems.push(outputItem);
         }
+        const hasMessage = outputItems.some(item => item.type === 'message');
+        const hasReasoning = outputItems.some(item => item.type === 'reasoning');
+        if (!hasMessage && hasReasoning) {
+            outputItems.push({
+                id: `message_placeholder_${outputItems.length + 1}`,
+                type: 'message',
+                status: 'completed',
+                role: 'assistant',
+                content: [{ type: 'output_text', text: '' }]
+            });
+        }
         return outputItems;
     }
     /**
-     * 构建消息项
+     * 构建消息项并根据需要拆分reasoning
      */
     buildMessageItem(state) {
-        return {
+        return normalizeResponsesMessageItem({
             id: state.id,
             type: 'message',
             status: 'completed',
-            role: 'assistant',
+            role: state.role || 'assistant',
             content: state.contentParts
-        };
+        }, {
+            requestId: state.id || 'message',
+            outputIndex: 0
+        });
     }
     /**
      * 构建函数调用项

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

@@ -46,6 +46,10 @@ export declare class ChatSseToJsonConverter {
      * 创建choice构建器
      */
     private createChoiceBuilder;
+    /**
+     * 将reasoning文本附加到消息内容
+     */
+    private appendReasoningToMessageContent;
     /**
      * 处理delta
      */
@@ -58,6 +62,10 @@ export declare class ChatSseToJsonConverter {
      * 更新响应中的choice
      */
     private updateResponseChoice;
+    /**
+     * 将reasoning内容规范化为独立字段并抽取工具调用
+     */
+    private normalizeReasoning;
     /**
      * 处理done事件
      */