@jsonstudio/rcc 0.90.352 → 0.90.364

package/vendor/@jsonstudio/llms/dist/sse/types/chat-types.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Chat协议相关类型定义
+ * 支持OpenAI Chat Completions的JSON↔SSE双向转换
+ */
+import type { BaseSseEvent, StreamDirection } from './core-interfaces.js';
+type JsonObject = Record<string, unknown>;
+export type ChatSseEventType = 'chat_chunk' | 'chat.done' | 'error' | 'ping';
+export interface ChatSseEvent extends BaseSseEvent {
+    /** 事件类型（SSE标准wire格式） */
+    event: ChatSseEventType;
+    /** 重写type字段以满足BaseSseEvent要求，与event保持一致 */
+    type: string;
+    /** 时间戳 */
+    timestamp: number;
+    /** 事件ID（SSE标准字段） */
+    id?: string;
+    /** 重试间隔（SSE标准字段） */
+    retry?: number;
+    /** 协议标识 */
+    protocol: 'chat';
+    /** 方向标识 */
+    direction: StreamDirection;
+}
+export interface ChatSseEventWithEventField {
+    id?: string;
+    event: ChatSseEventType;
+    data: string;
+    timestamp?: number;
+    retry?: number;
+    sequenceNumber?: number;
+}
+export interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    system_fingerprint?: string;
+    choices: ChatChoiceChunk[];
+    usage?: ChatUsage;
+}
+export interface ChatChoiceChunk {
+    index: number;
+    delta: ChatDelta;
+    finish_reason?: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call' | null;
+    logprobs?: ChatLogProbs;
+}
+export interface ChatDelta {
+    role?: 'system' | 'user' | 'assistant' | 'tool';
+    content?: string | null;
+    reasoning?: string;
+    function_call?: ChatFunctionCall;
+    tool_calls?: ChatToolCallChunk[];
+}
+export interface ChatFunctionCall {
+    name?: string;
+    arguments?: string;
+}
+export interface ChatToolCallChunk {
+    index: number;
+    id?: string;
+    type?: 'function';
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+}
+export interface ChatLogProbs {
+    content?: ChatTokenLogProb[];
+}
+export interface ChatTokenLogProb {
+    token: string;
+    logprob: number;
+    bytes?: number[];
+    top_logprobs?: ChatTopLogProb[];
+}
+export interface ChatTopLogProb {
+    token: string;
+    logprob: number;
+    bytes?: number[];
+}
+export interface ChatUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+export interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    functions?: ChatFunction[];
+    function_call?: 'auto' | 'none' | {
+        name: string;
+    };
+    tools?: ChatTool[];
+    tool_choice?: 'auto' | 'none' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    temperature?: number;
+    top_p?: number;
+    n?: number;
+    stream?: boolean;
+    stop?: string | string[] | null;
+    max_tokens?: number;
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    logit_bias?: Record<string, number>;
+    user?: string;
+    response_format?: {
+        type: 'text' | 'json_object';
+    };
+    seed?: number;
+}
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content?: string | null;
+    name?: string;
+    reasoning_content?: string;
+    reasoning?: string;
+    function_call?: ChatFunctionCall;
+    tool_calls?: ChatToolCall[];
+    tool_call_id?: string;
+}
+export interface ChatFunction {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+}
+export interface ChatTool {
+    type: 'function';
+    function: ChatFunction;
+}
+export interface ChatToolCall {
+    id: string;
+    type: 'function';
+    function: ChatFunctionCall;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    system_fingerprint?: string;
+    choices: ChatChoice[];
+    usage?: ChatUsage;
+}
+export interface ChatChoice {
+    index: number;
+    message: ChatMessage;
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter' | 'function_call';
+    logprobs?: ChatLogProbs;
+}
+export interface ChatJsonToSseContext {
+    requestId: string;
+    model: string;
+    chatRequest: ChatCompletionRequest;
+    options: ChatJsonToSseOptions;
+    startTime: number;
+    sequenceCounter: number;
+    choiceIndexCounter: number;
+    toolCallIndexCounter: number;
+    isStreaming: boolean;
+    currentChunk: Partial<ChatCompletionChunk>;
+    eventStats: ChatEventStats;
+    contentIndexCounter?: Map<string, number>;
+    currentRequest?: ChatCompletionRequest;
+    currentResponse?: ChatCompletionResponse;
+    chatResponse?: ChatCompletionResponse;
+}
+export interface SseToChatJsonContext {
+    requestId: string;
+    model: string;
+    options: SseToChatJsonOptions;
+    startTime: number;
+    aggregatedChunks: ChatCompletionChunk[];
+    currentResponse: Partial<ChatCompletionResponse>;
+    choiceIndexMap: Map<number, ChatChoiceBuilder>;
+    toolCallIndexMap: Map<number, Map<number, ChatToolCallBuilder>>;
+    eventStats: ChatEventStats;
+    isCompleted: boolean;
+}
+export interface ChatChoiceBuilder {
+    index: number;
+    delta: ChatDelta;
+    finishReason?: ChatChoice['finish_reason'];
+    logprobs?: ChatLogProbs;
+    messageBuilder: ChatMessageBuilder;
+    isCompleted: boolean;
+    accumulatedContent: string;
+    toolCallBuilders: Map<number, ChatToolCallBuilder>;
+}
+export interface ChatMessageBuilder {
+    role?: 'system' | 'user' | 'assistant' | 'tool';
+    content?: string;
+    reasoningContent?: string;
+    name?: string;
+    functionCall?: ChatFunctionCall;
+    toolCalls?: ChatToolCall[];
+    toolCallId?: string;
+    isCompleted: boolean;
+}
+export interface ChatToolCallBuilder {
+    index: number;
+    id?: string;
+    type?: 'function';
+    function?: {
+        name?: string;
+        arguments?: string;
+    };
+    isCompleted: boolean;
+    accumulatedArguments: string;
+}
+export type ChatReasoningMode = 'channel' | 'text' | 'drop';
+export interface ChatJsonToSseOptions {
+    requestId: string;
+    model: string;
+    timeoutMs?: number;
+    enableHeartbeat?: boolean;
+    heartbeatIntervalMs?: number;
+    chunkDelayMs?: number;
+    includeSystemFingerprint?: boolean;
+    includeLogprobs?: boolean;
+    maxTokensPerChunk?: number;
+    validationMode?: 'none' | 'basic' | 'strict';
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+    onChunk?: (chunk: ChatCompletionChunk) => void;
+    onError?: (error: Error) => void;
+    onComplete?: () => void;
+}
+export interface SseToChatJsonOptions {
+    requestId: string;
+    model: string;
+    timeoutMs?: number;
+    validateChunks?: boolean;
+    enableSequenceValidation?: boolean;
+    accumulateToolCalls?: boolean;
+    reasoningMode?: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+    onPartialResponse?: (partial: Partial<ChatCompletionResponse>) => void;
+    onEvent?: (event: ChatSseEvent) => void;
+    onChunk?: (chunk: ChatCompletionChunk) => void;
+    onCompletion?: (final: ChatCompletionResponse) => void;
+    onError?: (error: Error) => void;
+    onTimeout?: () => void;
+}
+export interface ChatEventStats {
+    totalChunks: number;
+    totalTokens: number;
+    totalChoices: number;
+    totalToolCalls: number;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    tokenRate: number;
+    chunkRate: number;
+    errorCount: number;
+    retryCount: number;
+    totalEvents?: number;
+    eventTypes?: Record<string, number>;
+    lastEventTime?: number;
+}
+export interface ChatConversionError extends Error {
+    code: string;
+    requestId: string;
+    chunkId?: string;
+    choiceIndex?: number;
+    toolCallIndex?: number;
+    context?: JsonObject;
+}
+export declare const CHAT_CONVERSION_ERROR_CODES: {
+    readonly TIMEOUT: "CHAT_TIMEOUT";
+    readonly INVALID_CHUNK: "CHAT_INVALID_CHUNK";
+    readonly SEQUENCE_ERROR: "CHAT_SEQUENCE_ERROR";
+    readonly TOOL_CALL_ERROR: "CHAT_TOOL_CALL_ERROR";
+    readonly PARSE_ERROR: "CHAT_PARSE_ERROR";
+    readonly VALIDATION_ERROR: "CHAT_VALIDATION_ERROR";
+    readonly STREAM_ERROR: "CHAT_STREAM_ERROR";
+};
+export interface ChatEventValidationRule {
+    eventType: ChatSseEventType;
+    requiredFields: string[];
+    optionalFields: string[];
+    dataValidation?: {
+        schema?: JsonObject;
+        customValidator?: (data: JsonObject) => boolean;
+    };
+}
+export interface ChatConversionConfig {
+    defaultTimeoutMs: number;
+    heartbeatIntervalMs: number;
+    chunkTimeoutMs: number;
+    defaultChunkDelayMs: number;
+    maxTokensPerChunk: number;
+    maxChunkSize: number;
+    enableChunkValidation: boolean;
+    strictMode: boolean;
+    validateToolCalls: boolean;
+    maxConcurrentChoices: number;
+    maxConcurrentToolCalls: number;
+    eventBufferSize: number;
+    debugMode: boolean;
+    logLevel: 'debug' | 'info' | 'warn' | 'error';
+    enableMetrics: boolean;
+    reasoningMode: ChatReasoningMode;
+    reasoningTextPrefix?: string;
+}
+export declare const DEFAULT_CHAT_CONVERSION_CONFIG: ChatConversionConfig;
+export interface ChatSseEventStream extends AsyncIterable<ChatSseEvent> {
+    getStats(): ChatEventStats;
+    getConfig(): ChatConversionConfig;
+    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: 'chunk', handler: (chunk: ChatCompletionChunk) => void): this;
+    on(event: 'stats', handler: (stats: ChatEventStats) => void): this;
+}
+export {};

