@jsonstudio/llms 0.4.4 → 0.4.5

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

@@ -0,0 +1,7 @@
+/**
+ * SSE→JSON转换模块导出
+ */
+export { ChatSseToJsonConverter, defaultChatSseToJsonConverter } from './chat-sse-to-json-converter.js';
+export { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from './responses-sse-to-json-converter.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'
     ])
 };
 /**
@@ -195,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') ||
@@ -250,6 +296,12 @@ 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);
         }

package/dist/sse/types/anthropic-types.d.ts

@@ -0,0 +1,170 @@
+import type { BaseSseEvent, StreamDirection } from './core-interfaces.js';
+import type { ChatReasoningMode } from './chat-types.js';
+/**
+ * Anthropic JSON/SSE 类型定义与转换上下文
+ */
+export interface AnthropicContentTextBlock {
+    type: 'text';
+    text: string;
+}
+export interface AnthropicContentThinkingBlock {
+    type: 'thinking';
+    text: string;
+}
+export interface AnthropicContentToolUseBlock {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface AnthropicContentToolResultBlock {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: unknown;
+    is_error?: boolean;
+}
+export type AnthropicContentBlock = AnthropicContentTextBlock | AnthropicContentThinkingBlock | AnthropicContentToolUseBlock | AnthropicContentToolResultBlock;
+export interface AnthropicMessageResponse {
+    id: string;
+    type: 'message';
+    role: 'assistant' | 'user';
+    model: string;
+    content: AnthropicContentBlock[];
+    usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+    };
+    stop_reason?: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'tool_use';
+}
+export interface AnthropicEventStats {
+    totalEvents: number;
+    contentBlocks: number;
+    toolUseBlocks: number;
+    thinkingBlocks: number;
+    textBlocks: number;
+    errors: number;
+    startTime: number;
+    endTime?: number;
+}
+export interface AnthropicJsonToSseContext {
+    requestId: string;
+    model: string;
+    response: AnthropicMessageResponse;
+    options: AnthropicJsonToSseOptions;
+    startTime: number;
+    eventStats: AnthropicEventStats;
+}
+export interface SseToAnthropicJsonContext {
+    requestId: string;
+    model?: string;
+    startTime: number;
+    eventStats: AnthropicEventStats;
+    isCompleted: boolean;
+    startTimestamp?: number;
+    endTimestamp?: number;
+}
+export interface AnthropicJsonToSseOptions {
+    requestId: string;
+    model: string;
+    chunkSize?: number;
+    chunkDelayMs?: number;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface SseToAnthropicJsonOptions {
+    requestId: string;
+    model?: string;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export declare const DEFAULT_ANTHROPIC_CONVERSION_CONFIG: {
+    defaultChunkSize: number;
+    defaultDelayMs: number;
+    enableEventValidation: boolean;
+    strictMode: boolean;
+    reasoningMode: ChatReasoningMode;
+    reasoningTextPrefix: string | undefined;
+};
+export type AnthropicSseEventType = 'message_start' | 'content_block_start' | 'content_block_delta' | 'content_block_stop' | 'message_delta' | 'message_stop';
+export interface AnthropicSseEventBase<T extends AnthropicSseEventType = AnthropicSseEventType> extends BaseSseEvent {
+    type: T;
+    event?: T;
+    protocol: 'anthropic-messages';
+    direction: StreamDirection;
+    data: unknown;
+}
+export interface AnthropicSseEventMessageStart extends AnthropicSseEventBase<'message_start'> {
+    data: {
+        type: 'message_start';
+        message: {
+            id: string;
+            type: 'message';
+            role: 'assistant';
+            model: string;
+        };
+    };
+}
+export interface AnthropicSseEventContentBlockStart extends AnthropicSseEventBase<'content_block_start'> {
+    data: {
+        type: 'content_block_start';
+        index: number;
+        content_block: {
+            type: 'text';
+            text?: string;
+        } | {
+            type: 'thinking';
+            text?: string;
+        } | {
+            type: 'tool_use';
+            id: string;
+            name: string;
+            input?: Record<string, unknown>;
+        } | {
+            type: 'tool_result';
+            tool_use_id: string;
+            content?: unknown;
+            is_error?: boolean;
+        };
+    };
+}
+export interface AnthropicSseEventContentBlockDelta extends AnthropicSseEventBase<'content_block_delta'> {
+    data: {
+        type: 'content_block_delta';
+        index: number;
+        delta: {
+            type: 'text_delta';
+            text: string;
+        } | {
+            type: 'thinking_delta';
+            text: string;
+        } | {
+            type: 'input_json_delta';
+            partial_json: string;
+        } | {
+            type: 'output_json_delta';
+            partial_json: string;
+        };
+    };
+}
+export interface AnthropicSseEventContentBlockStop extends AnthropicSseEventBase<'content_block_stop'> {
+    data: {
+        type: 'content_block_stop';
+        index: number;
+    };
+}
+export interface AnthropicSseEventMessageDelta extends AnthropicSseEventBase<'message_delta'> {
+    data: {
+        type: 'message_delta';
+        delta?: {
+            stop_reason?: AnthropicMessageResponse['stop_reason'];
+            usage?: AnthropicMessageResponse['usage'];
+        };
+    };
+}
+export interface AnthropicSseEventMessageStop extends AnthropicSseEventBase<'message_stop'> {
+    data: {
+        type: 'message_stop';
+    };
+}
+export type AnthropicSseEvent = AnthropicSseEventMessageStart | AnthropicSseEventContentBlockStart | AnthropicSseEventContentBlockDelta | AnthropicSseEventContentBlockStop | AnthropicSseEventMessageDelta | AnthropicSseEventMessageStop;
+export type AnthropicSseEventStream = AsyncIterable<string> | AsyncIterable<Buffer>;

package/dist/sse/types/anthropic-types.js

@@ -1,5 +1,8 @@
-/**
- * Minimal Anthropic SSE/JSON types for v3 SSE converters
- * Only covers text and basic tool_use blocks needed for roundtrip.
- */
-export {};
+export const DEFAULT_ANTHROPIC_CONVERSION_CONFIG = {
+    defaultChunkSize: 1024,
+    defaultDelayMs: 0,
+    enableEventValidation: true,
+    strictMode: false,
+    reasoningMode: 'channel',
+    reasoningTextPrefix: undefined
+};

package/dist/sse/types/chat-types.d.ts

@@ -116,6 +116,8 @@ export interface ChatMessage {
     role: 'system' | 'user' | 'assistant' | 'tool';
     content?: string | null;
     name?: string;
+    reasoning_content?: string;
+    reasoning?: string;
     function_call?: ChatFunctionCall;
     tool_calls?: ChatToolCall[];
     tool_call_id?: string;
@@ -191,6 +193,7 @@ export interface ChatChoiceBuilder {
 export interface ChatMessageBuilder {
     role?: 'system' | 'user' | 'assistant' | 'tool';
     content?: string;
+    reasoningContent?: string;
     name?: string;
     functionCall?: ChatFunctionCall;
     toolCalls?: ChatToolCall[];
@@ -208,6 +211,7 @@ export interface ChatToolCallBuilder {
     isCompleted: boolean;
     accumulatedArguments: string;
 }
+export type ChatReasoningMode = 'channel' | 'text' | 'drop';
 export interface ChatJsonToSseOptions {
     requestId: string;
     model: string;
@@ -219,6 +223,8 @@ export interface ChatJsonToSseOptions {
     includeLogprobs?: boolean;
     maxTokensPerChunk?: number;
     validationMode?: 'none' | 'basic' | 'strict';
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
     onChunk?: (chunk: ChatCompletionChunk) => void;
     onError?: (error: Error) => void;
     onComplete?: () => void;
@@ -230,6 +236,8 @@ export interface SseToChatJsonOptions {
     validateChunks?: boolean;
     enableSequenceValidation?: boolean;
     accumulateToolCalls?: boolean;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
     onPartialResponse?: (partial: Partial<ChatCompletionResponse>) => void;
     onEvent?: (event: ChatSseEvent) => void;
     onChunk?: (chunk: ChatCompletionChunk) => void;
@@ -295,6 +303,8 @@ export interface ChatConversionConfig {
     debugMode: boolean;
     logLevel: 'debug' | 'info' | 'warn' | 'error';
     enableMetrics: boolean;
+    reasoningMode: ChatReasoningMode;
+    reasoningTextPrefix?: string;
 }
 export declare const DEFAULT_CHAT_CONVERSION_CONFIG: ChatConversionConfig;
 export interface ChatSseEventStream extends AsyncIterable<ChatSseEvent> {

package/dist/sse/types/chat-types.js

@@ -28,5 +28,6 @@ export const DEFAULT_CHAT_CONVERSION_CONFIG = {
     eventBufferSize: 1000,
     debugMode: false,
     logLevel: 'info',
-    enableMetrics: true
+    enableMetrics: true,
+    reasoningMode: 'channel'
 };

package/dist/sse/types/core-interfaces.d.ts

@@ -20,7 +20,7 @@ export interface BaseSseEvent {
     /** 方向标识 */
     direction?: StreamDirection;
 }
-export type StreamProtocol = 'chat' | 'responses';
+export type StreamProtocol = 'chat' | 'responses' | 'anthropic-messages' | 'gemini-chat';
 export type StreamDirection = 'json_to_sse' | 'sse_to_json';
 export type SseProtocol = StreamProtocol;
 export type SseDirection = StreamDirection;

package/dist/sse/types/gemini-types.d.ts

@@ -0,0 +1,116 @@
+import type { BaseSseEvent, StreamDirection } from './core-interfaces.js';
+import type { ChatReasoningMode } from './chat-types.js';
+export interface GeminiContentTextPart {
+    text: string;
+}
+export interface GeminiContentFunctionCallPart {
+    functionCall: {
+        name: string;
+        args?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+}
+export interface GeminiContentFunctionResponsePart {
+    functionResponse: {
+        name?: string;
+        response?: unknown;
+        [key: string]: unknown;
+    };
+}
+export interface GeminiContentInlineDataPart {
+    inlineData: {
+        mimeType: string;
+        data: string;
+    };
+}
+export type GeminiContentPart = GeminiContentTextPart | GeminiContentFunctionCallPart | GeminiContentFunctionResponsePart | GeminiContentInlineDataPart | Record<string, unknown>;
+export interface GeminiCandidate {
+    content?: {
+        role?: string;
+        parts?: GeminiContentPart[];
+    };
+    finishReason?: string;
+    safetyRatings?: unknown[];
+}
+export interface GeminiUsageMetadata {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    totalTokenCount?: number;
+}
+export interface GeminiResponse {
+    candidates?: GeminiCandidate[];
+    promptFeedback?: Record<string, unknown>;
+    usageMetadata?: GeminiUsageMetadata;
+    modelVersion?: string;
+}
+export interface GeminiEventStats {
+    totalEvents: number;
+    chunkEvents: number;
+    doneEvents: number;
+    errors: number;
+    startTime: number;
+    endTime?: number;
+}
+export interface GeminiJsonToSseOptions {
+    requestId: string;
+    model?: string;
+    chunkDelayMs?: number;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface GeminiJsonToSseContext {
+    requestId: string;
+    model?: string;
+    response: GeminiResponse;
+    options: GeminiJsonToSseOptions;
+    startTime: number;
+    eventStats: GeminiEventStats;
+}
+export interface SseToGeminiJsonOptions {
+    requestId: string;
+    model?: string;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export interface SseToGeminiJsonContext {
+    requestId: string;
+    model?: string;
+    options: {
+        reasoningMode?: ChatReasoningMode;
+        reasoningTextPrefix?: string;
+    };
+    startTime: number;
+    eventStats: GeminiEventStats;
+    isCompleted: boolean;
+}
+export type GeminiSseEventType = 'gemini.data' | 'gemini.done' | 'gemini.error';
+export interface GeminiSseEvent extends BaseSseEvent {
+    type: GeminiSseEventType;
+    event?: GeminiSseEventType;
+    protocol: 'gemini-chat';
+    direction: StreamDirection;
+    data: unknown;
+}
+export interface GeminiChunkEventData {
+    kind: 'part';
+    candidateIndex: number;
+    partIndex: number;
+    role: string;
+    part: GeminiContentPart;
+}
+export interface GeminiDoneEventData {
+    kind: 'done';
+    usageMetadata?: GeminiUsageMetadata;
+    promptFeedback?: Record<string, unknown>;
+    modelVersion?: string;
+    candidates?: Array<{
+        index: number;
+        finishReason?: string;
+        safetyRatings?: unknown[];
+    }>;
+}
+export declare const DEFAULT_GEMINI_CONVERSION_CONFIG: {
+    chunkDelayMs: number;
+    reasoningMode: ChatReasoningMode;
+    reasoningTextPrefix: string | undefined;
+};

package/dist/sse/types/gemini-types.js

@@ -0,0 +1,5 @@
+export const DEFAULT_GEMINI_CONVERSION_CONFIG = {
+    chunkDelayMs: 0,
+    reasoningMode: 'channel',
+    reasoningTextPrefix: undefined
+};

package/dist/sse/types/index.d.ts

@@ -3,11 +3,14 @@
  * 支持Responses和Chat协议的JSON↔SSE双向转换
  */
 export type { BaseSseEvent, BaseSseEventStream, StreamProtocol, StreamDirection, SseProtocol, SseDirection } from './core-interfaces.js';
-export type { ChatSseEvent, ChatSseEventType, ChatSseEventStream, ChatEventStats, ChatJsonToSseContext, SseToChatJsonContext, ChatCompletionRequest, ChatCompletionResponse, ChatCompletionChunk, ChatMessage, ChatJsonToSseOptions, SseToChatJsonOptions, ChatConversionError, ChatToolCall, ChatToolCallChunk, ChatChoiceBuilder, ChatMessageBuilder, ChatToolCallBuilder } from './chat-types.js';
+export type { ChatSseEvent, ChatSseEventType, ChatSseEventStream, ChatEventStats, ChatJsonToSseContext, SseToChatJsonContext, ChatCompletionRequest, ChatCompletionResponse, ChatCompletionChunk, ChatMessage, ChatJsonToSseOptions, SseToChatJsonOptions, ChatConversionError, ChatToolCall, ChatToolCallChunk, ChatChoiceBuilder, ChatMessageBuilder, ChatToolCallBuilder, ChatReasoningMode } from './chat-types.js';
 export type { ChatJsonToSseConverter } from '../json-to-sse/chat-json-to-sse-converter.js';
 export type { ResponsesJsonToSseConverter } from '../json-to-sse/responses-json-to-sse-converter.js';
 export type { ResponsesSseEvent, ResponsesSseEventType, ResponsesSseEventStream, ResponsesEventStats, ResponsesJsonToSseContext, SseToResponsesJsonContext, ResponsesJsonToSseOptions, SseToResponsesJsonOptions, ResponsesResponse, ResponsesRequest, ResponsesOutputItem, ResponsesMessageItem, ResponsesFunctionCallItem, ResponsesFunctionCallOutputItem, ResponsesReasoningItem, ResponsesContent, ResponsesTool, ResponsesToolCall, ResponsesUsage, OutputItemBuilder, OutputItemProcessingState } from './responses-types.js';
-export type { AnthropicMessageResponse } from './anthropic-types.js';
+export type { AnthropicMessageResponse, AnthropicContentBlock, AnthropicJsonToSseContext, AnthropicJsonToSseOptions, AnthropicEventStats, SseToAnthropicJsonContext, SseToAnthropicJsonOptions, AnthropicSseEvent, AnthropicSseEventStream } from './anthropic-types.js';
+export { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from './anthropic-types.js';
+export type { GeminiResponse, GeminiCandidate, GeminiContentPart, GeminiUsageMetadata, GeminiJsonToSseOptions, GeminiJsonToSseContext, SseToGeminiJsonOptions, SseToGeminiJsonContext, GeminiEventStats, GeminiSseEvent, GeminiChunkEventData, GeminiDoneEventData } from './gemini-types.js';
+export { DEFAULT_GEMINI_CONVERSION_CONFIG } from './gemini-types.js';
 export type { ChatSseToJsonConverter } from '../sse-to-json/chat-sse-to-json-converter.js';
 export type { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from '../sse-to-json/responses-sse-to-json-converter.js';
 export { DEFAULT_CHAT_CONVERSION_CONFIG, CHAT_CONVERSION_ERROR_CODES } from './chat-types.js';

package/dist/sse/types/index.js

@@ -2,6 +2,8 @@
  * SSE双向转换模块类型定义统一导出
  * 支持Responses和Chat协议的JSON↔SSE双向转换
  */
+export { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from './anthropic-types.js';
+export { DEFAULT_GEMINI_CONVERSION_CONFIG } from './gemini-types.js';
 // 常量
 export { DEFAULT_CHAT_CONVERSION_CONFIG, CHAT_CONVERSION_ERROR_CODES } from './chat-types.js';
 export { DEFAULT_RESPONSES_CONVERSION_CONFIG, RESPONSES_CONVERSION_ERROR_CODES } from './responses-types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",