better-supabase 0.14.0 → 0.15.1

package/dist/ai-files-CgFCRsnU.js

@@ -0,0 +1,339 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-ntFBW2p2.js";
+import { t as fromStorageError } from "./errors-CyxMxzlu.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-CtBdjgO4.js";
+import { r as withBlockHooks } from "./block-hooks-BfxX3682.js";
+import { c as withFields, n as blockFields, r as extraFieldsArg, t as allWithFields } from "./block-fields-DE_FgpOU.js";
+import { n as claimsUploads, t as claimUpload } from "./upload-claim-B1ZU8ydB.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),
+			upsert: (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-schedules-D_Hz-ik5.d.ts

@@ -0,0 +1,166 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "./standard-DBV730sF.js";
+import { r as FieldsOf } from "./block-fields-BE7pInWZ.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { r as BlockTemporalOptions } from "./block-helpers-CRpAHrp_.js";
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "./block-hooks-DZN2w69m.js";
+import { g as JobHandler } from "./types-Czq9Xtpa.js";
+import { r as RunState } from "./run-state-BMCD_1Lt.js";
+import { I as Notifier } from "./define-block-DvvcM54N.js";
+//#region src/blocks/ai-schedules/ai-schedules.d.ts
+/** A task run's state, in the words ai-chat and workflow runs share. */
+type AiTaskRunStatus = Extract<RunState, "queued" | "running" | "completed" | "failed">;
+interface AiTaskRun {
+  readonly id: string;
+  readonly taskId: string;
+  readonly organizationId: string;
+  readonly userId: string;
+  readonly status: AiTaskRunStatus;
+  readonly scheduledFor: Temporal.Instant;
+  readonly chatId: string | undefined;
+  readonly error: string | undefined;
+  readonly startedAt: Temporal.Instant | undefined;
+  readonly finishedAt: Temporal.Instant | undefined;
+  readonly createdAt: Temporal.Instant;
+}
+interface AiTask {
+  readonly id: string;
+  readonly organizationId: string;
+  readonly userId: string;
+  /** The chat each run writes to; the first run's chat when unset. */
+  readonly chatId: string | undefined;
+  readonly agentId: string | undefined;
+  readonly title: string;
+  readonly prompt: string;
+  /** Five-field cron or an interval such as `30 minutes`. */
+  readonly cron: string;
+  /** An IANA time zone the cron runs in. */
+  readonly timezone: string;
+  readonly enabled: boolean;
+  readonly nextRunAt: Temporal.Instant | undefined;
+  readonly lastRunAt: Temporal.Instant | undefined;
+  /** Only `list` sets it. */
+  readonly lastRun: AiTaskRun | undefined;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface AiTaskFields {
+  readonly title?: string;
+  readonly prompt?: string;
+  readonly cron?: string;
+  readonly timezone?: string;
+  readonly chatId?: string | null;
+  readonly agentId?: string | null;
+}
+type NewAiTask = AiTaskFields & {
+  readonly title: string;
+  readonly prompt: string;
+  readonly cron: string;
+};
+/**
+ * Runs one occurrence of a task, as the task's user: sends the prompt to the
+ * assistant and returns the chat it wrote to. A throw fails the run.
+ */
+type AiTaskRunner = ((task: AiTask, run: AiTaskRun, signal: AbortSignal) => Promise<{
+  readonly chatId?: string;
+} | void>) & {
+  /** The runner contract version. Omitted means 1. */
+  readonly apiVersion?: 1;
+};
+interface AiTaskOutcome {
+  readonly task: AiTask;
+  readonly run: AiTaskRun;
+  readonly ok: boolean;
+  readonly error?: string;
+  readonly chatId?: string;
+}
+interface AiSchedulesOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  /**
+   * A Standard Schema for the task columns the app adds
+   * (`blocks["ai-schedules"].options.extraColumns`), keyed by column name. It
+   * types and parses them on `create`, `update`, `pause`, `resume` and `list`,
+   * and validates them on `create` and `update`, which return a `validation`
+   * error for a bad value.
+   */
+  readonly fields?: S;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<AiSchedules<FieldsOf<S>>>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  /** Calls as the user: `rpcTransport(supabase)`. */
+  readonly transport: BlockTransport;
+  /** Calls as the service role, for `tick`, `execute` and `runJob`. */
+  readonly service?: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`. Default `better_supabase`.
+   */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  readonly run?: AiTaskRunner;
+  /**
+   * Called after each run finishes, to notify the task's user. Defaults to
+   * `notification` through `notifier`.
+   */
+  readonly notify?: (outcome: AiTaskOutcome) => unknown;
+  /** The `notifier` port: the `notifications` block, from `createBlocks`. */
+  readonly notifier?: Notifier;
+  /**
+   * The notification type `notifier` sends the task's user after each run. Its
+   * data is `{ taskId, runId, ok, error?, chatId? }`.
+   */
+  readonly notification?: string;
+  /** The clock, for tests. */
+  readonly now?: () => Temporal.Instant;
+}
+/** `F` is the extra task fields `options.fields` describes. */
+interface AiSchedules<F extends object = Record<never, never>> {
+  /** Keys besides the task's own are its extra columns. */
+  create(organizationId: string, task: NewAiTask & Partial<F>): AsyncResult<AiTask & F>;
+  update(organizationId: string, taskId: string, fields: AiTaskFields & Partial<F>): AsyncResult<AiTask & F>;
+  pause(organizationId: string, taskId: string): AsyncResult<AiTask & F>;
+  /** Enables a task again; it runs at its next occurrence. */
+  resume(organizationId: string, taskId: string): AsyncResult<AiTask & F>;
+  remove(taskId: string): AsyncResult<boolean>;
+  /** The caller's tasks, or every task in the tenant with `all` and `ai.admin`. */
+  list(organizationId: string, options?: {
+    readonly all?: boolean;
+  }): AsyncResult<readonly (AiTask & F)[]>;
+  runs(taskId: string, options?: {
+    readonly limit?: number;
+  }): AsyncResult<readonly AiTaskRun[]>;
+  /**
+   * Claims due tasks (service role): queues a run for each, which the
+   * `ai_task_run` queue picks up when jobs is installed, and computes the next
+   * occurrence of every task that needs one. Returns the queued runs.
+   */
+  tick(options?: {
+    readonly batch?: number;
+  }): AsyncResult<readonly AiTaskRun[]>;
+  /**
+   * Starts, runs and finishes a queued run (service role). `false` when another
+   * worker has it.
+   */
+  execute(runId: string, options?: {
+    readonly signal?: AbortSignal;
+  }): AsyncResult<boolean>;
+  /** The handler for the `ai_task_run` queue. */
+  runJob(): JobHandler<{
+    readonly run_id: string;
+  }>;
+  /**
+   * `tick` then `execute` each run in turn, without a queue. Returns how many
+   * ran. A failed run does not stop the others; when any failed, the result is
+   * the first error, with every failed run listed in `details`.
+   */
+  drain(options?: {
+    readonly batch?: number;
+    readonly signal?: AbortSignal;
+  }): AsyncResult<number>;
+}
+/** Prompts users schedule on a cron, and the scheduler that runs them. */
+declare function createAiSchedules<S extends StandardSchemaV1 | undefined = undefined>(options: AiSchedulesOptions<S>): AiSchedules<FieldsOf<S>>;
+//#endregion
+export { AiTaskOutcome as a, AiTaskRunner as c, AiTaskFields as i, NewAiTask as l, AiSchedulesOptions as n, AiTaskRun as o, AiTask as r, AiTaskRunStatus as s, AiSchedules as t, createAiSchedules as u };

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

@@ -1,10 +1,10 @@
 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-CFkCRxO9.js";
-import { t as Agent } from "../../agents-CmZlLPXC.js";
-import { P as AiToolPolicy, _ as AiModerationAction, b as AiModerationStage, i as AiChat } from "../../ai-chat-DBxEz3o1.js";
-import { r as AuthorizationOperation } from "../../authorization-BuT26_sR.js";
-import { t as OperationTable } from "../../operations-nWYRexee.js";
-import { i as SearchToolOptions, r as ResultsFilter } from "../../embeddings-CcRP-cMN.js";
+import { d as KnowledgeSearchOptions, o as KnowledgeHit, r as Knowledge } from "../../knowledge-F1IhRI4Q.js";
+import { t as Agent } from "../../agents-CMIB3802.js";
+import { P as AiToolPolicy, _ as AiModerationAction, b as AiModerationStage, i as AiChat } from "../../ai-chat-BCaKsvLW.js";
+import { r as AuthorizationOperation } from "../../authorization-HZdJCaVm.js";
+import { t as OperationTable } from "../../operations-CSc_IsHO.js";
+import { i as SearchToolOptions, r as ResultsFilter } from "../../embeddings-D_RsS6ow.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

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

@@ -1,7 +1,7 @@
 import { t as DbException } from "../../db-exception-Lngc1W49.js";
-import { n as dbError } from "../../errors-03ysrOt4.js";
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
 import { n as operationMeta, r as operationPermission, t as OPERATION_PREFIXES } from "../../operations-DVHRHvv6.js";
-import { r as agentClaims } from "../../actor-hNajGNEK.js";
+import { r as agentClaims } from "../../actor-go7p9-CJ.js";
 import { t as gatewayOptions } from "../../gateway-options-Cl74B7k6.js";
 import { i as searchTool } from "../../embeddings-vVzseUw0.js";
 import { ToolLoopAgent, stepCountIs } from "ai";

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

@@ -1,7 +1,7 @@
-import { t as AsyncResult } from "../../result-C6jDfedy.js";
-import { i as CursorPageOptions } from "../../block-helpers-BaugZlJV.js";
-import { g as JobHandler } from "../../types-CGUDoF5I.js";
-import { i as AiBatchItemInput, r as AiBatchItem, t as AiBatch, u as AiProviders } from "../../types-BRJHGhSq.js";
+import { t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { i as CursorPageOptions } from "../../block-helpers-CRpAHrp_.js";
+import { g as JobHandler } from "../../types-Czq9Xtpa.js";
+import { c as AiKeys, i as AiBatchItemInput, r as AiBatchItem, t as AiBatch } from "../../types-EO2crSX_.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. */
@@ -25,7 +25,7 @@ interface AiBatchesOptions {
    * The providers block: a user transport for `start`, a service one for
    * polling.
    */
-  readonly providers: Pick<AiProviders, "batches">;
+  readonly providers: Pick<AiKeys, "batches">;
   /**
    * The batch provider, or a function that picks one for a stored reference.
    * Defaults to the global provider, or the AI Gateway.

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

@@ -1,8 +1,8 @@
-import { n as dbError } from "../../errors-03ysrOt4.js";
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
 import { s as nowInstant } from "../../temporal-DLZlWbOi.js";
-import { t as temporal } from "../../temporal-required-B8qQHYbI.js";
-import { a as ok, r as err, t as AsyncResult } from "../../result-B3m7xtRY.js";
-import { f as errorText } from "../../block-helpers-CiKtrb6g.js";
+import { t as temporal } from "../../temporal-required-Dy0GGD8E.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-ntFBW2p2.js";
+import { f as errorText } from "../../block-helpers-CtBdjgO4.js";
 import { experimental_cancelBatch, experimental_getBatchResults, experimental_getBatchStatus, experimental_startBatch } from "ai";
 //#region src/ai-sdk/batches/batches.ts
 const DEFAULT_API = {

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

@@ -1,5 +1,5 @@
-import { b as DbError } from "../../result-C6jDfedy.js";
-import { t as AiCache } from "../../ai-cache-BxlOkc_M.js";
+import { b as DbError } from "../../result-DZeA5KS6.js";
+import { t as AiCache } from "../../ai-cache-2LGgaT7F.js";
 import { LanguageModelMiddleware } from "ai";
 //#region src/ai-sdk/cache/cache.d.ts
 type WrapGenerate = NonNullable<LanguageModelMiddleware["wrapGenerate"]>;
@@ -7,7 +7,7 @@ type WrapGenerate = NonNullable<LanguageModelMiddleware["wrapGenerate"]>;
 type CacheCall = Parameters<WrapGenerate>[0];
 interface CacheMiddlewareOptions {
   /** The AI cache block with a service transport. */
-  readonly cache: Pick<AiCache, "get" | "set">;
+  readonly cache: Pick<AiCache, "get" | "upsert">;
   /** Seconds an entry lives, capped by the module's `maxTtl`. */
   readonly ttl: number;
   /**

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

@@ -1,5 +1,5 @@
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { t as cacheKey } from "../../ai-cache-DQikwXhJ.js";
+import { t as cacheKey } from "../../ai-cache-Cu8j6aQQ.js";
 import { simulateReadableStream } from "ai";
 //#region src/ai-sdk/cache/cache.ts
 const BYTES = "$bytes";
@@ -61,7 +61,7 @@ function cacheMiddleware(options) {
 		return entry.data?.value;
 	};
 	const write = async (key, value, call, kind) => {
-		const saved = await options.cache.set(key, encode(value), {
+		const saved = await options.cache.upsert(key, encode(value), {
 			ttl: options.ttl,
 			kind,
 			model: `${call.model.provider}/${call.model.modelId}`,

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

@@ -1,2 +1,2 @@
-import { a as AssistantOptions, c as AssistantRunResult, i as AssistantModeration, l as AssistantTurn, n as AssistantContext, o as AssistantRequestBody, r as AssistantFinish, s as AssistantRunArgs, t as Assistant, u as createAssistant } from "../../assistant-D1yev_fR.js";
+import { a as AssistantOptions, c as AssistantRunResult, i as AssistantModeration, l as AssistantTurn, n as AssistantContext, o as AssistantRequestBody, r as AssistantFinish, s as AssistantRunArgs, t as Assistant, u as createAssistant } from "../../assistant-ndGdOBax.js";
 export { type Assistant, type AssistantContext, type AssistantFinish, type AssistantModeration, type AssistantOptions, type AssistantRequestBody, type AssistantRunArgs, type AssistantRunResult, type AssistantTurn, createAssistant };

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

@@ -1,11 +1,11 @@
-import { n as dbError } from "../../errors-03ysrOt4.js";
+import { n as dbError } from "../../errors-BVFgt8BZ.js";
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
-import { o as problemResponse } from "../../problem-BWElIgIb.js";
+import { o as problemResponse } from "../../problem-Bf0cJ7tk.js";
 import { n as pathToHistory, r as repairDanglingToolCalls } from "../../history-GH1HJWQV.js";
 import { t as gatewayOptions } from "../../gateway-options-Cl74B7k6.js";
-import { d as problem429, f as runRelease, i as isUIMessage, m as usageOf, r as fromUIMessage, s as toUIMessages, t as AI_SDK_UI_FORMAT } from "../../messages-DNzIVvgN.js";
-import { n as teeToStore, t as resumeFromStore } from "../../tee-DwkUvJD_.js";
-import { n as readJson, r as sse, t as badRequest } from "../../http-51t9xppD.js";
+import { d as problem429, f as runRelease, i as isUIMessage, m as usageOf, r as fromUIMessage, s as toUIMessages, t as AI_SDK_UI_FORMAT } from "../../messages-D4XWuRTj.js";
+import { n as teeToStore, t as resumeFromStore } from "../../tee-V97_v1ZS.js";
+import { n as readJson, r as sse, t as badRequest } from "../../http-7-UvHjQe.js";
 import { JsonToSseTransformStream, convertToModelMessages } from "ai";
 //#region src/ai-sdk/chat/assistant.ts
 const TRIGGERS = /* @__PURE__ */ new Set(["submit-message", "regenerate-message"]);

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

@@ -1,3 +1,3 @@
-import { n as Embedder, o as KnowledgeHit } from "../../knowledge-CFkCRxO9.js";
-import { a as SearchToolResult, c as embedWith, d as searchTool, f as supabaseEmbed, i as SearchToolOptions, l as modelName, n as Reranker, o as SupabaseAiSession, p as toSourceParts, r as ResultsFilter, s as SupabaseEmbedOptions, t as EmbedWithOptions, u as rerankWith } from "../../embeddings-CcRP-cMN.js";
+import { n as Embedder, o as KnowledgeHit } from "../../knowledge-F1IhRI4Q.js";
+import { a as SearchToolResult, c as embedWith, d as searchTool, f as supabaseEmbed, i as SearchToolOptions, l as modelName, n as Reranker, o as SupabaseAiSession, p as toSourceParts, r as ResultsFilter, s as SupabaseEmbedOptions, t as EmbedWithOptions, u as rerankWith } from "../../embeddings-D_RsS6ow.js";
 export { type EmbedWithOptions, type Embedder, type KnowledgeHit, type Reranker, type ResultsFilter, type SearchToolOptions, type SearchToolResult, type SupabaseAiSession, type SupabaseEmbedOptions, embedWith, modelName, rerankWith, searchTool, supabaseEmbed, toSourceParts };

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

@@ -1,7 +1,7 @@
 /// <reference lib="esnext.temporal" />
-import { b as DbError, t as AsyncResult } from "../../result-C6jDfedy.js";
+import { b as DbError, t as AsyncResult } from "../../result-DZeA5KS6.js";
 import { r as AiFilePart } from "../../message-Bg4TKA12.js";
-import { c as AiFileSource, f as AiFiles } from "../../types-BEDfwXL4.js";
+import { c as AiFileSource, f as AiFiles } from "../../types-Dr9wZgNy.js";
 import { Experimental_DownloadFunction } from "ai";
 //#region src/ai-sdk/files/files.d.ts
 interface AiFileDownloadOptions {