@jsonstudio/llms 0.4.4 → 0.4.6

package/dist/router/virtual-router/types.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Virtual Router 类型定义
+ */
+import type { StandardizedRequest } from '../../conversion/hub/types/standardized.js';
+export declare const DEFAULT_ROUTE = "default";
+export declare const ROUTE_PRIORITY: string[];
+export type RoutingPools = Record<string, string[]>;
+export interface ProviderAuthConfig {
+    type: 'apiKey' | 'oauth';
+    secretRef?: string;
+    value?: string;
+    tokenFile?: string;
+    tokenUrl?: string;
+    deviceCodeUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+    scopes?: string[];
+    authorizationUrl?: string;
+    userInfoUrl?: string;
+    refreshUrl?: string;
+    oauthProviderId?: string;
+    rawType?: string;
+}
+export interface ProviderProfile {
+    providerKey: string;
+    providerType: string;
+    endpoint: string;
+    auth: ProviderAuthConfig;
+    outboundProfile: string;
+    compatibilityProfile?: string;
+    runtimeKey?: string;
+    modelId?: string;
+    processMode?: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
+}
+export interface ProviderRuntimeProfile {
+    runtimeKey: string;
+    providerId: string;
+    keyAlias: string;
+    providerType: string;
+    endpoint: string;
+    headers?: Record<string, string>;
+    auth: ProviderAuthConfig;
+    outboundProfile: string;
+    compatibilityProfile?: string;
+    modelId?: string;
+    processMode?: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
+}
+export interface VirtualRouterClassifierConfig {
+    longContextThresholdTokens?: number;
+    thinkingKeywords?: string[];
+    codingKeywords?: string[];
+    backgroundKeywords?: string[];
+    visionKeywords?: string[];
+}
+export interface LoadBalancingPolicy {
+    strategy: 'round-robin' | 'weighted' | 'sticky';
+    weights?: Record<string, number>;
+}
+export interface ProviderHealthConfig {
+    failureThreshold: number;
+    cooldownMs: number;
+    fatalCooldownMs?: number;
+}
+export interface VirtualRouterConfig {
+    routing: RoutingPools;
+    providers: Record<string, ProviderProfile>;
+    classifier: VirtualRouterClassifierConfig;
+    loadBalancing?: LoadBalancingPolicy;
+    health?: ProviderHealthConfig;
+}
+export type VirtualRouterProviderDefinition = Record<string, unknown>;
+export interface VirtualRouterBootstrapInput extends Record<string, unknown> {
+    virtualrouter?: Record<string, unknown>;
+    providers?: Record<string, VirtualRouterProviderDefinition>;
+    routing?: Record<string, unknown>;
+    classifier?: VirtualRouterClassifierConfig;
+    loadBalancing?: LoadBalancingPolicy;
+    health?: ProviderHealthConfig;
+}
+export type ProviderRuntimeMap = Record<string, ProviderRuntimeProfile>;
+export interface VirtualRouterBootstrapResult {
+    config: VirtualRouterConfig;
+    runtime: ProviderRuntimeMap;
+    targetRuntime: Record<string, ProviderRuntimeProfile>;
+    providers: Record<string, ProviderProfile>;
+    routing: RoutingPools;
+}
+export interface RouterMetadataInput {
+    requestId: string;
+    entryEndpoint: string;
+    processMode: 'chat' | 'passthrough';
+    stream: boolean;
+    direction: 'request' | 'response';
+    providerProtocol?: string;
+    stage?: 'inbound' | 'outbound' | 'response';
+    routeHint?: string;
+}
+export interface RoutingFeatures {
+    requestId: string;
+    model: string;
+    totalMessages: number;
+    userTextSample: string;
+    toolCount: number;
+    hasTools: boolean;
+    hasToolCallResponses: boolean;
+    hasVisionTool: boolean;
+    hasImageAttachment: boolean;
+    hasWebTool: boolean;
+    hasCodingTool: boolean;
+    hasThinkingKeyword: boolean;
+    estimatedTokens: number;
+    metadata: RouterMetadataInput;
+}
+export interface ClassificationResult {
+    routeName: string;
+    confidence: number;
+    reasoning: string;
+    fallback: boolean;
+    candidates?: string[];
+}
+export interface RoutingDecision {
+    routeName: string;
+    providerKey: string;
+    confidence: number;
+    reasoning: string;
+    fallback: boolean;
+    pool: string[];
+}
+export interface TargetMetadata {
+    providerKey: string;
+    providerType: string;
+    outboundProfile: string;
+    compatibilityProfile?: string;
+    runtimeKey?: string;
+    modelId: string;
+    processMode?: 'chat' | 'passthrough';
+    responsesConfig?: ResponsesProviderConfig;
+}
+export interface ResponsesProviderConfig {
+    toolCallIdStyle?: 'fc' | 'preserve';
+}
+export declare enum VirtualRouterErrorCode {
+    NO_STANDARDIZED_REQUEST = "NO_STANDARDIZED_REQUEST",
+    ROUTE_NOT_FOUND = "ROUTE_NOT_FOUND",
+    PROVIDER_NOT_AVAILABLE = "PROVIDER_NOT_AVAILABLE",
+    CONFIG_ERROR = "CONFIG_ERROR"
+}
+export declare class VirtualRouterError extends Error {
+    readonly code: VirtualRouterErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: VirtualRouterErrorCode, details?: Record<string, unknown>);
+}
+export interface RoutingDiagnostics {
+    routeName: string;
+    providerKey: string;
+    reasoning: string;
+    fallback: boolean;
+    pool: string[];
+    confidence: number;
+}
+export interface RoutingStatusSnapshot {
+    routes: Record<string, {
+        providers: string[];
+        hits: number;
+        lastUsedProvider?: string;
+    }>;
+    health: ProviderHealthState[];
+}
+export interface ProviderHealthState {
+    providerKey: string;
+    state: 'healthy' | 'tripped';
+    failureCount: number;
+    cooldownExpiresAt?: number;
+    reason?: string;
+}
+export interface ProviderFailureEvent {
+    providerKey: string;
+    routeName?: string;
+    reason?: string;
+    fatal?: boolean;
+    statusCode?: number;
+    errorCode?: string;
+    retryable?: boolean;
+    affectsHealth?: boolean;
+    cooldownOverrideMs?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ProviderErrorRuntimeMetadata {
+    requestId: string;
+    routeName?: string;
+    providerKey?: string;
+    providerId?: string;
+    providerType?: string;
+    providerProtocol?: string;
+    pipelineId?: string;
+    target?: TargetMetadata | Record<string, unknown>;
+}
+export interface ProviderErrorEvent {
+    code: string;
+    message: string;
+    stage: string;
+    status?: number;
+    recoverable?: boolean;
+    runtime: ProviderErrorRuntimeMetadata;
+    timestamp: number;
+    details?: Record<string, unknown>;
+}
+export interface FeatureBuilder {
+    build(request: StandardizedRequest, metadata: RouterMetadataInput): RoutingFeatures;
+}

package/dist/sse/index.d.ts

@@ -4,14 +4,19 @@
  */
 import type { ChatCompletionResponse, ChatJsonToSseOptions, ResponsesJsonToSseOptions, ResponsesResponse, SseToChatJsonOptions, SseToResponsesJsonOptions } from './types/index.js';
 import type { AnthropicMessageResponse } from './types/anthropic-types.js';
+import type { GeminiResponse, GeminiJsonToSseOptions, SseToGeminiJsonOptions } from './types/gemini-types.js';
 import { ChatSseToJsonConverter as ChatSseToJsonConverterCtor } from './sse-to-json/index.js';
 import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
 import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
 import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+import { GeminiJsonToSseConverter as GeminiJsonToSseConverterCtor } from './json-to-sse/gemini-json-to-sse-converter.js';
+import { GeminiSseToJsonConverter as GeminiSseToJsonConverterCtor } from './sse-to-json/gemini-sse-to-json-converter.js';
 export { ChatJsonToSseConverter } from './json-to-sse/index.js';
 export { ChatSseToJsonConverter } from './sse-to-json/index.js';
 export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
 export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+export { GeminiJsonToSseConverter } from './json-to-sse/index.js';
+export { GeminiSseToJsonConverter } from './sse-to-json/index.js';
 export * from './shared/utils.js';
 export * from './types/index.js';
 /**
@@ -45,8 +50,18 @@ export declare function createAnthropicConverters(): {
     roundTrip(input: AnthropicMessageResponse, options: {
         requestId: string;
         model: string;
+        reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+        reasoningTextPrefix?: string;
     }): Promise<AnthropicMessageResponse>;
 };
+/**
+ * 工厂函数：创建Gemini协议转换器
+ */
+export declare function createGeminiConverters(): {
+    jsonToSse: GeminiJsonToSseConverterCtor;
+    sseToJson: GeminiSseToJsonConverterCtor;
+    roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+};
 /**
  * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
  */
@@ -73,12 +88,19 @@ export declare function createBidirectionalConverters(): {
         roundTrip(input: AnthropicMessageResponse, options: {
             requestId: string;
             model: string;
+            reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+            reasoningTextPrefix?: string;
         }): Promise<AnthropicMessageResponse>;
     };
+    gemini: {
+        jsonToSse: GeminiJsonToSseConverterCtor;
+        sseToJson: GeminiSseToJsonConverterCtor;
+        roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+    };
     /**
      * 自动检测协议类型并执行转换
      */
-    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse | GeminiResponse>;
 };
 /**
  * 默认转换器实例
@@ -122,12 +144,19 @@ export declare const bidirectionalConverters: {
         roundTrip(input: AnthropicMessageResponse, options: {
             requestId: string;
             model: string;
+            reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+            reasoningTextPrefix?: string;
         }): Promise<AnthropicMessageResponse>;
     };
+    gemini: {
+        jsonToSse: GeminiJsonToSseConverterCtor;
+        sseToJson: GeminiSseToJsonConverterCtor;
+        roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+    };
     /**
      * 自动检测协议类型并执行转换
      */
