better-supabase 0.8.0 → 0.9.0

package/dist/flags-sdk/index.js

@@ -0,0 +1,175 @@
+import { f as errorText } from "../block-helpers-CfG_MvDR.js";
+import { a as flagContext, n as createFlagsProvider, r as evaluateFlag } from "../flags-XAOsdNAc.js";
+//#region src/flags-sdk/flags-sdk.ts
+function originOf(origin, key) {
+	return typeof origin === "function" ? origin(key) : origin?.replaceAll("{key}", encodeURIComponent(key));
+}
+/** Maps Flags SDK entities to the provider's evaluation context. */
+function flagContextOf(entities) {
+	const { user, organization, ...rest } = entities ?? {};
+	const roles = organization?.roles ?? [];
+	const contexts = Object.fromEntries(Object.entries(rest).flatMap(([name, entity]) => typeof entity?.id === "string" ? [[name, entity.id]] : []));
+	return {
+		...typeof user?.id === "string" && { targetingKey: user.id },
+		...typeof organization?.id === "string" && { tenant: organization.id },
+		...organization?.plans && { plans: organization.plans },
+		...roles.length > 0 && {
+			role: roles[0],
+			roles
+		},
+		...Object.keys(contexts).length > 0 && { contexts }
+	};
+}
+/** Whether `value` fits a flag of `type`; an `object` flag holds any JSON object or list. */
+function fitsType(value, type) {
+	return type === "object" ? typeof value === "object" && value !== null : typeof value === type;
+}
+/**
+* The flag's value for a declaration with `defaultValue`, or `undefined`
+* for the fallback: a missing variant or an unknown type always falls back.
+* A `null` value is served to a declaration whose default is `null` or
+* unset. Otherwise a declaration without a default takes any value, one
+* with a `null` default a value of the flag's type, and any other default a
+* value of its own `typeof`.
+*/
+async function valueOf(flag, defaultValue, context) {
+	if (!flag || flag.invalidType !== void 0) return;
+	const { value, found } = await evaluateFlag(flag, context);
+	if (!found) return;
+	if (value === null) return defaultValue === null || defaultValue === void 0 ? { value } : void 0;
+	if (defaultValue === void 0) return { value };
+	if (defaultValue === null) return fitsType(value, flag.type) ? { value } : void 0;
+	return typeof value === typeof defaultValue ? { value } : void 0;
+}
+const why = (flag) => flag === void 0 ? "it is missing" : flag.invalidType === void 0 ? "it has no such variant or has another type" : `it has the unknown type "${flag.invalidType}"`;
+/**
+* A Flags SDK adapter over the `flags` block. It evaluates rules, overrides,
+* custom contexts and rollouts like `flag_evaluation()`, from definitions it
+* caches for `ttl`. A flag that is missing, has an unknown type, has
+* another type than the declaration or fails to load gets the declaration's
+* `defaultValue`; without one, `decide` throws. A variant whose value is
+* `null` is served to a declaration whose `defaultValue` is `null` or unset.
+*/
+function betterSupabaseAdapter(options) {
+	const provider = options.provider ?? createFlagsProvider(options);
+	const adapterId = Symbol("better-supabase");
+	const { origin } = options;
+	const fallback = (key, defaultValue, why) => {
+		if (defaultValue === void 0) throw new Error(`Flag "${key}": ${why}, and it has no defaultValue`);
+		return defaultValue;
+	};
+	const make = () => ({
+		adapterId,
+		...origin !== void 0 && { origin: (key) => originOf(origin, key) },
+		async decide({ key, entities, defaultValue }) {
+			let flags;
+			try {
+				flags = await provider.definitions();
+			} catch (error) {
+				return fallback(key, defaultValue, errorText(error));
+			}
+			const flag = flags.find((entry) => entry.key === key);
+			const served = await valueOf(flag, defaultValue, flagContextOf(entities));
+			return served === void 0 ? fallback(key, defaultValue, why(flag)) : served.value;
+		},
+		async bulkDecide({ flags, entities }) {
+			const decided = {};
+			let definitions;
+			try {
+				definitions = new Map((await provider.definitions()).map((flag) => [flag.key, flag]));
+			} catch {
+				return decided;
+			}
+			const context = flagContextOf(entities);
+			for (const { key, defaultValue } of flags) {
+				const served = await valueOf(definitions.get(key), defaultValue, context);
+				if (served !== void 0) decided[key] = served.value;
+				else if (defaultValue !== void 0) decided[key] = defaultValue;
+			}
+			return decided;
+		}
+	});
+	return Object.assign(make, {
+		provider,
+		...origin !== void 0 && { origin }
+	});
+}
+/**
+* An `identify` for `flag()` declarations, built on `flagContext()`. Wrap it
+* in the Flags SDK's `dedupe` so it runs once per request.
+*/
+function createIdentify(options) {
+	return async (request) => {
+		const claims = await options.claims(request);
+		const tenant = await options.tenant?.(request, claims);
+		const contexts = await options.contexts?.(request, claims);
+		const context = flagContext({
+			jwtClaims: claims,
+			...tenant !== void 0 && { tenant },
+			...contexts !== void 0 && { contexts }
+		}, options);
+		const roles = context.roles ?? (context.role === void 0 ? void 0 : [context.role]);
+		const named = Object.entries(context.contexts ?? {}).filter(([name]) => name !== "user" && name !== "organization");
+		return {
+			...context.targetingKey !== void 0 && { user: { id: context.targetingKey } },
+			...context.tenant !== void 0 && { organization: {
+				id: context.tenant,
+				...context.plans && { plans: context.plans },
+				...roles && { roles }
+			} },
+			...Object.fromEntries(named.map(([name, id]) => [name, { id }]))
+		};
+	};
+}
+/**
+* A flag's variants as Flags SDK `options`, labelled by variant name. A
+* precomputed flag needs them to list its permutations.
+*/
+function flagOptions(definition) {
+	return Object.entries(definition.variants).map(([label, value]) => ({
+		value,
+		label
+	}));
+}
+/**
+* Flags Explorer data for every flag that isn't archived. Pass the adapter
+* factory or `{ provider, origin }`, and combine the result with other
+* providers' data through `mergeProviderData`. A failed load becomes a hint.
+*/
+async function getProviderData(options) {
+	let flags;
+	try {
+		flags = await options.provider.definitions();
+	} catch (error) {
+		return {
+			definitions: {},
+			hints: [{
+				key: "better-supabase/load-failed",
+				text: `Could not load the flag definitions: ${errorText(error)}`
+			}]
+		};
+	}
+	const definitions = {};
+	const hints = [];
+	for (const flag of flags) {
+		if (flag.archived === true) continue;
+		if (flag.invalidType !== void 0) hints.push({
+			key: "better-supabase/invalid-type",
+			text: `Flag "${flag.key}" has the unknown type "${flag.invalidType}", so it always serves its fallback`
+		});
+		const origin = originOf(options.origin, flag.key);
+		const updatedAt = flag.updatedAt === void 0 ? NaN : Date.parse(flag.updatedAt);
+		definitions[flag.key] = {
+			options: flagOptions(flag),
+			...flag.description !== void 0 && { description: flag.description },
+			...origin !== void 0 && { origin },
+			...Number.isFinite(updatedAt) && { updatedAt }
+		};
+	}
+	return {
+		definitions,
+		hints
+	};
+}
+//#endregion
+export { betterSupabaseAdapter, createIdentify, flagContextOf, flagOptions, getProviderData };

