better-supabase 0.5.0 → 0.6.0

package/dist/ai-files-CSPNswUY.js

@@ -0,0 +1,319 @@
+import { n as dbError } from "./errors-B11Duf73.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-DzUbqgdW.js";
+import { O as textOf, d as isRecord, f as notFoundError, 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 { t as fromStorageError } from "./errors-DLjJHPLK.js";
+//#region src/blocks/ai-files/rows.ts
+const FILE_STATUSES = [
+	"pending",
+	"ready",
+	"failed"
+];
+const FILE_SOURCES = [
+	"upload",
+	"generated",
+	"provider"
+];
+const DOCUMENT_KINDS = [
+	"text",
+	"code",
+	"sheet",
+	"image"
+];
+const instant = (value) => value instanceof Date ? toInstant(value) : toInstant(textOf(value));
+function fileOf(value) {
+	const row = recordOf(value, "ai_files");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		ownerId: textOf(row["owner_id"]),
+		chatId: optionalText(row["chat_id"]),
+		projectId: optionalText(row["project_id"]),
+		bucket: textOf(row["bucket"]),
+		path: textOf(row["path"]),
+		mediaType: textOf(row["media_type"]),
+		filename: textOf(row["filename"]),
+		size: Number(row["byte_size"] ?? 0),
+		sha256: optionalText(row["sha256"]),
+		status: oneOf(textOf(row["status"]), FILE_STATUSES, "failed"),
+		source: oneOf(textOf(row["source"]), FILE_SOURCES, "upload"),
+		createdAt: instant(row["created_at"]),
+		uploadedAt: optionalInstant(row["uploaded_at"]),
+		expiresAt: optionalInstant(row["expires_at"])
+	};
+}
+function providerFileOf(value) {
+	const row = recordOf(value, "ai_provider_files");
+	return {
+		fileId: textOf(row["file_id"]),
+		provider: textOf(row["provider"]),
+		reference: textOf(row["reference"]),
+		expiresAt: optionalInstant(row["expires_at"])
+	};
+}
+function documentOf(value) {
+	const row = recordOf(value, "ai_documents");
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organization_id"]),
+		ownerId: textOf(row["owner_id"]),
+		chatId: optionalText(row["chat_id"]),
+		kind: oneOf(textOf(row["kind"]), DOCUMENT_KINDS, "text"),
+		title: textOf(row["title"]),
+		version: Number(row["current_version"] ?? 1),
+		createdAt: instant(row["created_at"]),
+		updatedAt: instant(row["updated_at"])
+	};
+}
+function versionOf(value) {
+	const row = recordOf(value, "ai_document_versions");
+	return {
+		documentId: textOf(row["document_id"]),
+		version: Number(row["version"]),
+		content: optionalText(row["content"]),
+		storagePath: optionalText(row["storage_path"]),
+		messageId: optionalText(row["created_by_message_id"]),
+		createdBy: optionalText(row["created_by"]),
+		createdAt: instant(row["created_at"])
+	};
+}
+function suggestionOf(value) {
+	const row = recordOf(value, "ai_suggestions");
+	const accepted = row["accepted"];
+	return {
+		id: textOf(row["id"]),
+		documentId: textOf(row["document_id"]),
+		version: Number(row["version"]),
+		originalText: textOf(row["original_text"]),
+		suggestedText: textOf(row["suggested_text"]),
+		description: optionalText(row["description"]),
+		createdBy: optionalText(row["created_by"]),
+		createdAt: instant(row["created_at"]),
+		resolvedAt: optionalInstant(row["resolved_at"]),
+		accepted: typeof accepted === "boolean" ? accepted : void 0
+	};
+}
+//#endregion
+//#region src/blocks/ai-files/ai-files.ts
+const SCHEME = "supabase-storage:";
+/** The URL a message stores for a file: `supabase-storage://{bucket}/{path}`. */
+function aiFileUrl(file) {
+	return `${SCHEME}//${file.bucket}/${file.path.split("/").map(encodeURIComponent).join("/")}`;
+}
+/** The bucket and path of a `supabase-storage://` URL, or `undefined`. */
+function parseAiFileUrl(url) {
+	let parsed;
+	try {
+		parsed = typeof url === "string" ? new URL(url) : url;
+	} catch {
+		return;
+	}
+	if (parsed.protocol !== SCHEME || parsed.hostname === "") return void 0;
+	const segments = parsed.pathname.split("/").filter((part) => part !== "");
+	if (segments.length === 0) return void 0;
+	try {
+		return {
+			bucket: decodeURIComponent(parsed.hostname),
+			path: segments.map(decodeURIComponent).join("/")
+		};
+	} catch {
+		return;
+	}
+}
+const notFound = () => notFoundError("No AI file you can see has this id", "AI_FILE_NOT_FOUND");
+const notReady = () => dbError("invalid_request", "The file is not uploaded yet", { hint: "AI_FILE_NOT_READY" });
+function stored(reply) {
+	return AsyncResult.from(async () => {
+		try {
+			const { data, error } = await reply;
+			if (error) return err(fromStorageError(error, "storage.objects"));
+			if (data === null || data === void 0) return err(dbError("network", "Storage returned no data"));
+			return ok(data);
+		} catch (cause) {
+			return err(fromStorageError(cause, "storage.objects"));
+		}
+	});
+}
+/** 50 MB, the module's default `maxSize`. */
+const DEFAULT_MAX_BYTES = 52428800;
+/** Files and documents for AI chats, as the caller and as the service role. */
+function createAiFiles(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const service = blockCall(options.service ?? options.transport, options.schema, options.mappers);
+	const ttl = options.downloadTtl ?? 300;
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+	const serviceStorage = options.serviceStorage ?? options.storage;
+	const found = (value) => isRecord(value) ? AsyncResult.ok(fileOf(value)) : AsyncResult.err(notFound());
+	const get = (fileId) => call("get_ai_file", { file_id: fileId }, (value) => value).andThen(found);
+	const fileFrom = (file) => typeof file === "string" ? get(file) : AsyncResult.ok(file);
+	const resolve = (url) => {
+		const target = parseAiFileUrl(url);
+		if (!target) return AsyncResult.err(dbError("invalid_request", "Not a supabase-storage:// URL", { hint: "AI_FILE_URL" }));
+		return call("get_ai_file_by_path", {
+			bucket: target.bucket,
+			path: target.path
+		}, (value) => value).andThen(found);
+	};
+	const sign = (file) => fileFrom(file).andThen((row) => row.status === "ready" ? stored(options.storage.from(row.bucket).createSignedUrl(row.path, ttl)).map((url) => url.signedUrl) : Promise.resolve(err(notReady())));
+	return {
+		files: {
+			upload: (organizationId, file) => call("reserve_ai_file", {
+				tenant: organizationId,
+				filename: file.filename,
+				media_type: file.mediaType,
+				byte_size: file.size,
+				chat_id: file.chatId,
+				project_id: file.projectId
+			}, fileOf).andThen((created) => stored(options.storage.from(created.bucket).createSignedUploadUrl(created.path)).map((url) => ({
+				file: created,
+				signedUrl: url.signedUrl,
+				token: url.token
+			}))),
+			confirm: (fileId, sha256) => call("confirm_ai_file", {
+				file_id: fileId,
+				sha256
+			}, fileOf),
+			get,
+			resolve,
+			list: (chatId) => call("list_ai_files", { chat_id: chatId }, (value) => recordsOf(value, "list_ai_files").map(fileOf)),
+			sign,
+			read: (file) => fileFrom(file).andThen(async (row) => {
+				if (row.status !== "ready") return err(notReady());
+				if (row.size > maxBytes) return err(dbError("invalid_request", "The file is larger than maxBytes", { hint: "AI_FILE_TOO_LARGE" }));
+				const blob = await stored(options.storage.from(row.bucket).download(row.path));
+				if (!blob.ok) return err(blob.error);
+				if (blob.data.size > maxBytes) return err(dbError("invalid_request", "The file is larger than maxBytes", { hint: "AI_FILE_TOO_LARGE" }));
+				return ok({
+					file: row,
+					data: new Uint8Array(await blob.data.arrayBuffer())
+				});
+			}),
+			remove: (fileId) => call("delete_ai_file", { file_id: fileId }, (value) => value).andThen(async (value) => {
+				if (!isRecord(value)) return ok(false);
+				const removed = await stored(options.storage.from(textOf(value["bucket"])).remove([textOf(value["path"])]));
+				return removed.ok ? ok(true) : err(removed.error);
+			}),
+			store: (organizationId, file) => service("store_ai_file", {
+				tenant: organizationId,
+				owner: file.ownerId,
+				filename: file.filename,
+				media_type: file.mediaType,
+				byte_size: file.data instanceof Uint8Array ? file.data.byteLength : file.data.size,
+				chat_id: file.chatId,
+				source: file.source ?? "generated"
+			}, fileOf).andThen(async (created) => {
+				const target = serviceStorage.from(created.bucket);
+				if (!target.upload) return err(dbError("invalid_request", "The storage client has no upload", { hint: "AI_FILE_STORAGE_CLIENT" }));
+				const sent = await stored(target.upload(created.path, file.data, {
+					contentType: created.mediaType,
+					upsert: false
+				}));
+				if (sent.ok) return ok(created);
+				await service("delete_ai_file", { file_id: created.id }, () => true);
+				return err(sent.error);
+			}),
+			purge: (purgeOptions = {}) => service("purge_ai_files", {
+				older_than: purgeOptions.olderThan,
+				batch: purgeOptions.batch
+			}, (value) => recordsOf(value, "purge_ai_files")).andThen(async (removed) => {
+				const byBucket = /* @__PURE__ */ new Map();
+				for (const row of removed) {
+					const bucket = textOf(row["bucket"]);
+					const paths = byBucket.get(bucket) ?? [];
+					paths.push(textOf(row["path"]));
+					byBucket.set(bucket, paths);
+				}
+				for (const [bucket, paths] of byBucket) {
+					const result = await stored(serviceStorage.from(bucket).remove(paths));
+					if (!result.ok) return err(result.error);
+				}
+				return ok(removed.length);
+			})
+		},
+		providerFiles: {
+			get: (fileId, provider) => service("get_ai_provider_file", {
+				file_id: fileId,
+				provider
+			}, (value) => isRecord(value) ? providerFileOf(value) : void 0),
+			set: (fileId, provider, reference, expiresAt) => service("set_ai_provider_file", {
+				file_id: fileId,
+				provider,
+				reference,
+				expires_at: instantArg(expiresAt)
+			}, (value) => value === true),
+			expiring: (horizon, batch) => service("expiring_ai_provider_files", {
+				horizon,
+				batch
+			}, (value) => recordsOf(value, "expiring_ai_provider_files").map(providerFileOf))
+		},
+		documents: {
+			create: (organizationId, document) => (document.ownerId === void 0 ? call : service)("create_ai_document", {
+				tenant: organizationId,
+				kind: document.kind,
+				title: document.title,
+				content: document.content,
+				chat_id: document.chatId,
+				message_id: document.messageId,
+				owner: document.ownerId,
+				storage_path: document.storagePath
+			}, documentOf),
+			get: (documentId) => call("get_ai_document", { document_id: documentId }, (value) => value).andThen((value) => Promise.resolve(isRecord(value) ? ok({
+				...documentOf(value),
+				content: optionalText(value["content"]),
+				storagePath: optionalText(value["storage_path"])
+			}) : err(dbError("not_found", "No document you can see has this id", { hint: "AI_DOCUMENT_NOT_FOUND" })))),
+			update: (documentId, edit) => call("update_ai_document", {
+				document_id: documentId,
+				content: edit.content,
+				title: edit.title,
+				message_id: edit.messageId,
+				expected_version: edit.expectedVersion,
+				storage_path: edit.storagePath
+			}, documentOf),
+			rollback: (documentId, version) => call("rollback_ai_document", {
+				document_id: documentId,
+				version
+			}, documentOf),
+			versions: (documentId) => call("list_ai_document_versions", { document_id: documentId }, (value) => recordsOf(value, "list_ai_document_versions").map(versionOf)),
+			remove: (documentId) => call("delete_ai_document", { document_id: documentId }, (value) => value === true),
+			suggest: (documentId, suggestion) => call("suggest_ai_document_edit", {
+				document_id: documentId,
+				original_text: suggestion.originalText,
+				suggested_text: suggestion.suggestedText,
+				description: suggestion.description
+			}, suggestionOf),
+			suggestions: (documentId, query = {}) => call("list_ai_suggestions", {
+				document_id: documentId,
+				open_only: query.openOnly ?? true
+			}, (value) => recordsOf(value, "list_ai_suggestions").map(suggestionOf)),
+			resolve: (suggestionId, accepted) => call("resolve_ai_suggestion", {
+				suggestion_id: suggestionId,
+				accepted
+			}, suggestionOf)
+		},
+		sign: async (messages) => {
+			const signed = /* @__PURE__ */ new Map();
+			for (const message of messages) for (const part of message.parts) {
+				if (part.type !== "file" || signed.has(part.url)) continue;
+				if (!parseAiFileUrl(part.url)) continue;
+				const result = await resolve(part.url).andThen(sign);
+				signed.set(part.url, result.ok ? result.data : void 0);
+			}
+			if (signed.size === 0) return messages;
+			const swap = (part) => {
+				if (part.type !== "file") return part;
+				const url = signed.get(part.url);
+				return url === void 0 ? part : {
+					...part,
+					url
+				};
+			};
+			return messages.map((message) => ({
+				...message,
+				parts: message.parts.map(swap)
+			}));
+		}
+	};
+}
+//#endregion
+export { createAiFiles as n, parseAiFileUrl as r, aiFileUrl as t };

