better-supabase 0.5.0 → 0.6.0

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

@@ -0,0 +1,111 @@
+import { n as dbError } from "../../errors-B11Duf73.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 { r as parseAiFileUrl, t as aiFileUrl } from "../../ai-files-CSPNswUY.js";
+import { createDownload } from "ai";
+//#region src/ai-sdk/files/files.ts
+/** Thrown by the download function, so the SDK reports a failed file part. */
+var AiFileDownloadError = class extends Error {
+	error;
+	constructor(url, error) {
+		super(`Could not download ${url.href}: ${error.message}`);
+		this.name = "AiFileDownloadError";
+		this.error = error;
+	}
+};
+/**
+* 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`.
+*/
+function aiFileDownload(files, options = {}) {
+	const fallback = options.fallback ?? sdkDownload(options.abortSignal);
+	return (requests) => Promise.all(requests.map(async (request) => {
+		if (parseAiFileUrl(request.url)) {
+			const read = await files.files.resolve(request.url).andThen((file) => files.files.read(file));
+			if (!read.ok) throw new AiFileDownloadError(request.url, read.error);
+			return {
+				data: read.data.data,
+				mediaType: read.data.file.mediaType
+			};
+		}
+		if (request.isUrlSupportedByModel) return null;
+		if (fallback === false) throw new AiFileDownloadError(request.url, dbError("invalid_request", "Only supabase-storage:// URLs", { hint: "AI_FILE_URL" }));
+		const [downloaded] = await fallback([request]);
+		return downloaded ?? null;
+	}));
+}
+function sdkDownload(abortSignal) {
+	const download = createDownload();
+	return (requests) => Promise.all(requests.map((request) => download(abortSignal === void 0 ? { url: request.url } : {
+		url: request.url,
+		abortSignal
+	})));
+}
+const EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/webp": "webp",
+	"image/gif": "gif",
+	"audio/mpeg": "mp3",
+	"audio/wav": "wav",
+	"audio/ogg": "ogg",
+	"video/mp4": "mp4",
+	"application/pdf": "pdf",
+	"text/plain": "txt"
+};
+/**
+* Stores what `generateImage`, `generateSpeech` or a model's file output
+* returned (service role) and gives back file parts that point at them.
+*/
+function saveGeneratedFiles(files, generated, options) {
+	return AsyncResult.from(async () => {
+		const parts = [];
+		for (const [index, file] of generated.entries()) {
+			const filename = options.filename?.(file, index) ?? `generated-${String(index + 1)}.${EXTENSIONS[file.mediaType] ?? "bin"}`;
+			const stored = await files.files.store(options.organizationId, {
+				ownerId: options.ownerId,
+				filename,
+				mediaType: file.mediaType,
+				data: file.uint8Array,
+				source: options.source ?? "generated",
+				...options.chatId === void 0 ? {} : { chatId: options.chatId }
+			});
+			if (!stored.ok) return err(stored.error);
+			parts.push({
+				type: "file",
+				mediaType: stored.data.mediaType,
+				url: aiFileUrl(stored.data),
+				filename: stored.data.filename
+			});
+		}
+		return ok(parts);
+	});
+}
+/**
+* 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.
+*/
+function providerFile(files, fileId, provider, upload) {
+	return files.providerFiles.get(fileId, provider).andThen(async (cached) => {
+		if (cached) return ok(cached.reference);
+		const read = await files.files.read(fileId);
+		if (!read.ok) return err(read.error);
+		let uploaded;
+		try {
+			uploaded = await upload({
+				data: read.data.data,
+				mediaType: read.data.file.mediaType,
+				filename: read.data.file.filename
+			});
+		} catch (cause) {
+			return err(dbError("network", `The ${provider} upload failed: ${errorText(cause)}`, { hint: "AI_PROVIDER_FILE_UPLOAD" }));
+		}
+		const saved = await files.providerFiles.set(fileId, provider, uploaded.reference, uploaded.expiresAt);
+		return saved.ok ? ok(uploaded.reference) : err(saved.error);
+	});
+}
+//#endregion
+export { AiFileDownloadError, aiFileDownload, providerFile, saveGeneratedFiles };

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

