@jsonstudio/llms 0.4.4 → 0.4.5

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

@@ -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;
+    /**
+     * 构建消息项并根据需要拆分reasoning
+     */
+    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;

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,
@@ -636,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;
@@ -649,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

@@ -0,0 +1,114 @@
+/**
+ * Chat SSE → JSON转换器
+ * 将SSE事件流聚合为ChatCompletion响应
+ */
+import { ChatCompletionResponse, ChatSseEvent, SseToChatJsonOptions, ChatEventStats, DEFAULT_CHAT_CONVERSION_CONFIG } from '../types/index.js';
+/**
+ * Chat SSE到JSON转换器
+ */
+export declare class ChatSseToJsonConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_CHAT_CONVERSION_CONFIG>);
+    /**
+     * 将SSE流转换为Chat Completion响应
+     */
+    convertSseToJson(sseStream: AsyncIterable<ChatSseEvent> | AsyncIterable<string | Buffer>, options: SseToChatJsonOptions): Promise<ChatCompletionResponse>;
+    /**
+     * 将SSE流转换为流式响应
+     */
+    aggregateSseStream(sseStream: AsyncIterable<ChatSseEvent> | AsyncIterable<string | Buffer>, options: SseToChatJsonOptions): AsyncGenerator<ChatCompletionResponse>;
+    /**
+     * 确保输入流转换为 ChatSseEvent 流
+     */
+    private ensureEventStream;
+    /**
+     * 将SSE文本块解析为Chat事件
+     */
+    private parseSseChunk;
+    /**
+     * 创建转换上下文
+     */
+    private createContext;
+    /**
+     * 处理SSE事件
+     */
+    private processSseEvent;
+    /**
+     * 处理chat_chunk事件
+     */
+    private processChatChunk;
+    /**
+     * 处理choice
+     */
+    private processChoice;
+    /**
+     * 创建choice构建器
+     */
+    private createChoiceBuilder;
+    /**
+     * 将reasoning文本附加到消息内容
+     */
+    private appendReasoningToMessageContent;
+    /**
+     * 处理delta
+     */
+    private processDelta;
+    /**
+     * 处理tool_call delta
+     */
+    private processToolCallDelta;
+    /**
+     * 更新响应中的choice
+     */
+    private updateResponseChoice;
+    /**
+     * 将reasoning内容规范化为独立字段并抽取工具调用
+     */
+    private normalizeReasoning;
+    /**
+     * 处理done事件
+     */
+    private processDoneEvent;
+    /**
+     * 处理error事件
+     */
+    private processErrorEvent;
+    /**
+     * 构建部分响应
+     */
+    private buildPartialResponse;
+    /**
+     * 完成响应构建
+     */
+    private finalizeResponse;
+    /**
+     * 构建使用量信息
+     */
+    private buildUsageInfo;
+    /**
+     * 验证SSE事件
+     */
+    private validateSseEvent;
+    /**
+     * 验证Chat chunk
+     */
+    private validateChatChunk;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 获取转换统计
+     */
+    getStats(requestId: string): ChatEventStats | undefined;
+    /**
+     * 清理上下文
+     */
+    cleanup(requestId: string): void;
+    /**
+     * 清理所有上下文
+     */
+    cleanupAll(): void;
+}
+export declare const defaultChatSseToJsonConverter: ChatSseToJsonConverter;

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

@@ -4,6 +4,9 @@
  */
 import { DEFAULT_CHAT_CONVERSION_CONFIG, CHAT_CONVERSION_ERROR_CODES } from '../types/index.js';
 import { TimeUtils, ErrorUtils } from '../shared/utils.js';
+import { normalizeMessageReasoningTools } from '../../conversion/shared/reasoning-tool-normalizer.js';
+import { normalizeChatMessageContent } from '../../conversion/shared/chat-output-normalizer.js';
+import { dispatchReasoning } from '../shared/reasoning-dispatcher.js';
 /**
  * Chat SSE到JSON转换器
  */
