better-supabase 0.5.1 → 0.6.0

package/dist/ai-chat-B24UI962.js

@@ -0,0 +1,743 @@
+import { a as ok, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { D as stringsOf, O as textOf, c as errorText, d as isRecord, g as pageOf, h as optionalText, i as blockCall, k as toInstant, m as optionalInstant, n as applyTemporal, p as oneOf, x as recordsOf, y as recordOf } from "./block-helpers-DWHxHsEQ.js";
+import { n as runStateOf } from "./run-state-CgBKzYMW.js";
+import { t as AI_MESSAGE_PART_TYPES } from "./message-CaKlqdsX.js";
+//#region src/blocks/ai-chat/rows.ts
+const record = (value) => isRecord(value) ? value : {};
+const instant = (value) => toInstant(textOf(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: instant(row["last_message_at"]),
+		createdAt: instant(row["created_at"]),
+		updatedAt: instant(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: instant(row["created_at"]),
+		updatedAt: instant(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: instant(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: instant(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: instant(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: instant(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: instant(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: instant(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}`;
+}
+function createAiChat(options) {
+	applyTemporal(options);
+	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);
+	return {
+		chats: {
+			create: (organizationId, input = {}) => (input.ownerId === void 0 ? call : service)("create_ai_chat", {
+				tenant: organizationId,
+				fields: chatFields(input)
+			}, chatOf),
+			get: (chatId) => call("get_ai_chat", { chat: chatId }, chatOf),
+			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(chatOf),
+					next: optionalText(row["next"])
+				};
+			}),
+			update: (chatId, patch) => call("update_ai_chat", {
+				chat: chatId,
+				fields: patchFields$1(patch)
+			}, chatOf),
+			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: instant(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: instant(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))
+		}
+	};
+}
+//#endregion
+export { createHarnessSessions as i, aiChatTopic as n, createAiChat as r, aiChatListTopic as t };