better-supabase 0.7.1 → 0.9.0

package/dist/ai-files-D2_9YLjF.js

@@ -0,0 +1,331 @@
+import { n as dbError } from "./errors-8i6tSICm.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-BlgnMB0H.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { t as fromStorageError } from "./errors-PIpcoe4z.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-CfG_MvDR.js";
+import { r as withBlockHooks } from "./block-hooks-BsXncUlZ.js";
+import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "./block-fields-ffD6Gxe4.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 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) => call("confirm_ai_file", {
+				file_id: fileId,
+				sha256
+			}, (value) => value).andThen(typed),
+			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-message-DfaP8sis.js

@@ -0,0 +1,14 @@
+//#region src/core/contracts/ai-message.ts
+const AI_MESSAGE_PART_TYPES = [
+	"text",
+	"reasoning",
+	"file",
+	"tool-call",
+	"tool-result",
+	"tool-approval",
+	"source",
+	"data",
+	"step"
+];
+//#endregion
+export { AI_MESSAGE_PART_TYPES as t };

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

@@ -1,14 +1,105 @@
-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 { 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-BXQ2-V0a.js";
+import { t as Agent } from "../../agents-BCNhIxVZ.js";
+import { P as AiToolPolicy, _ as AiModerationAction, b as AiModerationStage, i as AiChat } from "../../ai-chat-3GBSlFR4.js";
+import { r as AuthorizationOperation } from "../../authorization-DpRfs6Wx.js";
+import { t as OperationTable } from "../../operations-C9-UcReN.js";
+import { i as SearchToolOptions, r as ResultsFilter } from "../../embeddings-C2S14foD.js";
+import { n as GatewayOptions } from "../../gateway-options-ClvvfuuU.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. */
+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. */
+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`.
+ */
+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
+   * 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.
+ */
+export declare function agentRunContext(agent: Pick<Agent, "id" | "organizationId">, caller?: AgentCaller, tools?: readonly string[], actor?: SessionActor): AgentRunContext;
+/** The part of an actor `assertToolDelegated` reads. */
+interface ToolDelegation {
+  readonly kind: string;
+  readonly tools?: readonly string[];
+}
+/** 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`.
+ */
+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.
+ */
+type AgentToolPermissions = Readonly<Record<string, string | false>>;
+/** The provider operation each tool checks, in place of `ai.tool.<name>`. */
+type AgentToolOperations = Readonly<Record<string, string>>;
+/** The operation an AI tool is, with what the provider says about it. */
+interface AgentToolOperation {
+  /** `ai.tool.<name>`. */
+  readonly operation: string;
+  /** 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"];
+  readonly title?: string;
+}
+/**
+ * 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`.
+ */
+export declare function agentToolOperation(name: string, operations?: OperationTable, permissions?: AgentToolPermissions, toolOperations?: AgentToolOperations): AgentToolOperation;
+/** What `authorizeTool` gets with the permission. */
+type AgentToolCallContext = AgentRunContext & {
+  readonly toolName: string;
+  readonly operation: string;
+  /** The model's arguments; treat them as untrusted input. */
+  readonly input: unknown;
+};
+/** What the runtime's `results` filter gets with the items. */
+type AgentResultsContext = AgentRunContext & {
+  readonly toolName: string;
+  readonly query: string;
+};
+/** Decides whether the caller may run a model. */
+type AgentModelAuthorizer = (modelId: string, context: AgentRunContext) => boolean | PromiseLike<boolean>;
+/** Decides whether the caller holds a tool's permission. */
+type AgentToolAuthorizer = (permission: string, context: AgentToolCallContext) => boolean | PromiseLike<boolean>;
+//#endregion
 //#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.
+ * 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>>): ToolSet;
+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. */
 export declare function agentToolApproval(tools: ToolSet, policies?: Readonly<Record<string, AiToolPolicy>>): Record<string, "user-approval">;
 /** A `toolApproval` function, as `ToolLoopAgent` takes it. */
@@ -34,11 +125,64 @@ interface AgentRuntimeOptions {
   /** 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.
+   * 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.
+   */
+  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.
+   */
+  readonly actor?: SessionActor;
+  /**
+   * Called before every model call with the model id and the run context.
+   * `false` or a throw refuses the run with a `forbidden` error before the
+   * model is called. Every model is allowed without it.
+   */
+  readonly authorizeModel?: AgentModelAuthorizer;
+  /**
+   * Drops the knowledge hits the caller may not read, before the reranker,
+   * `onHits` and the model see them.
+   */
+  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.
+   */
+  readonly operations?: OperationTable;
+  /** Each tool's own permission; `false` marks a tool that needs none. */
+  readonly permissions?: AgentToolPermissions;
+  /** 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.
+   */
+  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.
+   */
+  readonly gateway?: {
+    readonly feature?: string;
+    readonly chatId?: string;
+    readonly tags?: readonly string[];
+    readonly options?: GatewayOptions;
+  };
 }
 /** A `ToolLoopAgent` from an agent row. */
 export declare function createAgentRuntime(options: AgentRuntimeOptions): ToolLoopAgent<never, ToolSet>;
@@ -71,4 +215,4 @@ export declare class ModerationBlockedError extends Error {
  */
 export declare function moderationMiddleware(options: ModerationMiddlewareOptions): LanguageModelMiddleware;
 //#endregion
-export type { Agent, AgentRuntimeOptions, AgentToolApprovalFunction, ModerationMiddlewareOptions, ModerationVerdict };
+export { type Agent, type AgentActOptions, type AgentActor, type AgentCaller, type AgentModelAuthorizer, type AgentResultsContext, type AgentRunContext, type AgentRuntimeOptions, type AgentToolApprovalFunction, type AgentToolAuthorizer, type AgentToolCallContext, type AgentToolOperation, type AgentToolOperations, type AgentToolPermissions, type ModerationMiddlewareOptions, type ModerationVerdict, type ToolDelegation, agentClaims };