@od-oneapp/ai-platform 0.1.0

package/dist/streaming-infra-resilience.mjs

@@ -0,0 +1,358 @@
+//#region src/streaming/infra/resilience/index.ts
+/**
+* Create a Redis-backed stream checkpoint store
+*
+* @example
+* ```typescript
+* const store = createStreamCheckpointStore(redis, {
+*   prefix: 'stream:',
+*   defaultTTL: 3600,
+* });
+*
+* await store.save(checkpoint);
+* const resumed = await store.load(streamId);
+* ```
+*/
+function createStreamCheckpointStore(redis, options = {}) {
+	const { prefix = "stream:checkpoint:", defaultTTL = 3600 } = options;
+	function key(streamId) {
+		return `${prefix}${streamId}`;
+	}
+	function chunkKey(streamId) {
+		return `${prefix}${streamId}:chunks`;
+	}
+	return {
+		async save(checkpoint, ttl) {
+			const effectiveTTL = ttl || defaultTTL;
+			await redis.set(key(checkpoint.streamId), JSON.stringify(checkpoint), { ex: effectiveTTL });
+		},
+		async load(streamId) {
+			const data = await redis.get(key(streamId));
+			if (!data) return null;
+			return JSON.parse(data);
+		},
+		async exists(streamId) {
+			return await redis.exists(key(streamId)) > 0;
+		},
+		async delete(streamId) {
+			await redis.del(key(streamId));
+			await redis.del(chunkKey(streamId));
+		},
+		async updateStatus(streamId, status, error) {
+			const checkpoint = await this.load(streamId);
+			if (checkpoint) {
+				checkpoint.status = status;
+				checkpoint.error = error;
+				checkpoint.updatedAt = Date.now();
+				await this.save(checkpoint);
+			}
+		},
+		async appendChunks(streamId, chunks) {
+			if (chunks.length === 0) return;
+			await redis.rpush(chunkKey(streamId), ...chunks.map((c) => JSON.stringify(c)));
+		},
+		async getChunks(streamId, fromSequence) {
+			return (await redis.lrange(chunkKey(streamId), 0, -1)).map((c) => JSON.parse(c)).filter((c) => c.sequenceNumber >= fromSequence);
+		},
+		async trimChunks(streamId, keepLast) {
+			await redis.ltrim(chunkKey(streamId), -keepLast, -1);
+		},
+		async extend(streamId, ttl) {
+			const effectiveTTL = ttl || defaultTTL;
+			await redis.expire(key(streamId), effectiveTTL);
+			await redis.expire(chunkKey(streamId), effectiveTTL);
+		}
+	};
+}
+/**
+* Create a resumable stream wrapper
+*
+* Wraps an AI SDK stream to add checkpointing and resumption capability.
+*
+* @example
+* ```typescript
+* const resumable = createResumableStream({
+*   redis,
+*   checkpointInterval: 10,
+* });
+*
+* // Start new stream
+* const { streamId, stream } = await resumable.start(originalStream);
+*
+* // Resume from checkpoint
+* const resumed = await resumable.resume(streamId, newStream);
+* ```
+*/
+function createResumableStream(options) {
+	const { redis, prefix = "resumable:", checkpointInterval = 10, checkpointTTL = 3600, chunkBufferSize = 100, enableChunkBuffer = true } = options;
+	const store = createStreamCheckpointStore(redis, {
+		prefix,
+		defaultTTL: checkpointTTL
+	});
+	function generateStreamId() {
+		return `stream_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+	}
+	return {
+		async start(sourceStream, options = {}) {
+			const streamId = options.streamId || generateStreamId();
+			const checkpoint = {
+				streamId,
+				sequenceNumber: 0,
+				accumulatedText: "",
+				toolCalls: [],
+				tokenUsage: {
+					promptTokens: 0,
+					completionTokens: 0
+				},
+				status: "active",
+				createdAt: Date.now(),
+				updatedAt: Date.now(),
+				metadata: options.metadata
+			};
+			await store.save(checkpoint, checkpointTTL);
+			let sequenceNumber = 0;
+			const chunkBuffer = [];
+			async function* wrappedStream() {
+				try {
+					for await (const chunk of sourceStream) {
+						sequenceNumber++;
+						const sequencedChunk = processChunk(chunk, sequenceNumber);
+						if (enableChunkBuffer) {
+							chunkBuffer.push(sequencedChunk);
+							if (chunkBuffer.length >= chunkBufferSize) {
+								await store.appendChunks(streamId, chunkBuffer);
+								chunkBuffer.length = 0;
+							}
+						}
+						if (sequenceNumber % checkpointInterval === 0) await updateCheckpoint(sequencedChunk);
+						yield chunk;
+					}
+					checkpoint.status = "completed";
+					checkpoint.sequenceNumber = sequenceNumber;
+					checkpoint.updatedAt = Date.now();
+					await store.save(checkpoint, checkpointTTL);
+					if (enableChunkBuffer && chunkBuffer.length > 0) await store.appendChunks(streamId, chunkBuffer);
+					options.onCheckpoint?.(checkpoint);
+				} catch (error) {
+					checkpoint.status = "failed";
+					checkpoint.error = error instanceof Error ? error.message : String(error);
+					checkpoint.updatedAt = Date.now();
+					await store.save(checkpoint, checkpointTTL);
+					throw error;
+				}
+			}
+			function processChunk(chunk, seq) {
+				const chunkObj = chunk;
+				let type = "text";
+				if (chunkObj.type === "tool-call") type = "tool-call";
+				else if (chunkObj.type === "tool-result") type = "tool-result";
+				else if (chunkObj.type === "finish") type = "finish";
+				else if (chunkObj.type === "error") type = "error";
+				return {
+					sequenceNumber: seq,
+					type,
+					data: chunk,
+					timestamp: Date.now()
+				};
+			}
+			async function updateCheckpoint(chunk) {
+				checkpoint.sequenceNumber = chunk.sequenceNumber;
+				checkpoint.updatedAt = Date.now();
+				if (chunk.type === "text") {
+					const textData = chunk.data;
+					if (textData.textDelta) checkpoint.accumulatedText += textData.textDelta;
+				}
+				if (chunk.type === "tool-call") {
+					const toolData = chunk.data;
+					if (toolData.toolCallId) checkpoint.toolCalls.push({
+						id: toolData.toolCallId,
+						name: toolData.toolName || "",
+						args: toolData.args || ""
+					});
+				}
+				await store.save(checkpoint, checkpointTTL);
+				options.onCheckpoint?.(checkpoint);
+			}
+			return {
+				streamId,
+				stream: wrappedStream(),
+				getCheckpoint: () => store.load(streamId)
+			};
+		},
+		async resume(streamId, newSourceStream, options = {}) {
+			const checkpoint = await store.load(streamId);
+			if (!checkpoint) throw new Error(`No checkpoint found for stream: ${streamId}`);
+			const activeCheckpoint = checkpoint;
+			if (activeCheckpoint.status === "completed") throw new Error(`Stream already completed: ${streamId}`);
+			const resumeFromSequence = activeCheckpoint.sequenceNumber;
+			let currentSequence = resumeFromSequence;
+			if (options.replayBufferedChunks) {
+				const bufferedChunks = await store.getChunks(streamId, resumeFromSequence);
+				for (const chunk of bufferedChunks) options.onReplay?.(chunk);
+			}
+			activeCheckpoint.status = "active";
+			activeCheckpoint.updatedAt = Date.now();
+			await store.save(activeCheckpoint, checkpointTTL);
+			async function* resumedStream() {
+				for await (const chunk of newSourceStream) {
+					currentSequence++;
+					if (currentSequence <= resumeFromSequence) continue;
+					if (currentSequence % checkpointInterval === 0) {
+						activeCheckpoint.sequenceNumber = currentSequence;
+						activeCheckpoint.updatedAt = Date.now();
+						await store.save(activeCheckpoint, checkpointTTL);
+					}
+					yield chunk;
+				}
+				activeCheckpoint.status = "completed";
+				activeCheckpoint.sequenceNumber = currentSequence;
+				activeCheckpoint.updatedAt = Date.now();
+				await store.save(activeCheckpoint, checkpointTTL);
+			}
+			return {
+				checkpoint: activeCheckpoint,
+				stream: resumedStream(),
+				skippedChunks: 0
+			};
+		},
+		async pause(streamId) {
+			await store.updateStatus(streamId, "paused");
+		},
+		async getCheckpoint(streamId) {
+			return store.load(streamId);
+		},
+		async canResume(streamId) {
+			const checkpoint = await store.load(streamId);
+			return checkpoint !== null && checkpoint.status !== "completed";
+		},
+		async delete(streamId) {
+			await store.delete(streamId);
+		},
+		async keepAlive(streamId, ttl) {
+			await store.extend(streamId, ttl || checkpointTTL);
+		},
+		getStore() {
+			return store;
+		}
+	};
+}
+const DEFAULT_RETRY_CONFIG = {
+	maxRetries: 3,
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4,
+	backoffMultiplier: 2,
+	retryableErrors: [
+		"ECONNRESET",
+		"ETIMEDOUT",
+		"ENOTFOUND",
+		"rate_limit"
+	]
+};
+/**
+* Create a retry wrapper for stream operations
+*/
+function createStreamRetry(config = {}) {
+	const { maxRetries, initialDelayMs, maxDelayMs, backoffMultiplier, retryableErrors } = {
+		...DEFAULT_RETRY_CONFIG,
+		...config
+	};
+	function isRetryable(error) {
+		if (!retryableErrors) return true;
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		const errorCode = error.code;
+		return retryableErrors.some((re) => errorMessage.includes(re) || errorCode === re);
+	}
+	function calculateDelay(attempt) {
+		const delay = initialDelayMs * Math.pow(backoffMultiplier, attempt);
+		return Math.min(delay, maxDelayMs);
+	}
+	return {
+		async execute(fn) {
+			let lastError;
+			for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+				return await fn();
+			} catch (error) {
+				lastError = error;
+				if (attempt === maxRetries || !isRetryable(error)) throw error;
+				const delay = calculateDelay(attempt);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+			}
+			throw lastError;
+		},
+		async *wrapStream(createStream, options = {}) {
+			let attempt = 0;
+			let processedCount = options.resumeFrom || 0;
+			while (attempt <= maxRetries) try {
+				let currentCount = 0;
+				const stream = createStream();
+				for await (const chunk of stream) {
+					currentCount++;
+					if (currentCount <= processedCount) continue;
+					processedCount = currentCount;
+					yield chunk;
+				}
+				return;
+			} catch (error) {
+				if (attempt === maxRetries || !isRetryable(error)) throw error;
+				options.onRetry?.(attempt, error);
+				const delay = calculateDelay(attempt);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+				attempt++;
+			}
+		}
+	};
+}
+/**
+* Create a circuit breaker for stream operations
+*/
+function createCircuitBreaker(config = {}) {
+	const { failureThreshold = 5, resetTimeoutMs = 3e4, halfOpenRequests = 1 } = config;
+	let state = "closed";
+	let failures = 0;
+	let lastFailureTime = 0;
+	let halfOpenAttempts = 0;
+	return {
+		getState() {
+			if (state === "open" && Date.now() - lastFailureTime >= resetTimeoutMs) {
+				state = "half-open";
+				halfOpenAttempts = 0;
+			}
+			return state;
+		},
+		async execute(fn) {
+			const currentState = this.getState();
+			if (currentState === "open") throw new Error("Circuit breaker is open");
+			if (currentState === "half-open" && halfOpenAttempts >= halfOpenRequests) throw new Error("Circuit breaker half-open limit reached");
+			if (currentState === "half-open") halfOpenAttempts++;
+			try {
+				const result = await fn();
+				if (currentState === "half-open") {
+					state = "closed";
+					failures = 0;
+				} else failures = 0;
+				return result;
+			} catch (error) {
+				failures++;
+				lastFailureTime = Date.now();
+				if (currentState === "half-open" || failures >= failureThreshold) state = "open";
+				throw error;
+			}
+		},
+		reset() {
+			state = "closed";
+			failures = 0;
+			halfOpenAttempts = 0;
+		},
+		getStats() {
+			return {
+				state: this.getState(),
+				failures,
+				lastFailureTime: lastFailureTime ? new Date(lastFailureTime) : null
+			};
+		}
+	};
+}
+
+//#endregion
+export { createCircuitBreaker, createResumableStream, createStreamCheckpointStore, createStreamRetry };
+//# sourceMappingURL=streaming-infra-resilience.mjs.map

package/dist/streaming-infra-resilience.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-infra-resilience.mjs","names":[],"sources":["../src/streaming/infra/resilience/index.ts"],"sourcesContent":["/**\n * Stream Resilience & Resumption\n *\n * Provides stream recovery, resumption from Redis checkpoints,\n * and fault-tolerant streaming for long-running AI operations.\n *\n * @module @od-oneapp/ai-platform/streaming/infra/resilience\n */\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Stream checkpoint for resumption\n */\nexport interface StreamCheckpoint {\n  /** Unique stream ID */\n  streamId: string;\n  /** Sequence number of last processed chunk */\n  sequenceNumber: number;\n  /** Accumulated text so far */\n  accumulatedText: string;\n  /** Accumulated tool calls */\n  toolCalls: StreamToolCall[];\n  /** Token usage so far */\n  tokenUsage: {\n    promptTokens: number;\n    completionTokens: number;\n  };\n  /** Stream status */\n  status: 'active' | 'paused' | 'completed' | 'failed';\n  /** Creation timestamp */\n  createdAt: number;\n  /** Last update timestamp */\n  updatedAt: number;\n  /** Error if failed */\n  error?: string;\n  /** Custom metadata */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Tool call in stream\n */\nexport interface StreamToolCall {\n  id: string;\n  name: string;\n  args: string;\n  result?: string;\n}\n\n/**\n * Stream chunk with sequence info\n */\nexport interface SequencedChunk {\n  sequenceNumber: number;\n  type: 'text' | 'tool-call' | 'tool-result' | 'finish' | 'error';\n  data: unknown;\n  timestamp: number;\n}\n\nimport type { RedisClientExtended as RedisClient } from '../../../integrations/redis';\nexport type { RedisClient };\n\n/**\n * Resumable stream options\n */\nexport interface ResumableStreamOptions {\n  /** Redis client */\n  redis: RedisClient;\n  /** Key prefix for storage */\n  prefix?: string;\n  /** Checkpoint interval (chunks) */\n  checkpointInterval?: number;\n  /** TTL for checkpoints (seconds) */\n  checkpointTTL?: number;\n  /** Buffer size for chunks */\n  chunkBufferSize?: number;\n  /** Enable chunk buffering */\n  enableChunkBuffer?: boolean;\n}\n\n// ============================================================================\n// Stream Checkpoint Store\n// ============================================================================\n\n/**\n * Create a Redis-backed stream checkpoint store\n *\n * @example\n * ```typescript\n * const store = createStreamCheckpointStore(redis, {\n *   prefix: 'stream:',\n *   defaultTTL: 3600,\n * });\n *\n * await store.save(checkpoint);\n * const resumed = await store.load(streamId);\n * ```\n */\nexport function createStreamCheckpointStore(\n  redis: RedisClient,\n  options: {\n    prefix?: string;\n    defaultTTL?: number;\n  } = {},\n) {\n  const { prefix = 'stream:checkpoint:', defaultTTL = 3600 } = options;\n\n  function key(streamId: string): string {\n    return `${prefix}${streamId}`;\n  }\n\n  function chunkKey(streamId: string): string {\n    return `${prefix}${streamId}:chunks`;\n  }\n\n  return {\n    async save(checkpoint: StreamCheckpoint, ttl?: number): Promise<void> {\n      const effectiveTTL = ttl || defaultTTL;\n      await redis.set(key(checkpoint.streamId), JSON.stringify(checkpoint), { ex: effectiveTTL });\n    },\n\n    async load(streamId: string): Promise<StreamCheckpoint | null> {\n      const data = await redis.get(key(streamId));\n      if (!data) return null;\n      return JSON.parse(data) as StreamCheckpoint;\n    },\n\n    async exists(streamId: string): Promise<boolean> {\n      return (await redis.exists(key(streamId))) > 0;\n    },\n\n    async delete(streamId: string): Promise<void> {\n      await redis.del(key(streamId));\n      await redis.del(chunkKey(streamId));\n    },\n\n    async updateStatus(\n      streamId: string,\n      status: StreamCheckpoint['status'],\n      error?: string,\n    ): Promise<void> {\n      const checkpoint = await this.load(streamId);\n      if (checkpoint) {\n        checkpoint.status = status;\n        checkpoint.error = error;\n        checkpoint.updatedAt = Date.now();\n        await this.save(checkpoint);\n      }\n    },\n\n    async appendChunks(streamId: string, chunks: SequencedChunk[]): Promise<void> {\n      if (chunks.length === 0) return;\n      await redis.rpush(chunkKey(streamId), ...chunks.map(c => JSON.stringify(c)));\n    },\n\n    async getChunks(streamId: string, fromSequence: number): Promise<SequencedChunk[]> {\n      const allChunks = await redis.lrange(chunkKey(streamId), 0, -1);\n      return allChunks\n        .map((c: string) => JSON.parse(c) as SequencedChunk)\n        .filter((c: SequencedChunk) => c.sequenceNumber >= fromSequence);\n    },\n\n    async trimChunks(streamId: string, keepLast: number): Promise<void> {\n      await redis.ltrim(chunkKey(streamId), -keepLast, -1);\n    },\n\n    async extend(streamId: string, ttl?: number): Promise<void> {\n      const effectiveTTL = ttl || defaultTTL;\n      await redis.expire(key(streamId), effectiveTTL);\n      await redis.expire(chunkKey(streamId), effectiveTTL);\n    },\n  };\n}\n\n// ============================================================================\n// Resumable Stream\n// ============================================================================\n\n/**\n * Create a resumable stream wrapper\n *\n * Wraps an AI SDK stream to add checkpointing and resumption capability.\n *\n * @example\n * ```typescript\n * const resumable = createResumableStream({\n *   redis,\n *   checkpointInterval: 10,\n * });\n *\n * // Start new stream\n * const { streamId, stream } = await resumable.start(originalStream);\n *\n * // Resume from checkpoint\n * const resumed = await resumable.resume(streamId, newStream);\n * ```\n */\nexport function createResumableStream(options: ResumableStreamOptions) {\n  const {\n    redis,\n    prefix = 'resumable:',\n    checkpointInterval = 10,\n    checkpointTTL = 3600,\n    chunkBufferSize = 100,\n    enableChunkBuffer = true,\n  } = options;\n\n  const store = createStreamCheckpointStore(redis, {\n    prefix,\n    defaultTTL: checkpointTTL,\n  });\n\n  function generateStreamId(): string {\n    return `stream_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;\n  }\n\n  return {\n    /**\n     * Start a new resumable stream\n     */\n    async start<T>(\n      sourceStream: AsyncIterable<T>,\n      options: {\n        streamId?: string;\n        metadata?: Record<string, unknown>;\n        onCheckpoint?: (checkpoint: StreamCheckpoint) => void;\n      } = {},\n    ): Promise<{\n      streamId: string;\n      stream: AsyncGenerator<T>;\n      getCheckpoint: () => Promise<StreamCheckpoint | null>;\n    }> {\n      const streamId = options.streamId || generateStreamId();\n\n      // Initialize checkpoint\n      const checkpoint: StreamCheckpoint = {\n        streamId,\n        sequenceNumber: 0,\n        accumulatedText: '',\n        toolCalls: [],\n        tokenUsage: { promptTokens: 0, completionTokens: 0 },\n        status: 'active',\n        createdAt: Date.now(),\n        updatedAt: Date.now(),\n        metadata: options.metadata,\n      };\n\n      await store.save(checkpoint, checkpointTTL);\n\n      let sequenceNumber = 0;\n      const chunkBuffer: SequencedChunk[] = [];\n\n      async function* wrappedStream(): AsyncGenerator<T> {\n        try {\n          for await (const chunk of sourceStream) {\n            sequenceNumber++;\n\n            // Process chunk based on type\n            const sequencedChunk = processChunk(chunk, sequenceNumber);\n\n            // Buffer chunks\n            if (enableChunkBuffer) {\n              chunkBuffer.push(sequencedChunk);\n              if (chunkBuffer.length >= chunkBufferSize) {\n                await store.appendChunks(streamId, chunkBuffer);\n                chunkBuffer.length = 0;\n              }\n            }\n\n            // Update checkpoint periodically\n            if (sequenceNumber % checkpointInterval === 0) {\n              await updateCheckpoint(sequencedChunk);\n            }\n\n            yield chunk;\n          }\n\n          // Final checkpoint\n          checkpoint.status = 'completed';\n          checkpoint.sequenceNumber = sequenceNumber;\n          checkpoint.updatedAt = Date.now();\n          await store.save(checkpoint, checkpointTTL);\n\n          // Flush remaining chunks\n          if (enableChunkBuffer && chunkBuffer.length > 0) {\n            await store.appendChunks(streamId, chunkBuffer);\n          }\n\n          options.onCheckpoint?.(checkpoint);\n        } catch (error) {\n          checkpoint.status = 'failed';\n          checkpoint.error = error instanceof Error ? error.message : String(error);\n          checkpoint.updatedAt = Date.now();\n          await store.save(checkpoint, checkpointTTL);\n          throw error;\n        }\n      }\n\n      function processChunk(chunk: T, seq: number): SequencedChunk {\n        const chunkObj = chunk as Record<string, unknown>;\n        let type: SequencedChunk['type'] = 'text';\n\n        if (chunkObj.type === 'tool-call') type = 'tool-call';\n        else if (chunkObj.type === 'tool-result') type = 'tool-result';\n        else if (chunkObj.type === 'finish') type = 'finish';\n        else if (chunkObj.type === 'error') type = 'error';\n\n        return {\n          sequenceNumber: seq,\n          type,\n          data: chunk,\n          timestamp: Date.now(),\n        };\n      }\n\n      async function updateCheckpoint(chunk: SequencedChunk): Promise<void> {\n        checkpoint.sequenceNumber = chunk.sequenceNumber;\n        checkpoint.updatedAt = Date.now();\n\n        // Accumulate text\n        if (chunk.type === 'text') {\n          const textData = chunk.data as { textDelta?: string };\n          if (textData.textDelta) {\n            checkpoint.accumulatedText += textData.textDelta;\n          }\n        }\n\n        // Track tool calls\n        if (chunk.type === 'tool-call') {\n          const toolData = chunk.data as { toolCallId?: string; toolName?: string; args?: string };\n          if (toolData.toolCallId) {\n            checkpoint.toolCalls.push({\n              id: toolData.toolCallId,\n              name: toolData.toolName || '',\n              args: toolData.args || '',\n            });\n          }\n        }\n\n        await store.save(checkpoint, checkpointTTL);\n        options.onCheckpoint?.(checkpoint);\n      }\n\n      return {\n        streamId,\n        stream: wrappedStream(),\n        getCheckpoint: () => store.load(streamId),\n      };\n    },\n\n    /**\n     * Resume a stream from checkpoint\n     */\n    async resume<T>(\n      streamId: string,\n      newSourceStream: AsyncIterable<T>,\n      options: {\n        replayBufferedChunks?: boolean;\n        onReplay?: (chunk: SequencedChunk) => void;\n      } = {},\n    ): Promise<{\n      checkpoint: StreamCheckpoint;\n      stream: AsyncGenerator<T>;\n      skippedChunks: number;\n    }> {\n      const checkpoint = await store.load(streamId);\n      if (!checkpoint) {\n        throw new Error(`No checkpoint found for stream: ${streamId}`);\n      }\n\n      const activeCheckpoint = checkpoint;\n\n      if (activeCheckpoint.status === 'completed') {\n        throw new Error(`Stream already completed: ${streamId}`);\n      }\n\n      const resumeFromSequence = activeCheckpoint.sequenceNumber;\n      let currentSequence = resumeFromSequence;\n\n      // Optionally replay buffered chunks\n      if (options.replayBufferedChunks) {\n        const bufferedChunks = await store.getChunks(streamId, resumeFromSequence);\n        for (const chunk of bufferedChunks) {\n          options.onReplay?.(chunk);\n        }\n      }\n\n      // Update checkpoint status\n      activeCheckpoint.status = 'active';\n      activeCheckpoint.updatedAt = Date.now();\n      await store.save(activeCheckpoint, checkpointTTL);\n\n      async function* resumedStream(): AsyncGenerator<T> {\n        for await (const chunk of newSourceStream) {\n          currentSequence++;\n\n          // Skip chunks we've already processed\n          if (currentSequence <= resumeFromSequence) {\n            continue;\n          }\n\n          // Update checkpoint periodically\n          if (currentSequence % checkpointInterval === 0) {\n            activeCheckpoint.sequenceNumber = currentSequence;\n            activeCheckpoint.updatedAt = Date.now();\n            await store.save(activeCheckpoint, checkpointTTL);\n          }\n\n          yield chunk;\n        }\n\n        // Final checkpoint\n        activeCheckpoint.status = 'completed';\n        activeCheckpoint.sequenceNumber = currentSequence;\n        activeCheckpoint.updatedAt = Date.now();\n        await store.save(activeCheckpoint, checkpointTTL);\n      }\n\n      return {\n        checkpoint: activeCheckpoint,\n        stream: resumedStream(),\n        skippedChunks: 0, // Will be updated during iteration\n      };\n    },\n\n    /**\n     * Pause a stream (mark for later resumption)\n     */\n    async pause(streamId: string): Promise<void> {\n      await store.updateStatus(streamId, 'paused');\n    },\n\n    /**\n     * Get checkpoint for a stream\n     */\n    async getCheckpoint(streamId: string): Promise<StreamCheckpoint | null> {\n      return store.load(streamId);\n    },\n\n    /**\n     * Check if stream can be resumed\n     */\n    async canResume(streamId: string): Promise<boolean> {\n      const checkpoint = await store.load(streamId);\n      return checkpoint !== null && checkpoint.status !== 'completed';\n    },\n\n    /**\n     * Delete stream checkpoint\n     */\n    async delete(streamId: string): Promise<void> {\n      await store.delete(streamId);\n    },\n\n    /**\n     * Extend TTL for active stream\n     */\n    async keepAlive(streamId: string, ttl?: number): Promise<void> {\n      await store.extend(streamId, ttl || checkpointTTL);\n    },\n\n    /**\n     * Get the underlying store\n     */\n    getStore() {\n      return store;\n    },\n  };\n}\n\n// ============================================================================\n// Retry Utilities\n// ============================================================================\n\n/**\n * Retry configuration\n */\nexport interface RetryConfig {\n  maxRetries: number;\n  initialDelayMs: number;\n  maxDelayMs: number;\n  backoffMultiplier: number;\n  retryableErrors?: string[];\n}\n\nconst DEFAULT_RETRY_CONFIG: RetryConfig = {\n  maxRetries: 3,\n  initialDelayMs: 1000,\n  maxDelayMs: 30000,\n  backoffMultiplier: 2,\n  retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ENOTFOUND', 'rate_limit'],\n};\n\n/**\n * Create a retry wrapper for stream operations\n */\nexport function createStreamRetry(config: Partial<RetryConfig> = {}) {\n  const { maxRetries, initialDelayMs, maxDelayMs, backoffMultiplier, retryableErrors } = {\n    ...DEFAULT_RETRY_CONFIG,\n    ...config,\n  };\n\n  function isRetryable(error: unknown): boolean {\n    if (!retryableErrors) return true;\n\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    const errorCode = (error as { code?: string }).code;\n\n    return retryableErrors.some(re => errorMessage.includes(re) || errorCode === re);\n  }\n\n  function calculateDelay(attempt: number): number {\n    const delay = initialDelayMs * Math.pow(backoffMultiplier, attempt);\n    return Math.min(delay, maxDelayMs);\n  }\n\n  return {\n    /**\n     * Execute with retry\n     */\n    async execute<T>(fn: () => Promise<T>): Promise<T> {\n      let lastError: unknown;\n\n      for (let attempt = 0; attempt <= maxRetries; attempt++) {\n        try {\n          return await fn();\n        } catch (error) {\n          lastError = error;\n\n          if (attempt === maxRetries || !isRetryable(error)) {\n            throw error;\n          }\n\n          const delay = calculateDelay(attempt);\n          await new Promise(resolve => setTimeout(resolve, delay));\n        }\n      }\n\n      throw lastError;\n    },\n\n    /**\n     * Wrap an async generator with retry logic\n     */\n    async *wrapStream<T>(\n      createStream: () => AsyncIterable<T>,\n      options: {\n        onRetry?: (attempt: number, error: unknown) => void;\n        resumeFrom?: number;\n      } = {},\n    ): AsyncGenerator<T> {\n      let attempt = 0;\n      let processedCount = options.resumeFrom || 0;\n\n      while (attempt <= maxRetries) {\n        try {\n          let currentCount = 0;\n          const stream = createStream();\n\n          for await (const chunk of stream) {\n            currentCount++;\n\n            // Skip already processed chunks on retry\n            if (currentCount <= processedCount) {\n              continue;\n            }\n\n            processedCount = currentCount;\n            yield chunk;\n          }\n\n          return; // Success\n        } catch (error) {\n          if (attempt === maxRetries || !isRetryable(error)) {\n            throw error;\n          }\n\n          options.onRetry?.(attempt, error);\n\n          const delay = calculateDelay(attempt);\n          await new Promise(resolve => setTimeout(resolve, delay));\n          attempt++;\n        }\n      }\n    },\n  };\n}\n\n// ============================================================================\n// Circuit Breaker\n// ============================================================================\n\n/**\n * Circuit breaker state\n */\nexport type CircuitState = 'closed' | 'open' | 'half-open';\n\n/**\n * Circuit breaker configuration\n */\nexport interface CircuitBreakerConfig {\n  failureThreshold: number;\n  resetTimeoutMs: number;\n  halfOpenRequests: number;\n}\n\n/**\n * Create a circuit breaker for stream operations\n */\nexport function createCircuitBreaker(config: Partial<CircuitBreakerConfig> = {}) {\n  const { failureThreshold = 5, resetTimeoutMs = 30000, halfOpenRequests = 1 } = config;\n\n  let state: CircuitState = 'closed';\n  let failures = 0;\n  let lastFailureTime = 0;\n  let halfOpenAttempts = 0;\n\n  return {\n    getState(): CircuitState {\n      // Check if we should transition from open to half-open\n      if (state === 'open' && Date.now() - lastFailureTime >= resetTimeoutMs) {\n        state = 'half-open';\n        halfOpenAttempts = 0;\n      }\n      return state;\n    },\n\n    async execute<T>(fn: () => Promise<T>): Promise<T> {\n      const currentState = this.getState();\n\n      if (currentState === 'open') {\n        throw new Error('Circuit breaker is open');\n      }\n\n      if (currentState === 'half-open' && halfOpenAttempts >= halfOpenRequests) {\n        throw new Error('Circuit breaker half-open limit reached');\n      }\n\n      if (currentState === 'half-open') {\n        halfOpenAttempts++;\n      }\n\n      try {\n        const result = await fn();\n\n        // Success - reset on closed, close on half-open\n        if (currentState === 'half-open') {\n          state = 'closed';\n          failures = 0;\n        } else {\n          failures = 0;\n        }\n\n        return result;\n      } catch (error) {\n        failures++;\n        lastFailureTime = Date.now();\n\n        if (currentState === 'half-open' || failures >= failureThreshold) {\n          state = 'open';\n        }\n\n        throw error;\n      }\n    },\n\n    reset(): void {\n      state = 'closed';\n      failures = 0;\n      halfOpenAttempts = 0;\n    },\n\n    getStats() {\n      return {\n        state: this.getState(),\n        failures,\n        lastFailureTime: lastFailureTime ? new Date(lastFailureTime) : null,\n      };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/streaming-infra-transport.d.mts

@@ -0,0 +1,57 @@
+//#region src/streaming/infra/transport/index.d.ts
+type TransportType = 'sse' | 'websocket' | 'http-streaming';
+interface TransportConfig {
+  readonly type: TransportType;
+  readonly url?: string;
+  readonly headers?: Record<string, string>;
+  readonly timeout?: number;
+}
+interface TransportAdapter<T> {
+  readonly type: TransportType;
+  connect(): AsyncIterable<T>;
+  send(chunk: T): Promise<void>;
+  close(): Promise<void>;
+  isConnected(): boolean;
+  onError(handler: (error: Error) => void): () => void;
+  onClose(handler: () => void): () => void;
+}
+interface SSEConfig extends TransportConfig {
+  readonly type: 'sse';
+  readonly url: string;
+  readonly withCredentials?: boolean;
+  readonly eventTypes?: string[];
+  readonly reconnectTimeout?: number;
+}
+interface WebSocketConfig extends TransportConfig {
+  readonly type: 'websocket';
+  readonly url: string;
+  readonly protocols?: string[];
+  readonly binaryType?: 'blob' | 'arraybuffer';
+  readonly pingInterval?: number;
+}
+interface HTTPStreamConfig extends TransportConfig {
+  readonly type: 'http-streaming';
+  readonly url: string;
+  readonly method?: 'GET' | 'POST';
+  readonly body?: unknown;
+}
+interface SSEEvent {
+  readonly id?: string;
+  readonly event?: string;
+  readonly data: string;
+  readonly retry?: number;
+}
+interface WebSocketMessage<T = unknown> {
+  readonly type: 'message' | 'binary';
+  readonly data: T;
+  readonly timestamp: Date;
+}
+declare function createSSETransport(config: SSEConfig): TransportAdapter<SSEEvent>;
+declare function createWebSocketTransport<T = unknown>(config: WebSocketConfig): TransportAdapter<WebSocketMessage<T>>;
+declare function createHTTPStreamTransport(config: HTTPStreamConfig): TransportAdapter<string>;
+declare function createTransport<T = unknown>(config: SSEConfig | WebSocketConfig | HTTPStreamConfig): TransportAdapter<T>;
+declare function parseSSEStream(text: string): SSEEvent[];
+declare function createMockTransport<T>(items: T[], delayMs?: number): TransportAdapter<T>;
+//#endregion
+export { HTTPStreamConfig, SSEConfig, SSEEvent, TransportAdapter, TransportConfig, TransportType, WebSocketConfig, WebSocketMessage, createHTTPStreamTransport, createMockTransport, createSSETransport, createTransport, createWebSocketTransport, parseSSEStream };
+//# sourceMappingURL=streaming-infra-transport.d.mts.map

package/dist/streaming-infra-transport.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-infra-transport.d.mts","names":[],"sources":["../src/streaming/infra/transport/index.ts"],"mappings":";KA4BY,aAAA;AAAA,UAGK,eAAA;EAAA,SACN,IAAA,EAAM,aAAA;EAAA,SACN,GAAA;EAAA,SACA,OAAA,GAAU,MAAA;EAAA,SACV,OAAA;AAAA;AAAA,UAIM,gBAAA;EAAA,SACN,IAAA,EAAM,aAAA;EACf,OAAA,IAAW,aAAA,CAAc,CAAA;EACzB,IAAA,CAAK,KAAA,EAAO,CAAA,GAAI,OAAA;EAChB,KAAA,IAAS,OAAA;EACT,WAAA;EACA,OAAA,CAAQ,OAAA,GAAU,KAAA,EAAO,KAAA;EACzB,OAAA,CAAQ,OAAA;AAAA;AAAA,UAIO,SAAA,SAAkB,eAAA;EAAA,SACxB,IAAA;EAAA,SACA,GAAA;EAAA,SACA,eAAA;EAAA,SACA,UAAA;EAAA,SACA,gBAAA;AAAA;AAAA,UAIM,eAAA,SAAwB,eAAA;EAAA,SAC9B,IAAA;EAAA,SACA,GAAA;EAAA,SACA,SAAA;EAAA,SACA,UAAA;EAAA,SACA,YAAA;AAAA;AAAA,UAIM,gBAAA,SAAyB,eAAA;EAAA,SAC/B,IAAA;EAAA,SACA,GAAA;EAAA,SACA,MAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAIM,QAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;AAAA;AAAA,UAIM,gBAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA,EAAM,CAAA;EAAA,SACN,SAAA,EAAW,IAAA;AAAA;AAAA,iBAuBN,kBAAA,CAAmB,MAAA,EAAQ,SAAA,GAAY,gBAAA,CAAiB,QAAA;AAAA,iBAuMxD,wBAAA,aAAA,CACd,MAAA,EAAQ,eAAA,GACP,gBAAA,CAAiB,gBAAA,CAAiB,CAAA;AAAA,iBA2LrB,yBAAA,CAA0B,MAAA,EAAQ,gBAAA,GAAmB,gBAAA;AAAA,iBAkJrD,eAAA,aAAA,CACd,MAAA,EAAQ,SAAA,GAAY,eAAA,GAAkB,gBAAA,GACrC,gBAAA,CAAiB,CAAA;AAAA,iBAwBJ,cAAA,CAAe,IAAA,WAAe,QAAA;AAAA,iBA2D9B,mBAAA,GAAA,CAAuB,KAAA,EAAO,CAAA,IAAK,OAAA,YAAsB,gBAAA,CAAiB,CAAA"}