@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/sse/json-to-sse/sequencers/chat-sequencer.js

@@ -3,12 +3,16 @@
  * 负责严格的事件时序组合：role → content OR tool_calls(name → args.delta*) → finish_reason → done
  */
 import { buildRoleDelta, buildReasoningDeltas, buildContentDeltas, buildToolCallStart, buildToolCallArgsDeltas, buildFinishEvent, buildDoneEvent, buildErrorEvent, DEFAULT_CHAT_EVENT_GENERATOR_CONFIG, createDefaultContext } from '../event-generators/chat.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';
 // 默认配置
 export const DEFAULT_CHAT_SEQUENCER_CONFIG = {
     ...DEFAULT_CHAT_EVENT_GENERATOR_CONFIG,
     includeSequenceNumbers: true,
     enableDelay: false,
-    validateOrder: true
+    validateOrder: true,
+    reasoningMode: 'channel'
 };
 /**
  * 验证消息顺序的合法性
@@ -40,6 +44,26 @@ function hasMeaningfulContent(content) {
         return Object.keys(content).length > 0;
     return false;
 }
+function appendReasoningToContent(message, reasoningText, prefix) {
+    const trimmed = reasoningText.trim();
+    if (!trimmed) {
+        return;
+    }
+    const normalizedPrefix = typeof prefix === 'string' && prefix.length ? prefix : '';
+    const formatted = normalizedPrefix ? `${normalizedPrefix}${normalizedPrefix.endsWith(' ') || normalizedPrefix.endsWith('\n') ? '' : ' '}${trimmed}` : trimmed;
+    const current = message.content;
+    if (typeof current === 'string' || current == null) {
+        message.content = typeof current === 'string' && current.length
+            ? `${current}${current.endsWith('\n') ? '' : '\n\n'}${formatted}`
+            : formatted;
+        return;
+    }
+    if (Array.isArray(current)) {
+        current.push({ type: 'text', text: formatted });
+        return;
+    }
+    message.content = [current, { type: 'text', text: formatted }];
+}
 /**
  * 异步生成器：为事件添加序列号和延迟
  */
