@demicodes/provider 0.1.0 → 0.2.0

package/README.md

@@ -11,9 +11,21 @@ writing providers.
   `withProviderId`.
 - **HTTP helpers** — `redactSecretText`, `httpErrorCode`, `normalizeErrorCode`,
   `providerErrorFromUnknown`, `authStatusFromKey`, `httpRequestFailedEvent`.
+- **Quota** — optional `Provider.quota` (`ProviderQuota` / `ProviderQuotaSnapshot`),
+  `createProviderQuota`, `ensureQuota`. See
+  [docs/provider-quota.md](../../docs/provider-quota.md).
+- **Credentials** — optional `Provider.credentials` for multi-account pool + global
+  `setActive` (subscription CLIs). See
+  [docs/provider-global-credentials.md](../../docs/provider-global-credentials.md).
 
 ```ts
-import { defineProvider, zeroUsage } from '@demicodes/provider'
+import {
+  defineProvider,
+  createProviderQuota,
+  ensureQuota,
+  type ProviderCredentials,
+  type ProviderQuota,
+} from '@demicodes/provider'
 ```
 
 See [Add a Provider](../../docs/guides/add-a-provider.md). Part of

package/dist/credentials-pool.d.mts

@@ -0,0 +1,66 @@
+import { d as ProviderCredentialInfo } from "./types-B6AclLz0.mjs";
+//#region src/credentials-pool.d.ts
+interface CredentialEntryMeta {
+  id: string;
+  label: string;
+  detail?: string | null;
+  updatedAt: string;
+  source?: string | null;
+  /** Stable account key for upsert on re-import (email, accountId, entryKey, …). */
+  identityKey?: string | null;
+}
+interface FileCredentialPoolOptions {
+  /** Demi state root ($DEMI_HOME / ~/.demi). */
+  stateDir?: string;
+  /** Subdir under credentials/ (e.g. codex, grok-build, claude-code). */
+  providerKey: string;
+  /** Secret filename inside each entry (auth.json, oauth.json). */
+  secretFileName: string;
+}
+/**
+ * Demi local state root (`$DEMI_HOME` / `~/.demi`). Canonical copy — host-local
+ * re-exports this for its bridge layout.
+ */
+declare function resolveDemiHome(explicit?: string): string;
+declare function credentialIdFromIdentity(identityKey: string | null | undefined, fallbackLabel: string): string;
+declare function newCredentialId(): string;
+declare class FileCredentialPool {
+  readonly root: string;
+  readonly secretFileName: string;
+  constructor(options: FileCredentialPoolOptions);
+  entriesDir(): string;
+  entryDir(id: string): string;
+  metaPath(id: string): string;
+  secretPath(id: string): string;
+  activePath(): string;
+  list(): Promise<ProviderCredentialInfo[]>;
+  listMeta(): Promise<CredentialEntryMeta[]>;
+  readMeta(id: string): Promise<CredentialEntryMeta | null>;
+  getActiveId(): Promise<string | null>;
+  setActiveId(id: string): Promise<void>;
+  clearActive(): Promise<void>;
+  writeEntry(meta: CredentialEntryMeta, secretText: string): Promise<CredentialEntryMeta>;
+  readSecretText(id: string): Promise<string>;
+  remove(id: string): Promise<void>;
+  private tmpPath;
+  /**
+   * Serializes pool mutations across processes with a create-exclusive lock
+   * file; stale locks (mtime older than 30s) are removed.
+   */
+  private withWriteLock;
+  findByIdentityKey(identityKey: string): Promise<CredentialEntryMeta | null>;
+  /** If active missing but entries exist, pick first and repair active pointer. */
+  ensureActivePointer(): Promise<string | null>;
+}
+declare class CredentialPoolError extends Error {
+  readonly code: 'credential_not_found' | 'credential_invalid';
+  constructor(code: 'credential_not_found' | 'credential_invalid', message: string);
+}
+declare function runVendorLoginCommand(command: string, args: string[], options?: {
+  signal?: AbortSignal;
+}): Promise<{
+  status: 'completed' | 'cancelled' | 'failed' | 'unavailable';
+  message?: string;
+}>;
+//#endregion
+export { CredentialEntryMeta, CredentialPoolError, FileCredentialPool, FileCredentialPoolOptions, credentialIdFromIdentity, newCredentialId, resolveDemiHome, runVendorLoginCommand };

package/dist/credentials-pool.mjs

