@od-oneapp/ai-platform 0.1.0

package/dist/buffer-BC8mvXHE.d.mts

@@ -0,0 +1,98 @@
+//#region src/streaming/infra/types.d.ts
+type StreamChunkType = 'text-delta' | 'tool-call-delta' | 'tool-result' | 'finish' | 'error' | 'metadata';
+interface StreamChunk<T = unknown> {
+  type: StreamChunkType;
+  payload: T;
+  timestamp: Date;
+  sequence: number;
+}
+interface TextDeltaChunk extends StreamChunk<{
+  text: string;
+}> {
+  type: 'text-delta';
+}
+interface ToolCallDeltaChunk extends StreamChunk<{
+  toolCallId: string;
+  toolName: string;
+  argsTextDelta: string;
+}> {
+  type: 'tool-call-delta';
+}
+interface FinishChunk extends StreamChunk<{
+  finishReason: 'stop' | 'length' | 'tool-calls' | 'error' | 'unknown';
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}> {
+  type: 'finish';
+}
+type StreamTransform<TIn, TOut> = (chunk: TIn) => TOut | TOut[] | null | Promise<TOut | TOut[] | null>;
+interface StreamPipelineConfig {
+  bufferSize?: number;
+  timeout?: number;
+  onError?: 'throw' | 'skip' | 'terminate';
+}
+interface StreamMetrics {
+  chunksProcessed: number;
+  bytesTransferred: number;
+  startTime: Date;
+  endTime?: Date;
+  timeToFirstChunk?: number;
+  avgChunkLatency?: number;
+}
+type StreamState = 'idle' | 'streaming' | 'paused' | 'completed' | 'error';
+interface StreamController {
+  state: StreamState;
+  pause(): void;
+  resume(): void;
+  abort(reason?: string): void;
+  getMetrics(): StreamMetrics;
+}
+//#endregion
+//#region src/streaming/infra/transform/stream-transforms.d.ts
+declare function filterChunks<T>(predicate: (chunk: T) => boolean): StreamTransform<T, T>;
+declare function mapChunks<TIn, TOut>(mapper: (chunk: TIn) => TOut): StreamTransform<TIn, TOut>;
+declare function batchChunks<T>(batchSize: number): StreamTransform<T, T[]>;
+declare function debounceChunks<T>(delayMs: number): StreamTransform<T, T>;
+declare function throttleChunks<T>(intervalMs: number): StreamTransform<T, T>;
+declare function composeTransforms<T>(...transforms: Array<StreamTransform<unknown, unknown>>): StreamTransform<T, unknown>;
+declare function accumulateText(): StreamTransform<StreamChunk, {
+  accumulated: string;
+  delta: string;
+}>;
+declare function reportProgress<T>(onProgress: (count: number, chunk: T) => void): StreamTransform<T, T>;
+//#endregion
+//#region src/streaming/infra/backpressure/buffer.d.ts
+type OverflowStrategy = 'drop-oldest' | 'drop-newest' | 'block' | 'error';
+interface BoundedBufferOptions {
+  capacity: number;
+  overflowStrategy?: OverflowStrategy;
+  highWaterMark?: number;
+  lowWaterMark?: number;
+}
+declare class BoundedBuffer<T> {
+  private buffer;
+  private pressureCallbacks;
+  private isPaused;
+  private waiters;
+  private readonly capacity;
+  private readonly overflowStrategy;
+  private readonly highWaterMark;
+  private readonly lowWaterMark;
+  constructor(options: BoundedBufferOptions);
+  push(item: T): Promise<boolean>;
+  pop(): T | undefined;
+  popAsync(timeoutMs?: number): Promise<T>;
+  onPressure(callback: (signal: 'pause' | 'resume') => void): () => void;
+  size(): number;
+  isEmpty(): boolean;
+  isFull(): boolean;
+  clear(): void;
+  private notifyPressure;
+  private waitForSpace;
+}
+//#endregion
+export { StreamPipelineConfig as _, batchChunks as a, TextDeltaChunk as b, filterChunks as c, throttleChunks as d, FinishChunk as f, StreamMetrics as g, StreamController as h, accumulateText as i, mapChunks as l, StreamChunkType as m, BoundedBufferOptions as n, composeTransforms as o, StreamChunk as p, OverflowStrategy as r, debounceChunks as s, BoundedBuffer as t, reportProgress as u, StreamState as v, ToolCallDeltaChunk as x, StreamTransform as y };
+//# sourceMappingURL=buffer-BC8mvXHE.d.mts.map

