@jsonstudio/llms 0.4.2

package/dist/sse/types/conversion-context.d.ts

@@ -0,0 +1,211 @@
+/**
+ * 转换上下文类型定义
+ * 定义JSON<>SSE双向转换过程中的上下文信息
+ */
+import type { SseEvent, SseEventStats, SseEventType } from './sse-events.js';
+export interface BaseConversionContext {
+    requestId: string;
+    model: string;
+    createdAt: number;
+    outputIndexCounter: number;
+    sequenceCounter: number;
+    timeoutMs?: number;
+    heartbeatTimer?: NodeJS.Timeout;
+    isCompleted: boolean;
+    lastEventTime: number;
+    logger: ConversionLogger;
+}
+export interface JsonToSseContext extends BaseConversionContext {
+    jsonResponse: ResponsesJson;
+    options: JsonToSseOptions;
+    eventStats: SseEventStats;
+    startTime: number;
+    currentOutputIndex: number;
+    contentIndexCounter: Map<string, number>;
+    itemIds: Map<string, string>;
+    activeOutputItems: Map<number, OutputItemState>;
+}
+export interface SseToJsonContext extends BaseConversionContext {
+    options: SseToJsonOptions;
+    aggregatedEvents: SseEvent[];
+    partialResponse: ResponsesPartialJson;
+    completionTimeout?: NodeJS.Timeout;
+    outputItems: Map<number, OutputItemBuilder>;
+    lastSequenceNumber: number;
+    expectedSequenceNumbers: Set<number>;
+    isResponseCreated: boolean;
+    isInProgress: boolean;
+}
+export interface JsonToSseOptions {
+    requestId: string;
+    model: string;
+    timeoutMs?: number;
+    heartbeatIntervalMs?: number;
+    chunkSize?: number;
+    delayMs?: number;
+    includeSequenceNumbers?: boolean;
+    enableHeartbeat?: boolean;
+    validationMode?: 'none' | 'basic' | 'strict';
+    onEvent?: (event: SseEvent) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+}
+export interface SseToJsonOptions {
+    requestId: string;
+    timeoutMs?: number;
+    validateEvents?: boolean;
+    enableSequenceValidation?: boolean;
+    onPartialResult?: (partial: ResponsesPartialJson) => void;
+    onEvent?: (event: SseEvent) => void;
+    onCompletion?: (final: ResponsesJson) => void;
+    onError?: (error: Error) => void;
+    onTimeout?: () => void;
+}
+export interface ResponsesJson {
+    id: string;
+    object: 'response';
+    created_at: number;
+    model: string;
+    status: 'in_progress' | 'requires_action' | 'completed';
+    output: OutputItem[];
+    usage?: UsageInfo;
+    previous_response_id?: string | null;
+    required_action?: RequiredAction;
+    output_text?: string;
+}
+export interface ResponsesPartialJson {
+    id: string;
+    object: 'response';
+    created_at: number;
+    model: string;
+    status: 'in_progress' | 'requires_action' | 'completed';
+    output: OutputItem[];
+    usage?: UsageInfo;
+    required_action?: RequiredAction;
+    output_text?: string;
+}
+export interface OutputItemState {
+    id: string;
+    type: string;
+    status: 'in_progress' | 'completed';
+    contentIndex: number;
+    isContentPartAdded: boolean;
+    isTextStarted: boolean;
+    isTextCompleted: boolean;
+    accumulatedText: string;
+    accumulatedDelta: string;
+}
+export interface OutputItemBuilder {
+    item: OutputItem;
+    isCompleted: boolean;
+    contentParts: ContentPart[];
+    currentContentIndex: number;
+    accumulatedText: string;
+    hasContentPartAdded: boolean;
+    isTextInProgress: boolean;
+}
+export interface ConversionLogger {
+    debug(message: string, meta?: any): void;
+    info(message: string, meta?: any): void;
+    warn(message: string, meta?: any): void;
+    error(message: string, error?: Error, meta?: any): void;
+    event(eventType: string, data?: any): void;
+    metric(name: string, value: number, tags?: Record<string, string>): void;
+}
+export interface ConversionError extends Error {
+    code: string;
+    requestId: string;
+    eventType?: string;
+    sequenceNumber?: number;
+    context?: any;
+}
+export interface StreamState {
+    isStarted: boolean;
+    isCompleted: boolean;
+    isAborted: boolean;
+    lastActivityTime: number;
+    totalEventsProcessed: number;
+    bytesProcessed: number;
+    errorCount: number;
+}
+export interface SseEventStream extends AsyncIterable<SseEvent> {
+    getStats(): SseEventStats;
+    getState(): StreamState;
+    complete(): void;
+    abort(error?: Error): void;
+    on?(event: 'error', handler: (error: Error) => void): this;
+    on?(event: 'complete', handler: () => void): this;
+    on?(event: 'timeout', handler: () => void): this;
+    on?(event: 'stats', handler: (stats: SseEventStats) => void): this;
+}
+export interface ConversionConfig {
+    defaultTimeoutMs: number;
+    heartbeatIntervalMs: number;
+    inactivityTimeoutMs: number;
+    defaultChunkSize: number;
+    defaultDelayMs: number;
+    enableEventValidation: boolean;
+    enableSequenceValidation: boolean;
+    strictMode: boolean;
+    maxConcurrentEvents: number;
+    eventBufferSize: number;
+    debugMode: boolean;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    enableMetrics: boolean;
+}
+export declare const DEFAULT_CONVERSION_CONFIG: ConversionConfig;
+export interface EventHandler {
+    canHandle(eventType: SseEventType): boolean;
+    handle(event: SseEvent, context: any): Promise<void>;
+}
+export interface ConversionMiddleware {
+    name: string;
+    beforeConversion?: (context: any) => Promise<void>;
+    afterConversion?: (context: any, result: any) => Promise<void>;
+    onError?: (context: any, error: Error) => Promise<void>;
+}
+interface OutputItem {
+    id: string;
+    type: 'reasoning' | 'message' | 'function_call' | 'system_message';
+    status?: 'in_progress' | 'completed';
+    content?: ContentPart[];
+    summary?: any[];
+    role?: string;
+    arguments?: string;
+    call_id?: string;
+    name?: string;
+    message?: MessageContent;
+}
+interface ContentPart {
+    type: 'reasoning_text' | 'output_text' | 'input_text' | 'commentary';
+    text: string;
+}
+interface MessageContent {
+    id?: string;
+    role: string;
+    status?: string;
+    content: ContentPart[];
+}
+interface UsageInfo {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+    output_tokens_details?: {
+        reasoning_tokens: number;
+    };
+}
+interface RequiredAction {
+    type: 'submit_tool_outputs';
+    submit_tool_outputs: {
+        tool_calls: ToolCall[];
+    };
+}
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export {};