@@ -0,0 +1,262 @@
+import { errorCode, isRecord, nonEmptyString } from "@demicodes/utils";
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+//#region src/credentials-pool.ts
+/**
+* Demi multi-credential pool on disk:
+*   <stateDir>/credentials/<providerKey>/{active,entries/<id>/{meta.json,secret}}
+*/
+/**
+* Demi local state root (`$DEMI_HOME` / `~/.demi`). Canonical copy — host-local
+* re-exports this for its bridge layout.
+*/
+function resolveDemiHome(explicit) {
+	if (explicit && explicit.trim()) return resolve(explicit.trim());
+	const fromEnv = process.env.DEMI_HOME;
+	if (fromEnv && fromEnv.trim()) return resolve(fromEnv.trim());
+	return join(homedir(), ".demi");
+}
+function credentialIdFromIdentity(identityKey, fallbackLabel) {
+	const basis = nonEmptyString(identityKey) ?? fallbackLabel;
+	return `cred-${createHash("sha256").update(basis).digest("hex").slice(0, 16)}`;
+}
+function newCredentialId() {
+	return `cred-${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+}
+var FileCredentialPool = class {
+	root;
+	secretFileName;
+	constructor(options) {
+		const stateDir = resolveDemiHome(options.stateDir);
+		this.root = join(stateDir, "credentials", options.providerKey);
+		this.secretFileName = options.secretFileName;
+	}
+	entriesDir() {
+		return join(this.root, "entries");
+	}
+	entryDir(id) {
+		return join(this.entriesDir(), id);
+	}
+	metaPath(id) {
+		return join(this.entryDir(id), "meta.json");
+	}
+	secretPath(id) {
+		return join(this.entryDir(id), this.secretFileName);
+	}
+	activePath() {
+		return join(this.root, "active");
+	}
+	async list() {
+		return (await this.listMeta()).map((m) => ({
+			id: m.id,
+			label: m.label,
+			detail: m.detail ?? null,
+			updatedAt: m.updatedAt
+		}));
+	}
+	async listMeta() {
+		let names;
+		try {
+			names = await readdir(this.entriesDir());
+		} catch {
+			return [];
+		}
+		const out = [];
+		for (const name of names) {
+			const meta = await this.readMeta(name);
+			if (meta) out.push(meta);
+		}
+		out.sort((a, b) => a.id.localeCompare(b.id));
+		return out;
+	}
+	async readMeta(id) {
+		try {
+			const raw = JSON.parse(await readFile(this.metaPath(id), "utf8"));
+			if (!isRecord(raw)) return null;
+			const entryId = nonEmptyString(raw.id) ?? id;
+			const label = nonEmptyString(raw.label);
+			if (!label) return null;
+			return {
+				id: entryId,
+				label,
+				detail: nonEmptyString(raw.detail) ?? null,
+				updatedAt: nonEmptyString(raw.updatedAt) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+				source: nonEmptyString(raw.source) ?? null,
+				identityKey: nonEmptyString(raw.identityKey) ?? null
+			};
+		} catch {
+			return null;
+		}
+	}
+	async getActiveId() {
+		try {
+			const id = (await readFile(this.activePath(), "utf8")).trim();
+			if (!id) return null;
+			return await this.readMeta(id) ? id : null;
+		} catch {
+			return null;
+		}
+	}
+	async setActiveId(id) {
+		if (!await this.readMeta(id)) throw new CredentialPoolError("credential_not_found", `Credential "${id}" not found`);
+		try {
+			await readFile(this.secretPath(id), "utf8");
+		} catch {
+			throw new CredentialPoolError("credential_not_found", `Credential "${id}" has no secret material`);
+		}
+		await this.withWriteLock(async () => {
+			const tmp = this.tmpPath(this.activePath());
+			await writeFile(tmp, `${id}\n`, { mode: 384 });
+			await rename(tmp, this.activePath());
+		});
+	}
+	async clearActive() {
+		await rm(this.activePath(), { force: true }).catch(() => void 0);
+	}
+	async writeEntry(meta, secretText) {
+		return this.withWriteLock(async () => {
+			await mkdir(this.entryDir(meta.id), {
+				recursive: true,
+				mode: 448
+			});
+			const secretTmp = this.tmpPath(this.secretPath(meta.id));
+			const metaTmp = this.tmpPath(this.metaPath(meta.id));
+			await writeFile(secretTmp, secretText, { mode: 384 });
+			await chmod(secretTmp, 384).catch(() => void 0);
+			await rename(secretTmp, this.secretPath(meta.id));
+			await writeFile(metaTmp, `${JSON.stringify(meta, null, 2)}\n`, { mode: 384 });
+			await rename(metaTmp, this.metaPath(meta.id));
+			return meta;
+		});
+	}
+	async readSecretText(id) {
+		return readFile(this.secretPath(id), "utf8");
+	}
+	async remove(id) {
+		await this.withWriteLock(async () => {
+			const active = await this.getActiveId();
+			await rm(this.entryDir(id), {
+				recursive: true,
+				force: true
+			});
+			if (active === id) await this.clearActive();
+		});
+	}
+	tmpPath(target) {
+		return `${target}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+	}
+	/**
+	* Serializes pool mutations across processes with a create-exclusive lock
+	* file; stale locks (mtime older than 30s) are removed.
+	*/
+	async withWriteLock(fn) {
+		await mkdir(this.root, {
+			recursive: true,
+			mode: 448
+		});
+		const lockPath = join(this.root, ".lock");
+		const started = Date.now();
+		while (true) try {
+			await writeFile(lockPath, `${process.pid}\n`, {
+				flag: "wx",
+				mode: 384
+			});
+			break;
+		} catch (error) {
+			if (errorCode(error) !== "EEXIST") throw error;
+			const info = await stat(lockPath).catch(() => null);
+			if (info && Date.now() - info.mtimeMs > 3e4) {
+				await rm(lockPath, { force: true }).catch(() => void 0);
+				continue;
+			}
+			if (Date.now() - started > 5e3) throw new CredentialPoolError("credential_invalid", `Timed out waiting for credential pool lock ${lockPath}`);
+			await new Promise((resolve) => setTimeout(resolve, 25));
+		}
+		try {
+			return await fn();
+		} finally {
+			await rm(lockPath, { force: true }).catch(() => void 0);
+		}
+	}
+	async findByIdentityKey(identityKey) {
+		return (await this.listMeta()).find((m) => m.identityKey === identityKey) ?? null;
+	}
+	/** If active missing but entries exist, pick first and repair active pointer. */
+	async ensureActivePointer() {
+		const active = await this.getActiveId();
+		if (active) return active;
+		const all = await this.listMeta();
+		if (all.length === 0) return null;
+		await this.setActiveId(all[0].id);
+		return all[0].id;
+	}
+};
+var CredentialPoolError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "CredentialPoolError";
+	}
+};
+async function runVendorLoginCommand(command, args, options = {}) {
+	const { spawn } = await import("node:child_process");
+	return new Promise((resolvePromise) => {
+		let child;
+		try {
+			child = spawn(command, args, {
+				stdio: "inherit",
+				env: process.env,
+				shell: false
+			});
+		} catch (error) {
+			resolvePromise({
+				status: "unavailable",
+				message: error instanceof Error ? error.message : String(error)
+			});
+			return;
+		}
+		const onAbort = () => {
+			child.kill("SIGTERM");
+		};
+		if (options.signal) {
+			if (options.signal.aborted) {
+				child.kill("SIGTERM");
+				resolvePromise({ status: "cancelled" });
+				return;
+			}
+			options.signal.addEventListener("abort", onAbort, { once: true });
+		}
+		child.on("error", (error) => {
+			options.signal?.removeEventListener("abort", onAbort);
+			const msg = error instanceof Error ? error.message : String(error);
+			if (errorCode(error) === "ENOENT") {
+				resolvePromise({
+					status: "unavailable",
+					message: `Command not found: ${command}`
+				});
+				return;
+			}
+			resolvePromise({
+				status: "failed",
+				message: msg
+			});
+		});
+		child.on("exit", (code, signal) => {
+			options.signal?.removeEventListener("abort", onAbort);
+			if (options.signal?.aborted || signal === "SIGTERM" || signal === "SIGINT") {
+				resolvePromise({ status: "cancelled" });
+				return;
+			}
+			if (code === 0) resolvePromise({ status: "completed" });
+			else resolvePromise({
+				status: "failed",
+				message: `${command} exited with code ${code ?? "null"}`
+			});
+		});
+	});
+}
+//#endregion
+export { CredentialPoolError, FileCredentialPool, credentialIdFromIdentity, newCredentialId, resolveDemiHome, runVendorLoginCommand };

package/dist/index.d.mts

