@voltro/ai 0.84.0 → 0.86.0

package/dist/realtimeSession.js

@@ -0,0 +1,154 @@
+import { RealtimeClientEvent as e, RealtimeServerEvent as t } from "./realtimeEvent.js";
+import { createOpenAI as n } from "@ai-sdk/openai";
+import { createGateway as r } from "@ai-sdk/gateway";
+import { Effect as i, Queue as a, Result as o, Schema as s } from "effect";
+import { defineWebSocket as c } from "@voltro/protocol";
+import { WebSocket as l } from "ws";
+//#region src/realtimeSession.ts
+var u = (e) => {
+	if (e.name !== "gateway" && e.name !== "openai") throw TypeError(`Provider '${e.name}' does not support realtime sessions. Use 'gateway' or 'openai'.`);
+	let t = {
+		...e.apiKey === void 0 ? {} : { apiKey: e.apiKey },
+		...e.baseURL === void 0 ? {} : { baseURL: e.baseURL }
+	};
+	return (e.name === "gateway" ? r(t) : n(t)).experimental_realtime(e.model);
+}, d = s.decodeUnknownResult(e, { onExcessProperty: "error" }), f = s.decodeUnknownResult(t), p = class extends Error {
+	code;
+	constructor(e, t) {
+		super(t), this.code = e;
+	}
+}, m = {
+	maxMessageBytes: 262144,
+	maxPendingBytes: 1048576,
+	maxPendingMessages: 32,
+	setupTimeoutMs: 15e3,
+	maxDurationMs: 6e5
+}, h = (e) => {
+	let t = {
+		...m,
+		...e.limits
+	};
+	for (let [e, n] of Object.entries(t)) if (!Number.isSafeInteger(n) || n <= 0 || n > 2147483647) throw TypeError(`defineRealtimeSession: ${e} must be a positive integer at most 2147483647.`);
+	if (typeof e.authorize != "function") throw TypeError("defineRealtimeSession: authorize is required.");
+	if ("tools" in e.sessionConfig && e.sessionConfig.tools !== void 0) throw TypeError("defineRealtimeSession: tools are not supported; use a server-authorized tool execution surface instead.");
+	return c({
+		path: e.path,
+		auth: "subject",
+		limits: {
+			maxMessageBytes: t.maxMessageBytes,
+			maxPendingBytes: t.maxPendingBytes,
+			maxPendingMessages: t.maxPendingMessages
+		},
+		onConnection: (n) => g(e, t, n)
+	});
+}, g = (e, t, n) => {
+	let r = new AbortController(), s = !1, c = !1, u = (e, t) => {
+		s || (s = !0, r.abort(), n.close(e, t));
+	}, m = () => {
+		s = !0, r.abort();
+	}, h = () => u(4400, "Realtime session is not ready");
+	n.onMessage((e) => {
+		c ? h(e) : u(4400, "Realtime session is not ready");
+	}), n.signal.addEventListener("abort", m, { once: !0 }), n.signal.aborted && m();
+	let g = i.scoped(i.gen(function* () {
+		yield* i.addFinalizer(() => i.sync(() => {
+			s || u(4502, "Realtime session failed"), n.signal.removeEventListener("abort", m);
+		}));
+		let r = yield* a.dropping(t.maxPendingMessages), g = yield* a.dropping(t.maxPendingMessages);
+		yield* i.addFinalizer(() => i.all([a.shutdown(r), a.shutdown(g)]));
+		let v = 0, y = 0, b = 0, x = 0, S = (e, n) => {
+			if (s) return;
+			let i = n === "input" ? v : y, o = n === "input" ? b : x, c = n === "input" ? r : g;
+			e.byteLength > t.maxMessageBytes || i + e.byteLength > t.maxPendingBytes || o >= t.maxPendingMessages || !a.offerUnsafe(c, e) ? u(4409, "Realtime buffer limit exceeded") : n === "input" ? (v += e.byteLength, b++) : (y += e.byteLength, x++);
+		};
+		h = (e) => S(e, "input"), yield* i.forkScoped(i.sleep(t.maxDurationMs).pipe(i.tap(() => i.sync(() => u(4401, "Realtime session expired")))));
+		let C = yield* i.gen(function* () {
+			let r = n.subject;
+			if (r === null || r.type === "anonymous" || !(yield* i.suspend(() => e.authorize(r, {
+				provider: e.model.provider,
+				modelId: e.model.modelId
+			})))) return yield* i.fail(new p(4403, "Realtime access denied"));
+			let a = e.model.doCreateClientSecret, o = e.model.getWebSocketConfig;
+			if (a === void 0 || o === void 0) return yield* i.fail(new p(4502, "Realtime provider does not support WebSocket sessions"));
+			let d = yield* i.tryPromise(() => Promise.resolve(a.call(e.model, {
+				expiresAfterSeconds: Math.ceil(t.maxDurationMs / 1e3),
+				sessionConfig: e.sessionConfig
+			})));
+			if (d.expiresAt !== void 0) {
+				let e = d.expiresAt * 1e3 - Date.now();
+				if (!Number.isFinite(e) || e <= 0) return yield* i.fail(new p(4401, "Realtime session expired"));
+				yield* i.forkScoped(i.sleep(Math.min(e, t.maxDurationMs)).pipe(i.tap(() => i.sync(() => u(4401, "Realtime session expired")))));
+			}
+			let f = o.call(e.model, d), m = yield* i.acquireRelease(i.sync(() => {
+				let e = new l(f.url, f.protocols, {
+					maxPayload: t.maxMessageBytes,
+					perMessageDeflate: !1,
+					handshakeTimeout: t.setupTimeoutMs
+				});
+				return e.on("error", () => {
+					s || u(4502, "Realtime provider failed");
+				}), e.on("close", () => {
+					s || u(4501, "Realtime provider disconnected");
+				}), e.on("message", (e, t) => {
+					t ? u(4502, "Invalid realtime provider event") : S(Array.isArray(e) ? Buffer.concat(e) : e instanceof ArrayBuffer ? new Uint8Array(e) : e, "output");
+				}), e;
+			}), (e) => i.sync(() => {
+				e.terminate();
+			}));
+			return yield* i.callback((e) => {
+				let t = () => e(i.void), n = () => e(i.fail(new p(4502, "Realtime provider failed")));
+				return m.once("open", t), m.once("error", n), m.once("close", n), i.sync(() => {
+					m.off("open", t), m.off("error", n), m.off("close", n);
+				});
+			}), yield* i.tryPromise(() => Promise.resolve(e.model.serializeClientEvent({
+				type: "session-update",
+				config: e.sessionConfig
+			})).then((e) => _(m, e, t, () => s))), yield* i.tryPromise(() => n.sendAsync(JSON.stringify({ type: "ready" }))), c = !0, m;
+		}).pipe(i.timeoutOrElse({
+			duration: t.setupTimeoutMs,
+			orElse: () => i.fail(new p(4408, "Realtime setup timed out"))
+		})), w = (e, t) => i.forever(i.flatMap(a.take(e === "input" ? r : g), (n) => i.tryPromise({
+			try: () => t(n),
+			catch: (e) => e instanceof p ? e : new p(4502, "Realtime provider failed")
+		}).pipe(i.ensuring(i.sync(() => {
+			e === "input" ? (v -= n.byteLength, b--) : (y -= n.byteLength, x--);
+		}))))).pipe(i.catch((e) => i.sync(() => u(e.code, e.message))));
+		yield* i.forkScoped(w("input", async (n) => {
+			let r;
+			try {
+				r = JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(n));
+			} catch {
+				throw new p(4400, "Invalid realtime client event");
+			}
+			let i = d(r);
+			if (o.isFailure(i)) throw new p(4400, "Invalid realtime client event");
+			let a = await e.model.serializeClientEvent(i.success);
+			await _(C, a, t, () => s);
+		})), yield* i.forkScoped(w("output", async (r) => {
+			let i = JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(r)), a = e.model.getHealthCheckResponse?.(i);
+			a != null && await _(C, a, t, () => s);
+			let c = e.model.parseServerEvent(i), l = Array.isArray(c) ? c : [c];
+			if (l.length > t.maxPendingMessages) throw new p(4409, "Realtime buffer limit exceeded");
+			for (let e of l) {
+				if (s) return;
+				if (e?.type === "custom") continue;
+				let r = f(e);
+				if (o.isFailure(r)) throw new p(4502, "Invalid realtime provider event");
+				let i = JSON.stringify(r.success);
+				if (Buffer.byteLength(i) > t.maxMessageBytes) throw new p(4409, "Realtime buffer limit exceeded");
+				await n.sendAsync(i);
+			}
+		})), yield* i.never;
+	}).pipe(i.catch((e) => i.sync(() => {
+		e instanceof p ? u(e.code, e.message) : u(4502, "Realtime session failed");
+	}))));
+	return i.runPromise(g, { signal: r.signal }).catch((e) => {
+		s || u(4502, "Realtime session failed");
+	}), m;
+}, _ = (e, t, n, r) => {
+	if (r() || e.readyState !== l.OPEN) return Promise.reject(new p(4501, "Realtime provider disconnected"));
+	let i = JSON.stringify(t);
+	return i === void 0 || Buffer.byteLength(i) > n.maxMessageBytes || e.bufferedAmount + Buffer.byteLength(i) > n.maxPendingBytes ? Promise.reject(new p(4409, "Realtime buffer limit exceeded")) : new Promise((t, n) => e.send(i, (e) => e ? n(new p(4502, "Realtime provider failed")) : t()));
+};
+//#endregion
+export { h as defineRealtimeSession, u as resolveRealtimeModel };