package/dist/ai-sdk/agents/index.d.ts

@@ -0,0 +1,74 @@
+import { r as Knowledge, u as KnowledgeSearchOptions } from "../../knowledge-BXBbT0Tr.js";
+import { t as Agent } from "../../agents-CVHGd7It.js";
+import { P as AiToolPolicy, _ as AiModerationAction, b as AiModerationStage, i as AiChat } from "../../ai-chat-7amvXjmQ.js";
+import { r as SearchToolOptions } from "../../embeddings-C9KGQnXt.js";
+import { LanguageModel, LanguageModelMiddleware, StopCondition, ToolLoopAgent, ToolLoopAgentSettings, ToolSet } from "ai";
+//#region src/ai-sdk/agents/agents.d.ts
+/**
+ * The tools an agent may call: the ones it lists (every tool when it lists
+ * none), without the tenant's `deny` tools.
+ */
+export declare function agentTools(agent: Pick<Agent, "tools">, available: ToolSet, policies?: Readonly<Record<string, AiToolPolicy>>): ToolSet;
+/** The `toolApproval` setting that makes the tenant's `ask` tools wait for the user. */
+export declare function agentToolApproval(tools: ToolSet, policies?: Readonly<Record<string, AiToolPolicy>>): Record<string, "user-approval">;
+/** A `toolApproval` function, as `ToolLoopAgent` takes it. */
+type AgentToolApprovalFunction = Extract<NonNullable<ToolLoopAgentSettings<never, ToolSet>["toolApproval"]>, (options: never) => unknown>;
+/** The knowledge scopes an agent searches; `agent` without an id is its own. */
+export declare function agentScopes(agent: Pick<Agent, "id" | "knowledgeScopes">): NonNullable<KnowledgeSearchOptions["scopes"]>;
+interface AgentRuntimeOptions {
+  readonly agent: Agent;
+  /** The model for the agent's `model` id; the app picks one when it is unset. */
+  readonly model: (modelId: string | undefined) => LanguageModel;
+  /** Every tool the app offers; the agent gets the ones it may call. */
+  readonly tools?: ToolSet;
+  /** `approvals.policies(organizationId)` of the ai-chat block. */
+  readonly policies?: Readonly<Record<string, AiToolPolicy>>;
+  /** Adds a `search_knowledge` tool over the agent's knowledge scopes. */
+  readonly knowledge?: {
+    readonly knowledge: Knowledge;
+    readonly organizationId: string;
+    readonly options?: SearchToolOptions;
+  };
+  /** Text before the agent's own instructions, such as the app's rules. */
+  readonly instructions?: string;
+  /** Default 20 steps. */
+  readonly stopWhen?: StopCondition<ToolSet> | StopCondition<ToolSet>[];
+  /**
+   * The app's approval check for each tool call, such as an authorization
+   * check. It runs before the tenant's `policies`, and the stricter answer
+   * wins: `denied` over `user-approval` over `approved`. A throw denies.
+   */
+  readonly toolApproval?: AgentToolApprovalFunction;
+}
+/** A `ToolLoopAgent` from an agent row. */
+export declare function createAgentRuntime(options: AgentRuntimeOptions): ToolLoopAgent<never, ToolSet>;
+/** What a moderation check says about a text. */
+interface ModerationVerdict {
+  readonly action: AiModerationAction;
+  readonly category: string;
+  readonly score?: number;
+}
+interface ModerationMiddlewareOptions {
+  readonly chats: AiChat;
+  readonly organizationId: string;
+  readonly chatId?: string;
+  readonly userId?: string;
+  /** Checks the last user message (`input`) and the answer (`output`). */
+  readonly check: (text: string, stage: Extract<AiModerationStage, "input" | "output">) => Promise<ModerationVerdict | undefined>;
+}
+/** Thrown by the moderation middleware when a check blocks the input or output. */
+export declare class ModerationBlockedError extends Error {
+  readonly category: string;
+  readonly stage: AiModerationStage;
+  constructor(stage: AiModerationStage, category: string);
+}
+/**
+ * A language model middleware that checks the user's message before the
+ * model runs and the answer after it, records every verdict but `allow` in
+ * the ai-chat moderation log, and throws `ModerationBlockedError` on
+ * `block`. A streamed answer has reached the client when its check runs, so
+ * a blocked stream ends with an error part instead of the text vanishing.
+ */
+export declare function moderationMiddleware(options: ModerationMiddlewareOptions): LanguageModelMiddleware;
+//#endregion
+export type { Agent, AgentRuntimeOptions, AgentToolApprovalFunction, ModerationMiddlewareOptions, ModerationVerdict };