-    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse>;
+    autoConvert(input: any, options?: any): Promise<ChatCompletionResponse | ResponsesResponse | AnthropicMessageResponse | GeminiResponse>;
 };
 export declare const anthropicConverters: {
     jsonToSse: AnthropicJsonToSseConverterCtor;
@@ -135,6 +164,13 @@ export declare const anthropicConverters: {
     roundTrip(input: AnthropicMessageResponse, options: {
         requestId: string;
         model: string;
+        reasoningMode?: import("./types/chat-types.js").ChatReasoningMode;
+        reasoningTextPrefix?: string;
     }): Promise<AnthropicMessageResponse>;
 };
+export declare const geminiConverters: {
+    jsonToSse: GeminiJsonToSseConverterCtor;
+    sseToJson: GeminiSseToJsonConverterCtor;
+    roundTrip(input: GeminiResponse, options: GeminiJsonToSseOptions & SseToGeminiJsonOptions): Promise<GeminiResponse>;
+};
 export { defaultSseCodecRegistry, SseCodecRegistry, type SseCodec, type SseProtocol, type JsonToSseContext, type SseToJsonContext, type NormalizeSseContext } from './registry/sse-codec-registry.js';

package/dist/sse/index.js

@@ -8,12 +8,17 @@ import { ResponsesJsonToSseConverter as ResponsesJsonToSseConverterCtor } from '
 import { ResponsesSseToJsonConverter as ResponsesSseToJsonConverterCtor } from './sse-to-json/index.js';
 import { AnthropicJsonToSseConverter as AnthropicJsonToSseConverterCtor } from './json-to-sse/anthropic-json-to-sse-converter.js';
 import { AnthropicSseToJsonConverter as AnthropicSseToJsonConverterCtor } from './sse-to-json/anthropic-sse-to-json-converter.js';
+import { GeminiJsonToSseConverter as GeminiJsonToSseConverterCtor } from './json-to-sse/gemini-json-to-sse-converter.js';
+import { GeminiSseToJsonConverter as GeminiSseToJsonConverterCtor } from './sse-to-json/gemini-sse-to-json-converter.js';
 // Chat协议转换器
 export { ChatJsonToSseConverter } from './json-to-sse/index.js';
 export { ChatSseToJsonConverter } from './sse-to-json/index.js';
 // Responses协议转换器
 export { ResponsesJsonToSseConverter } from './json-to-sse/index.js';
 export { ResponsesSseToJsonConverter } from './sse-to-json/index.js';
+// Gemini协议转换器
+export { GeminiJsonToSseConverter } from './json-to-sse/index.js';
+export { GeminiSseToJsonConverter } from './sse-to-json/index.js';
 // 共享工具导出
 export * from './shared/utils.js';
 // 序列化器暂时禁用以专注核心SSE转换功能
@@ -74,6 +79,22 @@ export function createAnthropicConverters() {
         }
     };
 }
