better-supabase 0.5.1 → 0.6.0

package/dist/messages-B9-5887d.js

@@ -0,0 +1,715 @@
+import { n as dbError } from "./errors-B11Duf73.js";
+import { s as nowInstant } from "./temporal-BJGitm-h.js";
+import { a as problemResponse } from "./problem-BreOl8b8.js";
+import { d as isRecord } from "./block-helpers-DWHxHsEQ.js";
+//#region src/ai-sdk/gateway.ts
+/**
+* `providerOptions` for `streamText` and agents that attribute the spend in
+* the AI Gateway: `user` is the user id, and `tags` name the tenant, the chat
+* and the feature. `extra` adds gateway options such as `order` or
+* `zeroDataRetention`; its `tags` are appended.
+*/
+function gatewayOptions(context, extra = {}) {
+	const tags = [];
+	if (context.organizationId !== void 0) tags.push(`org:${context.organizationId}`);
+	if (context.chatId !== void 0) tags.push(`chat:${context.chatId}`);
+	if (context.feature !== void 0) tags.push(`feature:${context.feature}`);
+	const more = extra["tags"];
+	if (Array.isArray(more)) {
+		for (const tag of more) if (typeof tag === "string") tags.push(tag);
+	}
+	return { gateway: {
+		...extra,
+		...context.userId === void 0 ? {} : { user: context.userId },
+		...tags.length === 0 ? {} : { tags }
+	} };
+}
+const count = (value) => typeof value === "number" && Number.isFinite(value) ? value : 0;
+/** Parses a USD amount (`"0.00042"` or a number) into micro-USD. */
+function microUsd(value) {
+	const amount = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+	return Number.isFinite(amount) && amount >= 0 ? Math.round(amount * 1e6) : void 0;
+}
+/** The usage of a finished generation, with the gateway's cost when it has one. */
+function usageOf(source) {
+	const usage = source.totalUsage ?? source.usage ?? {};
+	const input = count(usage.inputTokens);
+	const output = count(usage.outputTokens);
+	const gateway = isRecord(source.providerMetadata) && isRecord(source.providerMetadata["gateway"]) ? source.providerMetadata["gateway"] : {};
+	const generationId = gateway["generationId"];
+	return {
+		inputTokens: input,
+		outputTokens: output,
+		totalTokens: count(usage.totalTokens) || input + output,
+		cachedInputTokens: count(usage.inputTokenDetails?.cacheReadTokens),
+		reasoningTokens: count(usage.outputTokenDetails?.reasoningTokens),
+		generationId: typeof generationId === "string" ? generationId : void 0,
+		costMicroUsd: microUsd(gateway["cost"])
+	};
+}
+/** What `runs.release` stores for a generation that ended. */
+function runRelease(status, usage, error) {
+	return {
+		status,
+		...usage === void 0 ? {} : { usage: {
+			inputTokens: usage.inputTokens,
+			outputTokens: usage.outputTokens,
+			totalTokens: usage.totalTokens,
+			cachedInputTokens: usage.cachedInputTokens,
+			reasoningTokens: usage.reasoningTokens
+		} },
+		...usage?.generationId === void 0 ? {} : { generationId: usage.generationId },
+		...usage?.costMicroUsd === void 0 ? {} : { costMicroUsd: usage.costMicroUsd },
+		...error === void 0 ? {} : { error }
+	};
+}
+/** The entries to pass to `usage.recordMany` for a generation. */
+function usageEntries(usage, meters = {}) {
+	const entries = [{
+		meter: meters.input ?? "ai.input_tokens",
+		quantity: usage.inputTokens
+	}, {
+		meter: meters.output ?? "ai.output_tokens",
+		quantity: usage.outputTokens
+	}];
+	if (meters.cost !== void 0 && usage.costMicroUsd !== void 0) entries.push({
+		meter: meters.cost,
+		quantity: usage.costMicroUsd
+	});
+	return entries.filter((entry) => (entry.quantity ?? 0) > 0);
+}
+/**
+* A 429 Problem Details response for a quota or rate limit: pass the
+* `quota_exceeded` or `rate_limited` error a block returned, or the
+* `UsageStatus` of a meter with nothing left. It carries `Retry-After`.
+*/
+function problem429(decision, now = nowInstant()) {
+	if ("kind" in decision) return problemResponse(decision);
+	const retryAfter = Math.max(1, Math.ceil(now.until(decision.resetsAt).total("seconds")));
+	return problemResponse(dbError("quota_exceeded", `The ${decision.meter} quota is used up.`, {
+		meter: decision.meter,
+		...decision.limit === void 0 ? {} : { limit: decision.limit },
+		retryAfter
+	}));
+}
+/**
+* The quota check `createAssistant` runs before a generation: the error when
+* `meter` has nothing left for the tenant, otherwise `undefined`.
+*/
+function usageQuota(usage, meter) {
+	return async (organizationId) => {
+		const status = await usage.current(organizationId, meter);
+		if (!status.ok) return status.error;
+		const { remaining, limit } = status.data;
+		if (remaining === void 0 || remaining > 0) return;
+		const retryAfter = Math.max(1, Math.ceil(nowInstant().until(status.data.resetsAt).total("seconds")));
+		return dbError("quota_exceeded", `The ${meter} quota is used up.`, {
+			meter,
+			...limit === void 0 ? {} : { limit },
+			retryAfter
+		});
+	};
+}
+/**
+* A job handler that looks up a generation's cost in the AI Gateway and
+* writes it to the run (`runs.setCost`). Enqueue it when `usageOf` found no
+* cost; it throws so the queue retries while the gateway doesn't know it yet.
+*/
+function costBackfill(options) {
+	return async (payload) => {
+		const info = await options.gateway.getGenerationInfo({ id: payload.generationId });
+		const cost = microUsd(info.totalCost) ?? 0;
+		await options.chats.runs.setCost(payload.generationId, cost, {
+			...info.promptTokens === void 0 ? {} : { inputTokens: info.promptTokens },
+			...info.completionTokens === void 0 ? {} : { outputTokens: info.completionTokens }
+		}).orThrow();
+		if (options.usage !== void 0 && options.meter !== void 0 && payload.organizationId !== void 0 && cost > 0) await options.usage.record(payload.organizationId, options.meter, {
+			quantity: cost,
+			idempotencyKey: `ai-cost:${payload.generationId}`,
+			source: "ai:gateway"
+		}).orThrow();
+		return cost;
+	};
+}
+const isLanguageModel = (model) => model.modelType === void 0 || model.modelType === null || model.modelType === "language";
+/** The catalog row for a gateway model. */
+function modelInputOf(model, plans) {
+	const pricing = {};
+	for (const [key, value] of Object.entries(model.pricing ?? {})) if (typeof value === "string") pricing[key] = value;
+	return {
+		id: model.id,
+		provider: model.id.split("/", 1)[0] ?? "gateway",
+		name: model.name,
+		pricing,
+		capabilities: {
+			...model.modelType ? { modelType: model.modelType } : {},
+			...model.description ? { description: model.description } : {}
+		},
+		...plans === void 0 ? {} : { plans }
+	};
+}
+/**
+* A job handler that copies the AI Gateway's model list into the chat
+* block's catalog (`models.upsert`); schedule it daily.
+*/
+function modelCatalogRefresh(options) {
+	const keep = options.filter ?? isLanguageModel;
+	return async () => {
+		const { models } = await options.gateway.getAvailableModels();
+		const rows = models.filter(keep).map((model) => modelInputOf(model, options.plans?.(model)));
+		return options.chats.models.upsert(rows, { prune: options.prune ?? false }).orThrow();
+	};
+}
+//#endregion
+//#region src/ai-sdk/messages.ts
+/** The `format` the chat tree stores next to an AI SDK message it keeps as is. */
+const AI_SDK_UI_FORMAT = "ai-sdk-ui";
+/** The output a denied tool call gets in the canonical history. */
+const DENIED_TOOL_OUTPUT = "The tool call was denied.";
+const meta = (value) => isRecord(value) ? { providerMetadata: value } : {};
+/** Provider metadata is an object of objects per provider; JSON values inside. */
+function isProviderMetadata(value) {
+	return isRecord(value) && Object.values(value).every(isRecord);
+}
+const isToolPart = (part) => part.type === "dynamic-tool" || part.type.startsWith("tool-");
+/** Whether `value` has the shape of an AI SDK `UIMessage`. */
+function isUIMessage(value) {
+	return isRecord(value) && typeof value["id"] === "string" && (value["role"] === "system" || value["role"] === "user" || value["role"] === "assistant") && Array.isArray(value["parts"]);
+}
+function toolParts(part) {
+	const toolName = part.type === "dynamic-tool" ? part.toolName : part.type.slice(5);
+	const parts = [{
+		type: "tool-call",
+		toolCallId: part.toolCallId,
+		toolName,
+		input: part.input ?? {},
+		...part.providerExecuted === void 0 ? {} : { providerExecuted: part.providerExecuted },
+		...meta(part.callProviderMetadata)
+	}];
+	const { approval } = part;
+	if (approval !== void 0) {
+		let state = "requested";
+		if (approval.approved === true) state = "approved";
+		else if (approval.approved === false) state = "denied";
+		parts.push({
+			type: "tool-approval",
+			toolCallId: part.toolCallId,
+			approvalId: approval.id,
+			state,
+			...approval.reason === void 0 ? {} : { reason: approval.reason }
+		});
+	}
+	const result = (output, isError, metadata) => ({
+		type: "tool-result",
+		toolCallId: part.toolCallId,
+		toolName,
+		output,
+		...isError ? { isError } : {},
+		...meta(metadata)
+	});
+	switch (part.state) {
+		case "output-available":
+			parts.push(result(part.output, false, part.resultProviderMetadata));
+			break;
+		case "output-error":
+			parts.push(result(part.errorText, true, part.resultProviderMetadata));
+			break;
+		case "output-denied":
+			parts.push(result(part.approval.reason ?? "The tool call was denied.", true));
+			break;
+		case "input-streaming":
+		case "input-available":
+		case "approval-requested":
+		case "approval-responded": break;
+		default: return part;
+	}
+	return parts;
+}
+function fromPart(part) {
+	if (isToolPart(part)) return toolParts(part);
+	switch (part.type) {
+		case "text":
+		case "reasoning": return [{
+			type: part.type,
+			text: part.text,
+			...part.state === void 0 ? {} : { state: part.state },
+			...meta(part.providerMetadata)
+		}];
+		case "file": return [{
+			type: "file",
+			mediaType: part.mediaType,
+			url: part.url,
+			...part.filename === void 0 ? {} : { filename: part.filename },
+			...meta(part.providerMetadata)
+		}];
+		case "source-url": return [{
+			type: "source",
+			sourceType: "url",
+			id: part.sourceId,
+			url: part.url,
+			...part.title === void 0 ? {} : { title: part.title },
+			...meta(part.providerMetadata)
+		}];
+		case "source-document": return [{
+			type: "source",
+			sourceType: "document",
+			id: part.sourceId,
+			title: part.title,
+			mediaType: part.mediaType,
+			...meta(part.providerMetadata)
+		}];
+		case "step-start": return [{
+			type: "step",
+			boundary: "start"
+		}];
+		case "custom": return [{
+			type: "data",
+			name: "ui.custom",
+			data: { kind: part.kind },
+			...meta(part.providerMetadata)
+		}];
+		case "reasoning-file": return [{
+			type: "data",
+			name: "ui.reasoning-file",
+			data: {
+				mediaType: part.mediaType,
+				url: part.url
+			},
+			...meta(part.providerMetadata)
+		}];
+		default:
+			if (part.type.startsWith("data-") && "data" in part) return [{
+				type: "data",
+				name: part.type.slice(5),
+				..."id" in part && typeof part.id === "string" ? { id: part.id } : {},
+				data: part.data
+			}];
+			return [];
+	}
+}
+/**
+* The canonical form of an AI SDK `UIMessage`. Tool parts become a
+* `tool-call`, then a `tool-approval` and a `tool-result` as far as the
+* call got; parts with no canonical counterpart become `data` parts named
+* `ui.<type>`.
+*/
+function fromUIMessage(message) {
+	return {
+		id: message.id,
+		role: message.role,
+		parts: message.parts.flatMap(fromPart),
+		...isRecord(message.metadata) ? { metadata: message.metadata } : {}
+	};
+}
+function toToolPart({ call, approval, result }) {
+	const base = {
+		type: `tool-${call.toolName}`,
+		toolCallId: call.toolCallId,
+		input: call.input,
+		...call.providerExecuted === void 0 ? {} : { providerExecuted: call.providerExecuted },
+		...isProviderMetadata(call.providerMetadata) ? { callProviderMetadata: call.providerMetadata } : {}
+	};
+	const reason = approval?.reason === void 0 ? {} : { reason: approval.reason };
+	if (approval?.state === "denied") return result === void 0 ? {
+		...base,
+		state: "approval-responded",
+		approval: {
+			id: approval.approvalId,
+			approved: false,
+			...reason
+		}
+	} : {
+		...base,
+		state: "output-denied",
+		approval: {
+			id: approval.approvalId,
+			approved: false,
+			...reason
+		}
+	};
+	const approved = approval?.state === "approved" ? { approval: {
+		id: approval.approvalId,
+		approved: true
+	} } : {};
+	if (result !== void 0) {
+		const resultMeta = isProviderMetadata(result.providerMetadata) ? { resultProviderMetadata: result.providerMetadata } : {};
+		if (result.isError === true) return {
+			...base,
+			...approved,
+			...resultMeta,
+			state: "output-error",
+			errorText: typeof result.output === "string" ? result.output : JSON.stringify(result.output)
+		};
+		return {
+			...base,
+			...approved,
+			...resultMeta,
+			state: "output-available",
+			output: result.output
+		};
+	}
+	if (approval?.state === "requested") return {
+		...base,
+		state: "approval-requested",
+		approval: { id: approval.approvalId }
+	};
+	if (approval?.state === "approved") return {
+		...base,
+		state: "approval-responded",
+		approval: {
+			id: approval.approvalId,
+			approved: true,
+			...reason
+		}
+	};
+	return {
+		...base,
+		state: "input-available"
+	};
+}
+function toPart(part) {
+	const providerMetadata = isProviderMetadata(part.providerMetadata) ? { providerMetadata: part.providerMetadata } : {};
+	switch (part.type) {
+		case "text":
+		case "reasoning": return {
+			type: part.type,
+			text: part.text,
+			...part.state === void 0 ? {} : { state: part.state },
+			...providerMetadata
+		};
+		case "file": return {
+			type: "file",
+			mediaType: part.mediaType,
+			url: part.url,
+			...part.filename === void 0 ? {} : { filename: part.filename },
+			...providerMetadata
+		};
+		case "source": return part.sourceType === "url" ? {
+			type: "source-url",
+			sourceId: part.id,
+			url: part.url ?? "",
+			...part.title === void 0 ? {} : { title: part.title },
+			...providerMetadata
+		} : {
+			type: "source-document",
+			sourceId: part.id,
+			mediaType: part.mediaType ?? "application/octet-stream",
+			title: part.title ?? "",
+			...providerMetadata
+		};
+		case "step": return part.boundary === "start" ? { type: "step-start" } : void 0;
+		case "data":
+			if (part.name === "ui.custom" && isRecord(part.data)) {
+				const kind = part.data["kind"];
+				return typeof kind === "string" && kind.includes(".") ? {
+					type: "custom",
+					kind,
+					...providerMetadata
+				} : void 0;
+			}
+			if (part.name === "ui.reasoning-file" && isRecord(part.data)) {
+				const { mediaType, url } = part.data;
+				return typeof mediaType === "string" && typeof url === "string" ? {
+					type: "reasoning-file",
+					mediaType,
+					url,
+					...providerMetadata
+				} : void 0;
+			}
+			return {
+				type: `data-${part.name}`,
+				...part.id === void 0 ? {} : { id: part.id },
+				data: part.data
+			};
+		case "tool-call":
+		case "tool-result":
+		case "tool-approval": return;
+		default: return part;
+	}
+}
+function render(parts, tools, into, slots) {
+	for (const part of parts) {
+		if (part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-approval") {
+			let state = tools.get(part.toolCallId);
+			if (part.type === "tool-call") {
+				state = {
+					...state,
+					call: part
+				};
+				tools.set(part.toolCallId, state);
+				if (!slots.has(part.toolCallId)) {
+					slots.set(part.toolCallId, into.length);
+					into.push(toToolPart(state));
+				}
+			} else if (state !== void 0) {
+				if (part.type === "tool-result") state.result = part;
+				else state.approval = part;
+			}
+			const slot = slots.get(part.toolCallId);
+			if (state !== void 0 && slot !== void 0) into[slot] = toToolPart(state);
+			continue;
+		}
+		const converted = toPart(part);
+		if (converted !== void 0) into.push(converted);
+	}
+}
+function nativeOf(message) {
+	const stored = message;
+	return stored.format === "ai-sdk-ui" && isUIMessage(stored.native) ? stored.native : void 0;
+}
+/**
+* The AI SDK form of a canonical message: the stored native message when the
+* tree kept one (`format: "ai-sdk-ui"`), otherwise a conversion. A `tool`
+* message becomes an assistant message.
+*/
+function toUIMessage(message) {
+	const native = nativeOf(message);
+	if (native !== void 0) return native;
+	const parts = [];
+	render(message.parts, /* @__PURE__ */ new Map(), parts, /* @__PURE__ */ new Map());
+	return {
+		id: message.id,
+		role: message.role === "tool" ? "assistant" : message.role,
+		parts,
+		...message.metadata === void 0 ? {} : { metadata: message.metadata }
+	};
+}
+/**
+* Converts a history. Tool results and approvals in later messages, such as
+* the `tool` messages of other SDKs, update the tool part of the assistant
+* message that made the call.
+*/
+function toUIMessages(messages) {
+	const out = [];
+	const tools = /* @__PURE__ */ new Map();
+	let owner;
+	for (const message of messages) {
+		const native = nativeOf(message);
+		if (native !== void 0) {
+			out.push(native);
+			owner = void 0;
+			continue;
+		}
+		if (message.role === "tool" && owner !== void 0) {
+			render(message.parts, tools, owner.parts, owner.slots);
+			continue;
+		}
+		const parts = [];
+		const slots = /* @__PURE__ */ new Map();
+		render(message.parts, tools, parts, slots);
+		out.push({
+			id: message.id,
+			role: message.role === "tool" ? "assistant" : message.role,
+			parts,
+			...message.metadata === void 0 ? {} : { metadata: message.metadata }
+		});
+		owner = message.role === "user" ? void 0 : {
+			parts,
+			slots
+		};
+	}
+	return out;
+}
+const FETCHABLE_URL = /^(?:https?|data):/u;
+function fileUrl(data) {
+	if (data instanceof URL) return data.href;
+	if (typeof data === "string") return FETCHABLE_URL.test(data) ? data : void 0;
+	if (isRecord(data) && data["type"] === "url") return fileUrl(data["url"]);
+}
+function outputOf(output) {
+	switch (output.type) {
+		case "text":
+		case "json":
+		case "content": return {
+			output: output.value,
+			isError: false
+		};
+		case "error-text":
+		case "error-json": return {
+			output: output.value,
+			isError: true
+		};
+		case "execution-denied": {
+			const reason = output.reason ?? "The tool call was denied.";
+			return {
+				output: reason,
+				isError: true,
+				denied: reason
+			};
+		}
+		default: return output;
+	}
+}
+/** Collects one turn's parts, keeping one approval part per tool call. */
+var TurnParts = class {
+	parts = [];
+	#approvalAt = /* @__PURE__ */ new Map();
+	#callOf = /* @__PURE__ */ new Map();
+	constructor(approvals) {
+		for (const approval of approvals) this.#callOf.set(approval.approvalId, approval.toolCallId);
+	}
+	approval(part) {
+		this.#callOf.set(part.approvalId, part.toolCallId);
+		const at = this.#approvalAt.get(part.toolCallId);
+		if (at === void 0) {
+			this.#approvalAt.set(part.toolCallId, this.parts.length);
+			this.parts.push(part);
+		} else this.parts[at] = part;
+	}
+	callOf(approvalId) {
+		return this.#callOf.get(approvalId);
+	}
+	result(toolCallId, toolName, output) {
+		const result = outputOf(output);
+		if (result.denied !== void 0) {
+			const at = this.#approvalAt.get(toolCallId);
+			const current = at === void 0 ? void 0 : this.parts[at];
+			this.approval({
+				type: "tool-approval",
+				toolCallId,
+				approvalId: current?.type === "tool-approval" ? current.approvalId : `approval-${toolCallId}`,
+				state: "denied",
+				reason: result.denied
+			});
+		}
+		this.parts.push({
+			type: "tool-result",
+			toolCallId,
+			toolName,
+			output: result.output,
+			...result.isError ? { isError: true } : {}
+		});
+	}
+};
+function assistantParts(message, turn) {
+	if (typeof message.content === "string") {
+		if (message.content !== "") turn.parts.push({
+			type: "text",
+			text: message.content,
+			state: "done"
+		});
+		return;
+	}
+	for (const part of message.content) switch (part.type) {
+		case "text":
+		case "reasoning":
+			turn.parts.push({
+				type: part.type,
+				text: part.text,
+				state: "done"
+			});
+			break;
+		case "file": {
+			const url = fileUrl(part.data);
+			if (url !== void 0) turn.parts.push({
+				type: "file",
+				mediaType: part.mediaType,
+				url,
+				...part.filename === void 0 ? {} : { filename: part.filename }
+			});
+			break;
+		}
+		case "reasoning-file": {
+			const url = fileUrl(part.data);
+			if (url !== void 0) turn.parts.push({
+				type: "data",
+				name: "ui.reasoning-file",
+				data: {
+					mediaType: part.mediaType,
+					url
+				}
+			});
+			break;
+		}
+		case "custom":
+			turn.parts.push({
+				type: "data",
+				name: "ui.custom",
+				data: { kind: part.kind }
+			});
+			break;
+		case "tool-call":
+			turn.parts.push({
+				type: "tool-call",
+				toolCallId: part.toolCallId,
+				toolName: part.toolName,
+				input: part.input ?? {},
+				...part.providerExecuted === void 0 ? {} : { providerExecuted: part.providerExecuted }
+			});
+			break;
+		case "tool-result":
+			turn.result(part.toolCallId, part.toolName, part.output);
+			break;
+		case "tool-approval-request":
+			turn.approval({
+				type: "tool-approval",
+				toolCallId: part.toolCallId,
+				approvalId: part.approvalId,
+				state: "requested"
+			});
+			break;
+		default: return part;
+	}
+}
+function toolMessageParts(message, turn) {
+	for (const part of message.content) switch (part.type) {
+		case "tool-result":
+			turn.result(part.toolCallId, part.toolName, part.output);
+			break;
+		case "tool-approval-response": {
+			const toolCallId = turn.callOf(part.approvalId);
+			if (toolCallId !== void 0) turn.approval({
+				type: "tool-approval",
+				toolCallId,
+				approvalId: part.approvalId,
+				state: part.approved ? "approved" : "denied",
+				...part.reason === void 0 ? {} : { reason: part.reason }
+			});
+			break;
+		}
+		default: return part;
+	}
+}
+/**
+* One answer in the canonical form, from the model messages an agent added
+* in a turn (`result.messages` after the history). Each assistant message
+* starts a step whose id is `<id>:<n>`, so saving the answer again after
+* another step updates the same message.
+*/
+function fromModelMessages(id, messages, options = {}) {
+	const approvals = options.approvals ?? [];
+	const turn = new TurnParts(approvals);
+	let step = 0;
+	for (const message of messages) if (message.role === "assistant") {
+		turn.parts.push({
+			type: "step",
+			boundary: "start",
+			stepId: `${id}:${step}`
+		});
+		step += 1;
+		assistantParts(message, turn);
+	} else if (message.role === "tool") toolMessageParts(message, turn);
+	for (const approval of approvals) turn.approval({
+		type: "tool-approval",
+		toolCallId: approval.toolCallId,
+		approvalId: approval.approvalId,
+		state: approval.state,
+		...approval.reason === void 0 ? {} : { reason: approval.reason }
+	});
+	for (const source of options.sources ?? []) turn.parts.push({
+		type: "source",
+		sourceType: source.sourceType,
+		id: source.id,
+		...source.url === void 0 ? {} : { url: source.url },
+		...source.title === void 0 ? {} : { title: source.title },
+		...source.mediaType === void 0 ? {} : { mediaType: source.mediaType },
+		...meta(source.providerMetadata)
+	});
+	return {
+		id,
+		role: "assistant",
+		parts: turn.parts
+	};
+}
+//#endregion
+export { isUIMessage as a, costBackfill as c, modelInputOf as d, problem429 as f, usageQuota as g, usageOf as h, fromUIMessage as i, gatewayOptions as l, usageEntries as m, DENIED_TOOL_OUTPUT as n, toUIMessage as o, runRelease as p, fromModelMessages as r, toUIMessages as s, AI_SDK_UI_FORMAT as t, modelCatalogRefresh as u };