@jsonstudio/llms 0.6.802 → 0.6.938

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

@@ -0,0 +1,55 @@
+/**
+ * Chat协议事件生成器
+ * 提供纯函数，将Chat响应数据转换为SSE事件对象，不处理流写入
+ */
+import type { 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/sse/json-to-sse/event-generators/responses.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Responses协议事件生成器
+ * 提供纯函数，将Responses响应数据转换为SSE事件对象，不处理流写入
+ */
+import type { 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;

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

@@ -1,5 +1,6 @@
 import { PassThrough } from 'node:stream';
-import { GeminiResponse, GeminiJsonToSseOptions, DEFAULT_GEMINI_CONVERSION_CONFIG } from '../types/index.js';
+import { DEFAULT_GEMINI_CONVERSION_CONFIG } from '../types/index.js';
+import type { GeminiResponse, GeminiJsonToSseOptions } from '../types/index.js';
 export declare class GeminiJsonToSseConverter {
     private config;
     private contexts;

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

@@ -0,0 +1,80 @@
+/**
+ * Responses JSON → SSE转换器（重构版本）
+ * 使用函数化架构：事件生成 + 序列化 + 写入分离
+ */
+import { DEFAULT_RESPONSES_CONVERSION_CONFIG } from '../types/index.js';
+import type { ResponsesRequest, ResponsesResponse, ResponsesJsonToSseContext, ResponsesJsonToSseOptions, ResponsesSseEventStream } from '../types/index.js';
+/**
+ * 重构后的Responses JSON到SSE转换器
+ * 采用函数化架构，专注于编排而非具体业务逻辑
+ */
+export declare class ResponsesJsonToSseConverterRefactored {
+    private config;
+    private contexts;
+    constructor(config?: Partial<typeof DEFAULT_RESPONSES_CONVERSION_CONFIG>);
+    /**
+     * 将Responses请求转换为SSE流
+     */
+    convertRequestToJsonToSse(request: ResponsesRequest, options: ResponsesJsonToSseOptions): Promise<ResponsesSseEventStream>;
+    /**
+     * 将Responses响应转换为SSE流
+     */
+    convertResponseToJsonToSse(response: ResponsesResponse, options: ResponsesJsonToSseOptions): Promise<ResponsesSseEventStream>;
+    /**
+     * 使用函数化架构处理请求转换
+     */
+    private processRequestToSseWithFunctions;
+    /**
+     * 使用函数化架构处理响应转换
+     */
+    private processResponseToSseWithFunctions;
+    /**
+     * 验证请求格式
+     */
+    private validateRequest;
+    /**
+     * 验证响应格式
+     */
+    private validateResponse;
+    /**
+     * 更新统计信息
+     */
+    private updateStats;
+    /**
+     * 包装错误
+     */
+    private wrapError;
+    /**
+     * 处理流错误
+     */
+    private handleStreamError;
+    /**
+     * 完成流
+     */
+    private completeStream;
+    /**
+     * 中止流
+     */
+    private abortStream;
+    /**
+     * 创建请求上下文
+     */
+    private createRequestContext;
+    /**
+     * 创建响应上下文
+     */
+    private createResponseContext;
+    /**
+     * 获取上下文
+     */
+    getContext(requestId: string): ResponsesJsonToSseContext | undefined;
+    /**
+     * 清理上下文
+     */
+    clearContext(requestId: string): void;
+    /**
+     * 获取所有活跃的上下文
+     */
+    getActiveContexts(): Map<string, ResponsesJsonToSseContext>;
+}
+export declare const ResponsesJsonToSseConverter: typeof ResponsesJsonToSseConverterRefactored;

package/dist/sse/json-to-sse/sequencers/anthropic-sequencer.d.ts

@@ -1,4 +1,4 @@
-import { AnthropicMessageResponse, AnthropicSseEvent } from '../../types/index.js';
+import type { AnthropicMessageResponse, AnthropicSseEvent } from '../../types/index.js';
 import type { ChatReasoningMode } from '../../types/chat-types.js';
 export interface AnthropicSequencerConfig {
     chunkSize: number;

package/dist/sse/json-to-sse/sequencers/chat-sequencer.d.ts

@@ -2,8 +2,8 @@
  * Chat协议事件编排器
  * 负责严格的事件时序组合：role → content OR tool_calls(name → args.delta*) → finish_reason → done
  */
-import { ChatCompletionResponse, ChatReasoningMode, ChatSseEvent } from '../../types/index.js';
-import { ChatEventGeneratorContext, ChatEventGeneratorConfig } from '../event-generators/chat.js';
+import type { ChatCompletionResponse, ChatReasoningMode, ChatSseEvent } from '../../types/index.js';
+import type { ChatEventGeneratorContext, ChatEventGeneratorConfig } from '../event-generators/chat.js';
 export interface ChatSequencerConfig extends ChatEventGeneratorConfig {
     includeSequenceNumbers: boolean;
     enableDelay: boolean;

package/dist/sse/json-to-sse/sequencers/gemini-sequencer.d.ts

@@ -1,4 +1,4 @@
-import { GeminiResponse, GeminiSseEvent } from '../../types/index.js';
+import type { GeminiResponse, GeminiSseEvent } from '../../types/index.js';
 import type { ChatReasoningMode } from '../../types/chat-types.js';
 export interface GeminiSequencerConfig {
     chunkDelayMs: number;

package/dist/sse/json-to-sse/sequencers/responses-sequencer.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Responses协议事件编排器
+ * 负责将Responses响应数据转换为有序的SSE事件流
+ */
+import type { ResponsesResponse, ResponsesFunctionCallOutputItem, ResponsesSseEvent } from '../../types/index.js';
+import type { ResponsesEventGeneratorContext, ResponsesEventGeneratorConfig } from '../event-generators/responses.js';
+export interface ResponsesSequencerConfig extends ResponsesEventGeneratorConfig {
+    enableValidation: boolean;
+    enableRecovery: boolean;
+    enableDelay: boolean;
+    maxOutputItems: number;
+    maxContentParts: number;
+    submittedToolOutputs?: ResponsesFunctionCallOutputItem[];
+}
+export declare const DEFAULT_RESPONSES_SEQUENCER_CONFIG: ResponsesSequencerConfig;
+/**
+ * 主编排器：将Responses响应转换为有序的SSE事件流
+ */
+export declare function sequenceResponse(response: ResponsesResponse, context: ResponsesEventGeneratorContext, config?: ResponsesSequencerConfig): AsyncGenerator<ResponsesSseEvent>;
+/**
+ * 序列化Responses请求（用于请求→SSE转换）
+ */
+export declare function sequenceRequest(request: any, context: ResponsesEventGeneratorContext, config?: ResponsesSequencerConfig): AsyncGenerator<ResponsesSseEvent>;
+/**
+ * 创建Responses事件序列化器工厂
+ */
+export declare function createResponsesSequencer(config?: Partial<ResponsesSequencerConfig>): {
+    /**
+     * 序列化响应
+     */
+    sequenceResponse(response: ResponsesResponse, requestId: string): AsyncGenerator<ResponsesSseEvent, void, any>;
+    /**
+     * 序列化请求
+     */
+    sequenceRequest(request: any, requestId: string): AsyncGenerator<ResponsesSseEvent, void, any>;
+    /**
+     * 获取当前配置
+     */
+    getConfig(): ResponsesSequencerConfig;
+};

package/dist/sse/shared/chat-serializer.d.ts

@@ -0,0 +1,4 @@
+import { PassThrough, Readable } from 'node:stream';
+import type { ChatSseEvent } from '../types/index.js';
+export declare function serializeChatEventToSSE(evt: ChatSseEvent): string;
+export declare function toSSETextStream(objectEventStream: Readable): PassThrough;

package/dist/sse/shared/constants.d.ts

@@ -0,0 +1,272 @@
+/**
+ * 共享常量定义
+ * 定义JSON↔SSE双向转换中使用的常量
+ */
+export declare const PROTOCOL_TYPES: {
+    readonly CHAT: "chat";
+    readonly RESPONSES: "responses";
+};
+export declare const CONVERSION_DIRECTIONS: {
+    readonly JSON_TO_SSE: "json_to_sse";
+    readonly SSE_TO_JSON: "sse_to_json";
+};
+export declare const TIMEOUT_CONSTANTS: {
+    readonly DEFAULT_TIMEOUT_MS: 30000;
+    readonly HEARTBEAT_INTERVAL_MS: 15000;
+    readonly INACTIVITY_TIMEOUT_MS: 60000;
+    readonly EVENT_PROCESSING_TIMEOUT_MS: 5000;
+    readonly CHUNK_TIMEOUT_MS: 10000;
+    readonly TOTAL_TIMEOUT_MS: 300000;
+};
+export declare const CHUNK_CONSTANTS: {
+    readonly DEFAULT_CHUNK_SIZE: 12;
+    readonly DEFAULT_DELAY_MS: 8;
+    readonly REASONING_CHUNK_SIZE: 24;
+    readonly TEXT_CHUNK_SIZE: 12;
+    readonly FUNCTION_CALL_CHUNK_SIZE: 24;
+    readonly MAX_CHUNK_SIZE: 1024;
+    readonly MIN_CHUNK_SIZE: 1;
+};
+export declare const BUFFER_CONSTANTS: {
+    readonly DEFAULT_BUFFER_SIZE: 1000;
+    readonly MAX_BUFFER_SIZE: 10000;
+    readonly HIGH_WATER_MARK: 8000;
+    readonly LOW_WATER_MARK: 2000;
+    readonly BACKPRESSURE_THRESHOLD: 0.8;
+};
+export declare const RETRY_CONSTANTS: {
+    readonly DEFAULT_MAX_RETRIES: 3;
+    readonly INITIAL_DELAY_MS: 1000;
+    readonly MAX_DELAY_MS: 30000;
+    readonly BACKOFF_MULTIPLIER: 2;
+    readonly JITTER_FACTOR: 0.1;
+};
+export declare const VALIDATION_CONSTANTS: {
+    readonly MAX_SEQUENCE_NUMBER: 10000;
+    readonly MAX_OUTPUT_ITEMS: 100;
+    readonly MAX_CONTENT_PARTS: 1000;
+    readonly MAX_TOOL_CALLS: 50;
+    readonly MAX_MESSAGE_LENGTH: 1000000;
+    readonly MAX_ARGUMENTS_LENGTH: 100000;
+};
+export declare const ERROR_CODES: {
+    readonly TIMEOUT: "TIMEOUT";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly PARSE_ERROR: "PARSE_ERROR";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly STREAM_ERROR: "STREAM_ERROR";
+    readonly CHAT_TIMEOUT: "CHAT_TIMEOUT";
+    readonly CHAT_INVALID_CHUNK: "CHAT_INVALID_CHUNK";
+    readonly CHAT_SEQUENCE_ERROR: "CHAT_SEQUENCE_ERROR";
+    readonly CHAT_TOOL_CALL_ERROR: "CHAT_TOOL_CALL_ERROR";
+    readonly CHAT_PARSE_ERROR: "CHAT_PARSE_ERROR";
+    readonly CHAT_VALIDATION_ERROR: "CHAT_VALIDATION_ERROR";
+    readonly CHAT_STREAM_ERROR: "CHAT_STREAM_ERROR";
+    readonly RESPONSES_TIMEOUT: "RESPONSES_TIMEOUT";
+    readonly RESPONSES_INVALID_EVENT: "RESPONSES_INVALID_EVENT";
+    readonly RESPONSES_SEQUENCE_ERROR: "RESPONSES_SEQUENCE_ERROR";
+    readonly RESPONSES_OUTPUT_ITEM_ERROR: "RESPONSES_OUTPUT_ITEM_ERROR";
+    readonly RESPONSES_CONTENT_PART_ERROR: "RESPONSES_CONTENT_PART_ERROR";
+    readonly RESPONSES_PARSE_ERROR: "RESPONSES_PARSE_ERROR";
+    readonly RESPONSES_VALIDATION_ERROR: "RESPONSES_VALIDATION_ERROR";
+    readonly RESPONSES_STREAM_ERROR: "RESPONSES_STREAM_ERROR";
+};
+export declare const STREAM_STATUS: {
+    readonly IDLE: "idle";
+    readonly STARTING: "starting";
+    readonly ACTIVE: "active";
+    readonly PAUSED: "paused";
+    readonly COMPLETING: "completing";
+    readonly COMPLETED: "completed";
+    readonly ERROR: "error";
+    readonly TIMEOUT: "timeout";
+    readonly ABORTED: "aborted";
+};
+export declare const CHAT_EVENT_TYPES: {
+    readonly CHUNK: "chat_chunk";
+    readonly DONE: "chat.done";
+    readonly ERROR: "error";
+    readonly PING: "ping";
+};
+export declare const RESPONSES_EVENT_TYPES: {
+    readonly RESPONSE_CREATED: "response.created";
+    readonly RESPONSE_IN_PROGRESS: "response.in_progress";
+    readonly RESPONSE_COMPLETED: "response.completed";
+    readonly RESPONSE_REQUIRED_ACTION: "response.required_action";
+    readonly RESPONSE_DONE: "response.done";
+    readonly OUTPUT_ITEM_ADDED: "response.output_item.added";
+    readonly OUTPUT_ITEM_DONE: "response.output_item.done";
+    readonly CONTENT_PART_ADDED: "response.content_part.added";
+    readonly CONTENT_PART_DONE: "response.content_part.done";
+    readonly OUTPUT_TEXT_DELTA: "response.output_text.delta";
+    readonly OUTPUT_TEXT_DONE: "response.output_text.done";
+    readonly REASONING_TEXT_DELTA: "response.reasoning_text.delta";
+    readonly REASONING_TEXT_DONE: "response.reasoning_text.done";
+    readonly FUNCTION_CALL_ARGUMENTS_DELTA: "response.function_call_arguments.delta";
+    readonly FUNCTION_CALL_ARGUMENTS_DONE: "response.function_call_arguments.done";
+};
+export declare const OUTPUT_ITEM_TYPES: {
+    readonly REASONING: "reasoning";
+    readonly MESSAGE: "message";
+    readonly FUNCTION_CALL: "function_call";
+    readonly SYSTEM_MESSAGE: "system_message";
+    readonly FUNCTION_CALL_OUTPUT: "function_call_output";
+};
+export declare const CONTENT_PART_TYPES: {
+    readonly REASONING_TEXT: "reasoning_text";
+    readonly REASONING_SIGNATURE: "reasoning_signature";
+    readonly REASONING_IMAGE: "reasoning_image";
+    readonly OUTPUT_TEXT: "output_text";
+    readonly INPUT_TEXT: "input_text";
+    readonly INPUT_IMAGE: "input_image";
+    readonly COMMENTARY: "commentary";
+};
+export declare const TOOL_CALL_TYPES: {
+    readonly FUNCTION: "function";
+};
+export declare const RESPONSE_STATUS: {
+    readonly IN_PROGRESS: "in_progress";
+    readonly REQUIRES_ACTION: "requires_action";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly INCOMPLETE: "incomplete";
+};
+export declare const FINISH_REASONS: {
+    readonly STOP: "stop";
+    readonly LENGTH: "length";
+    readonly TOOL_CALLS: "tool_calls";
+    readonly CONTENT_FILTER: "content_filter";
+    readonly FUNCTION_CALL: "function_call";
+};
+export declare const REQUIRED_ACTION_TYPES: {
+    readonly SUBMIT_TOOL_OUTPUTS: "submit_tool_outputs";
+    readonly RUN_PARALLEL_TOOLS: "run_parallel_tools";
+};
+export declare const DEFAULT_CONFIG: {
+    readonly TIMEOUT_MS: 30000;
+    readonly HEARTBEAT_INTERVAL_MS: 15000;
+    readonly CHUNK_SIZE: 12;
+    readonly DELAY_MS: 8;
+    readonly VALIDATION_MODE: "basic";
+    readonly DEBUG_MODE: false;
+    readonly CHAT: {
+        readonly TIMEOUT_MS: 30000;
+        readonly HEARTBEAT_INTERVAL_MS: 15000;
+        readonly CHUNK_DELAY_MS: 10;
+        readonly MAX_TOKENS_PER_CHUNK: 100;
+        readonly VALIDATE_CHUNKS: true;
+        readonly STRICT_MODE: false;
+        readonly VALIDATE_TOOL_CALLS: true;
+        readonly MAX_CONCURRENT_CHOICES: 10;
+        readonly MAX_CONCURRENT_TOOL_CALLS: 50;
+    };
+    readonly RESPONSES: {
+        readonly TIMEOUT_MS: 30000;
+        readonly HEARTBEAT_INTERVAL_MS: 15000;
+        readonly REASONING_CHUNK_SIZE: 24;
+        readonly TEXT_CHUNK_SIZE: 12;
+        readonly FUNCTION_CALL_CHUNK_SIZE: 24;
+        readonly ENABLE_EVENT_VALIDATION: true;
+        readonly ENABLE_SEQUENCE_VALIDATION: true;
+        readonly STRICT_MODE: false;
+        readonly VALIDATE_OUTPUT_ITEMS: true;
+        readonly MAX_CONCURRENT_OUTPUT_ITEMS: 10;
+        readonly MAX_CONCURRENT_CONTENT_PARTS: 50;
+    };
+};
+export declare const ENV_KEYS: {
+    readonly SSE_DEFAULT_TIMEOUT_MS: "SSE_DEFAULT_TIMEOUT_MS";
+    readonly SSE_HEARTBEAT_INTERVAL_MS: "SSE_HEARTBEAT_INTERVAL_MS";
+    readonly SSE_INACTIVITY_TIMEOUT_MS: "SSE_INACTIVITY_TIMEOUT_MS";
+    readonly SSE_EVENT_PROCESSING_TIMEOUT_MS: "SSE_EVENT_PROCESSING_TIMEOUT_MS";
+    readonly SSE_DEFAULT_CHUNK_SIZE: "SSE_DEFAULT_CHUNK_SIZE";
+    readonly SSE_DEFAULT_DELAY_MS: "SSE_DEFAULT_DELAY_MS";
+    readonly SSE_REASONING_CHUNK_SIZE: "SSE_REASONING_CHUNK_SIZE";
+    readonly SSE_TEXT_CHUNK_SIZE: "SSE_TEXT_CHUNK_SIZE";
+    readonly SSE_ARGS_CHUNK_SIZE: "SSE_ARGS_CHUNK_SIZE";
+    readonly SSE_ARGS_DELAY_MS: "SSE_ARGS_DELAY_MS";
+    readonly SSE_MAX_BUFFER_SIZE: "SSE_MAX_BUFFER_SIZE";
+    readonly SSE_HIGH_WATER_MARK: "SSE_HIGH_WATER_MARK";
+    readonly SSE_LOW_WATER_MARK: "SSE_LOW_WATER_MARK";
+    readonly SSE_ENABLE_VALIDATION: "SSE_ENABLE_VALIDATION";
+    readonly SSE_ENABLE_SEQUENCE_VALIDATION: "SSE_ENABLE_SEQUENCE_VALIDATION";
+    readonly SSE_MAX_SEQUENCE_NUMBER: "SSE_MAX_SEQUENCE_NUMBER";
+    readonly SSE_STRICT_MODE: "SSE_STRICT_MODE";
+    readonly SSE_DEBUG_EVENTS: "SSE_DEBUG_EVENTS";
+    readonly SSE_DEBUG_MODE: "SSE_DEBUG_MODE";
+    readonly SSE_LOG_LEVEL: "SSE_LOG_LEVEL";
+    readonly SSE_ENABLE_METRICS: "SSE_ENABLE_METRICS";
+    readonly RCC_STREAM_HEARTBEAT: "RCC_STREAM_HEARTBEAT";
+    readonly RCC_STREAM_PRE_HEARTBEAT: "RCC_STREAM_PRE_HEARTBEAT";
+    readonly RCC_RESP_GENERIC_ONMESSAGE: "RCC_RESP_GENERIC_ONMESSAGE";
+    readonly LMSTUDIO_BASE_URL: "LMSTUDIO_BASEURL";
+    readonly LMSTUDIO_API_KEY: "LMSTUDIO_API_KEY";
+};
+export declare const HTTP_STATUS_CODES: {
+    readonly OK: 200;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly TIMEOUT: 408;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+};
+export declare const CONTENT_TYPES: {
+    readonly JSON: "application/json";
+    readonly SSE: "text/event-stream";
+    readonly TEXT: "text/plain";
+    readonly HTML: "text/html";
+};
+export declare const SSE_FIELDS: {
+    readonly EVENT: "event";
+    readonly DATA: "data";
+    readonly ID: "id";
+    readonly RETRY: "retry";
+};
+export declare const STANDARD_SSE_EVENTS: {
+    readonly OPEN: "open";
+    readonly MESSAGE: "message";
+    readonly ERROR: "error";
+    readonly CLOSE: "close";
+};
+export declare const CACHE_PREFIXES: {
+    readonly CONVERSION: "conversion:";
+    readonly VALIDATION: "validation:";
+    readonly METRICS: "metrics:";
+    readonly CONFIG: "config:";
+};
+export declare const METRIC_NAMES: {
+    readonly CONVERSION_REQUESTS_TOTAL: "conversion_requests_total";
+    readonly CONVERSION_ERRORS_TOTAL: "conversion_errors_total";
+    readonly EVENTS_PROCESSED_TOTAL: "events_processed_total";
+    readonly TIMEOUTS_TOTAL: "timeouts_total";
+    readonly CONVERSION_DURATION_SECONDS: "conversion_duration_seconds";
+    readonly EVENT_PROCESSING_DURATION_SECONDS: "event_processing_duration_seconds";
+    readonly BUFFER_SIZE_BYTES: "buffer_size_bytes";
+    readonly ACTIVE_CONVERSIONS: "active_conversions";
+    readonly BUFFER_UTILIZATION_RATIO: "buffer_utilization_ratio";
+    readonly ERROR_RATE: "error_rate";
+};
+export declare const LOG_LEVELS: {
+    readonly DEBUG: "debug";
+    readonly INFO: "info";
+    readonly WARN: "warn";
+    readonly ERROR: "error";
+};
+export declare const REGEX_PATTERNS: {
+    readonly WORD_BOUNDARY: RegExp;
+    readonly SENTENCE_BOUNDARY: RegExp;
+    readonly PARAGRAPH_BOUNDARY: RegExp;
+    readonly JSON_STRING: RegExp;
+    readonly SSE_LINE: RegExp;
+    readonly SSE_DATA_LINE: RegExp;
+    readonly REQUEST_ID: RegExp;
+    readonly RESPONSE_ID: RegExp;
+    readonly ITEM_ID: RegExp;
+    readonly CALL_ID: RegExp;
+};

package/dist/sse/shared/serializers/anthropic-event-serializer.d.ts

@@ -1,2 +1,2 @@
-import { AnthropicSseEvent } from '../../types/index.js';
+import type { AnthropicSseEvent } from '../../types/index.js';
 export declare function serializeAnthropicEventToSSE(event: AnthropicSseEvent): string;