better-supabase 0.12.0 → 0.13.0

package/dist/ai-files-DTbIJcxQ.js

@@ -0,0 +1,339 @@
+import { n as dbError } from "./errors-D7u24ZJH.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-DIT_qp4G.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { t as fromStorageError } from "./errors-Cq72lONT.js";
+import { C as optionalText, D as recordOf, I as textOf, S as optionalInstant, _ as notFoundError, b as oneOf, h as instantOf, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "./block-helpers-DwE32_gT.js";
+import { r as withBlockHooks } from "./block-hooks-C1r-R2r0.js";
+import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "./block-fields-Cwd4c8m-.js";
+import { n as claimsUploads, t as claimUpload } from "./upload-claim-DCuklVyh.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"
+];
+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: instantOf(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: instantOf(row["created_at"]),
+		updatedAt: instantOf(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: instantOf(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: instantOf(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;
+	const segments = parsed.pathname.split("/").filter((part) => part !== "");
+	if (segments.length === 0) return;
+	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 CLAIM_HINTS = {
+	notUploaded: "AI_FILE_NOT_UPLOADED",
+	forbidden: "AI_FILE_FORBIDDEN"
+};
+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 fields = blockFields(options.fields, "file fields");
+	const typed = (value) => AsyncResult.from(() => withFields(fields, value, fileOf(value)));
+	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) ? typed(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 withBlockHooks({
+		files: {
+			upload: (organizationId, { filename, mediaType, size, chatId, projectId, ...extra }) => AsyncResult.from(() => extraFieldsArg(fields, extra)).andThen((more) => call("reserve_ai_file", {
+				tenant: organizationId,
+				filename,
+				media_type: mediaType,
+				byte_size: size,
+				chat_id: chatId,
+				project_id: projectId,
+				...more
+			}, (value) => value)).andThen(typed).andThen((created) => stored(options.storage.from(created.bucket).createSignedUploadUrl(created.path)).map((url) => ({
+				file: created,
+				signedUrl: url.signedUrl,
+				token: url.token
+			}))),
+			confirm: (fileId, sha256) => {
+				const confirmed = () => call("confirm_ai_file", {
+					file_id: fileId,
+					sha256
+				}, (value) => value).andThen(typed);
+				return claimsUploads(options.storage) ? get(fileId).andThen((row) => row.status === "pending" ? claimUpload(options.storage, row, CLAIM_HINTS).andThen(confirmed) : confirmed()) : confirmed();
+			},
+			get,
+			resolve,
+			list: (chatId) => call("list_ai_files", { chat_id: chatId }, (value) => recordsOf(value, "list_ai_files").map((raw) => [raw, fileOf(raw)])).andThen((rows) => allWithFields(fields, rows)),
+			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) => {
+				const { ownerId, filename, mediaType, data, chatId, source, ...extra } = file;
+				return AsyncResult.from(() => extraFieldsArg(fields, extra)).andThen((more) => service("store_ai_file", {
+					tenant: organizationId,
+					owner: ownerId,
+					filename,
+					media_type: mediaType,
+					byte_size: data instanceof Uint8Array ? data.byteLength : data.size,
+					chat_id: chatId,
+					source: source ?? "generated",
+					...more
+				}, (value) => value)).andThen(typed).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)
+			}));
+		}
+	}, options.hooks, {
+		block: "ai-files",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+export { createAiFiles as n, parseAiFileUrl as r, aiFileUrl as t };

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

@@ -1,44 +1,49 @@
-import { a as SessionActor, c as agentClaims, r as AgentActOptions } from "../../actor-BAhb-d1S.js";
-import { d as KnowledgeSearchOptions, o as KnowledgeHit, r as Knowledge } from "../../knowledge-B5zdpDD-.js";
-import { t as Agent } from "../../agents-CGP2AQge.js";
-import { P as AiToolPolicy, _ as AiModerationAction, b as AiModerationStage, i as AiChat } from "../../ai-chat-D-2MH1sU.js";
-import { r as AuthorizationOperation } from "../../authorization-ClWBcXJi.js";
-import { t as OperationTable } from "../../operations-DQCWqkt3.js";
-import { i as SearchToolOptions, r as ResultsFilter } from "../../embeddings-CKhygw4C.js";
-import { n as GatewayOptions } from "../../gateway-options-ClvvfuuU.js";
+import { a as SessionActor, c as agentClaims, r as AgentActOptions } from "../../actor-CoveJgya.js";
+import { d as KnowledgeSearchOptions, o as KnowledgeHit, r as Knowledge } from "../../knowledge-CYdNJasZ.js";
+import { t as Agent } from "../../agents-CuxuXVWv.js";
+import { P as AiToolPolicy, _ as AiModerationAction, b as AiModerationStage, i as AiChat } from "../../ai-chat-B00sIOjY.js";
+import { r as AuthorizationOperation } from "../../authorization-CB69cvnA.js";
+import { t as OperationTable } from "../../operations-Cc27HkTG.js";
+import { i as SearchToolOptions, r as ResultsFilter } from "../../embeddings-Deusi99x.js";
+import { n as GatewayOptions } from "../../gateway-options-BlVCqgb8.js";
 import { LanguageModel, LanguageModelMiddleware, StopCondition, ToolLoopAgent, ToolLoopAgentSettings, ToolSet } from "ai";
 //#region src/ai-sdk/agents/authorization.d.ts
-/** Who runs an agent: the user from the verified session, never a model or tool value. */
+/**
+ * Who runs an agent: the user from the verified session, never a model or tool
+ * value.
+ */
 interface AgentCaller {
   readonly userId: string;
   /** The tenant of the run; the agent's own tenant when unset. */
   readonly organizationId?: string;
 }
-/** The agent as the actor of a run. It acts for the caller and is never the principal. */
+/**
+ * The agent as the actor of a run. It acts for the caller and is never the
+ * principal.
+ */
 interface AgentActor {
   readonly kind: "agent";
   readonly id: string;
 }
 /**
  * Who a run is for. `userId` is the principal: the invoking user, or the
- * publishing user for a run nobody invoked. The agent only appears as
- * `actor`.
+ * publishing user for a run nobody invoked. The agent only appears as `actor`.
  */
 type AgentRunContext = {
   readonly userId: string | undefined;
   readonly organizationId: string | undefined;
   readonly actor: AgentActor;
   /**
-   * The `act` level a tool's database calls carry, with the run's tools:
-   * pass `agentClaims(claims, run.act)` to `asUser` or `forContext`, so a tool
+   * The `act` level a tool's database calls carry, with the run's tools: pass
+   * `agentClaims(claims, run.act)` to `asUser` or `forContext`, so a tool
    * writes as the user, with the agent recorded as the actor.
    */
   readonly act: AgentActOptions;
 };
 /**
  * The run context for an agent row, its caller and the tools it may call,
- * frozen. A read-only agent `actor` (the session's own agent level) makes
- * the run's `act` read-only too.
+ * frozen. A read-only agent `actor` (the session's own agent level) makes the
+ * run's `act` read-only too.
  */
 export declare function agentRunContext(agent: Pick<Agent, "id" | "organizationId">, caller?: AgentCaller, tools?: readonly string[], actor?: SessionActor): AgentRunContext;
 /** The part of an actor `assertToolDelegated` reads. */
@@ -46,16 +51,19 @@ interface ToolDelegation {
   readonly kind: string;
   readonly tools?: readonly string[];
 }
-/** Whether an agent level that lists tools lists `toolName`; every other actor may call it. */
+/**
+ * Whether an agent level that lists tools lists `toolName`; every other actor
+ * may call it.
+ */
 export declare function toolDelegated(actor: ToolDelegation | undefined, toolName: string): boolean;
 /**
- * Throws a forbidden `DbException` (`AGENT_TOOL_NOT_DELEGATED`) when the
- * actor is an agent whose `act.tools` lists tools and not `toolName`.
+ * Throws a forbidden `DbException` (`AGENT_TOOL_NOT_DELEGATED`) when the actor
+ * is an agent whose `act.tools` lists tools and not `toolName`.
  */
 export declare function assertToolDelegated(actor: ToolDelegation | undefined, toolName: string): void;
 /**
- * The permission each tool needs when the provider's operations name none:
- * a permission key, or `false` for a tool that is public by design.
+ * The permission each tool needs when the provider's operations name none: a
+ * permission key, or `false` for a tool that is public by design.
  */
 type AgentToolPermissions = Readonly<Record<string, string | false>>;
 /** The provider operation each tool checks, in place of `ai.tool.<name>`. */
@@ -64,7 +72,10 @@ type AgentToolOperations = Readonly<Record<string, string>>;
 interface AgentToolOperation {
   /** `ai.tool.<name>`. */
   readonly operation: string;
-  /** The permission the tool needs; `false` when public, `undefined` when none is declared. */
+  /**
+   * The permission the tool needs; `false` when public, `undefined` when none
+   * is declared.
+   */
   readonly permission: string | false | undefined;
   readonly risk?: NonNullable<AuthorizationOperation["meta"]>["risk"];
   readonly effects?: NonNullable<AuthorizationOperation["meta"]>["effects"];
@@ -72,8 +83,8 @@ interface AgentToolOperation {
 }
 /**
  * The operation of the tool `name`: the provider's entry for the tool's
- * operation (from `toolOperations`, default `ai.tool.<name>`) first, then
- * the tool's own permission from `permissions`.
+ * operation (from `toolOperations`, default `ai.tool.<name>`) first, then the
+ * tool's own permission from `permissions`.
  */
 export declare function agentToolOperation(name: string, operations?: OperationTable, permissions?: AgentToolPermissions, toolOperations?: AgentToolOperations): AgentToolOperation;
 /** What `authorizeTool` gets with the permission. */
@@ -96,11 +107,14 @@ type AgentToolAuthorizer = (permission: string, context: AgentToolCallContext) =
 //#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 and, when the session's `actor`
- * is an agent that lists tools, without the ones it wasn't delegated.
+ * none), without the tenant's `deny` tools and, when the session's `actor` is
+ * an agent that lists tools, without the ones it wasn't delegated.
  */
 export declare function agentTools(agent: Pick<Agent, "tools">, available: ToolSet, policies?: Readonly<Record<string, AiToolPolicy>>, actor?: SessionActor): ToolSet;
-/** The `toolApproval` setting that makes the tenant's `ask` tools wait for the user. */
+/**
+ * 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>;
@@ -125,23 +139,22 @@ interface AgentRuntimeOptions {
   /** Default 20 steps. */
   readonly stopWhen?: StopCondition<ToolSet> | StopCondition<ToolSet>[];
   /**
-   * The app's approval check for each tool call. It runs after the
-   * permission check and before the tenant's `policies`, and the stricter
-   * answer wins: `denied` over `user-approval` over `approved`. A throw
-   * denies.
+   * The app's approval check for each tool call. It runs after the permission
+   * check and before the tenant's `policies`, and the stricter answer wins:
+   * `denied` over `user-approval` over `approved`. A throw denies.
    */
   readonly toolApproval?: AgentToolApprovalFunction;
   /**
-   * The user the agent runs for, from the verified session. It is the
-   * principal of every check and the AI Gateway's `user`; the agent is only
-   * the actor. For a run nobody invoked, pass the publishing user.
+   * The user the agent runs for, from the verified session. It is the principal
+   * of every check and the AI Gateway's `user`; the agent is only the actor.
+   * For a run nobody invoked, pass the publishing user.
    */
   readonly caller?: AgentCaller;
   /**
    * The session's actor, from `actorOf(claims)`. When it is an agent whose
-   * `act.tools` lists tools, the run gets only those, and a call to any
-   * other is denied (`AGENT_TOOL_NOT_DELEGATED`). A read-only agent makes
-   * the run's `act` read-only.
+   * `act.tools` lists tools, the run gets only those, and a call to any other
+   * is denied (`AGENT_TOOL_NOT_DELEGATED`). A read-only agent makes the run's
+   * `act` read-only.
    */
   readonly actor?: SessionActor;
   /**
@@ -156,9 +169,9 @@ interface AgentRuntimeOptions {
    */
   readonly results?: ResultsFilter<KnowledgeHit, AgentResultsContext>;
   /**
-   * The provider's operations (`authorization.operations`). An
-   * `ai.tool.<name>` entry sets the tool's permission over `permissions`,
-   * and a `high` risk makes the tool wait for the user's approval.
+   * The provider's operations (`authorization.operations`). An `ai.tool.<name>`
+   * entry sets the tool's permission over `permissions`, and a `high` risk
+   * makes the tool wait for the user's approval.
    */
   readonly operations?: OperationTable;
   /** Each tool's own permission; `false` marks a tool that needs none. */
@@ -166,16 +179,15 @@ interface AgentRuntimeOptions {
   /** The provider operation each tool checks, in place of `ai.tool.<name>`. */
   readonly toolOperations?: AgentToolOperations;
   /**
-   * Checks the caller's permission for each tool call. With it, a tool
-   * without a permission (from `operations` or `permissions`) is denied,
-   * and so is a check that returns `false` or throws.
+   * Checks the caller's permission for each tool call. With it, a tool without
+   * a permission (from `operations` or `permissions`) is denied, and so is a
+   * check that returns `false` or throws.
    */
   readonly authorizeTool?: AgentToolAuthorizer;
   /**
-   * AI Gateway attribution for every model call: the caller's id as
-   * `user`, and the tenant, `feature` (default `agent`), `agent:<id>` and
-   * `tags` as tags. `options` adds gateway options; a `user` in it is
-   * dropped.
+   * AI Gateway attribution for every model call: the caller's id as `user`, and
+   * the tenant, `feature` (default `agent`), `agent:<id>` and `tags` as tags.
+   * `options` adds gateway options; a `user` in it is dropped.
    */
   readonly gateway?: {
     readonly feature?: string;
@@ -207,11 +219,11 @@ export declare class ModerationBlockedError extends Error {
   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.
+ * 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