better-supabase 0.5.0 → 0.6.0

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

@@ -0,0 +1,180 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { s as nowInstant } from "../../temporal-BJGitm-h.js";
+import { t as temporal } from "../../temporal-required-BVvW7SYJ.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-DzUbqgdW.js";
+import { c as errorText } from "../../block-helpers-DWHxHsEQ.js";
+import { experimental_cancelBatch, experimental_getBatchResults, experimental_getBatchStatus, experimental_startBatch } from "ai";
+//#region src/ai-sdk/batches/batches.ts
+const DEFAULT_API = {
+	start: (options) => experimental_startBatch(options),
+	status: (options) => experimental_getBatchStatus(options),
+	results: (options) => experimental_getBatchResults(options),
+	cancel: (options) => experimental_cancelBatch(options)
+};
+const PAGE = 100;
+function referenceOf(batch) {
+	const reference = batch.reference;
+	return reference["version"] === 2 && typeof reference["id"] === "string" && typeof reference["provider"] === "string" ? {
+		version: 2,
+		id: reference["id"],
+		provider: reference["provider"]
+	} : void 0;
+}
+function countsOf(status) {
+	return status.requestCounts === void 0 ? void 0 : { ...status.requestCounts };
+}
+function jsonOf(value) {
+	return value === void 0 ? void 0 : JSON.parse(JSON.stringify(value));
+}
+/** What is stored for one result by default. */
+function batchItemOf(item) {
+	if (item.status !== "succeeded") return {
+		requestId: item.id,
+		status: item.status,
+		...item.error === void 0 ? {} : { error: item.error.message }
+	};
+	if (item.type === "text") return {
+		requestId: item.id,
+		status: "succeeded",
+		output: jsonOf({
+			text: item.text,
+			content: item.content,
+			finishReason: item.finishReason,
+			response: item.response
+		}),
+		usage: jsonOf(item.usage)
+	};
+	return {
+		requestId: item.id,
+		status: "succeeded",
+		output: { images: item.images.map((image) => ({
+			mediaType: image.mediaType,
+			base64: image.base64
+		})) },
+		usage: jsonOf(item.usage)
+	};
+}
+/**
+* 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.
+*/
+function aiBatches(options) {
+	const api = {
+		...DEFAULT_API,
+		...options.api
+	};
+	const store = options.providers.batches;
+	const pollEvery = options.pollEvery ?? 60;
+	const providerFor = (reference) => {
+		const chosen = typeof options.provider === "function" ? options.provider(reference) : options.provider;
+		return chosen === void 0 ? {} : { provider: chosen };
+	};
+	const nextPoll = () => nowInstant().add({ seconds: pollEvery });
+	const call = (run) => AsyncResult.from(async () => {
+		try {
+			return ok(await run());
+		} catch (cause) {
+			return err(dbError("network", errorText(cause), { hint: "AI_BATCH_PROVIDER" }));
+		}
+	});
+	const withReference = (batch) => {
+		const reference = referenceOf(batch);
+		return reference === void 0 ? AsyncResult.err(dbError("invalid_input", `batch ${batch.id} has no batch reference`, { hint: "AI_BATCH_INVALID" })) : AsyncResult.ok(reference);
+	};
+	const refresh = (batch) => withReference(batch).andThen((reference) => call(() => api.status({
+		...providerFor(reference),
+		batch: reference
+	})).andThen((status) => {
+		const counts = countsOf(status);
+		return store.update(batch.id, {
+			status: status.status,
+			...status.rawStatus === void 0 ? {} : { rawStatus: status.rawStatus },
+			...counts === void 0 ? {} : { counts },
+			...status.error === void 0 ? {} : { error: status.error.message },
+			...status.expiresAt === void 0 ? {} : { expiresAt: temporal().Instant.from(status.expiresAt) },
+			nextPollAt: nextPoll()
+		});
+	}));
+	const collect = (batch) => withReference(batch).andThen((reference) => AsyncResult.from(async () => {
+		let saved = 0;
+		let page = [];
+		const flush = async () => {
+			if (page.length === 0) return ok(0);
+			const written = await store.saveItems(batch.id, page);
+			page = [];
+			return written;
+		};
+		try {
+			for await (const item of api.results({
+				...providerFor(reference),
+				batch: reference
+			})) {
+				page.push(options.onItem === void 0 ? batchItemOf(item) : await options.onItem(item, batch));
+				if (page.length >= PAGE) {
+					const written = await flush();
+					if (!written.ok) return written;
+					saved += written.data;
+				}
+			}
+		} catch (cause) {
+			return err(dbError("network", errorText(cause), { hint: "AI_BATCH_PROVIDER" }));
+		}
+		const written = await flush();
+		if (!written.ok) return written;
+		saved += written.data;
+		const done = await store.update(batch.id, {
+			resultsSaved: true,
+			nextPollAt: null
+		});
+		if (!done.ok) return done;
+		await options.onDone?.(done.data);
+		return ok(saved);
+	}));
+	const pollOne = (batch) => {
+		if (batch.status !== "pending") return collect(batch).map(() => batch);
+		return refresh(batch).andThen((fresh) => fresh.status === "pending" ? AsyncResult.ok(fresh) : collect(fresh).map(() => fresh));
+	};
+	const poll = (pollOptions = {}) => store.due(pollOptions).andThen((due) => AsyncResult.from(async () => {
+		for (const batch of due) {
+			const polled = await pollOne(batch);
+			if (!polled.ok) {
+				const noted = await store.update(batch.id, { error: polled.error.message });
+				if (!noted.ok) return noted;
+			}
+		}
+		return ok(due.length);
+	}));
+	return {
+		start: (context, startOptions) => {
+			const { metadata, ...batchOptions } = startOptions;
+			return call(() => api.start(batchOptions)).andThen((started) => store.record(context.organizationId, {
+				provider: started.provider,
+				reference: {
+					version: started.version,
+					id: started.id,
+					provider: started.provider
+				},
+				itemCount: batchOptions.requests.length,
+				status: started.status,
+				...context.userId === void 0 ? {} : { userId: context.userId },
+				...metadata === void 0 ? {} : { metadata },
+				...started.rawStatus === void 0 ? {} : { rawStatus: started.rawStatus },
+				...started.requestCounts === void 0 ? {} : { counts: { ...started.requestCounts } },
+				...started.expiresAt === void 0 ? {} : { expiresAt: temporal().Instant.from(started.expiresAt) }
+			}));
+		},
+		status: (batchId) => store.get(batchId),
+		results: (batchId, resultOptions) => store.items(batchId, resultOptions),
+		refresh,
+		collect,
+		cancel: (batch) => withReference(batch).andThen((reference) => call(() => api.cancel({
+			...providerFor(reference),
+			batch: reference
+		})).andThen(() => store.update(batch.id, { status: "cancelled" }))),
+		poll,
+		pollJob: (jobOptions) => async () => poll(jobOptions).orThrow()
+	};
+}
+//#endregion
+export { aiBatches, batchItemOf };

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