package/dist/form-definition-sagoefQr.d.ts

@@ -0,0 +1,95 @@
+//#region src/core/contracts/form-definition.d.ts
+/**
+ * The forms block's definition format and the JSON Schema each published
+ * version gets. The SQL module embeds `FORM_DEFINITION_SCHEMA` and builds the
+ * same answer schema as `formSchema`, so the two can't drift.
+ */
+/** A JSON value in a definition or an answer. */
+type FormJson = string | number | boolean | null | readonly FormJson[] | {
+  readonly [key: string]: FormJson;
+};
+/** A JSON Schema document, as the generator writes it. */
+type FormJsonSchema = {
+  readonly [key: string]: FormJson;
+};
+type FormFieldType = "text" | "textarea" | "email" | "url" | "number" | "integer" | "date" | "bool" | "consent" | "option" | "multi" | "json";
+declare const FORM_FIELD_TYPES: readonly FormFieldType[];
+/**
+ * When a step or field shows: an earlier field's answer `equals` a value, is
+ * one of `in`, or is `filled` (present and not `null`, `""` or `[]`).
+ */
+type FormCondition = {
+  readonly field: string;
+  readonly equals: FormJson;
+} | {
+  readonly field: string;
+  readonly in: readonly FormJson[];
+} | {
+  readonly field: string;
+  readonly filled: true;
+};
+interface FormOption {
+  readonly value: string;
+  readonly label: string;
+}
+interface FormField {
+  /** The answer's key: a letter, then letters, digits or `_`. */
+  readonly key: string;
+  readonly label?: string;
+  readonly type?: FormFieldType;
+  readonly required?: boolean;
+  readonly help?: string;
+  readonly placeholder?: string;
+  /** The choices of an `option` or `multi` field. */
+  readonly options?: readonly FormOption[];
+  /** The bounds of a number, or the number of choices of a `multi` field. */
+  readonly min?: number;
+  readonly max?: number;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  readonly pattern?: string;
+  readonly showIf?: FormCondition;
+  /**
+   * A custom-fields definition id. Publishing copies its label, type,
+   * options and `required` into the field; the field's own keys win.
+   */
+  readonly customField?: string;
+}
+interface FormStep {
+  readonly key: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly showIf?: FormCondition;
+  readonly fields: readonly FormField[];
+}
+interface FormDefinition {
+  readonly steps: readonly FormStep[];
+}
+/** The dialect every generated schema declares (`SPEC_PINS.jsonSchema`). */
+declare const FORM_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+/**
+ * The shape of a definition. It uses only keywords whose meaning is the same
+ * in drafts 7 and 2020-12, because pg_jsonschema validates by draft 7 rules.
+ */
+declare const FORM_DEFINITION_SCHEMA: FormJsonSchema;
+/**
+ * The JSON Schema 2020-12 a version's submissions validate against. A
+ * required field with a `showIf` (its own or its step's) is required only
+ * while the condition holds. Like `FORM_DEFINITION_SCHEMA`, it keeps to the
+ * keywords drafts 7 and 2020-12 share.
+ */
+declare function formSchema(definition: FormDefinition): FormJsonSchema;
+/**
+ * Whether `value` has a definition's outline: steps with a key and fields
+ * with a key. `FORM_DEFINITION_SCHEMA` checks the rest.
+ */
+declare function isFormDefinition(value: unknown): value is FormDefinition;
+/**
+ * What the definition's shape can't say: duplicate keys, conditions on a
+ * field that isn't earlier in the form, a field without a label and type
+ * (and no `customField`), and a choice field without options. Empty when
+ * the definition is fine.
+ */
+declare function formDefinitionProblems(definition: FormDefinition): readonly string[];
+//#endregion
+export { FormDefinition as a, FormJson as c, FormStep as d, formDefinitionProblems as f, FormCondition as i, FormJsonSchema as l, isFormDefinition as m, FORM_FIELD_TYPES as n, FormField as o, formSchema as p, FORM_SCHEMA_DIALECT as r, FormFieldType as s, FORM_DEFINITION_SCHEMA as t, FormOption as u };