package/dist/buffer-BC8mvXHE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-BC8mvXHE.d.mts","names":[],"sources":["../src/streaming/infra/types.ts","../src/streaming/infra/transform/stream-transforms.ts","../src/streaming/infra/backpressure/buffer.ts"],"mappings":";KAOY,eAAA;AAAA,UAWK,WAAA;EAEf,IAAA,EAAM,eAAA;EAEN,OAAA,EAAS,CAAA;EAET,SAAA,EAAW,IAAA;EAEX,QAAA;AAAA;AAAA,UAMe,cAAA,SAAuB,WAAA;EAAc,IAAA;AAAA;EACpD,IAAA;AAAA;AAAA,UAMe,kBAAA,SAA2B,WAAA;EAC1C,UAAA;EACA,QAAA;EACA,aAAA;AAAA;EAEA,IAAA;AAAA;AAAA,UAMe,WAAA,SAAoB,WAAA;EACnC,YAAA;EACA,KAAA;IACE,YAAA;IACA,gBAAA;IACA,WAAA;EAAA;AAAA;EAGF,IAAA;AAAA;AAAA,KAMU,eAAA,eACV,KAAA,EAAO,GAAA,KACJ,IAAA,GAAO,IAAA,YAAgB,OAAA,CAAQ,IAAA,GAAO,IAAA;AAAA,UAK1B,oBAAA;EAEf,UAAA;EAEA,OAAA;EAEA,OAAA;AAAA;AAAA,UAMe,aAAA;EAEf,eAAA;EAEA,gBAAA;EAEA,SAAA,EAAW,IAAA;EAEX,OAAA,GAAU,IAAA;EAEV,gBAAA;EAEA,eAAA;AAAA;AAAA,KAMU,WAAA;AAAA,UAKK,gBAAA;EAEf,KAAA,EAAO,WAAA;EAEP,KAAA;EAEA,MAAA;EAEA,KAAA,CAAM,MAAA;EAEN,UAAA,IAAc,aAAA;AAAA;;;iBCpGA,YAAA,GAAA,CAAgB,SAAA,GAAY,KAAA,EAAO,CAAA,eAAgB,eAAA,CAAgB,CAAA,EAAG,CAAA;AAAA,iBActE,SAAA,WAAA,CAAqB,MAAA,GAAS,KAAA,EAAO,GAAA,KAAQ,IAAA,GAAO,eAAA,CAAgB,GAAA,EAAK,IAAA;AAAA,iBAazE,WAAA,GAAA,CAAe,SAAA,WAAoB,eAAA,CAAgB,CAAA,EAAG,CAAA;AAAA,iBAiBtD,cAAA,GAAA,CAAkB,OAAA,WAAkB,eAAA,CAAgB,CAAA,EAAG,CAAA;AAAA,iBAuBvD,cAAA,GAAA,CAAkB,UAAA,WAAqB,eAAA,CAAgB,CAAA,EAAG,CAAA;AAAA,iBAyB1D,iBAAA,GAAA,CAAA,GACX,UAAA,EAAY,KAAA,CAAM,eAAA,sBACpB,eAAA,CAAgB,CAAA;AAAA,iBA0BH,cAAA,CAAA,GAAkB,eAAA,CAChC,WAAA;EACE,WAAA;EAAqB,KAAA;AAAA;AAAA,iBAiBT,cAAA,GAAA,CACd,UAAA,GAAa,KAAA,UAAe,KAAA,EAAO,CAAA,YAClC,eAAA,CAAgB,CAAA,EAAG,CAAA;;;KCtJV,gBAAA;AAAA,UAKK,oBAAA;EAEf,QAAA;EAEA,gBAAA,GAAmB,gBAAA;EAEnB,aAAA;EAEA,YAAA;AAAA;AAAA,cA2BW,aAAA;EAAA,QACH,MAAA;EAAA,QACA,iBAAA;EAAA,QACA,QAAA;EAAA,QACA,OAAA;EAAA,iBAKS,QAAA;EAAA,iBACA,gBAAA;EAAA,iBACA,aAAA;EAAA,iBACA,YAAA;cAEL,OAAA,EAAS,oBAAA;EAUf,IAAA,CAAK,IAAA,EAAM,CAAA,GAAI,OAAA;EAwCrB,GAAA,CAAA,GAAO,CAAA;EAeD,QAAA,CAAS,SAAA,YAAqB,OAAA,CAAQ,CAAA;EAyB5C,UAAA,CAAW,QAAA,GAAW,MAAA;EAWtB,IAAA,CAAA;EAOA,OAAA,CAAA;EAOA,MAAA,CAAA;EAOA,KAAA,CAAA;EAAA,QAQQ,cAAA;EAAA,QAMA,YAAA;AAAA"}