package/dist/rerank.js

@@ -0,0 +1,61 @@
+import { aiGenerationError as e } from "./api.js";
+import { rerank as t } from "ai";
+import { Effect as n } from "effect";
+//#region src/rerank.ts
+var r = (t) => n.tryPromise({
+	try: async () => {
+		let e = t.getText ?? ((e) => String(e)), n = t.provider ?? "mock", r = [...typeof n == "string" ? n === "mock" ? i(t.query, t.documents, e) : await o(n, t.query, t.documents, e, t.model) : await s(n, t.query, t.documents, e, t.model)].sort((e, t) => t.score - e.score);
+		return t.topN === void 0 ? r : r.slice(0, t.topN);
+	},
+	catch: (t) => e(t)
+}), i = (e, t, n) => {
+	let r = a(e), i = new Set(r);
+	return t.map((e) => {
+		let t = new Set(a(n(e))), r = 0;
+		for (let e of i) t.has(e) && r++;
+		return {
+			document: e,
+			score: i.size === 0 ? 0 : r / i.size
+		};
+	});
+}, a = (e) => e.toLowerCase().split(/[^a-z0-9]+/).filter((e) => e.length > 0), o = async (e, n, r, i, a) => {
+	let o = e === "cohere" ? "@ai-sdk/cohere" : "voyage-ai-provider", s;
+	try {
+		s = await import(
+			/* @vite-ignore */
+			o
+);
+	} catch {
+		throw Error(`rerank provider '${e}' needs the '${o}' package — install it or use the default mock provider for tests/demos.`);
+	}
+	let c = s[e], l = c?.rerankingModel ?? c?.reranking;
+	if (typeof l != "function") throw Error(`rerank provider '${e}' does not expose a reranking model in '${o}'.`);
+	let u = l(a ?? (e === "cohere" ? "rerank-english-v3.0" : "rerank-2")), d = r.map(i);
+	return (await t({
+		model: u,
+		query: n,
+		documents: d
+	})).ranking.map((e) => ({
+		document: r[e.originalIndex],
+		score: e.score
+	}));
+}, s = async (e, n, r, a, o) => {
+	if (e.name === "mock") return i(n, r, a);
+	if (e.name !== "gateway") throw Error(`rerank: provider '${e.name}' has no reranking model. Use { name: 'gateway', model: 'cohere/rerank-v4-pro' } to reach the catalog, or the direct-key shorthands 'cohere' / 'voyage'.`);
+	let { createGateway: s } = await import("@ai-sdk/gateway"), c = s({
+		...e.apiKey === void 0 ? {} : { apiKey: e.apiKey },
+		...e.baseURL === void 0 ? {} : { baseURL: e.baseURL }
+	});
+	if (typeof c.rerankingModel != "function") throw Error("rerank: this @ai-sdk/gateway build exposes no `rerankingModel`.");
+	let l = o ?? e.model, u = r.map(a);
+	return (await t({
+		model: c.rerankingModel(l),
+		query: n,
+		documents: u
+	})).ranking.map((e) => ({
+		document: r[e.originalIndex],
+		score: e.score
+	}));
+};
+//#endregion
+export { r as rerank };