package/dist/sse/types/conversion-context.js

@@ -0,0 +1,20 @@
+/**
+ * 转换上下文类型定义
+ * 定义JSON<>SSE双向转换过程中的上下文信息
+ */
+// 预定义配置
+export const DEFAULT_CONVERSION_CONFIG = {
+    defaultTimeoutMs: 30000,
+    heartbeatIntervalMs: 15000,
+    inactivityTimeoutMs: 60000,
+    defaultChunkSize: 12,
+    defaultDelayMs: 8,
+    enableEventValidation: true,
+    enableSequenceValidation: true,
+    strictMode: false,
+    maxConcurrentEvents: 10,
+    eventBufferSize: 1000,
+    debugMode: false,
+    logLevel: 'info',
+    enableMetrics: true
+};

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

@@ -0,0 +1,90 @@
+/**
+ * 核心接口定义
+ * 统一的SSE事件最小接口，供writer.ts等共享模块使用
+ */
+export interface BaseSseEvent {
+    /** 事件类型 */
+    type: string;
+    /** 事件时间戳 */
+    timestamp: number;
+    /** 事件数据 */
+    data: any;
+    /** 序列号（可选） */
+    sequenceNumber?: number;
+    /** 协议标识 */
+    protocol?: StreamProtocol;
+    /** 方向标识 */
+    direction?: StreamDirection;
+}
+export type StreamProtocol = 'chat' | 'responses';
+export type StreamDirection = 'json_to_sse' | 'sse_to_json';
+export type SseProtocol = StreamProtocol;
+export type SseDirection = StreamDirection;
+export interface BaseSseEventStream extends AsyncIterable<BaseSseEvent> {
+    /** 获取当前统计信息 */
+    getStats(): BaseSseEventStats;
+    /** 完成流 */
+    complete(): void;
+    /** 中止流 */
+    abort(error?: Error): void;
+    /** 错误事件监听 */
+    on(event: 'error', handler: (error: Error) => void): this;
+    /** 完成事件监听 */
+    on(event: 'complete', handler: () => void): this;
+    /** 超时事件监听 */
+    on(event: 'timeout', handler: () => void): this;
+}
+export interface BaseSseEventStats {
+    /** 总事件数 */
+    totalEvents: number;
+    /** 事件类型统计 */
+    eventTypes: Record<string, number>;
+    /** 开始时间 */
+    startTime: number;
+    /** 结束时间（可选） */
+    endTime?: number;
+    /** 持续时间（可选） */
+    duration?: number;
+    /** 错误计数 */
+    errorCount?: number;
+    /** 最后事件时间（可选） */
+    lastEventTime?: number;
+}
+export interface BaseConversionContext {
+    /** 请求ID */
+    requestId: string;
+    /** 模型名称 */
+    model: string;
+    /** 转换选项 */
+    options: any;
+    /** 开始时间 */
+    startTime: number;
+}
+export interface BaseConversionOptions {
+    /** 请求ID */
+    requestId: string;
+    /** 模型名称 */
+    model: string;
+    /** 超时毫秒数（可选） */
+    timeoutMs?: number;
+}
+export interface BaseStreamState {
+    /** 是否活跃 */
+    isActive: boolean;
+    /** 当前序列号 */
+    currentSequence: number;
+    /** 缓冲区大小 */
+    bufferSize: number;
+    /** 错误状态 */
+    hasError: boolean;
+}
+export type ProtocolSseEvent<T extends BaseSseEvent, P extends SseProtocol> = T & {
+    protocol: P;
+};
+export type DirectionalSseEvent<T extends BaseSseEvent, D extends SseDirection> = T & {
+    direction: D;
+};
+export type CompleteSseEvent<T extends BaseSseEvent, P extends SseProtocol, D extends SseDirection> = T & {
+    protocol: P;
+    direction: D;
+};