package/dist/ai-sdk/agents/index.js

@@ -0,0 +1,159 @@
+import { t as DbException } from "../../db-exception-CnWcYPxL.js";
+import { i as searchTool } from "../../embeddings-4ZvFzjsU.js";
+import { ToolLoopAgent, stepCountIs } from "ai";
+//#region src/ai-sdk/agents/agents.ts
+/**
+* The tools an agent may call: the ones it lists (every tool when it lists
+* none), without the tenant's `deny` tools.
+*/
+function agentTools(agent, available, policies = {}) {
+	const allowed = agent.tools.length === 0 ? void 0 : new Set(agent.tools);
+	const tools = {};
+	for (const [name, tool] of Object.entries(available)) {
+		if (allowed !== void 0 && !allowed.has(name)) continue;
+		if (policies[name] === "deny") continue;
+		tools[name] = tool;
+	}
+	return tools;
+}
+/** The `toolApproval` setting that makes the tenant's `ask` tools wait for the user. */
+function agentToolApproval(tools, policies = {}) {
+	const approval = {};
+	for (const name of Object.keys(tools)) if (policies[name] === "ask") approval[name] = "user-approval";
+	return approval;
+}
+const APPROVAL_RANK = {
+	"not-applicable": 0,
+	approved: 1,
+	"user-approval": 2,
+	denied: 3
+};
+const approvalType = (status) => status === void 0 ? "not-applicable" : typeof status === "string" ? status : status.type;
+/**
+* The app's `toolApproval` with the tenant's `ask` tools: the app decides
+* first, and the stricter of the two answers wins (`denied`, then
+* `user-approval`). A function that throws denies the call.
+*/
+function composedApproval(approve, tenant) {
+	return async (options) => {
+		let status;
+		try {
+			status = await approve(options);
+		} catch {
+			return {
+				type: "denied",
+				reason: "The tool approval check failed"
+			};
+		}
+		return tenant[options.toolCall.toolName] !== void 0 && APPROVAL_RANK[approvalType(status)] < APPROVAL_RANK["user-approval"] ? "user-approval" : status;
+	};
+}
+/** The knowledge scopes an agent searches; `agent` without an id is its own. */
+function agentScopes(agent) {
+	return agent.knowledgeScopes.map((scope) => scope.scope === "agent" && scope.id === void 0 ? {
+		scope: "agent",
+		id: agent.id
+	} : scope);
+}
+/** A `ToolLoopAgent` from an agent row. */
+function createAgentRuntime(options) {
+	const { agent } = options;
+	const tools = agentTools(agent, options.tools ?? {}, options.policies);
+	if (options.knowledge !== void 0 && agent.knowledgeScopes.length > 0) {
+		const { knowledge, organizationId, options: search = {} } = options.knowledge;
+		tools["search_knowledge"] = searchTool(knowledge, organizationId, {
+			...search,
+			scopes: agentScopes(agent)
+		});
+	}
+	const instructions = [options.instructions, agent.instructions].filter((text) => text !== void 0 && text !== "").join("\n\n");
+	return new ToolLoopAgent({
+		id: agent.id,
+		model: options.model(agent.model),
+		tools,
+		toolApproval: options.toolApproval === void 0 ? agentToolApproval(tools, options.policies) : composedApproval(options.toolApproval, agentToolApproval(tools, options.policies)),
+		...instructions === "" ? {} : { instructions },
+		stopWhen: options.stopWhen ?? stepCountIs(20)
+	});
+}
+/** Thrown by the moderation middleware when a check blocks the input or output. */
+var ModerationBlockedError = class extends Error {
+	category;
+	stage;
+	constructor(stage, category) {
+		super(`The ${stage} was blocked by moderation (${category})`);
+		this.name = "ModerationBlockedError";
+		this.stage = stage;
+		this.category = category;
+	}
+};
+function lastUserText(prompt) {
+	for (let index = prompt.length - 1; index >= 0; index -= 1) {
+		const message = prompt[index];
+		if (message?.role !== "user") continue;
+		return message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n");
+	}
+	return "";
+}
+/**
+* A language model middleware that checks the user's message before the
+* model runs and the answer after it, records every verdict but `allow` in
+* the ai-chat moderation log, and throws `ModerationBlockedError` on
+* `block`. A streamed answer has reached the client when its check runs, so
+* a blocked stream ends with an error part instead of the text vanishing.
+*/
+function moderationMiddleware(options) {
+	const judge = async (text, stage) => {
+		if (text.trim() === "") return void 0;
+		const verdict = await options.check(text, stage);
+		if (verdict === void 0 || verdict.action === "allow") return verdict;
+		const recorded = await options.chats.moderation.record({
+			organizationId: options.organizationId,
+			stage,
+			action: verdict.action,
+			category: verdict.category,
+			...options.chatId === void 0 ? {} : { chatId: options.chatId },
+			...options.userId === void 0 ? {} : { userId: options.userId },
+			...verdict.score === void 0 ? {} : { score: verdict.score }
+		});
+		if (!recorded.ok) throw new DbException(recorded.error);
+		return verdict;
+	};
+	return {
+		transformParams: async ({ params }) => {
+			const verdict = await judge(lastUserText(params.prompt), "input");
+			if (verdict?.action === "block") throw new ModerationBlockedError("input", verdict.category);
+			return params;
+		},
+		wrapGenerate: async ({ doGenerate }) => {
+			const result = await doGenerate();
+			const text = result.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+			const verdict = await judge(text, "output");
+			if (verdict?.action === "block") throw new ModerationBlockedError("output", verdict.category);
+			return result;
+		},
+		wrapStream: async ({ doStream }) => {
+			const result = await doStream();
+			let text = "";
+			const checked = result.stream.pipeThrough(new TransformStream({
+				transform(part, controller) {
+					if (part.type === "text-delta") text += part.delta;
+					controller.enqueue(part);
+				},
+				async flush(controller) {
+					const verdict = await judge(text, "output");
+					if (verdict?.action === "block") controller.enqueue({
+						type: "error",
+						error: new ModerationBlockedError("output", verdict.category)
+					});
+				}
+			}));
+			return {
+				...result,
+				stream: checked
+			};
+		}
+	};
+}
+//#endregion
+export { ModerationBlockedError, agentScopes, agentToolApproval, agentTools, createAgentRuntime, moderationMiddleware };