package/dist/resumableStream.js

@@ -0,0 +1,321 @@
+import { streamText as e } from "./streamText.js";
+import { awaitStreamChange as t, hasStreamReaders as n, watchStream as r, withStreamWakeups as i } from "./streamWakeups.js";
+import { Cause as a, Clock as o, Duration as s, Effect as c, Exit as l, Option as u, Stream as d } from "effect";
+import { and as f, boolean as p, eq as m, generateId as h, gt as g, id as _, inSet as v, integer as y, json as b, lt as x, registerRetention as S, retentionTtlMsFromEnv as C, table as w, text as T, timestamp as E } from "@voltro/database";
+//#region src/resumableStream.ts
+var D = (e) => e._tag === "done" || e._tag === "error", O = (e, n, i = {}) => {
+	let a = i.pollMs ?? 50, l = Math.max(a, i.maxPollMs ?? 1e3);
+	if (!Number.isFinite(a) || a <= 0 || !Number.isFinite(l)) throw RangeError("Stream poll intervals must be finite positive milliseconds");
+	let f = i.fromSeq ?? 0, p = i.idleTimeoutMs, m = [[], u.none()];
+	return d.unwrap(c.map(r(n, e), (r) => d.paginate({
+		cursor: f,
+		idleMs: 0,
+		pollMs: a
+	}, (i) => c.gen(function* () {
+		let d = r.version, f = yield* n.read(e, i.cursor, 256);
+		if (f.length > 0) {
+			let e = f[f.length - 1].seq;
+			return [Array.from(f), u.some({
+				cursor: e,
+				idleMs: 0,
+				pollMs: a
+			})];
+		}
+		if (yield* n.isDone(e)) {
+			let t = yield* n.read(e, i.cursor, 256);
+			if (t.length === 0) return m;
+			let r = t[t.length - 1].seq;
+			return [Array.from(t), u.some({
+				cursor: r,
+				idleMs: 0,
+				pollMs: a
+			})];
+		}
+		if (p !== void 0 && i.idleMs >= p) return m;
+		let h = Math.min(i.pollMs, p === void 0 ? Infinity : p - i.idleMs), g = yield* o.currentTimeMillis;
+		yield* c.raceFirst(t(r, d), c.sleep(s.millis(h)));
+		let _ = Math.max(0, (yield* o.currentTimeMillis) - g), v = r.version !== d;
+		return [[], u.some({
+			...i,
+			idleMs: v ? 0 : i.idleMs + _,
+			pollMs: v ? a : Math.min(l, i.pollMs * 2)
+		})];
+	})).pipe(d.takeUntil(({ event: e }) => D(e)))));
+}, k = (e, t, n) => c.suspend(() => {
+	let r = 0, i = !1, o, s = (n) => c.suspend(() => (r += 1, D(n) && (o = r), t.append(e, {
+		seq: r,
+		event: n
+	}).pipe(c.tap(() => c.sync(() => {
+		D(n) && (i = !0);
+	}))))), u = (n) => c.gen(function* () {
+		if (t.appendMany === void 0) {
+			for (let e of n) yield* s(e);
+			return;
+		}
+		let a = n;
+		for (let n = 0; n < a.length; n += 64) {
+			let s = a.slice(n, n + 64).map((e) => (r += 1, D(e) && (o = r), {
+				seq: r,
+				event: e
+			}));
+			yield* t.appendMany(e, s), s.some(({ event: e }) => D(e)) && (i = !0);
+		}
+	});
+	return c.uninterruptibleMask((r) => c.gen(function* () {
+		let f = yield* r(c.suspend(() => n().pipe(d.takeUntil(D), d.runForEachArray(u)))).pipe(c.exit);
+		if (!i && o !== void 0) {
+			let n = o;
+			i = (yield* t.read(e, n - 1)).some((e) => e.seq === n && D(e.event));
+		}
+		if (!i) {
+			let e = l.isFailure(f) && a.hasInterruptsOnly(f.cause);
+			yield* s({
+				_tag: "error",
+				code: e ? "cancelled" : "internal",
+				message: e ? "Resumable stream producer cancelled." : "Resumable stream producer failed.",
+				retryable: !1
+			});
+		}
+		yield* t.markDone(e);
+	}));
+}), A = (e) => d.unwrap(c.gen(function* () {
+	return (yield* e.store.claimProducer(e.streamId)) && (yield* c.forkDetach(k(e.streamId, e.store, e.source).pipe(c.catchCause(() => c.logError("ai: resumable stream finalization could not be persisted"))))), O(e.streamId, e.store, {
+		fromSeq: e.fromSeq ?? 0,
+		pollMs: e.pollMs ?? 50,
+		...e.maxPollMs === void 0 ? {} : { maxPollMs: e.maxPollMs },
+		...e.idleTimeoutMs === void 0 ? {} : { idleTimeoutMs: e.idleTimeoutMs }
+	});
+})), j = (t) => A({
+	streamId: t.streamId,
+	store: t.store,
+	source: () => e(t.options),
+	...t.fromSeq === void 0 ? {} : { fromSeq: t.fromSeq },
+	...t.pollMs === void 0 ? {} : { pollMs: t.pollMs },
+	...t.maxPollMs === void 0 ? {} : { maxPollMs: t.maxPollMs },
+	...t.idleTimeoutMs === void 0 ? {} : { idleTimeoutMs: t.idleTimeoutMs }
+}), M = (e = {}) => {
+	let t = e.retentionMs ?? 6048e5;
+	if (!Number.isFinite(t) || t < 0) throw RangeError("Stream retention must be finite non-negative milliseconds");
+	let r = e.now ?? Date.now, a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set(), l = !1, u, d = () => {
+		if (l) throw Error("Resumable stream store has been disposed");
+		u ??= a.entries();
+		let e = r() - t;
+		for (let t = 0; t < 16; t++) {
+			let t = u.next();
+			if (t.done) {
+				u = void 0;
+				break;
+			}
+			let [r, i] = t.value;
+			i.finishedAt !== void 0 && i.finishedAt <= e && !n(m, r) && a.delete(r);
+		}
+	}, f = (e) => {
+		let t = a.get(e);
+		return t === void 0 && (t = {
+			events: [],
+			ordered: !0,
+			finishedAt: void 0
+		}, a.set(e, t)), t;
+	}, p = (e, t) => {
+		let n = f(e), r = t.seq, i = n.events.at(-1);
+		(!Number.isFinite(r) || i !== void 0 && r < i.seq) && (n.ordered = !1), n.events.push({
+			seq: r,
+			event: t.event
+		});
+	}, m = i({
+		claimProducer: (e) => c.sync(() => (d(), !o.has(e) && (o.add(e), !0))),
+		append: (e, t) => c.sync(() => {
+			d(), p(e, t);
+		}),
+		appendMany: (e, t) => c.sync(() => {
+			d();
+			for (let n of t) p(e, n);
+		}),
+		read: (e, t, n) => c.sync(() => {
+			if (d(), n !== void 0 && (!Number.isSafeInteger(n) || n < 0)) throw RangeError("Stream read limit must be a non-negative integer");
+			let r = a.get(e);
+			if (r === void 0 || n === 0) return [];
+			let i;
+			if (!r.ordered || Number.isNaN(t)) {
+				let e = [];
+				for (let i of r.events) if (i.seq > t && e.push(i), n !== void 0 && e.length >= n) break;
+				i = e;
+			} else {
+				let e = 0, a = r.events.length;
+				for (; e < a;) {
+					let n = e + Math.floor((a - e) / 2);
+					r.events[n].seq <= t ? e = n + 1 : a = n;
+				}
+				i = r.events.slice(e, n === void 0 ? void 0 : e + n);
+			}
+			return i.map((e) => ({ ...e }));
+		}),
+		markDone: (e) => c.sync(() => {
+			d();
+			let t = f(e);
+			t.finishedAt = r(), s.add(e);
+		}),
+		isDone: (e) => c.sync(() => (d(), s.has(e))),
+		dispose: c.sync(() => {
+			l = !0, a.clear(), o.clear(), s.clear(), u = void 0;
+		})
+	});
+	return m;
+}, N = "_voltro_stream_events", P = "_voltro_stream_state", F = w(N, {
+	id: _({ prefix: "sev" }),
+	streamId: T(),
+	seq: y(),
+	event: b(),
+	createdAt: E().default("now")
+}).unique(["streamId", "seq"]).index(["streamId"]), I = w(P, {
+	id: _({ prefix: "sst" }),
+	streamId: T().unique(),
+	done: p().default(!1),
+	createdAt: E().default("now"),
+	updatedAt: E().default("now")
+}).index(["createdAt"]), L = 168, R = () => {
+	let e = C(process.env.VOLTRO_STREAM_LOG_TTL_HOURS, 168);
+	S({
+		source: "framework",
+		table: N,
+		timeColumn: "createdAt",
+		ttlMs: e,
+		envVar: "VOLTRO_STREAM_LOG_TTL_HOURS",
+		label: "resumable stream log"
+	}), S({
+		source: "framework",
+		table: P,
+		timeColumn: "createdAt",
+		ttlMs: e,
+		envVar: "VOLTRO_STREAM_LOG_TTL_HOURS",
+		label: "resumable stream state"
+	});
+}, z = (e) => e === !0 || e === 1 || e === "1" || e === "t", B = async (e, t) => (await e.query({
+	table: "_voltro_stream_state",
+	predicate: m("streamId", t),
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0]?.id ?? null, V = (e) => (R(), i({
+	claimProducer: (t) => c.promise(async () => {
+		let n = h({
+			kind: "typeid",
+			prefix: "sst"
+		}, P);
+		return (await e.insertIgnore(P, {
+			id: n,
+			streamId: t,
+			done: !1,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		}, { conflictColumns: ["streamId"] })).id === n;
+	}),
+	append: (t, n) => c.promise(async () => {
+		await e.insert(N, {
+			streamId: t,
+			seq: n.seq,
+			event: n.event,
+			createdAt: /* @__PURE__ */ new Date()
+		});
+	}),
+	appendMany: (t, n) => c.promise(async () => {
+		if (n.length === 0) return;
+		let r = /* @__PURE__ */ new Date();
+		await e.insertMany(N, n.map((e) => ({
+			streamId: t,
+			seq: e.seq,
+			event: e.event,
+			createdAt: r
+		})));
+	}),
+	read: (t, n, r) => c.promise(async () => (await e.query({
+		table: N,
+		predicate: f(m("streamId", t), g("seq", n)),
+		order: [{
+			column: "seq",
+			direction: "asc"
+		}],
+		take: r,
+		skip: void 0,
+		projection: void 0
+	})).map((e) => ({
+		seq: Number(e.seq),
+		event: e.event
+	}))),
+	markDone: (t) => c.promise(async () => {
+		let n = await B(e, t);
+		n !== null && await e.update(P, n, {
+			done: !0,
+			updatedAt: /* @__PURE__ */ new Date()
+		});
+	}),
+	isDone: (t) => c.promise(async () => {
+		let n = (await e.query({
+			table: P,
+			predicate: m("streamId", t),
+			order: [],
+			take: 1,
+			skip: void 0,
+			projection: void 0
+		}))[0];
+		return n !== void 0 && z(n.done);
+	})
+})), H = (e, t) => c.promise(async () => {
+	if (!Number.isFinite(t.olderThan.getTime())) throw RangeError("olderThan must be a valid Date");
+	let n = f(m("done", !0), x("createdAt", t.olderThan)), r = 0;
+	for (;;) {
+		let t = await e.query({
+			table: P,
+			predicate: n,
+			order: [{
+				column: "id",
+				direction: "asc"
+			}],
+			take: 200,
+			skip: void 0,
+			projection: ["id", "streamId"]
+		});
+		if (t.length === 0) return r;
+		await e.deleteMany(N, { where: v("streamId", t.map((e) => e.streamId)) });
+		let i = await e.deleteMany(P, { where: f(n, v("id", t.map((e) => e.id))) });
+		if (r += i, i === 0) return r;
+	}
+}), U = (e, t = {}) => {
+	let n = t.keyPrefix ?? "voltro:rstream", r = t.ttlSeconds ?? 3600, a = (e) => `${n}:log:${e}`, o = (e) => `${n}:producer:${e}`, s = (e) => `${n}:done:${e}`;
+	return i({
+		claimProducer: (t) => c.promise(() => e.setNx(o(t), "1", r)),
+		append: (t, n) => c.promise(async () => {
+			await e.rpush(a(t), JSON.stringify(n)), e.expire && await e.expire(a(t), r);
+		}),
+		read: (t, n, r) => c.promise(async () => {
+			if (r !== void 0 && (!Number.isSafeInteger(r) || r < 0)) throw RangeError("Stream read limit must be a non-negative integer");
+			if (r === 0) return [];
+			let i = [], o = Math.max(0, n - 1), s = n > 0;
+			for (;;) {
+				let c = r === void 0 ? void 0 : r + +!!s, l = await e.lrange(a(t), o, c === void 0 ? -1 : o + c - 1);
+				if (s) {
+					s = !1;
+					let e = !1;
+					try {
+						e = l[0] !== void 0 && JSON.parse(l[0]).seq === n;
+					} catch {}
+					if (!e) {
+						o = 0;
+						continue;
+					}
+				}
+				for (let e of l) try {
+					let t = JSON.parse(e);
+					t.seq > n && i.push(t);
+				} catch {}
+				if (r === void 0 || i.length > 0 || l.length < c) return i;
+				o += l.length;
+			}
+		}),
+		markDone: (t) => c.promise(() => e.set(s(t), "1", r)),
+		isDone: (t) => c.promise(() => e.exists(s(t)))
+	});
+};
+//#endregion
+export { L as DEFAULT_STREAM_LOG_RETENTION_HOURS, N as STREAM_EVENTS_TABLE, P as STREAM_STATE_TABLE, O as consumeResumableStream, V as dataStoreResumableStreamStore, H as gcResumableStreams, M as memoryResumableStreamStore, U as redisResumableStreamStore, A as resumableStream, j as resumableStreamText, k as startResumableProducer, F as streamEventsTable, I as streamStateTable };

package/dist/retrieveReranked.js

@@ -0,0 +1,16 @@
+import { rerank as e } from "./rerank.js";
+import { Effect as t } from "effect";
+//#region src/retrieveReranked.ts
+var n = (n) => t.gen(function* () {
+	let t = n.candidates ?? 50, r = n.topN ?? 8, i = yield* n.search(t);
+	return i.length === 0 ? i : (yield* e({
+		query: n.query,
+		documents: i,
+		getText: n.getText,
+		topN: r,
+		...n.provider === void 0 ? {} : { provider: n.provider },
+		...n.model === void 0 ? {} : { model: n.model }
+	})).map((e) => e.document);
+});
+//#endregion
+export { n as retrieveReranked };