better-supabase 0.5.0 → 0.6.0

package/dist/blocks/ai-chat/react/index.js

@@ -0,0 +1,387 @@
+"use client";
+import { a as ok } from "../../../result-DzUbqgdW.js";
+import { i as useAuth, l as useSupabase } from "../../../hooks-1BTCJsiw.js";
+import { n as rpcTransport } from "../../../block-transport-BLr-ZgLc.js";
+import { g as pageOf } from "../../../block-helpers-DWHxHsEQ.js";
+import { t as watchTopic } from "../../../react-topic-seAWjL3_.js";
+import { n as aiChatTopic, r as createAiChat, t as aiChatListTopic } from "../../../ai-chat-B24UI962.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+//#region src/blocks/ai-chat/react/index.ts
+function useAiChatClient(schema) {
+	const supabase = useSupabase();
+	return useMemo(() => createAiChat({
+		transport: rpcTransport(supabase),
+		...schema === void 0 ? {} : { schema }
+	}), [supabase, schema]);
+}
+/** Keeps a result's data, or its error next to the last good data. */
+function useResultState() {
+	const [data, setData] = useState(void 0);
+	const [error, setError] = useState(void 0);
+	return {
+		data,
+		error,
+		apply: useCallback((result) => {
+			if (result.ok) {
+				setData(result.data);
+				setError(void 0);
+			} else setError(result.error);
+		}, []),
+		fail: setError,
+		set: setData,
+		reset: useCallback(() => {
+			setData(void 0);
+			setError(void 0);
+		}, [])
+	};
+}
+/** 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.
+*
+* ```tsx
+* const { items, loadMore, create } = useAiChats({ organizationId });
+* ```
+*/
+function useAiChats(options = {}) {
+	const supabase = useSupabase();
+	const auth = useAuth();
+	const client = useAiChatClient(options.schema);
+	const state = useResultState();
+	const [next, setNext] = useState(void 0);
+	const [status, setStatus] = useState("closed");
+	const userId = auth.user?.id ?? null;
+	const prefix = options.topic === void 0 ? "ai-chats" : options.topic;
+	const { organizationId, search, projectId, pinned, archived } = options;
+	const { limit } = pageOf(options);
+	const query = useMemo(() => ({
+		organizationId: organizationId ?? null,
+		...search === void 0 ? {} : { search },
+		...projectId === void 0 ? {} : { projectId },
+		...pinned === void 0 ? {} : { pinned },
+		...archived === void 0 ? {} : { archived },
+		...limit === void 0 ? {} : { limit }
+	}), [
+		organizationId,
+		search,
+		projectId,
+		pinned,
+		archived,
+		limit
+	]);
+	const { apply, fail, set, reset } = state;
+	const scope = useMemo(() => ({
+		client,
+		query,
+		userId
+	}), [
+		client,
+		query,
+		userId
+	]);
+	const [shown, setShown] = useState(scope);
+	if (shown !== scope) {
+		setShown(scope);
+		reset();
+		setNext(void 0);
+	}
+	const current = useRef(scope);
+	const ticket = useRef(0);
+	const pages = useRef(1);
+	const loadWindow = useCallback(async () => {
+		if (scope.userId === null || current.current !== scope) return;
+		const run = ++ticket.current;
+		const items = [];
+		let page;
+		for (let loaded = 0; loaded < pages.current; loaded += 1) {
+			const result = await scope.client.chats.list(page?.next === void 0 ? scope.query : {
+				...scope.query,
+				cursor: page.next
+			});
+			if (run !== ticket.current) return;
+			if (!result.ok) {
+				fail(result.error);
+				return;
+			}
+			page = result.data;
+			items.push(...page.items);
+			if (page.next === void 0) break;
+		}
+		apply(ok(items));
+		setNext(page?.next);
+	}, [
+		scope,
+		apply,
+		fail
+	]);
+	const loadMore = useCallback(async () => {
+		if (next === void 0 || current.current !== scope) return;
+		const run = ++ticket.current;
+		pages.current += 1;
+		const result = await scope.client.chats.list({
+			...scope.query,
+			cursor: next
+		});
+		if (run !== ticket.current) return;
+		if (!result.ok) {
+			pages.current -= 1;
+			fail(result.error);
+			return;
+		}
+		const page = result.data;
+		set((items) => [...items ?? [], ...page.items]);
+		setNext(page.next);
+	}, [
+		scope,
+		next,
+		fail,
+		set
+	]);
+	const create = useCallback(async (input) => {
+		if (!organizationId) return;
+		const chat = await attempt(client.chats.create(organizationId, input), fail);
+		if (chat && !chat.temporary && current.current === scope) set((items) => [chat, ...(items ?? []).filter((item) => item.id !== chat.id)]);
+		return chat;
+	}, [
+		client,
+		scope,
+		organizationId,
+		fail,
+		set
+	]);
+	const update = useCallback(async (chatId, patch) => {
+		const chat = await attempt(client.chats.update(chatId, patch), fail);
+		if (chat && current.current === scope) set((items) => items?.map((item) => item.id === chat.id ? chat : item));
+		return chat;
+	}, [
+		client,
+		scope,
+		fail,
+		set
+	]);
+	const remove = useCallback(async (chatId) => {
+		if (await attempt(client.chats.remove(chatId), fail) && current.current === scope) set((items) => items?.filter((item) => item.id !== chatId));
+	}, [
+		client,
+		scope,
+		fail,
+		set
+	]);
+	useEffect(() => {
+		current.current = scope;
+		ticket.current += 1;
+		pages.current = 1;
+		loadWindow();
+	}, [scope, loadWindow]);
+	useEffect(() => {
+		if (userId === null || !prefix) return;
+		const reload = () => void loadWindow();
+		return watchTopic(supabase, aiChatListTopic(userId, prefix), {
+			onMessage: reload,
+			onRejoin: reload,
+			onStatus: setStatus
+		});
+	}, [
+		supabase,
+		prefix,
+		userId,
+		loadWindow
+	]);
+	return {
+		items: state.data,
+		hasMore: next !== void 0,
+		status,
+		error: state.error,
+		loadMore,
+		refresh: loadWindow,
+		create,
+		update,
+		remove
+	};
+}
+/**
+* One chat's active branch, loaded again when a message is saved or the
+* branch changes, in this tab or another.
+*
+* ```tsx
+* const { path, step } = useAiChatTree(chatId);
+* ```
+*/
+function useAiChatTree(chatId, options = {}) {
+	const supabase = useSupabase();
+	const client = useAiChatClient(options.schema);
+	const state = useResultState();
+	const [status, setStatus] = useState("closed");
+	const prefix = options.topic === void 0 ? "ai-chat" : options.topic;
+	const { apply, fail, reset } = state;
+	const path = state.data;
+	const scope = useMemo(() => ({
+		client,
+		chatId
+	}), [client, chatId]);
+	const [shown, setShown] = useState(scope);
+	if (shown !== scope) {
+		setShown(scope);
+		reset();
+	}
+	const current = useRef(scope);
+	const ticket = useRef(0);
+	const loadPath = useCallback(async (leafId) => {
+		const id = scope.chatId;
+		if (!id || current.current !== scope) return;
+		const run = ++ticket.current;
+		const result = await scope.client.messages.path(id, leafId === void 0 ? void 0 : { leafId });
+		if (run === ticket.current) apply(result);
+	}, [scope, apply]);
+	const refresh = useCallback(() => loadPath(), [loadPath]);
+	const switchBranch = useCallback(async (messageId) => {
+		const id = scope.chatId;
+		if (!id || current.current !== scope) return;
+		const result = await scope.client.messages.switchBranch(id, messageId);
+		if (current.current !== scope) return;
+		if (result.ok) await loadPath(result.data);
+		else fail(result.error);
+	}, [
+		scope,
+		loadPath,
+		fail
+	]);
+	const step = useCallback(async (messageId, offset) => {
+		const id = scope.chatId;
+		if (!id || current.current !== scope) return;
+		const result = await scope.client.messages.siblings(id, messageId);
+		if (current.current !== scope) return;
+		if (!result.ok) {
+			fail(result.error);
+			return;
+		}
+		const siblings = result.data;
+		const index = siblings.findIndex((item) => item.id === messageId);
+		const target = siblings[index + offset];
+		if (index >= 0 && target) await switchBranch(target.id);
+	}, [
+		scope,
+		fail,
+		switchBranch
+	]);
+	useEffect(() => {
+		current.current = scope;
+		ticket.current += 1;
+		loadPath();
+	}, [scope, loadPath]);
+	useEffect(() => {
+		if (!chatId || !prefix) return;
+		const reload = () => void loadPath();
+		return watchTopic(supabase, aiChatTopic(chatId, prefix), {
+			onMessage: (event) => {
+				if (event === "message.saved" || event === "leaf.changed") reload();
+			},
+			onRejoin: reload,
+			onStatus: setStatus
+		});
+	}, [
+		supabase,
+		prefix,
+		chatId,
+		loadPath
+	]);
+	return {
+		path,
+		status,
+		error: state.error,
+		refresh,
+		switchBranch,
+		step
+	};
+}
+/** The models the tenant's plans allow, for a model picker. */
+function useAiModels(organizationId, options = {}) {
+	const client = useAiChatClient(options.schema);
+	const state = useResultState();
+	const tenant = organizationId ?? null;
+	const { apply } = state;
+	const refresh = useCallback(async () => {
+		apply(await client.models.allowed(tenant));
+	}, [
+		client,
+		tenant,
+		apply
+	]);
+	useEffect(() => {
+		let active = true;
+		client.models.allowed(tenant).then((result) => {
+			if (active) apply(result);
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		client,
+		tenant,
+		apply
+	]);
+	return {
+		models: state.data,
+		error: state.error,
+		refresh
+	};
+}
+/** Share links for one chat the user owns. */
+function useAiShare(chatId, options = {}) {
+	const client = useAiChatClient(options.schema);
+	const state = useResultState();
+	const { apply, fail } = state;
+	const reload = useCallback(async () => {
+		if (chatId) apply(await client.shares.list(chatId));
+	}, [
+		client,
+		chatId,
+		apply
+	]);
+	const create = useCallback(async (leafId) => {
+		if (!chatId) return;
+		const link = await attempt(client.shares.create(chatId, leafId), fail);
+		if (link) await reload();
+		return link;
+	}, [
+		client,
+		chatId,
+		fail,
+		reload
+	]);
+	const revoke = useCallback(async (shareId) => {
+		if (await attempt(client.shares.revoke(shareId), fail)) await reload();
+	}, [
+		client,
+		fail,
+		reload
+	]);
+	useEffect(() => {
+		if (!chatId) return;
+		let active = true;
+		client.shares.list(chatId).then((result) => {
+			if (active) apply(result);
+		});
+		return () => {
+			active = false;
+		};
+	}, [
+		client,
+		chatId,
+		apply
+	]);
+	return {
+		shares: state.data,
+		error: state.error,
+		create,
+		revoke
+	};
+}
+//#endregion
+export { useAiChatTree, useAiChats, useAiModels, useAiShare };

package/dist/blocks/ai-chat/react/server.d.ts

@@ -0,0 +1,16 @@
+import { AiChatTreeState, AiChatsState, AiModelsState, AiShareState, UseAiChatTreeOptions, UseAiChatsOptions } from "./index.js";
+//#region src/blocks/ai-chat/react/server.d.ts
+/** The `react-server` build of `useAiChats`: call `aiChat.chats.list()` instead. */
+export declare const useAiChats: (options?: UseAiChatsOptions) => AiChatsState;
+/** The `react-server` build of `useAiChatTree`: call `aiChat.messages.path()` instead. */
+export declare const useAiChatTree: (chatId: string | null | undefined, options?: UseAiChatTreeOptions) => AiChatTreeState;
+/** The `react-server` build of `useAiModels`: call `aiChat.models.allowed()` instead. */
+export declare const useAiModels: (organizationId?: string | null, options?: {
+  readonly schema?: string;
+}) => AiModelsState;
+/** The `react-server` build of `useAiShare`: call `aiChat.shares.list()` instead. */
+export declare const useAiShare: (chatId: string | null | undefined, options?: {
+  readonly schema?: string;
+}) => AiShareState;
+//#endregion
+export type { AiChatTreeState, AiChatsState, AiModelsState, AiShareState, UseAiChatTreeOptions, UseAiChatsOptions };

package/dist/blocks/ai-chat/react/server.js

@@ -0,0 +1,14 @@
+//#region src/blocks/ai-chat/react/server.ts
+const clientOnly = (hook, instead) => {
+	throw new Error(`better-supabase: ${hook}() runs in Client Components only. In Server Components call \`${instead}\` instead.`);
+};
+/** The `react-server` build of `useAiChats`: call `aiChat.chats.list()` instead. */
+const useAiChats = () => clientOnly("useAiChats", "aiChat.chats.list()");
+/** The `react-server` build of `useAiChatTree`: call `aiChat.messages.path()` instead. */
+const useAiChatTree = () => clientOnly("useAiChatTree", "aiChat.messages.path()");
+/** The `react-server` build of `useAiModels`: call `aiChat.models.allowed()` instead. */
+const useAiModels = () => clientOnly("useAiModels", "aiChat.models.allowed()");
+/** The `react-server` build of `useAiShare`: call `aiChat.shares.list()` instead. */
+const useAiShare = () => clientOnly("useAiShare", "aiChat.shares.list()");
+//#endregion
+export { useAiChatTree, useAiChats, useAiModels, useAiShare };

package/dist/blocks/ai-files/index.d.ts

@@ -0,0 +1,14 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { _ as NewAiFile, a as AiDocumentWithContent, c as AiFileSource, d as AiFileUpload, f as AiFiles, g as NewAiDocument, h as AiSuggestion, i as AiDocumentVersion, l as AiFileStatus, m as AiProviderFile, n as AiDocumentEdit, o as AiFile, p as AiFilesOptions, r as AiDocumentKind, s as AiFileBucket, t as AiDocument, u as AiFileStorage, v as StoredAiFile } from "../../types-C05bxW-W.js";
+//#region src/blocks/ai-files/ai-files.d.ts
+/** The URL a message stores for a file: `supabase-storage://{bucket}/{path}`. */
+export declare function aiFileUrl(file: Pick<AiFile, "bucket" | "path">): string;
+/** The bucket and path of a `supabase-storage://` URL, or `undefined`. */
+export declare function parseAiFileUrl(url: string | URL): {
+  readonly bucket: string;
+  readonly path: string;
+} | undefined;
+/** Files and documents for AI chats, as the caller and as the service role. */
+export declare function createAiFiles(options: AiFilesOptions): AiFiles;
+//#endregion
+export { type AiDocument, type AiDocumentEdit, type AiDocumentKind, type AiDocumentVersion, type AiDocumentWithContent, type AiFile, type AiFileBucket, type AiFileSource, type AiFileStatus, type AiFileStorage, type AiFileUpload, type AiFiles, type AiFilesOptions, type AiProviderFile, type AiSuggestion, type BlockTransport, type NewAiDocument, type NewAiFile, type StoredAiFile, rpcTransport, sqlTransport };

package/dist/blocks/ai-files/index.js

@@ -0,0 +1,3 @@
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { n as createAiFiles, r as parseAiFileUrl, t as aiFileUrl } from "../../ai-files-CSPNswUY.js";
+export { aiFileUrl, createAiFiles, parseAiFileUrl, rpcTransport, sqlTransport };

package/dist/blocks/ai-providers/index.d.ts

@@ -0,0 +1,7 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { a as AiBatchItemStatus, c as AiProviderKey, d as AiProvidersOptions, f as NewAiBatch, i as AiBatchItemInput, l as AiProviderKeyInput, n as AiBatchCounts, o as AiBatchPatch, p as ResolvedProviderKey, r as AiBatchItem, s as AiBatchStatus, t as AiBatch, u as AiProviders } from "../../types-TaiEeBGA.js";
+//#region src/blocks/ai-providers/ai-providers.d.ts
+/** Per-tenant provider keys and provider batch jobs. */
+export declare function createAiProviders(options: AiProvidersOptions): AiProviders;
+//#endregion
+export { type AiBatch, type AiBatchCounts, type AiBatchItem, type AiBatchItemInput, type AiBatchItemStatus, type AiBatchPatch, type AiBatchStatus, type AiProviderKey, type AiProviderKeyInput, type AiProviders, type AiProvidersOptions, type BlockTransport, type NewAiBatch, type ResolvedProviderKey, rpcTransport, sqlTransport };

package/dist/blocks/ai-providers/index.js

@@ -0,0 +1,211 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { n as credentialRefInTenant, r as foreignCredentialRef } from "../../provider-Di3sRutW.js";
+import { n as rpcTransport, r as sqlTransport } from "../../block-transport-BLr-ZgLc.js";
+import { O as textOf, a as credentialRefOf, b as recordOrEmpty, d as isRecord, g as pageOf, h as optionalText, i as blockCall, k as toInstant, m as optionalInstant, n as applyTemporal, p as oneOf, u as instantArg, x as recordsOf, y as recordOf } from "../../block-helpers-DWHxHsEQ.js";
+import { n as revokeIfConfigured } from "../../compose-BIBNgAnq.js";
+//#region src/blocks/ai-providers/rows.ts
+const BATCH_STATUSES = [
+	"pending",
+	"completed",
+	"failed",
+	"cancelled"
+];
+const ITEM_STATUSES = [
+	"succeeded",
+	"failed",
+	"cancelled",
+	"expired"
+];
+const instant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
+const numberOf = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+function refOf(value) {
+	const ref = credentialRefOf(value);
+	if (ref === void 0) throw new TypeError("ai_provider_keys returned a key without a ref");
+	return ref;
+}
+function keyOf(value) {
+	const row = recordOf(value, "ai_provider_keys");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		provider: textOf(row["provider"]),
+		name: textOf(row["name"]),
+		credentialRef: refOf(row["credential_ref"]),
+		settings: recordOrEmpty(row["settings"]),
+		enabled: row["enabled"] !== false,
+		createdBy: optionalText(row["created_by"]),
+		createdAt: instant(row["created_at"]),
+		updatedAt: instant(row["updated_at"])
+	};
+}
+function countsOf(value) {
+	const row = recordOrEmpty(value);
+	const out = {};
+	for (const key of [
+		"total",
+		"pending",
+		"completed",
+		"failed"
+	]) if (typeof row[key] === "number") out[key] = row[key];
+	return out;
+}
+function batchOf(value) {
+	const row = recordOf(value, "ai_batches");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		userId: optionalText(row["user_id"]),
+		provider: textOf(row["provider"]),
+		reference: recordOrEmpty(row["reference"]),
+		status: oneOf(row["status"], BATCH_STATUSES, "failed"),
+		rawStatus: optionalText(row["raw_status"]),
+		itemCount: numberOf(row["item_count"]),
+		counts: countsOf(row["counts"]),
+		error: optionalText(row["error"]),
+		metadata: recordOrEmpty(row["metadata"]),
+		resultsSaved: row["results_saved"] === true,
+		polls: numberOf(row["polls"]),
+		nextPollAt: optionalInstant(row["next_poll_at"]),
+		expiresAt: optionalInstant(row["expires_at"]),
+		completedAt: optionalInstant(row["completed_at"]),
+		createdAt: instant(row["created_at"]),
+		updatedAt: instant(row["updated_at"])
+	};
+}
+function itemOf(value) {
+	const row = recordOf(value, "ai_batch_items");
+	return {
+		batchId: textOf(row["batch_id"]),
+		requestId: textOf(row["request_id"]),
+		organizationId: textOf(row["organization_id"]),
+		status: oneOf(row["status"], ITEM_STATUSES, "failed"),
+		output: row["output"] ?? void 0,
+		usage: row["usage"] ?? void 0,
+		error: optionalText(row["error"]),
+		createdAt: instant(row["created_at"])
+	};
+}
+//#endregion
+//#region src/blocks/ai-providers/ai-providers.ts
+const sameRef = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/** Per-tenant provider keys and provider batch jobs. */
+function createAiProviders(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const credentials = options.credentials;
+	const revoke = (ref, organizationId) => revokeIfConfigured(credentials, ref, {
+		subject: { type: "app" },
+		tenant: organizationId
+	});
+	const revokeAll = (keys) => AsyncResult.from(async () => {
+		for (const key of keys) {
+			const revoked = await revoke(key.credentialRef, key.organizationId);
+			if (!revoked.ok) return revoked;
+		}
+		return ok(keys.length);
+	});
+	return {
+		keys: {
+			list: (organizationId) => call("list_ai_provider_keys", { tenant: organizationId }, (value) => recordsOf(value, "list_ai_provider_keys").map(keyOf)),
+			save: (organizationId, key) => call("save_ai_provider_key", {
+				tenant: organizationId,
+				provider: key.provider,
+				credential_ref: key.credentialRef,
+				name: key.name,
+				settings: key.settings,
+				enabled: key.enabled
+			}, (value) => recordOf(value, "save_ai_provider_key")).andThen((saved) => {
+				const stored = keyOf(saved["key"]);
+				const replaced = saved["replaced"];
+				return isRecord(replaced) && !sameRef(refOf(replaced), stored.credentialRef) ? revoke(refOf(replaced), stored.organizationId).map(() => stored) : AsyncResult.ok(stored);
+			}),
+			remove: (keyId) => call("delete_ai_provider_key", { id: keyId }, (value) => value === null || value === void 0 ? void 0 : keyOf(value)).andThen((key) => key === void 0 ? AsyncResult.ok(false) : revoke(key.credentialRef, key.organizationId).map(() => true)),
+			removeAll: (organizationId) => service("delete_ai_provider_keys", { tenant: organizationId }, (value) => recordsOf(value, "delete_ai_provider_keys").map(keyOf)).andThen(revokeAll),
+			resolve: (organizationId, resolveOptions = {}) => service("ai_provider_keys_for", {
+				tenant: organizationId,
+				providers: resolveOptions.providers
+			}, (value) => recordsOf(value, "ai_provider_keys_for").map(keyOf)).andThen((keys) => AsyncResult.from(async () => {
+				if (keys.length === 0) return ok([]);
+				if (credentials === void 0) return err(dbError("invalid_input", "createAiProviders needs credentials to resolve provider keys", { hint: "AI_PROVIDER_KEY_UNRESOLVED" }));
+				if (keys.find((key) => !credentialRefInTenant(key.credentialRef, organizationId)) !== void 0) return err(foreignCredentialRef(organizationId));
+				const tokens = await Promise.all(keys.map((key) => credentials.getToken(key.credentialRef, {
+					subject: { type: "app" },
+					...resolveOptions.signal === void 0 ? {} : { signal: resolveOptions.signal }
+				})));
+				const resolved = [];
+				for (const [index, token] of tokens.entries()) {
+					if (!token.ok) return token;
+					const key = keys[index];
+					if (key === void 0) continue;
+					resolved.push({
+						provider: key.provider,
+						name: key.name,
+						token: token.data.token,
+						headers: token.data.headers,
+						settings: key.settings
+					});
+				}
+				return ok(resolved);
+			}))
+		},
+		batches: {
+			record: (organizationId, batch) => call("record_ai_batch", {
+				tenant: organizationId,
+				provider: batch.provider,
+				reference: batch.reference,
+				fields: {
+					...batch.userId === void 0 ? {} : { user_id: batch.userId },
+					...batch.itemCount === void 0 ? {} : { item_count: batch.itemCount },
+					...batch.metadata === void 0 ? {} : { metadata: batch.metadata },
+					...batch.status === void 0 ? {} : { status: batch.status },
+					...batch.rawStatus === void 0 ? {} : { raw_status: batch.rawStatus },
+					...batch.counts === void 0 ? {} : { counts: batch.counts },
+					...batch.expiresAt === void 0 ? {} : { expires_at: batch.expiresAt.toString() }
+				}
+			}, batchOf),
+			get: (batchId) => call("get_ai_batch", { id: batchId }, (value) => value === null || value === void 0 ? void 0 : batchOf(value)),
+			list: (organizationId, listOptions = {}) => call("list_ai_batches", {
+				tenant: organizationId,
+				status: listOptions.status,
+				max_rows: listOptions.limit
+			}, (value) => recordsOf(value, "list_ai_batches").map(batchOf)),
+			items: (batchId, itemOptions = {}) => call("list_ai_batch_items", {
+				id: batchId,
+				after: pageOf(itemOptions).cursor,
+				max_rows: itemOptions.limit
+			}, (value) => recordsOf(value, "list_ai_batch_items").map(itemOf)),
+			due: (dueOptions = {}) => service("due_ai_batches", {
+				batch: dueOptions.batch,
+				lease_seconds: dueOptions.leaseSeconds
+			}, (value) => recordsOf(value, "due_ai_batches").map(batchOf)),
+			update: (batchId, patch) => {
+				const fields = {};
+				if (patch.status !== void 0) fields["status"] = patch.status;
+				if (patch.rawStatus !== void 0) fields["raw_status"] = patch.rawStatus;
+				if (patch.counts !== void 0) fields["counts"] = patch.counts;
+				if (patch.error !== void 0) fields["error"] = patch.error;
+				if (patch.expiresAt !== void 0) fields["expires_at"] = patch.expiresAt.toString();
+				if (patch.resultsSaved !== void 0) fields["results_saved"] = patch.resultsSaved;
+				if (patch.nextPollAt !== void 0) fields["next_poll_at"] = instantArg(patch.nextPollAt);
+				return service("update_ai_batch", {
+					id: batchId,
+					fields
+				}, batchOf);
+			},
+			saveItems: (batchId, items) => service("save_ai_batch_items", {
+				id: batchId,
+				items: { items: items.map((item) => ({
+					request_id: item.requestId,
+					status: item.status,
+					output: item.output ?? null,
+					usage: item.usage ?? null,
+					error: item.error ?? null
+				})) }
+			}, (value) => Number(value ?? 0))
+		}
+	};
+}
+//#endregion
+export { createAiProviders, rpcTransport, sqlTransport };

package/dist/blocks/ai-tasks/index.d.ts

@@ -0,0 +1,3 @@
+import { i as sqlTransport, r as rpcTransport, t as BlockTransport } from "../../block-transport-DvaoPuZ9.js";
+import { a as AiTaskRunStatus, c as AiTasksOptions, i as AiTaskRun, l as NewAiTask, n as AiTaskFields, o as AiTaskRunner, r as AiTaskOutcome, s as AiTasks, t as AiTask, u as createAiTasks } from "../../ai-tasks-Cd1HMFvB.js";
+export { type AiTask, type AiTaskFields, type AiTaskOutcome, type AiTaskRun, type AiTaskRunStatus, type AiTaskRunner, type AiTasks, type AiTasksOptions, type BlockTransport, type NewAiTask, createAiTasks, rpcTransport, sqlTransport };