package/vendor/@jsonstudio/llms/dist/sse/types/chat-types.js

@@ -0,0 +1,33 @@
+/**
+ * Chat协议相关类型定义
+ * 支持OpenAI Chat Completions的JSON↔SSE双向转换
+ */
+// Chat转换错误代码
+export const CHAT_CONVERSION_ERROR_CODES = {
+    TIMEOUT: 'CHAT_TIMEOUT',
+    INVALID_CHUNK: 'CHAT_INVALID_CHUNK',
+    SEQUENCE_ERROR: 'CHAT_SEQUENCE_ERROR',
+    TOOL_CALL_ERROR: 'CHAT_TOOL_CALL_ERROR',
+    PARSE_ERROR: 'CHAT_PARSE_ERROR',
+    VALIDATION_ERROR: 'CHAT_VALIDATION_ERROR',
+    STREAM_ERROR: 'CHAT_STREAM_ERROR'
+};
+// 默认Chat转换配置
+export const DEFAULT_CHAT_CONVERSION_CONFIG = {
+    defaultTimeoutMs: 30000,
+    heartbeatIntervalMs: 15000,
+    chunkTimeoutMs: 5000,
+    defaultChunkDelayMs: 10,
+    maxTokensPerChunk: 100,
+    maxChunkSize: 1024,
+    enableChunkValidation: true,
+    strictMode: false,
+    validateToolCalls: true,
+    maxConcurrentChoices: 10,
+    maxConcurrentToolCalls: 50,
+    eventBufferSize: 1000,
+    debugMode: false,
+    logLevel: 'info',
+    enableMetrics: true,
+    reasoningMode: 'channel'
+};

