better-supabase 0.11.0 → 0.13.0

package/dist/client-0qFNkNhT.js

@@ -0,0 +1,1060 @@
+import { a as ok, t as AsyncResult } from "./result-DIT_qp4G.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { t as AI_MESSAGE_PART_TYPES } from "./ai-message-DfaP8sis.js";
+import { n as runStateOf } from "./run-state-CgBKzYMW.js";
+import { n as whileSignedIn, t as defineController } from "./controller-BEliOBOv.js";
+import { C as optionalText, D as recordOf, F as stringsOf, I as textOf, R as toInstant, S as optionalInstant, b as oneOf, f as errorText, h as instantOf, k as recordsOf, n as applyTemporal, o as blockCall, w as pageOf } from "./block-helpers-DwE32_gT.js";
+import { r as withBlockHooks } from "./block-hooks-C1r-R2r0.js";
+import { c as withFields, i as extraOf, n as blockFields, t as allWithFields } from "./block-fields-Cwd4c8m-.js";
+//#region src/blocks/ai-chat/rows.ts
+const record = (value) => isRecord(value) ? value : {};
+const optionalNumber = (value) => typeof value === "number" ? value : void 0;
+function chatOf(value) {
+	const row = recordOf(value, "ai_chat");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		ownerId: textOf(row["owner_id"]),
+		projectId: optionalText(row["project_id"]),
+		agentId: optionalText(row["agent_id"]),
+		title: textOf(row["title"] ?? ""),
+		model: optionalText(row["model"]),
+		visibility: oneOf(row["visibility"], ["private", "organization"], "private"),
+		pinned: row["pinned"] === true,
+		archivedAt: optionalInstant(row["archived_at"]),
+		temporary: row["is_temporary"] === true,
+		expiresAt: optionalInstant(row["expires_at"]),
+		leafId: optionalText(row["current_leaf_id"]),
+		activeStreamId: optionalText(row["active_stream_id"]),
+		activeRunId: optionalText(row["active_run_id"]),
+		lastMessageAt: instantOf(row["last_message_at"]),
+		createdAt: instantOf(row["created_at"]),
+		updatedAt: instantOf(row["updated_at"])
+	};
+}
+function projectOf(value) {
+	const row = recordOf(value, "ai_project");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		ownerId: textOf(row["owner_id"]),
+		name: textOf(row["name"]),
+		instructions: textOf(row["instructions"] ?? ""),
+		defaultModel: optionalText(row["default_model"]),
+		pinned: row["pinned"] === true,
+		archivedAt: optionalInstant(row["archived_at"]),
+		createdAt: instantOf(row["created_at"]),
+		updatedAt: instantOf(row["updated_at"])
+	};
+}
+const PART_TYPES = new Set(AI_MESSAGE_PART_TYPES);
+/**
+* The table's check constraint admits only canonical parts; this keeps the type
+* honest.
+*/
+function isPart(value) {
+	return isRecord(value) && PART_TYPES.has(value["type"]);
+}
+const ROLES = [
+	"system",
+	"user",
+	"assistant",
+	"tool"
+];
+function storedOf(value) {
+	const row = recordOf(value, "ai_message_path");
+	const metadata = row["metadata"];
+	const parts = Array.isArray(row["parts"]) ? row["parts"].filter(isPart) : [];
+	return {
+		id: textOf(row["id"]),
+		role: oneOf(row["role"], ROLES, "user"),
+		parts,
+		...isRecord(metadata) && Object.keys(metadata).length > 0 ? { metadata } : {},
+		parentId: optionalText(row["parent_id"]),
+		format: textOf(row["format"] ?? "canonical"),
+		native: row["native"] ?? void 0,
+		model: optionalText(row["model"]),
+		status: oneOf(row["status"], [
+			"complete",
+			"aborted",
+			"error"
+		], "complete"),
+		createdAt: instantOf(row["created_at"]),
+		siblingCount: optionalNumber(row["sibling_count"]) ?? 1,
+		siblingIndex: optionalNumber(row["sibling_index"]) ?? 0
+	};
+}
+function savedOf(value) {
+	const row = recordOf(value, "ai_message");
+	return {
+		messageId: textOf(row["message_id"]),
+		parentId: optionalText(row["parent_id"]),
+		created: row["created"] === true
+	};
+}
+/** Reads an approval row from the module's JSON. */
+function approvalOf(value) {
+	const row = recordOf(value, "ai_tool_approval");
+	return {
+		approvalId: textOf(row["approval_id"]),
+		chatId: textOf(row["chat_id"]),
+		runId: optionalText(row["run_id"]),
+		messageId: optionalText(row["message_id"]),
+		tool: textOf(row["tool"]),
+		toolCallId: textOf(row["tool_call_id"]),
+		input: row["input"] ?? void 0,
+		decision: oneOf(row["decision"], [
+			"pending",
+			"approved",
+			"denied"
+		], "pending"),
+		reason: optionalText(row["reason"]),
+		signature: optionalText(row["signature"]),
+		decidedBy: optionalText(row["decided_by"]),
+		decidedAt: optionalInstant(row["decided_at"]),
+		createdAt: instantOf(row["created_at"])
+	};
+}
+const POLICIES = [
+	"auto",
+	"ask",
+	"deny"
+];
+function policyOf(value) {
+	return POLICIES.find((policy) => policy === value);
+}
+function inputOf(value) {
+	const row = recordOf(value, "ai_pending_input");
+	const answer = row["answer"];
+	return {
+		id: textOf(row["id"]),
+		chatId: textOf(row["chat_id"]),
+		runId: optionalText(row["run_id"]),
+		toolCallId: optionalText(row["tool_call_id"]),
+		question: textOf(row["question"] ?? ""),
+		schema: row["schema"] ?? void 0,
+		answer: isRecord(answer) && "value" in answer ? answer["value"] : answer,
+		answeredAt: optionalInstant(row["answered_at"]),
+		createdAt: instantOf(row["created_at"])
+	};
+}
+function feedbackOf(value) {
+	const row = recordOf(value, "rate_ai_message");
+	const rating = row["rating"];
+	return {
+		chatId: textOf(row["chat_id"]),
+		messageId: textOf(row["message_id"]),
+		rating: rating === 1 || rating === -1 ? rating : 0,
+		reason: optionalText(row["reason"]),
+		comment: optionalText(row["comment"])
+	};
+}
+function shareOf(value) {
+	const row = recordOf(value, "list_ai_chat_shares");
+	return {
+		id: textOf(row["id"]),
+		leafId: textOf(row["leaf_id"]),
+		createdBy: optionalText(row["created_by"]),
+		createdAt: instantOf(row["created_at"]),
+		revokedAt: optionalInstant(row["revoked_at"])
+	};
+}
+function sharedOf(value) {
+	const row = recordOf(value, "get_shared_ai_chat");
+	const chat = record(row["chat"]);
+	return {
+		chat: {
+			id: textOf(chat["id"]),
+			title: textOf(chat["title"] ?? ""),
+			model: optionalText(chat["model"]),
+			createdAt: instantOf(chat["created_at"])
+		},
+		leafId: textOf(row["leaf_id"]),
+		messages: recordsOf(row["messages"], "get_shared_ai_chat").map(storedOf)
+	};
+}
+function modelOf(value) {
+	const row = recordOf(value, "allowed_ai_models");
+	return {
+		id: textOf(row["model_id"]),
+		provider: textOf(row["provider"]),
+		name: textOf(row["name"]),
+		pricing: record(row["pricing"]),
+		capabilities: record(row["capabilities"]),
+		plans: stringsOf(row["plans"]),
+		enabled: row["enabled"] !== false,
+		refreshedAt: optionalInstant(row["refreshed_at"])
+	};
+}
+function moderationOf(value) {
+	const row = recordOf(value, "ai_moderation_event");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		chatId: optionalText(row["chat_id"]),
+		messageId: optionalText(row["message_id"]),
+		userId: optionalText(row["user_id"]),
+		stage: oneOf(row["stage"], [
+			"input",
+			"output",
+			"tool"
+		], "input"),
+		category: textOf(row["category"] ?? ""),
+		score: optionalNumber(row["score"]),
+		action: oneOf(row["action"], [
+			"allow",
+			"flag",
+			"redact",
+			"block"
+		], "flag"),
+		createdAt: instantOf(row["created_at"])
+	};
+}
+/** The fields `create_ai_chat` reads, from the ones the input names. */
+function chatFields(input) {
+	const fields = {};
+	if (input.id !== void 0) fields["id"] = input.id;
+	if (input.title !== void 0) fields["title"] = input.title;
+	if (input.model !== void 0) fields["model"] = input.model;
+	if (input.projectId !== void 0) fields["project_id"] = input.projectId;
+	if (input.agentId !== void 0) fields["agent_id"] = input.agentId;
+	if (input.visibility !== void 0) fields["visibility"] = input.visibility;
+	if (input.pinned !== void 0) fields["pinned"] = input.pinned;
+	if (input.temporary !== void 0) fields["is_temporary"] = input.temporary;
+	if (input.ownerId !== void 0) fields["owner_id"] = input.ownerId;
+	return fields;
+}
+function patchFields$1(patch) {
+	const fields = {};
+	if (patch.title !== void 0) fields["title"] = patch.title;
+	if (patch.model !== void 0) fields["model"] = patch.model;
+	if (patch.projectId !== void 0) fields["project_id"] = patch.projectId;
+	if (patch.visibility !== void 0) fields["visibility"] = patch.visibility;
+	if (patch.pinned !== void 0) fields["pinned"] = patch.pinned;
+	if (patch.archived !== void 0) fields["archived"] = patch.archived;
+	return fields;
+}
+function projectFields(input) {
+	const fields = {};
+	if (input.name !== void 0) fields["name"] = input.name;
+	if (input.instructions !== void 0) fields["instructions"] = input.instructions;
+	if (input.defaultModel !== void 0) fields["default_model"] = input.defaultModel;
+	if (input.pinned !== void 0) fields["pinned"] = input.pinned;
+	if (input.archived !== void 0) fields["archived"] = input.archived;
+	return fields;
+}
+const canonical = (message) => ({
+	id: message.id,
+	role: message.role,
+	parts: message.parts,
+	...message.metadata === void 0 ? {} : { metadata: message.metadata }
+});
+/**
+* The chat block over the `ai-chat` SQL module: chats with a message tree,
+* projects, stream claims, tool approvals, feedback, share links, the model
+* catalog and moderation events. It names no AI SDK; the adapters in
+* `better-supabase/ai-sdk` convert to and from it.
+*/
+//#endregion
+//#region src/blocks/ai-chat/durable.ts
+const RUN_STATES = [
+	"queued",
+	"running",
+	"cancel_requested",
+	"completed",
+	"failed",
+	"cancelled"
+];
+const STEP_STATES = [
+	"running",
+	"done",
+	"error",
+	"skipped"
+];
+const HARNESS_STATES = [
+	"active",
+	"idle",
+	"stopped",
+	"error"
+];
+const object = (value) => isRecord(value) ? value : {};
+function runOf(value) {
+	const row = recordOf(value, "ai_run");
+	return {
+		id: textOf(row["id"]),
+		chatId: textOf(row["chat_id"]),
+		ownerId: textOf(row["owner_id"]),
+		assistantMessageId: optionalText(row["assistant_message_id"]),
+		streamId: optionalText(row["stream_id"]),
+		engine: textOf(row["engine"]),
+		externalRunId: optionalText(row["external_run_id"]),
+		model: optionalText(row["model"]),
+		status: runStateOf(row["status"], RUN_STATES, "running"),
+		usage: object(row["usage"]),
+		costMicroUsd: row["cost_micro_usd"] === null || row["cost_micro_usd"] === void 0 ? void 0 : Number(row["cost_micro_usd"]),
+		error: optionalText(row["error"]),
+		startedAt: toInstant(textOf(row["started_at"])),
+		endedAt: optionalInstant(row["ended_at"])
+	};
+}
+function stepOf(value) {
+	const row = recordOf(value, "ai_run_step");
+	return {
+		id: textOf(row["id"]),
+		runId: textOf(row["run_id"]),
+		chatId: textOf(row["chat_id"]),
+		key: textOf(row["step_key"]),
+		label: textOf(row["label"]),
+		status: oneOf(row["status"], STEP_STATES, "running"),
+		detail: object(row["detail"]),
+		startedAt: toInstant(textOf(row["started_at"])),
+		endedAt: optionalInstant(row["ended_at"])
+	};
+}
+/**
+* Run lookups, run steps and the approval inbox: what a durable chat needs to
+* stop or resume a run, and what an activity console shows.
+*/
+function aiRunLookups(options) {
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	return {
+		get: (runId) => call("get_ai_run", { run: runId }, runOf),
+		list: (query = {}) => call("list_ai_runs", {
+			chat: query.chatId,
+			active: query.active,
+			size: pageOf(query).limit
+		}, (value) => recordsOf(value, "list_ai_runs").map(runOf)),
+		attach: (runId, externalRunId) => service("attach_ai_run", {
+			run: runId,
+			external_run_id: externalRunId
+		}, (value) => value === true),
+		steps: {
+			record: (runId, step) => service("record_ai_run_step", {
+				run: runId,
+				step: {
+					key: step.key,
+					...step.label === void 0 ? {} : { label: step.label },
+					...step.status === void 0 ? {} : { status: step.status },
+					...step.detail === void 0 ? {} : { detail: step.detail }
+				}
+			}, stepOf),
+			list: (runId) => call("list_ai_run_steps", { run: runId }, (value) => recordsOf(value, "list_ai_run_steps").map(stepOf))
+		},
+		pendingApprovals: (size) => call("list_pending_ai_tool_approvals", { size }, (value) => recordsOf(value, "list_pending_ai_tool_approvals").map((row) => ({
+			...approvalOf(row),
+			chatTitle: textOf(row["chat_title"] ?? "")
+		})))
+	};
+}
+function harnessOf(value) {
+	const row = recordOf(value, "ai_harness_session");
+	return {
+		chatId: textOf(row["chat_id"]),
+		harnessId: textOf(row["harness_id"]),
+		ownerId: textOf(row["owner_id"]),
+		resumeState: row["resume_state"] ?? void 0,
+		continueState: row["continue_state"] ?? void 0,
+		sandboxId: optionalText(row["sandbox_id"]),
+		status: oneOf(row["status"], HARNESS_STATES, "active"),
+		lockHolder: optionalText(row["lock_holder"]),
+		lockedUntil: optionalInstant(row["locked_until"]),
+		lastActiveAt: toInstant(textOf(row["last_active_at"])),
+		createdAt: toInstant(textOf(row["created_at"])),
+		updatedAt: toInstant(textOf(row["updated_at"]))
+	};
+}
+function patchFields(patch) {
+	return {
+		..."resumeState" in patch ? { resume_state: patch.resumeState ?? null } : {},
+		..."continueState" in patch ? { continue_state: patch.continueState ?? null } : {},
+		..."sandboxId" in patch ? { sandbox_id: patch.sandboxId ?? null } : {},
+		...patch.sandboxProvider === void 0 ? {} : { sandbox_provider: patch.sandboxProvider },
+		...patch.status === void 0 ? {} : { status: patch.status }
+	};
+}
+/**
+* The harness session store of the `ai-chat` block (experimental). It takes a
+* service transport: harness state stays on the server.
+*/
+function createHarnessSessions(options) {
+	applyTemporal(options);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const isTrue = (value) => value === true;
+	return {
+		load: (chatId, harnessId) => service("load_ai_harness_session", {
+			chat: chatId,
+			harness: harnessId
+		}, (value) => value === null ? void 0 : harnessOf(value)),
+		save: (chatId, harnessId, patch, saveOptions = {}) => service("save_ai_harness_session", {
+			chat: chatId,
+			harness: harnessId,
+			fields: patchFields(patch),
+			holder: saveOptions.holder
+		}, harnessOf),
+		lock: (chatId, harnessId, holder, lockOptions = {}) => service("lock_ai_harness_session", {
+			chat: chatId,
+			harness: harnessId,
+			holder,
+			ttl_seconds: lockOptions.ttlSeconds
+		}, isTrue),
+		unlock: (chatId, harnessId, holder) => service("unlock_ai_harness_session", {
+			chat: chatId,
+			harness: harnessId,
+			holder
+		}, isTrue)
+	};
+}
+//#endregion
+//#region src/blocks/ai-chat/sandbox-rows.ts
+const SANDBOX_STATUSES = [
+	"running",
+	"stopping",
+	"stopped"
+];
+const sandboxInstant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
+function sandboxOf(value) {
+	const row = recordOf(value, "ai_sandboxes");
+	const idle = row["idle_seconds"];
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		userId: optionalText(row["user_id"]),
+		chatId: optionalText(row["chat_id"]),
+		harnessId: optionalText(row["harness_id"]),
+		provider: textOf(row["provider"]),
+		sandboxId: textOf(row["sandbox_id"]),
+		containerId: optionalText(row["container_id"]),
+		status: oneOf(row["status"], SANDBOX_STATUSES, "stopped"),
+		metadata: isRecord(row["metadata"]) ? row["metadata"] : {},
+		idleSeconds: typeof idle === "number" && Number.isFinite(idle) ? idle : 0,
+		error: optionalText(row["error"]),
+		lastUsedAt: sandboxInstant(row["last_used_at"]),
+		expiresAt: optionalInstant(row["expires_at"]),
+		stoppedAt: optionalInstant(row["stopped_at"]),
+		createdAt: sandboxInstant(row["created_at"])
+	};
+}
+//#endregion
+//#region src/blocks/ai-chat/sandboxes.ts
+function sandboxFields(sandbox) {
+	return {
+		...sandbox.userId === void 0 ? {} : { user_id: sandbox.userId },
+		...sandbox.chatId === void 0 ? {} : { chat_id: sandbox.chatId },
+		...sandbox.harnessId === void 0 ? {} : { harness_id: sandbox.harnessId },
+		...sandbox.containerId === void 0 ? {} : { container_id: sandbox.containerId },
+		...sandbox.metadata === void 0 ? {} : { metadata: sandbox.metadata },
+		...sandbox.idleSeconds === void 0 ? {} : { idle_seconds: Math.max(1, Math.round(sandbox.idleSeconds)) },
+		...sandbox.expiresAt === void 0 ? {} : { expires_at: sandbox.expiresAt.toString() }
+	};
+}
+/** The sandbox registry over the chat block's user and service calls. */
+function aiSandboxes(call, service) {
+	const idle = (idleOptions = {}) => service("idle_ai_sandboxes", {
+		batch: idleOptions.batch,
+		lease_seconds: idleOptions.leaseSeconds
+	}, (value) => recordsOf(value, "idle_ai_sandboxes").map(sandboxOf));
+	const finishStop = (sandboxId, stopped, error) => service("finish_ai_sandbox_stop", {
+		id: sandboxId,
+		stopped,
+		error
+	}, (value) => value === true);
+	const stopIdle = (stop, stopOptions = {}) => idle(stopOptions).andThen((claimed) => AsyncResult.from(async () => {
+		let stopped = 0;
+		for (const sandbox of claimed) {
+			let error;
+			try {
+				await stop(sandbox);
+			} catch (cause) {
+				error = errorText(cause);
+			}
+			const finished = await finishStop(sandbox.id, error === void 0, error);
+			if (!finished.ok) return finished;
+			if (error === void 0) stopped += 1;
+		}
+		return ok(stopped);
+	}));
+	return {
+		register: (organizationId, sandbox) => service("register_ai_sandbox", {
+			tenant: organizationId,
+			provider: sandbox.provider,
+			sandbox_id: sandbox.sandboxId,
+			fields: sandboxFields(sandbox)
+		}, sandboxOf),
+		touch: (sandboxId) => service("touch_ai_sandbox", { id: sandboxId }, (value) => value === true),
+		forChat: (chatId, provider) => service("ai_sandbox_for", {
+			chat_id: chatId,
+			provider
+		}, (value) => value === null || value === void 0 ? void 0 : sandboxOf(value)),
+		list: (organizationId, listOptions = {}) => call("list_ai_sandboxes", {
+			tenant: organizationId,
+			chat_id: listOptions.chatId
+		}, (value) => recordsOf(value, "list_ai_sandboxes").map(sandboxOf)),
+		idle,
+		finishStop,
+		stopIdle,
+		idleStopJob: (stop, jobOptions) => async () => stopIdle(stop, jobOptions).orThrow()
+	};
+}
+//#endregion
+//#region src/blocks/ai-chat/ai-chat.ts
+/** The topic of one chat's events (`message.saved`, `stream.started`, ...). */
+function aiChatTopic(chatId, prefix = "ai-chat") {
+	return `${prefix}:${chatId}`;
+}
+/** The topic that tells a user their chat list changed. */
+function aiChatListTopic(userId, prefix = "ai-chats") {
+	return `${prefix}:${userId}`;
+}
+const CHAT_INPUT = /* @__PURE__ */ new Set([
+	"id",
+	"title",
+	"model",
+	"projectId",
+	"agentId",
+	"visibility",
+	"pinned",
+	"temporary",
+	"ownerId",
+	"archived"
+]);
+function createAiChat(options) {
+	applyTemporal(options);
+	const fields = blockFields(options.fields, "chat fields");
+	const typed = (value) => AsyncResult.from(() => withFields(fields, value, chatOf(value)));
+	const checked = (input) => AsyncResult.from(() => fields.write(extraOf(input, CHAT_INPUT)));
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const isTrue = (value) => value === true;
+	const count = (value) => typeof value === "number" ? value : Number(value ?? 0);
+	const client = {
+		chats: {
+			create: (organizationId, input = {}) => checked(input).andThen((extra) => (input.ownerId === void 0 ? call : service)("create_ai_chat", {
+				tenant: organizationId,
+				fields: {
+					...extra,
+					...chatFields(input)
+				}
+			}, (value) => value).andThen(typed)),
+			get: (chatId) => call("get_ai_chat", { chat: chatId }, (value) => value).andThen(typed),
+			list: (query = {}) => call("list_ai_chats", {
+				tenant: query.organizationId ?? null,
+				search: query.search,
+				project: query.projectId,
+				pinned: query.pinned,
+				archived: query.archived,
+				after: pageOf(query).cursor,
+				size: pageOf(query).limit
+			}, (value) => {
+				const row = recordOf(value, "list_ai_chats");
+				return {
+					items: recordsOf(row["items"], "list_ai_chats").map((item) => [item, chatOf(item)]),
+					next: optionalText(row["next"])
+				};
+			}).andThen(async ({ items, next }) => {
+				const parsed = await allWithFields(fields, items);
+				return parsed.ok ? ok({
+					items: parsed.data,
+					next
+				}) : parsed;
+			}),
+			update: (chatId, patch) => checked(patch).andThen((extra) => call("update_ai_chat", {
+				chat: chatId,
+				fields: {
+					...extra,
+					...patchFields$1(patch)
+				}
+			}, (value) => value).andThen(typed)),
+			remove: (chatId) => call("delete_ai_chat", { chat: chatId }, isTrue),
+			purge: (batch) => service("purge_ai_chats", { batch }, count)
+		},
+		projects: {
+			create: (organizationId, input) => call("save_ai_project", {
+				id: null,
+				tenant: organizationId,
+				fields: projectFields(input)
+			}, projectOf),
+			update: (projectId, input) => call("save_ai_project", {
+				id: projectId,
+				tenant: null,
+				fields: projectFields(input)
+			}, projectOf),
+			list: (organizationId) => call("list_ai_projects", { tenant: organizationId }, (value) => recordsOf(value, "list_ai_projects").map(projectOf)),
+			remove: (projectId) => call("delete_ai_project", { id: projectId }, isTrue)
+		},
+		messages: {
+			appendUser: (chatId, message, appendOptions = {}) => call("append_ai_user_message", {
+				chat: chatId,
+				message: canonical(message),
+				trigger: appendOptions.trigger,
+				message_id: appendOptions.messageId
+			}, savedOf),
+			saveAssistant: (chatId, message, saveOptions) => service("save_ai_assistant_message", {
+				chat: chatId,
+				message: canonical(message),
+				parent_id: saveOptions.parentId,
+				status: saveOptions.status,
+				model: saveOptions.model,
+				format: saveOptions.format,
+				native: saveOptions.native === void 0 ? void 0 : { value: saveOptions.native },
+				run: saveOptions.runId
+			}, savedOf),
+			path: (chatId, pathOptions = {}) => call("ai_message_path", {
+				chat: chatId,
+				leaf: pathOptions.leafId,
+				include_native: pathOptions.native
+			}, (value) => recordsOf(value, "ai_message_path").map((row) => {
+				const stored = storedOf(row);
+				const native = stored.native;
+				return isRecord(native) && "value" in native ? {
+					...stored,
+					native: native["value"]
+				} : stored;
+			})),
+			siblings: (chatId, messageId) => call("ai_message_siblings", {
+				chat: chatId,
+				message_id: messageId
+			}, (value) => recordsOf(value, "ai_message_siblings").map((row) => ({
+				id: textOf(row["id"]),
+				role: oneOf(row["role"], ROLES, "user"),
+				createdAt: instantOf(row["created_at"])
+			}))),
+			switchBranch: (chatId, messageId) => call("switch_ai_branch", {
+				chat: chatId,
+				message_id: messageId
+			}, (value) => textOf(recordOf(value, "switch_ai_branch")["leaf_id"]))
+		},
+		sandboxes: aiSandboxes(call, service),
+		runs: {
+			...aiRunLookups(options),
+			claim: (chatId, streamId, claimOptions = {}) => service("claim_ai_chat_stream", {
+				chat: chatId,
+				stream: streamId,
+				model: claimOptions.model,
+				message_id: claimOptions.messageId,
+				engine: claimOptions.engine,
+				external_run_id: claimOptions.externalRunId
+			}, (value) => {
+				const row = recordOf(value, "claim_ai_chat_stream");
+				return {
+					claimed: row["claimed"] === true,
+					streamId: optionalText(row["stream_id"]),
+					runId: optionalText(row["run_id"])
+				};
+			}),
+			release: (chatId, streamId, release = {}) => service("release_ai_chat_stream", {
+				chat: chatId,
+				stream: streamId,
+				status: release.status,
+				usage: release.usage,
+				generation_id: release.generationId,
+				error: release.error,
+				cost_micro_usd: release.costMicroUsd
+			}, isTrue),
+			stop: (chatId) => call("request_ai_chat_stop", { chat: chatId }, (value) => {
+				const row = record(value);
+				const streamId = optionalText(row["stream_id"]);
+				const runId = optionalText(row["run_id"]);
+				return streamId && runId ? {
+					streamId,
+					runId
+				} : void 0;
+			}),
+			setCost: (generationId, costMicroUsd, usage) => service("set_ai_run_cost", {
+				generation_id: generationId,
+				cost_micro_usd: costMicroUsd,
+				usage
+			}, isTrue)
+		},
+		approvals: {
+			request: (chatId, request) => service("record_ai_tool_approval", {
+				chat: chatId,
+				approval: {
+					approval_id: request.approvalId,
+					tool: request.tool,
+					tool_call_id: request.toolCallId,
+					input: request.input ?? null,
+					run_id: request.runId ?? null,
+					message_id: request.messageId ?? null,
+					signature: request.signature ?? null
+				}
+			}, approvalOf),
+			decide: (approvalId, approved, reason) => call("decide_ai_tool_approval", {
+				approval_id: approvalId,
+				approved,
+				reason
+			}, approvalOf),
+			list: (chatId, approvalIds) => call("get_ai_tool_approvals", {
+				chat: chatId,
+				ids: approvalIds
+			}, (value) => recordsOf(value, "get_ai_tool_approvals").map(approvalOf)),
+			setPolicy: (organizationId, tool, policy) => call("set_ai_tool_policy", {
+				tenant: organizationId,
+				tool,
+				policy
+			}, (value) => policyOf(record(value)["policy"])),
+			policies: (organizationId) => call("ai_tool_policies_for", { tenant: organizationId }, (value) => {
+				const policies = {};
+				for (const [tool, policy] of Object.entries(record(value))) {
+					const known = policyOf(policy);
+					if (known) policies[tool] = known;
+				}
+				return policies;
+			})
+		},
+		inputs: {
+			open: (chatId, request) => service("open_ai_pending_input", {
+				chat: chatId,
+				input: {
+					question: request.question,
+					schema: request.schema ?? null,
+					run_id: request.runId ?? null,
+					tool_call_id: request.toolCallId ?? null
+				}
+			}, inputOf),
+			answer: (inputId, answer) => call("answer_ai_pending_input", {
+				id: inputId,
+				answer: { value: answer }
+			}, inputOf)
+		},
+		feedback: { rate: (chatId, messageId, rating, rateOptions = {}) => call("rate_ai_message", {
+			chat: chatId,
+			message_id: messageId,
+			rating: rating === 0 ? null : rating,
+			reason: rateOptions.reason,
+			comment: rateOptions.comment
+		}, (value) => value === null || value === void 0 ? {
+			chatId,
+			messageId,
+			rating: 0,
+			reason: void 0,
+			comment: void 0
+		} : feedbackOf(value)) },
+		shares: {
+			create: (chatId, leafId) => call("share_ai_chat", {
+				chat: chatId,
+				leaf: leafId
+			}, (value) => {
+				const row = recordOf(value, "share_ai_chat");
+				return {
+					id: textOf(row["id"]),
+					token: textOf(row["token"]),
+					leafId: textOf(row["leaf_id"]),
+					createdAt: instantOf(row["created_at"])
+				};
+			}),
+			revoke: (shareId) => call("revoke_ai_chat_share", { id: shareId }, isTrue),
+			list: (chatId) => call("list_ai_chat_shares", { chat: chatId }, (value) => recordsOf(value, "list_ai_chat_shares").map(shareOf)),
+			get: (token) => call("get_shared_ai_chat", { token }, sharedOf)
+		},
+		models: {
+			allowed: (organizationId) => call("allowed_ai_models", { tenant: organizationId ?? null }, (value) => recordsOf(value, "allowed_ai_models").map(modelOf)),
+			upsert: (models, upsertOptions = {}) => service("upsert_ai_models", {
+				models: { models },
+				prune: upsertOptions.prune
+			}, count)
+		},
+		moderation: {
+			record: (event) => service("record_ai_moderation_event", { event: {
+				organization_id: event.organizationId,
+				stage: event.stage,
+				action: event.action,
+				chat_id: event.chatId ?? null,
+				message_id: event.messageId ?? null,
+				user_id: event.userId ?? null,
+				category: event.category,
+				score: event.score ?? null
+			} }, moderationOf),
+			list: (organizationId, size) => call("list_ai_moderation_events", {
+				tenant: organizationId,
+				size
+			}, (value) => recordsOf(value, "list_ai_moderation_events").map(moderationOf))
+		}
+	};
+	return withBlockHooks(client, options.hooks, {
+		block: "ai-chat",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/ai-chat/client.ts
+/**
+* Runs a write and returns its data, or records the error and returns
+* `undefined`.
+*/
+async function attempt(write, fail) {
+	const result = await write;
+	if (result.ok) return result.data;
+	fail(result.error);
+}
+/**
+* The signed-in user's chats in a tenant, newest first, loaded again when any
+* of their chats changes. Pages loaded with `loadMore` load again too.
+*/
+function createAiChatsController(options) {
+	const { chats } = options.client;
+	const query = {
+		...options.query,
+		organizationId: options.query?.organizationId ?? null
+	};
+	const prefix = options.topic === void 0 ? "ai-chats" : options.topic;
+	return defineController({
+		items: void 0,
+		hasMore: false,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let user = null;
+		let generation = 0;
+		let ticket = 0;
+		let pages = 1;
+		let next;
+		const fail = (error) => {
+			state.set({ error });
+		};
+		const showPage = (items, cursor) => {
+			next = cursor;
+			state.set({
+				items,
+				hasMore: cursor !== void 0,
+				error: void 0
+			});
+		};
+		const loadWindow = async () => {
+			if (user === null) return;
+			ticket += 1;
+			const run = ticket;
+			const items = [];
+			let page;
+			for (let loaded = 0; loaded < pages; loaded += 1) {
+				const result = await chats.list(page?.next === void 0 ? query : {
+					...query,
+					cursor: page.next
+				});
+				if (run !== ticket) return;
+				if (!result.ok) {
+					fail(result.error);
+					return;
+				}
+				page = result.data;
+				items.push(...page.items);
+				if (page.next === void 0) break;
+			}
+			showPage(items, page?.next);
+		};
+		const edit = (at, change) => {
+			if (at !== generation) return;
+			state.set((current) => current.items === void 0 ? {} : { items: change(current.items) });
+		};
+		return {
+			actions: {
+				refresh: loadWindow,
+				loadMore: async () => {
+					if (next === void 0 || user === null) return;
+					ticket += 1;
+					const run = ticket;
+					pages += 1;
+					const result = await chats.list({
+						...query,
+						cursor: next
+					});
+					if (run !== ticket) return;
+					if (!result.ok) {
+						pages -= 1;
+						fail(result.error);
+						return;
+					}
+					const page = result.data;
+					showPage([...state.get().items ?? [], ...page.items], page.next);
+				},
+				create: async (input) => {
+					const organizationId = query.organizationId;
+					if (!organizationId) return;
+					const at = generation;
+					const chat = await attempt(chats.create(organizationId, input), fail);
+					if (chat && !chat.temporary) edit(at, (items) => [chat, ...items.filter((item) => item.id !== chat.id)]);
+					return chat;
+				},
+				update: async (chatId, patch) => {
+					const at = generation;
+					const chat = await attempt(chats.update(chatId, patch), fail);
+					if (chat) edit(at, (items) => items.map((item) => item.id === chat.id ? chat : item));
+					return chat;
+				},
+				remove: async (chatId) => {
+					const at = generation;
+					if (await attempt(chats.remove(chatId), fail)) edit(at, (items) => items.filter((item) => item.id !== chatId));
+				}
+			},
+			start: () => whileSignedIn(options.auth, (userId) => {
+				user = userId;
+				generation += 1;
+				pages = 1;
+				next = void 0;
+				state.set({
+					items: void 0,
+					hasMore: false,
+					error: void 0
+				});
+				loadWindow();
+				const leave = prefix ? options.ports.topic(aiChatListTopic(userId, prefix), {
+					onMessage: () => void loadWindow(),
+					onRejoin: () => void loadWindow(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave : void 0;
+				return () => {
+					user = null;
+					generation += 1;
+					ticket += 1;
+					leave?.();
+					next = void 0;
+					state.set({
+						items: void 0,
+						hasMore: false,
+						error: void 0
+					});
+				};
+			})
+		};
+	});
+}
+/**
+* One chat's active branch, loaded again when a message is saved or the branch
+* changes, in this tab or another.
+*/
+function createAiChatTreeController(options) {
+	const { messages } = options.client;
+	const { chatId } = options;
+	const prefix = options.topic === void 0 ? "ai-chat" : options.topic;
+	return defineController({
+		path: void 0,
+		status: "closed",
+		error: void 0
+	}, (state) => {
+		let ticket = 0;
+		const apply = (result) => {
+			state.set(result.ok ? {
+				path: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		const loadPath = async (leafId) => {
+			if (!chatId) return;
+			ticket += 1;
+			const run = ticket;
+			const result = await messages.path(chatId, leafId === void 0 ? void 0 : { leafId });
+			if (run === ticket) apply(result);
+		};
+		const switchBranch = async (messageId) => {
+			if (!chatId) return;
+			const run = state.run();
+			const result = await messages.switchBranch(chatId, messageId);
+			if (run !== state.run()) return;
+			if (result.ok) await loadPath(result.data);
+			else state.set({ error: result.error });
+		};
+		return {
+			actions: {
+				refresh: () => loadPath(),
+				switchBranch,
+				step: async (messageId, offset) => {
+					if (!chatId) return;
+					const run = state.run();
+					const result = await messages.siblings(chatId, messageId);
+					if (run !== state.run()) return;
+					if (!result.ok) {
+						state.set({ error: result.error });
+						return;
+					}
+					const siblings = result.data;
+					const index = siblings.findIndex((item) => item.id === messageId);
+					const target = siblings[index + offset];
+					if (index !== -1 && target) await switchBranch(target.id);
+				}
+			},
+			start: () => {
+				loadPath();
+				const leave = chatId && prefix ? options.ports.topic(aiChatTopic(chatId, prefix), {
+					onMessage: (event) => {
+						if (event === "message.saved" || event === "leaf.changed") loadPath();
+					},
+					onRejoin: () => void loadPath(),
+					onStatus: (status) => {
+						state.set({ status });
+					}
+				}).leave : void 0;
+				return () => {
+					ticket += 1;
+					leave?.();
+				};
+			}
+		};
+	});
+}
+/** The models the tenant's plans allow, for a model picker. */
+function createAiModelsController(options) {
+	const tenant = options.organizationId ?? null;
+	return defineController({
+		models: void 0,
+		error: void 0
+	}, (state) => {
+		const refresh = async () => {
+			const run = state.run();
+			const result = await options.client.models.allowed(tenant);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				models: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: { refresh },
+			start: () => {
+				refresh();
+			}
+		};
+	});
+}
+/** Share links for one chat the user owns. */
+function createAiShareController(options) {
+	const { shares } = options.client;
+	const { chatId } = options;
+	return defineController({
+		shares: void 0,
+		error: void 0
+	}, (state) => {
+		const fail = (error) => {
+			state.set({ error });
+		};
+		const reload = async () => {
+			if (!chatId) return;
+			const run = state.run();
+			const result = await shares.list(chatId);
+			if (run !== state.run()) return;
+			state.set(result.ok ? {
+				shares: result.data,
+				error: void 0
+			} : { error: result.error });
+		};
+		return {
+			actions: {
+				create: async (leafId) => {
+					if (!chatId) return;
+					const link = await attempt(shares.create(chatId, leafId), fail);
+					if (link) await reload();
+					return link;
+				},
+				revoke: async (shareId) => {
+					if (await attempt(shares.revoke(shareId), fail)) await reload();
+				}
+			},
+			start: () => {
+				reload();
+			}
+		};
+	});
+}
+//#endregion
+export { aiChatListTopic as a, createHarnessSessions as c, createAiShareController as i, createAiChatsController as n, aiChatTopic as o, createAiModelsController as r, createAiChat as s, createAiChatTreeController as t };