@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -1,11 +1,14 @@
-import type { AnthropicMessageResponse, AnthropicJsonToSseOptions } from '../types/anthropic-types.js';
-/**
- * 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 { PassThrough } from 'node:stream';
+import { AnthropicMessageResponse, AnthropicJsonToSseOptions, DEFAULT_ANTHROPIC_CONVERSION_CONFIG } from '../types/index.js';
 export declare class AnthropicJsonToSseConverter {
-    convertResponseToJsonToSse(payload: AnthropicMessageResponse, options: AnthropicJsonToSseOptions): Promise<import('node:stream').Readable>;
+    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;
+}

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

@@ -3,4 +3,5 @@
  */
 export { ChatJsonToSseConverter } from './chat-json-to-sse-converter.js';
 export { ResponsesJsonToSseConverter } from './responses-json-to-sse-converter.js';
-export type { ChatJsonToSseOptions, ChatJsonToSseContext, ChatEventStats, ResponsesJsonToSseOptions, ResponsesJsonToSseContext, ResponsesEventStats } from '../types/index.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

@@ -2,12 +2,14 @@
  * Chat协议事件编排器
  * 负责严格的事件时序组合：role → content OR tool_calls(name → args.delta*) → finish_reason → done
  */
-import { ChatCompletionResponse, ChatSseEvent } from '../../types/index.js';
+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;
 /**