package/vendor/@jsonstudio/llms/dist/sse/types/conversion-context.d.ts

@@ -0,0 +1,214 @@
+/**
+ * 转换上下文类型定义
+ * 定义JSON<>SSE双向转换过程中的上下文信息
+ */
+import type { JsonObject, JsonValue } from './core-interfaces.js';
+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;
+}
+type ConversionContextUnion = JsonToSseContext | SseToJsonContext;
+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;
+}
+type LoggerMetadata = Record<string, unknown>;
+export interface ConversionLogger {
+    debug(message: string, meta?: LoggerMetadata): void;
+    info(message: string, meta?: LoggerMetadata): void;
+    warn(message: string, meta?: LoggerMetadata): void;
+    error(message: string, error?: Error, meta?: LoggerMetadata): void;
+    event(eventType: string, data?: LoggerMetadata): 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?: JsonObject;
+}
+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: ConversionContextUnion): Promise<void>;
+}
+export interface ConversionMiddleware {
+    name: string;
+    beforeConversion?: (context: ConversionContextUnion) => Promise<void>;
+    afterConversion?: (context: ConversionContextUnion, result: unknown) => Promise<void>;
+    onError?: (context: ConversionContextUnion, error: Error) => Promise<void>;
+}
+interface OutputItem {
+    id: string;
+    type: 'reasoning' | 'message' | 'function_call' | 'system_message';
+    status?: 'in_progress' | 'completed';
+    content?: ContentPart[];
+    summary?: JsonValue[];
+    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/vendor/@jsonstudio/llms/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/vendor/@jsonstudio/llms/dist/sse/types/core-interfaces.d.ts

@@ -0,0 +1,94 @@
+/**
+ * 核心接口定义
+ * 统一的SSE事件最小接口，供writer.ts等共享模块使用
+ */
+export interface JsonObject {
+    [key: string]: JsonValue;
+}
+export type JsonValue = string | number | boolean | null | JsonObject | JsonValue[];
+export interface BaseSseEvent {
+    /** 事件类型 */
+    type: string;
+    /** 事件时间戳 */
+    timestamp: number;
+    /** 事件数据 */
+    data: unknown;
+    /** 序列号（可选） */
+    sequenceNumber?: number;
+    /** 协议标识 */
+    protocol?: StreamProtocol;
+    /** 方向标识 */
+    direction?: StreamDirection;
+}
+export type StreamProtocol = 'chat' | 'responses' | 'anthropic-messages' | 'gemini-chat';
+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: JsonObject;
+    /** 开始时间 */
+    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/vendor/@jsonstudio/llms/dist/sse/types/core-interfaces.js

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