@@ -0,0 +1,38 @@
+import { b as DbError } from "../../result-D7y2fT87.js";
+import { t as AiCache } from "../../ai-cache-DaDu_G5L.js";
+import { LanguageModelMiddleware } from "ai";
+//#region src/ai-sdk/cache/cache.d.ts
+type WrapGenerate = NonNullable<LanguageModelMiddleware["wrapGenerate"]>;
+/** The call `cacheMiddleware` derives a key from. */
+type CacheCall = Parameters<WrapGenerate>[0];
+interface CacheMiddlewareOptions {
+  /** The AI cache block with a service transport. */
+  readonly cache: Pick<AiCache, "get" | "set">;
+  /** Seconds an entry lives, capped by the module's `maxTtl`. */
+  readonly ttl: number;
+  /** Keeps tenants' entries apart and lets `clear` and tenant deletion find them. */
+  readonly organizationId?: string;
+  /**
+   * What the key covers. Defaults to the provider, the model id and the call
+   * options without the abort signal and headers.
+   */
+  readonly key?: (call: CacheCall) => unknown;
+  /** Skips the cache for a call, such as one with a high temperature. */
+  readonly when?: (call: CacheCall) => boolean;
+  /** Pacing for replayed streams, in milliseconds; no delay by default. */
+  readonly replay?: {
+    readonly initialDelayInMs?: number | null;
+    readonly chunkDelayInMs?: number | null;
+  };
+  /** Called when the cache can't be read or written; the call still runs. */
+  readonly onError?: (error: DbError) => void;
+}
+/**
+ * A `wrapLanguageModel` middleware that answers repeated calls from the AI
+ * cache block. A cached generation is returned as is, and a cached stream is
+ * replayed through `simulateReadableStream`. Calls that end in an error are
+ * never cached, and a cache that fails to answer only costs the lookup.
+ */
+export declare function cacheMiddleware(options: CacheMiddlewareOptions): LanguageModelMiddleware;
+//#endregion
+export type { CacheCall, CacheMiddlewareOptions };

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

