@jsonstudio/llms 0.4.3 → 0.4.5

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转换器
  */
@@ -201,7 +204,8 @@ export class ChatSseToJsonConverter {
      */
     async processChatChunk(event, context) {
         try {
-            const chunk = JSON.parse(event.data);
+            const payload = typeof event.data === 'string' ? event.data : JSON.stringify(event.data ?? {});
+            const chunk = JSON.parse(payload);
             // 验证chunk格式
             if (context.options.validateChunks) {
                 this.validateChatChunk(chunk);
@@ -237,8 +241,11 @@ export class ChatSseToJsonConverter {
             context.choiceIndexMap.set(choiceIndex, choiceBuilder);
             context.currentResponse.choices?.push({
                 index: choiceIndex,
-                message: {},
-                finish_reason: null,
+                message: {
+                    role: 'assistant',
+                    content: ''
+                },
+                finish_reason: 'stop',
                 logprobs: choice.logprobs
             });
         }
@@ -261,11 +268,12 @@ export class ChatSseToJsonConverter {
         return {
             index,
             delta: {},
-            finishReason: null,
-            logprobs: null,
+            finishReason: undefined,
+            logprobs: undefined,
             messageBuilder: {
                 role: undefined,
                 content: '',
+                reasoningContent: '',
                 name: undefined,
                 functionCall: undefined,
                 toolCalls: [],
@@ -277,10 +285,23 @@ 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
      */
-    async processDelta(delta, choiceBuilder, context) {
+    async processDelta(delta, choiceBuilder, _context) {
         const messageBuilder = choiceBuilder.messageBuilder;
         // 处理role
         if (delta.role) {
@@ -288,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) {
@@ -314,7 +336,7 @@ export class ChatSseToJsonConverter {
         // 处理tool_calls
         if (delta.tool_calls && Array.isArray(delta.tool_calls)) {
             for (const toolCallDelta of delta.tool_calls) {
-                await this.processToolCallDelta(toolCallDelta, choiceBuilder, context);
+                await this.processToolCallDelta(toolCallDelta, choiceBuilder);
             }
         }
         // 合并delta到choiceBuilder
@@ -323,7 +345,7 @@ export class ChatSseToJsonConverter {
     /**
      * 处理tool_call delta
      */
-    async processToolCallDelta(toolCallDelta, choiceBuilder, context) {
+    async processToolCallDelta(toolCallDelta, choiceBuilder) {
         const toolCallIndex = toolCallDelta.index;
         // 获取或创建tool_call构建器
         let toolCallBuilder = choiceBuilder.toolCallBuilders.get(toolCallIndex);
@@ -367,37 +389,99 @@ export class ChatSseToJsonConverter {
      */
     updateResponseChoice(choiceIndex, choiceBuilder, context) {
         const responseChoice = context.currentResponse.choices?.[choiceIndex];
-        if (!responseChoice)
+        if (!responseChoice) {
             return;
+        }
         const messageBuilder = choiceBuilder.messageBuilder;
         // 构建message
         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;
         }
         // 构建tool_calls
         const toolCalls = [];
-        for (const [_, toolCallBuilder] of choiceBuilder.toolCallBuilders) {
-            if (toolCallBuilder.id) {
+        for (const toolCallBuilder of choiceBuilder.toolCallBuilders.values()) {
+            if (toolCallBuilder.id && toolCallBuilder.function) {
                 toolCalls.push({
                     id: toolCallBuilder.id,
                     type: toolCallBuilder.type || 'function',
-                    function: toolCallBuilder.function
+                    function: {
+                        name: toolCallBuilder.function.name ?? '',
+                        arguments: toolCallBuilder.function.arguments ?? ''
+                    }
                 });
             }
         }
         if (toolCalls.length > 0) {
             message.tool_calls = toolCalls;
         }
+        this.normalizeReasoning(choiceBuilder, message, context);
         responseChoice.message = message;
-        responseChoice.finish_reason = choiceBuilder.finishReason;
+        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事件
      */
@@ -405,9 +489,11 @@ export class ChatSseToJsonConverter {
         context.isCompleted = true;
         // 解析done事件数据（如果有的话）
         try {
-            const doneData = JSON.parse(event.data);
-            if (doneData.totalTokens) {
-                context.eventStats.totalTokens = doneData.totalTokens;
+            if (typeof event.data === 'string') {
+                const doneData = JSON.parse(event.data);
+                if (typeof doneData.totalTokens === 'number') {
+                    context.eventStats.totalTokens = doneData.totalTokens;
+                }
             }
         }
         catch (e) {
@@ -417,12 +503,15 @@ export class ChatSseToJsonConverter {
     /**
      * 处理error事件
      */
-    async processErrorEvent(event, context) {
+    async processErrorEvent(event, _context) {
         try {
-            const errorData = JSON.parse(event.data);
-            const error = new Error(errorData.error || 'Unknown SSE error');
-            error.code = errorData.code || 'SSE_ERROR';
-            throw ErrorUtils.createError(error.message, CHAT_CONVERSION_ERROR_CODES.STREAM_ERROR, { errorData, event });
+            const rawPayload = typeof event.data === 'string' ? event.data : JSON.stringify(event.data ?? {});
+            const errorData = JSON.parse(rawPayload);
+            const errorMessage = typeof errorData.error === 'string' ? errorData.error : 'Unknown SSE error';
+            const code = typeof errorData.code === 'string' ? errorData.code : 'SSE_ERROR';
+            const typedError = new Error(errorMessage);
+            typedError.code = code;
+            throw ErrorUtils.createError(typedError.message, CHAT_CONVERSION_ERROR_CODES.STREAM_ERROR, { errorData, event });
         }
         catch (parseError) {
             throw ErrorUtils.createError(`SSE error event: ${event.data}`, CHAT_CONVERSION_ERROR_CODES.STREAM_ERROR, { event });
@@ -433,8 +522,9 @@ export class ChatSseToJsonConverter {
      */
     buildPartialResponse(context) {
         const choices = context.currentResponse.choices || [];
-        if (choices.length === 0)
+        if (choices.length === 0) {
             return null;
+        }
         return {
             id: context.currentResponse.id || '',
             object: 'chat.completion',
@@ -475,7 +565,7 @@ export class ChatSseToJsonConverter {
     /**
      * 构建使用量信息
      */
-    buildUsageInfo(context) {
+    buildUsageInfo(_context) {
         // 这里可以基于token计数来计算usage
         // 暂时返回null，后续可以实现更精确的token计数
         return null;

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

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

@@ -0,0 +1,160 @@
+import { DEFAULT_GEMINI_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { dispatchReasoning } from '../shared/reasoning-dispatcher.js';
+import { createSseParser } from './parsers/sse-parser.js';
+export class GeminiSseToJsonConverter {
+    config = DEFAULT_GEMINI_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: true,
+            enableEventRecovery: true,
+            allowedEventTypes: new Set([
+                'gemini.data',
+                'gemini.done'
+            ])
+        });
+        const accumulator = new Map();
+        let donePayload = null;
+        try {
+            for await (const result of parser.parseStreamAsync(this.normalizeStream(sseStream))) {
+                if (!result.success || !result.event) {
+                    if (result.error) {
+                        throw new Error(result.error);
+                    }
+                    continue;
+                }
+                const event = result.event;
+                if (event.protocol !== 'gemini-chat')
+                    continue;
+                if (event.type === 'gemini.data') {
+                    this.processChunkEvent(event, accumulator, context);
+                    context.eventStats.chunkEvents += 1;
+                }
+                else if (event.type === 'gemini.done') {
+                    donePayload = event.data;
+                    context.eventStats.doneEvents += 1;
+                }
+                context.eventStats.totalEvents += 1;
+            }
+            if (!donePayload) {
+                throw new Error('Gemini SSE stream missing done event');
+            }
+            const response = this.buildResponse(accumulator, donePayload);
+            context.isCompleted = true;
+            context.eventStats.endTime = Date.now();
+            return response;
+        }
+        catch (error) {
+            context.eventStats.errors += 1;
+            throw this.wrapError('GEMINI_SSE_TO_JSON_FAILED', error, options.requestId);
+        }
+        finally {
+            this.contexts.delete(options.requestId);
+        }
+    }
+    processChunkEvent(event, accumulator, context) {
+        const payload = event.data;
+        const candidateIndex = typeof payload?.candidateIndex === 'number' ? payload.candidateIndex : 0;
+        const part = payload?.part;
+        if (!part)
+            return;
+        const role = typeof payload?.role === 'string' ? payload.role : 'model';
+        if (!accumulator.has(candidateIndex)) {
+            accumulator.set(candidateIndex, { role, parts: [] });
+        }
+        const normalizedParts = this.normalizeReasoningPart(part, context);
+        for (const normalizedPart of normalizedParts) {
+            accumulator.get(candidateIndex).parts.push(normalizedPart);
+        }
+    }
+    buildResponse(accumulator, donePayload) {
+        const candidates = [];
+        const candidateMeta = {};
+        if (Array.isArray(donePayload?.candidates)) {
+            for (const entry of donePayload.candidates) {
+                if (!entry || typeof entry.index !== 'number')
+                    continue;
+                candidateMeta[entry.index] = {
+                    finishReason: entry.finishReason,
+                    safetyRatings: entry.safetyRatings
+                };
+            }
+        }
+        const indices = Array.from(accumulator.keys()).sort((a, b) => a - b);
+        for (const index of indices) {
+            const acc = accumulator.get(index);
+            if (!acc)
+                continue;
+            candidates.push({
+                content: {
+                    role: acc.role,
+                    parts: acc.parts
+                },
+                finishReason: candidateMeta[index]?.finishReason,
+                safetyRatings: candidateMeta[index]?.safetyRatings
+            });
+        }
+        return {
+            candidates,
+            promptFeedback: donePayload?.promptFeedback,
+            usageMetadata: donePayload?.usageMetadata,
+            modelVersion: donePayload?.modelVersion
+        };
+    }
+    async *normalizeStream(stream) {
+        for await (const chunk of stream) {
+            yield typeof chunk === 'string' ? chunk : chunk.toString();
+        }
+    }
+    createContext(options) {
+        return {
+            requestId: options.requestId,
+            model: options.model,
+            options: {
+                reasoningMode: options.reasoningMode ?? this.config.reasoningMode,
+                reasoningTextPrefix: options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+            },
+            startTime: Date.now(),
+            eventStats: {
+                totalEvents: 0,
+                chunkEvents: 0,
+                doneEvents: 0,
+                errors: 0,
+                startTime: Date.now()
+            },
+            isCompleted: false
+        };
+    }
+    wrapError(code, error, requestId) {
+        return ErrorUtils.createError(error.message, code, { requestId });
+    }
+    normalizeReasoningPart(part, context) {
+        if (!part || typeof part !== 'object') {
+            return [part];
+        }
+        const reasoning = typeof part.reasoning === 'string' ? part.reasoning : undefined;
+        if (!reasoning) {
+            return [part];
+        }
+        const decision = dispatchReasoning(reasoning, {
+            mode: context.options.reasoningMode ?? this.config.reasoningMode,
+            prefix: context.options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+        });
+        const normalized = [];
+        if (decision.appendToContent) {
+            normalized.push({ text: decision.appendToContent });
+        }
+        if (decision.channel) {
+            normalized.push({ reasoning: decision.channel });
+        }
+        return normalized;
+    }
+}

package/dist/sse/sse-to-json/index.d.ts

@@ -3,4 +3,5 @@
  */
 export { ChatSseToJsonConverter, defaultChatSseToJsonConverter } from './chat-sse-to-json-converter.js';
 export { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from './responses-sse-to-json-converter.js';
-export type { SseToChatJsonOptions, SseToChatJsonContext, ChatEventStats, SseToResponsesJsonOptions, SseToResponsesJsonContext, ResponsesEventStats } from '../types/index.js';
+export { GeminiSseToJsonConverter } from './gemini-sse-to-json-converter.js';
+export type { SseToChatJsonOptions, SseToChatJsonContext, ChatEventStats, SseToResponsesJsonOptions, SseToResponsesJsonContext, ResponsesEventStats, SseToGeminiJsonOptions, SseToGeminiJsonContext, GeminiEventStats } from '../types/index.js';

package/dist/sse/sse-to-json/index.js

@@ -5,3 +5,5 @@
 export { ChatSseToJsonConverter, defaultChatSseToJsonConverter } from './chat-sse-to-json-converter.js';
 // Responses协议转换器（重构版本）
 export { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from './responses-sse-to-json-converter.js';
+// Gemini协议转换器
+export { GeminiSseToJsonConverter } from './gemini-sse-to-json-converter.js';

package/dist/sse/sse-to-json/parsers/sse-parser.js

@@ -50,7 +50,17 @@ export const DEFAULT_SSE_PARSER_CONFIG = {
         'reasoning.start',
         'reasoning.delta',
         'reasoning.done',
-        'required_action'
+        'required_action',
+        // Anthropic event types
+        'message_start',
+        'content_block_start',
+        'content_block_delta',
+        'content_block_stop',
+        'message_delta',
+        'message_stop',
+        // Gemini event types
+        'gemini.data',
+        'gemini.done'
     ])
 };
 /**
@@ -76,16 +86,18 @@ function parseSseLine(line) {
  * 将原始SSE行组装为事件
  */
 export function assembleSseEvent(lines) {
-    if (lines.length === 0)
+    if (lines.length === 0) {
         return null;
+    }
     const event = {
         event: 'message', // 默认事件类型
         data: ''
     };
     for (const line of lines) {
         const { field, value } = parseSseLine(line);
-        if (!field)
+        if (!field) {
             continue;
+        }
         switch (field) {
             case 'id':
                 event.id = value;
@@ -94,7 +106,7 @@ export function assembleSseEvent(lines) {
                 event.event = value;
                 break;
             case 'data':
-                event.data = event.data ? event.data + '\n' + value : value;
+                event.data = event.data ? `${event.data}\n${value}` : value;
                 break;
             case 'retry':
                 event.retry = value;
@@ -119,7 +131,8 @@ function safeJsonParse(data) {
         return JSON.parse(data);
     }
     catch (error) {
-        throw new Error(`Invalid JSON data: ${error.message}`);
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid JSON data: ${message}`);
     }
 }
 /**
@@ -134,19 +147,23 @@ function validateEventType(eventType, config) {
 /**
  * 创建基础事件对象
  */
-function createBaseEvent(rawEvent, config, rawData) {
+function createBaseEvent(rawEvent, config, _rawData) {
     const baseEvent = {
         type: rawEvent.event,
-        timestamp: rawEvent.timestamp || Date.now(),
+        timestamp: rawEvent.timestamp ?? Date.now(),
         data: null,
         sequenceNumber: typeof rawEvent.id === 'string' ? Number(rawEvent.id) : 0
     };
     // 解析数据字段
     try {
         if (rawEvent.data) {
-            baseEvent.data = safeJsonParse(rawEvent.data);
-            if (baseEvent.data && typeof baseEvent.data.sequence_number === 'number') {
-                baseEvent.sequenceNumber = baseEvent.data.sequence_number;
+            const parsedData = safeJsonParse(rawEvent.data);
+            baseEvent.data = parsedData;
+            if (parsedData &&
+                typeof parsedData === 'object' &&
+                'sequence_number' in parsedData &&
+                typeof parsedData.sequence_number === 'number') {
+                baseEvent.sequenceNumber = parsedData.sequence_number;
             }
         }
     }
@@ -156,7 +173,7 @@ function createBaseEvent(rawEvent, config, rawData) {
             baseEvent.type = 'error';
         }
         else {
-            throw error;
+            throw error instanceof Error ? error : new Error(String(error));
         }
     }
     return baseEvent;
@@ -188,15 +205,51 @@ function createResponsesEvent(baseEvent) {
         direction: 'sse_to_json'
     };
 }
+function createAnthropicEvent(baseEvent) {
+    return {
+        type: baseEvent.type,
+        timestamp: baseEvent.timestamp,
+        data: baseEvent.data,
+        sequenceNumber: baseEvent.sequenceNumber,
+        protocol: 'anthropic-messages',
+        direction: 'sse_to_json'
+    };
+}
+function createGeminiEvent(baseEvent) {
+    return {
+        type: baseEvent.type,
+        event: baseEvent.type,
+        timestamp: baseEvent.timestamp,
+        data: baseEvent.data,
+        sequenceNumber: baseEvent.sequenceNumber,
+        protocol: 'gemini-chat',
+        direction: 'sse_to_json'
+    };
+}
 /**
  * 检测事件协议类型
  */
 function detectEventType(eventType) {
     // Chat协议事件类型
     const chatEventTypes = new Set(['chunk', 'done', 'error', 'heartbeat']);
+    const anthropicEventTypes = new Set([
+        'message_start',
+        'content_block_start',
+        'content_block_delta',
+        'content_block_stop',
+        'message_delta',
+        'message_stop'
+    ]);
+    const geminiEventTypes = new Set(['gemini.data', 'gemini.done']);
     if (chatEventTypes.has(eventType)) {
         return 'chat';
     }
+    if (anthropicEventTypes.has(eventType)) {
+        return 'anthropic';
+    }
+    if (geminiEventTypes.has(eventType)) {
+        return 'gemini';
+    }
     // Responses协议事件类型（以点分隔或特定关键词）
     if (eventType.includes('.') ||
         eventType.startsWith('response') ||
@@ -243,13 +296,19 @@ export function parseSseEvent(sseText, config = DEFAULT_SSE_PARSER_CONFIG) {
         if (protocol === 'chat') {
             result.event = createChatEvent(baseEvent);
         }
+        else if (protocol === 'anthropic') {
+            result.event = createAnthropicEvent(baseEvent);
+        }
+        else if (protocol === 'gemini') {
+            result.event = createGeminiEvent(baseEvent);
+        }
         else {
             result.event = createResponsesEvent(baseEvent);
         }
         result.success = true;
     }
     catch (error) {
-        result.error = error.message;
+        result.error = error instanceof Error ? error.message : String(error);
     }
     return result;
 }
@@ -276,8 +335,9 @@ export async function* parseSseStreamAsync(asyncSseData, config = DEFAULT_SSE_PA
         // 查找完整的事件边界
         while (true) {
             const eventEnd = buffer.indexOf('\n\n');
-            if (eventEnd === -1)
+            if (eventEnd === -1) {
                 break;
+            }
             const eventData = buffer.substring(0, eventEnd);
             buffer = buffer.substring(eventEnd + 2);
             const result = parseSseEvent(eventData, config);

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

@@ -27,6 +27,7 @@ export declare class ResponsesSseToJsonConverterRefactored {
      * 将事件对象序列化为SSE格式（简单实现）
      */
     private serializeEventToSSE;
+    private chunkStrings;
     /**
      * 验证序列号
      */

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

@@ -48,14 +48,10 @@ export class ResponsesSseToJsonConverterRefactored {
             const readableStream = this.createReadableStream(sseStream);
             // 5. 流式处理SSE数据（按增量缓冲解析，避免跨 chunk 的事件被截断）
             // 注意：不要对每个 chunk 独立 parse；必须使用一个持续的 async 解析器维持缓冲区。
-            async function* chunkStrings(stream) {
-                for await (const chunk of stream) {
-                    yield typeof chunk === 'string' ? chunk : chunk.toString();
-                }
-            }
-            for await (const parseResult of parser.parseStreamAsync(chunkStrings(readableStream))) {
-                if (context.isCompleted)
+            for await (const parseResult of parser.parseStreamAsync(this.chunkStrings(readableStream))) {
+                if (context.isCompleted) {
                     break;
+                }
                 if (parseResult.success && parseResult.event) {
                     const event = parseResult.event;
                     // 验证序列号
@@ -150,8 +146,14 @@ export class ResponsesSseToJsonConverterRefactored {
      * 将事件对象序列化为SSE格式（简单实现）
      */
     serializeEventToSSE(event) {
+        const type = typeof event.type === 'string' ? event.type : 'data';
         const data = event.data ? JSON.stringify(event.data) : '';
-        return `event: ${event.type}\ndata: ${data}\n\n`;
+        return `event: ${type}\ndata: ${data}\n\n`;
+    }
+    async *chunkStrings(stream) {
+        for await (const chunk of stream) {
+            yield typeof chunk === 'string' ? chunk : chunk.toString();
+        }
     }
     /**
      * 验证序列号