@tanstack/ai 0.42.0 → 0.43.1

package/dist/esm/stream-durability.d.ts

@@ -0,0 +1,171 @@
+import { StreamChunk } from './types.js';
+/**
+ * A pluggable delivery-durability backend.
+ *
+ * Offsets are owned by the adapter and opaque to the transport. The generic
+ * parameter lets an adapter retain a branded string type across append, read,
+ * and resume without requiring core to understand its cursor format.
+ */
+export interface StreamDurability<TOffset extends string = string> {
+    /** Return the adapter offset captured from the request, or null for a producer. */
+    resumeFrom: () => TOffset | null;
+    /**
+     * Persist a batch before it is delivered and return exactly one resumable
+     * offset for each chunk, in the same order.
+     */
+    append: (chunks: Array<StreamChunk>) => Promise<Array<TOffset>>;
+    /** Replay chunks strictly after the supplied adapter-owned offset. */
+    read: (offset: TOffset, signal?: AbortSignal) => AsyncIterable<{
+        offset: TOffset;
+        chunk: StreamChunk;
+    }>;
+    /**
+     * Terminalize the producer log and unblock live readers. Core awaits this
+     * for every producer exit, including completion, cancellation, and failure.
+     */
+    close: () => Promise<void>;
+    /**
+     * Everything stored for this run **at the moment of the call**, in append
+     * order, then resolve.
+     *
+     * This is the bounded counterpart to {@link StreamDurability.read}. `read`
+     * tails: it parks until the log is terminalized or the caller aborts, so it
+     * cannot be used to inspect a log whose producer died without calling
+     * `close` — that log stays open forever and a `for await` over it never
+     * finishes. `snapshot` exists for exactly that case: a producer resuming a
+     * run needs to see the prefix a previous host already stored so it can line
+     * its own output up against it, and it needs that read to *return*.
+     *
+     * Implementations MUST:
+     *
+     * - never wait for more entries — resolve with what is stored, including
+     *   while the log is still open and still being appended to;
+     * - resolve to an empty array for a run with nothing stored, rather than
+     *   throwing. In particular an implementation must not reuse the
+     *   unknown-run failure path a from-start `read` join takes (`read('-1')` on
+     *   an empty log is allowed to fail; `snapshot()` is not). A backend over a
+     *   network may of course still reject on a transport, protocol, or
+     *   authorization failure — that is a failed call, not an empty run;
+     * - return a fresh array the caller can keep or mutate without reaching the
+     *   stored log through it.
+     *
+     * The result is a point-in-time view and carries no lock: a concurrent
+     * `append` may land immediately after the snapshot is taken, so a caller
+     * must not treat the last returned offset as the permanent tail.
+     */
+    snapshot: () => Promise<Array<{
+        offset: TOffset;
+        chunk: StreamChunk;
+    }>>;
+}
+/**
+ * A {@link StreamDurability} that can re-persist an already-stored range
+ * idempotently.
+ *
+ * A run driver resuming after a crash re-derives the same offsets from its
+ * source position, so replaying an overlapping range must be a no-op rather
+ * than producing duplicates. That capability is deliberately a **separate,
+ * optional method** instead of an optional parameter on `append`:
+ *
+ * - Only adapters that actually support it return this type, so a consumer
+ *   requiring the capability asks for `UpsertableStreamDurability` and a
+ *   mismatch is a compile error rather than a runtime failure buried in a
+ *   run log.
+ * - Pairing each chunk with its offset structurally makes a length mismatch
+ *   and an unpaired chunk unrepresentable. A sparse hole is still
+ *   representable, so implementations must reject one explicitly.
+ *
+ * Implementations MUST validate the entire batch before mutating any stored
+ * state (so a rejected call never partially applies), MUST reject an offset
+ * they did not mint themselves (every accepted offset is resumable by
+ * definition), MUST reject an offset repeated within one batch, and MUST
+ * reject a hole in the entries array.
+ */
+export interface UpsertableStreamDurability<TOffset extends string = string> extends StreamDurability<TOffset> {
+    /**
+     * Persist a batch at caller-supplied offsets, replacing any entry already
+     * stored at the same offset. Returns the offsets in the order supplied.
+     */
+    upsert: (entries: Array<{
+        chunk: StreamChunk;
+        offset: TOffset;
+    }>) => Promise<Array<TOffset>>;
+}
+/**
+ * The run id a request names: `X-Run-Id` header first, then `?runId`.
+ *
+ * The single implementation of that precedence, shared by the durability
+ * adapters below and by the resume response helpers' run driver
+ * (`stream-to-response.ts`), so the helper and the adapter can never disagree
+ * about which run a request is talking about.
+ */
+export declare function resolveResumeRunId(request: Request): string | null;
+/** Options for the in-process delivery-durability backend. */
+export interface MemoryStreamOptions {
+    /**
+     * Milliseconds a from-start join waits for the run's first chunk before
+     * throwing. Defaults to {@link DEFAULT_FIRST_CHUNK_DEADLINE_MS} (100ms) —
+     * raise it if a producer can legitimately start long after a joiner attaches.
+     */
+    firstChunkDeadlineMs?: number;
+}
+/**
+ * Explicit construction for {@link memoryStream}, for callers that don't have
+ * the incoming `Request` — e.g. a TanStack Start server function implementing
+ * a `joinRun` replay for a run id it received as call data:
+ *
+ * ```ts
+ * const durability = memoryStream({ runId })
+ * for await (const chunk of replayRunStream(durability)) yield chunk
+ * ```
+ */
+export interface MemoryStreamInit {
+    /** The run this durability adapter attaches to. */
+    runId: string;
+    /**
+     * Resume offset captured by the consumer (`resumeFrom()` returns it).
+     * Defaults to `null` (a producer / from-start reader).
+     */
+    offset?: string | null;
+}
+/**
+ * The zero-infrastructure delivery-durability backend. Its versioned cursor is
+ * deliberately private: callers and core only pass the returned string back.
+ *
+ * Construct from the incoming `Request` (HTTP transports) or from an explicit
+ * {@link MemoryStreamInit} (server functions / direct calls that already know
+ * the run id).
+ *
+ * Logs live in a process-global map, so this backend is for development, tests,
+ * and single-process deployments only. Completed runs are evicted after a grace
+ * window (see {@link COMPLETED_LOG_TTL_MS}); a resume of an evicted or unknown
+ * run fails loudly rather than hanging.
+ */
+export declare function memoryStream(source: Request | MemoryStreamInit, options?: MemoryStreamOptions): UpsertableStreamDurability;
+/**
+ * Replay a run's delivery-durability log as a bare stream of chunks, for
+ * callers that serve a `joinRun` handler without an HTTP `Response` — e.g. a
+ * TanStack Start server function returning an async iterable:
+ *
+ * ```ts
+ * async function* joinImageRun({ data: runId }: { data: string }) {
+ *   yield* replayRunStream(memoryStream({ runId }))
+ * }
+ *
+ * // Serve it from a server function whose handler is the generator above
+ * // (`createServerFn({ method: 'GET' }).inputValidator(...)`).
+ * ```
+ *
+ * NOTE: the example deliberately declares the generator separately instead of
+ * inlining it into the server-fn builder chain. TanStack Start's server-fn
+ * Vite plugin decides whether a module needs compiling by regex-matching the
+ * SOURCE for a dotted `handler(` call, and JSDoc survives into `dist` — an
+ * inlined chain here would make every Start app treat this package as a
+ * server-fn module and try to resolve its framework's `@tanstack/*-start`
+ * package, failing the build wherever that framework is not the one installed.
+ *
+ * Reads from `offset` (default `'-1'` — from the start) and tails until the
+ * producer closes the log or `signal` aborts, exactly like the HTTP
+ * `resumeServerSentEventsResponse` path.
+ */
+export declare function replayRunStream<TOffset extends string>(durability: StreamDurability<TOffset>, offset?: TOffset, signal?: AbortSignal): AsyncGenerator<StreamChunk>;

