@voltro/ai 0.85.0 → 0.87.0

package/dist/runAndPersist.js

@@ -0,0 +1,147 @@
+import { providerFromEnv as e } from "./provider.js";
+import { recordAiUsageBestEffort as t } from "./cost.js";
+import { streamText as n } from "./streamText.js";
+import { AGENT_MESSAGES_TABLE as r, AGENT_THREADS_TABLE as i } from "./agentConstants.js";
+import { Effect as a, Stream as o } from "effect";
+//#region src/runAndPersist.ts
+var s = (e) => [...e].sort((e, t) => e.order - t.order || e.stepOrder - t.stepOrder).filter((e) => !e.streaming && e.content.length > 0 && (e.role === "user" || e.role === "assistant")).map((e) => e.role === "user" ? {
+	role: "user",
+	content: e.content
+} : {
+	role: "assistant",
+	content: e.content
+}), c = (e, t) => a.promise(async () => {
+	let n = await e.insert(r, {
+		threadId: t.threadId,
+		tenantId: t.tenantId ?? null,
+		role: "assistant",
+		content: "",
+		streaming: !0,
+		order: t.order,
+		stepOrder: 0,
+		parts: [],
+		createdAt: /* @__PURE__ */ new Date()
+	});
+	return await e.update(i, t.threadId, { updatedAt: /* @__PURE__ */ new Date() }).catch(() => null), n.id;
+}), l = (e, t, n) => a.promise(async () => {
+	await e.update(r, t, {
+		parts: n,
+		content: u(n)
+	});
+}), u = (e) => e.filter((e) => e.type === "text").map((e) => e.text).join(""), d = (i, s) => a.gen(function* () {
+	let d = s.provider ?? (yield* a.try({
+		try: () => e(),
+		catch: (e) => e instanceof Error ? e : Error(String(e))
+	})), f = yield* c(i, {
+		threadId: s.threadId,
+		tenantId: s.tenantId ?? null,
+		order: s.order
+	}), p = "", m = "", h = /* @__PURE__ */ new Map(), g = [], _ = [], v = [], y = 0, b = null, x, S = s.throttleMs ?? 100, C = () => {
+		let e = [];
+		p.length > 0 && e.push({
+			type: "reasoning",
+			text: p
+		}), m.length > 0 && e.push({
+			type: "text",
+			text: m
+		});
+		for (let t of h.values()) e.push(t);
+		for (let t of g) e.push(t);
+		for (let t of _) e.push(t);
+		for (let t of v) e.push(t);
+		return e;
+	}, w = (e) => {
+		let t = Date.now();
+		return !e && t - y < S ? a.void : (y = t, l(i, f, C()));
+	};
+	yield* n({
+		prompt: s.prompt,
+		...s.messages === void 0 ? {} : { messages: s.messages },
+		...s.system === void 0 ? {} : { system: s.system },
+		...s.tools === void 0 ? {} : { tools: s.tools },
+		provider: d,
+		...s.maxSteps === void 0 ? {} : { maxSteps: s.maxSteps },
+		...s.toolContext === void 0 ? {} : { toolContext: s.toolContext },
+		...s.providerOptions === void 0 ? {} : { providerOptions: s.providerOptions }
+	}).pipe(o.runForEach((e) => a.gen(function* () {
+		switch (e._tag) {
+			case "token":
+				m += e.text, yield* w(!1);
+				break;
+			case "toolCall":
+				h.set(e.id, {
+					type: "tool",
+					toolCallId: e.id,
+					toolName: e.name,
+					state: "input-available",
+					input: e.input,
+					...e.execution === void 0 ? {} : { execution: e.execution }
+				}), yield* w(!0);
+				break;
+			case "toolResult": {
+				let t = h.get(e.id);
+				h.set(e.id, {
+					type: "tool",
+					toolCallId: e.id,
+					toolName: e.name,
+					state: e.error ? "output-error" : "output-available",
+					input: t?.input,
+					output: e.output,
+					...e.error ? { errorText: e.error } : {}
+				}), yield* w(!0);
+				break;
+			}
+			case "reasoning":
+				p += e.text, yield* w(!1);
+				break;
+			case "source": {
+				let { _tag: t, ...n } = e;
+				g.push({
+					type: t,
+					...n
+				}), yield* w(!0);
+				break;
+			}
+			case "file": {
+				let { _tag: t, ...n } = e;
+				_.push({
+					type: t,
+					...n
+				}), yield* w(!0);
+				break;
+			}
+			case "stepMetadata": {
+				let { _tag: t, ...n } = e;
+				v.push({
+					type: t,
+					...n
+				}), yield* w(!0);
+				break;
+			}
+			case "error":
+				b = e.message;
+				break;
+			case "done": x = e.usage;
+		}
+	})));
+	let T = C();
+	return yield* a.promise(() => i.update(r, f, {
+		parts: T,
+		content: u(T),
+		streaming: !1
+	})), s.recordUsage !== !1 && x !== void 0 && (yield* t(i, {
+		tenantId: s.tenantId ?? null,
+		provider: d.name,
+		model: d.model ?? "unknown",
+		operation: "agent.turn",
+		agent: s.agent ?? null,
+		requestId: f,
+		usage: {
+			inputTokens: x.inputTokens,
+			outputTokens: x.outputTokens,
+			...x.totalTokens === void 0 ? {} : { totalTokens: x.totalTokens }
+		}
+	})), b ? yield* a.fail(Error(b)) : u(T);
+});
+//#endregion
+export { c as appendStreamingMessage, s as historyToModelMessages, l as patchStreamingMessage, d as runAssistant };