@@ -1,6 +1,12 @@
-import { _ as ProviderSelection, a as ModelPolicy, c as ProviderAuthState, d as ProviderModel, f as ProviderModelCost, g as ProviderRuntimeState, h as ProviderRuntimeFactory, i as InferenceSteer, l as ProviderEvent, m as ProviderRun, n as InferenceItem, o as Provider, p as ProviderModelList, r as InferenceRequest, s as ProviderAuth, t as AgentProvider, u as ProviderFactoryDefinition, v as ProviderServiceTier, y as ToolDefinition } from "./types-CGXGUfNJ.mjs";
-import { FileExtension, ModelSelection, ThinkingCapability, ThinkingConfig } from "@demicodes/core";
-
+import { A as ProviderQuotaCapability, B as ProviderQuotaWindow, C as ProviderRuntimeState, D as CreateProviderQuotaOptions, E as ToolDefinition, F as ProviderQuotaProbeResult, G as severityFromUsedPercent, H as clampUsedPercent, I as ProviderQuotaSeverity, K as unixSecondsToIso, L as ProviderQuotaSnapshot, M as ProviderQuotaPlan, N as ProviderQuotaProbeCost, O as EnsureQuotaOptions, P as ProviderQuotaProbeOptions, R as ProviderQuotaSource, S as ProviderRuntimeFactory, T as ProviderServiceTier, U as createProviderQuota, V as ProviderQuotaWindowUnit, W as ensureQuota, _ as ProviderFactoryDefinition, a as ModelPolicy, b as ProviderModelList, c as ProviderAuthState, d as ProviderCredentialInfo, f as ProviderCredentialLoginOptions, g as ProviderEvent, h as ProviderCredentialsCapability, i as InferenceSteer, j as ProviderQuotaObserveInput, k as ProviderQuota, l as ProviderCredentialActive, m as ProviderCredentials, n as InferenceItem, o as Provider, p as ProviderCredentialLoginResult, q as usedPercentFromRatio, r as InferenceRequest, s as ProviderAuth, t as AgentProvider, u as ProviderCredentialAddInput, v as ProviderModel, w as ProviderSelection, x as ProviderRun, y as ProviderModelCost, z as ProviderQuotaUnsupportedError } from "./types-B6AclLz0.mjs";
+import { FileExtension, ModelSelection, ThinkingCapability, ThinkingConfig, ToolResultContentBlock } from "@demicodes/core";
+//#region src/content.d.ts
+/**
+ * Flattens a tool result to plain text for wire formats without native media
+ * blocks; non-text blocks become `[<type>:<mediaType>]` placeholders.
+ */
+declare function toolResultContentToText(output: ToolResultContentBlock[]): string;
+//#endregion
 //#region src/provider.d.ts
 declare function defineProvider(definition: ProviderFactoryDefinition): Provider;
 declare function providerRuntime(provider: Provider, selection: ProviderSelection): Promise<AgentProvider> | AgentProvider;
@@ -41,6 +47,8 @@ type HeadersResolver = () => Record<string, string> | Promise<Record<string, str
 declare function clampPromptCacheKey(value: string): string;
 /** Replaces every occurrence of `secret` in `value` with a redaction marker. */
 declare function redactSecretText(value: string, secret: string | null | undefined): string;
+/** Masks bearer tokens and named credential fields in free-form auth error text. */
+declare function redactCredentialText(text: string, extraFieldPatterns?: readonly string[]): string;
 /** Maps an HTTP status (and response text) to a coarse provider error code. */
 declare function httpErrorCode(status: number, message: string): string | null;
 /** Classifies a provider error code/message into a coarse category, falling back to `code`. */