package/dist/esm/stream-durability.js

@@ -0,0 +1,295 @@
+//#region src/stream-durability.ts
+var MEMORY_OFFSET_PREFIX = "memory:v1:";
+function encodeMemoryOffset(runId, seq) {
+	return `${MEMORY_OFFSET_PREFIX}${encodeURIComponent(runId)}:${seq}`;
+}
+function decodeMemoryOffset(offset) {
+	if (!offset.startsWith(MEMORY_OFFSET_PREFIX)) throw new Error(`Invalid memory stream offset: ${offset}`);
+	const encoded = offset.slice(10);
+	const separator = encoded.lastIndexOf(":");
+	if (separator === -1) throw new Error(`Invalid memory stream offset: ${offset}`);
+	const runId = decodeURIComponent(encoded.slice(0, separator));
+	const seq = Number(encoded.slice(separator + 1));
+	if (!Number.isSafeInteger(seq) || seq < 1) throw new Error(`Invalid memory stream offset: ${offset}`);
+	return {
+		runId,
+		seq
+	};
+}
+function readResumeOffset(request) {
+	const header = request.headers.get("Last-Event-ID");
+	if (header) return header;
+	try {
+		return new URL(request.url).searchParams.get("offset");
+	} catch {
+		return null;
+	}
+}
+/**
+* The run id a request names: `X-Run-Id` header first, then `?runId`.
+*
+* The single implementation of that precedence, shared by the durability
+* adapters below and by the resume response helpers' run driver
+* (`stream-to-response.ts`), so the helper and the adapter can never disagree
+* about which run a request is talking about.
+*/
+function resolveResumeRunId(request) {
+	const header = request.headers.get("X-Run-Id");
+	if (header) return header;
+	try {
+		return new URL(request.url).searchParams.get("runId");
+	} catch {
+		return null;
+	}
+}
+function assertValidRunId(runId) {
+	if (runId.length === 0 || /[\r\n]/.test(runId)) throw new Error(`Invalid runId (must be non-empty and contain no CR/LF): ${JSON.stringify(runId)}`);
+	return runId;
+}
+function resolveMemoryRunId(request, resumeOffset) {
+	if (resumeOffset !== null && resumeOffset !== "-1" && resumeOffset !== "now") return assertValidRunId(decodeMemoryOffset(resumeOffset).runId);
+	const requestedRunId = resolveResumeRunId(request);
+	return requestedRunId === null ? crypto.randomUUID() : assertValidRunId(requestedRunId);
+}
+function memoryThreshold(offset, runId, tail) {
+	if (offset === "-1") return -1;
+	if (offset === "now") return tail;
+	const decoded = decodeMemoryOffset(offset);
+	if (decoded.runId !== runId) throw new Error(`Memory stream offset belongs to run ${JSON.stringify(decoded.runId)}, not ${JSON.stringify(runId)}`);
+	return decoded.seq;
+}
+/**
+* Bounds for the in-process log store. `memoryStream` is the dev/single-process
+* backend; without eviction its module-global Map would grow without bound on a
+* long-lived server (one retained chunk buffer per run, forever). Completed logs
+* are swept after a grace window — late resumers/joiners still work briefly —
+* and a hard cap drops the oldest completed logs under pressure. Active
+* (incomplete) logs are never evicted, so an in-flight run is never dropped.
+*/
+var MAX_MEMORY_RUNS = 1024;
+var COMPLETED_LOG_TTL_MS = 5 * 6e4;
+/**
+* How long a from-start join (`-1` / `now`) waits for a run's first chunk before
+* failing. Bounds the "joined a run that never produces" case so a consumer
+* gets a surfaced error instead of an indefinitely-open, event-less connection.
+*
+* Defaults short: the common from-start join is a reload rejoining a run whose
+* producer ran in a PRIOR request, so an in-flight run's log already holds
+* chunks (it streams immediately, deadline never applies) and an empty log means
+* the run is gone — failing fast lets the client re-enable input near-instantly
+* instead of hanging. Raise `firstChunkDeadlineMs` for backends where a producer
+* legitimately starts well after a joiner attaches (a queued/deferred job).
+*/
+var DEFAULT_FIRST_CHUNK_DEADLINE_MS = 100;
+var memoryLogs = /* @__PURE__ */ new Map();
+/**
+* Evict completed logs past their grace window, then, if still over the cap,
+* drop the oldest completed logs (the Map preserves insertion order) until back
+* under the cap. Never touches an incomplete (in-flight) log.
+*/
+function sweepMemoryLogs(now) {
+	for (const [id, log] of memoryLogs) if (log.complete && log.completedAt !== void 0 && now - log.completedAt > COMPLETED_LOG_TTL_MS) memoryLogs.delete(id);
+	if (memoryLogs.size <= MAX_MEMORY_RUNS) return;
+	for (const [id, log] of memoryLogs) {
+		if (memoryLogs.size <= MAX_MEMORY_RUNS) break;
+		if (log.complete) memoryLogs.delete(id);
+	}
+}
+function getOrCreateLog(id) {
+	let log = memoryLogs.get(id);
+	if (!log) {
+		sweepMemoryLogs(Date.now());
+		log = {
+			entries: [],
+			complete: false,
+			completedAt: void 0,
+			waiters: []
+		};
+		memoryLogs.set(id, log);
+	}
+	return log;
+}
+function markComplete(log) {
+	if (!log.complete) {
+		log.complete = true;
+		log.completedAt = Date.now();
+	}
+}
+function wakeWaiters(log) {
+	const waiters = log.waiters;
+	log.waiters = [];
+	for (const wake of waiters) wake();
+}
+/**
+* The zero-infrastructure delivery-durability backend. Its versioned cursor is
+* deliberately private: callers and core only pass the returned string back.
+*
+* Construct from the incoming `Request` (HTTP transports) or from an explicit
+* {@link MemoryStreamInit} (server functions / direct calls that already know
+* the run id).
+*
+* Logs live in a process-global map, so this backend is for development, tests,
+* and single-process deployments only. Completed runs are evicted after a grace
+* window (see {@link COMPLETED_LOG_TTL_MS}); a resume of an evicted or unknown
+* run fails loudly rather than hanging.
+*/
+function memoryStream(source, options = {}) {
+	const resumeOffset = source instanceof Request ? readResumeOffset(source) : source.offset ?? null;
+	const runId = source instanceof Request ? resolveMemoryRunId(source, resumeOffset) : assertValidRunId(source.runId);
+	const firstChunkDeadlineMs = options.firstChunkDeadlineMs ?? DEFAULT_FIRST_CHUNK_DEADLINE_MS;
+	return {
+		resumeFrom: () => resumeOffset,
+		append: async (chunks) => {
+			const log = getOrCreateLog(runId);
+			const firstSeq = (log.entries.at(-1)?.seq ?? 0) + 1;
+			const offsets = chunks.map((chunk, index) => {
+				const seq = firstSeq + index;
+				const offset = encodeMemoryOffset(runId, seq);
+				log.entries.push({
+					seq,
+					offset,
+					chunk
+				});
+				return offset;
+			});
+			wakeWaiters(log);
+			return offsets;
+		},
+		upsert: async (entries) => {
+			const log = getOrCreateLog(runId);
+			const tailSeq = log.entries.at(-1)?.seq ?? 0;
+			const seen = /* @__PURE__ */ new Set();
+			let plannedTailSeq = tailSeq;
+			const plan = Array.from(entries, (entry, index) => {
+				if (entry === void 0) throw new Error(`memoryStream: entries[${index}] is missing; entries must be dense`);
+				const { chunk, offset } = entry;
+				let decoded;
+				try {
+					decoded = decodeMemoryOffset(offset);
+				} catch (cause) {
+					throw new Error(`memoryStream: entries[${index}].offset ${JSON.stringify(offset)} is not a resumable memory stream offset: ${cause instanceof Error ? cause.message : String(cause)}`);
+				}
+				if (decoded.runId !== runId) throw new Error(`memoryStream: entries[${index}].offset ${JSON.stringify(offset)} belongs to run ${JSON.stringify(decoded.runId)}, not ${JSON.stringify(runId)}`);
+				const seq = decoded.seq;
+				if (seen.has(offset)) throw new Error(`memoryStream: entries[${index}].offset ${JSON.stringify(offset)} is repeated within the batch; each offset may appear at most once`);
+				seen.add(offset);
+				const existing = log.entries.find((stored) => stored.offset === offset);
+				if (existing) return {
+					kind: "replace",
+					existing,
+					chunk
+				};
+				if (seq <= plannedTailSeq) throw new Error(`memoryStream: entries[${index}].offset ${JSON.stringify(offset)} is not stored yet but claims position ${seq}, at or before the tail ${plannedTailSeq}; a new offset must come after every stored and preceding entry`);
+				plannedTailSeq = seq;
+				return {
+					kind: "push",
+					seq,
+					offset,
+					chunk
+				};
+			});
+			for (const step of plan) if (step.kind === "replace") step.existing.chunk = step.chunk;
+			else log.entries.push({
+				seq: step.seq,
+				offset: step.offset,
+				chunk: step.chunk
+			});
+			wakeWaiters(log);
+			return plan.map((step) => step.kind === "replace" ? step.existing.offset : step.offset);
+		},
+		snapshot: () => {
+			const log = memoryLogs.get(runId);
+			if (log === void 0) return Promise.resolve([]);
+			return Promise.resolve(log.entries.map((entry) => ({
+				offset: entry.offset,
+				chunk: entry.chunk
+			})));
+		},
+		close: () => {
+			const log = getOrCreateLog(runId);
+			markComplete(log);
+			wakeWaiters(log);
+			return Promise.resolve();
+		},
+		read: async function* (offset, signal) {
+			const isFromStartJoin = offset === "-1" || offset === "now";
+			let log = memoryLogs.get(runId);
+			if (log === void 0 || log.entries.length === 0 && !log.complete) {
+				if (!isFromStartJoin) throw new Error(`Unknown or expired memory stream run: ${JSON.stringify(runId)}`);
+				log = getOrCreateLog(runId);
+			}
+			const threshold = memoryThreshold(offset, runId, log.entries.at(-1)?.seq ?? 0);
+			let index = 0;
+			for (;;) {
+				while (index < log.entries.length) {
+					const entry = log.entries[index];
+					index += 1;
+					if (entry && entry.seq > threshold) yield {
+						offset: entry.offset,
+						chunk: entry.chunk
+					};
+				}
+				if (log.complete || signal?.aborted) return;
+				const deadlineForFirstChunk = log.entries.length === 0 ? firstChunkDeadlineMs : void 0;
+				await new Promise((resolve, reject) => {
+					let timer;
+					const cleanup = () => {
+						if (timer !== void 0) clearTimeout(timer);
+						signal?.removeEventListener("abort", onAbort);
+						const waiterIndex = log.waiters.indexOf(wake);
+						if (waiterIndex !== -1) log.waiters.splice(waiterIndex, 1);
+					};
+					const onAbort = () => {
+						cleanup();
+						resolve();
+					};
+					const wake = () => {
+						cleanup();
+						resolve();
+					};
+					log.waiters.push(wake);
+					signal?.addEventListener("abort", onAbort, { once: true });
+					if (deadlineForFirstChunk !== void 0) timer = setTimeout(() => {
+						cleanup();
+						if (log.entries.length === 0 && !log.complete && memoryLogs.get(runId) === log) memoryLogs.delete(runId);
+						reject(/* @__PURE__ */ new Error(`Memory stream run produced no data within ${deadlineForFirstChunk}ms: ${JSON.stringify(runId)}`));
+					}, deadlineForFirstChunk);
+				});
+			}
+		}
+	};
+}
+/**
+* Replay a run's delivery-durability log as a bare stream of chunks, for
+* callers that serve a `joinRun` handler without an HTTP `Response` — e.g. a
+* TanStack Start server function returning an async iterable:
+*
+* ```ts
+* async function* joinImageRun({ data: runId }: { data: string }) {
+*   yield* replayRunStream(memoryStream({ runId }))
+* }
+*
+* // Serve it from a server function whose handler is the generator above
+* // (`createServerFn({ method: 'GET' }).inputValidator(...)`).
+* ```
+*
+* NOTE: the example deliberately declares the generator separately instead of
+* inlining it into the server-fn builder chain. TanStack Start's server-fn
+* Vite plugin decides whether a module needs compiling by regex-matching the
+* SOURCE for a dotted `handler(` call, and JSDoc survives into `dist` — an
+* inlined chain here would make every Start app treat this package as a
+* server-fn module and try to resolve its framework's `@tanstack/*-start`
+* package, failing the build wherever that framework is not the one installed.
+*
+* Reads from `offset` (default `'-1'` — from the start) and tails until the
+* producer closes the log or `signal` aborts, exactly like the HTTP
+* `resumeServerSentEventsResponse` path.
+*/
+async function* replayRunStream(durability, offset, signal) {
+	const from = offset ?? "-1";
+	for await (const { chunk } of durability.read(from, signal)) yield chunk;
+}
+//#endregion
+export { memoryStream, replayRunStream, resolveResumeRunId };
+
+//# sourceMappingURL=stream-durability.js.map