package/dist/semanticCache.js

@@ -0,0 +1,66 @@
+import { generateObject as e, generateText as t } from "./api.js";
+import { embed as n } from "./embed.js";
+import { Effect as r, Option as i } from "effect";
+import { rowDep as a, tableDep as o } from "@voltro/cache";
+//#region src/semanticCache.ts
+var s = {
+	inputTokens: 0,
+	outputTokens: 0,
+	totalTokens: 0
+}, c = .95, l = (e, t) => t === void 0 ? e : `${t}\n\n${e}`, u = (e, t, n) => e.lookup(t, { threshold: n }).pipe(r.catchTag("CacheError", () => r.succeed(i.none()))), d = (e, t, n, i) => e.put(t, n, {
+	deps: i.deps,
+	...i.ttlMs === void 0 ? {} : { ttlMs: i.ttlMs }
+}).pipe(r.catchTag("CacheError", () => r.void)), f = (e, a, o) => r.gen(function* () {
+	if (e.messages !== void 0 || e.prompt === void 0) {
+		let n = yield* t(e);
+		return {
+			value: n.text,
+			cached: !1,
+			usage: n.usage
+		};
+	}
+	let r = o.embed ?? n, f = a.threshold ?? c, p = yield* r(l(e.prompt, e.system)), m = yield* u(o.cache, p, f);
+	if (i.isSome(m)) return {
+		value: m.value,
+		cached: !0,
+		usage: s
+	};
+	let h = yield* t(e);
+	return yield* d(o.cache, p, h.text, a), {
+		value: h.text,
+		cached: !1,
+		usage: h.usage
+	};
+}), p = (t, a, o) => r.gen(function* () {
+	let r = o.embed ?? n, f = a.threshold ?? c, p = yield* r(l(t.prompt, t.system)), m = yield* u(o.cache, p, f);
+	if (i.isSome(m)) return {
+		value: m.value,
+		cached: !0,
+		usage: s
+	};
+	let h = yield* e(t);
+	return yield* d(o.cache, p, h.object, a), {
+		value: h.object,
+		cached: !1,
+		usage: h.usage
+	};
+}), m = (e) => {
+	let t = /* @__PURE__ */ new Set(), n = async (n) => {
+		let r = await e.query(n);
+		t.add(o(n.table));
+		for (let e of r) {
+			let r = e.id;
+			r != null && t.add(a(n.table, String(r)));
+		}
+		return r;
+	};
+	return {
+		store: new Proxy(e, { get(e, t, r) {
+			return t === "query" ? n : Reflect.get(e, t, r);
+		} }),
+		deps: () => [...t],
+		reset: () => t.clear()
+	};
+};
+//#endregion
+export { m as recordReads, p as semanticGenerateObject, f as semanticGenerateText };

package/dist/speechProvider.js