@@ -51,7 +59,9 @@ declare function providerErrorFromUnknown(error: unknown, secret: string | null
 declare function authStatusFromKey(resolveKey: SecretResolver, resolveHeaders: HeadersResolver | undefined, authHeader: string, providerLabel: string): Promise<ProviderAuthState>;
 /** Parses a Retry-After header (delta-seconds or HTTP-date) into milliseconds. */
 declare function retryAfterMsFromHeader(value: string | null): number | undefined;
+/** Reads a header as a finite number, or null when absent/blank/non-numeric. */
+declare function numberHeader(headers: Headers, name: string): number | null;
 /** Builds a redacted provider `error` event from a failed HTTP response. */
 declare function httpRequestFailedEvent(response: Response, secret: string | null | undefined, providerLabel: string): Promise<ProviderEvent>;
 //#endregion
-export { AgentProvider, DEFAULT_ATTACHMENT_EXTENSIONS, InferenceItem, InferenceRequest, InferenceSteer, ModelPolicy, type ModelSelectionFromCatalogOptions, Provider, ProviderAuth, ProviderAuthState, ProviderEvent, ProviderFactoryDefinition, ProviderModel, ProviderModelCost, ProviderModelList, ProviderRun, ProviderRuntimeFactory, ProviderRuntimeState, ProviderSelection, ProviderServiceTier, ToolDefinition, applyModelPolicy, authStatusFromKey, clampPromptCacheKey, defineProvider, httpErrorCode, httpRequestFailedEvent, modelSelectionFromCatalog, normalizeErrorCode, providerErrorFromUnknown, providerRuntime, redactSecretText, retryAfterMsFromHeader, thinkingCapabilitiesFromProviderModel, withProviderId };
+export { AgentProvider, type CreateProviderQuotaOptions, DEFAULT_ATTACHMENT_EXTENSIONS, type EnsureQuotaOptions, InferenceItem, InferenceRequest, InferenceSteer, ModelPolicy, type ModelSelectionFromCatalogOptions, Provider, ProviderAuth, ProviderAuthState, ProviderCredentialActive, ProviderCredentialAddInput, ProviderCredentialInfo, ProviderCredentialLoginOptions, ProviderCredentialLoginResult, ProviderCredentials, ProviderCredentialsCapability, ProviderEvent, ProviderFactoryDefinition, ProviderModel, ProviderModelCost, ProviderModelList, type ProviderQuota, type ProviderQuotaCapability, type ProviderQuotaObserveInput, type ProviderQuotaPlan, type ProviderQuotaProbeCost, type ProviderQuotaProbeOptions, type ProviderQuotaProbeResult, type ProviderQuotaSeverity, type ProviderQuotaSnapshot, type ProviderQuotaSource, ProviderQuotaUnsupportedError, type ProviderQuotaWindow, type ProviderQuotaWindowUnit, ProviderRun, ProviderRuntimeFactory, ProviderRuntimeState, ProviderSelection, ProviderServiceTier, ToolDefinition, applyModelPolicy, authStatusFromKey, clampPromptCacheKey, clampUsedPercent, createProviderQuota, defineProvider, ensureQuota, httpErrorCode, httpRequestFailedEvent, modelSelectionFromCatalog, normalizeErrorCode, numberHeader, providerErrorFromUnknown, providerRuntime, redactCredentialText, redactSecretText, retryAfterMsFromHeader, severityFromUsedPercent, thinkingCapabilitiesFromProviderModel, toolResultContentToText, unixSecondsToIso, usedPercentFromRatio, withProviderId };

package/dist/index.mjs

@@ -1,4 +1,14 @@
+import { VIDEO_FILE_EXTENSIONS } from "@demicodes/core";
 import { shortHash } from "@demicodes/utils";
+//#region src/content.ts
+/**
+* Flattens a tool result to plain text for wire formats without native media
+* blocks; non-text blocks become `[<type>:<mediaType>]` placeholders.
+*/
+function toolResultContentToText(output) {
+	return output.map((block) => block.type === "text" ? block.text : `[${block.type}:${block.source.mediaType}]`).join("\n");
+}
+//#endregion
 //#region src/provider.ts
 const runtimeFactorySymbol = Symbol("demi.provider.runtimeFactory");
 function defineProvider(definition) {
@@ -89,7 +99,7 @@ function modelSelectionFromCatalog(providerId, model, options = {}) {
 			contextWindow: model?.contextWindow ?? 0,
 			inputLimit: null,
 			thinking: thinkingCapabilitiesFromProviderModel(model),
-			acceptedExtensions: model?.supportsAttachments ? [...accepted] : []
+			acceptedExtensions: [...model?.supportsAttachments ? accepted : [], ...model?.supportsVideo ? VIDEO_FILE_EXTENSIONS : []]
 		},
 		thinking: options.thinking ?? null,
 		serviceTierId: options.serviceTierId ?? null
@@ -108,6 +118,16 @@ function clampPromptCacheKey(value) {
 function redactSecretText(value, secret) {
 	return secret ? value.split(secret).join("[redacted]") : value;
 }
+/** Masks bearer tokens and named credential fields in free-form auth error text. */
+function redactCredentialText(text, extraFieldPatterns = []) {
+	const fields = [
+		"access_token",
+		"refresh_token",
+		"id_token",
+		...extraFieldPatterns
+	];
+	return text.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, "Bearer [REDACTED]").replace(new RegExp(`(${fields.join("|")})["'=:\\s]+[A-Za-z0-9._~+/=-]+`, "gi"), "$1=[REDACTED]");
+}
 /** Maps an HTTP status (and response text) to a coarse provider error code. */
 function httpErrorCode(status, message) {
 	if (status === 401 || status === 403) return "auth_expired";
@@ -150,6 +170,13 @@ function retryAfterMsFromHeader(value) {
 	const dateMs = Date.parse(value);
 	if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
 }
+/** Reads a header as a finite number, or null when absent/blank/non-numeric. */
+function numberHeader(headers, name) {
+	const raw = headers.get(name);
+	if (raw == null || raw === "") return null;
+	const n = Number(raw);
+	return Number.isFinite(n) ? n : null;
+}
 /** Builds a redacted provider `error` event from a failed HTTP response. */
 async function httpRequestFailedEvent(response, secret, providerLabel) {
 	const text = await response.text().catch(() => "");
@@ -164,4 +191,121 @@ async function httpRequestFailedEvent(response, secret, providerLabel) {
 	return event;
 }
 //#endregion
-export { DEFAULT_ATTACHMENT_EXTENSIONS, applyModelPolicy, authStatusFromKey, clampPromptCacheKey, defineProvider, httpErrorCode, httpRequestFailedEvent, modelSelectionFromCatalog, normalizeErrorCode, providerErrorFromUnknown, providerRuntime, redactSecretText, retryAfterMsFromHeader, thinkingCapabilitiesFromProviderModel, withProviderId };
+//#region src/quota.ts
+var ProviderQuotaUnsupportedError = class extends Error {
+	providerId;
+	constructor(providerId, message) {
+		super(message ?? `Provider "${providerId}" does not support quota probe`);
+		this.providerId = providerId;
+		this.name = "ProviderQuotaUnsupportedError";
+	}
+};
+/**
+* Return a fresh-enough snapshot: cache when valid, else probe when allowed.
+* When only observation is supported and nothing is cached yet, returns null.
+*/
+async function ensureQuota(quota, options = {}) {
+	const cap = quota.capability();
+	if (cap.mode === "none") return null;
+	const latest = quota.latest();
+	const maxStale = options.maxStaleMs ?? cap.staleAfterMs ?? 6e4;
+	if ((latest !== null && Number.isFinite(Date.parse(latest.observedAt)) ? Date.now() - Date.parse(latest.observedAt) < maxStale : false) && latest && options.prefer !== "probe") return {
+		...latest,
+		source: "cache"
+	};
+	if (cap.canProbe) return quota.probe({
+		signal: options.signal,
+		force: options.prefer === "probe"
+	});
+	return latest;
+}
+/** In-memory latest snapshot + capability wiring for concrete providers. */
+function createProviderQuota(options) {
+	let latest = null;
+	const canObserve = options.canObserve ?? Boolean(options.observe);
+	const capability = () => {
+		if (!options.canProbe && !canObserve) return { mode: "none" };
+		return {
+			mode: "supported",
+			canProbe: options.canProbe,
+			canObserve,
+			probeCost: options.probeCost,
+			staleAfterMs: options.staleAfterMs
+		};
+	};
+	const materialize = (partial, source) => {
+		const previous = source === "observation" ? latest : null;
+		const snapshot = {
+			providerId: options.providerId,
+			observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source,
+			plan: partial.plan === void 0 ? previous?.plan ?? null : partial.plan,
+			accountLabel: partial.accountLabel === void 0 ? previous?.accountLabel ?? null : partial.accountLabel,
+			windows: previous ? mergeQuotaWindows(previous.windows, partial.windows) : partial.windows,
+			raw: partial.raw
+		};
+		latest = snapshot;
+		return snapshot;
+	};
+	const quota = {
+		capability,
+		latest: () => latest,
+		clearLatest: () => {
+			latest = null;
+		},
+		async probe(probeOptions = {}) {
+			if (!options.canProbe) throw new ProviderQuotaUnsupportedError(options.providerId);
+			const partial = await options.probe(probeOptions);
+			return materialize(partial, "probe");
+		}
+	};
+	if (options.observe) {
+		const observe = options.observe;
+		quota.observeResponse = (input) => {
+			const partial = observe(input);
+			if (!partial) return null;
+			return materialize(partial, "observation");
+		};
+	}
+	return quota;
+}
+function mergeQuotaWindows(previous, observed) {
+	const observedById = new Map(observed.map((window) => [window.id, window]));
+	const merged = previous.map((window) => observedById.get(window.id) ?? window);
+	const previousIds = new Set(previous.map((window) => window.id));
+	for (const window of observed) if (!previousIds.has(window.id)) merged.push(window);
+	return merged;
+}
+/** Clamp percent into 0–100 or null. */
+function clampUsedPercent(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return null;
+	if (value < 0) return 0;
+	if (value > 100) return 100;
+	return value;
+}
+/** used/limit → percent, or null when limit is missing/zero. */
+function usedPercentFromRatio(used, limit) {
+	if (used == null || limit == null || !Number.isFinite(used) || !Number.isFinite(limit) || limit <= 0) return null;
+	return clampUsedPercent(used / limit * 100);
+}
+function unixSecondsToIso(value) {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		const ms = value > 0xe8d4a51000 ? value : value * 1e3;
+		return new Date(ms).toISOString();
+	}
+	if (typeof value === "string" && value.trim()) {
+		const asNum = Number(value);
+		if (Number.isFinite(asNum) && /^\d+(\.\d+)?$/.test(value.trim())) return unixSecondsToIso(asNum);
+		const parsed = Date.parse(value);
+		if (Number.isFinite(parsed)) return new Date(parsed).toISOString();
+	}
+	return null;
+}
+function severityFromUsedPercent(usedPercent) {
+	if (usedPercent == null) return null;
+	if (usedPercent >= 95) return "critical";
+	if (usedPercent >= 80) return "warning";
+	return "normal";
+}
+//#endregion
+export { DEFAULT_ATTACHMENT_EXTENSIONS, ProviderQuotaUnsupportedError, applyModelPolicy, authStatusFromKey, clampPromptCacheKey, clampUsedPercent, createProviderQuota, defineProvider, ensureQuota, httpErrorCode, httpRequestFailedEvent, modelSelectionFromCatalog, normalizeErrorCode, numberHeader, providerErrorFromUnknown, providerRuntime, redactCredentialText, redactSecretText, retryAfterMsFromHeader, severityFromUsedPercent, thinkingCapabilitiesFromProviderModel, toolResultContentToText, unixSecondsToIso, usedPercentFromRatio, withProviderId };

package/dist/testing.d.mts

@@ -1,5 +1,4 @@
-import { i as InferenceSteer, l as ProviderEvent, m as ProviderRun, r as InferenceRequest, t as AgentProvider } from "./types-CGXGUfNJ.mjs";
-
+import { g as ProviderEvent, i as InferenceSteer, r as InferenceRequest, t as AgentProvider, x as ProviderRun } from "./types-B6AclLz0.mjs";
 //#region src/testing.d.ts
 /**
  * Scripted provider for testing. Each "turn" is a list of events to yield.

package/dist/types-B6AclLz0.d.mts

@@ -0,0 +1,424 @@
+import { ModelSelection, ThinkingConfig, ThinkingEffort, TokenUsage, ToolResultContentBlock, UserContentBlock } from "@demicodes/core";
+//#region src/quota.d.ts
+/**
+ * Unified subscription / rate-limit quota surface for concrete providers.
+ *
+ * - One snapshot shape for all vendors (windows + optional plan).
+ * - Two fill paths: active {@link ProviderQuota.probe} and passive
+ *   {@link ProviderQuota.observeResponse} (headers / envelopes).
+ * - Products read {@link ProviderQuota.latest} or call {@link ensureQuota}.
+ */
+type ProviderQuotaWindowUnit = 'percent' | 'credits' | 'usd_minor' | 'requests' | 'tokens' | 'unknown';
+type ProviderQuotaSeverity = 'normal' | 'warning' | 'critical';
+interface ProviderQuotaWindow {
+  /** Stable id: five_hour, seven_day, primary, monthly, rpm, … */
+  id: string;
+  label?: string;
+  /** 0–100 when known. */
+  usedPercent: number | null;
+  used?: number | null;
+  limit?: number | null;
+  unit?: ProviderQuotaWindowUnit;
+  /** ISO-8601 reset time when known. */
+  resetsAt: string | null;
+  severity?: ProviderQuotaSeverity | null;
+  scope?: {
+    kind: string;
+    label?: string;
+  } | null;
+}
+interface ProviderQuotaPlan {
+  id: string | null;
+  label?: string | null;
+  raw?: string | null;
+}
+type ProviderQuotaSource = 'probe' | 'observation' | 'cache';
+interface ProviderQuotaSnapshot {
+  providerId: string;
+  observedAt: string;
+  source: ProviderQuotaSource;
+  plan?: ProviderQuotaPlan | null;
+  accountLabel?: string | null;
+  windows: ProviderQuotaWindow[];
+  /** Vendor payload for debugging; not for generic UI logic. */
+  raw?: unknown;
+}
+type ProviderQuotaProbeCost = 'free' | 'minimal_request';
+type ProviderQuotaCapability = {
+  mode: 'none';
+} | {
+  mode: 'supported';
+  canProbe: boolean;
+  canObserve: boolean;
+  /** free = dedicated usage API; minimal_request = burns a tiny inference */
+  probeCost?: ProviderQuotaProbeCost;
+  staleAfterMs?: number;
+};
+interface ProviderQuotaProbeOptions {
+  signal?: AbortSignal;
+  /** Bypass in-memory cache freshness for probe implementations that short-circuit. */
+  force?: boolean;
+}
+interface ProviderQuotaObserveInput {
+  /** HTTP response headers when the vendor exposes quota there. */
+  headers?: Headers;
+  status?: number;
+  /**
+   * Vendor-specific envelope (e.g. Claude stream-json message with `rate_limits`).
+   * Used when there is no raw HTTP Response (CLI transport).
+   */
+  body?: unknown;
+}
+interface ProviderQuota {
+  capability(): ProviderQuotaCapability;
+  probe(options?: ProviderQuotaProbeOptions): Promise<ProviderQuotaSnapshot>;
+  latest(): ProviderQuotaSnapshot | null;
+  /**
+   * Drop the in-memory latest snapshot (e.g. after credentials.setActive so the
+   * next ensureQuota/probe does not show the previous account).
+   */
+  clearLatest?(): void;
+  /**
+   * Optional passive update from a vendor HTTP response (headers, etc.).
+   * Returns the new snapshot when observation succeeded; otherwise null.
+   */
+  observeResponse?(input: ProviderQuotaObserveInput): ProviderQuotaSnapshot | null;
+}
+declare class ProviderQuotaUnsupportedError extends Error {
+  readonly providerId: string;
+  constructor(providerId: string, message?: string);
+}
+interface EnsureQuotaOptions {
+  /** Prefer a network probe even when cache is fresh. */
+  prefer?: 'probe' | 'cache';
+  /** Override capability.staleAfterMs when deciding cache freshness. */
+  maxStaleMs?: number;
+  signal?: AbortSignal;
+}
+/**
+ * Return a fresh-enough snapshot: cache when valid, else probe when allowed.
+ * When only observation is supported and nothing is cached yet, returns null.
+ */
+declare function ensureQuota(quota: ProviderQuota, options?: EnsureQuotaOptions): Promise<ProviderQuotaSnapshot | null>;
+interface CreateProviderQuotaOptions {
+  providerId: string;
+  canProbe: boolean;
+  canObserve?: boolean;
+  probeCost?: ProviderQuotaProbeCost;
+  staleAfterMs?: number;
+  /**
+   * Active fetch. Should return plan/windows/account/raw; controller fills
+   * providerId, observedAt, source.
+   */
+  probe: (options: ProviderQuotaProbeOptions) => Promise<ProviderQuotaProbeResult>;
+  /**
+   * Optional passive header/body observation. Return null when headers do not
+   * carry quota windows.
+   */
+  observe?: (input: ProviderQuotaObserveInput) => ProviderQuotaProbeResult | null;
+}
+interface ProviderQuotaProbeResult {
+  plan?: ProviderQuotaPlan | null;
+  accountLabel?: string | null;
+  windows: ProviderQuotaWindow[];
+  raw?: unknown;
+}
+/** In-memory latest snapshot + capability wiring for concrete providers. */
+declare function createProviderQuota(options: CreateProviderQuotaOptions): ProviderQuota;
+/** Clamp percent into 0–100 or null. */
+declare function clampUsedPercent(value: unknown): number | null;
+/** used/limit → percent, or null when limit is missing/zero. */
+declare function usedPercentFromRatio(used: number | null | undefined, limit: number | null | undefined): number | null;
+declare function unixSecondsToIso(value: unknown): string | null;
+declare function severityFromUsedPercent(usedPercent: number | null): ProviderQuotaSeverity | null;
+//#endregion
+//#region src/types.d.ts
+interface ToolDefinition {
+  name: string;
+  description: string;
+  /** JSON Schema describing the tool input. */
+  inputSchema: Record<string, unknown>;
+}
+type InferenceItem = {
+  type: 'user_message';
+  content: UserContentBlock[];
+} | {
+  type: 'user_steer';
+  turnId: string;
+  content: UserContentBlock[];
+} | {
+  type: 'assistant_text';
+  modelId: string;
+  text: string;
+} | {
+  type: 'assistant_thinking';
+  modelId: string;
+  text: string;
+  signature: string | null;
+} | {
+  type: 'assistant_redacted_thinking';
+  modelId: string;
+  data: string;
+} | {
+  type: 'tool_use';
+  modelId: string;
+  toolUseId: string;
+  toolName: string;
+  input: unknown;
+} | {
+  type: 'tool_result';
+  toolUseId: string;
+  output: ToolResultContentBlock[];
+  isError: boolean;
+};
+interface InferenceRequest {
+  /** Stable id for the owning agent session. */
+  sessionId: string;
+  /** Stable id for the active user/maintenance turn; shared by provider continuations inside that turn. */
+  turnId: string;
+  /** Unique id for this concrete provider request. */
+  requestId: string;
+  modelId: string;
+  systemPrompt: string;
+  cwd: string;
+  items: InferenceItem[];
+  tools: ToolDefinition[];
+  thinking: ThinkingConfig | null;
+  serviceTierId?: string | null;
+  cancel: AbortSignal;
+}
+type ProviderEvent = {
+  type: 'thinking_start';
+} | {
+  type: 'thinking_delta';
+  text: string;
+} | {
+  type: 'thinking_signature';
+  signature: string;
+} | {
+  type: 'redacted_thinking';
+  data: string;
+} | {
+  type: 'text_delta';
+  text: string;
+} | {
+  type: 'tool_call_requested';
+  toolUseId: string;
+  toolName: string;
+  input: unknown;
+} | {
+  type: 'response';
+  usage: TokenUsage;
+} | {
+  type: 'error';
+  message: string;
+  code: string | null;
+  /** Server-suggested retry delay (e.g. from a Retry-After header), if any. */
+  retryAfterMs?: number;
+} | {
+  type: 'abort';
+};
+interface InferenceSteer {
+  id: string;
+  sessionId: string;
+  turnId: string;
+  content: UserContentBlock[];
+}
+interface ProviderRun extends AsyncIterable<ProviderEvent> {
+  steer?(input: InferenceSteer): Promise<void> | void;
+}
+interface AgentProvider {
+  run(request: InferenceRequest): ProviderRun;
+  /**
+   * Releases any resources the provider holds open across turns — e.g. a long-lived CLI
+   * subprocess kept alive for a whole session. Called once when the owning session closes.
+   */
+  dispose?(): Promise<void> | void;
+}
+interface ProviderSelection {
+  providerId: string;
+  model: ModelSelection;
+}
+type ProviderAuthState = {
+  status: 'unknown';
+  message?: string;
+} | {
+  status: 'authenticated';
+  accountLabel?: string;
+} | {
+  status: 'unauthenticated';
+  message?: string;
+} | {
+  status: 'error';
+  message: string;
+};
+interface ProviderAuth {
+  status(): Promise<ProviderAuthState> | ProviderAuthState;
+}
+/** Public metadata only — never tokens, cookies, or raw auth files. */
+interface ProviderCredentialInfo {
+  /** Stable id within this provider (not globally unique across providers). */
+  id: string;
+  /** Human label: email, account id, or import tag. */
+  label: string;
+  /** Optional secondary display (plan name, issuer, …). */
+  detail?: string | null;
+  /** ISO-8601 when this entry was last imported or refreshed in the pool. */
+  updatedAt?: string | null;
+}
+interface ProviderCredentialActive {
+  credentialId: string | null;
+  /** Same shape as auth status, for the active credential. */
+  status: ProviderAuthState;
+}
+interface ProviderCredentialLoginOptions {
+  /** Abort the spawned login process. */
+  signal?: AbortSignal;
+  /** Prefer browser vs device/CLI when the vendor supports both; best-effort. */
+  preferBrowser?: boolean;
+}
+/**
+ * Login invoke result — status of the *vendor* process only, not a pool id.
+ * Demi does not complete OAuth; product should `importDefault` afterwards.
+ */
+type ProviderCredentialLoginResult = {
+  status: 'completed';
+} | {
+  status: 'cancelled';
+} | {
+  status: 'unavailable';
+  message: string;
+} | {
+  status: 'failed';
+  message: string;
+};
+/**
+ * Provider-specific add payloads. Concrete packages document accepted variants.
+ * Do not put secrets on browser-visible control protocols.
+ */
+type ProviderCredentialAddInput = {
+  [key: string]: unknown;
+};
+type ProviderCredentialsCapability = {
+  mode: 'none';
+} | {
+  mode: 'supported';
+  /** Can spawn / open vendor login (`beginLogin`). */
+  canBeginLogin?: boolean;
+  /** Can import from the vendor default location into the pool. */
+  canImportDefault?: boolean;
+  /** Can register externally supplied material (`add`). */
+  canAdd?: boolean;
+  /** Pool can hold more than one credential. */
+  multi?: boolean;
+};
+/**
+ * Multi-credential pool + process-global active switch.
+ * See `docs/provider-global-credentials.md`.
+ */
+interface ProviderCredentials {
+  capability(): ProviderCredentialsCapability;
+  list(): Promise<ProviderCredentialInfo[]> | ProviderCredentialInfo[];
+  getActive(): Promise<ProviderCredentialActive> | ProviderCredentialActive;
+  /**
+   * Make `credentialId` the process-global active credential for this provider.
+   * Subsequent auth / quota / inference use it.
+   */
+  setActive(credentialId: string): Promise<ProviderCredentialActive> | ProviderCredentialActive;
+  /**
+   * Invoke the vendor’s own login flow. Does not complete OAuth inside demi
+   * and does not return a credential id.
+   */
+  beginLogin?(options?: ProviderCredentialLoginOptions): Promise<ProviderCredentialLoginResult>;
+  /**
+   * Snapshot current vendor-default material into the demi pool.
+   * Assigns a stable `id` and returns public metadata (no secrets).
+   */
+  importDefault?(): Promise<ProviderCredentialInfo>;
+  /** Register material supplied by the product. */
+  add?(input: ProviderCredentialAddInput): Promise<ProviderCredentialInfo>;
+  /** Remove a pool entry. */
+  remove?(credentialId: string): Promise<void>;
+}
+type ProviderRuntimeState = {
+  status: 'unknown';
+  message?: string;
+} | {
+  status: 'ready';
+  message?: string;
+} | {
+  status: 'unavailable';
+  message: string;
+} | {
+  status: 'error';
+  message: string;
+};
+interface Provider {
+  id: string;
+  displayName: string;
+  auth?: ProviderAuth;
+  /** Optional subscription / rate-limit quota surface (`@demicodes/provider` quota helpers). */
+  quota?: ProviderQuota;
+  /** Optional multi-credential pool + global active switch. */
+  credentials?: ProviderCredentials;
+  state?(): Promise<ProviderRuntimeState> | ProviderRuntimeState;
+  listModels?(): Promise<ProviderModelList> | ProviderModelList;
+}
+interface ProviderRuntimeFactory {
+  createRuntime(selection: ProviderSelection): Promise<AgentProvider> | AgentProvider;
+}
+interface ProviderFactoryDefinition extends Provider {
+  createRuntime(selection: ProviderSelection): Promise<AgentProvider> | AgentProvider;
+}
+interface ProviderModelCost {
+  input: number | null;
+  output: number | null;
+  cacheRead: number | null;
+  cacheWrite: number | null;
+}
+interface ProviderServiceTier {
+  id: string;
+  label: string;
+  description?: string;
+}
+interface ProviderModel {
+  providerId: string;
+  id: string;
+  displayName: string;
+  description?: string;
+  contextWindow: number | null;
+  outputLimit: number | null;
+  supportsTools: boolean | null;
+  supportsAttachments: boolean | null;
+  /** Whether the model accepts native video input (not frame extraction). Most models
+   *  (all current Anthropic/Claude Code models) do not — their API has no video block.
+   *  Optional: unset/undefined means "no video", so existing catalogs need no change. */
+  supportsVideo?: boolean | null;
+  supportsReasoning: boolean | null;
+  supportedThinkingEfforts: ThinkingEffort[] | null;
+  defaultThinkingEffort: ThinkingEffort | null;
+  /** Whether thinking can be turned off entirely. Some transports (e.g. the Claude Code CLI, whose
+   *  `--effort` flag only accepts low|medium|high|xhigh|max) can level thinking but never disable it,
+   *  so the UI must not offer a "no reasoning" option. Defaults to true (optional) when unset. */
+  canDisableThinking?: boolean | null;
+  serviceTiers?: ProviderServiceTier[] | null;
+  defaultServiceTierId?: string | null;
+  cost?: ProviderModelCost;
+  sourceFetchedAt: string;
+  stale: boolean;
+}
+interface ProviderModelList {
+  providerId: string;
+  models: ProviderModel[];
+  defaultModelId: string | null;
+  warnings: string[];
+  sourceFetchedAt: string;
+  stale: boolean;
+}
+type ModelPolicy = {
+  include?: string[];
+  exclude?: string[];
+  default?: string;
+};
+//#endregion
+export { ProviderQuotaCapability as A, ProviderQuotaWindow as B, ProviderRuntimeState as C, CreateProviderQuotaOptions as D, ToolDefinition as E, ProviderQuotaProbeResult as F, severityFromUsedPercent as G, clampUsedPercent as H, ProviderQuotaSeverity as I, unixSecondsToIso as K, ProviderQuotaSnapshot as L, ProviderQuotaPlan as M, ProviderQuotaProbeCost as N, EnsureQuotaOptions as O, ProviderQuotaProbeOptions as P, ProviderQuotaSource as R, ProviderRuntimeFactory as S, ProviderServiceTier as T, createProviderQuota as U, ProviderQuotaWindowUnit as V, ensureQuota as W, ProviderFactoryDefinition as _, ModelPolicy as a, ProviderModelList as b, ProviderAuthState as c, ProviderCredentialInfo as d, ProviderCredentialLoginOptions as f, ProviderEvent as g, ProviderCredentialsCapability as h, InferenceSteer as i, ProviderQuotaObserveInput as j, ProviderQuota as k, ProviderCredentialActive as l, ProviderCredentials as m, InferenceItem as n, Provider as o, ProviderCredentialLoginResult as p, usedPercentFromRatio as q, InferenceRequest as r, ProviderAuth as s, AgentProvider as t, ProviderCredentialAddInput as u, ProviderModel as v, ProviderSelection as w, ProviderRun as x, ProviderModelCost as y, ProviderQuotaUnsupportedError as z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@demicodes/provider",
   "description": "Provider contract and shared building blocks for Demi inference adapters.",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -14,11 +14,16 @@
       "development": "./src/testing.ts",
       "types": "./dist/testing.d.mts",
       "import": "./dist/testing.mjs"
+    },
+    "./credentials-pool": {
+      "development": "./src/credentials-pool.ts",
+      "types": "./dist/credentials-pool.d.mts",
+      "import": "./dist/credentials-pool.mjs"
     }
   },
   "dependencies": {
-    "@demicodes/core": "workspace:*",
-    "@demicodes/utils": "workspace:*"
+    "@demicodes/core": "0.2.0",
+    "@demicodes/utils": "0.2.0"
   },
   "license": "Apache-2.0",
   "main": "./dist/index.mjs",

package/dist/types-CGXGUfNJ.d.mts

@@ -1,198 +0,0 @@
-import { ModelSelection, ThinkingConfig, ThinkingEffort, TokenUsage, ToolResultContentBlock, UserContentBlock } from "@demicodes/core";
-
-//#region src/types.d.ts
-interface ToolDefinition {
-  name: string;
-  description: string;
-  /** JSON Schema describing the tool input. */
-  inputSchema: Record<string, unknown>;
-}
-type InferenceItem = {
-  type: 'user_message';
-  content: UserContentBlock[];
-} | {
-  type: 'user_steer';
-  turnId: string;
-  content: UserContentBlock[];
-} | {
-  type: 'assistant_text';
-  modelId: string;
-  text: string;
-} | {
-  type: 'assistant_thinking';
-  modelId: string;
-  text: string;
-  signature: string | null;
-} | {
-  type: 'assistant_redacted_thinking';
-  modelId: string;
-  data: string;
-} | {
-  type: 'tool_use';
-  modelId: string;
-  toolUseId: string;
-  toolName: string;
-  input: unknown;
-} | {
-  type: 'tool_result';
-  toolUseId: string;
-  output: ToolResultContentBlock[];
-  isError: boolean;
-};
-interface InferenceRequest {
-  /** Stable id for the owning agent session. */
-  sessionId: string;
-  /** Stable id for the active user/maintenance turn; shared by provider continuations inside that turn. */
-  turnId: string;
-  /** Unique id for this concrete provider request. */
-  requestId: string;
-  modelId: string;
-  systemPrompt: string;
-  cwd: string;
-  items: InferenceItem[];
-  tools: ToolDefinition[];
-  thinking: ThinkingConfig | null;
-  serviceTierId?: string | null;
-  cancel: AbortSignal;
-}
-type ProviderEvent = {
-  type: 'thinking_start';
-} | {
-  type: 'thinking_delta';
-  text: string;
-} | {
-  type: 'thinking_signature';
-  signature: string;
-} | {
-  type: 'redacted_thinking';
-  data: string;
-} | {
-  type: 'text_delta';
-  text: string;
-} | {
-  type: 'tool_call_requested';
-  toolUseId: string;
-  toolName: string;
-  input: unknown;
-} | {
-  type: 'response';
-  usage: TokenUsage;
-} | {
-  type: 'error';
-  message: string;
-  code: string | null; /** Server-suggested retry delay (e.g. from a Retry-After header), if any. */
-  retryAfterMs?: number;
-} | {
-  type: 'abort';
-};
-interface InferenceSteer {
-  id: string;
-  sessionId: string;
-  turnId: string;
-  content: UserContentBlock[];
-}
-interface ProviderRun extends AsyncIterable<ProviderEvent> {
-  steer?(input: InferenceSteer): Promise<void> | void;
-}
-interface AgentProvider {
-  run(request: InferenceRequest): ProviderRun;
-  /**
-   * Releases any resources the provider holds open across turns — e.g. a long-lived CLI
-   * subprocess kept alive for a whole session. Called once when the owning session closes.
-   */
-  dispose?(): Promise<void> | void;
-}
-interface ProviderSelection {
-  providerId: string;
-  model: ModelSelection;
-}
-type ProviderAuthState = {
-  status: 'unknown';
-  message?: string;
-} | {
-  status: 'authenticated';
-  accountLabel?: string;
-} | {
-  status: 'unauthenticated';
-  message?: string;
-} | {
-  status: 'error';
-  message: string;
-};
-interface ProviderAuth {
-  status(): Promise<ProviderAuthState> | ProviderAuthState;
-}
-type ProviderRuntimeState = {
-  status: 'unknown';
-  message?: string;
-} | {
-  status: 'ready';
-  message?: string;
-} | {
-  status: 'unavailable';
-  message: string;
-} | {
-  status: 'error';
-  message: string;
-};
-interface Provider {
-  id: string;
-  displayName: string;
-  auth?: ProviderAuth;
-  state?(): Promise<ProviderRuntimeState> | ProviderRuntimeState;
-  listModels?(): Promise<ProviderModelList> | ProviderModelList;
-}
-interface ProviderRuntimeFactory {
-  createRuntime(selection: ProviderSelection): Promise<AgentProvider> | AgentProvider;
-}
-interface ProviderFactoryDefinition extends Provider {
-  createRuntime(selection: ProviderSelection): Promise<AgentProvider> | AgentProvider;
-}
-interface ProviderModelCost {
-  input: number | null;
-  output: number | null;
-  cacheRead: number | null;
-  cacheWrite: number | null;
-}
-interface ProviderServiceTier {
-  id: string;
-  label: string;
-  description?: string;
-}
-interface ProviderModel {
-  providerId: string;
-  id: string;
-  displayName: string;
-  description?: string;
-  contextWindow: number | null;
-  outputLimit: number | null;
-  supportsTools: boolean | null;
-  supportsAttachments: boolean | null;
-  supportsReasoning: boolean | null;
-  supportedThinkingEfforts: ThinkingEffort[] | null;
-  defaultThinkingEffort: ThinkingEffort | null;
-  /** Whether thinking can be turned off entirely. Some transports (e.g. the Claude Code CLI, whose
-   *  `--effort` flag only accepts low|medium|high|xhigh|max) can level thinking but never disable it,
-   *  so the UI must not offer a "no reasoning" option. Defaults to true (optional) when unset. */
-  canDisableThinking?: boolean | null;
-  serviceTiers?: ProviderServiceTier[] | null;
-  defaultServiceTierId?: string | null;
-  cost?: ProviderModelCost;
-  sourceFetchedAt: string;
-  stale: boolean;
-}
-interface ProviderModelList {
-  providerId: string;
-  models: ProviderModel[];
-  defaultModelId: string | null;
-  warnings: string[];
-  sourceFetchedAt: string;
-  stale: boolean;
-}
-type ModelPolicy = {
-  include?: string[];
-  exclude?: string[];
-  default?: string;
-};
-//#endregion
-export { ProviderSelection as _, ModelPolicy as a, ProviderAuthState as c, ProviderModel as d, ProviderModelCost as f, ProviderRuntimeState as g, ProviderRuntimeFactory as h, InferenceSteer as i, ProviderEvent as l, ProviderRun as m, InferenceItem as n, Provider as o, ProviderModelList as p, InferenceRequest as r, ProviderAuth as s, AgentProvider as t, ProviderFactoryDefinition as u, ProviderServiceTier as v, ToolDefinition as y };