package/dist/ai-sdk/batches/index.d.ts

@@ -0,0 +1,74 @@
+import { t as AsyncResult } from "../../result-D7y2fT87.js";
+import { i as CursorPageOptions } from "../../block-helpers-CKtbFcRv.js";
+import { m as JobHandler } from "../../queue-CLJurhdy.js";
+import { i as AiBatchItemInput, r as AiBatchItem, t as AiBatch, u as AiProviders } from "../../types-TaiEeBGA.js";
+import { Experimental_BatchItemResult, Experimental_BatchProvider, Experimental_BatchReference, Experimental_BatchStatus, Experimental_StartBatchOptions, Experimental_StartBatchResult } from "ai";
+//#region src/ai-sdk/batches/batches.d.ts
+/** The AI SDK batch calls, replaceable in tests. */
+interface BatchApi {
+  start(options: Experimental_StartBatchOptions): PromiseLike<Experimental_StartBatchResult>;
+  status(options: {
+    provider?: Experimental_BatchProvider;
+    batch: Experimental_BatchReference;
+  }): PromiseLike<Experimental_BatchStatus>;
+  results(options: {
+    provider?: Experimental_BatchProvider;
+    batch: Experimental_BatchReference;
+  }): AsyncIterable<Experimental_BatchItemResult>;
+  cancel(options: {
+    provider?: Experimental_BatchProvider;
+    batch: Experimental_BatchReference;
+  }): PromiseLike<unknown>;
+}
+interface AiBatchesOptions {
+  /** The providers block: a user transport for `start`, a service one for polling. */
+  readonly providers: Pick<AiProviders, "batches">;
+  /**
+   * The batch provider, or a function that picks one for a stored reference.
+   * Defaults to the global provider, or the AI Gateway.
+   */
+  readonly provider?: Experimental_BatchProvider | ((reference: Experimental_BatchReference) => Experimental_BatchProvider | undefined);
+  /** Seconds between two polls of a pending batch. Default 60. */
+  readonly pollEvery?: number;
+  /** Changes what is stored for an item, such as moving images to Storage first. */
+  readonly onItem?: (item: Experimental_BatchItemResult, batch: AiBatch) => AiBatchItemInput | Promise<AiBatchItemInput>;
+  /** Called once a batch's results are saved, or it failed. */
+  readonly onDone?: (batch: AiBatch) => unknown;
+  readonly api?: Partial<BatchApi>;
+}
+interface AiBatches {
+  /** Starts a batch and records it for the tenant, as the caller. */
+  start(context: {
+    readonly organizationId: string;
+    readonly userId?: string;
+  }, options: Experimental_StartBatchOptions & {
+    readonly metadata?: Readonly<Record<string, unknown>>;
+  }): AsyncResult<AiBatch>;
+  /** The stored batch, as the caller. */
+  status(batchId: string): AsyncResult<AiBatch | undefined>;
+  /** The stored results, as the caller, after the `requestId` in `cursor`. */
+  results(batchId: string, options?: CursorPageOptions<string>): AsyncResult<readonly AiBatchItem[]>;
+  /** Asks the provider for the batch's status and stores it (service role). */
+  refresh(batch: AiBatch): AsyncResult<AiBatch>;
+  /** Streams a finished batch's results into the table (service role). Returns how many. */
+  collect(batch: AiBatch): AsyncResult<number>;
+  cancel(batch: AiBatch): AsyncResult<AiBatch>;
+  /** Claims due batches, refreshes them and collects finished ones. Returns how many it polled. */
+  poll(options?: {
+    readonly batch?: number;
+  }): AsyncResult<number>;
+  /** A job handler that runs `poll`; schedule it every minute. */
+  pollJob(options?: {
+    readonly batch?: number;
+  }): JobHandler<unknown>;
+}
+/** What is stored for one result by default. */
+export declare function batchItemOf(item: Experimental_BatchItemResult): AiBatchItemInput;
+/**
+ * Batch jobs over the AI SDK's batch API, recorded in the providers block:
+ * `start` records the batch, the poll job asks the provider for its status
+ * until it finishes and then saves its results, which `results` pages.
+ */
+export declare function aiBatches(options: AiBatchesOptions): AiBatches;
+//#endregion
+export type { AiBatches, AiBatchesOptions, BatchApi };