@@ -0,0 +1,16 @@
+//#region src/speechProvider.ts
+var e = Symbol.for("@voltro/ai/speechProviders"), t = globalThis, n = () => t[e] ?? (t[e] = /* @__PURE__ */ new Map()), r = [
+	"mock",
+	"openai",
+	"gateway",
+	"anthropic"
+], i = (e, t, i = {}) => {
+	if (r.includes(e) && i.replaceBuiltin !== !0) throw Error(`registerSpeechProvider: '${e}' is a built-in provider name.\n  Shadowing one by accident would make the same config mean different things depending on which module loaded first.
+  → if you meant it, say so: registerSpeechProvider('${e}', provider, { replaceBuiltin: true }). That is the right call when the name is not yours to choose — a gateway model id's provider segment, say, that your stored rows already carry.
+  → otherwise pick another name.`);
+	n().set(e, t);
+}, a = (e) => r.includes(e) && n().has(e), o = (e) => n().get(e), s = () => [...n().keys()].sort(), c = () => {
+	n().clear();
+};
+//#endregion
+export { r as BUILTIN_SPEECH_PROVIDERS, c as clearSpeechProviders, i as registerSpeechProvider, s as registeredSpeechProviders, a as replacesBuiltinSpeechProvider, o as speechProvider };

package/dist/streamRegistry.js

@@ -0,0 +1,14 @@
+//#region src/streamRegistry.ts
+var e = /* @__PURE__ */ new Map(), t = (t) => {
+	let n = e.get(t);
+	if (n) return n;
+	let r = new AbortController();
+	return e.set(t, r), r;
+}, n = (t) => {
+	let n = e.get(t);
+	return n ? (e.delete(t), n.abort(), !0) : !1;
+}, r = (t) => e.has(t), i = (t) => {
+	e.delete(t);
+}, a = () => e.size;
+//#endregion
+export { a as activeStreamCount, n as cancelStream, r as isStreamActive, t as registerStream, i as unregisterStream };

package/dist/streamText.js