package/dist/format-CNwSjXUU.d.ts

@@ -0,0 +1,70 @@
+import { t as ApiModel } from "./model-lUafmeBQ.js";
+//#region src/spec/format.d.ts
+/** How a version of a format is supported. `preview` follows a draft and is never a default. */
+type VersionStatus = "stable" | "legacy" | "preview";
+interface FormatVersion {
+  /** The exact version or commit the output follows (a `SPEC_PINS` value). */
+  readonly pin: string;
+  readonly status: VersionStatus;
+}
+type DiagnosticSeverity = "error" | "warning" | "info";
+/**
+ * A finding from building, lowering or checking a document. `code` is
+ * stable: tools and `--fail-on` read it, and a retired code stays reserved.
+ */
+interface SpecDiagnostic {
+  readonly code: string;
+  readonly severity: DiagnosticSeverity;
+  readonly message: string;
+  /** A JSON Pointer into the document or the model, when there is one. */
+  readonly pointer?: string;
+}
+interface LowerContext {
+  /** Records a diagnostic; lowering continues. */
+  report(diagnostic: SpecDiagnostic): void;
+}
+/**
+ * The plugin contract every document format implements, the first-party
+ * ones included (API v1). `lower` is pure: it reads the model and returns a
+ * new document, so the same model renders to every version. `Docs` maps
+ * each version to its document type, so `transform` hooks can switch on the
+ * version; it defaults to `Doc` for every version.
+ */
+interface DocumentFormat<Id extends string = string, V extends string = string, Doc = unknown, Docs extends Readonly<Record<V, Doc>> = Readonly<Record<V, Doc>>> {
+  readonly apiVersion: 1;
+  readonly id: Id;
+  readonly versions: Readonly<Record<V, FormatVersion>>;
+  readonly defaultVersion: V;
+  lower(model: ApiModel, version: V, ctx: LowerContext): Doc;
+  /** Semantic checks a schema cannot express (unique ids, resolvable references). */
+  lint?(doc: Doc, version: V): readonly SpecDiagnostic[];
+  /** Default file name for a version, e.g. `openapi.json`. */
+  fileName(version: V): string;
+  /** Phantom carrying the per-version document types. */
+  readonly "~documents"?: Docs;
+}
+type AnyDocumentFormat = DocumentFormat<string, any, any, any>;
+type VersionOf<F> = F extends DocumentFormat<string, infer V> ? V : never;
+type DocumentOf<F> = F extends DocumentFormat<string, any, infer D, any> ? D : never;
+/**
+ * What a `transform` hook receives: the document with its format and
+ * version, a union discriminated by `version`.
+ */
+type RenderedOf<F> = F extends DocumentFormat<infer Id, infer V, any, infer Docs> ? { [K in V]: {
+  readonly format: Id;
+  readonly version: K;
+  readonly document: K extends keyof Docs ? Docs[K] : never;
+}; }[V] : never;
+/** Identity helper that fixes `apiVersion` and checks that the default version exists. */
+declare function defineDocumentFormat<const Id extends string, const V extends string, Doc, Docs extends Readonly<Record<V, Doc>> = Readonly<Record<V, Doc>>>(format: {
+  readonly apiVersion?: 1;
+  readonly id: Id;
+  readonly versions: Readonly<Record<V, FormatVersion>>;
+  readonly defaultVersion: NoInfer<V>;
+  lower(model: ApiModel, version: NoInfer<V>, ctx: LowerContext): Doc;
+  lint?(doc: Doc, version: NoInfer<V>): readonly SpecDiagnostic[];
+  fileName(version: NoInfer<V>): string;
+  readonly "~documents"?: Docs;
+}): DocumentFormat<Id, V, Doc, Docs>;
+//#endregion
+export { FormatVersion as a, SpecDiagnostic as c, defineDocumentFormat as d, DocumentOf as i, VersionOf as l, DiagnosticSeverity as n, LowerContext as o, DocumentFormat as r, RenderedOf as s, AnyDocumentFormat as t, VersionStatus as u };