@@ -0,0 +1,145 @@
+/// <reference lib="esnext.temporal" />
+import { b as DbError, t as AsyncResult } from "../result-D7y2fT87.js";
+import { m as JobHandler } from "../queue-CLJurhdy.js";
+import { U as AiSandboxes } from "../ai-chat-7amvXjmQ.js";
+import { p as ResolvedProviderKey, u as AiProviders } from "../types-TaiEeBGA.js";
+import { i as Usage } from "../usage-CrvrL2vw.js";
+import { _ as usageOf, a as GatewayClient, c as GatewayOptions, d as costBackfill, f as gatewayOptions, g as usageEntries, h as problem429, i as CostBackfillPayload, l as ModelCatalogRefreshOptions, m as modelInputOf, n as AiUsageMeters, o as GatewayContext, p as modelCatalogRefresh, r as CostBackfillOptions, s as GatewayModelEntry, t as AiUsage, u as UsageSource, v as usageQuota } from "../gateway-C1ssRHnf.js";
+import { a as ModelSource, c as isUIMessage, i as ModelApproval, l as toUIMessage, n as DENIED_TOOL_OUTPUT, o as fromModelMessages, r as FromModelMessagesOptions, s as fromUIMessage, t as AI_SDK_UI_FORMAT, u as toUIMessages } from "../messages-DYP0sUTe.js";
+import { Experimental_SandboxSession, Telemetry } from "ai";
+//#region src/ai-sdk/providers.d.ts
+/** The `settings` key that names the credential field, `apiKey` unless set. */
+export declare const BYOK_FIELD = "credentialField";
+/**
+ * The AI Gateway's `byok` option for a tenant's resolved keys: each key
+ * becomes `{ apiKey: token, ...settings }` under its provider, in order. A
+ * provider whose credential field isn't `apiKey` names it in the key's
+ * `settings.credentialField`.
+ */
+export declare function byokOptions(keys: readonly ResolvedProviderKey[]): GatewayOptions;
+/**
+ * `providerOptions` for a tenant's request: `gatewayOptions(context, extra)`
+ * with the tenant's own keys as `byok`, resolved through the providers block
+ * (service role) for this request only. Without keys, the gateway uses the
+ * app's credentials.
+ */
+export declare function tenantGatewayOptions(providers: Pick<AiProviders, "keys">, context: GatewayContext & {
+  readonly organizationId: string;
+}, extra?: GatewayOptions, options?: {
+  readonly providers?: readonly string[];
+  readonly signal?: AbortSignal;
+}): AsyncResult<{
+  readonly gateway: GatewayOptions;
+}>;
+interface TrackedSandboxOptions {
+  /** The ai-chat block's sandboxes, with a service transport. */
+  readonly sandboxes: Pick<AiSandboxes, "touch">;
+  /** The `ai_sandboxes` row id from `sandboxes.register`. */
+  readonly id: string;
+  /** Milliseconds between two touches. Default 30000. */
+  readonly every?: number;
+  /** The clock, for tests. */
+  readonly now?: () => number;
+}
+/**
+ * Wraps an `experimental_sandbox` session so each use marks its registry row
+ * used (`sandboxes.touch`, at most every `every` milliseconds). The idle-stop
+ * job then stops only sandboxes nobody used for their `idle_seconds`.
+ */
+export declare function trackedSandbox(session: Experimental_SandboxSession, options: TrackedSandboxOptions): Experimental_SandboxSession;
+//#endregion
+//#region src/ai-sdk/telemetry.d.ts
+/** The usage meters `meterTelemetry` writes. */
+interface TelemetryMeters {
+  /** Default `ai.input_tokens`. */
+  readonly input?: string;
+  /** Default `ai.output_tokens`. */
+  readonly output?: string;
+  /** Default `ai.embedding_tokens`. */
+  readonly embedding?: string;
+  /** Default `ai.rerank_calls`. */
+  readonly rerank?: string;
+}
+/** What `meterTelemetry` reads from the event that starts an operation. */
+interface TelemetryStart {
+  readonly callId: string;
+  readonly operationId: string;
+  readonly provider?: string;
+  readonly modelId?: string;
+  readonly functionId?: string;
+  readonly runtimeContext?: unknown;
+  readonly providerOptions?: unknown;
+}
+interface MeterTelemetryOptions {
+  /** The usage block with a service transport. */
+  readonly usage: Pick<Usage, "recordMany">;
+  /**
+   * The tenant an operation is for. Defaults to the `org:` tag `gatewayOptions`
+   * puts in `providerOptions.gateway.tags`, then `runtimeContext.organizationId`.
+   * Operations without a tenant are not metered.
+   */
+  readonly tenant?: (event: TelemetryStart) => string | undefined;
+  readonly meters?: TelemetryMeters;
+  /** The `source` of each usage row. Default `ai:telemetry`. */
+  readonly source?: string;
+  readonly onError?: (error: DbError) => void;
+}
+/** The `org:` tag of `providerOptions.gateway.tags`, then `runtimeContext.organizationId`. */
+export declare function tenantOfEvent(event: TelemetryStart): string | undefined;
+/**
+ * A telemetry integration that meters every model call on the tenant's usage
+ * meters: input and output tokens of each language model call (agent steps
+ * included), embedding tokens, and rerank calls. Register it once with
+ * `registerTelemetry(meterTelemetry({ usage }))`; each call's rows carry an
+ * idempotency key, so a retried event is counted once. Don't also record the
+ * same tokens with `usageEntries`.
+ */
+export declare function meterTelemetry(options: MeterTelemetryOptions): Telemetry;
+/** One row of `gateway.getSpendReport()` grouped by tag. */
+interface SpendReportRow {
+  readonly tag?: string;
+  readonly totalCost: number;
+  readonly requestCount?: number;
+}
+/** The AI Gateway call `spendReconciliation` makes (`gateway` from `ai`). */
+interface SpendReportClient {
+  getSpendReport(params: {
+    startDate: string;
+    endDate: string;
+    groupBy?: "tag";
+    credentialType?: "byok" | "system";
+  }): PromiseLike<{
+    readonly results: readonly SpendReportRow[];
+  }>;
+}
+interface SpendReconciliationOptions {
+  readonly gateway: SpendReportClient;
+  /** The usage block with a service transport. */
+  readonly usage: Pick<Usage, "recordMany">;
+  /** The micro-USD meter of the gateway's own figure. Default `ai.gateway_cost`. */
+  readonly meter?: string;
+  /** Only the spend the app pays (`system`) or tenants' own keys pay (`byok`). */
+  readonly credentialType?: "byok" | "system";
+  /** The clock, for tests. */
+  readonly now?: () => Temporal.Instant;
+}
+interface SpendReconciliation {
+  /** The UTC day reconciled, `YYYY-MM-DD`. */
+  readonly day: string;
+  readonly tenants: readonly {
+    readonly organizationId: string;
+    readonly costMicroUsd: number;
+    readonly requests: number;
+  }[];
+}
+/**
+ * A nightly job handler that reads the AI Gateway's spend for a UTC day
+ * (yesterday unless the payload names `day`), grouped by the `org:` tags
+ * `gatewayOptions` sets, and records each tenant's cost on `meter` once per
+ * day. Compare that meter with the per-call cost meter to find drift.
+ */
+export declare function spendReconciliation(options: SpendReconciliationOptions): JobHandler<{
+  readonly day?: string;
+} | undefined>;
+//#endregion
+export { AI_SDK_UI_FORMAT, type AiUsage, type AiUsageMeters, type CostBackfillOptions, type CostBackfillPayload, DENIED_TOOL_OUTPUT, type FromModelMessagesOptions, type GatewayClient, type GatewayContext, type GatewayModelEntry, type GatewayOptions, type MeterTelemetryOptions, type ModelApproval, type ModelCatalogRefreshOptions, type ModelSource, type SpendReconciliation, type SpendReconciliationOptions, type SpendReportClient, type SpendReportRow, type TelemetryMeters, type TelemetryStart, type TrackedSandboxOptions, type UsageSource, costBackfill, fromModelMessages, fromUIMessage, gatewayOptions, isUIMessage, modelCatalogRefresh, modelInputOf, problem429, toUIMessage, toUIMessages, usageEntries, usageOf, usageQuota };

