@jsonstudio/llms 0.4.2 → 0.4.4

package/dist/sse/types/stream-state.d.ts

@@ -2,6 +2,7 @@
  * 流状态管理类型定义
  * 管理JSON↔SSE双向转换过程中的流状态
  */
+import type { JsonToSseOptions, ResponsesJson, ResponsesPartialJson, SseToJsonOptions } from './conversion-context.js';
 import { SseEvent, SseEventType } from './sse-events.js';
 export declare enum StreamState {
     IDLE = "idle",
@@ -33,8 +34,8 @@ export interface BaseStreamState {
 }
 export interface JsonToSseStreamState extends BaseStreamState {
     direction: StreamDirection.JSON_TO_SSE;
-    inputJson: any;
-    options: any;
+    inputJson: ResponsesJson;
+    options: JsonToSseOptions;
     currentOutputIndex: number;
     currentSequenceNumber: number;
     outputItemsGenerated: number;
@@ -47,7 +48,7 @@ export interface JsonToSseStreamState extends BaseStreamState {
 }
 export interface SseToJsonStreamState extends BaseStreamState {
     direction: StreamDirection.SSE_TO_JSON;
-    options: any;
+    options: SseToJsonOptions;
     expectedEventTypes: Set<SseEventType>;
     receivedEventTypes: Set<SseEventType>;
     lastSequenceNumber: number;
@@ -57,7 +58,7 @@ export interface SseToJsonStreamState extends BaseStreamState {
     isResponseCompleted: boolean;
     isRequiredActionReceived: boolean;
     aggregatedEvents: SseEvent[];
-    partialJson: any;
+    partialJson: ResponsesPartialJson;
 }
 export interface StreamStatistics {
     duration: number;
@@ -120,56 +121,50 @@ export interface StreamConfig {
     gcThreshold: number;
 }
 export declare const DEFAULT_STREAM_CONFIG: StreamConfig;
-export interface StreamEvent {
+export interface StreamEvent<TPayload = unknown> {
     type: 'state_change' | 'error' | 'timeout' | 'metrics' | 'heartbeat' | 'completion';
     timestamp: number;
     requestId: string;
-    data: any;
+    data: TPayload;
 }
-export interface StateChangeEvent extends StreamEvent {
+export interface StateChangeEvent extends StreamEvent<{
+    oldState: StreamState;
+    newState: StreamState;
+    reason?: string;
+}> {
     type: 'state_change';
-    data: {
-        oldState: StreamState;
-        newState: StreamState;
-        reason?: string;
-    };
 }
-export interface StreamErrorEvent extends StreamEvent {
+export interface StreamErrorEvent extends StreamEvent<{
+    error: Error;
+    eventType?: SseEventType;
+    sequenceNumber?: number;
+    recoverable: boolean;
+}> {
     type: 'error';
-    data: {
-        error: Error;
-        eventType?: SseEventType;
-        sequenceNumber?: number;
-        recoverable: boolean;
-    };
 }
-export interface StreamTimeoutEvent extends StreamEvent {
+export interface StreamTimeoutEvent extends StreamEvent<{
+    timeoutType: 'idle' | 'total' | 'heartbeat' | 'event_processing';
+    timeoutDuration: number;
+    lastActivityTime: number;
+}> {
     type: 'timeout';
-    data: {
-        timeoutType: 'idle' | 'total' | 'heartbeat' | 'event_processing';
-        timeoutDuration: number;
-        lastActivityTime: number;
-    };
 }
-export interface StreamMetricsEvent extends StreamEvent {
+export interface StreamMetricsEvent extends StreamEvent<StreamStatistics> {
     type: 'metrics';
-    data: StreamStatistics;
 }
-export interface StreamHeartbeatEvent extends StreamEvent {
+export interface StreamHeartbeatEvent extends StreamEvent<{
+    interval: number;
+    eventsSinceLastHeartbeat: number;
+}> {
     type: 'heartbeat';
-    data: {
-        interval: number;
-        eventsSinceLastHeartbeat: number;
-    };
 }
-export interface StreamCompletionEvent extends StreamEvent {
+export interface StreamCompletionEvent extends StreamEvent<{
+    finalState: StreamState;
+    totalEvents: number;
+    totalDuration: number;
+    success: boolean;
+}> {
     type: 'completion';
-    data: {
-        finalState: StreamState;
-        totalEvents: number;
-        totalDuration: number;
-        success: boolean;
-    };
 }
 export type StreamEventData = StateChangeEvent | StreamErrorEvent | StreamTimeoutEvent | StreamMetricsEvent | StreamHeartbeatEvent | StreamCompletionEvent;
 export interface StreamStateListener {

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

@@ -2,6 +2,7 @@
  * 工具类型定义
  * 提供JSON↔SSE双向转换中常用的工具类型和辅助函数
  */
+import type { JsonObject, JsonValue } from './core-interfaces.js';
 export type ProtocolType = 'chat' | 'responses';
 export type ConversionDirection = 'json_to_sse' | 'sse_to_json';
 export interface EventTypeMap {
@@ -17,9 +18,9 @@ export interface EventTypeMap {
 export interface GenericConverter<TProtocol extends ProtocolType, TDirection extends ConversionDirection> {
     protocol: TProtocol;
     direction: TDirection;
-    convert(input: any, options: any): Promise<any>;
-    validate?(input: any): boolean;
-    getStats?(): any;
+    convert(input: unknown, options: JsonObject): Promise<unknown>;
+    validate?(input: unknown): boolean;
+    getStats?(): JsonObject;
 }
 export interface UnifiedConversionOptions {
     requestId: string;
@@ -34,12 +35,12 @@ export interface UnifiedConversionOptions {
     onError?: (error: Error) => void;
     onComplete?: () => void;
 }
-export interface UnifiedEventStream extends AsyncIterable<any> {
+export interface UnifiedEventStream extends AsyncIterable<unknown> {
     protocol: ProtocolType;
     direction: ConversionDirection;
     requestId: string;
-    getStats(): any;
-    getConfig(): any;
+    getStats(): JsonObject;
+    getConfig(): JsonObject;
     pause?(): void;
     resume?(): void;
     complete(): void;
@@ -47,7 +48,7 @@ export interface UnifiedEventStream extends AsyncIterable<any> {
     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: any) => void): this;
+    on?(event: 'stats', handler: (stats: JsonObject) => void): this;
 }
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type RequireKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
@@ -58,8 +59,8 @@ export interface ChatJsonType {
     object: 'chat.completion' | 'chat.completion.chunk';
     created: number;
     model: string;
-    choices: any[];
-    usage?: any;
+    choices: unknown[];
+    usage?: JsonObject;
 }
 export type ChatSseEventType = 'chat_chunk' | 'chat.done' | 'error' | 'ping';
 export interface ResponsesJsonType {
@@ -68,11 +69,11 @@ export interface ResponsesJsonType {
     created_at: number;
     model: string;
     status: string;
-    output: any[];
-    usage?: any;
+    output: unknown[];
+    usage?: JsonObject;
 }
 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.function_call_arguments.delta' | 'response.function_call_arguments.done';
-export interface ConversionResult<TSuccess = any, TError = Error> {
+export interface ConversionResult<TSuccess = unknown, TError = Error> {
     success: boolean;
     data?: TSuccess;
     error?: TError;
@@ -84,7 +85,7 @@ export interface ConversionResult<TSuccess = any, TError = Error> {
         direction: ConversionDirection;
     };
 }
-export type AsyncConversionResult<TSuccess = any, TError = Error> = Promise<ConversionResult<TSuccess, TError>>;
+export type AsyncConversionResult<TSuccess = unknown, TError = Error> = Promise<ConversionResult<TSuccess, TError>>;
 export interface ConverterFactory {
     createJsonToSseConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'json_to_sse'>;
     createSseToJsonConverter<TProtocol extends ProtocolType>(protocol: TProtocol, options: UnifiedConversionOptions): GenericConverter<TProtocol, 'sse_to_json'>;
@@ -95,7 +96,7 @@ export interface ConverterRegistry {
     list(): Array<{
         protocol: ProtocolType;
         direction: ConversionDirection;
-        converter: GenericConverter<any, any>;
+        converter: GenericConverter<ProtocolType, ConversionDirection>;
     }>;
 }
 export interface Validator<T> {
@@ -112,13 +113,13 @@ export interface ValidationError {
     code: string;
     message: string;
     path: string;
-    value?: any;
+    value?: JsonValue;
 }
 export interface ValidationWarning {
     code: string;
     message: string;
     path: string;
-    value?: any;
+    value?: JsonValue;
 }
 export interface Serializer<T> {
     serialize(input: T): string;
@@ -138,14 +139,15 @@ export interface MetricsCollector {
     recordHistogram(name: string, value: number, tags?: Record<string, string>): void;
     setGauge(name: string, value: number, tags?: Record<string, string>): void;
     recordTimer(name: string, duration: number, tags?: Record<string, string>): void;
-    getMetrics(): Record<string, any>;
+    getMetrics(): Record<string, unknown>;
 }
+type LoggerMetadata = Record<string, unknown>;
 export interface Logger {
-    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;
-    child(meta: any): Logger;
+    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;
+    child(meta: LoggerMetadata): Logger;
 }
 export interface RetryConfig {
     maxAttempts: number;
@@ -175,26 +177,27 @@ export interface HealthCheck {
 export interface HealthStatus {
     healthy: boolean;
     timestamp: number;
-    details?: Record<string, any>;
+    details?: Record<string, unknown>;
 }
+type LifecycleContext = Record<string, unknown>;
 export interface LifecycleHooks {
-    beforeConversion?: (context: any) => Promise<void>;
-    afterConversion?: (context: any, result: any) => Promise<void>;
-    onError?: (context: any, error: Error) => Promise<void>;
-    onTimeout?: (context: any) => Promise<void>;
-    onRetry?: (context: any, attempt: number) => Promise<void>;
+    beforeConversion?: (context: LifecycleContext) => Promise<void>;
+    afterConversion?: (context: LifecycleContext, result: unknown) => Promise<void>;
+    onError?: (context: LifecycleContext, error: Error) => Promise<void>;
+    onTimeout?: (context: LifecycleContext) => Promise<void>;
+    onRetry?: (context: LifecycleContext, attempt: number) => Promise<void>;
 }
 export interface Middleware {
     name: string;
     priority: number;
-    beforeConversion?: (context: any) => Promise<void>;
-    afterConversion?: (context: any, result: any) => Promise<void>;
-    onError?: (context: any, error: Error) => Promise<void>;
+    beforeConversion?: (context: LifecycleContext) => Promise<void>;
+    afterConversion?: (context: LifecycleContext, result: unknown) => Promise<void>;
+    onError?: (context: LifecycleContext, error: Error) => Promise<void>;
 }
 export interface Plugin {
     name: string;
     version: string;
-    initialize(context: any): Promise<void>;
+    initialize(context: LifecycleContext): Promise<void>;
     destroy(): Promise<void>;
     getMiddlewares(): Middleware[];
     getHooks(): LifecycleHooks;
@@ -209,22 +212,23 @@ export interface EnvironmentParser {
     getNumber(key: string, defaultValue?: number): number;
     getBoolean(key: string, defaultValue?: boolean): boolean;
     getArray(key: string, delimiter?: string): string[];
-    getObject(key: string): any;
+    getObject(key: string): JsonObject;
 }
 export declare const TypeGuards: {
-    isString: (value: any) => value is string;
-    isNumber: (value: any) => value is number;
-    isBoolean: (value: any) => value is boolean;
-    isObject: (value: any) => value is object;
-    isArray: (value: any) => value is any[];
-    isFunction: (value: any) => value is Function;
-    isDate: (value: any) => value is Date;
-    isNull: (value: any) => value is null;
-    isUndefined: (value: any) => value is undefined;
-    isNullOrUndefined: (value: any) => value is null | undefined;
+    isString: (value: unknown) => value is string;
+    isNumber: (value: unknown) => value is number;
+    isBoolean: (value: unknown) => value is boolean;
+    isObject: (value: unknown) => value is JsonObject;
+    isArray: (value: unknown) => value is JsonValue[];
+    isFunction: (value: unknown) => value is (...args: unknown[]) => unknown;
+    isDate: (value: unknown) => value is Date;
+    isNull: (value: unknown) => value is null;
+    isUndefined: (value: unknown) => value is undefined;
+    isNullOrUndefined: (value: unknown) => value is null | undefined;
 };
 export declare const AsyncUtils: {
     delay: (ms: number) => Promise<void>;
     timeout: <T>(promise: Promise<T>, ms: number) => Promise<T>;
     retry: <T>(fn: () => Promise<T>, config: RetryConfig) => Promise<T>;
 };
+export {};

package/dist/sse/types/utility-types.js

@@ -5,15 +5,15 @@
 // 类型守卫工具函数
 export const TypeGuards = {
     isString: (value) => typeof value === 'string',
-    isNumber: (value) => typeof value === 'number' && !isNaN(value),
+    isNumber: (value) => typeof value === 'number' && !Number.isNaN(value),
     isBoolean: (value) => typeof value === 'boolean',
-    isObject: (value) => value !== null && typeof value === 'object',
+    isObject: (value) => value !== null && typeof value === 'object' && !Array.isArray(value),
     isArray: (value) => Array.isArray(value),
     isFunction: (value) => typeof value === 'function',
     isDate: (value) => value instanceof Date,
     isNull: (value) => value === null,
     isUndefined: (value) => value === undefined,
-    isNullOrUndefined: (value) => value == null
+    isNullOrUndefined: (value) => value === null || value === undefined
 };
 // 异步工具函数
 export const AsyncUtils = {
@@ -31,19 +31,16 @@ export const AsyncUtils = {
                 return await fn();
             }
             catch (error) {
-                lastError = error;
-                if (!config.retryableErrors.includes(error.name) || attempt === config.maxAttempts) {
-                    throw error;
+                const normalizedError = error instanceof Error ? error : new Error(String(error));
+                lastError = normalizedError;
+                if (!config.retryableErrors.includes(normalizedError.name) || attempt === config.maxAttempts) {
+                    throw normalizedError;
                 }
                 const delay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt - 1), config.maxDelayMs);
-                if (config.jitter) {
-                    await AsyncUtils.delay(delay + Math.random() * delay * 0.1);
-                }
-                else {
-                    await AsyncUtils.delay(delay);
-                }
+                const jitter = config.jitter ? Math.random() * delay * 0.1 : 0;
+                await AsyncUtils.delay(delay + jitter);
             }
         }
-        throw lastError;
+        throw lastError ?? new Error('Operation failed after retry attempts');
     }
 };