package/dist/buffer-CefJGbRy.mjs

@@ -0,0 +1,289 @@
+//#region src/streaming/infra/transform/stream-transforms.ts
+/**
+* Create a transform that filters chunks
+*
+* @example
+* ```ts
+* const textOnly = filterChunks<StreamChunk>(
+*   (chunk) => chunk.type === "text-delta"
+* );
+* ```
+*/
+function filterChunks(predicate) {
+	return (chunk) => predicate(chunk) ? chunk : null;
+}
+/**
+* Create a transform that maps chunks
+*
+* @example
+* ```ts
+* const extractText = mapChunks<TextDeltaChunk, string>(
+*   (chunk) => chunk.payload.text
+* );
+* ```
+*/
+function mapChunks(mapper) {
+	return (chunk) => mapper(chunk);
+}
+/**
+* Create a transform that batches chunks
+*
+* @example
+* ```ts
+* const batchedTransform = batchChunks<string>(10);
+* // Collects 10 chunks before emitting them as an array
+* ```
+*/
+function batchChunks(batchSize) {
+	let buffer = [];
+	return (chunk) => {
+		buffer.push(chunk);
+		if (buffer.length >= batchSize) {
+			const batch = buffer;
+			buffer = [];
+			return batch;
+		}
+		return null;
+	};
+}
+/**
+* Create a transform that debounces chunks
+*/
+function debounceChunks(delayMs) {
+	let lastChunk = null;
+	let timer = null;
+	return async (chunk) => {
+		lastChunk = chunk;
+		if (timer) clearTimeout(timer);
+		return new Promise((resolve) => {
+			timer = setTimeout(() => {
+				resolve(lastChunk);
+				lastChunk = null;
+			}, delayMs);
+		});
+	};
+}
+/**
+* Create a transform that throttles chunks
+*/
+function throttleChunks(intervalMs) {
+	let lastEmit = 0;
+	return (chunk) => {
+		const now = Date.now();
+		if (now - lastEmit >= intervalMs) {
+			lastEmit = now;
+			return chunk;
+		}
+		return null;
+	};
+}
+/**
+* Compose multiple transforms into a pipeline
+*
+* @example
+* ```ts
+* const pipeline = composeTransforms(
+*   filterChunks((c) => c.type === "text-delta"),
+*   mapChunks((c) => c.payload.text),
+*   batchChunks(5)
+* );
+* ```
+*/
+function composeTransforms(...transforms) {
+	return async (chunk) => {
+		let current = chunk;
+		for (const transform of transforms) {
+			if (current === null) return null;
+			const result = await transform(current);
+			if (result === null) return null;
+			if (Array.isArray(result)) current = result;
+			else current = result;
+		}
+		return current;
+	};
+}
+/**
+* Create a text accumulator transform
+*/
+function accumulateText() {
+	let accumulated = "";
+	return (chunk) => {
+		if (chunk.type === "text-delta") {
+			const delta = chunk.payload.text;
+			accumulated += delta;
+			return {
+				accumulated,
+				delta
+			};
+		}
+		return null;
+	};
+}
+/**
+* Create a progress reporter transform
+*/
+function reportProgress(onProgress) {
+	let count = 0;
+	return (chunk) => {
+		count++;
+		onProgress(count, chunk);
+		return chunk;
+	};
+}
+
+//#endregion
+//#region src/streaming/infra/backpressure/buffer.ts
+/**
+* Bounded buffer for backpressure management
+*
+* @example
+* ```ts
+* const buffer = new BoundedBuffer<string>({
+*   capacity: 100,
+*   overflowStrategy: "drop-oldest",
+*   highWaterMark: 80,
+*   lowWaterMark: 20,
+* });
+*
+* buffer.onPressure((signal) => {
+*   if (signal === "pause") {
+*     producer.pause();
+*   } else {
+*     producer.resume();
+*   }
+* });
+*
+* buffer.push(item);
+* const item = buffer.pop();
+* ```
+*/
+var BoundedBuffer = class {
+	buffer = [];
+	pressureCallbacks = [];
+	isPaused = false;
+	waiters = [];
+	capacity;
+	overflowStrategy;
+	highWaterMark;
+	lowWaterMark;
+	constructor(options) {
+		this.capacity = options.capacity;
+		this.overflowStrategy = options.overflowStrategy || "block";
+		this.highWaterMark = options.highWaterMark || Math.floor(options.capacity * .8);
+		this.lowWaterMark = options.lowWaterMark || Math.floor(options.capacity * .2);
+	}
+	/**
+	* Push an item to the buffer
+	*/
+	async push(item) {
+		if (this.waiters.length > 0) {
+			const waiter = this.waiters.shift();
+			if (waiter) {
+				waiter.resolve(item);
+				return true;
+			}
+		}
+		if (this.buffer.length >= this.capacity) switch (this.overflowStrategy) {
+			case "drop-oldest":
+				this.buffer.shift();
+				break;
+			case "drop-newest": return false;
+			case "error": throw new Error("Buffer overflow");
+			case "block":
+				await this.waitForSpace();
+				break;
+		}
+		this.buffer.push(item);
+		if (!this.isPaused && this.buffer.length >= this.highWaterMark) {
+			this.isPaused = true;
+			this.notifyPressure("pause");
+		}
+		return true;
+	}
+	/**
+	* Pop an item from the buffer
+	*/
+	pop() {
+		const item = this.buffer.shift();
+		if (this.isPaused && this.buffer.length <= this.lowWaterMark) {
+			this.isPaused = false;
+			this.notifyPressure("resume");
+		}
+		return item;
+	}
+	/**
+	* Wait for an item to be available
+	*/
+	async popAsync(timeoutMs) {
+		const item = this.pop();
+		if (item !== void 0) return item;
+		return new Promise((resolve, reject) => {
+			const waiter = {
+				resolve,
+				reject
+			};
+			this.waiters.push(waiter);
+			if (timeoutMs) setTimeout(() => {
+				const idx = this.waiters.indexOf(waiter);
+				if (idx >= 0) {
+					this.waiters.splice(idx, 1);
+					reject(/* @__PURE__ */ new Error("Buffer pop timeout"));
+				}
+			}, timeoutMs);
+		});
+	}
+	/**
+	* Register a pressure callback
+	*/
+	onPressure(callback) {
+		this.pressureCallbacks.push(callback);
+		return () => {
+			const idx = this.pressureCallbacks.indexOf(callback);
+			if (idx >= 0) this.pressureCallbacks.splice(idx, 1);
+		};
+	}
+	/**
+	* Get current buffer size
+	*/
+	size() {
+		return this.buffer.length;
+	}
+	/**
+	* Check if buffer is empty
+	*/
+	isEmpty() {
+		return this.buffer.length === 0;
+	}
+	/**
+	* Check if buffer is full
+	*/
+	isFull() {
+		return this.buffer.length >= this.capacity;
+	}
+	/**
+	* Clear the buffer
+	*/
+	clear() {
+		this.buffer = [];
+		if (this.isPaused) {
+			this.isPaused = false;
+			this.notifyPressure("resume");
+		}
+	}
+	notifyPressure(signal) {
+		for (const callback of this.pressureCallbacks) callback(signal);
+	}
+	waitForSpace() {
+		return new Promise((resolve) => {
+			const check = () => {
+				if (this.buffer.length < this.capacity) resolve();
+				else setTimeout(check, 10);
+			};
+			check();
+		});
+	}
+};
+
+//#endregion
+export { debounceChunks as a, reportProgress as c, composeTransforms as i, throttleChunks as l, accumulateText as n, filterChunks as o, batchChunks as r, mapChunks as s, BoundedBuffer as t };
+//# sourceMappingURL=buffer-CefJGbRy.mjs.map

