@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,296 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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

@@ -1,233 +0,0 @@
-/**
- * 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

@@ -1,99 +0,0 @@
-/**
- * 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;