@@ -0,0 +1,170 @@
+import { providerFromEnv as e, resolveModel as t } from "./provider.js";
+import { buildSdkTools as n } from "./tools.js";
+import { aiCallAttributes as r, observeStream as i } from "./observe.js";
+import { registerStream as a, unregisterStream as o } from "./streamRegistry.js";
+import { smoothStream as s, stepCountIs as c, streamText as l } from "ai";
+import { Duration as u, Effect as d, Stream as f } from "effect";
+//#region src/streamText.ts
+var p = (e) => {
+	let t = e?.name, n = String(e?.message ?? e ?? "");
+	return t === "AbortError" || t === "TimeoutError" || /\babort(ed)?\b/i.test(n);
+}, m = (e, t) => e === null ? Promise.resolve() : t.aborted ? Promise.reject(t.reason ?? new DOMException("stream aborted", "AbortError")) : new Promise((n, r) => {
+	let i = setTimeout(() => {
+		t.removeEventListener("abort", a), n();
+	}, e), a = () => {
+		clearTimeout(i), t.removeEventListener("abort", a), r(t.reason ?? new DOMException("stream aborted", "AbortError"));
+	};
+	t.addEventListener("abort", a, { once: !0 });
+}), h = (e, t) => () => {
+	let n;
+	return new TransformStream({ async transform(r, i) {
+		r.type !== "text-delta" && r.type !== "reasoning-delta" ? (n = void 0, i.enqueue(r)) : (n?.type === r.type && n.id === r.id && await m(e, t), i.enqueue(r), n = {
+			type: r.type,
+			id: r.id
+		});
+	} });
+}, g = (e, t) => {
+	switch (e?.type) {
+		case "text-delta": return {
+			_tag: "token",
+			text: e.text ?? e.delta ?? ""
+		};
+		case "reasoning-delta":
+		case "reasoning": return {
+			_tag: "reasoning",
+			text: e.text ?? e.delta ?? ""
+		};
+		case "tool-call": return {
+			_tag: "toolCall",
+			id: e.toolCallId ?? "",
+			name: e.toolName ?? "",
+			input: e.input
+		};
+		case "tool-result": return {
+			_tag: "toolResult",
+			id: e.toolCallId ?? "",
+			name: e.toolName ?? "",
+			output: e.output
+		};
+		case "tool-error": return {
+			_tag: "toolResult",
+			id: e.toolCallId ?? "",
+			name: e.toolName ?? "",
+			error: String(e.error?.message ?? e.error ?? "tool error")
+		};
+		case "source": return {
+			_tag: "source",
+			sourceType: e.sourceType === "document" ? "document" : "url",
+			id: e.id ?? "",
+			...e.url === void 0 ? {} : { url: e.url },
+			...e.title === void 0 ? {} : { title: e.title },
+			...e.mediaType === void 0 ? {} : { mediaType: e.mediaType },
+			...e.filename === void 0 ? {} : { filename: e.filename },
+			...e.providerMetadata === void 0 ? {} : { providerMetadata: e.providerMetadata }
+		};
+		case "file": return e.file ? {
+			_tag: "file",
+			mediaType: e.file.mediaType,
+			data: e.file.base64,
+			...e.providerMetadata === void 0 ? {} : { providerMetadata: e.providerMetadata }
+		} : null;
+		case "finish-step": return e.providerMetadata === void 0 ? null : {
+			_tag: "stepMetadata",
+			step: t,
+			providerMetadata: e.providerMetadata
+		};
+		case "abort": return {
+			_tag: "error",
+			code: "cancelled",
+			message: "stream aborted",
+			retryable: !1
+		};
+		case "finish": return {
+			_tag: "done",
+			finishReason: String(e.finishReason ?? "stop"),
+			usage: {
+				inputTokens: e.totalUsage?.inputTokens,
+				outputTokens: e.totalUsage?.outputTokens,
+				totalTokens: e.totalUsage?.totalTokens
+			}
+		};
+		case "error": return {
+			_tag: "error",
+			code: "provider",
+			message: String(e.error),
+			retryable: !0
+		};
+		default: return null;
+	}
+}, _ = (u) => f.unwrap(d.gen(function* () {
+	let m = yield* d.context(), _ = u.provider ?? e(), v = t(_), y = u.tools ? {
+		store: void 0,
+		...u.toolContext,
+		runtime: m
+	} : u.toolContext, b = u.tools ? n(u.tools, y) : void 0, x = new Set(Object.entries(b ?? {}).filter(([, e]) => e.execute === void 0).map(([e]) => e)), S = u.streamId === void 0 ? new AbortController() : a(u.streamId);
+	u.signal !== void 0 && (u.signal.aborted ? S.abort() : u.signal.addEventListener("abort", () => S.abort(), { once: !0 }));
+	let C = S.signal, w = u.smooth === !1 ? void 0 : u.smooth, T = l({
+		model: v,
+		...u.messages === void 0 ? { prompt: u.prompt } : { messages: [...u.messages] },
+		...u.system === void 0 ? {} : { system: u.system },
+		...u.maxTokens === void 0 ? {} : { maxOutputTokens: u.maxTokens },
+		...u.temperature === void 0 ? {} : { temperature: u.temperature },
+		...u.providerOptions === void 0 ? {} : { providerOptions: u.providerOptions },
+		...u.maxRetries === void 0 ? {} : { maxRetries: u.maxRetries },
+		abortSignal: C,
+		...w === void 0 ? {} : { experimental_transform: [s({
+			...w.chunking === void 0 ? {} : { chunking: w.chunking },
+			delayInMs: null
+		}), h(w.delayMs === void 0 ? 10 : w.delayMs, C)] },
+		...b ? {
+			tools: b,
+			stopWhen: c(u.maxSteps ?? 8)
+		} : {}
+	}), E = 0;
+	return i(r(_, "streamText"), f.fromAsyncIterable(T.fullStream, (e) => e).pipe(f.map((e) => {
+		let t = g(e, E), n = t?._tag === "toolCall" && x.has(t.name) ? {
+			...t,
+			execution: "client"
+		} : t;
+		return e.type === "finish-step" && (E += 1), n;
+	}), f.filter((e) => e !== null), f.catch((e) => {
+		let t = C.aborted || p(e);
+		return f.make({
+			_tag: "error",
+			code: t ? "cancelled" : "provider",
+			message: t ? "stream aborted" : String(e),
+			retryable: !t
+		});
+	}), f.ensuring(d.sync(() => {
+		S.abort(), u.streamId !== void 0 && o(u.streamId);
+	}))));
+})), v = (e) => e._tag === "token" || e._tag === "reasoning" || e._tag === "toolCall" || e._tag === "toolResult" || e._tag === "source" || e._tag === "file" || e._tag === "message" || e._tag === "stepMetadata", y = (e) => e._tag === "done" || e._tag === "error", b = (e, t = {}) => {
+	let n = Math.max(1, t.maxAttempts ?? 3), r = t.backoffMs ?? 250, i = t.maxBackoffMs ?? 5e3, a = [e.provider, ...e.fallbacks ?? []], o = (t, s) => {
+		let c = !1, l = a[t];
+		return _(l === void 0 ? e : {
+			...e,
+			provider: l
+		}).pipe(f.takeUntil(y), f.flatMap((e) => {
+			if (e._tag === "error" && e.retryable && !c) {
+				if (s + 1 < n) {
+					let e = Math.min(i, r * 2 ** s);
+					return f.unwrap(d.as(d.sleep(u.millis(e)), o(t, s + 1)));
+				}
+				if (t + 1 < a.length) return o(t + 1, 0);
+			}
+			return v(e) && (c = !0), f.make(e);
+		}, { concurrency: 1 }));
+	};
+	return o(0, 0);
+}, x = (e) => {
+	let t = [e.provider, ...e.fallbacks ?? []], n = (r) => {
+		let i = !1, a = t[r];
+		return _(a === void 0 ? e : {
+			...e,
+			provider: a
+		}).pipe(f.takeUntil(y), f.flatMap((e) => e._tag === "error" && e.retryable && !i && r + 1 < t.length ? n(r + 1) : (v(e) && (i = !0), f.make(e)), { concurrency: 1 }));
+	};
+	return n(0);
+};
+//#endregion
+export { _ as streamText, x as streamTextWithFallback, b as streamTextWithRetry };