package/dist/esm/stream-durability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-durability.js","names":[],"sources":["../../src/stream-durability.ts"],"sourcesContent":["import type { StreamChunk } from './types'\n\n/**\n * A pluggable delivery-durability backend.\n *\n * Offsets are owned by the adapter and opaque to the transport. The generic\n * parameter lets an adapter retain a branded string type across append, read,\n * and resume without requiring core to understand its cursor format.\n */\nexport interface StreamDurability<TOffset extends string = string> {\n  /** Return the adapter offset captured from the request, or null for a producer. */\n  resumeFrom: () => TOffset | null\n  /**\n   * Persist a batch before it is delivered and return exactly one resumable\n   * offset for each chunk, in the same order.\n   */\n  append: (chunks: Array<StreamChunk>) => Promise<Array<TOffset>>\n  /** Replay chunks strictly after the supplied adapter-owned offset. */\n  read: (\n    offset: TOffset,\n    signal?: AbortSignal,\n  ) => AsyncIterable<{ offset: TOffset; chunk: StreamChunk }>\n  /**\n   * Terminalize the producer log and unblock live readers. Core awaits this\n   * for every producer exit, including completion, cancellation, and failure.\n   */\n  close: () => Promise<void>\n  /**\n   * Everything stored for this run **at the moment of the call**, in append\n   * order, then resolve.\n   *\n   * This is the bounded counterpart to {@link StreamDurability.read}. `read`\n   * tails: it parks until the log is terminalized or the caller aborts, so it\n   * cannot be used to inspect a log whose producer died without calling\n   * `close` — that log stays open forever and a `for await` over it never\n   * finishes. `snapshot` exists for exactly that case: a producer resuming a\n   * run needs to see the prefix a previous host already stored so it can line\n   * its own output up against it, and it needs that read to *return*.\n   *\n   * Implementations MUST:\n   *\n   * - never wait for more entries — resolve with what is stored, including\n   *   while the log is still open and still being appended to;\n   * - resolve to an empty array for a run with nothing stored, rather than\n   *   throwing. In particular an implementation must not reuse the\n   *   unknown-run failure path a from-start `read` join takes (`read('-1')` on\n   *   an empty log is allowed to fail; `snapshot()` is not). A backend over a\n   *   network may of course still reject on a transport, protocol, or\n   *   authorization failure — that is a failed call, not an empty run;\n   * - return a fresh array the caller can keep or mutate without reaching the\n   *   stored log through it.\n   *\n   * The result is a point-in-time view and carries no lock: a concurrent\n   * `append` may land immediately after the snapshot is taken, so a caller\n   * must not treat the last returned offset as the permanent tail.\n   */\n  snapshot: () => Promise<Array<{ offset: TOffset; chunk: StreamChunk }>>\n}\n\n/**\n * A {@link StreamDurability} that can re-persist an already-stored range\n * idempotently.\n *\n * A run driver resuming after a crash re-derives the same offsets from its\n * source position, so replaying an overlapping range must be a no-op rather\n * than producing duplicates. That capability is deliberately a **separate,\n * optional method** instead of an optional parameter on `append`:\n *\n * - Only adapters that actually support it return this type, so a consumer\n *   requiring the capability asks for `UpsertableStreamDurability` and a\n *   mismatch is a compile error rather than a runtime failure buried in a\n *   run log.\n * - Pairing each chunk with its offset structurally makes a length mismatch\n *   and an unpaired chunk unrepresentable. A sparse hole is still\n *   representable, so implementations must reject one explicitly.\n *\n * Implementations MUST validate the entire batch before mutating any stored\n * state (so a rejected call never partially applies), MUST reject an offset\n * they did not mint themselves (every accepted offset is resumable by\n * definition), MUST reject an offset repeated within one batch, and MUST\n * reject a hole in the entries array.\n */\nexport interface UpsertableStreamDurability<\n  TOffset extends string = string,\n> extends StreamDurability<TOffset> {\n  /**\n   * Persist a batch at caller-supplied offsets, replacing any entry already\n   * stored at the same offset. Returns the offsets in the order supplied.\n   */\n  upsert: (\n    entries: Array<{ chunk: StreamChunk; offset: TOffset }>,\n  ) => Promise<Array<TOffset>>\n}\n\nconst MEMORY_OFFSET_PREFIX = 'memory:v1:'\n\ninterface MemoryOffset {\n  runId: string\n  seq: number\n}\n\nfunction encodeMemoryOffset(runId: string, seq: number): string {\n  return `${MEMORY_OFFSET_PREFIX}${encodeURIComponent(runId)}:${seq}`\n}\n\nfunction decodeMemoryOffset(offset: string): MemoryOffset {\n  if (!offset.startsWith(MEMORY_OFFSET_PREFIX)) {\n    throw new Error(`Invalid memory stream offset: ${offset}`)\n  }\n  const encoded = offset.slice(MEMORY_OFFSET_PREFIX.length)\n  const separator = encoded.lastIndexOf(':')\n  if (separator === -1) {\n    throw new Error(`Invalid memory stream offset: ${offset}`)\n  }\n  const runId = decodeURIComponent(encoded.slice(0, separator))\n  const seq = Number(encoded.slice(separator + 1))\n  if (!Number.isSafeInteger(seq) || seq < 1) {\n    throw new Error(`Invalid memory stream offset: ${offset}`)\n  }\n  return { runId, seq }\n}\n\nfunction readResumeOffset(request: Request): string | null {\n  const header = request.headers.get('Last-Event-ID')\n  if (header) return header\n  try {\n    return new URL(request.url).searchParams.get('offset')\n  } catch {\n    return null\n  }\n}\n\n/**\n * The run id a request names: `X-Run-Id` header first, then `?runId`.\n *\n * The single implementation of that precedence, shared by the durability\n * adapters below and by the resume response helpers' run driver\n * (`stream-to-response.ts`), so the helper and the adapter can never disagree\n * about which run a request is talking about.\n */\nexport function resolveResumeRunId(request: Request): string | null {\n  // A POST producer carries its client-chosen run id in the X-Run-Id header so\n  // the request URL stays byte-identical to a plain, non-durable request; the\n  // GET join path carries it in the ?runId query instead. Prefer the header,\n  // fall back to the query.\n  const header = request.headers.get('X-Run-Id')\n  if (header) return header\n  try {\n    return new URL(request.url).searchParams.get('runId')\n  } catch {\n    return null\n  }\n}\n\nfunction assertValidRunId(runId: string): string {\n  if (runId.length === 0 || /[\\r\\n]/.test(runId)) {\n    throw new Error(\n      `Invalid runId (must be non-empty and contain no CR/LF): ${JSON.stringify(runId)}`,\n    )\n  }\n  return runId\n}\n\nfunction resolveMemoryRunId(\n  request: Request,\n  resumeOffset: string | null,\n): string {\n  if (\n    resumeOffset !== null &&\n    resumeOffset !== '-1' &&\n    resumeOffset !== 'now'\n  ) {\n    return assertValidRunId(decodeMemoryOffset(resumeOffset).runId)\n  }\n  const requestedRunId = resolveResumeRunId(request)\n  return requestedRunId === null\n    ? crypto.randomUUID()\n    : assertValidRunId(requestedRunId)\n}\n\nfunction memoryThreshold(offset: string, runId: string, tail: number): number {\n  if (offset === '-1') return -1\n  if (offset === 'now') return tail\n  const decoded = decodeMemoryOffset(offset)\n  if (decoded.runId !== runId) {\n    throw new Error(\n      `Memory stream offset belongs to run ${JSON.stringify(decoded.runId)}, not ${JSON.stringify(runId)}`,\n    )\n  }\n  return decoded.seq\n}\n\ninterface MemoryEntry {\n  seq: number\n  offset: string\n  chunk: StreamChunk\n}\n\n/**\n * One validated action from an `upsert` batch. Building the whole plan before\n * applying any of it is what keeps a rejected `upsert` from partially mutating\n * the log.\n */\ntype UpsertStep =\n  | { kind: 'replace'; existing: MemoryEntry; chunk: StreamChunk }\n  | { kind: 'push'; seq: number; offset: string; chunk: StreamChunk }\n\ninterface MemoryLog {\n  entries: Array<MemoryEntry>\n  complete: boolean\n  /** Epoch ms when the log was terminalized; undefined while still producing. */\n  completedAt: number | undefined\n  waiters: Array<() => void>\n}\n\n/**\n * Bounds for the in-process log store. `memoryStream` is the dev/single-process\n * backend; without eviction its module-global Map would grow without bound on a\n * long-lived server (one retained chunk buffer per run, forever). Completed logs\n * are swept after a grace window — late resumers/joiners still work briefly —\n * and a hard cap drops the oldest completed logs under pressure. Active\n * (incomplete) logs are never evicted, so an in-flight run is never dropped.\n */\nconst MAX_MEMORY_RUNS = 1024\nconst COMPLETED_LOG_TTL_MS = 5 * 60_000\n\n/**\n * How long a from-start join (`-1` / `now`) waits for a run's first chunk before\n * failing. Bounds the \"joined a run that never produces\" case so a consumer\n * gets a surfaced error instead of an indefinitely-open, event-less connection.\n *\n * Defaults short: the common from-start join is a reload rejoining a run whose\n * producer ran in a PRIOR request, so an in-flight run's log already holds\n * chunks (it streams immediately, deadline never applies) and an empty log means\n * the run is gone — failing fast lets the client re-enable input near-instantly\n * instead of hanging. Raise `firstChunkDeadlineMs` for backends where a producer\n * legitimately starts well after a joiner attaches (a queued/deferred job).\n */\nconst DEFAULT_FIRST_CHUNK_DEADLINE_MS = 100\n\n/** Options for the in-process delivery-durability backend. */\nexport interface MemoryStreamOptions {\n  /**\n   * Milliseconds a from-start join waits for the run's first chunk before\n   * throwing. Defaults to {@link DEFAULT_FIRST_CHUNK_DEADLINE_MS} (100ms) —\n   * raise it if a producer can legitimately start long after a joiner attaches.\n   */\n  firstChunkDeadlineMs?: number\n}\n\nconst memoryLogs = new Map<string, MemoryLog>()\n\n/**\n * Evict completed logs past their grace window, then, if still over the cap,\n * drop the oldest completed logs (the Map preserves insertion order) until back\n * under the cap. Never touches an incomplete (in-flight) log.\n */\nfunction sweepMemoryLogs(now: number): void {\n  for (const [id, log] of memoryLogs) {\n    if (\n      log.complete &&\n      log.completedAt !== undefined &&\n      now - log.completedAt > COMPLETED_LOG_TTL_MS\n    ) {\n      memoryLogs.delete(id)\n    }\n  }\n  if (memoryLogs.size <= MAX_MEMORY_RUNS) return\n  for (const [id, log] of memoryLogs) {\n    if (memoryLogs.size <= MAX_MEMORY_RUNS) break\n    if (log.complete) memoryLogs.delete(id)\n  }\n}\n\nfunction getOrCreateLog(id: string): MemoryLog {\n  let log = memoryLogs.get(id)\n  if (!log) {\n    sweepMemoryLogs(Date.now())\n    log = { entries: [], complete: false, completedAt: undefined, waiters: [] }\n    memoryLogs.set(id, log)\n  }\n  return log\n}\n\nfunction markComplete(log: MemoryLog): void {\n  if (!log.complete) {\n    log.complete = true\n    log.completedAt = Date.now()\n  }\n}\n\nfunction wakeWaiters(log: MemoryLog): void {\n  const waiters = log.waiters\n  log.waiters = []\n  for (const wake of waiters) wake()\n}\n\n/**\n * Explicit construction for {@link memoryStream}, for callers that don't have\n * the incoming `Request` — e.g. a TanStack Start server function implementing\n * a `joinRun` replay for a run id it received as call data:\n *\n * ```ts\n * const durability = memoryStream({ runId })\n * for await (const chunk of replayRunStream(durability)) yield chunk\n * ```\n */\nexport interface MemoryStreamInit {\n  /** The run this durability adapter attaches to. */\n  runId: string\n  /**\n   * Resume offset captured by the consumer (`resumeFrom()` returns it).\n   * Defaults to `null` (a producer / from-start reader).\n   */\n  offset?: string | null\n}\n\n/**\n * The zero-infrastructure delivery-durability backend. Its versioned cursor is\n * deliberately private: callers and core only pass the returned string back.\n *\n * Construct from the incoming `Request` (HTTP transports) or from an explicit\n * {@link MemoryStreamInit} (server functions / direct calls that already know\n * the run id).\n *\n * Logs live in a process-global map, so this backend is for development, tests,\n * and single-process deployments only. Completed runs are evicted after a grace\n * window (see {@link COMPLETED_LOG_TTL_MS}); a resume of an evicted or unknown\n * run fails loudly rather than hanging.\n */\nexport function memoryStream(\n  source: Request | MemoryStreamInit,\n  options: MemoryStreamOptions = {},\n): UpsertableStreamDurability {\n  const resumeOffset =\n    source instanceof Request\n      ? readResumeOffset(source)\n      : (source.offset ?? null)\n  const runId =\n    source instanceof Request\n      ? resolveMemoryRunId(source, resumeOffset)\n      : assertValidRunId(source.runId)\n  const firstChunkDeadlineMs =\n    options.firstChunkDeadlineMs ?? DEFAULT_FIRST_CHUNK_DEADLINE_MS\n\n  return {\n    resumeFrom: () => resumeOffset,\n    // `async` so every failure surfaces as a rejected promise rather than a\n    // synchronous throw at the call site — `append` is declared to return a\n    // Promise, so callers must be able to `.catch()` every failure mode.\n    append: async (chunks) => {\n      const log = getOrCreateLog(runId)\n      const firstSeq = (log.entries.at(-1)?.seq ?? 0) + 1\n      const offsets = chunks.map((chunk, index) => {\n        const seq = firstSeq + index\n        const offset = encodeMemoryOffset(runId, seq)\n        log.entries.push({ seq, offset, chunk })\n        return offset\n      })\n      wakeWaiters(log)\n      return offsets\n    },\n    // `async` for the same reason as `append`: every validation failure below\n    // must be observable via `.catch()`, never as a synchronous throw.\n    upsert: async (entries) => {\n      const log = getOrCreateLog(runId)\n      const tailSeq = log.entries.at(-1)?.seq ?? 0\n\n      // Validate the WHOLE batch before touching `log.entries`, so a rejected\n      // upsert never partially applies and a caller that catches and retries\n      // can be sure no prefix landed.\n      const seen = new Set<string>()\n      // Tail as it will stand once every push planned so far has been applied,\n      // so intra-batch ordering is validated up front too.\n      let plannedTailSeq = tailSeq\n      // `Array.from` rather than `entries.map`: `map` SKIPS holes in a sparse\n      // array, which would leave the plan short and make the apply loop below\n      // read `undefined` partway through, after earlier steps had already\n      // mutated the log. `Array.from` invokes this callback for every index,\n      // so a hole is rejected here, before anything is touched.\n      const plan = Array.from(entries, (entry, index): UpsertStep => {\n        if (entry === undefined) {\n          throw new Error(\n            `memoryStream: entries[${index}] is missing; entries must be dense`,\n          )\n        }\n        const { chunk, offset } = entry\n        let decoded: MemoryOffset\n        try {\n          decoded = decodeMemoryOffset(offset)\n        } catch (cause) {\n          throw new Error(\n            `memoryStream: entries[${index}].offset ${JSON.stringify(offset)} is not a resumable memory stream offset: ${cause instanceof Error ? cause.message : String(cause)}`,\n          )\n        }\n        if (decoded.runId !== runId) {\n          throw new Error(\n            `memoryStream: entries[${index}].offset ${JSON.stringify(offset)} belongs to run ${JSON.stringify(decoded.runId)}, not ${JSON.stringify(runId)}`,\n          )\n        }\n        const seq = decoded.seq\n        if (seen.has(offset)) {\n          throw new Error(\n            `memoryStream: entries[${index}].offset ${JSON.stringify(offset)} is repeated within the batch; each offset may appear at most once`,\n          )\n        }\n        seen.add(offset)\n        const existing = log.entries.find((stored) => stored.offset === offset)\n        if (existing) return { kind: 'replace', existing, chunk }\n        // A not-yet-stored offset must sit strictly after the current tail.\n        // `read()` walks `entries` in array order and filters `seq > threshold`,\n        // so a pushed entry has to keep the seqs monotonically increasing;\n        // reusing the offset's own decoded seq also keeps a returned offset's\n        // threshold exactly consistent with the entry it names. Gaps are fine —\n        // nothing depends on seqs being contiguous, only on them increasing —\n        // so do NOT \"fix\" this to renumber densely.\n        if (seq <= plannedTailSeq) {\n          throw new Error(\n            `memoryStream: entries[${index}].offset ${JSON.stringify(offset)} is not stored yet but claims position ${seq}, at or before the tail ${plannedTailSeq}; a new offset must come after every stored and preceding entry`,\n          )\n        }\n        plannedTailSeq = seq\n        return { kind: 'push', seq, offset, chunk }\n      })\n\n      // Validation passed for every entry — mutation below cannot fail.\n      for (const step of plan) {\n        if (step.kind === 'replace') {\n          step.existing.chunk = step.chunk\n        } else {\n          log.entries.push({\n            seq: step.seq,\n            offset: step.offset,\n            chunk: step.chunk,\n          })\n        }\n      }\n      wakeWaiters(log)\n      return plan.map((step) =>\n        step.kind === 'replace' ? step.existing.offset : step.offset,\n      )\n    },\n    snapshot: () => {\n      // Peek, never getOrCreateLog: an unknown run must resolve to `[]`, and\n      // inserting an empty, never-completed log here would leave a permanent\n      // entry the sweep cannot reclaim (it only reclaims complete logs).\n      const log = memoryLogs.get(runId)\n      if (log === undefined) return Promise.resolve([])\n      // Fresh outer array AND fresh pair objects, so a caller that mutates the\n      // result cannot reach `log.entries` or the stored entries through it.\n      // Never touches `log.waiters` — a snapshot is a point-in-time read and\n      // returns even while the log is open and still being appended to.\n      return Promise.resolve(\n        log.entries.map((entry) => ({\n          offset: entry.offset,\n          chunk: entry.chunk,\n        })),\n      )\n    },\n    close: () => {\n      const log = getOrCreateLog(runId)\n      markComplete(log)\n      wakeWaiters(log)\n      return Promise.resolve()\n    },\n    read: async function* (offset, signal) {\n      const isFromStartJoin = offset === '-1' || offset === 'now'\n\n      // Peek, never getOrCreateLog. A concrete resume offset for an absent run\n      // means the run was evicted (or never lived in this process) and will not\n      // reappear — fail WITHOUT inserting a log. Inserting here would leave a\n      // permanent empty, never-completed log (sweep only reclaims complete\n      // ones), so client-supplied offsets could grow the map without bound and\n      // defeat the eviction this backend relies on.\n      let log = memoryLogs.get(runId)\n      if (log === undefined || (log.entries.length === 0 && !log.complete)) {\n        if (!isFromStartJoin) {\n          throw new Error(\n            `Unknown or expired memory stream run: ${JSON.stringify(runId)}`,\n          )\n        }\n        // A from-start join may legitimately attach before the producer creates\n        // the log (second-tab race); create it so a later append reuses the\n        // same entry. If no producer ever arrives, the first-chunk deadline\n        // below deletes this phantom before rejecting.\n        log = getOrCreateLog(runId)\n      }\n\n      const threshold = memoryThreshold(\n        offset,\n        runId,\n        log.entries.at(-1)?.seq ?? 0,\n      )\n      let index = 0\n\n      for (;;) {\n        while (index < log.entries.length) {\n          const entry = log.entries[index]\n          index += 1\n          if (entry && entry.seq > threshold) {\n            yield { offset: entry.offset, chunk: entry.chunk }\n          }\n        }\n        // A terminal chunk (RUN_FINISHED / RUN_ERROR) does NOT end the read: an\n        // agent-loop run emits one per iteration (finishReason \"tool_calls\" then\n        // \"stop\"), so stopping on the first would truncate a tool-calling run at\n        // its first tool call. The producer signals true completion by calling\n        // `close()` (it does so on every exit — see StreamDurability.close), which\n        // sets `log.complete`. Read tails until then, or until the caller aborts.\n        if (log.complete || signal?.aborted) return\n\n        // Bound only the wait for the very first chunk: once a run has produced\n        // anything, its producer owns termination and a caught-up reader may\n        // legitimately park indefinitely between chunks.\n        const deadlineForFirstChunk =\n          log.entries.length === 0 ? firstChunkDeadlineMs : undefined\n\n        await new Promise<void>((resolve, reject) => {\n          let timer: ReturnType<typeof setTimeout> | undefined\n          const cleanup = () => {\n            if (timer !== undefined) clearTimeout(timer)\n            signal?.removeEventListener('abort', onAbort)\n            const waiterIndex = log.waiters.indexOf(wake)\n            if (waiterIndex !== -1) log.waiters.splice(waiterIndex, 1)\n          }\n          const onAbort = () => {\n            cleanup()\n            resolve()\n          }\n          const wake = () => {\n            cleanup()\n            resolve()\n          }\n          log.waiters.push(wake)\n          signal?.addEventListener('abort', onAbort, { once: true })\n          if (deadlineForFirstChunk !== undefined) {\n            timer = setTimeout(() => {\n              cleanup()\n              // No producer ever created data for this joined run. Drop the\n              // phantom log we created above so it does not linger uncollected\n              // (it is empty and will never be marked complete).\n              if (\n                log.entries.length === 0 &&\n                !log.complete &&\n                memoryLogs.get(runId) === log\n              ) {\n                memoryLogs.delete(runId)\n              }\n              reject(\n                new Error(\n                  `Memory stream run produced no data within ${deadlineForFirstChunk}ms: ${JSON.stringify(runId)}`,\n                ),\n              )\n            }, deadlineForFirstChunk)\n          }\n        })\n      }\n    },\n  }\n}\n\n/**\n * Replay a run's delivery-durability log as a bare stream of chunks, for\n * callers that serve a `joinRun` handler without an HTTP `Response` — e.g. a\n * TanStack Start server function returning an async iterable:\n *\n * ```ts\n * async function* joinImageRun({ data: runId }: { data: string }) {\n *   yield* replayRunStream(memoryStream({ runId }))\n * }\n *\n * // Serve it from a server function whose handler is the generator above\n * // (`createServerFn({ method: 'GET' }).inputValidator(...)`).\n * ```\n *\n * NOTE: the example deliberately declares the generator separately instead of\n * inlining it into the server-fn builder chain. TanStack Start's server-fn\n * Vite plugin decides whether a module needs compiling by regex-matching the\n * SOURCE for a dotted `handler(` call, and JSDoc survives into `dist` — an\n * inlined chain here would make every Start app treat this package as a\n * server-fn module and try to resolve its framework's `@tanstack/*-start`\n * package, failing the build wherever that framework is not the one installed.\n *\n * Reads from `offset` (default `'-1'` — from the start) and tails until the\n * producer closes the log or `signal` aborts, exactly like the HTTP\n * `resumeServerSentEventsResponse` path.\n */\nexport async function* replayRunStream<TOffset extends string>(\n  durability: StreamDurability<TOffset>,\n  offset?: TOffset,\n  signal?: AbortSignal,\n): AsyncGenerator<StreamChunk> {\n  // '-1' is the from-start replay sentinel every shipped backend honors.\n  const from = offset ?? ('-1' as TOffset)\n  for await (const { chunk } of durability.read(from, signal)) {\n    yield chunk\n  }\n}\n"],"mappings":"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"}