@jsonstudio/llms 0.4.4 → 0.4.6

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

@@ -0,0 +1,99 @@
+import { PassThrough } from 'node:stream';
+import { DEFAULT_GEMINI_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { createGeminiSequencer } from './sequencers/gemini-sequencer.js';
+import { createGeminiStreamWriter } from '../shared/writer.js';
+export class GeminiJsonToSseConverter {
+    config = DEFAULT_GEMINI_CONVERSION_CONFIG;
+    contexts = new Map();
+    constructor(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    async convertResponseToJsonToSse(response, options) {
+        const context = this.createContext(response, options);
+        this.contexts.set(options.requestId, context);
+        const stream = new PassThrough({ objectMode: true });
+        const writer = createGeminiStreamWriter(stream, {
+            onEvent: () => this.updateStats(context, 'chunk'),
+            onError: (error) => this.handleStreamError(context, error, stream)
+        });
+        this.processResponse(response, context, writer, stream).catch((error) => {
+            this.handleStreamError(context, error, stream);
+        });
+        return Object.assign(stream, {
+            protocol: 'gemini-chat',
+            direction: 'json_to_sse',
+            requestId: options.requestId,
+            getStats: () => context.eventStats,
+            complete: () => writer.complete(),
+            abort: (error) => writer.abort(error)
+        });
+    }
+    createContext(response, options) {
+        const stats = {
+            totalEvents: 0,
+            chunkEvents: 0,
+            doneEvents: 0,
+            errors: 0,
+            startTime: Date.now()
+        };
+        return {
+            requestId: options.requestId,
+            model: options.model,
+            response,
+            options,
+            startTime: Date.now(),
+            eventStats: stats
+        };
+    }
+    async processResponse(response, context, writer, stream) {
+        try {
+            this.validateResponse(response);
+            const sequencer = createGeminiSequencer({
+                chunkDelayMs: context.options.chunkDelayMs ?? this.config.chunkDelayMs,
+                reasoningMode: context.options.reasoningMode ?? this.config.reasoningMode,
+                reasoningTextPrefix: context.options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+            });
+            const events = sequencer.sequenceResponse(response);
+            await writer.writeGeminiEvents(events);
+            this.updateStats(context, 'done');
+            writer.complete();
+        }
+        catch (error) {
+            writer.abort(error);
+            throw this.wrapError('GEMINI_JSON_TO_SSE_FAILED', error, context.requestId);
+        }
+        finally {
+            this.contexts.delete(context.requestId);
+            stream.end();
+        }
+    }
+    validateResponse(response) {
+        if (!response || typeof response !== 'object') {
+            throw new Error('Invalid Gemini response payload');
+        }
+    }
+    updateStats(context, kind) {
+        context.eventStats.totalEvents += 1;
+        if (kind === 'chunk') {
+            context.eventStats.chunkEvents += 1;
+        }
+        else {
+            context.eventStats.doneEvents += 1;
+        }
+    }
+    handleStreamError(context, error, stream) {
+        context.eventStats.errors += 1;
+        try {
+            stream.destroy(error);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    wrapError(code, error, requestId) {
+        return ErrorUtils.createError(error.message, code, { requestId });
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * JSON→SSE转换模块导出
+ */
+export { ChatJsonToSseConverter } from './chat-json-to-sse-converter.js';
+export { ResponsesJsonToSseConverter } from './responses-json-to-sse-converter.js';
+export { GeminiJsonToSseConverter } from './gemini-json-to-sse-converter.js';
+export type { ChatJsonToSseOptions, ChatJsonToSseContext, ChatEventStats, ResponsesJsonToSseOptions, ResponsesJsonToSseContext, ResponsesEventStats, GeminiJsonToSseOptions, GeminiJsonToSseContext, GeminiEventStats } from '../types/index.js';

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

@@ -5,3 +5,5 @@
 export { ChatJsonToSseConverter } from './chat-json-to-sse-converter.js';
 // Responses协议转换器（重构版本）
 export { ResponsesJsonToSseConverter } from './responses-json-to-sse-converter.js';
+// Gemini协议转换器
+export { GeminiJsonToSseConverter } from './gemini-json-to-sse-converter.js';

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

@@ -0,0 +1,13 @@
+import { AnthropicMessageResponse, AnthropicSseEvent } from '../../types/index.js';
+import type { ChatReasoningMode } from '../../types/chat-types.js';
+export interface AnthropicSequencerConfig {
+    chunkSize: number;
+    chunkDelayMs: number;
+    enableDelay: boolean;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export declare const DEFAULT_ANTHROPIC_SEQUENCER_CONFIG: AnthropicSequencerConfig;
+export declare function createAnthropicSequencer(config?: Partial<AnthropicSequencerConfig>): {
+    sequenceResponse(response: AnthropicMessageResponse, requestId: string): AsyncGenerator<AnthropicSseEvent>;
+};

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

@@ -0,0 +1,150 @@
+import { dispatchReasoning } from '../../shared/reasoning-dispatcher.js';
+export const DEFAULT_ANTHROPIC_SEQUENCER_CONFIG = {
+    chunkSize: 1024,
+    chunkDelayMs: 0,
+    enableDelay: false,
+    reasoningMode: 'channel',
+    reasoningTextPrefix: undefined
+};
+function createEvent(type, data) {
+    return {
+        type,
+        event: type,
+        timestamp: Date.now(),
+        protocol: 'anthropic-messages',
+        direction: 'json_to_sse',
+        data: { type, ...data }
+    };
+}
+async function maybeDelay(config) {
+    if (!config.enableDelay || !config.chunkDelayMs)
+        return;
+    await new Promise(resolve => setTimeout(resolve, config.chunkDelayMs));
+}
+function chunkText(input, size) {
+    if (!input || size <= 0)
+        return [input];
+    const chunks = [];
+    for (let i = 0; i < input.length; i += size) {
+        chunks.push(input.slice(i, i + size));
+    }
+    return chunks.length ? chunks : [''];
+}
+function normalizeToolInput(input) {
+    if (typeof input === 'string') {
+        return input;
+    }
+    try {
+        return JSON.stringify(input ?? {});
+    }
+    catch {
+        return String(input ?? '');
+    }
+}
+export function createAnthropicSequencer(config) {
+    const finalConfig = {
+        ...DEFAULT_ANTHROPIC_SEQUENCER_CONFIG,
+        ...config
+    };
+    return {
+        async *sequenceResponse(response, requestId) {
+            yield createEvent('message_start', {
+                message: {
+                    id: response.id || `msg_${requestId}`,
+                    type: 'message',
+                    role: response.role || 'assistant',
+                    model: response.model
+                }
+            });
+            let index = 0;
+            for (const block of response.content || []) {
+                if (!block || typeof block !== 'object')
+                    continue;
+                if (block.type === 'text') {
+                    yield createEvent('content_block_start', { index, content_block: { type: 'text' } });
+                    for (const chunk of chunkText(block.text ?? '', finalConfig.chunkSize)) {
+                        if (!chunk)
+                            continue;
+                        yield createEvent('content_block_delta', {
+                            index,
+                            delta: { type: 'text_delta', text: chunk }
+                        });
+                        await maybeDelay(finalConfig);
+                    }
+                    yield createEvent('content_block_stop', { index });
+                    index += 1;
+                }
+                else if (block.type === 'thinking') {
+                    const decision = dispatchReasoning(block.text, {
+                        mode: finalConfig.reasoningMode,
+                        prefix: finalConfig.reasoningTextPrefix
+                    });
+                    if (decision.appendToContent) {
+                        yield createEvent('content_block_start', { index, content_block: { type: 'text' } });
+                        for (const chunk of chunkText(decision.appendToContent, finalConfig.chunkSize)) {
+                            if (!chunk)
+                                continue;
+                            yield createEvent('content_block_delta', {
+                                index,
+                                delta: { type: 'text_delta', text: chunk }
+                            });
+                            await maybeDelay(finalConfig);
+                        }
+                        yield createEvent('content_block_stop', { index });
+                        index += 1;
+                    }
+                    if (decision.channel) {
+                        yield createEvent('content_block_start', { index, content_block: { type: 'thinking' } });
+                        for (const chunk of chunkText(decision.channel, finalConfig.chunkSize)) {
+                            if (!chunk)
+                                continue;
+                            yield createEvent('content_block_delta', {
+                                index,
+                                delta: { type: 'thinking_delta', text: chunk }
+                            });
+                            await maybeDelay(finalConfig);
+                        }
+                        yield createEvent('content_block_stop', { index });
+                        index += 1;
+                    }
+                }
+                else if (block.type === 'tool_use') {
+                    const id = block.id || `call_${requestId}_${index}`;
+                    yield createEvent('content_block_start', {
+                        index,
+                        content_block: { type: 'tool_use', id, name: block.name, input: block.input }
+                    });
+                    const payload = normalizeToolInput(block.input ?? {});
+                    if (payload) {
+                        yield createEvent('content_block_delta', {
+                            index,
+                            delta: { type: 'input_json_delta', partial_json: payload }
+                        });
+                    }
+                    yield createEvent('content_block_stop', { index });
+                    index += 1;
+                }
+                else if (block.type === 'tool_result') {
+                    yield createEvent('content_block_start', {
+                        index,
+                        content_block: {
+                            type: 'tool_result',
+                            tool_use_id: block.tool_use_id,
+                            content: block.content,
+                            is_error: block.is_error
+                        }
+                    });
+                    yield createEvent('content_block_stop', { index });
+                    index += 1;
+                }
+            }
+            yield createEvent('message_delta', {
+                delta: {
+                    stop_reason: response.stop_reason ?? 'end_turn',
+                    usage: response.usage
+                }
+            });
+            yield createEvent('message_stop', {});
+        }
+    };
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Chat协议事件编排器
+ * 负责严格的事件时序组合：role → content OR tool_calls(name → args.delta*) → finish_reason → done
+ */
+import { ChatCompletionResponse, ChatReasoningMode, ChatSseEvent } from '../../types/index.js';
+import { ChatEventGeneratorContext, ChatEventGeneratorConfig } from '../event-generators/chat.js';
+export interface ChatSequencerConfig extends ChatEventGeneratorConfig {
+    includeSequenceNumbers: boolean;
+    enableDelay: boolean;
+    validateOrder: boolean;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export declare const DEFAULT_CHAT_SEQUENCER_CONFIG: ChatSequencerConfig;
+/**
+ * 主编排器：将Chat响应转换为有序的SSE事件流
+ */
+export declare function sequenceChatResponse(response: ChatCompletionResponse, context: ChatEventGeneratorContext, config?: ChatSequencerConfig): AsyncGenerator<ChatSseEvent>;
+/**
+ * 序列化Chat请求（用于请求→SSE转换）
+ */
+export declare function sequenceChatRequest(request: any, context: ChatEventGeneratorContext, config?: ChatSequencerConfig): AsyncGenerator<ChatSseEvent>;
+/**
+ * 创建Chat事件序列化器工厂
+ */
+export declare function createChatSequencer(config?: Partial<ChatSequencerConfig>): {
+    /**
+     * 序列化响应
+     */
+    sequenceResponse(response: ChatCompletionResponse, model: string, requestId: string): AsyncGenerator<ChatSseEvent, void, any>;
+    /**
+     * 序列化请求
+     */
+    sequenceRequest(request: any, model: string, requestId: string): AsyncGenerator<ChatSseEvent, void, any>;
+    /**
+     * 获取当前配置
+     */
+    getConfig(): ChatSequencerConfig;
+};

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

@@ -0,0 +1,32 @@
+import type { ResponsesFunctionCallOutputItem } from '../types/index.js';
+export type SseProtocol = 'openai-chat' | 'openai-responses' | 'anthropic-messages' | 'gemini-chat';
+export type SseStreamLike = any;
+export type SseStreamInput = any;
+export interface JsonToSseContext {
+    requestId: string;
+    model?: string;
+    direction?: 'request' | 'response';
+    resumeToolOutputs?: ResponsesFunctionCallOutputItem[];
+}
+export interface SseToJsonContext {
+    requestId: string;
+    model?: string;
+    direction?: 'request' | 'response';
+}
+export interface NormalizeSseContext {
+    requestId: string;
+    protocol: SseProtocol;
+}
+export interface SseCodec {
+    protocol: SseProtocol;
+    convertJsonToSse(payload: unknown, context: JsonToSseContext): Promise<SseStreamLike>;
+    convertSseToJson(stream: SseStreamInput, context: SseToJsonContext): Promise<unknown>;
+    normalize?(stream: SseStreamInput, context: NormalizeSseContext): Promise<SseStreamInput>;
+}
+export declare class SseCodecRegistry {
+    private readonly codecs;
+    register(codec: SseCodec): void;
+    get(protocol: SseProtocol): SseCodec;
+    list(): SseCodec[];
+}
+export declare const defaultSseCodecRegistry: SseCodecRegistry;

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());