package/dist/streamTranscribe.js

@@ -0,0 +1,74 @@
+import { providerFromEnv as e, resolveTranscriptionModel as t } from "./provider.js";
+import { TranscriptionStreamError as n, TranscriptionStreamEvent as r } from "./transcriptionEvent.js";
+import { experimental_streamTranscribe as i } from "ai";
+import { Effect as a, Schema as o, Stream as s } from "effect";
+//#region src/streamTranscribe.ts
+var c = (c) => s.unwrap(a.gen(function* () {
+	let l = yield* a.acquireRelease(a.sync(() => new AbortController()), (e) => a.promise(async () => {
+		e.abort(), c.audio.locked || await c.audio.cancel().catch(() => {});
+	})), u = c.signal === void 0 ? l.signal : AbortSignal.any([l.signal, c.signal]), d = (e) => {
+		let t = new n({
+			reason: u.aborted ? "cancelled" : "provider",
+			message: u.aborted ? "Transcription cancelled." : "Streaming transcription failed."
+		});
+		return Object.defineProperty(t, "cause", {
+			value: e,
+			enumerable: !1
+		}), t;
+	};
+	if (u.aborted) return s.fail(d(u.reason));
+	let f = c.inputAudioFormat;
+	if (![
+		"audio/pcm",
+		"audio/pcmu",
+		"audio/pcma"
+	].includes(f.type) || f.type === "audio/pcm" && f.rate === void 0 || f.rate !== void 0 && (!Number.isSafeInteger(f.rate) || f.rate <= 0)) return s.fail(new n({
+		reason: "input",
+		message: "streamTranscribe requires raw PCM (with a positive integer rate), PCMU or PCMA audio; decode container files first."
+	}));
+	let p = yield* a.try({
+		try: () => t(c.provider ?? e()),
+		catch: d
+	});
+	if (p.doStream === void 0) return s.fail(new n({
+		reason: "unsupported",
+		message: "The selected transcription provider/model does not support streaming."
+	}));
+	let m = yield* a.try({
+		try: () => i({
+			model: p,
+			audio: c.audio,
+			inputAudioFormat: f,
+			...c.providerOptions === void 0 ? {} : { providerOptions: c.providerOptions },
+			abortSignal: u
+		}),
+		catch: d
+	}), h = s.fromReadableStream({
+		evaluate: () => m.fullStream,
+		onError: d
+	}).pipe(s.filter((e) => e.type !== "raw"), s.mapEffect((e) => e.type === "error" ? a.fail(d(e.error)) : o.decodeUnknownEffect(r)(e).pipe(a.mapError(d)))), g = s.fromEffect(a.tryPromise({
+		try: async () => {
+			let [e, t, n, i] = await Promise.all([
+				m.text,
+				m.segments,
+				m.language,
+				m.durationInSeconds
+			]);
+			return o.decodeUnknownSync(r)({
+				type: "finish",
+				text: e,
+				segments: t.map((e) => ({
+					text: e.text,
+					start: e.startSecond,
+					end: e.endSecond
+				})),
+				...n === void 0 ? {} : { language: n },
+				...i === void 0 ? {} : { durationSec: i }
+			});
+		},
+		catch: d
+	}));
+	return s.concat(h, g);
+}));
+//#endregion
+export { n as TranscriptionStreamError, r as TranscriptionStreamEvent, c as streamTranscribe };