package/dist/ai-sdk/index.js

@@ -0,0 +1,174 @@
+import { s as nowInstant } from "../temporal-BJGitm-h.js";
+import { d as isRecord } from "../block-helpers-DWHxHsEQ.js";
+import { a as isUIMessage, c as costBackfill, d as modelInputOf, f as problem429, g as usageQuota, h as usageOf, i as fromUIMessage, l as gatewayOptions, m as usageEntries, n as DENIED_TOOL_OUTPUT, o as toUIMessage, r as fromModelMessages, s as toUIMessages, t as AI_SDK_UI_FORMAT, u as modelCatalogRefresh } from "../messages-B9-5887d.js";
+//#region src/ai-sdk/providers.ts
+/** The `settings` key that names the credential field, `apiKey` unless set. */
+const BYOK_FIELD = "credentialField";
+function jsonOf(value) {
+	return JSON.parse(JSON.stringify(value ?? null));
+}
+/**
+* The AI Gateway's `byok` option for a tenant's resolved keys: each key
+* becomes `{ apiKey: token, ...settings }` under its provider, in order. A
+* provider whose credential field isn't `apiKey` names it in the key's
+* `settings.credentialField`.
+*/
+function byokOptions(keys) {
+	const byok = {};
+	for (const key of keys) {
+		const { [BYOK_FIELD]: field, ...settings } = key.settings;
+		const name = typeof field === "string" && field.length > 0 ? field : "apiKey";
+		const entry = {};
+		for (const [option, value] of Object.entries(settings)) if (value !== void 0) entry[option] = jsonOf(value);
+		entry[name] = key.token;
+		(byok[key.provider] ??= []).push(entry);
+	}
+	return Object.keys(byok).length === 0 ? {} : { byok };
+}
+/**
+* `providerOptions` for a tenant's request: `gatewayOptions(context, extra)`
+* with the tenant's own keys as `byok`, resolved through the providers block
+* (service role) for this request only. Without keys, the gateway uses the
+* app's credentials.
+*/
+function tenantGatewayOptions(providers, context, extra = {}, options = {}) {
+	return providers.keys.resolve(context.organizationId, options).map((keys) => gatewayOptions(context, {
+		...extra,
+		...byokOptions(keys)
+	}));
+}
+/**
+* Wraps an `experimental_sandbox` session so each use marks its registry row
+* used (`sandboxes.touch`, at most every `every` milliseconds). The idle-stop
+* job then stops only sandboxes nobody used for their `idle_seconds`.
+*/
+function trackedSandbox(session, options) {
+	const every = options.every ?? 3e4;
+	const now = options.now ?? Date.now;
+	let last = Number.NEGATIVE_INFINITY;
+	const touch = () => {
+		const at = now();
+		if (at - last < every) return;
+		last = at;
+		options.sandboxes.touch(options.id);
+	};
+	return new Proxy(session, { get(target, property) {
+		const value = target[property];
+		if (typeof value !== "function") return value;
+		return (...args) => {
+			touch();
+			return value.apply(target, args);
+		};
+	} });
+}
+//#endregion
+//#region src/ai-sdk/telemetry.ts
+/** The `org:` tag of `providerOptions.gateway.tags`, then `runtimeContext.organizationId`. */
+function tenantOfEvent(event) {
+	const options = event.providerOptions;
+	const tags = (isRecord(options) && isRecord(options["gateway"]) ? options["gateway"] : void 0)?.["tags"];
+	if (Array.isArray(tags)) {
+		for (const tag of tags) if (typeof tag === "string" && tag.startsWith("org:") && tag.length > 4) return tag.slice(4);
+	}
+	const context = event.runtimeContext;
+	const id = isRecord(context) ? context["organizationId"] : void 0;
+	return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+const count = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.round(value) : 0;
+/**
+* A telemetry integration that meters every model call on the tenant's usage
+* meters: input and output tokens of each language model call (agent steps
+* included), embedding tokens, and rerank calls. Register it once with
+* `registerTelemetry(meterTelemetry({ usage }))`; each call's rows carry an
+* idempotency key, so a retried event is counted once. Don't also record the
+* same tokens with `usageEntries`.
+*/
+function meterTelemetry(options) {
+	const tenants = /* @__PURE__ */ new Map();
+	const calls = /* @__PURE__ */ new Map();
+	const tenantOf = options.tenant ?? tenantOfEvent;
+	const meters = options.meters ?? {};
+	const source = options.source ?? "ai:telemetry";
+	const record = async (callId, key, entries) => {
+		const tenant = tenants.get(callId);
+		const kept = entries.filter((entry) => (entry.quantity ?? 0) > 0);
+		if (tenant === void 0 || kept.length === 0) return;
+		const saved = await options.usage.recordMany(tenant, kept, {
+			idempotencyKey: `ai-call:${key}`,
+			source
+		});
+		if (!saved.ok) options.onError?.(saved.error);
+	};
+	return {
+		onStart: (event) => {
+			const tenant = tenantOf(event);
+			if (tenant !== void 0) tenants.set(event.callId, tenant);
+		},
+		onLanguageModelCallEnd: (event) => {
+			const step = calls.get(event.callId) ?? 0;
+			calls.set(event.callId, step + 1);
+			return record(event.callId, `${event.callId}:${step}`, [{
+				meter: meters.input ?? "ai.input_tokens",
+				quantity: count(event.usage.inputTokens)
+			}, {
+				meter: meters.output ?? "ai.output_tokens",
+				quantity: count(event.usage.outputTokens)
+			}]);
+		},
+		onEmbedEnd: (event) => record(event.callId, `${event.callId}:${event.embedCallId}`, [{
+			meter: meters.embedding ?? "ai.embedding_tokens",
+			quantity: count(event.usage.tokens)
+		}]),
+		onRerankEnd: (event) => record(event.callId, `${event.callId}:rerank`, [{
+			meter: meters.rerank ?? "ai.rerank_calls",
+			quantity: 1
+		}]),
+		onEnd: (event) => {
+			tenants.delete(event.callId);
+			calls.delete(event.callId);
+		}
+	};
+}
+/**
+* A nightly job handler that reads the AI Gateway's spend for a UTC day
+* (yesterday unless the payload names `day`), grouped by the `org:` tags
+* `gatewayOptions` sets, and records each tenant's cost on `meter` once per
+* day. Compare that meter with the per-call cost meter to find drift.
+*/
+function spendReconciliation(options) {
+	const meter = options.meter ?? "ai.gateway_cost";
+	return async (payload) => {
+		const day = payload?.day ?? (options.now ?? nowInstant)().toZonedDateTimeISO("UTC").subtract({ days: 1 }).toPlainDate().toString();
+		const report = await options.gateway.getSpendReport({
+			startDate: day,
+			endDate: day,
+			groupBy: "tag",
+			...options.credentialType === void 0 ? {} : { credentialType: options.credentialType }
+		});
+		const tenants = [];
+		for (const row of report.results) {
+			if (typeof row.tag !== "string" || !row.tag.startsWith("org:")) continue;
+			const organizationId = row.tag.slice(4);
+			const costMicroUsd = Math.round(Math.max(0, row.totalCost) * 1e6);
+			tenants.push({
+				organizationId,
+				costMicroUsd,
+				requests: count(row.requestCount)
+			});
+			if (costMicroUsd === 0) continue;
+			await options.usage.recordMany(organizationId, [{
+				meter,
+				quantity: costMicroUsd
+			}], {
+				idempotencyKey: `ai-spend:${day}:${organizationId}`,
+				source: "ai:gateway-spend"
+			}).orThrow();
+		}
+		return {
+			day,
+			tenants
+		};
+	};
+}
+//#endregion
+export { AI_SDK_UI_FORMAT, BYOK_FIELD, DENIED_TOOL_OUTPUT, byokOptions, costBackfill, fromModelMessages, fromUIMessage, gatewayOptions, isUIMessage, meterTelemetry, modelCatalogRefresh, modelInputOf, problem429, spendReconciliation, tenantGatewayOptions, tenantOfEvent, toUIMessage, toUIMessages, trackedSandbox, usageEntries, usageOf, usageQuota };

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

@@ -0,0 +1,102 @@
+import { b as DbError, t as AsyncResult } from "../../result-D7y2fT87.js";
+import { i as CredentialRef, r as CredentialProvider } from "../../provider-BH5UWZJ6.js";
+import { r as ConnectorServer, s as Connectors } from "../../connectors-hkLCwyEz.js";
+import { n as VaultCredentials } from "../../vault-CSO7ss5C.js";
+import { ToolSet } from "ai";
+import { ElicitResult, ElicitationRequest, MCPClient, OAuthClientMetadata, OAuthClientProvider } from "@ai-sdk/mcp";
+//#region src/ai-sdk/mcp/mcp.d.ts
+/** The Vault ref of a user's OAuth connection to a server. */
+export declare function mcpOAuthRef(serverId: string): CredentialRef;
+interface VaultOAuthProviderOptions {
+  readonly vault: VaultCredentials;
+  readonly server: Pick<ConnectorServer, "id" | "clientMetadata" | "scopes">;
+  readonly userId: string;
+  /** The app's OAuth callback URL. */
+  readonly redirectUrl: string;
+  /** Overrides the server's `client_metadata`. */
+  readonly clientMetadata?: OAuthClientMetadata;
+}
+interface VaultOAuthProvider extends OAuthClientProvider {
+  /** Where `auth` asked to send the user, once it did. */
+  readonly authorizationUrl: URL | undefined;
+}
+/**
+ * An `OAuthClientProvider` that keeps the user's tokens, PKCE verifier and
+ * state in one per-user Vault secret, and the dynamically registered client
+ * in one secret per server.
+ */
+export declare function vaultOAuthProvider(options: VaultOAuthProviderOptions): VaultOAuthProvider;
+interface AuthorizeConnectorOptions {
+  readonly connectors: Connectors;
+  readonly vault: VaultCredentials;
+  readonly server: ConnectorServer;
+  readonly userId: string;
+  readonly redirectUrl: string;
+}
+/**
+ * Starts the user's OAuth connection to a server: `{ url }` to send them
+ * to, or `{ url: undefined }` when stored tokens still work and the grant
+ * is recorded.
+ */
+export declare function authorizeConnector(options: AuthorizeConnectorOptions): AsyncResult<{
+  readonly url: string | undefined;
+}>;
+/**
+ * Finishes the connection from the OAuth callback: checks the state,
+ * exchanges the code, keeps the tokens in Vault and records the grant.
+ */
+export declare function completeConnector(options: AuthorizeConnectorOptions & {
+  readonly callback: URL | string;
+}): AsyncResult<void>;
+interface ConnectToolsOptions {
+  /** The connectors block as the user. */
+  readonly connectors: Connectors;
+  readonly server: ConnectorServer;
+  readonly userId: string;
+  /** For `oauth` servers whose grant lives in Vault. */
+  readonly vault?: VaultCredentials;
+  /** Resolves `header` refs and grants from other providers (Vercel Connect). */
+  readonly credentials?: CredentialProvider;
+  /** The OAuth callback URL, for refreshing tokens. */
+  readonly redirectUrl?: string;
+  /** Reuses the MCP session per chat. */
+  readonly chatKey?: string;
+  /** Asks for MCP Apps and returns their app-only tools apart. */
+  readonly apps?: boolean;
+  /** Answers the server's elicitation requests; declined without one. */
+  readonly elicit?: (request: ElicitationRequest) => Promise<ElicitResult>;
+  /** Prefixes tool names, such as `github_`, so servers don't collide. */
+  readonly prefix?: string;
+}
+interface ConnectedTools {
+  readonly tools: ToolSet;
+  /** Tools only an MCP App may call; empty unless `apps`. */
+  readonly appTools: ToolSet;
+  readonly client: MCPClient;
+  readonly fingerprint: string;
+  close(): Promise<void>;
+}
+/**
+ * Connects to a server as the user and returns its tools, once the
+ * fingerprint of their definitions is approved. A changed tool list waits
+ * for an admin (`CONNECTOR_TOOLS_CHANGED`) and the client is closed. Close
+ * the client when the run ends.
+ */
+export declare function connectTools(options: ConnectToolsOptions): AsyncResult<ConnectedTools>;
+interface ConnectAllResult {
+  readonly tools: ToolSet;
+  /** The servers left out, with why. */
+  readonly skipped: readonly {
+    readonly server: ConnectorServer;
+    readonly error: DbError;
+  }[];
+  close(): Promise<void>;
+}
+/**
+ * Connects to several servers (an agent's `connectorIds`) and merges their
+ * tools, each prefixed with its server's name. A server that fails is
+ * skipped and reported, not fatal.
+ */
+export declare function connectAll(servers: readonly ConnectorServer[], options: Omit<ConnectToolsOptions, "server" | "prefix">): Promise<ConnectAllResult>;
+//#endregion
+export type { AuthorizeConnectorOptions, ConnectAllResult, ConnectToolsOptions, ConnectedTools, VaultOAuthProvider, VaultOAuthProviderOptions };