@@ -62,9 +86,31 @@ async function* sequenceMessageContent(message, context, config) {
     for (const roleEvent of buildRoleDelta(message.role, context, config)) {
         yield roleEvent;
     }
+    const contentNormalization = normalizeChatMessageContent(message.content);
+    if (contentNormalization.contentText !== undefined) {
+        message.content = contentNormalization.contentText;
+    }
+    const normalization = normalizeMessageReasoningTools(message, {
+        idPrefix: `chat_seq_reasoning_${context.choiceIndex + 1}`
+    });
+    const reasoningText = normalization.cleanedReasoning
+        ?? contentNormalization.reasoningText
+        ?? (typeof message?.reasoning_content === 'string'
+            ? message.reasoning_content
+            : typeof message?.reasoning === 'string'
+                ? message.reasoning
+                : undefined);
+    const reasoningDispatch = dispatchReasoning(reasoningText, {
+        mode: config.reasoningMode,
+        prefix: config.reasoningTextPrefix
+    });
+    if (reasoningDispatch.appendToContent) {
+        appendReasoningToContent(message, reasoningDispatch.appendToContent);
+    }
+    const reasoningForChannel = reasoningDispatch.channel;
     // 2. 处理reasoning（如果有）
-    if (message.reasoning) {
-        yield* withSequencing(buildReasoningDeltas(message.reasoning, context, config), config);
+    if (reasoningForChannel) {
+        yield* withSequencing(buildReasoningDeltas(reasoningForChannel, context, config), config);
     }
     // 3. 处理content和tool_calls
     if (hasMeaningfulContent(message.content)) {

package/dist/sse/json-to-sse/sequencers/gemini-sequencer.d.ts

@@ -0,0 +1,10 @@
+import { GeminiResponse, GeminiSseEvent } from '../../types/index.js';
+import type { ChatReasoningMode } from '../../types/chat-types.js';
+export interface GeminiSequencerConfig {
+    chunkDelayMs: number;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export declare function createGeminiSequencer(config?: Partial<GeminiSequencerConfig>): {
+    sequenceResponse(response: GeminiResponse): AsyncGenerator<GeminiSseEvent>;
+};

package/dist/sse/json-to-sse/sequencers/gemini-sequencer.js

@@ -0,0 +1,95 @@
+import { dispatchReasoning } from '../../shared/reasoning-dispatcher.js';
+const DEFAULT_CONFIG = {
+    chunkDelayMs: 0,
+    reasoningMode: 'channel',
+    reasoningTextPrefix: undefined
+};
+function createEvent(type, data) {
+    return {
+        type,
+        event: type,
+        protocol: 'gemini-chat',
+        direction: 'json_to_sse',
+        timestamp: Date.now(),
+        data,
+        sequenceNumber: 0
+    };
+}
+async function maybeDelay(config) {
+    if (!config.chunkDelayMs)
+        return;
+    await new Promise((resolve) => setTimeout(resolve, config.chunkDelayMs));
+}
+function getCandidateRole(candidate, fallback = 'model') {
+    const role = candidate?.content?.role;
+    if (typeof role === 'string' && role.trim().length) {
+        return role;
+    }
+    return fallback;
+}
+function getCandidateParts(candidate) {
+    const parts = candidate?.content?.parts;
+    if (Array.isArray(parts)) {
+        return parts.filter((part) => Boolean(part));
+    }
+    return [];
+}
+export function createGeminiSequencer(config) {
+    const finalConfig = { ...DEFAULT_CONFIG, ...config };
+    return {
+        async *sequenceResponse(response) {
+            const candidates = Array.isArray(response.candidates) ? response.candidates : [];
+            for (let candidateIndex = 0; candidateIndex < candidates.length; candidateIndex += 1) {
+                const candidate = candidates[candidateIndex] || {};
+                const role = getCandidateRole(candidate);
+                const parts = getCandidateParts(candidate);
+                for (let partIndex = 0; partIndex < parts.length; partIndex += 1) {
+                    const normalizedParts = normalizeReasoningPart(parts[partIndex], finalConfig);
+                    for (const normalizedPart of normalizedParts) {
+                        yield createEvent('gemini.data', {
+                            kind: 'part',
+                            candidateIndex,
+                            partIndex,
+                            role,
+                            part: normalizedPart
+                        });
+                        await maybeDelay(finalConfig);
+                    }
+                }
+            }
+            const doneData = {
+                kind: 'done',
+                usageMetadata: response.usageMetadata,
+                promptFeedback: response.promptFeedback,
+                modelVersion: response.modelVersion,
+                candidates: candidates.map((candidate, index) => ({
+                    index,
+                    finishReason: candidate?.finishReason,
+                    safetyRatings: candidate?.safetyRatings
+                }))
+            };
+            yield createEvent('gemini.done', doneData);
+        }
+    };
+}
+function normalizeReasoningPart(part, config) {
+    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: config.reasoningMode,
+        prefix: 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/json-to-sse/sequencers/responses-sequencer.js

@@ -3,6 +3,7 @@
  * 负责将Responses响应数据转换为有序的SSE事件流
  */
 import { buildResponseStartEvents, buildResponseDoneEvent, buildOutputItemStartEvent, buildOutputItemDoneEvent, buildContentPartStartEvent, buildContentPartDeltas, buildContentPartDoneEvent, buildOutputTextDoneEvent, buildFunctionCallArgsDeltas, buildFunctionCallDoneEvent, buildReasoningStartEvent, buildReasoningDeltas, buildReasoningDoneEvent, buildRequiredActionEvent, buildResponseCompletedEvent, buildErrorEvent, DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG, createDefaultResponsesContext } from '../event-generators/responses.js';
+import { expandResponsesMessageItem } from '../../shared/responses-output-normalizer.js';
 // 默认配置
 export const DEFAULT_RESPONSES_SEQUENCER_CONFIG = {
     ...DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG,
@@ -13,6 +14,23 @@ export const DEFAULT_RESPONSES_SEQUENCER_CONFIG = {
     maxContentParts: 100,
     submittedToolOutputs: undefined
 };
+function normalizeResponseOutput(output, requestId) {
+    if (!Array.isArray(output))
+        return [];
+    const normalized = [];
+    output.forEach((item, index) => {
+        if (item && typeof item === 'object' && item.type === 'message') {
+            normalized.push(...expandResponsesMessageItem(item, {
+                requestId,
+                outputIndex: index
+            }));
+        }
+        else {
+            normalized.push(item);
+        }
+    });
+    return normalized;
+}
 /**
  * 验证响应格式
  */
@@ -158,14 +176,15 @@ export async function* sequenceResponse(response, context, config = DEFAULT_RESP
             context.outputIndexCounter = i;
             yield* sequenceFunctionCallOutputItem(submittedOutputs[i], context, config);
         }
+        const normalizedOutput = normalizeResponseOutput(response.output, context.requestId);
         const outputOffset = submittedOutputs.length;
         // 3. 序列化所有输出项
-        for (let outputIndex = 0; outputIndex < response.output.length; outputIndex++) {
-            const item = response.output[outputIndex];
+        for (let outputIndex = 0; outputIndex < normalizedOutput.length; outputIndex++) {
+            const item = normalizedOutput[outputIndex];
             context.outputIndexCounter = outputOffset + outputIndex;
             yield* sequenceOutputItem(item, context, config);
             // 输出项间添加小延迟（如果启用）
-            if (config.enableDelay && config.chunkDelayMs > 0 && outputIndex < response.output.length - 1) {
+            if (config.enableDelay && config.chunkDelayMs > 0 && outputIndex < normalizedOutput.length - 1) {
                 await new Promise(resolve => setTimeout(resolve, config.chunkDelayMs * 2));
             }
         }
@@ -203,9 +222,9 @@ export async function* sequenceRequest(request, context, config = DEFAULT_RESPON
         }, context, config);
         // 回显输入消息作为输出项
         if (request.input && Array.isArray(request.input)) {
+            let syntheticIndex = 0;
             for (let inputIndex = 0; inputIndex < request.input.length; inputIndex++) {
                 const inputItem = request.input[inputIndex];
-                context.outputIndexCounter = inputIndex;
                 // 将输入转换为输出项格式
                 const outputItem = {
                     id: `${context.requestId}-input-${inputIndex}`,
@@ -214,7 +233,14 @@ export async function* sequenceRequest(request, context, config = DEFAULT_RESPON
                     role: inputItem.role,
                     content: inputItem.content
                 };
-                yield* sequenceMessageItem(outputItem, context, config);
+                const expandedItems = expandResponsesMessageItem(outputItem, {
+                    requestId: context.requestId,
+                    outputIndex: syntheticIndex
+                });
+                for (const expanded of expandedItems) {
+                    context.outputIndexCounter = syntheticIndex++;
+                    yield* sequenceOutputItem(expanded, context, config);
+                }
             }
         }
         const syntheticResponse = {

package/dist/sse/registry/sse-codec-registry.d.ts

@@ -1,5 +1,5 @@
 import type { ResponsesFunctionCallOutputItem } from '../types/index.js';
-export type SseProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages';
+export type SseProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
 export type SseStreamLike = any;
 export type SseStreamInput = any;
 export interface JsonToSseContext {

package/dist/sse/registry/sse-codec-registry.js

@@ -1,4 +1,4 @@
-import { chatConverters, responsesConverters, anthropicConverters } from '../index.js';
+import { chatConverters, responsesConverters, anthropicConverters, geminiConverters } from '../index.js';
 export class SseCodecRegistry {
     codecs = new Map();
     register(codec) {
@@ -27,11 +27,17 @@ function resolveModelId(payload, fallback) {
     if (typeof record.model === 'string') {
         return record.model;
     }
+    if (record.modelVersion && typeof record.modelVersion === 'string') {
+        return record.modelVersion;
+    }
     if (record.response && typeof record.response === 'object') {
         const inner = record.response;
         if (typeof inner.model === 'string') {
             return inner.model;
         }
+        if (typeof inner.modelVersion === 'string') {
+            return inner.modelVersion;
+        }
     }
     return 'unknown';
 }
@@ -101,6 +107,29 @@ function createAnthropicCodec() {
         }
     };
 }
+function createGeminiCodec() {
+    return {
+        protocol: 'gemini-chat',
+        async convertJsonToSse(payload, context) {
+            const model = resolveModelId(payload, context.model);
+            return geminiConverters.jsonToSse
+                .convertResponseToJsonToSse(payload, {
+                requestId: context.requestId,
+                model
+            });
+        },
+        async convertSseToJson(stream, context) {
+            return geminiConverters.sseToJson.convertSseToJson(stream, {
+                requestId: context.requestId,
+                model: context.model
+            });
+        },
+        async normalize(stream) {
+            return stream;
+        }
+    };
+}
 defaultSseCodecRegistry.register(createChatCodec());
 defaultSseCodecRegistry.register(createResponsesCodec());
 defaultSseCodecRegistry.register(createAnthropicCodec());
+defaultSseCodecRegistry.register(createGeminiCodec());

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

@@ -9,6 +9,8 @@ export type { SerializationOptions, ChatSerializationOptions, ResponsesSerializa
 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';
 /**
  * 创建序列化器工厂
  */

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

@@ -4,7 +4,7 @@
  */
 import { PassThrough } from 'stream';
 import { BaseSseEvent } from '../types/core-interfaces.js';
-import { ChatSseEvent, ResponsesSseEvent } from '../types/index.js';
+import { ChatSseEvent, ResponsesSseEvent, AnthropicSseEvent, GeminiSseEvent } from '../types/index.js';
 export interface StreamWriterConfig {
     timeoutMs?: number;
     enableHeartbeat?: boolean;
@@ -76,6 +76,14 @@ export declare class StreamWriter {
      * 写入Responses事件流
      */
     writeResponsesEvents(events: AsyncIterable<ResponsesSseEvent> | ResponsesSseEvent[]): Promise<void>;
+    /**
+     * 写入Anthropic事件流
+     */
+    writeAnthropicEvents(events: AsyncIterable<AnthropicSseEvent> | AnthropicSseEvent[]): Promise<void>;
+    /**
+     * 写入Gemini事件流
+     */
+    writeGeminiEvents(events: AsyncIterable<GeminiSseEvent> | GeminiSseEvent[]): Promise<void>;
     /**
      * 完成流写入
      */
@@ -109,3 +117,11 @@ export declare function createChatStreamWriter(stream: PassThrough, config?: Str
  * 创建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

@@ -1,13 +1,11 @@
-import type { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/anthropic-types.js';
-/**
- * Minimal Anthropic SSE → JSON converter (v3)
- *
- * Aggregates a subset of Anthropic events into a single message object:
- * - message_start → capture id/model
- * - content_block_start/delta/stop → build text/tool_use blocks
- * - message_delta → stop_reason hint
- * - message_stop → finalize
- */
+import { AnthropicMessageResponse, SseToAnthropicJsonOptions } from '../types/index.js';
 export declare class AnthropicSseToJsonConverter {
-    convertSseToJson(sseStream: AsyncIterable<string | Buffer>, _options: SseToAnthropicJsonOptions): Promise<AnthropicMessageResponse>;
+    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;
 }