package/dist/streamWakeups.js

@@ -0,0 +1,44 @@
+import { Effect as e } from "effect";
+//#region src/streamWakeups.ts
+var t = /* @__PURE__ */ new WeakMap(), n = (e, n) => (t.get(e)?.get(n)?.readers ?? 0) > 0, r = (n, r) => e.acquireRelease(e.sync(() => {
+	let e = t.get(n);
+	e === void 0 && (e = /* @__PURE__ */ new Map(), t.set(n, e));
+	let i = e.get(r);
+	return i === void 0 && (i = {
+		version: 0,
+		readers: 0,
+		waiters: /* @__PURE__ */ new Set()
+	}, e.set(r, i)), i.readers++, i;
+}), (i) => e.sync(() => {
+	if (i.readers--, i.readers === 0) {
+		let e = t.get(n);
+		e?.delete(r), e?.size === 0 && t.delete(n);
+	}
+})), i = (t, n) => e.callback((r) => {
+	if (t.version !== n) {
+		r(e.void);
+		return;
+	}
+	let i = () => {
+		t.waiters.delete(i), r(e.void);
+	};
+	return t.waiters.add(i), e.sync(() => {
+		t.waiters.delete(i);
+	});
+}), a = (n) => {
+	let r = (e) => {
+		let n = t.get(i)?.get(e);
+		if (n === void 0) return;
+		n.version++;
+		let r = [...n.waiters];
+		for (let e of r) n.waiters.has(e) && e();
+	}, i = {
+		...n,
+		append: (t, i) => n.append(t, i).pipe(e.tap(() => e.sync(() => r(t)))),
+		...n.appendMany === void 0 ? {} : { appendMany: (t, i) => n.appendMany(t, i).pipe(e.tap(() => e.sync(() => r(t)))) },
+		markDone: (t) => n.markDone(t).pipe(e.tap(() => e.sync(() => r(t))))
+	};
+	return i;
+};
+//#endregion
+export { i as awaitStreamChange, n as hasStreamReaders, r as watchStream, a as withStreamWakeups };

package/dist/structuredEvidence.js

@@ -0,0 +1,48 @@
+import { normalizeAiCallEvidence as e } from "./callEvidence.js";
+import { wrapLanguageModel as t } from "ai";
+//#region src/structuredEvidence.ts
+var n = (n, r) => {
+	let i = [];
+	return {
+		model: t({
+			model: r,
+			middleware: {
+				specificationVersion: "v4",
+				wrapGenerate: async ({ doGenerate: t }) => {
+					let a = await t(), o = a.usage.inputTokens.total, s = a.usage.outputTokens.total;
+					return i.push(e(n, r.modelId, {
+						inputTokens: o,
+						outputTokens: s,
+						totalTokens: o !== void 0 && s !== void 0 ? o + s : void 0
+					}, a.providerMetadata)), a;
+				}
+			}
+		}),
+		evidence: (t) => {
+			if (i.length === 0) return e(n, r.modelId, t);
+			let a = (e) => {
+				let t = 0;
+				for (let n of i) {
+					let r = n.usage[e];
+					if (r === void 0) return;
+					t += r;
+				}
+				return t;
+			}, o = 0;
+			for (let e of i) {
+				if (e.cost.status !== "actual") {
+					o = void 0;
+					break;
+				}
+				o += e.cost.usd;
+			}
+			return e(n, r.modelId, {
+				inputTokens: a("inputTokens"),
+				outputTokens: a("outputTokens"),
+				totalTokens: a("totalTokens")
+			}, o === void 0 ? void 0 : { gateway: { cost: o } });
+		}
+	};
+};
+//#endregion
+export { n as captureStructuredEvidence };