package/dist/sse/types/core-interfaces.js

@@ -0,0 +1,5 @@
+/**
+ * 核心接口定义
+ * 统一的SSE事件最小接口，供writer.ts等共享模块使用
+ */
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * SSE双向转换模块类型定义统一导出
+ * 支持Responses和Chat协议的JSON↔SSE双向转换
+ */
+export type { BaseSseEvent, BaseSseEventStream, StreamProtocol, StreamDirection, SseProtocol, SseDirection } from './core-interfaces.js';
+export type { ChatSseEvent, ChatSseEventType, ChatSseEventStream, ChatEventStats, ChatJsonToSseContext, SseToChatJsonContext, ChatCompletionRequest, ChatCompletionResponse, ChatCompletionChunk, ChatJsonToSseOptions, SseToChatJsonOptions, ChatConversionError, ChatToolCall, ChatChoiceBuilder, ChatMessageBuilder, ChatToolCallBuilder } from './chat-types.js';
+export type { ChatJsonToSseConverter } from '../json-to-sse/chat-json-to-sse-converter.js';
+export type { ResponsesJsonToSseConverter } from '../json-to-sse/responses-json-to-sse-converter.js';
+export type { ResponsesSseEvent, ResponsesSseEventType, ResponsesSseEventStream, ResponsesEventStats, ResponsesJsonToSseContext, SseToResponsesJsonContext, ResponsesJsonToSseOptions, SseToResponsesJsonOptions, ResponsesResponse, ResponsesRequest, ResponsesOutputItem, ResponsesMessageItem, ResponsesFunctionCallItem, ResponsesFunctionCallOutputItem, ResponsesReasoningItem, ResponsesContent, ResponsesTool, ResponsesToolCall, ResponsesUsage, OutputItemBuilder, OutputItemProcessingState } from './responses-types.js';
+export type { AnthropicMessageResponse } from './anthropic-types.js';
+export type { ChatSseToJsonConverter } from '../sse-to-json/chat-sse-to-json-converter.js';
+export type { ResponsesSseToJsonConverterRefactored as ResponsesSseToJsonConverter } from '../sse-to-json/responses-sse-to-json-converter.js';
+export { DEFAULT_CHAT_CONVERSION_CONFIG, CHAT_CONVERSION_ERROR_CODES } from './chat-types.js';
+export { DEFAULT_RESPONSES_CONVERSION_CONFIG, RESPONSES_CONVERSION_ERROR_CODES } from './responses-types.js';

