better-supabase 0.8.0 → 0.9.0

package/dist/ai-chat-CVLRWbtS.js

@@ -1,744 +0,0 @@
-import { a as ok, t as AsyncResult } from "./result-DEqHCMKP.js";
-import { n as isRecord } from "./guards-6F2bCtQR.js";
-import { A as stringsOf, N as toInstant, S as recordOf, _ as optionalInstant, g as oneOf, i as blockCall, j as textOf, l as errorText, n as applyTemporal, v as optionalText, w as recordsOf, y as pageOf } from "./block-helpers-Cy3pB96I.js";
-import { n as runStateOf } from "./run-state-CgBKzYMW.js";
-import { t as AI_MESSAGE_PART_TYPES } from "./ai-message-DfaP8sis.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 };