@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,296 @@
+/**
+ * Chat JSON → SSE转换器（重构版本）
+ * 使用函数化架构：事件生成 + 序列化 + 写入分离
+ */
+import { PassThrough } from 'stream';
+import { DEFAULT_CHAT_CONVERSION_CONFIG } from '../types/index.js';
+import { ErrorUtils } from '../shared/utils.js';
+import { createChatSequencer } from './sequencers/chat-sequencer.js';
+import { createChatStreamWriter } from '../shared/writer.js';
+/**
+ * 重构后的Chat JSON到SSE转换器
+ * 采用函数化架构，专注于编排而非具体业务逻辑
+ */
+export class ChatJsonToSseConverterRefactored {
+    config = DEFAULT_CHAT_CONVERSION_CONFIG;
+    contexts = new Map();
+    constructor(config) {
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    /**
+     * 将Chat Completion请求转换为SSE流
+     */
+    async convertRequestToJsonToSse(request, options) {
+        // 1. 创建上下文
+        const context = this.createRequestContext(request, options);
+        this.contexts.set(options.requestId, context);
+        // 2. 创建底层流
+        const stream = new PassThrough({ objectMode: true });
+        // 3. 创建SSE事件流接口
+        const sseStream = Object.assign(stream, {
+            protocol: 'chat',
+            direction: 'json_to_sse',
+            requestId: options.requestId,
+            getStats: () => context.eventStats,
+            getConfig: () => this.config,
+            complete: () => this.completeStream(context, stream),
+            abort: (error) => this.abortStream(context, stream, error)
+        });
+        // 4. 启动异步转换过程（使用函数化架构）
+        this.processRequestToSseWithFunctions(request, context, stream).catch(error => {
+            this.handleStreamError(context, error, stream);
+        });
+        return sseStream;
+    }
+    /**
+     * 将Chat Completion响应转换为SSE流
+     */
+    async convertResponseToJsonToSse(response, options) {
+        // 1. 创建上下文
+        const context = this.createResponseContext(response, options);
+        this.contexts.set(options.requestId, context);
+        // 2. 创建底层流
+        const stream = new PassThrough({ objectMode: true });
+        // 3. 创建SSE事件流接口
+        const sseStream = Object.assign(stream, {
+            protocol: 'chat',
+            direction: 'json_to_sse',
+            requestId: options.requestId,
+            getStats: () => context.eventStats,
+            getConfig: () => this.config,
+            complete: () => this.completeStream(context, stream),
+            abort: (error) => this.abortStream(context, stream, error)
+        });
+        // 4. 启动异步转换过程（使用函数化架构）
+        this.processResponseToSseWithFunctions(response, context, stream).catch(error => {
+            this.handleStreamError(context, error, stream);
+        });
+        return sseStream;
+    }
+    /**
+     * 使用函数化架构处理请求转换
+     */
+    async processRequestToSseWithFunctions(request, context, stream) {
+        try {
+            // 1. 验证请求
+            this.validateRequest(request);
+            // 2. 创建流写入器
+            const writer = createChatStreamWriter(stream, {
+                onEvent: (event) => this.updateStats(context, event),
+                onError: (error) => this.handleStreamError(context, error, stream)
+            });
+            // 3. 创建事件序列化器
+            const sequencer = createChatSequencer({
+                chunkSize: context.options.maxTokensPerChunk || this.config.maxTokensPerChunk,
+                chunkDelayMs: context.options.chunkDelayMs || this.config.defaultChunkDelayMs,
+                enableDelay: !!context.options.chunkDelayMs
+            });
+            // 4. 生成事件序列并写入流
+            const eventStream = sequencer.sequenceRequest(request, context.model, context.requestId);
+            await writer.writeChatEvents(eventStream);
+            // 5. 完成流
+            writer.complete();
+        }
+        catch (error) {
+            throw this.wrapError('REQUEST_CONVERSION_ERROR', error, context.requestId);
+        }
+    }
+    /**
+     * 使用函数化架构处理响应转换
+     */
+    async processResponseToSseWithFunctions(response, context, stream) {
+        try {
+            // 1. 验证响应
+            this.validateResponse(response);
+            // 2. 创建流写入器
+            const writer = createChatStreamWriter(stream, {
+                onEvent: (event) => this.updateStats(context, event),
+                onError: (error) => this.handleStreamError(context, error, stream)
+            });
+            // 3. 创建事件序列化器
+            const sequencer = createChatSequencer({
+                chunkSize: context.options.maxTokensPerChunk || this.config.maxTokensPerChunk,
+                chunkDelayMs: context.options.chunkDelayMs || this.config.defaultChunkDelayMs,
+                enableDelay: !!context.options.chunkDelayMs
+            });
+            // 4. 生成事件序列并写入流
+            const eventStream = sequencer.sequenceResponse(response, context.model, context.requestId);
+            await writer.writeChatEvents(eventStream);
+            // 5. 完成流
+            writer.complete();
+        }
+        catch (error) {
+            throw this.wrapError('RESPONSE_CONVERSION_ERROR', error, context.requestId);
+        }
+    }
+    /**
+     * 验证请求格式
+     */
+    validateRequest(request) {
+        // 最小校验，避免依赖不存在的 ValidationUtils 方法
+        if (!request || typeof request !== 'object' || !Array.isArray(request.messages) || !request.model) {
+            throw new Error('Invalid ChatCompletionRequest format');
+        }
+    }
+    /**
+     * 验证响应格式
+     */
+    validateResponse(response) {
+        if (!response || typeof response !== 'object' || !Array.isArray(response.choices) || !response.model) {
+            throw new Error('Invalid ChatCompletionResponse format');
+        }
+    }
+    /**
+     * 更新统计信息
+     */
+    updateStats(context, event) {
+        // 尽量兼容 event/event.type 两种字段
+        const et = (event && (event.event || event.type)) || 'unknown';
+        if (typeof context.eventStats.totalEvents === 'number')
+            context.eventStats.totalEvents++;
+        if (context.eventStats.eventTypes) {
+            context.eventStats.eventTypes[et] = (context.eventStats.eventTypes[et] || 0) + 1;
+        }
+        if (et === 'error' || et === 'chat.error') {
+            context.eventStats.errorCount++;
+        }
+        // 更新时间戳
+        if (et === 'chat_chunk') {
+            context.eventStats.totalChunks++;
+            try {
+                const chunkObj = typeof event?.data === 'string' ? JSON.parse(event.data) : event?.data;
+                const choice = chunkObj?.choices?.[0];
+                const deltaContent = choice?.delta?.content;
+                if (typeof deltaContent === 'string') {
+                    context.eventStats.totalTokens += deltaContent.length;
+                }
+            }
+            catch { /* ignore parse errors */ }
+        }
+        if (typeof event?.timestamp === 'number')
+            context.eventStats.lastEventTime = event.timestamp;
+    }
+    /**
+     * 包装错误
+     */
+    wrapError(code, originalError, requestId) {
+        return ErrorUtils.createError(`${code}: ${originalError.message}`, code, { requestId, originalError });
+    }
+    /**
+     * 处理流错误
+     */
+    handleStreamError(context, error, stream) {
+        context.eventStats.errorCount++;
+        const wrappedError = this.wrapError('STREAM_ERROR', error, context.requestId);
+        if (stream.writable) {
+            stream.destroy(wrappedError);
+        }
+    }
+    /**
+     * 完成流
+     */
+    completeStream(context, stream) {
+        context.eventStats.endTime = Date.now();
+        context.eventStats.duration = context.eventStats.endTime - context.eventStats.startTime;
+        if (stream.writable) {
+            stream.end();
+        }
+    }
+    /**
+     * 中止流
+     */
+    abortStream(context, stream, error) {
+        context.eventStats.endTime = Date.now();
+        context.eventStats.duration = context.eventStats.endTime - context.eventStats.startTime;
+        if (error) {
+            context.eventStats.errorCount++;
+        }
+        if (stream.writable) {
+            stream.destroy(error);
+        }
+    }
+    /**
+     * 创建请求上下文
+     */
+    createRequestContext(request, options) {
+        const eventStats = {
+            totalChunks: 0,
+            totalTokens: 0,
+            totalChoices: 0,
+            totalToolCalls: 0,
+            startTime: Date.now(),
+            tokenRate: 0,
+            chunkRate: 0,
+            errorCount: 0,
+            retryCount: 0,
+            totalEvents: 0,
+            eventTypes: {}
+        };
+        return {
+            requestId: options.requestId,
+            model: request.model,
+            chatRequest: request,
+            options,
+            startTime: Date.now(),
+            sequenceCounter: 0,
+            choiceIndexCounter: 0,
+            toolCallIndexCounter: 0,
+            currentChunk: {},
+            isStreaming: true,
+            eventStats
+        };
+    }
+    /**
+     * 创建响应上下文
+     */
+    createResponseContext(response, options) {
+        const eventStats = {
+            totalChunks: 0,
+            totalTokens: 0,
+            totalChoices: 0,
+            totalToolCalls: 0,
+            startTime: Date.now(),
+            tokenRate: 0,
+            chunkRate: 0,
+            errorCount: 0,
+            retryCount: 0,
+            totalEvents: 0,
+            eventTypes: {}
+        };
+        return {
+            requestId: options.requestId,
+            model: response.model,
+            chatRequest: {},
+            options,
+            startTime: Date.now(),
+            sequenceCounter: 0,
+            choiceIndexCounter: 0,
+            toolCallIndexCounter: 0,
+            currentChunk: {},
+            isStreaming: true,
+            eventStats
+        };
+    }
+    /**
+     * 获取上下文
+     */
+    getContext(requestId) {
+        return this.contexts.get(requestId);
+    }
+    /**
+     * 清理上下文
+     */
+    clearContext(requestId) {
+        this.contexts.delete(requestId);
+    }
+    /**
+     * 获取所有活跃的上下文
+     */
+    getActiveContexts() {
+        return new Map(this.contexts);
+    }
+}
+// 为了向后兼容，导出原有名称
+export const ChatJsonToSseConverter = ChatJsonToSseConverterRefactored;

package/dist/conversion/conversion-v3/sse/json-to-sse/event-generators/chat.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Chat协议事件生成器
+ * 提供纯函数，将Chat响应数据转换为SSE事件对象，不处理流写入
+ */
+import { ChatSseEvent, ChatToolCall } from '../../types/index.js';
+export interface ChatEventGeneratorConfig {
+    chunkSize: number;
+    chunkDelayMs: number;
+    enableIdGeneration: boolean;
+    enableTimestampGeneration: boolean;
+}
+export interface ChatEventGeneratorContext {
+    model: string;
+    requestId: string;
+    choiceIndex: number;
+    toolCallIndexCounter: number;
+    contentIndexCounter: Map<string, number>;
+}
+export declare const DEFAULT_CHAT_EVENT_GENERATOR_CONFIG: ChatEventGeneratorConfig;
+/**
+ * 创建默认上下文
+ */
+export declare function createDefaultContext(model: string, requestId: string): ChatEventGeneratorContext;
+/**
+ * 构建role delta事件
+ */
+export declare function buildRoleDelta(role: string, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent[];
+/**
+ * 构建reasoning delta事件
+ */
+export declare function buildReasoningDeltas(reasoning: string, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): Generator<ChatSseEvent>;
+/**
+ * 构建content delta事件
+ */
+export declare function buildContentDeltas(content: string, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): Generator<ChatSseEvent>;
+/**
+ * 构建tool_call开始事件
+ */
+export declare function buildToolCallStart(toolCall: ChatToolCall, toolCallIndex: number, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;
+/**
+ * 构建tool_call arguments delta事件
+ */
+export declare function buildToolCallArgsDeltas(args: string, toolCallIndex: number, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): Generator<ChatSseEvent>;
+/**
+ * 构建finish_reason事件
+ */
+export declare function buildFinishEvent(finishReason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call', context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;
+/**
+ * 构建done事件
+ */
+export declare function buildDoneEvent(context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;
+/**
+ * 构建error事件
+ */
+export declare function buildErrorEvent(error: Error, context: ChatEventGeneratorContext, config?: ChatEventGeneratorConfig): ChatSseEvent;

package/dist/conversion/conversion-v3/sse/json-to-sse/event-generators/chat.js

@@ -0,0 +1,233 @@
+/**
+ * Chat协议事件生成器
+ * 提供纯函数，将Chat响应数据转换为SSE事件对象，不处理流写入
+ */
+import { IdUtils, TimeUtils } from '../../shared/utils.js';
+// 默认配置
+export const DEFAULT_CHAT_EVENT_GENERATOR_CONFIG = {
+    chunkSize: 12,
+    chunkDelayMs: 8,
+    enableIdGeneration: true,
+    enableTimestampGeneration: true
+};
+/**
+ * 创建默认上下文
+ */
+export function createDefaultContext(model, requestId) {
+    return {
+        model,
+        requestId,
+        choiceIndex: 0,
+        toolCallIndexCounter: 0,
+        contentIndexCounter: new Map()
+    };
+}
+/**
+ * 生成基础chunk数据
+ */
+function createBaseChunk(context, config) {
+    return {
+        id: config.enableIdGeneration ? IdUtils.generateRequestId() : context.requestId,
+        object: 'chat.completion.chunk',
+        created: config.enableTimestampGeneration ? Math.floor(TimeUtils.now() / 1000) : 0,
+        model: context.model
+    };
+}
+/**
+ * 构建role delta事件
+ */
+export function buildRoleDelta(role, context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    const baseChunk = createBaseChunk(context, config);
+    const chunk = {
+        ...baseChunk,
+        choices: [{
+                index: context.choiceIndex,
+                delta: { role: role },
+                logprobs: null,
+                finish_reason: null
+            }]
+    };
+    return [{
+            event: 'chat_chunk',
+            type: 'chat_chunk',
+            timestamp: TimeUtils.now(),
+            data: JSON.stringify(chunk),
+            sequenceNumber: 0,
+            protocol: 'chat',
+            direction: 'json_to_sse'
+        }];
+}
+/**
+ * 构建reasoning delta事件
+ */
+export function* buildReasoningDeltas(reasoning, context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    if (!reasoning)
+        return;
+    const baseChunk = createBaseChunk(context, config);
+    const chunk = {
+        ...baseChunk,
+        choices: [{
+                index: context.choiceIndex,
+                delta: { reasoning },
+                logprobs: null,
+                finish_reason: null
+            }]
+    };
+    yield {
+        event: 'chat_chunk',
+        type: 'chat_chunk',
+        timestamp: TimeUtils.now(),
+        data: JSON.stringify(chunk),
+        sequenceNumber: 0,
+        protocol: 'chat',
+        direction: 'json_to_sse'
+    };
+}
+/**
+ * 构建content delta事件
+ */
+export function* buildContentDeltas(content, context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    if (!content)
+        return;
+    const baseChunk = createBaseChunk(context, config);
+    const chunk = {
+        ...baseChunk,
+        choices: [{
+                index: context.choiceIndex,
+                delta: { content },
+                logprobs: null,
+                finish_reason: null
+            }]
+    };
+    yield {
+        event: 'chat_chunk',
+        type: 'chat_chunk',
+        timestamp: TimeUtils.now(),
+        data: JSON.stringify(chunk),
+        sequenceNumber: 0,
+        protocol: 'chat',
+        direction: 'json_to_sse'
+    };
+}
+/**
+ * 构建tool_call开始事件
+ */
+export function buildToolCallStart(toolCall, toolCallIndex, context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    const baseChunk = createBaseChunk(context, config);
+    const chunk = {
+        ...baseChunk,
+        choices: [{
+                index: context.choiceIndex,
+                delta: {
+                    tool_calls: [{
+                            index: toolCallIndex,
+                            id: toolCall.id,
+                            type: toolCall.type || 'function',
+                            function: {
+                                name: toolCall.function.name
+                            }
+                        }]
+                },
+                logprobs: null,
+                finish_reason: null
+            }]
+    };
+    return {
+        event: 'chat_chunk',
+        type: 'chat_chunk',
+        timestamp: TimeUtils.now(),
+        data: JSON.stringify(chunk),
+        sequenceNumber: 0,
+        protocol: 'chat',
+        direction: 'json_to_sse'
+    };
+}
+/**
+ * 构建tool_call arguments delta事件
+ */
+export function* buildToolCallArgsDeltas(args, toolCallIndex, context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    if (!args)
+        return;
+    const baseChunk = createBaseChunk(context, config);
+    const chunk = {
+        ...baseChunk,
+        choices: [{
+                index: context.choiceIndex,
+                delta: {
+                    tool_calls: [{
+                            index: toolCallIndex,
+                            function: { arguments: args }
+                        }]
+                },
+                logprobs: null,
+                finish_reason: null
+            }]
+    };
+    yield {
+        event: 'chat_chunk',
+        type: 'chat_chunk',
+        timestamp: TimeUtils.now(),
+        data: JSON.stringify(chunk),
+        sequenceNumber: 0,
+        protocol: 'chat',
+        direction: 'json_to_sse'
+    };
+}
+/**
+ * 构建finish_reason事件
+ */
+export function buildFinishEvent(finishReason, context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    const baseChunk = createBaseChunk(context, config);
+    const chunk = {
+        ...baseChunk,
+        choices: [{
+                index: context.choiceIndex,
+                delta: {},
+                logprobs: null,
+                finish_reason: finishReason
+            }]
+    };
+    return {
+        event: 'chat_chunk',
+        type: 'chat_chunk',
+        timestamp: TimeUtils.now(),
+        data: JSON.stringify(chunk),
+        sequenceNumber: 0,
+        protocol: 'chat',
+        direction: 'json_to_sse'
+    };
+}
+/**
+ * 构建done事件
+ */
+export function buildDoneEvent(context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    return {
+        event: 'chat.done',
+        type: 'chat.done',
+        timestamp: TimeUtils.now(),
+        data: '[DONE]',
+        sequenceNumber: 0,
+        protocol: 'chat',
+        direction: 'json_to_sse'
+    };
+}
+/**
+ * 构建error事件
+ */
+export function buildErrorEvent(error, context, config = DEFAULT_CHAT_EVENT_GENERATOR_CONFIG) {
+    return {
+        event: 'error',
+        type: 'error',
+        timestamp: TimeUtils.now(),
+        data: JSON.stringify({
+            error: {
+                message: error.message,
+                type: 'internal_error',
+                code: 'generation_error'
+            }
+        }),
+        sequenceNumber: 0,
+        protocol: 'chat',
+        direction: 'json_to_sse'
+    };
+}

package/dist/conversion/conversion-v3/sse/json-to-sse/event-generators/responses.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Responses协议事件生成器
+ * 提供纯函数，将Responses响应数据转换为SSE事件对象，不处理流写入
+ */
+import { ResponsesSseEvent, ResponsesResponse, ResponsesOutputItem, ResponsesFunctionCallItem, ResponsesReasoningItem, ResponsesContent } from '../../types/index.js';
+export interface ResponsesEventGeneratorConfig {
+    chunkSize: number;
+    chunkDelayMs: number;
+    enableIdGeneration: boolean;
+    enableTimestampGeneration: boolean;
+    enableSequenceNumbers: boolean;
+    enableDelay: boolean;
+}
+export interface ResponsesEventGeneratorContext {
+    requestId: string;
+    model: string;
+    outputIndexCounter: number;
+    contentIndexCounter: Map<string, number>;
+    sequenceCounter: number;
+}
+export declare const DEFAULT_RESPONSES_EVENT_GENERATOR_CONFIG: ResponsesEventGeneratorConfig;
+/**
+ * 创建默认上下文
+ */
+export declare function createDefaultResponsesContext(requestId: string, model: string): ResponsesEventGeneratorContext;
+/**
+ * 构建response.created + response.in_progress事件
+ * 映射：response.start → response.created + response.in_progress
+ */
+export declare function buildResponseStartEvents(response: ResponsesResponse, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): Generator<ResponsesSseEvent>;
+/**
+ * 构建response.output_item.added事件
+ * 映射：output_item.start → response.output_item.added
+ */
+export declare function buildOutputItemStartEvent(outputItem: ResponsesOutputItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建response.content_part.added事件
+ * 映射：content_part.start → response.content_part.added
+ */
+export declare function buildContentPartStartEvent(outputItemId: string, contentIndex: number, content: ResponsesContent, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建response.output_text.delta事件流
+ * 映射：content_part.delta (input_text/output_text/…) → response.output_text.delta
+ * 对于 reasoning 使用 response.reasoning_text.delta
+ */
+export declare function buildContentPartDeltas(outputItemId: string, contentIndex: number, text: string, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): Generator<ResponsesSseEvent>;
+/**
+ * 构建content_part.done事件
+ */
+export declare function buildContentPartDoneEvent(outputItemId: string, contentIndex: number, content: ResponsesContent | undefined, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+export declare function buildOutputTextDoneEvent(outputItemId: string, contentIndex: number, fullText: string, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建response.function_call_arguments.delta/done的start部分
+ * 映射：function_call.start → 隐含在第一个 delta 中
+ */
+/**
+ * 构建response.function_call_arguments.delta事件流
+ * 映射：function_call.delta → response.function_call_arguments.delta
+ */
+export declare function buildFunctionCallArgsDeltas(functionCall: ResponsesFunctionCallItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): Generator<ResponsesSseEvent>;
+/**
+ * 构建response.function_call_arguments.done事件
+ * 映射：function_call.done → response.function_call_arguments.done
+ */
+export declare function buildFunctionCallDoneEvent(functionCall: ResponsesFunctionCallItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建reasoning.start事件
+ */
+export declare function buildReasoningStartEvent(reasoning: ResponsesReasoningItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建response.reasoning_text.delta事件流
+ * 映射：reasoning.delta → response.reasoning_text.delta
+ */
+export declare function buildReasoningDeltas(reasoning: ResponsesReasoningItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): Generator<ResponsesSseEvent>;
+/**
+ * 构建reasoning.done事件
+ */
+export declare function buildReasoningDoneEvent(reasoning: ResponsesReasoningItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建output_item.done事件
+ */
+export declare function buildOutputItemDoneEvent(outputItem: ResponsesOutputItem, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建required_action事件
+ */
+export declare function buildRequiredActionEvent(response: ResponsesResponse, requiredAction: any, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建response.completed事件
+ * 新增：在 done 之前增加 response.completed
+ */
+export declare function buildResponseCompletedEvent(response: ResponsesResponse, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建response.done事件
+ */
+export declare function buildResponseDoneEvent(response: ResponsesResponse, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;
+/**
+ * 构建error事件
+ */
+export declare function buildErrorEvent(error: Error, context: ResponsesEventGeneratorContext, config?: ResponsesEventGeneratorConfig): ResponsesSseEvent;