@@ -0,0 +1,127 @@
+import { d as isRecord } from "../../block-helpers-DWHxHsEQ.js";
+import { t as cacheKey } from "../../ai-cache-CBWs1W0k.js";
+import { simulateReadableStream } from "ai";
+//#region src/ai-sdk/cache/cache.ts
+const BYTES = "$bytes";
+const DATE = "$date";
+const URL_TAG = "$url";
+function encode(value) {
+	if (value instanceof Date) return { [DATE]: value.toISOString() };
+	if (value instanceof Uint8Array) {
+		let binary = "";
+		for (const byte of value) binary += String.fromCodePoint(byte);
+		return { [BYTES]: btoa(binary) };
+	}
+	if (value instanceof URL) return { [URL_TAG]: value.href };
+	if (Array.isArray(value)) return value.map(encode);
+	if (isRecord(value)) {
+		const out = {};
+		for (const [key, item] of Object.entries(value)) if (item !== void 0 && typeof item !== "function") out[key] = encode(item);
+		return out;
+	}
+	return value;
+}
+function decode(value) {
+	if (Array.isArray(value)) return value.map(decode);
+	if (!isRecord(value)) return value;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && typeof value[DATE] === "string") return new Date(value[DATE]);
+	if (keys.length === 1 && typeof value[URL_TAG] === "string") return new URL(value[URL_TAG]);
+	if (keys.length === 1 && typeof value[BYTES] === "string") return Uint8Array.from(atob(value[BYTES]), (char) => char.codePointAt(0) ?? 0);
+	const out = {};
+	for (const [key, item] of Object.entries(value)) out[key] = decode(item);
+	return out;
+}
+const defaultKey = (call) => {
+	const { abortSignal: _signal, headers: _headers, ...params } = call.params;
+	return {
+		provider: call.model.provider,
+		model: call.model.modelId,
+		params
+	};
+};
+/**
+* A `wrapLanguageModel` middleware that answers repeated calls from the AI
+* cache block. A cached generation is returned as is, and a cached stream is
+* replayed through `simulateReadableStream`. Calls that end in an error are
+* never cached, and a cache that fails to answer only costs the lookup.
+*/
+function cacheMiddleware(options) {
+	const keyOf = async (call, type) => cacheKey({
+		type,
+		tenant: options.organizationId ?? null,
+		parts: (options.key ?? defaultKey)(call)
+	});
+	const read = async (key) => {
+		const entry = await options.cache.get(key);
+		if (!entry.ok) {
+			options.onError?.(entry.error);
+			return;
+		}
+		return entry.data?.value;
+	};
+	const write = async (key, value, call, kind) => {
+		const saved = await options.cache.set(key, encode(value), {
+			ttl: options.ttl,
+			kind,
+			model: `${call.model.provider}/${call.model.modelId}`,
+			...options.organizationId === void 0 ? {} : { organizationId: options.organizationId }
+		});
+		if (!saved.ok) options.onError?.(saved.error);
+	};
+	return {
+		specificationVersion: "v4",
+		wrapGenerate: async (call) => {
+			if (options.when?.(call) === false) return call.doGenerate();
+			const key = await keyOf(call, "generate");
+			const cached = await read(key);
+			if (isRecord(cached)) return decode(cached);
+			const result = await call.doGenerate();
+			if (result.finishReason.unified !== "error") {
+				const { request: _request, ...rest } = result;
+				const response = rest.response === void 0 ? void 0 : {
+					...rest.response,
+					body: void 0,
+					headers: void 0
+				};
+				await write(key, {
+					...rest,
+					response
+				}, call, "generate");
+			}
+			return result;
+		},
+		wrapStream: async (call) => {
+			if (options.when?.(call) === false) return call.doStream();
+			const key = await keyOf(call, "stream");
+			const cached = await read(key);
+			if (isRecord(cached) && Array.isArray(cached["parts"])) {
+				const parts = decode(cached["parts"]);
+				return { stream: simulateReadableStream({
+					chunks: parts,
+					initialDelayInMs: options.replay?.initialDelayInMs ?? null,
+					chunkDelayInMs: options.replay?.chunkDelayInMs ?? null
+				}) };
+			}
+			const result = await call.doStream();
+			const parts = [];
+			let failed = false;
+			const stream = result.stream.pipeThrough(new TransformStream({
+				transform(part, controller) {
+					if (part.type === "error" || part.type === "finish" && part.finishReason.unified === "error") failed = true;
+					if (part.type !== "raw") parts.push(part);
+					controller.enqueue(part);
+				},
+				async flush() {
+					if (!failed) await write(key, { parts }, call, "stream");
+				}
+			}));
+			return {
+				...result,
+				stream
+			};
+		}
+	};
+}
+//#endregion
+export { cacheMiddleware };

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