@@ -270,6 +273,7 @@ export class ChatSseToJsonConverter {
             messageBuilder: {
                 role: undefined,
                 content: '',
+                reasoningContent: '',
                 name: undefined,
                 functionCall: undefined,
                 toolCalls: [],
@@ -281,6 +285,19 @@ export class ChatSseToJsonConverter {
             toolCallBuilders: new Map()
         };
     }
+    /**
+     * 将reasoning文本附加到消息内容
+     */
+    appendReasoningToMessageContent(message, reasoningText) {
+        const trimmed = typeof reasoningText === 'string' ? reasoningText.trim() : '';
+        if (!trimmed) {
+            return;
+        }
+        const current = typeof message.content === 'string' ? message.content : '';
+        const needsSeparator = current.length > 0;
+        const separator = !needsSeparator ? '' : current.endsWith('\n') ? '\n' : '\n\n';
+        message.content = `${current}${separator}${trimmed}`;
+    }
     /**
      * 处理delta
      */
@@ -292,8 +309,9 @@ export class ChatSseToJsonConverter {
         }
         // 处理reasoning
         if (delta.reasoning) {
-            messageBuilder.content += delta.reasoning;
-            choiceBuilder.accumulatedContent += delta.reasoning;
+            const chunk = delta.reasoning;
+            messageBuilder.reasoningContent = (messageBuilder.reasoningContent || '') + chunk;
+            choiceBuilder.accumulatedContent += chunk;
         }
         // 处理content
         if (delta.content) {
@@ -379,9 +397,19 @@ export class ChatSseToJsonConverter {
         const message = {
             role: messageBuilder.role || 'assistant'
         };
-        if (messageBuilder.content) {
+        const normalizedContent = normalizeChatMessageContent(messageBuilder.content);
+        if (normalizedContent.contentText !== undefined) {
+            message.content = normalizedContent.contentText;
+        }
+        else if (messageBuilder.content) {
             message.content = messageBuilder.content;
         }
+        const reasoningCandidate = messageBuilder.reasoningContent && messageBuilder.reasoningContent.length
+            ? messageBuilder.reasoningContent
+            : normalizedContent.reasoningText;
+        if (reasoningCandidate) {
+            message.reasoning_content = reasoningCandidate;
+        }
         if (messageBuilder.functionCall) {
             message.function_call = messageBuilder.functionCall;
         }
@@ -402,10 +430,58 @@ export class ChatSseToJsonConverter {
         if (toolCalls.length > 0) {
             message.tool_calls = toolCalls;
         }
+        this.normalizeReasoning(choiceBuilder, message, context);
         responseChoice.message = message;
         responseChoice.finish_reason = choiceBuilder.finishReason ?? responseChoice.finish_reason;
         context.eventStats.totalToolCalls += toolCalls.length;
     }
+    /**
+     * 将reasoning内容规范化为独立字段并抽取工具调用
+     */
+    normalizeReasoning(choiceBuilder, message, context) {
+        if (!message.reasoning_content && !message.reasoning) {
+            return;
+        }
+        const target = message;
+        normalizeMessageReasoningTools(target, {
+            idPrefix: `chat_sse_reasoning_${choiceBuilder.index + 1}`
+        });
+        const reasoningSource = typeof target.reasoning_content === 'string'
+            ? target.reasoning_content
+            : typeof target.reasoning === 'string'
+                ? target.reasoning
+                : undefined;
+        const reasoningText = typeof reasoningSource === 'string' ? reasoningSource.trim() : '';
+        if (!reasoningText) {
+            if ('reasoning_content' in target)
+                delete target.reasoning_content;
+            if ('reasoning' in target)
+                delete target.reasoning;
+            return;
+        }
+        const dispatchResult = dispatchReasoning(reasoningText, {
+            mode: context.options.reasoningMode ?? this.config.reasoningMode,
+            prefix: context.options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+        });
+        if (dispatchResult.appendToContent) {
+            this.appendReasoningToMessageContent(message, dispatchResult.appendToContent);
+            if ('reasoning_content' in target)
+                delete target.reasoning_content;
+            if ('reasoning' in target)
+                delete target.reasoning;
+            return;
+        }
+        if (dispatchResult.channel) {
+            target.reasoning_content = dispatchResult.channel;
+            if ('reasoning' in target)
+                delete target.reasoning;
+            return;
+        }
+        if ('reasoning_content' in target)
+            delete target.reasoning_content;
+        if ('reasoning' in target)
+            delete target.reasoning;
+    }
     /**
      * 处理done事件
      */

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

@@ -0,0 +1,13 @@
+import { GeminiResponse, SseToGeminiJsonOptions, DEFAULT_GEMINI_CONVERSION_CONFIG } from '../types/index.js';
+export declare class GeminiSseToJsonConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_GEMINI_CONVERSION_CONFIG>);
+    convertSseToJson(sseStream: AsyncIterable<string | Buffer>, options: SseToGeminiJsonOptions): Promise<GeminiResponse>;
+    private processChunkEvent;
+    private buildResponse;
+    private normalizeStream;
+    private createContext;
+    private wrapError;
+    private normalizeReasoningPart;
+}