package/dist/framework-DG5Bv39u.d.ts

@@ -0,0 +1,26 @@
+import { a as AnyModels, i as AnyFunctions } from "./types-YfwpIE-d.js";
+import { s as ServerOptions } from "./server-types-OohhIQb2.js";
+import { t as AuthSession } from "./view-Dv0A949a.js";
+import { n as SessionEntryConfig } from "./session-DiWHtYrO.js";
+import { n as BetterSupabaseContributions } from "./composite-djtGy6bz.js";
+import { t as RefusalRedirects } from "./refusal-oD3ISM9h.js";
+//#region src/server/framework.d.ts
+/** What the framework factories (`createSvelteKit`, `createReactRouter`, `createTanStackStart`) take. */
+interface FrameworkOptions extends ServerOptions, RefusalRedirects, Pick<SessionEntryConfig, "checkSession" | "cookieScopes" | "encode"> {
+  /**
+   * When the middleware refreshes an expired session cookie. Defaults to
+   * `'navigation'`: page loads, client navigations and form posts.
+   */
+  readonly refresh?: SessionEntryConfig["refresh"];
+  /** Include internal error messages in Problem Details. Defaults to development only. */
+  readonly exposeErrors?: boolean;
+  /** Keeps the invocation alive for event sink sends, e.g. the Workers `ctx.waitUntil`. */
+  readonly waitUntil?: (promise: Promise<unknown>) => void;
+}
+/** The keys the framework factories put on `locals` or `context`. */
+type FrameworkLocals<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> = BetterSupabaseContributions<M, F, E, C, P> & {
+  /** The caller as plain data, safe to return from a loader to the browser. */
+  readonly session: AuthSession<C, P>;
+};
+//#endregion
+export { FrameworkOptions as n, FrameworkLocals as t };