@@ -0,0 +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-DwdpDH1q.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

@@ -0,0 +1,246 @@
+import { n as dbError } from "../../errors-B11Duf73.js";
+import { a as problemResponse } from "../../problem-BreOl8b8.js";
+import { d as isRecord } from "../../block-helpers-DWHxHsEQ.js";
+import { n as pathToHistory, r as repairDanglingToolCalls } from "../../history-BZih6SFP.js";
+import { a as isUIMessage, f as problem429, h as usageOf, i as fromUIMessage, l as gatewayOptions, p as runRelease, s as toUIMessages, t as AI_SDK_UI_FORMAT } from "../../messages-B9-5887d.js";
+import { n as teeToStore, t as resumeFromStore } from "../../tee-CoEppCER.js";
+import { JsonToSseTransformStream, UI_MESSAGE_STREAM_HEADERS, convertToModelMessages } from "ai";
+//#region src/ai-sdk/chat/assistant.ts
+const TRIGGERS = /* @__PURE__ */ new Set(["submit-message", "regenerate-message"]);
+function badRequest(message) {
+	return problemResponse(dbError("invalid_request", message, { code: "AI_CHAT_BAD_REQUEST" }));
+}
+function parseBody(value) {
+	if (!isRecord(value)) return "Expected a JSON object.";
+	const { id, trigger, messageId, model } = value;
+	if (typeof id !== "string" || id === "") return "Expected the chat id.";
+	const messages = value["messages"];
+	const last = Array.isArray(messages) ? messages.at(-1) : void 0;
+	const message = value["message"] ?? last;
+	if (!isUIMessage(message) || message.role !== "user") return "Expected the user's message.";
+	if (trigger !== void 0 && !TRIGGERS.has(trigger)) return "Expected submit-message or regenerate-message.";
+	return {
+		id,
+		message,
+		...trigger === "regenerate-message" ? { trigger } : {},
+		...typeof messageId === "string" ? { messageId } : {},
+		...typeof model === "string" ? { model } : {}
+	};
+}
+async function readJson(request) {
+	try {
+		return await request.json();
+	} catch {
+		return;
+	}
+}
+const settle = async (value) => {
+	try {
+		return await value;
+	} catch {
+		return;
+	}
+};
+function sse(stream) {
+	return new Response(stream.pipeThrough(new TextEncoderStream()), { headers: UI_MESSAGE_STREAM_HEADERS });
+}
+/**
+* A chat route for the AI SDK on the `ai-chat` block: `respond` stores the
+* user's message, picks an allowed model, checks the quota, claims the
+* chat's answer, runs the model and streams it while keeping a copy in the
+* stream store; the answer and its usage are stored when it ends, even
+* after the client left. `resume` replays it after a reload, `stop` ends it.
+*/
+function createAssistant(options) {
+	const newId = options.generateId ?? (() => crypto.randomUUID());
+	async function chatOf(context, body) {
+		const found = await context.chats.chats.get(body.id);
+		if (found.ok) return found.data;
+		if (found.error.kind !== "not_found") return problemResponse(found.error);
+		const created = await context.chats.chats.create(context.organizationId, {
+			id: body.id,
+			...body.model === void 0 ? {} : { model: body.model }
+		});
+		return created.ok ? created.data : problemResponse(created.error);
+	}
+	async function modelOf(context, chat, requested) {
+		const allowed = await context.chats.models.allowed(chat.organizationId);
+		if (!allowed.ok) return problemResponse(allowed.error);
+		const ids = new Set(allowed.data.map((model) => model.id));
+		const fits = (id) => ids.size === 0 || ids.has(id);
+		if (requested !== void 0 && fits(requested)) return requested;
+		if (requested !== void 0) return problemResponse(dbError("forbidden", `The model ${requested} is not allowed.`, { code: "AI_MODEL_NOT_ALLOWED" }));
+		if (chat.model !== void 0 && fits(chat.model)) return chat.model;
+		if (fits(options.defaultModel)) return options.defaultModel;
+		const first = allowed.data[0];
+		return first === void 0 ? options.defaultModel : first.id;
+	}
+	async function moderated(context, chat, message) {
+		const verdict = await options.moderate?.({
+			message,
+			chat
+		});
+		if (verdict === void 0 || verdict.action === "allow") return void 0;
+		await context.chats.moderation.record({
+			organizationId: chat.organizationId,
+			chatId: chat.id,
+			messageId: message.id,
+			userId: context.userId,
+			stage: "input",
+			action: verdict.action,
+			category: verdict.category,
+			...verdict.score === void 0 ? {} : { score: verdict.score }
+		});
+		return verdict.action === "block" ? problemResponse(dbError("forbidden", "The message was blocked.", { code: "AI_MODERATION_BLOCKED" })) : void 0;
+	}
+	async function prepare(value, context) {
+		const body = parseBody(value);
+		if (typeof body === "string") return badRequest(body);
+		const chat = await chatOf(context, body);
+		if (chat instanceof Response) return chat;
+		const model = await modelOf(context, chat, body.model);
+		if (model instanceof Response) return model;
+		const userMessage = fromUIMessage(body.message);
+		const blocked = await moderated(context, chat, userMessage);
+		if (blocked) return blocked;
+		if (options.quota) {
+			const exceeded = await options.quota(chat.organizationId);
+			if (exceeded) return problem429(exceeded);
+		}
+		const appended = await context.chats.messages.appendUser(chat.id, userMessage, {
+			...body.trigger === void 0 ? {} : { trigger: body.trigger },
+			...body.messageId === void 0 ? {} : { messageId: body.messageId }
+		});
+		if (!appended.ok) return problemResponse(appended.error);
+		const parentId = appended.data.messageId;
+		const path = await context.chats.messages.path(chat.id, {
+			leafId: parentId,
+			native: true
+		});
+		if (!path.ok) return problemResponse(path.error);
+		const repaired = new Map(repairDanglingToolCalls(pathToHistory(path.data)).map((message) => [message.id, message]));
+		const uiMessages = toUIMessages(path.data.map((stored) => stored.format === "ai-sdk-ui" ? stored : repaired.get(stored.id) ?? stored));
+		return {
+			chat,
+			model,
+			parentId,
+			uiMessages,
+			messages: await convertToModelMessages(uiMessages, { ignoreIncompleteToolCalls: true }),
+			providerOptions: gatewayOptions({
+				userId: context.userId,
+				organizationId: chat.organizationId,
+				chatId: chat.id,
+				feature: options.feature ?? "chat"
+			})
+		};
+	}
+	async function respond(request, context) {
+		const turn = await prepare(await readJson(request), context);
+		if (turn instanceof Response) return turn;
+		const { chat, model, parentId, uiMessages } = turn;
+		const streamId = newId();
+		const assistantId = newId();
+		const claim = await context.chats.runs.claim(chat.id, streamId, {
+			model,
+			messageId: assistantId
+		});
+		if (!claim.ok) return problemResponse(claim.error);
+		if (!claim.data.claimed) return problemResponse(dbError("conflict", "An answer is already being written.", { code: "AI_CHAT_BUSY" }));
+		const runId = claim.data.runId;
+		const abort = new AbortController();
+		const release = (status, usage, error) => context.chats.runs.release(chat.id, streamId, runRelease(status, usage, error));
+		let result;
+		try {
+			result = await options.run({
+				chat,
+				model,
+				messages: turn.messages,
+				uiMessages,
+				abortSignal: abort.signal,
+				providerOptions: turn.providerOptions,
+				context
+			});
+		} catch (cause) {
+			await release("failed", void 0, String(cause));
+			return problemResponse(dbError("unexpected", "The answer could not be started.", { code: "AI_CHAT_RUN_FAILED" }));
+		}
+		let finished;
+		const onEnd = (event) => {
+			finished = (async () => {
+				const stopped = event.isAborted || abort.signal.aborted;
+				const status = stopped ? "cancelled" : "completed";
+				const saved = await context.chats.messages.saveAssistant(chat.id, fromUIMessage(event.responseMessage), {
+					parentId,
+					status: stopped ? "aborted" : "complete",
+					model,
+					format: AI_SDK_UI_FORMAT,
+					native: event.responseMessage,
+					runId
+				});
+				const usage = usageOf({
+					totalUsage: await settle(result.totalUsage),
+					providerMetadata: await settle(result.providerMetadata)
+				});
+				await release(saved.ok ? status : "failed", usage, saved.ok ? void 0 : saved.error.message);
+				if (usage.costMicroUsd === void 0 && usage.generationId !== void 0 && options.enqueueCostBackfill) await options.enqueueCostBackfill({
+					generationId: usage.generationId,
+					organizationId: chat.organizationId
+				});
+				await options.onFinish?.({
+					chat,
+					message: event.responseMessage,
+					status,
+					model,
+					usage,
+					context
+				});
+			})();
+			return finished;
+		};
+		const chunks = result.toUIMessageStream({
+			originalMessages: uiMessages,
+			generateMessageId: () => assistantId,
+			onEnd,
+			...options.onError === void 0 ? {} : { onError: options.onError }
+		});
+		const teed = teeToStore(options.streams, streamId, chunks.pipeThrough(new JsonToSseTransformStream()), {
+			owner: chat.ownerId,
+			tenant: chat.organizationId,
+			kind: "chat",
+			...options.streamTtl === void 0 ? {} : { ttl: options.streamTtl },
+			onCancel: () => {
+				abort.abort();
+			}
+		});
+		context.waitUntil?.((async () => {
+			await teed.persisted;
+			await finished;
+		})());
+		return sse(teed.stream);
+	}
+	async function resume(chatId, context, resumeOptions = {}) {
+		const chat = await context.chats.chats.get(chatId);
+		if (!chat.ok) return chat.error.kind === "not_found" ? new Response(null, { status: 204 }) : problemResponse(chat.error);
+		const { activeStreamId } = chat.data;
+		if (activeStreamId === void 0) return new Response(null, { status: 204 });
+		const stream = await resumeFromStore(options.streams, activeStreamId, {
+			...resumeOptions.fromIdx === void 0 ? {} : { fromIdx: resumeOptions.fromIdx },
+			...resumeOptions.signal === void 0 ? {} : { signal: resumeOptions.signal }
+		});
+		if (!stream.ok) return problemResponse(stream.error);
+		return stream.data === void 0 ? new Response(null, { status: 204 }) : sse(stream.data);
+	}
+	async function stop(chatId, context) {
+		const stopped = await context.chats.runs.stop(chatId);
+		if (!stopped.ok) return problemResponse(stopped.error);
+		return new Response(null, { status: 204 });
+	}
+	return {
+		respond,
+		prepare,
+		resume,
+		stop
+	};
+}
+//#endregion
+export { createAssistant };

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

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

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