package/dist/sse/types/index.js

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

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

@@ -0,0 +1,328 @@
+/**
+ * Responses协议相关类型定义
+ * 支持OpenAI Responses API的JSON↔SSE双向转换
+ */
+import { BaseSseEvent, StreamDirection } from './core-interfaces.js';
+export * from './sse-events.js';
+export type ResponsesSseEventType = 'response.created' | 'response.in_progress' | 'response.completed' | 'response.required_action' | 'response.done' | 'response.output_item.added' | 'response.output_item.done' | 'response.content_part.added' | 'response.content_part.done' | 'response.output_text.delta' | 'response.output_text.done' | 'response.reasoning_text.delta' | 'response.reasoning_text.done' | 'response.reasoning_signature.delta' | 'response.reasoning_image.delta' | 'response.reasoning_summary_part.added' | 'response.reasoning_summary_part.done' | 'response.reasoning_summary_text.delta' | 'response.reasoning_summary_text.done' | 'response.function_call_arguments.delta' | 'response.function_call_arguments.done' | 'response.error' | 'response.cancelled' | 'response.start' | 'content_part.delta' | 'reasoning.delta' | 'function_call.start' | 'function_call.delta' | 'function_call.done' | 'output_item.start' | 'content_part.start' | 'content_part.done' | 'output_item.done' | 'reasoning.start' | 'reasoning.done' | 'required_action' | 'error';
+export interface ResponsesSseEvent extends BaseSseEvent {
+    /** 事件类型（Responses协议使用点分隔符） */
+    type: ResponsesSseEventType;
+    /** 时间戳 */
+    timestamp: number;
+    /** 协议标识 */
+    protocol: 'responses';
+    /** 方向标识 */
+    direction: StreamDirection;
+}
+export interface ResponsesJsonToSseContext {
+    requestId: string;
+    model: string;
+    responsesRequest: ResponsesRequest;
+    options: ResponsesJsonToSseOptions;
+    startTime: number;
+    sequenceCounter: number;
+    outputIndexCounter: number;
+    contentIndexCounter: Map<string, number>;
+    isStreaming: boolean;
+    currentResponse: Partial<ResponsesResponse>;
+    responsesResponse?: ResponsesResponse;
+    eventStats: ResponsesEventStats;
+    outputItemStates: Map<string, OutputItemProcessingState>;
+}
+export interface SseToResponsesJsonContext {
+    requestId: string;
+    model: string;
+    options: SseToResponsesJsonOptions;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    aggregatedEvents: any[];
+    currentResponse: Partial<ResponsesResponse>;
+    outputItemBuilders: Map<string, OutputItemBuilder>;
+    eventStats: ResponsesEventStats;
+    isCompleted: boolean;
+    isResponseCreated: boolean;
+    isInProgress: boolean;
+    lastSequenceNumber: number;
+}
+export interface ResponsesRequest {
+    model: string;
+    input: ResponsesInput[];
+    tools?: ResponsesTool[];
+    temperature?: number;
+    top_p?: number;
+    max_output_tokens?: number;
+    metadata?: Record<string, any>;
+    store?: boolean;
+    truncation?: 'auto' | 'disabled';
+    user?: string;
+    include?: ('user.id' | 'user.name' | 'user.email' | string)[];
+    parallel_tool_calls?: boolean;
+    previous_response_id?: string;
+    reasoning?: ResponsesReasoningConfig;
+    stream?: boolean;
+}
+export interface ResponsesInput {
+    role: 'user' | 'assistant' | 'system';
+    content: ResponsesContent[];
+    name?: string;
+}
+export type ResponsesContent = {
+    type: 'input_text';
+    text: string;
+} | {
+    type: 'output_text';
+    text: string;
+} | {
+    type: 'input_image';
+    image_url: string;
+    detail?: 'auto' | 'low' | 'high';
+} | {
+    type: 'file_search';
+    file_search: any;
+} | {
+    type: 'computer_use';
+    computer_use: any;
+} | {
+    type: 'function_call';
+    name: string;
+    arguments: string;
+} | {
+    type: 'function_result';
+    result: any;
+    tool_call_id: string;
+} | {
+    type: 'conversation';
+    conversation: any[];
+};
+export interface ResponsesTool {
+    type: 'function';
+    name: string;
+    description?: string;
+    parameters?: any;
+    strict?: boolean;
+}
+export interface ResponsesReasoningConfig {
+    max_tokens: number;
+    summarize?: boolean;
+    summarize_threshold?: number;
+}
+export interface ResponsesResponse {
+    id: string;
+    object: 'response';
+    created_at: number;
+    status: 'in_progress' | 'requires_action' | 'completed' | 'failed' | 'incomplete';
+    error?: any;
+    model: string;
+    output: ResponsesOutputItem[];
+    previous_response_id?: string;
+    usage?: ResponsesUsage;
+    temperature?: number;
+    top_p?: number;
+    max_output_tokens?: number;
+    metadata?: Record<string, any>;
+    user?: string;
+    store?: boolean;
+    truncation?: 'auto' | 'disabled';
+    include?: string[];
+    parallel_tool_calls?: boolean;
+}
+export type ResponsesOutputItem = ResponsesMessageItem | ResponsesReasoningItem | ResponsesFunctionCallItem | ResponsesFunctionCallOutputItem | ResponsesSystemItem;
+export interface ResponsesMessageItem {
+    id: string;
+    type: 'message';
+    status: 'in_progress' | 'completed';
+    role: 'assistant';
+    content: ResponsesContent[];
+}
+export interface ResponsesReasoningItem {
+    id: string;
+    type: 'reasoning';
+    summary?: string[];
+    content: ResponsesReasoningContent[];
+}
+export type ResponsesReasoningContent = {
+    type: 'reasoning_text';
+    text: string;
+} | {
+    type: 'reasoning_signature';
+    signature: any;
+} | {
+    type: 'reasoning_image';
+    image_url: string;
+};
+export interface ResponsesFunctionCallItem {
+    id: string;
+    type: 'function_call';
+    status: 'in_progress' | 'completed';
+    call_id: string;
+    name: string;
+    arguments: string;
+}
+export interface ResponsesFunctionCallOutputItem {
+    id: string;
+    type: 'function_call_output';
+    call_id: string;
+    output: any;
+    tool_call_id?: string;
+}
+export interface ResponsesSystemItem {
+    id: string;
+    type: 'system';
+    name: string;
+    data: any;
+}
+export interface ResponsesUsage {
+    input_tokens: number;
+    output_tokens: number;
+    total_tokens: number;
+    input_tokens_details: {
+        cached_tokens: number;
+        audio_tokens: number;
+        text_tokens: number;
+        image_tokens: number;
+    };
+    output_tokens_details: {
+        reasoning_tokens: number;
+        audio_tokens: number;
+        text_tokens: number;
+    };
+}
+export interface ResponsesRequiredAction {
+    type: 'submit_tool_outputs' | 'run_parallel_tools';
+    submit_tool_outputs?: {
+        tool_calls: ResponsesToolCall[];
+    };
+    run_parallel_tools?: {
+        tool_calls: ResponsesToolCall[];
+    };
+}
+export interface ResponsesToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ResponsesJsonToSseOptions {
+    requestId: string;
+    model: string;
+    timeoutMs?: number;
+    enableHeartbeat?: boolean;
+    heartbeatIntervalMs?: number;
+    chunkSize?: number;
+    delayMs?: number;
+    includeSequenceNumbers?: boolean;
+    includeMetadata?: boolean;
+    validationMode?: 'none' | 'basic' | 'strict';
+    onEvent?: (event: any) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+    resumeToolOutputs?: ResponsesFunctionCallOutputItem[];
+}
+export interface SseToResponsesJsonOptions {
+    requestId: string;
+    model: string;
+    timeoutMs?: number;
+    validateEvents?: boolean;
+    enableSequenceValidation?: boolean;
+    accumulateOutputItems?: boolean;
+    onPartialResult?: (partial: Partial<ResponsesResponse>) => void;
+    onEvent?: (event: any) => void;
+    onCompletion?: (final: ResponsesResponse) => void;
+    onError?: (error: Error) => void;
+    onTimeout?: () => void;
+}
+export interface ResponsesEventStats {
+    totalEvents: number;
+    eventTypes: Record<string, number>;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    outputItemsCount: number;
+    contentPartsCount: number;
+    deltaEventsCount: number;
+    reasoningEventsCount: number;
+    functionCallEventsCount: number;
+    messageEventsCount: number;
+    errorCount: number;
+    lastEventTime?: number;
+}
+export interface OutputItemProcessingState {
+    id: string;
+    type: string;
+    status: 'in_progress' | 'completed';
+    contentIndex: number;
+    isContentPartAdded: boolean;
+    accumulatedContent: any[];
+    deltaBuffer: string;
+    isTextStarted: boolean;
+    isTextCompleted: boolean;
+}
+export interface OutputItemBuilder {
+    id: string;
+    type: string;
+    status: 'in_progress' | 'completed';
+    contentParts: any[];
+    currentContentIndex: number;
+    accumulatedContent: any[];
+    hasContentPartAdded: boolean;
+    isTextInProgress: boolean;
+    callId?: string;
+    name?: string;
+    arguments?: string;
+    role?: string;
+}
+export interface ResponsesConversionError extends Error {
+    code: string;
+    requestId: string;
+    eventId?: string;
+    outputItemId?: string;
+    sequenceNumber?: number;
+    context?: any;
+}
+export declare const RESPONSES_CONVERSION_ERROR_CODES: {
+    readonly TIMEOUT: "RESPONSES_TIMEOUT";
+    readonly INVALID_EVENT: "RESPONSES_INVALID_EVENT";
+    readonly SEQUENCE_ERROR: "RESPONSES_SEQUENCE_ERROR";
+    readonly OUTPUT_ITEM_ERROR: "RESPONSES_OUTPUT_ITEM_ERROR";
+    readonly CONTENT_PART_ERROR: "RESPONSES_CONTENT_PART_ERROR";
+    readonly PARSE_ERROR: "RESPONSES_PARSE_ERROR";
+    readonly VALIDATION_ERROR: "RESPONSES_VALIDATION_ERROR";
+    readonly STREAM_ERROR: "RESPONSES_STREAM_ERROR";
+};
+export interface ResponsesConversionConfig {
+    defaultTimeoutMs: number;
+    heartbeatIntervalMs: number;
+    eventTimeoutMs: number;
+    defaultChunkSize: number;
+    defaultDelayMs: number;
+    reasoningChunkSize: number;
+    textChunkSize: number;
+    functionCallChunkSize: number;
+    enableEventValidation: boolean;
+    enableSequenceValidation: boolean;
+    strictMode: boolean;
+    validateOutputItems: boolean;
+    maxConcurrentOutputItems: number;
+    maxConcurrentContentParts: number;
+    eventBufferSize: number;
+    debugMode: boolean;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    enableMetrics: boolean;
+}
+export declare const DEFAULT_RESPONSES_CONVERSION_CONFIG: ResponsesConversionConfig;
+export interface ResponsesSseEventStream extends AsyncIterable<ResponsesSseEvent> {
+    getStats(): ResponsesEventStats;
+    getConfig(): ResponsesConversionConfig;
+    complete(): void;
+    abort(error?: Error): void;
+    on(event: 'error', handler: (error: Error) => void): this;
+    on(event: 'complete', handler: () => void): this;
+    on(event: 'timeout', handler: () => void): this;
+    on(event: 'output_item', handler: (item: ResponsesOutputItem) => void): this;
+    on(event: 'content_part', handler: (part: any) => void): this;
+    on(event: 'stats', handler: (stats: ResponsesEventStats) => void): this;
+}