package/dist/framework-INbjMZX1.js

@@ -0,0 +1,51 @@
+import { n as toSession } from "./view-DZ63nqwt.js";
+import { t as withBetterSupabase } from "./composite-M6zPs1Xm.js";
+//#region src/server/framework.ts
+/** Every caller: the framework factories guard per loader, action or route instead. */
+const EVERY_CALLER = [
+	"user",
+	"anonymous",
+	"anon",
+	"service",
+	"apiKey"
+];
+/** The `withBetterSupabase` entry the framework factories run, admitting every caller. */
+function frameworkEntry(server, options, expose) {
+	return withBetterSupabase(server, {
+		refresh: options.refresh ?? "navigation",
+		allow: EVERY_CALLER,
+		expose,
+		...options.checkSession === void 0 ? {} : { checkSession: options.checkSession },
+		...options.cookieScopes === void 0 ? {} : { cookieScopes: options.cookieScopes },
+		...options.encode === void 0 ? {} : { encode: options.encode },
+		...options.waitUntil === void 0 ? {} : { waitUntil: options.waitUntil }
+	});
+}
+/** The contributions plus the serializable `session`. */
+function localsOf(contributions) {
+	const base = contributions;
+	return {
+		...base,
+		session: toSession(base.bs.auth)
+	};
+}
+function isWaitUntilHost(value) {
+	return typeof value === "object" && value !== null && "waitUntil" in value && typeof value.waitUntil === "function";
+}
+/** `platform.context.waitUntil` on Cloudflare, `platform.waitUntil` elsewhere. */
+function platformWaitUntil(platform) {
+	if (typeof platform !== "object" || platform === null) return;
+	const context = "context" in platform ? platform.context : platform;
+	if (!isWaitUntilHost(context)) return;
+	return (promise) => {
+		context.waitUntil(promise);
+	};
+}
+/** The form body as `FormData`, JSON as a value, nothing as `undefined`. */
+async function actionInput(request) {
+	const type = request.headers.get("content-type") ?? "";
+	if (type.includes("application/json")) return request.json();
+	if (type.includes("form-data") || type.includes("application/x-www-form-urlencoded")) return request.formData();
+}
+//#endregion
+export { platformWaitUntil as a, localsOf as i, actionInput as n, frameworkEntry as r, EVERY_CALLER as t };

package/dist/function-contract-B4c0XuTU.d.ts

@@ -0,0 +1,21 @@
+import { t as StandardSchemaV1 } from "./standard-C3_AAF3g.js";
+//#region src/core/function-contract.d.ts
+/** What a typed Edge Function takes and returns, as the caller sees them. */
+interface FunctionContract<In = unknown, Out = unknown> {
+  readonly input: In;
+  readonly output: Out;
+}
+/** The key `defineFunction` stores its schemas under, so `better-supabase/spec` can read them without importing `edge`. */
+declare const FUNCTION_DESCRIPTOR: unique symbol;
+/** The schemas and docs of a `defineFunction` handler, kept on the handler for spec generation. */
+interface FunctionDescriptor {
+  readonly input: StandardSchemaV1;
+  readonly output?: StandardSchemaV1;
+  readonly summary?: string;
+}
+/** A handler that carries a `FunctionDescriptor`. */
+interface DescribedFunction {
+  readonly [FUNCTION_DESCRIPTOR]: FunctionDescriptor;
+}
+//#endregion
+export { FunctionContract as n, DescribedFunction as t };