package/dist/test.js

@@ -1,4 +1,4 @@
-import { t as e, u as t } from "./provider-BnemgE4D.js";
+import { MockScript as e, setProviderOverride as t } from "./provider.js";
 //#region src/test/index.ts
 var n = (e) => e.turns && e.turns.length > 0 ? e.turns : e.stream && e.stream.length > 0 ? [{ text: e.stream.join("") }] : e.generate ? [{ text: e.generate.text }] : [{ text: "" }], r = (t) => {
 	let r = new e(n(t));

package/dist/threads.js

@@ -0,0 +1,92 @@
+import { AGENT_MESSAGES_TABLE as e, AGENT_THREADS_TABLE as t } from "./agentConstants.js";
+import { AgentThreadAccessDenied as n } from "./agent.js";
+import { Effect as r } from "effect";
+import { boolean as i, id as a, integer as o, json as s, table as c, text as l, timestamp as u } from "@voltro/database";
+//#region src/threads.ts
+var d = c(t, {
+	id: a({ prefix: "thread" }),
+	tenantId: l().nullable(),
+	subjectId: l().nullable(),
+	title: l().nullable(),
+	createdAt: u(),
+	updatedAt: u()
+}).renamedFrom("agent_threads").index(["tenantId"]), f = c(e, {
+	id: a({ prefix: "msg" }),
+	threadId: l(),
+	tenantId: l().nullable(),
+	role: l(),
+	content: l(),
+	streaming: i(),
+	order: o(),
+	stepOrder: o(),
+	parts: s(),
+	createdAt: u()
+}).renamedFrom("agent_messages").index(["threadId"]), p = (e, n = {}) => r.promise(async () => {
+	let r = /* @__PURE__ */ new Date();
+	return await e.insert(t, {
+		tenantId: n.tenantId ?? null,
+		subjectId: n.subjectId ?? null,
+		title: n.title ?? null,
+		createdAt: r,
+		updatedAt: r
+	});
+}), m = (e, i) => r.gen(function* () {
+	let a = yield* _(e, i.threadId);
+	if (a === null) {
+		let n = /* @__PURE__ */ new Date();
+		return yield* r.promise(() => e.insert(t, {
+			id: i.threadId,
+			tenantId: i.tenantId ?? null,
+			subjectId: i.subjectId,
+			title: null,
+			createdAt: n,
+			updatedAt: n
+		}));
+	}
+	return a.subjectId !== null && a.subjectId !== i.subjectId ? yield* r.fail(new n({ threadId: i.threadId })) : a;
+}), h = (n, i) => r.promise(async () => {
+	let r = i.parts ?? (i.content ? [{
+		type: "text",
+		text: i.content
+	}] : []), a = await n.insert(e, {
+		threadId: i.threadId,
+		tenantId: i.tenantId ?? null,
+		role: i.role,
+		content: i.content,
+		streaming: i.streaming ?? !1,
+		order: i.order ?? 0,
+		stepOrder: i.stepOrder ?? 0,
+		parts: r,
+		createdAt: /* @__PURE__ */ new Date()
+	});
+	return await n.update(t, i.threadId, { updatedAt: /* @__PURE__ */ new Date() }).catch(() => null), a;
+}), g = (t, n) => r.promise(async () => await t.query({
+	table: e,
+	predicate: {
+		_tag: "leaf",
+		column: "threadId",
+		op: "eq",
+		value: n
+	},
+	order: [{
+		column: "createdAt",
+		direction: "asc"
+	}],
+	take: void 0,
+	skip: void 0,
+	projection: void 0
+})), _ = (e, t) => r.promise(async () => (await e.query({
+	table: "_voltro_agent_threads",
+	predicate: {
+		_tag: "leaf",
+		column: "id",
+		op: "eq",
+		value: t
+	},
+	order: [],
+	take: 1,
+	skip: void 0,
+	projection: void 0
+}))[0] ?? null);
+//#endregion
+export { e as AGENT_MESSAGES_TABLE, t as AGENT_THREADS_TABLE, f as agentMessagesTable, d as agentThreadsTable, h as appendMessage, p as createThread, m as ensureThreadOwned, g as getMessages, _ as getThread };