+/**
+ * 工厂函数：创建Gemini协议转换器
+ */
+export function createGeminiConverters() {
+    const jsonToSse = new GeminiJsonToSseConverterCtor();
+    const sseToJson = new GeminiSseToJsonConverterCtor();
+    return {
+        jsonToSse,
+        sseToJson,
+        async roundTrip(input, options) {
+            const sseStream = await jsonToSse.convertResponseToJsonToSse(input, options);
+            const result = await sseToJson.convertSseToJson(sseStream, options);
+            return result;
+        }
+    };
+}
 /**
  * 工厂函数：创建完整的双向转换器（支持Chat和Responses协议）
  */
@@ -81,10 +102,12 @@ export function createBidirectionalConverters() {
     const chat = createChatConverters();
     const responses = createResponsesConverters();
     const anthropic = createAnthropicConverters();
+    const gemini = createGeminiConverters();
     return {
         chat,
         responses,
         anthropic,
+        gemini,
         /**
          * 自动检测协议类型并执行转换
          */
@@ -99,6 +122,9 @@ export function createBidirectionalConverters() {
             else if (input.type === 'message') {
                 return await anthropic.roundTrip(input, options);
             }
+            else if (Array.isArray(input?.candidates)) {
+                return await gemini.roundTrip(input, options);
+            }
             else {
                 throw new Error(`无法识别的协议类型: ${input.object}`);
             }
@@ -112,4 +138,5 @@ export const chatConverters = createChatConverters();
 export const responsesConverters = createResponsesConverters();
 export const bidirectionalConverters = createBidirectionalConverters();
 export const anthropicConverters = createAnthropicConverters();
+export const geminiConverters = createGeminiConverters();
 export { defaultSseCodecRegistry, SseCodecRegistry } from './registry/sse-codec-registry.js';

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

@@ -0,0 +1,14 @@
+import { PassThrough } from 'node:stream';
+import { AnthropicMessageResponse, AnthropicJsonToSseOptions, DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
+export declare class AnthropicJsonToSseConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_ANTHROPIC_CONVERSION_CONFIG>);
+    convertResponseToJsonToSse(response: AnthropicMessageResponse, options: AnthropicJsonToSseOptions): Promise<PassThrough>;
+    private createContext;
+    private processResponse;
+    private updateStats;
+    private validateResponse;
+    private handleStreamError;
+    private wrapError;
+}

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

@@ -1,79 +1,112 @@
 import { PassThrough } from 'node:stream';
-/**
- * Minimal Anthropic JSON → SSE converter (v3)
- * - Emits a compact but spec-aligned event sequence for text content.
- * - Tool use blocks: emits content_block_start (tool_use), input_json_delta (whole), content_block_stop.
- *
- * NOTE: This converter purposely avoids any tool governance. It only maps shapes/fields.
- */
+import { DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { createAnthropicSequencer } from './sequencers/anthropic-sequencer.js';
+import { createAnthropicStreamWriter } from '../shared/writer.js';
 export class AnthropicJsonToSseConverter {
-    async convertResponseToJsonToSse(payload, options) {
-        const stream = new PassThrough();
-        const write = (event, data) => {
-            stream.write(`event: ${event}\n`);
-            stream.write(`data: ${JSON.stringify(data)}\n\n`);
-        };
-        const messageId = payload.id || `msg_${Date.now()}`;
-        const model = payload.model || options.model || 'unknown';
-        // 1) message_start
-        write('message_start', {
-            type: 'message_start',
-            message: { id: messageId, type: 'message', role: 'assistant', model }
+    config = DEFAULT_ANTHROPIC_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 = createAnthropicStreamWriter(stream, {
+            onEvent: (event) => this.updateStats(context, event),
+            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: 'anthropic-messages',
+            direction: 'json_to_sse',
+            requestId: options.requestId,
+            getStats: () => context.eventStats,
+            complete: () => writer.complete(),
+            abort: (error) => writer.abort(error)
         });
-        // 2) Iterate content blocks
-        let index = 0;
-        for (const block of payload.content || []) {
-            if (!block || typeof block !== 'object')
-                continue;
-            const type = block.type;
-            if (type === 'text') {
-                write('content_block_start', {
-                    type: 'content_block_start',
-                    index,
-                    content_block: { type: 'text' }
-                });
-                const text = String(block.text || '');
-                if (text) {
-                    write('content_block_delta', {
-                        type: 'content_block_delta',
-                        index,
-                        delta: { type: 'text_delta', text }
-                    });
-                }
-                write('content_block_stop', { type: 'content_block_stop', index });
-                index += 1;
-            }
-            else if (type === 'tool_use') {
-                const id = String(block.id || `call_${Math.random().toString(36).slice(2, 10)}`);
-                const name = String(block.name || 'unknown_tool');
-                const input = block.input ?? {};
-                write('content_block_start', {
-                    type: 'content_block_start',
-                    index,
-                    content_block: { type: 'tool_use', id, name }
-                });
-                try {
-                    const partial_json = JSON.stringify(input);
-                    write('content_block_delta', {
-                        type: 'content_block_delta',
-                        index,
-                        delta: { type: 'input_json_delta', partial_json }
-                    });
-                }
-                catch {
-                    // best-effort: skip delta on stringify error
-                }
-                write('content_block_stop', { type: 'content_block_stop', index });
-                index += 1;
-            }
+    }
+    createContext(response, options) {
+        const stats = {
+            totalEvents: 0,
+            contentBlocks: 0,
+            toolUseBlocks: 0,
+            thinkingBlocks: 0,
+            textBlocks: 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 = createAnthropicSequencer({
+                chunkSize: context.options.chunkSize ?? this.config.defaultChunkSize,
+                chunkDelayMs: context.options.chunkDelayMs ?? this.config.defaultDelayMs,
+                enableDelay: Boolean(context.options.chunkDelayMs),
+                reasoningMode: context.options.reasoningMode ?? this.config.reasoningMode,
+                reasoningTextPrefix: context.options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
+            });
+            const events = sequencer.sequenceResponse(response, context.requestId);
+            await writer.writeAnthropicEvents(events);
+            writer.complete();
+        }
+        catch (error) {
+            writer.abort(error);
+            throw this.wrapError('ANTHROPIC_JSON_TO_SSE_FAILED', error, context.requestId);
         }
-        // 3) message_delta (stop_reason hint)
-        const stop_reason = payload.stop_reason || 'end_turn';
-        write('message_delta', { type: 'message_delta', delta: { stop_reason } });
-        // 4) message_stop
-        write('message_stop', { type: 'message_stop' });
-        // DONE
-        stream.end();
-        return stream;
+        finally {
+            this.contexts.delete(context.requestId);
+            stream.end();
+        }
+    }
+    updateStats(context, event) {
+        context.eventStats.totalEvents += 1;
+        if (!event || typeof event !== 'object')
+            return;
+        const type = event.type;
+        if (type === 'content_block_start') {
+            context.eventStats.contentBlocks += 1;
+            const blockType = event.data?.content_block?.type;
+            if (blockType === 'tool_use')
+                context.eventStats.toolUseBlocks += 1;
+            if (blockType === 'thinking')
+                context.eventStats.thinkingBlocks += 1;
+            if (blockType === 'text')
+                context.eventStats.textBlocks += 1;
+        }
+    }
+    validateResponse(response) {
+        if (!response || typeof response !== 'object') {
+            throw new Error('Invalid Anthropic response payload');
+        }
+        if (!Array.isArray(response.content)) {
+            throw new Error('Anthropic response content must be an array');
+        }
+    }
+    handleStreamError(context, error, stream) {
+        context.eventStats.errors += 1;
+        try {
+            stream.destroy(error);
+        }
+        catch {
+            /* noop */
+        }
+    }
+    wrapError(code, error, requestId) {
+        return ErrorUtils.createError(error.message, code, { requestId });
     }
 }

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

@@ -85,7 +85,9 @@ export class ChatJsonToSseConverterRefactored {
             const sequencer = createChatSequencer({
                 chunkSize: context.options.maxTokensPerChunk || this.config.maxTokensPerChunk,
                 chunkDelayMs: context.options.chunkDelayMs || this.config.defaultChunkDelayMs,
-                enableDelay: !!context.options.chunkDelayMs
+                enableDelay: !!context.options.chunkDelayMs,
+                reasoningMode: context.options.reasoningMode || this.config.reasoningMode,
+                reasoningTextPrefix: context.options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
             });
             // 4. 生成事件序列并写入流
             const eventStream = sequencer.sequenceRequest(request, context.model, context.requestId);
@@ -113,7 +115,9 @@ export class ChatJsonToSseConverterRefactored {
             const sequencer = createChatSequencer({
                 chunkSize: context.options.maxTokensPerChunk || this.config.maxTokensPerChunk,
                 chunkDelayMs: context.options.chunkDelayMs || this.config.defaultChunkDelayMs,
-                enableDelay: !!context.options.chunkDelayMs
+                enableDelay: !!context.options.chunkDelayMs,
+                reasoningMode: context.options.reasoningMode || this.config.reasoningMode,
+                reasoningTextPrefix: context.options.reasoningTextPrefix ?? this.config.reasoningTextPrefix
             });
             // 4. 生成事件序列并写入流
             const eventStream = sequencer.sequenceResponse(response, context.model, context.requestId);

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

@@ -0,0 +1,14 @@
+import { PassThrough } from 'node:stream';
+import { GeminiResponse, GeminiJsonToSseOptions, DEFAULT_GEMINI_CONVERSION_CONFIG } from '../types/index.js';
+export declare class GeminiJsonToSseConverter {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_GEMINI_CONVERSION_CONFIG>);
+    convertResponseToJsonToSse(response: GeminiResponse, options: GeminiJsonToSseOptions): Promise<PassThrough>;
+    private createContext;
+    private processResponse;
+    private validateResponse;
+    private updateStats;
+    private handleStreamError;
+    private wrapError;
+}