package/dist/function-contract-DmkBg19r.js

@@ -0,0 +1,5 @@
+//#region src/core/function-contract.ts
+/** The key `defineFunction` stores its schemas under, so `better-supabase/spec` can read them without importing `edge`. */
+const FUNCTION_DESCRIPTOR = Symbol.for("better-supabase.function");
+//#endregion
+export { FUNCTION_DESCRIPTOR as t };

package/dist/gateway-Cup00l0w.d.ts

@@ -0,0 +1,109 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError } from "./result-Cj3yWhjH.js";
+import { g as JobHandler } from "./types-CdP0z5tS.js";
+import { g as AiModelInput, i as AiChat } from "./ai-chat-3GBSlFR4.js";
+import { a as Usage, c as UsageEntry, h as UsageStatus } from "./usage-DM2rzczj.js";
+import { LanguageModelUsage } from "ai";
+//#region src/ai-sdk/gateway.d.ts
+/** Token counts and the gateway's cost of one generation. */
+interface AiUsage {
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly totalTokens: number;
+  readonly cachedInputTokens: number;
+  readonly reasoningTokens: number;
+  /** The gateway's generation id, for `costBackfill` when the cost isn't known yet. */
+  readonly generationId: string | undefined;
+  /** The cost in millionths of a US dollar, when the gateway reported it. */
+  readonly costMicroUsd: number | undefined;
+}
+/** What `usageOf` reads: a `streamText` or `generateText` result, awaited. */
+interface UsageSource {
+  readonly totalUsage?: Partial<LanguageModelUsage> | undefined;
+  readonly usage?: Partial<LanguageModelUsage> | undefined;
+  readonly providerMetadata?: unknown;
+}
+/** The usage of a finished generation, with the gateway's cost when it has one. */
+declare function usageOf(source: UsageSource): AiUsage;
+/** The usage meters `usageEntries` writes, by default `ai.input_tokens` and `ai.output_tokens`. */
+interface AiUsageMeters {
+  readonly input?: string;
+  readonly output?: string;
+  /** Micro-USD; left out unless named. */
+  readonly cost?: string;
+}
+/** The entries to pass to `usage.recordMany` for a generation. */
+declare function usageEntries(usage: AiUsage, meters?: AiUsageMeters): UsageEntry[];
+/**
+ * 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`.
+ */
+declare function problem429(decision: DbError | UsageStatus, now?: Temporal.Instant): Response;
+/**
+ * The quota check `createAssistant` runs before a generation: the error when
+ * `meter` has nothing left for the tenant, otherwise `undefined`.
+ */
+declare function usageQuota(usage: Pick<Usage, "current">, meter: string): (organizationId: string) => Promise<DbError | undefined>;
+/** The AI Gateway calls the job handlers make (`gateway` from `ai`). */
+interface GatewayClient {
+  getGenerationInfo(params: {
+    id: string;
+  }): PromiseLike<{
+    readonly totalCost: number;
+    readonly model?: string;
+    readonly promptTokens?: number;
+    readonly completionTokens?: number;
+  }>;
+  getAvailableModels(): PromiseLike<{
+    readonly models: readonly GatewayModelEntry[];
+  }>;
+}
+/** One model of `gateway.getAvailableModels()`. */
+interface GatewayModelEntry {
+  readonly id: string;
+  readonly name: string;
+  readonly description?: string | null;
+  readonly pricing?: Readonly<Record<string, string | undefined>> | null;
+  readonly modelType?: string | null;
+}
+/** The payload of a cost backfill job. */
+interface CostBackfillPayload {
+  readonly generationId: string;
+  /** With `usage` and `meter`, the cost is also recorded on the tenant's meter. */
+  readonly organizationId?: string;
+}
+interface CostBackfillOptions {
+  /** The chat block with a service transport. */
+  readonly chats: Pick<AiChat, "runs">;
+  readonly gateway: Pick<GatewayClient, "getGenerationInfo">;
+  readonly usage?: Pick<Usage, "record">;
+  /** The micro-USD meter, such as `ai.cost`. */
+  readonly meter?: string;
+}
+/**
+ * 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.
+ */
+declare function costBackfill(options: CostBackfillOptions): JobHandler<CostBackfillPayload>;
+interface ModelCatalogRefreshOptions {
+  /** The chat block with a service transport. */
+  readonly chats: Pick<AiChat, "models">;
+  readonly gateway: Pick<GatewayClient, "getAvailableModels">;
+  /** Keeps a model; defaults to language models. */
+  readonly filter?: (model: GatewayModelEntry) => boolean;
+  /** Plans per model id, for models only some plans may use. */
+  readonly plans?: (model: GatewayModelEntry) => readonly string[] | undefined;
+  /** Deletes catalog rows the gateway no longer lists. Defaults to false. */
+  readonly prune?: boolean;
+}
+/** The catalog row for a gateway model. */
+declare function modelInputOf(model: GatewayModelEntry, plans?: readonly string[]): AiModelInput;
+/**
+ * A job handler that copies the AI Gateway's model list into the chat
+ * block's catalog (`models.upsert`); schedule it daily.
+ */
+declare function modelCatalogRefresh(options: ModelCatalogRefreshOptions): JobHandler<unknown>;
+//#endregion
+export { GatewayClient as a, UsageSource as c, modelInputOf as d, problem429 as f, usageQuota as h, CostBackfillPayload as i, costBackfill as l, usageOf as m, AiUsageMeters as n, GatewayModelEntry as o, usageEntries as p, CostBackfillOptions as r, ModelCatalogRefreshOptions as s, AiUsage as t, modelCatalogRefresh as u };

