@lov3kaizen/agentsea-cache 0.5.1

package/dist/streaming/index.d.ts

@@ -0,0 +1,206 @@
+import EventEmitter from 'eventemitter3';
+import { C as CacheMessage } from '../cache.types-DMuyQseO.js';
+import { B as BaseCacheStore } from '../store.types-BQy5Yyz9.js';
+import { S as SimilarityEngine } from '../SimilarityEngine-Cwv_mF9a.js';
+
+type StreamChunkType = 'text' | 'tool_call' | 'tool_result' | 'metadata';
+interface StreamChunk {
+    type: StreamChunkType;
+    content?: string;
+    toolCall?: {
+        id: string;
+        name: string;
+        arguments: string;
+    };
+    toolResult?: {
+        callId: string;
+        content: string;
+    };
+    metadata?: Record<string, unknown>;
+    timestamp: number;
+    index: number;
+}
+interface RecordedStream {
+    id: string;
+    key: string;
+    chunks: StreamChunk[];
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string;
+    }>;
+    startTime: number;
+    endTime: number;
+    durationMs: number;
+    totalChars: number;
+    tokenUsage?: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+    complete: boolean;
+    error?: string;
+}
+interface ChunkBufferConfig {
+    maxChunks?: number;
+    maxBytes?: number;
+    flushIntervalMs?: number;
+    preserveOrder?: boolean;
+}
+interface StreamRecorderConfig {
+    buffer?: ChunkBufferConfig;
+    captureToolCalls?: boolean;
+    captureMetadata?: boolean;
+    maxDurationMs?: number;
+    maxChunks?: number;
+}
+interface StreamReplayerConfig {
+    speedMultiplier?: number;
+    minDelayMs?: number;
+    maxDelayMs?: number;
+    simulateTiming?: boolean;
+    onChunk?: (chunk: StreamChunk) => void;
+    onComplete?: (stream: RecordedStream) => void;
+    onError?: (error: Error) => void;
+}
+interface StreamCacheConfig {
+    recorder?: StreamRecorderConfig;
+    replayer?: StreamReplayerConfig;
+    cacheIncomplete?: boolean;
+    minLengthToCache?: number;
+    streamTtl?: number;
+}
+interface StreamCacheLookupResult {
+    hit: boolean;
+    stream?: RecordedStream;
+    similarity?: number;
+    source: 'exact' | 'semantic' | 'miss';
+    latencyMs: number;
+}
+interface StreamCacheStats {
+    totalLookups: number;
+    totalHits: number;
+    totalMisses: number;
+    hitRate: number;
+    avgReplayLatencyMs: number;
+    totalStreamsCached: number;
+    totalBytesCached: number;
+    avgStreamDurationMs: number;
+}
+
+declare class ChunkBuffer {
+    private chunks;
+    private currentBytes;
+    private config;
+    private flushTimer;
+    private onFlush?;
+    constructor(config?: ChunkBufferConfig, onFlush?: (chunks: StreamChunk[]) => void);
+    add(chunk: StreamChunk): void;
+    addAll(chunks: StreamChunk[]): void;
+    flush(): StreamChunk[];
+    size(): number;
+    bytes(): number;
+    isEmpty(): boolean;
+    peek(): readonly StreamChunk[];
+    clear(): void;
+    stop(): void;
+    destroy(): void;
+    private shouldFlush;
+    private startFlushTimer;
+    private estimateChunkSize;
+}
+declare function createChunkBuffer(config?: ChunkBufferConfig, onFlush?: (chunks: StreamChunk[]) => void): ChunkBuffer;
+
+declare class StreamRecorder {
+    private config;
+    private buffer;
+    private recording;
+    private startTime;
+    private model;
+    private messages;
+    private key;
+    private totalChars;
+    private chunkIndex;
+    private timeoutId;
+    constructor(config?: StreamRecorderConfig);
+    start(model: string, messages: Array<{
+        role: string;
+        content: string;
+    }>, key?: string): void;
+    recordText(content: string, metadata?: Record<string, unknown>): void;
+    recordToolCall(id: string, name: string, args: string, metadata?: Record<string, unknown>): void;
+    recordToolResult(callId: string, content: string, metadata?: Record<string, unknown>): void;
+    recordMetadata(metadata: Record<string, unknown>): void;
+    recordChunk(chunk: StreamChunk): void;
+    complete(tokenUsage?: {
+        prompt: number;
+        completion: number;
+        total: number;
+    }): RecordedStream;
+    abort(reason?: string): RecordedStream;
+    isRecording(): boolean;
+    getChunkCount(): number;
+    getDuration(): number;
+    destroy(): void;
+    private reset;
+    private clearTimeout;
+}
+declare function createStreamRecorder(config?: StreamRecorderConfig): StreamRecorder;
+
+declare class StreamReplayer {
+    private config;
+    private abortController;
+    constructor(config?: StreamReplayerConfig);
+    replay(stream: RecordedStream): AsyncGenerator<StreamChunk>;
+    replayText(stream: RecordedStream): AsyncGenerator<string>;
+    replaySync(stream: RecordedStream): Generator<StreamChunk>;
+    getAllChunks(stream: RecordedStream): StreamChunk[];
+    getFullText(stream: RecordedStream): string;
+    getToolCalls(stream: RecordedStream): Array<{
+        id: string;
+        name: string;
+        arguments: string;
+    }>;
+    stop(): void;
+    configure(config: Partial<StreamReplayerConfig>): void;
+    private delay;
+}
+declare function createStreamReplayer(config?: StreamReplayerConfig): StreamReplayer;
+
+interface StreamCacheEvents {
+    hit: (result: StreamCacheLookupResult) => void;
+    miss: (key: string) => void;
+    record: (stream: RecordedStream) => void;
+    error: (error: Error) => void;
+}
+declare class StreamCache extends EventEmitter<StreamCacheEvents> {
+    private store;
+    private similarity?;
+    private config;
+    private recorder;
+    private replayer;
+    private stats;
+    private replayLatencies;
+    private streamDurations;
+    constructor(store: BaseCacheStore, config?: StreamCacheConfig, similarity?: SimilarityEngine);
+    lookup(model: string, messages: CacheMessage[]): Promise<StreamCacheLookupResult>;
+    cache(stream: RecordedStream, embedding?: number[]): Promise<void>;
+    wrapStream<T extends {
+        content?: string;
+    }>(model: string, messages: CacheMessage[], streamFn: () => AsyncGenerator<T>, options?: {
+        embedding?: number[];
+    }): AsyncGenerator<T>;
+    replay(stream: RecordedStream): AsyncGenerator<StreamChunk>;
+    getStats(): StreamCacheStats;
+    clear(): Promise<void>;
+    destroy(): void;
+    private generateStreamKey;
+    private serializeStream;
+    private deserializeStream;
+    private estimateStreamSize;
+    private updateHitRate;
+    private updateAvgStreamDuration;
+}
+declare function createStreamCache(store: BaseCacheStore, config?: StreamCacheConfig, similarity?: SimilarityEngine): StreamCache;
+
+export { ChunkBuffer, type ChunkBufferConfig, type RecordedStream, StreamCache, type StreamCacheConfig, type StreamCacheEvents, type StreamCacheLookupResult, type StreamCacheStats, type StreamChunk, type StreamChunkType, StreamRecorder, type StreamRecorderConfig, StreamReplayer, type StreamReplayerConfig, createChunkBuffer, createStreamCache, createStreamRecorder, createStreamReplayer };