package/dist/buffer-CefJGbRy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer-CefJGbRy.mjs","names":[],"sources":["../src/streaming/infra/transform/stream-transforms.ts","../src/streaming/infra/backpressure/buffer.ts"],"sourcesContent":["/**\n * Stream transformation utilities\n */\n\nimport type { StreamChunk, StreamTransform } from '../types';\n\n/**\n * Create a transform that filters chunks\n *\n * @example\n * ```ts\n * const textOnly = filterChunks<StreamChunk>(\n *   (chunk) => chunk.type === \"text-delta\"\n * );\n * ```\n */\nexport function filterChunks<T>(predicate: (chunk: T) => boolean): StreamTransform<T, T> {\n  return (chunk: T) => (predicate(chunk) ? chunk : null);\n}\n\n/**\n * Create a transform that maps chunks\n *\n * @example\n * ```ts\n * const extractText = mapChunks<TextDeltaChunk, string>(\n *   (chunk) => chunk.payload.text\n * );\n * ```\n */\nexport function mapChunks<TIn, TOut>(mapper: (chunk: TIn) => TOut): StreamTransform<TIn, TOut> {\n  return (chunk: TIn) => mapper(chunk);\n}\n\n/**\n * Create a transform that batches chunks\n *\n * @example\n * ```ts\n * const batchedTransform = batchChunks<string>(10);\n * // Collects 10 chunks before emitting them as an array\n * ```\n */\nexport function batchChunks<T>(batchSize: number): StreamTransform<T, T[]> {\n  let buffer: T[] = [];\n\n  return (chunk: T) => {\n    buffer.push(chunk);\n    if (buffer.length >= batchSize) {\n      const batch = buffer;\n      buffer = [];\n      return batch;\n    }\n    return null;\n  };\n}\n\n/**\n * Create a transform that debounces chunks\n */\nexport function debounceChunks<T>(delayMs: number): StreamTransform<T, T> {\n  let lastChunk: T | null = null;\n  let timer: ReturnType<typeof setTimeout> | null = null;\n\n  return async (chunk: T) => {\n    lastChunk = chunk;\n\n    if (timer) {\n      clearTimeout(timer);\n    }\n\n    return new Promise(resolve => {\n      timer = setTimeout(() => {\n        resolve(lastChunk);\n        lastChunk = null;\n      }, delayMs);\n    });\n  };\n}\n\n/**\n * Create a transform that throttles chunks\n */\nexport function throttleChunks<T>(intervalMs: number): StreamTransform<T, T> {\n  let lastEmit = 0;\n\n  return (chunk: T) => {\n    const now = Date.now();\n    if (now - lastEmit >= intervalMs) {\n      lastEmit = now;\n      return chunk;\n    }\n    return null;\n  };\n}\n\n/**\n * Compose multiple transforms into a pipeline\n *\n * @example\n * ```ts\n * const pipeline = composeTransforms(\n *   filterChunks((c) => c.type === \"text-delta\"),\n *   mapChunks((c) => c.payload.text),\n *   batchChunks(5)\n * );\n * ```\n */\nexport function composeTransforms<T>(\n  ...transforms: Array<StreamTransform<unknown, unknown>>\n): StreamTransform<T, unknown> {\n  return async (chunk: T) => {\n    let current: unknown = chunk;\n\n    for (const transform of transforms) {\n      if (current === null) return null;\n\n      const result = await transform(current);\n      if (result === null) return null;\n\n      // Handle array results from batch transforms\n      if (Array.isArray(result)) {\n        // For array results, we'd need to flatten - simplified for now\n        current = result;\n      } else {\n        current = result;\n      }\n    }\n\n    return current;\n  };\n}\n\n/**\n * Create a text accumulator transform\n */\nexport function accumulateText(): StreamTransform<\n  StreamChunk,\n  { accumulated: string; delta: string }\n> {\n  let accumulated = '';\n\n  return (chunk: StreamChunk) => {\n    if (chunk.type === 'text-delta') {\n      const delta = (chunk.payload as { text: string }).text;\n      accumulated += delta;\n      return { accumulated, delta };\n    }\n    return null;\n  };\n}\n\n/**\n * Create a progress reporter transform\n */\nexport function reportProgress<T>(\n  onProgress: (count: number, chunk: T) => void,\n): StreamTransform<T, T> {\n  let count = 0;\n\n  return (chunk: T) => {\n    count++;\n    onProgress(count, chunk);\n    return chunk;\n  };\n}\n","/**\n * Backpressure buffer for stream flow control\n */\n\n/**\n * Buffer overflow strategy\n */\nexport type OverflowStrategy = 'drop-oldest' | 'drop-newest' | 'block' | 'error';\n\n/**\n * Bounded buffer options\n */\nexport interface BoundedBufferOptions {\n  /** Maximum buffer capacity */\n  capacity: number;\n  /** Strategy when buffer is full */\n  overflowStrategy?: OverflowStrategy;\n  /** High water mark for backpressure signal */\n  highWaterMark?: number;\n  /** Low water mark for resume signal */\n  lowWaterMark?: number;\n}\n\n/**\n * Bounded buffer for backpressure management\n *\n * @example\n * ```ts\n * const buffer = new BoundedBuffer<string>({\n *   capacity: 100,\n *   overflowStrategy: \"drop-oldest\",\n *   highWaterMark: 80,\n *   lowWaterMark: 20,\n * });\n *\n * buffer.onPressure((signal) => {\n *   if (signal === \"pause\") {\n *     producer.pause();\n *   } else {\n *     producer.resume();\n *   }\n * });\n *\n * buffer.push(item);\n * const item = buffer.pop();\n * ```\n */\nexport class BoundedBuffer<T> {\n  private buffer: T[] = [];\n  private pressureCallbacks: Array<(signal: 'pause' | 'resume') => void> = [];\n  private isPaused = false;\n  private waiters: Array<{\n    resolve: (value: T) => void;\n    reject: (error: Error) => void;\n  }> = [];\n\n  private readonly capacity: number;\n  private readonly overflowStrategy: OverflowStrategy;\n  private readonly highWaterMark: number;\n  private readonly lowWaterMark: number;\n\n  constructor(options: BoundedBufferOptions) {\n    this.capacity = options.capacity;\n    this.overflowStrategy = options.overflowStrategy || 'block';\n    this.highWaterMark = options.highWaterMark || Math.floor(options.capacity * 0.8);\n    this.lowWaterMark = options.lowWaterMark || Math.floor(options.capacity * 0.2);\n  }\n\n  /**\n   * Push an item to the buffer\n   */\n  async push(item: T): Promise<boolean> {\n    // If there are waiters, deliver directly\n    if (this.waiters.length > 0) {\n      const waiter = this.waiters.shift();\n      if (waiter) {\n        waiter.resolve(item);\n        return true;\n      }\n    }\n\n    // Handle buffer full\n    if (this.buffer.length >= this.capacity) {\n      switch (this.overflowStrategy) {\n        case 'drop-oldest':\n          this.buffer.shift();\n          break;\n        case 'drop-newest':\n          return false;\n        case 'error':\n          throw new Error('Buffer overflow');\n        case 'block':\n          await this.waitForSpace();\n          break;\n      }\n    }\n\n    this.buffer.push(item);\n\n    // Check high water mark\n    if (!this.isPaused && this.buffer.length >= this.highWaterMark) {\n      this.isPaused = true;\n      this.notifyPressure('pause');\n    }\n\n    return true;\n  }\n\n  /**\n   * Pop an item from the buffer\n   */\n  pop(): T | undefined {\n    const item = this.buffer.shift();\n\n    // Check low water mark\n    if (this.isPaused && this.buffer.length <= this.lowWaterMark) {\n      this.isPaused = false;\n      this.notifyPressure('resume');\n    }\n\n    return item;\n  }\n\n  /**\n   * Wait for an item to be available\n   */\n  async popAsync(timeoutMs?: number): Promise<T> {\n    const item = this.pop();\n    if (item !== undefined) {\n      return item;\n    }\n\n    return new Promise((resolve, reject) => {\n      const waiter = { resolve, reject };\n      this.waiters.push(waiter);\n\n      if (timeoutMs) {\n        setTimeout(() => {\n          const idx = this.waiters.indexOf(waiter);\n          if (idx >= 0) {\n            this.waiters.splice(idx, 1);\n            reject(new Error('Buffer pop timeout'));\n          }\n        }, timeoutMs);\n      }\n    });\n  }\n\n  /**\n   * Register a pressure callback\n   */\n  onPressure(callback: (signal: 'pause' | 'resume') => void): () => void {\n    this.pressureCallbacks.push(callback);\n    return () => {\n      const idx = this.pressureCallbacks.indexOf(callback);\n      if (idx >= 0) this.pressureCallbacks.splice(idx, 1);\n    };\n  }\n\n  /**\n   * Get current buffer size\n   */\n  size(): number {\n    return this.buffer.length;\n  }\n\n  /**\n   * Check if buffer is empty\n   */\n  isEmpty(): boolean {\n    return this.buffer.length === 0;\n  }\n\n  /**\n   * Check if buffer is full\n   */\n  isFull(): boolean {\n    return this.buffer.length >= this.capacity;\n  }\n\n  /**\n   * Clear the buffer\n   */\n  clear(): void {\n    this.buffer = [];\n    if (this.isPaused) {\n      this.isPaused = false;\n      this.notifyPressure('resume');\n    }\n  }\n\n  private notifyPressure(signal: 'pause' | 'resume'): void {\n    for (const callback of this.pressureCallbacks) {\n      callback(signal);\n    }\n  }\n\n  private waitForSpace(): Promise<void> {\n    return new Promise(resolve => {\n      const check = () => {\n        if (this.buffer.length < this.capacity) {\n          resolve();\n        } else {\n          setTimeout(check, 10);\n        }\n      };\n      check();\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/caching-adapters.d.mts

@@ -0,0 +1,5 @@
+import "./ai-runtime-DIwOEc6g.mjs";
+import { t as RedisClient } from "./types-By-r93bE.mjs";
+import "./types-BPnq3GQo.mjs";
+import { n as MemoryCacheAdapter, t as RedisCacheAdapter } from "./redis-CwguYFGh.mjs";
+export { MemoryCacheAdapter, RedisCacheAdapter, type RedisClient };

package/dist/caching-adapters.mjs

@@ -0,0 +1,3 @@
+import { n as MemoryCacheAdapter, t as RedisCacheAdapter } from "./redis-CpsSrF8K.mjs";
+
+export { MemoryCacheAdapter, RedisCacheAdapter };

package/dist/caching-strategies.d.mts

@@ -0,0 +1,52 @@
+//#region src/caching/strategies/index.d.ts
+type EvictionStrategy = 'lru' | 'lfu' | 'ttl' | 'fifo' | 'adaptive';
+interface StrategyConfig {
+  maxSize: number;
+  defaultTtlMs?: number;
+  onEvict?: (key: string, value: unknown) => void;
+}
+interface CacheEntryMeta {
+  createdAt: number;
+  lastAccessedAt: number;
+  accessCount: number;
+  expiresAt?: number;
+  sizeBytes?: number;
+}
+interface CacheEntry<T = unknown> {
+  key: string;
+  value: T;
+  meta: CacheEntryMeta;
+}
+interface StrategyStats {
+  hits: number;
+  misses: number;
+  evictions: number;
+  currentSize: number;
+  maxSize: number;
+  hitRate: number;
+}
+interface CacheEvictionStrategy<T = unknown> {
+  get(key: string): T | undefined;
+  set(key: string, value: T, ttlMs?: number): void;
+  has(key: string): boolean;
+  delete(key: string): boolean;
+  clear(): void;
+  size(): number;
+  keys(): string[];
+  stats(): StrategyStats;
+  peek(key: string): T | undefined;
+  peekEntry?(key: string): CacheEntry<T> | undefined;
+}
+declare function createLRUStrategy<T = unknown>(config: StrategyConfig): CacheEvictionStrategy<T>;
+declare function createLFUStrategy<T = unknown>(config: StrategyConfig): CacheEvictionStrategy<T>;
+declare function createFIFOStrategy<T = unknown>(config: StrategyConfig): CacheEvictionStrategy<T>;
+declare function createTTLStrategy<T = unknown>(config: StrategyConfig): CacheEvictionStrategy<T>;
+interface AdaptiveStrategyConfig extends StrategyConfig {
+  analysisWindowMs?: number;
+  analysisIntervalMs?: number;
+}
+declare function createAdaptiveStrategy<T = unknown>(config: AdaptiveStrategyConfig): CacheEvictionStrategy<T>;
+declare function createCacheStrategy<T = unknown>(strategy: EvictionStrategy, config: StrategyConfig | AdaptiveStrategyConfig): CacheEvictionStrategy<T>;
+//#endregion
+export { AdaptiveStrategyConfig, CacheEntry, CacheEntryMeta, CacheEvictionStrategy, EvictionStrategy, StrategyConfig, StrategyStats, createAdaptiveStrategy, createCacheStrategy, createFIFOStrategy, createLFUStrategy, createLRUStrategy, createTTLStrategy };
+//# sourceMappingURL=caching-strategies.d.mts.map

package/dist/caching-strategies.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caching-strategies.d.mts","names":[],"sources":["../src/caching/strategies/index.ts"],"mappings":";KAgCY,gBAAA;AAAA,UAGK,cAAA;EAEf,OAAA;EAEA,YAAA;EAEA,OAAA,IAAW,GAAA,UAAa,KAAA;AAAA;AAAA,UAIT,cAAA;EAEf,SAAA;EAEA,cAAA;EAEA,WAAA;EAEA,SAAA;EAEA,SAAA;AAAA;AAAA,UAIe,UAAA;EACf,GAAA;EACA,KAAA,EAAO,CAAA;EACP,IAAA,EAAM,cAAA;AAAA;AAAA,UAIS,aAAA;EACf,IAAA;EACA,MAAA;EACA,SAAA;EACA,WAAA;EACA,OAAA;EACA,OAAA;AAAA;AAAA,UAIe,qBAAA;EAEf,GAAA,CAAI,GAAA,WAAc,CAAA;EAElB,GAAA,CAAI,GAAA,UAAa,KAAA,EAAO,CAAA,EAAG,KAAA;EAE3B,GAAA,CAAI,GAAA;EAEJ,MAAA,CAAO,GAAA;EAEP,KAAA;EAEA,IAAA;EAEA,IAAA;EAEA,KAAA,IAAS,aAAA;EAET,IAAA,CAAK,GAAA,WAAc,CAAA;EAEnB,SAAA,EAAW,GAAA,WAAc,UAAA,CAAW,CAAA;AAAA;AAAA,iBAkBtB,iBAAA,aAAA,CAA+B,MAAA,EAAQ,cAAA,GAAiB,qBAAA,CAAsB,CAAA;AAAA,iBAoL9E,iBAAA,aAAA,CAA+B,MAAA,EAAQ,cAAA,GAAiB,qBAAA,CAAsB,CAAA;AAAA,iBA4K9E,kBAAA,aAAA,CAAgC,MAAA,EAAQ,cAAA,GAAiB,qBAAA,CAAsB,CAAA;AAAA,iBAwK/E,iBAAA,aAAA,CAA+B,MAAA,EAAQ,cAAA,GAAiB,qBAAA,CAAsB,CAAA;AAAA,UA+J7E,sBAAA,SAA+B,cAAA;EAE9C,gBAAA;EAEA,kBAAA;AAAA;AAAA,iBAec,sBAAA,aAAA,CACd,MAAA,EAAQ,sBAAA,GACP,qBAAA,CAAsB,CAAA;AAAA,iBA+KT,mBAAA,aAAA,CACd,QAAA,EAAU,gBAAA,EACV,MAAA,EAAQ,cAAA,GAAiB,sBAAA,GACxB,qBAAA,CAAsB,CAAA"}