@@ -0,0 +1,2 @@
+import { a as supabaseEmbed, i as searchTool, n as modelName, o as toSourceParts, r as rerankWith, t as embedWith } from "../../embeddings-4ZvFzjsU.js";
+export { embedWith, modelName, rerankWith, searchTool, supabaseEmbed, toSourceParts };

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

@@ -0,0 +1,61 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "../../result-D7y2fT87.js";
+import { i as AiFilePart } from "../../message-CfDoR0Y6.js";
+import { c as AiFileSource, f as AiFiles } from "../../types-C05bxW-W.js";
+import { Experimental_DownloadFunction } from "ai";
+//#region src/ai-sdk/files/files.d.ts
+interface AiFileDownloadOptions {
+  /**
+   * How other URLs download: the SDK's `createDownload()` by default, or
+   * `false` to refuse every URL that isn't `supabase-storage://`.
+   */
+  readonly fallback?: Experimental_DownloadFunction | false;
+  readonly abortSignal?: AbortSignal;
+}
+/** Thrown by the download function, so the SDK reports a failed file part. */
+export declare class AiFileDownloadError extends Error {
+  readonly error: DbError;
+  constructor(url: URL, error: DbError);
+}
+/**
+ * The SDK's `experimental_download` for messages that hold
+ * `supabase-storage://` file URLs: it reads each file as the caller, so a
+ * user can never send a model someone else's file, and keeps the
+ * `maxBytes` limit of `createAiFiles`.
+ */
+export declare function aiFileDownload(files: AiFiles, options?: AiFileDownloadOptions): Experimental_DownloadFunction;
+/** A file a model generated: the SDK's `GeneratedFile`, typed structurally. */
+interface GeneratedFileLike {
+  readonly uint8Array: Uint8Array;
+  readonly mediaType: string;
+}
+interface SaveGeneratedOptions {
+  readonly organizationId: string;
+  readonly ownerId: string;
+  readonly chatId?: string;
+  /** The file name for the n-th file; default `generated-{n}.{ext}`. */
+  readonly filename?: (file: GeneratedFileLike, index: number) => string;
+  readonly source?: AiFileSource;
+}
+/**
+ * Stores what `generateImage`, `generateSpeech` or a model's file output
+ * returned (service role) and gives back file parts that point at them.
+ */
+export declare function saveGeneratedFiles(files: AiFiles, generated: readonly GeneratedFileLike[], options: SaveGeneratedOptions): AsyncResult<readonly AiFilePart[]>;
+interface ProviderFileUpload {
+  /** What the provider's file API returned: a file id or a file URI. */
+  readonly reference: string;
+  readonly expiresAt?: Temporal.Instant;
+}
+/**
+ * The provider's reference for a file, uploading it once with `upload`
+ * (such as the SDK's `uploadFile` or a provider client) and reusing the
+ * reference until it expires.
+ */
+export declare function providerFile(files: AiFiles, fileId: string, provider: string, upload: (file: {
+  readonly data: Uint8Array;
+  readonly mediaType: string;
+  readonly filename: string;
+}) => Promise<ProviderFileUpload>): AsyncResult<string>;
+//#endregion
+export type { AiFileDownloadOptions, GeneratedFileLike, ProviderFileUpload, SaveGeneratedOptions };