package/dist/gateway-options-ClvvfuuU.d.ts

@@ -0,0 +1,29 @@
+import { JSONValue } from "ai";
+//#region src/ai-sdk/gateway-options.d.ts
+/** Who a generation is for, as the AI Gateway reports spend. */
+interface GatewayContext {
+  readonly userId?: string;
+  readonly organizationId?: string;
+  readonly chatId?: string;
+  /** What the generation is for, such as `chat` or `summary`. */
+  readonly feature?: string;
+  /** The app's own tags, after the tenant, chat and feature tags. */
+  readonly tags?: readonly string[];
+}
+/** The AI Gateway's own options (`providerOptions.gateway`). */
+type GatewayOptions = {
+  readonly [key: string]: JSONValue | undefined;
+};
+/**
+ * `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, then the context's own `tags`. `extra` adds gateway
+ * options such as `order` or `zeroDataRetention`; its `tags` are appended.
+ * `user` comes from `context.userId` only: an `extra.user` is dropped, so a
+ * request body or a model can't change whom the spend is attributed to.
+ */
+declare function gatewayOptions(context: GatewayContext, extra?: GatewayOptions): {
+  readonly gateway: GatewayOptions;
+};
+//#endregion
+export { GatewayOptions as n, gatewayOptions as r, GatewayContext as t };

package/dist/gateway-options-DcLcWL5_.js

@@ -0,0 +1,27 @@
+//#region src/ai-sdk/gateway-options.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, then the context's own `tags`. `extra` adds gateway
+* options such as `order` or `zeroDataRetention`; its `tags` are appended.
+* `user` comes from `context.userId` only: an `extra.user` is dropped, so a
+* request body or a model can't change whom the spend is attributed to.
+*/
+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}`);
+	if (context.tags !== void 0) tags.push(...context.tags);
+	const more = extra["tags"];
+	if (Array.isArray(more)) {
+		for (const tag of more) if (typeof tag === "string") tags.push(tag);
+	}
+	return { gateway: {
+		...Object.fromEntries(Object.entries(extra).filter(([key]) => key !== "user" && key !== "tags")),
+		...context.userId === void 0 ? {} : { user: context.userId },
+		...tags.length === 0 ? {} : { tags }
+	} };
+}
+//#endregion
+export { gatewayOptions as t };