zidane 7.0.19 → 7.0.22

package/dist/{oauth-D-LZ4ic-.js → oauth-CmtlmCzi.js}

@@ -1,9 +1,11 @@
 import { u as errorMessage } from "./errors-DKiMrOKq.js";
 import { t as writeFileAtomic } from "./atomic-write-B7zr1ddF.js";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { Buffer } from "node:buffer";
-import { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 //#region src/providers/oauth-registry.ts
 /**
 * Run a canonical pi-ai `OAuthAuth.refresh` from a bare refresh token.
@@ -245,15 +247,17 @@ function credentialsFilePath() {
 * Ignored on Windows.
 */
 const CREDENTIALS_FILE_MODE = 384;
-/**
-* In-process mutex table keyed by provider id. Concurrent `resolveOAuthApiKey`
-* calls for the same provider (typical when a host fans out multiple streams
-* at once) coalesce onto a single refresh. Without this, N concurrent calls
-* each hit `getOAuthApiKey`, producing N writes to `.credentials.json` with
-* last-write-wins semantics — and, in worst-case interleaving, a corrupted
-* file.
-*/
 const refreshLocks = /* @__PURE__ */ new Map();
+const storeIds = /* @__PURE__ */ new WeakMap();
+let nextStoreId = 0;
+function identity(value) {
+	let id = storeIds.get(value);
+	if (id === void 0) {
+		id = ++nextStoreId;
+		storeIds.set(value, id);
+	}
+	return id;
+}
 /**
 * Register a custom OAuth flow with the local registry (`./oauth-registry`)
 * so lazy refresh through {@link resolveOAuthApiKey} can resolve `providerId`.
@@ -316,7 +320,9 @@ function extractRuntimeCredentials(params) {
 *      reach providers via env vars set at TUI launch (see `applyApiKeyEnv`).
 */
 function readOAuthCredentials() {
-	const path = credentialsFilePath();
+	return readOAuthCredentialsAt(credentialsFilePath());
+}
+function readOAuthCredentialsAt(path) {
 	if (!existsSync(path)) return {};
 	try {
 		const raw = readFileSync(path, "utf-8");
@@ -339,139 +345,77 @@ function readOAuthCredentials() {
 		return {};
 	}
 }
-/**
-* Cross-process lockfile parameters for the credentials read-merge-write.
-* A holder normally completes in well under a millisecond (read + JSON merge
-* + atomic write of a tiny file), so the stale threshold is generous and the
-* total wait short — on timeout we proceed without the lock rather than fail
-* the refresh (degrades to the historic last-write-wins behavior).
-*/
-const CREDENTIALS_LOCK_STALE_MS = 5e3;
-const CREDENTIALS_LOCK_RETRY_MS = 20;
-const CREDENTIALS_LOCK_MAX_WAIT_MS = 2e3;
-/** Synchronous sleep without spinning — works on Bun and Node main threads. */
-function sleepSync(ms) {
-	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-/**
-* Best-effort exclusive lock via `O_EXCL` create of `<file>.lock`. Returns
-* `true` when the lock was acquired (caller must release), `false` on
-* timeout (caller proceeds unlocked — see threshold rationale above). Locks
-* older than {@link CREDENTIALS_LOCK_STALE_MS} are treated as leftovers from
-* a crashed process and broken.
-*/
-function acquireCredentialsLock(lockPath) {
-	const deadline = Date.now() + CREDENTIALS_LOCK_MAX_WAIT_MS;
-	while (true) try {
-		writeFileSync(lockPath, String(process.pid), {
+/** Never steal a lock based on age: a suspended holder may still own it. */
+function tryAcquireLock(lockPath) {
+	const owner = `${process.pid}:${randomUUID()}`;
+	try {
+		writeFileSync(lockPath, owner, {
 			flag: "wx",
 			mode: CREDENTIALS_FILE_MODE
 		});
-		return true;
 	} catch (err) {
-		if (err.code !== "EEXIST") return false;
-		try {
-			if (Date.now() - statSync(lockPath).mtimeMs > CREDENTIALS_LOCK_STALE_MS) {
-				unlinkSync(lockPath);
-				continue;
-			}
-		} catch {}
-		if (Date.now() >= deadline) return false;
-		sleepSync(CREDENTIALS_LOCK_RETRY_MS);
+		if (err.code === "EEXIST") return void 0;
+		throw err;
 	}
+	return () => {
+		try {
+			if (readFileSync(lockPath, "utf8") === owner) unlinkSync(lockPath);
+		} catch (err) {
+			if (err.code !== "ENOENT") throw err;
+		}
+	};
 }
-function releaseCredentialsLock(lockPath) {
+/** Shared by refresh persistence and interactive credential mutations. */
+function withCredentialsLock(path, fn) {
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const deadline = Date.now() + 2e3;
+	let release = tryAcquireLock(`${path}.lock`);
+	while (!release) {
+		if (Date.now() >= deadline) throw new Error("Timed out waiting for credentials lock");
+		Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+		release = tryAcquireLock(`${path}.lock`);
+	}
 	try {
-		unlinkSync(lockPath);
-	} catch {}
-}
-/**
-* Cross-process lock parameters for the REFRESH critical section (read →
-* check expiry → refresh → persist), held per provider around file-backed
-* resolves in {@link resolveOAuthApiKey}.
-*
-* This is a different beast from the write lock above: the holder performs a
-* network call, so it can legitimately hold the lock for seconds. Hence its
-* own generous thresholds — and async waiting, because blocking the event
-* loop for a peer's refresh round-trip is not acceptable. The stakes are
-* higher too: providers with single-use rotating refresh tokens (Bolt) treat
-* a replayed token as theft and revoke the WHOLE grant, so two processes
-* refreshing the same provider concurrently don't just race a write — they
-* self-revoke. A process that loses the race re-reads under the lock, finds
-* the winner's fresh token, and skips its own refresh entirely.
-*
-* On timeout we proceed without the lock (degrades to the pre-lock racy
-* behavior) rather than fail a resolve that would probably have succeeded.
-*/
-const REFRESH_LOCK_STALE_MS = 6e4;
-const REFRESH_LOCK_RETRY_MS = 50;
-const REFRESH_LOCK_MAX_WAIT_MS = 3e4;
-function refreshLockPath(providerId) {
-	return `${credentialsFilePath()}.refresh-${providerId.replace(/[^\w.-]/g, "_")}.lock`;
+		return fn();
+	} finally {
+		release();
+	}
 }
-/** Async sibling of {@link acquireCredentialsLock} with refresh-scale thresholds. */
 async function acquireRefreshLock(lockPath) {
-	const deadline = Date.now() + REFRESH_LOCK_MAX_WAIT_MS;
-	while (true) try {
-		writeFileSync(lockPath, String(process.pid), {
-			flag: "wx",
-			mode: CREDENTIALS_FILE_MODE
-		});
-		return true;
-	} catch (err) {
-		if (err.code !== "EEXIST") return false;
-		try {
-			if (Date.now() - statSync(lockPath).mtimeMs > REFRESH_LOCK_STALE_MS) {
-				unlinkSync(lockPath);
-				continue;
-			}
-		} catch {}
-		if (Date.now() >= deadline) return false;
-		await new Promise((resolve) => setTimeout(resolve, REFRESH_LOCK_RETRY_MS));
+	mkdirSync(dirname(lockPath), {
+		recursive: true,
+		mode: 448
+	});
+	const deadline = Date.now() + 3e4;
+	while (true) {
+		const release = tryAcquireLock(lockPath);
+		if (release) return release;
+		if (Date.now() >= deadline) throw new Error("Timed out waiting for OAuth refresh lock");
+		await new Promise((resolve) => setTimeout(resolve, 50));
 	}
 }
-/**
-* Atomically write `.credentials.json` with mode 0o600.
-*
-* Writes to a sibling temp file first, then renames. `rename(2)` is atomic on
-* the same filesystem, so readers either see the old file or the new one —
-* never a half-written one. This matters when a host has multiple processes
-* pointed at the same creds file.
-*
-* Merges the incoming OAuth entries on top of the raw file contents so that
-* entries this layer doesn't manage (e.g. `kind: 'apikey'` from the TUI
-* wizard) survive an OAuth refresh cycle. Without this merge,
-* `readOAuthCredentials` filters those entries out, and a naive overwrite
-* would delete them.
-*
-* The read-merge-write runs under a best-effort cross-process lockfile
-* (`<file>.lock`) so two processes refreshing different providers at the
-* same moment can't drop each other's rotated refresh tokens. On lock
-* timeout the write proceeds unlocked (last-write-wins, the pre-lock
-* behavior) rather than failing the refresh.
-*/
+function readRawCredentials(path) {
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+	} catch {}
+	return {};
+}
+function writeCredentialPatch(path, credentials) {
+	const merged = {
+		...readRawCredentials(path),
+		...credentials
+	};
+	for (const [key, value] of Object.entries(merged)) if (value === void 0) delete merged[key];
+	writeFileAtomic(path, JSON.stringify(merged, null, 2), { mode: CREDENTIALS_FILE_MODE });
+}
+/** Incoming entries are a provider-local patch, not a read-time snapshot. */
 function writeOAuthCredentials(credentials) {
 	const path = credentialsFilePath();
-	const lockPath = `${path}.lock`;
-	const locked = acquireCredentialsLock(lockPath);
-	try {
-		let existing = {};
-		try {
-			if (existsSync(path)) {
-				const raw = readFileSync(path, "utf-8");
-				const parsed = JSON.parse(raw);
-				if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) existing = parsed;
-			}
-		} catch {}
-		const merged = {
-			...existing,
-			...credentials
-		};
-		for (const [key, value] of Object.entries(merged)) if (value === void 0) delete merged[key];
-		writeFileAtomic(path, JSON.stringify(merged, null, 2), { mode: CREDENTIALS_FILE_MODE });
-	} finally {
-		if (locked) releaseCredentialsLock(lockPath);
-	}
+	withCredentialsLock(path, () => writeCredentialPatch(path, credentials));
 }
 function credentialsFromParams(params, extraKeys = []) {
 	if (typeof params?.access !== "string" || typeof params.refresh !== "string" || typeof params.expires !== "number") return void 0;
@@ -486,95 +430,83 @@ function credentialsFromParams(params, extraKeys = []) {
 async function resolveOAuthApiKey(options, callbacks) {
 	if (typeof options.params?.apiKey === "string") return options.params.apiKey;
 	const paramsCredentials = credentialsFromParams(options.params, options.extraCredentialKeys);
-	if (paramsCredentials) return await withRefreshLock(`params:${options.providerId}`, () => resolveCredentialSource("params", paramsCredentials));
-	if (typeof options.params?.access === "string") return options.params.access;
-	const readCredentials = options.readCredentials ?? readOAuthCredentials;
-	const writeCredentials = options.writeCredentials ?? writeOAuthCredentials;
+	if (!paramsCredentials && typeof options.params?.access === "string") return options.params.access;
+	const path = resolve(credentialsFilePath());
 	const usingDefaultStore = !options.readCredentials && !options.writeCredentials;
+	const read = options.readCredentials ?? (() => readOAuthCredentialsAt(path));
+	const write = options.writeCredentials ?? ((patch) => withCredentialsLock(path, () => writeCredentialPatch(path, patch)));
 	const envValue = options.envKey ? process.env[options.envKey] : void 0;
-	if (envValue) {
-		if (!isOAuthAccessToken(envValue)) return envValue;
-		if (!readCredentials()[options.providerId]) return envValue;
-		return await withRefreshLock(`file:${options.providerId}`, () => withCrossProcessRefreshLock(async () => {
-			const allCredentials = readCredentials();
-			const stored = allCredentials[options.providerId];
-			if (!stored) return envValue;
-			return await resolveCredentialSource("file", stored, allCredentials, writeCredentials);
-		}));
+	if (!paramsCredentials && envValue && (!isOAuthAccessToken(envValue) || !read()[options.providerId])) return envValue;
+	const source = paramsCredentials ? "params" : "file";
+	const initial = paramsCredentials ?? read()[options.providerId];
+	const store = usingDefaultStore ? path : [identity(options.readCredentials ?? readOAuthCredentials), identity(options.writeCredentials ?? writeOAuthCredentials)];
+	const key = JSON.stringify([
+		source,
+		options.providerId,
+		source === "file" ? store : null,
+		initial,
+		options.forceRefresh === true,
+		options.rejectedAccess,
+		identity(options.getOAuthApiKey ?? getOAuthApiKey)
+	]);
+	let task = refreshLocks.get(key);
+	if (!task) {
+		task = run();
+		refreshLocks.set(key, task);
+		task.finally(() => refreshLocks.delete(key)).catch(() => {});
 	}
-	return await withRefreshLock(`file:${options.providerId}`, () => withCrossProcessRefreshLock(async () => {
-		const allCredentials = readCredentials();
-		const storedCredentials = allCredentials[options.providerId];
-		if (!storedCredentials) throw new Error(options.missingError);
-		return await resolveCredentialSource("file", storedCredentials, allCredentials, writeCredentials);
-	}));
-	/**
-	* Hold the per-provider cross-process lockfile across the WHOLE file-backed
-	* critical section, not just the persist. Guarding only the write (as
-	* `writeOAuthCredentials` does) still lets two processes both spend a
-	* single-use rotating refresh token — which self-revokes providers with
-	* replay-detecting rotation. See the {@link REFRESH_LOCK_STALE_MS} note.
-	*/
-	async function withCrossProcessRefreshLock(fn) {
-		if (!usingDefaultStore) return fn();
-		const lockPath = refreshLockPath(options.providerId);
-		const locked = await acquireRefreshLock(lockPath);
-		try {
-			return await fn();
-		} finally {
-			if (locked) releaseCredentialsLock(lockPath);
-		}
-	}
-	async function resolveCredentialSource(source, current, allCredentials, persistCredentials) {
-		let result;
+	const result = await task;
+	if (result.event) await callbacks?.onOAuthRefresh?.({
+		...structuredClone(result.event),
+		provider: options.provider
+	});
+	return result.apiKey;
+	async function run() {
+		const release = source === "file" && usingDefaultStore ? await acquireRefreshLock(`${path}.refresh-${encodeURIComponent(options.providerId)}.lock`) : void 0;
 		try {
-			const refreshOAuthApiKey = options.getOAuthApiKey ?? getOAuthApiKey;
-			const stillRejectedGeneration = options.rejectedAccess === void 0 || current.access === options.rejectedAccess;
-			const force = options.forceRefresh === true && stillRejectedGeneration;
-			result = await refreshOAuthApiKey(options.providerId, { [options.providerId]: current }, { force });
-		} catch (err) {
-			throw new Error(options.refreshError(errorMessage(err)));
-		}
-		if (!result) throw new Error(options.refreshError(options.missingError));
-		if (result.newCredentials !== current) {
+			const current = paramsCredentials ?? read()[options.providerId];
+			if (!current) throw new Error(options.missingError);
+			const generation = structuredClone(current);
+			let result;
+			try {
+				const stillRejected = options.rejectedAccess === void 0 || current.access === options.rejectedAccess;
+				result = await (options.getOAuthApiKey ?? getOAuthApiKey)(options.providerId, { [options.providerId]: current }, { force: options.forceRefresh === true && stillRejected });
+			} catch (err) {
+				throw new Error(options.refreshError(errorMessage(err)), { cause: err });
+			}
+			if (!result) throw new Error(options.refreshError(options.missingError));
 			const refreshed = {
-				...current,
+				...generation,
 				...result.newCredentials
 			};
-			if (source === "file" && allCredentials && persistCredentials) {
-				allCredentials[options.providerId] = refreshed;
-				persistCredentials(allCredentials);
+			if (source === "file") {
+				const persist = () => {
+					if (!isDeepStrictEqual(read()[options.providerId], generation)) throw new Error("OAuth credentials changed during refresh; retry with current credentials");
+					if (result.newCredentials !== current) {
+						const patch = { [options.providerId]: refreshed };
+						if (usingDefaultStore) writeCredentialPatch(path, patch);
+						else write(patch);
+					}
+				};
+				if (usingDefaultStore) withCredentialsLock(path, persist);
+				else persist();
 			}
-			await callbacks?.onOAuthRefresh?.({
-				provider: options.provider,
-				providerId: options.providerId,
-				source,
-				previousCredentials: { ...current },
-				credentials: { ...refreshed }
-			});
-		}
-		return result.apiKey;
-	}
-}
-/**
-* Coalesce concurrent refresh calls onto a single in-flight promise per key.
-* The key combines the source (`params` vs `file`) and provider id, so a
-* per-agent param-only refresh does not starve a separate file-backed one.
-*/
-async function withRefreshLock(key, fn) {
-	const existing = refreshLocks.get(key);
-	if (existing) return existing;
-	const task = (async () => {
-		try {
-			return await fn();
+			return {
+				apiKey: result.apiKey,
+				...result.newCredentials !== current ? { event: {
+					provider: options.provider,
+					providerId: options.providerId,
+					source,
+					previousCredentials: generation,
+					credentials: refreshed
+				} } : {}
+			};
 		} finally {
-			refreshLocks.delete(key);
+			release?.();
 		}
-	})();
-	refreshLocks.set(key, task);
-	return task;
+	}
 }
 //#endregion
-export { readOAuthCredentials as a, writeOAuthCredentials as c, getOAuthProvider as d, refreshAnthropicToken as f, isOAuthAccessToken as i, ensureBundledOAuthFlows as l, registerOAuthProvider as m, credentialsFromParams as n, registerCustomOAuthProvider as o, refreshOpenAICodexToken as p, extractRuntimeCredentials as r, resolveOAuthApiKey as s, credentialsFilePath as t, getOAuthApiKey as u };
+export { readOAuthCredentials as a, withCredentialsLock as c, getOAuthApiKey as d, getOAuthProvider as f, registerOAuthProvider as h, isOAuthAccessToken as i, writeOAuthCredentials as l, refreshOpenAICodexToken as m, credentialsFromParams as n, registerCustomOAuthProvider as o, refreshAnthropicToken as p, extractRuntimeCredentials as r, resolveOAuthApiKey as s, credentialsFilePath as t, ensureBundledOAuthFlows as u };
 
-//# sourceMappingURL=oauth-D-LZ4ic-.js.map
+//# sourceMappingURL=oauth-CmtlmCzi.js.map

package/dist/oauth-CmtlmCzi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth-CmtlmCzi.js","names":[],"sources":["../src/providers/oauth-registry.ts","../src/providers/oauth.ts"],"sourcesContent":["/**\n * Local OAuth provider registry.\n *\n * pi-ai 0.80.8 removed its global OAuth registry (`registerOAuthProvider`,\n * `getOAuthApiKey`, `OAuthProviderInterface`) and the public low-level\n * refresh helpers in favor of canonical `Provider.auth.oauth` objects\n * resolved through a `Models` collection + `CredentialStore`. zidane's\n * credential architecture (shared `.credentials.json`, cross-process refresh\n * locks in `./oauth.ts`, themed login flows in `src/chat/oauth-page/`)\n * predates that and owns storage itself, so this module reproduces the\n * removed registry surface locally with the same semantics.\n *\n * Nothing protocol-level is duplicated here: token refresh for the built-in\n * providers delegates to pi-ai's canonical `auth.oauth.refresh` flows via the\n * public `providers/*` subpaths (lazily imported, so processes that never\n * authenticate don't load provider code).\n */\n\nimport type { OAuthAuth } from '@earendil-works/pi-ai'\nimport type { OAuthCredentials, OAuthLoginCallbacks } from '@earendil-works/pi-ai/oauth'\nimport { errorMessage } from '../errors'\n\n/**\n * Provider-owned OAuth flow. Mirrors the interface pi-ai exported from\n * `@earendil-works/pi-ai/oauth` up to 0.80.6 — kept as a local type so\n * zidane's descriptor seam (`ProviderDescriptor.oauthProvider`) and provider\n * extensions (e.g. `extensions/bolt`) stay source-compatible across the\n * upstream removal.\n */\nexport interface OAuthProviderInterface {\n  readonly id: string\n  readonly name: string\n\n  /** Run the login flow, return credentials to persist. */\n  login: (callbacks: OAuthLoginCallbacks) => Promise<OAuthCredentials>\n\n  /** Whether login uses a local callback server and supports manual code input. */\n  usesCallbackServer?: boolean\n\n  /** Refresh expired credentials, return updated credentials to persist. */\n  refreshToken: (credentials: OAuthCredentials) => Promise<OAuthCredentials>\n\n  /** Convert credentials to an API key string for the provider. */\n  getApiKey: (credentials: OAuthCredentials) => string\n}\n\n/**\n * Run a canonical pi-ai `OAuthAuth.refresh` from a bare refresh token.\n * pi-ai's built-in refresh implementations only read `credential.refresh`,\n * so the placeholder access/expires fields are never observed.\n *\n * The canonical result is an `OAuthCredential` tagged `type: 'oauth'`. Strip\n * the tag before returning: refresh results get merged into stored\n * `.credentials.json` entries and `onOAuthRefresh` hook payloads (see\n * `resolveCredentialSource` in `./oauth.ts`), whose documented shape carries\n * zidane's own `kind` tag — letting pi-ai's `type` leak through would\n * silently drift the on-disk shape.\n */\nasync function refreshViaCanonicalFlow(\n  providerId: string,\n  oauth: OAuthAuth | undefined,\n  refreshToken: string,\n): Promise<OAuthCredentials> {\n  if (!oauth)\n    throw new Error(`pi-ai provider ${providerId} exposes no OAuth flow`)\n  // pi-ai 0.84 made `signal` a required second argument. These refreshers are\n  // called from token-expiry paths that carry no cancellation of their own, so\n  // a never-aborting signal keeps the pre-0.84 behavior exactly — same idiom as\n  // `completion-core.ts`.\n  const { type: _type, ...credentials }\n    = await oauth.refresh(\n      { type: 'oauth', access: '', refresh: refreshToken, expires: 0 },\n      new AbortController().signal,\n    )\n  return credentials\n}\n\n/**\n * pi-ai ≥ 0.85 loads each OAuth flow module through a VARIABLE specifier\n * (`auth/oauth/load.js`: `import(rewrite(\"./anthropic.ts\"))`) precisely so\n * bundlers cannot follow it. Fine under plain Node/Bun where the file sits\n * next to `load.js`; fatal inside anything bundled — the compiled `zidane`\n * binary, the packaged Electron main — where the refresh path died with\n * `Cannot find module './anthropic.js'` and the user was told to re-run auth\n * for a token that was perfectly renewable.\n *\n * pi-ai ships the escape hatch for exactly this: `bun-oauth` statically\n * imports every flow and registers them with the loader. We call it lazily,\n * once, right before the first refresh — a static specifier the bundler DOES\n * follow — so every host (TUI binary, GUI, daemon, SDK) refreshes the same\n * way. Idempotent; failure to register falls through to the loader's own\n * behavior (works unbundled, so nothing gets worse).\n */\nlet bundledFlowsReady: Promise<void> | null = null\nexport function ensureBundledOAuthFlows(): Promise<void> {\n  bundledFlowsReady ??= import('@earendil-works/pi-ai/bun-oauth')\n    .then(({ registerBunOAuthFlows }) => {\n      registerBunOAuthFlows()\n    })\n    .catch(() => {\n      bundledFlowsReady = null\n    })\n  return bundledFlowsReady\n}\n\n/**\n * Refresh an Anthropic (Claude Pro/Max) OAuth token. Drop-in replacement for\n * the `refreshAnthropicToken` pi-ai exported until 0.80.6; delegates to the\n * canonical flow on `anthropicProvider().auth.oauth`.\n */\nexport async function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials> {\n  await ensureBundledOAuthFlows()\n  const { anthropicProvider } = await import('@earendil-works/pi-ai/providers/anthropic')\n  return refreshViaCanonicalFlow('anthropic', anthropicProvider().auth.oauth, refreshToken)\n}\n\n/**\n * Refresh an OpenAI Codex (ChatGPT) OAuth token. Drop-in replacement for the\n * removed `refreshOpenAICodexToken`; the canonical flow still derives\n * `accountId` from the refreshed access token's JWT claims, so the returned\n * credentials keep the extra field older callers persisted.\n */\nexport async function refreshOpenAICodexToken(refreshToken: string): Promise<OAuthCredentials> {\n  await ensureBundledOAuthFlows()\n  const { openaiCodexProvider } = await import('@earendil-works/pi-ai/providers/openai-codex')\n  return refreshViaCanonicalFlow('openai-codex', openaiCodexProvider().auth.oauth, refreshToken)\n}\n\n/**\n * Built-in registry seeds. Every id whose stored credential can expire has to\n * be seeded here, because zidane's lazy token refresh (`getOAuthApiKey` inside\n * `resolveOAuthApiKey`) resolves through the registry — an unseeded id is not a\n * degraded path but a dead end, with no way to renew the session. That is wider\n * than the Anthropic / OpenAI Codex pair pi-ai's removed registry pre-seeded:\n * flows zidane implements itself (xAI) need seeding just as much.\n *\n * Login is intentionally unsupported here: interactive login always goes\n * through `ProviderDescriptor.oauthProvider` (the themed flows in\n * `src/chat/oauth-page/`), never through the registry.\n */\nfunction builtinProvider(\n  id: string,\n  name: string,\n  refreshToken: (credentials: OAuthCredentials) => Promise<OAuthCredentials>,\n): OAuthProviderInterface {\n  return {\n    id,\n    name,\n    login: async () => {\n      throw new Error(`OAuth login for ${id} must run through a provider descriptor flow, not the registry`)\n    },\n    refreshToken,\n    getApiKey: credentials => credentials.access,\n  }\n}\n\n/**\n * Seed id for the xAI Grok OAuth flow. Duplicated from\n * `XAI_OAUTH_PROVIDER_ID` in `../chat/oauth-page/xai` rather than imported:\n * that module pulls in `node:http` and the PKCE helpers at module scope, and\n * this registry is loaded by every consumer that resolves a credential. The\n * ids are pinned together by a test, so the duplication cannot drift.\n */\nconst XAI_SEED_ID = 'xai-oauth'\n\n/**\n * Refresh an xAI Grok token. Imported lazily so seeding the registry does not\n * drag the login flow's `node:http` callback server into every consumer —\n * and so the static import edge back to this module stays type-only, leaving\n * no runtime cycle.\n *\n * Unlike the Anthropic / Codex seeds, this receives the FULL credential rather\n * than a bare refresh token: xAI stores its resolved `token_endpoint` (and the\n * cached discovery doc) alongside the tokens, and dropping them would force a\n * fresh OIDC discovery round-trip on every refresh — and discard the validated\n * endpoint that `refreshXaiToken` re-checks before posting the refresh token\n * to it.\n */\nasync function refreshXaiTokenSeed(credentials: OAuthCredentials): Promise<OAuthCredentials> {\n  const { refreshXaiToken } = await import('../chat/oauth-page/xai')\n  return refreshXaiToken(credentials)\n}\n\n/**\n * Seed id for the Cursor OAuth flow. Duplicated from\n * `CURSOR_OAUTH_PROVIDER_ID` for the same reason as {@link XAI_SEED_ID}, and\n * pinned to it by a test.\n */\nconst CURSOR_SEED_ID = 'cursor'\n\n/**\n * Refresh a Cursor token. Lazy for the same reason as the xAI seed: the login\n * module owns a callback server, and seeding must not drag it into every\n * consumer that merely resolves a credential.\n */\nasync function refreshCursorTokenSeed(credentials: OAuthCredentials): Promise<OAuthCredentials> {\n  const { refreshCursorToken } = await import('../chat/oauth-page/cursor')\n  return refreshCursorToken(credentials)\n}\n\n/**\n * The registry map is anchored on a process-wide `globalThis` slot rather\n * than module state. The pi-ai registry this replaces lived in pi-ai's own\n * module, so every copy of zidane code in a process shared one map — and two\n * copies is a real configuration, not a hypothetical: a host running from\n * `src` while a disk-loaded extension resolves `'zidane'` to `dist` through\n * ordinary node_modules resolution (see `import()` in\n * `src/extensions/discovery.ts`). The extension registers its flow at setup;\n * `resolveOAuthApiKey` looks it up only once a stored token expires — with\n * per-module maps that fails as a deferred \"Unknown OAuth provider\", which is\n * nasty to debug. `Symbol.for` restores the process-wide sharing. Whichever\n * copy touches the slot first seeds the built-ins, so a `dist` consumer can end\n * up refreshing through the `src` copy's closure (and vice versa). That is\n * harmless because the seeds are STATELESS refresh delegations — they close over\n * no module state and no configuration, so the two copies compute the same\n * result from the same stored credential. It is that property, not where the\n * refresh happens to be implemented, that makes first-copy-wins safe: it holds\n * equally for the seeds that delegate to pi-ai's canonical flows and for the\n * xAI one implemented in `../chat/oauth-page/xai`.\n */\n/**\n * Exported so tests that register a throwaway provider can remove it from the\n * same slot rather than re-deriving the key with a copied string: the registry\n * exposes no unregister, and a `Symbol.for` looked up from a duplicated literal\n * would silently stop matching if this key were ever renamed, leaving the test\n * provider resident in shared state. Deliberately kept out of the package's\n * public surface — `./index.ts` re-exports this module by explicit name list.\n */\nexport const REGISTRY_SLOT = Symbol.for('zidane.oauth-provider-registry')\n\nfunction oauthProviderRegistry(): Map<string, OAuthProviderInterface> {\n  const slots = globalThis as { [key: symbol]: Map<string, OAuthProviderInterface> | undefined }\n  slots[REGISTRY_SLOT] ??= new Map(\n    [\n      builtinProvider('anthropic', 'Anthropic (Claude Pro/Max)', c => refreshAnthropicToken(c.refresh)),\n      builtinProvider('openai-codex', 'OpenAI (ChatGPT Plus/Pro)', c => refreshOpenAICodexToken(c.refresh)),\n      // xAI is NOT built into pi-ai, so unlike the two above there is no\n      // canonical flow to delegate to — `../chat/oauth-page/xai` implements it.\n      // It is seeded here anyway because seeding is what makes refresh work for\n      // consumers that never import `chat/providers.ts` or `auth.ts`, whose\n      // module-scope `registerXaiOAuthProvider()` call was previously the ONLY\n      // thing that registered it. A library consumer resolving a stored\n      // credential through `getOAuthApiKey` got `Unknown OAuth provider:\n      // xai-oauth` and had no way to renew a session — a dead end rather than a\n      // degraded path. The interactive login half still comes from\n      // `registerXaiOAuthProvider(renderPage)`, which replaces this seed.\n      builtinProvider(XAI_SEED_ID, 'xAI Grok (SuperGrok / X Premium+)', refreshXaiTokenSeed),\n      // Cursor has the identical shape and had the identical defect: its flow\n      // lives in `../chat/oauth-page/cursor` and was registered only as a\n      // module-scope side effect of importing `chat/providers.ts` / `auth.ts`.\n      builtinProvider(CURSOR_SEED_ID, 'Cursor', refreshCursorTokenSeed),\n    ].map(provider => [provider.id, provider]),\n  )\n  return slots[REGISTRY_SLOT]\n}\n\n/** Register (or replace) an OAuth provider by id. */\nexport function registerOAuthProvider(provider: OAuthProviderInterface): void {\n  oauthProviderRegistry().set(provider.id, provider)\n}\n\n/** Get a registered OAuth provider by id. */\nexport function getOAuthProvider(id: string): OAuthProviderInterface | undefined {\n  return oauthProviderRegistry().get(id)\n}\n\n/**\n * Get an API key for a provider from OAuth credentials, refreshing expired\n * tokens through the registered flow. Same contract as the pi-ai original\n * (`null` when no credentials are stored for the provider, throws on unknown\n * provider or refresh failure), with two deliberate additions:\n *\n *   - refresh failures keep the underlying reason — the original discarded it,\n *     leaving invalid_grant (needs re-login) indistinguishable from a transient\n *     network error.\n *   - `options.force` rotates regardless of the local expiry, for 401 recovery\n *     when the server revoked the grant before our stored timestamp said so.\n *     Expressed as a flag rather than by handing this function a credential\n *     with a doctored `expires`: callers persist whatever comes back, so a\n *     fabricated expiry that a provider echoes through would land in the\n *     credential store. See `resolveCredentialSource` in `./oauth.ts`.\n */\nexport async function getOAuthApiKey(\n  providerId: string,\n  credentials: Record<string, OAuthCredentials>,\n  options?: { force?: boolean },\n): Promise<{ newCredentials: OAuthCredentials, apiKey: string } | null> {\n  const provider = oauthProviderRegistry().get(providerId)\n  if (!provider)\n    throw new Error(`Unknown OAuth provider: ${providerId}`)\n\n  let creds = credentials[providerId]\n  if (!creds)\n    return null\n\n  if (options?.force || Date.now() >= creds.expires) {\n    try {\n      creds = await provider.refreshToken(creds)\n    }\n    catch (err) {\n      throw new Error(`Failed to refresh OAuth token for ${providerId}: ${errorMessage(err)}`, { cause: err })\n    }\n  }\n\n  return { newCredentials: creds, apiKey: provider.getApiKey(creds) }\n}\n","import type { OAuthCredentials } from '@earendil-works/pi-ai/oauth'\nimport type { StreamCallbacks } from '.'\nimport type { OAuthRefreshHookContext } from '../types'\nimport { Buffer } from 'node:buffer'\nimport { randomUUID } from 'node:crypto'\nimport { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { dirname, resolve } from 'node:path'\nimport { isDeepStrictEqual } from 'node:util'\nimport { writeFileAtomic } from '../atomic-write'\nimport { errorMessage } from '../errors'\nimport { getOAuthApiKey, registerOAuthProvider } from './oauth-registry'\n\ntype GetOAuthApiKey = typeof getOAuthApiKey\n\n/**\n * Resolve the creds-file path at call time rather than module-load time, so\n * env changes between import and first OAuth use (test suites, multi-project\n * CLIs) are honored.\n *\n * Order:\n *   1. `ZIDANE_CREDENTIALS_PATH` — explicit override. The TUI sets this at\n *      launch to point at `<storageDir>/credentials.json` so the harness\n *      providers find the same file the TUI manages.\n *   2. `~/.credentials.json` — home-anchored default.\n *\n * The historic `cwd/.credentials.json` fallback was deliberately dropped:\n * launching zidane inside an untrusted checkout would let that repo plant a\n * `.credentials.json` and become the credential source (and receive rotated\n * refresh tokens on the next refresh persist). Same trust model as the TUI's\n * legacy-file migration in `chat/credentials.ts`, which only honors the\n * home-anchored location. The only \"trusted\" cwd under that model is `$HOME`\n * itself — where the cwd-relative path resolves to `~/.credentials.json`\n * anyway, so anchoring at home preserves the legitimate legacy case.\n */\nexport function credentialsFilePath(): string {\n  return process.env.ZIDANE_CREDENTIALS_PATH ?? resolve(homedir(), '.credentials.json')\n}\n\n/**\n * POSIX mode for credentials on disk. Read+write for the owner only — refresh\n * tokens and API keys leak if the file is world-readable on a shared box.\n * Ignored on Windows.\n */\nconst CREDENTIALS_FILE_MODE = 0o600\n\ninterface RefreshResult {\n  apiKey: string\n  event?: OAuthRefreshHookContext\n}\n\nconst refreshLocks = new Map<string, Promise<RefreshResult>>()\nconst storeIds = new WeakMap<object, number>()\nlet nextStoreId = 0\nfunction identity(value: object): number {\n  let id = storeIds.get(value)\n  if (id === undefined) {\n    id = ++nextStoreId\n    storeIds.set(value, id)\n  }\n  return id\n}\n\n/**\n * Register a custom OAuth flow with the local registry (`./oauth-registry`)\n * so lazy refresh through {@link resolveOAuthApiKey} can resolve `providerId`.\n *\n * Public because provider extensions need it: without registration,\n * `getOAuthApiKey('<id>', …)` throws `Unknown OAuth provider` the first time a\n * stored token expires. Idempotent per id (the registry is a keyed map). Kept\n * async for API stability — it awaited a dynamic pi-ai import before pi-ai\n * 0.80.8 removed its global registry and this moved in-repo.\n */\nexport async function registerCustomOAuthProvider(\n  provider: import('./oauth-registry').OAuthProviderInterface,\n): Promise<void> {\n  registerOAuthProvider(provider)\n}\n\nexport interface OAuthParams {\n  apiKey?: string\n  access?: string\n  refresh?: string\n  expires?: number\n}\n\n/**\n * Pull a complete `{ access, refresh, expires }` triple out of provider params\n * when (and only when) all three OAuth fields are present and well-typed.\n * Returns `undefined` for the static-api-key path. Shared by the OAuth-capable\n * providers so the runtime-credential guard can't drift between them.\n */\n/**\n * Whether a credential string is an OAuth *access token* rather than a real,\n * static API key. Anthropic OAuth tokens are prefixed `sk-ant-oat`; OpenAI\n * Codex OAuth access tokens are JWTs (`eyJ...`). Used to decide whether an\n * env-provided value can be refreshed (OAuth) or must be sent verbatim (API key).\n */\nexport function isOAuthAccessToken(value: string): boolean {\n  return value.startsWith('sk-ant-oat') || isJwtLikeAccessToken(value)\n}\n\nfunction isJwtLikeAccessToken(value: string): boolean {\n  const parts = value.split('.')\n  if (parts.length !== 3 || !parts[0]?.startsWith('eyJ'))\n    return false\n  try {\n    const header = JSON.parse(Buffer.from(parts[0], 'base64url').toString('utf8')) as unknown\n    return Boolean(header && typeof header === 'object' && 'alg' in header)\n  }\n  catch {\n    return false\n  }\n}\n\nexport function extractRuntimeCredentials(\n  params?: OAuthParams,\n): { access: string, refresh: string, expires: number } | undefined {\n  if (\n    typeof params?.access === 'string'\n    && typeof params.refresh === 'string'\n    && typeof params.expires === 'number'\n  ) {\n    return { access: params.access, refresh: params.refresh, expires: params.expires }\n  }\n  return undefined\n}\n\nexport interface ResolveOAuthApiKeyOptions<TParams extends OAuthParams = OAuthParams> {\n  provider: string\n  providerId: string\n  params?: TParams\n  envKey?: string\n  extraCredentialKeys?: (keyof TParams & string)[]\n  missingError: string\n  refreshError: (reason: string) => string\n  readCredentials?: () => Record<string, OAuthCredentials | undefined>\n  /** Synchronous provider-local patch writer; injected stores own cross-process coordination. */\n  writeCredentials?: (credentials: Record<string, OAuthCredentials | undefined>) => void\n  getOAuthApiKey?: GetOAuthApiKey\n  /**\n   * Force a refresh even when the credential's local expiry is still in the\n   * future (for one-shot 401 recovery). Reaches the refresh helper as an\n   * explicit flag, so no credential with a fabricated expiry ever exists to\n   * leak into the store — see {@link getOAuthApiKey}.\n   */\n  forceRefresh?: boolean\n  /** Access token rejected by the server; a different token found under lock is reused instead of rotated again. */\n  rejectedAccess?: string\n}\n\n/**\n * Read the shared credentials file.\n *\n * Returns `{}` when the file is missing OR when the file exists but is corrupted\n * / not valid JSON. Corrupt-file tolerance is important: the refresh-then-persist\n * path below writes atomically, but older builds wrote in place and could have\n * truncated the file on a crash. Treating corruption as \"no stored creds\" lets\n * users re-auth without manually deleting the file.\n *\n * Supports two on-disk shapes:\n *   1. **Legacy** (untagged): `{ \"anthropic\": { access, refresh, expires, ... } }`\n *      — written by older `bun run auth`.\n *   2. **New** (kind-tagged): `{ \"anthropic\": { kind: 'oauth', access, refresh, expires, ... } }`\n *      — written by the TUI. Entries with `kind: 'apikey'` are skipped — those\n *      reach providers via env vars set at TUI launch (see `applyApiKeyEnv`).\n */\nexport function readOAuthCredentials(): Record<string, OAuthCredentials | undefined> {\n  return readOAuthCredentialsAt(credentialsFilePath())\n}\n\nfunction readOAuthCredentialsAt(path: string): Record<string, OAuthCredentials | undefined> {\n  if (!existsSync(path))\n    return {}\n\n  try {\n    const raw = readFileSync(path, 'utf-8')\n    const parsed = JSON.parse(raw)\n    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))\n      return {}\n    const result: Record<string, OAuthCredentials | undefined> = {}\n    for (const [key, value] of Object.entries(parsed)) {\n      if (!value || typeof value !== 'object' || Array.isArray(value))\n        continue\n      const v = value as Record<string, unknown>\n      // New schema: explicit `kind` tag.\n      if (v.kind === 'apikey')\n        continue\n      // Both new (`kind: 'oauth'`) and legacy (untagged) entries have `access`;\n      // the harmless `kind` field is allowed by `OAuthCredentials`'s\n      // `[key: string]: unknown` index signature. Validate the required\n      // fields explicitly so the assignment doesn't need a double-cast.\n      if (\n        typeof v.access === 'string'\n        && typeof v.refresh === 'string'\n        && typeof v.expires === 'number'\n      ) {\n        result[key] = { ...v, access: v.access, refresh: v.refresh, expires: v.expires }\n      }\n    }\n    return result\n  }\n  catch {\n    return {}\n  }\n}\n\n/** Never steal a lock based on age: a suspended holder may still own it. */\nfunction tryAcquireLock(lockPath: string): (() => void) | undefined {\n  const owner = `${process.pid}:${randomUUID()}`\n  try {\n    writeFileSync(lockPath, owner, { flag: 'wx', mode: CREDENTIALS_FILE_MODE })\n  }\n  catch (err) {\n    if ((err as NodeJS.ErrnoException).code === 'EEXIST')\n      return undefined\n    throw err\n  }\n  return () => {\n    try {\n      if (readFileSync(lockPath, 'utf8') === owner)\n        unlinkSync(lockPath)\n    }\n    catch (err) {\n      if ((err as NodeJS.ErrnoException).code !== 'ENOENT')\n        throw err\n    }\n  }\n}\n\n/** Shared by refresh persistence and interactive credential mutations. */\nexport function withCredentialsLock<T>(path: string, fn: () => T): T {\n  mkdirSync(dirname(path), { recursive: true, mode: 0o700 })\n  const deadline = Date.now() + 2000\n  let release = tryAcquireLock(`${path}.lock`)\n  while (!release) {\n    if (Date.now() >= deadline)\n      throw new Error('Timed out waiting for credentials lock')\n    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20)\n    release = tryAcquireLock(`${path}.lock`)\n  }\n  try {\n    return fn()\n  }\n  finally {\n    release()\n  }\n}\n\nasync function acquireRefreshLock(lockPath: string): Promise<() => void> {\n  mkdirSync(dirname(lockPath), { recursive: true, mode: 0o700 })\n  const deadline = Date.now() + 30_000\n  while (true) {\n    const release = tryAcquireLock(lockPath)\n    if (release)\n      return release\n    if (Date.now() >= deadline)\n      throw new Error('Timed out waiting for OAuth refresh lock')\n    await new Promise(resolve => setTimeout(resolve, 50))\n  }\n}\n\nfunction readRawCredentials(path: string): Record<string, unknown> {\n  try {\n    const parsed = JSON.parse(readFileSync(path, 'utf8'))\n    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))\n      return parsed\n  }\n  catch { /* Missing or corrupt file. */ }\n  return {}\n}\n\nfunction writeCredentialPatch(path: string, credentials: Record<string, unknown>): void {\n  const merged = { ...readRawCredentials(path), ...credentials }\n  for (const [key, value] of Object.entries(merged)) {\n    if (value === undefined)\n      delete merged[key]\n  }\n  writeFileAtomic(path, JSON.stringify(merged, null, 2), { mode: CREDENTIALS_FILE_MODE })\n}\n\n/** Incoming entries are a provider-local patch, not a read-time snapshot. */\nexport function writeOAuthCredentials(credentials: Record<string, OAuthCredentials | undefined>) {\n  const path = credentialsFilePath()\n  withCredentialsLock(path, () => writeCredentialPatch(path, credentials))\n}\n\nexport function credentialsFromParams<TParams extends OAuthParams>(params?: TParams, extraKeys: (keyof TParams & string)[] = []): OAuthCredentials | undefined {\n  if (typeof params?.access !== 'string' || typeof params.refresh !== 'string' || typeof params.expires !== 'number')\n    return undefined\n\n  const extras = Object.fromEntries(\n    extraKeys\n      .map(key => [key, params[key]])\n      .filter(([, value]) => value !== undefined),\n  )\n\n  return {\n    access: params.access,\n    refresh: params.refresh,\n    expires: params.expires,\n    ...extras,\n  }\n}\n\nexport async function resolveOAuthApiKey<TParams extends OAuthParams>(\n  options: ResolveOAuthApiKeyOptions<TParams>,\n  callbacks?: Pick<StreamCallbacks, 'onOAuthRefresh'>,\n): Promise<string> {\n  if (typeof options.params?.apiKey === 'string')\n    return options.params.apiKey\n  const paramsCredentials = credentialsFromParams(options.params, options.extraCredentialKeys)\n  if (!paramsCredentials && typeof options.params?.access === 'string')\n    return options.params.access\n\n  // Capture the store before awaiting: environment changes cannot redirect writes.\n  const path = resolve(credentialsFilePath())\n  const usingDefaultStore = !options.readCredentials && !options.writeCredentials\n  const read = options.readCredentials ?? (() => readOAuthCredentialsAt(path))\n  const write = options.writeCredentials ?? (patch => withCredentialsLock(path, () => writeCredentialPatch(path, patch)))\n  const envValue = options.envKey ? process.env[options.envKey] : undefined\n  if (!paramsCredentials && envValue && (!isOAuthAccessToken(envValue) || !read()[options.providerId]))\n    return envValue\n\n  const source = paramsCredentials ? 'params' : 'file'\n  const initial = paramsCredentials ?? read()[options.providerId]\n  const store = usingDefaultStore ? path : [identity(options.readCredentials ?? readOAuthCredentials), identity(options.writeCredentials ?? writeOAuthCredentials)]\n  const key = JSON.stringify([source, options.providerId, source === 'file' ? store : null, initial, options.forceRefresh === true, options.rejectedAccess, identity(options.getOAuthApiKey ?? getOAuthApiKey)])\n  let task = refreshLocks.get(key)\n  if (!task) {\n    task = run()\n    refreshLocks.set(key, task)\n    // Delete before callbacks run; a failing subscriber must not poison peers.\n    void task.finally(() => refreshLocks.delete(key)).catch(() => {})\n  }\n  const result = await task\n  if (result.event) {\n    await callbacks?.onOAuthRefresh?.({\n      ...structuredClone(result.event),\n      provider: options.provider,\n    })\n  }\n  return result.apiKey\n\n  async function run(): Promise<RefreshResult> {\n    const release = source === 'file' && usingDefaultStore\n      ? await acquireRefreshLock(`${path}.refresh-${encodeURIComponent(options.providerId)}.lock`)\n      : undefined\n    try {\n      const current = paramsCredentials ?? read()[options.providerId]\n      if (!current)\n        throw new Error(options.missingError)\n      const generation = structuredClone(current)\n      let result: Awaited<ReturnType<GetOAuthApiKey>>\n      try {\n        const stillRejected = options.rejectedAccess === undefined || current.access === options.rejectedAccess\n        result = await (options.getOAuthApiKey ?? getOAuthApiKey)(\n          options.providerId,\n          { [options.providerId]: current },\n          { force: options.forceRefresh === true && stillRejected },\n        )\n      }\n      catch (err) {\n        throw new Error(options.refreshError(errorMessage(err)), { cause: err })\n      }\n      if (!result)\n        throw new Error(options.refreshError(options.missingError))\n      const refreshed = { ...generation, ...result.newCredentials }\n      if (source === 'file') {\n        const persist = () => {\n          if (!isDeepStrictEqual(read()[options.providerId], generation))\n            throw new Error('OAuth credentials changed during refresh; retry with current credentials')\n          if (result.newCredentials !== current) {\n            const patch = { [options.providerId]: refreshed }\n            if (usingDefaultStore)\n              writeCredentialPatch(path, patch)\n            else\n              write(patch)\n          }\n        }\n        if (usingDefaultStore)\n          withCredentialsLock(path, persist)\n        else\n          persist()\n      }\n      return {\n        apiKey: result.apiKey,\n        ...(result.newCredentials !== current\n          ? { event: {\n              provider: options.provider,\n              providerId: options.providerId,\n              source,\n              previousCredentials: generation,\n              credentials: refreshed,\n            } }\n          : {}),\n      }\n    }\n    finally {\n      release?.()\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA0DA,eAAe,wBACb,YACA,OACA,cAC2B;CAC3B,IAAI,CAAC,OACH,MAAM,IAAI,MAAM,kBAAkB,WAAW,uBAAuB;CAKtE,MAAM,EAAE,MAAM,OAAO,GAAG,gBACpB,MAAM,MAAM,QACZ;EAAE,MAAM;EAAS,QAAQ;EAAI,SAAS;EAAc,SAAS;CAAE,GAC/D,IAAI,gBAAgB,CAAC,CAAC,MACxB;CACF,OAAO;AACT;;;;;;;;;;;;;;;;;AAkBA,IAAI,oBAA0C;AAC9C,SAAgB,0BAAyC;CACvD,sBAAsB,OAAO,kCAAkC,CAC5D,MAAM,EAAE,4BAA4B;EACnC,sBAAsB;CACxB,CAAC,CAAC,CACD,YAAY;EACX,oBAAoB;CACtB,CAAC;CACH,OAAO;AACT;;;;;;AAOA,eAAsB,sBAAsB,cAAiD;CAC3F,MAAM,wBAAwB;CAC9B,MAAM,EAAE,sBAAsB,MAAM,OAAO;CAC3C,OAAO,wBAAwB,aAAa,kBAAkB,CAAC,CAAC,KAAK,OAAO,YAAY;AAC1F;;;;;;;AAQA,eAAsB,wBAAwB,cAAiD;CAC7F,MAAM,wBAAwB;CAC9B,MAAM,EAAE,wBAAwB,MAAM,OAAO;CAC7C,OAAO,wBAAwB,gBAAgB,oBAAoB,CAAC,CAAC,KAAK,OAAO,YAAY;AAC/F;;;;;;;;;;;;;AAcA,SAAS,gBACP,IACA,MACA,cACwB;CACxB,OAAO;EACL;EACA;EACA,OAAO,YAAY;GACjB,MAAM,IAAI,MAAM,mBAAmB,GAAG,+DAA+D;EACvG;EACA;EACA,YAAW,gBAAe,YAAY;CACxC;AACF;;;;;;;;AASA,MAAM,cAAc;;;;;;;;;;;;;;AAepB,eAAe,oBAAoB,aAA0D;CAC3F,MAAM,EAAE,oBAAoB,MAAM,OAAO,oBAAyB,CAAA,MAAA,MAAA,EAAA,CAAA;CAClE,OAAO,gBAAgB,WAAW;AACpC;;;;;;AAOA,MAAM,iBAAiB;;;;;;AAOvB,eAAe,uBAAuB,aAA0D;CAC9F,MAAM,EAAE,uBAAuB,MAAM,OAAO,uBAA4B,CAAA,MAAA,MAAA,EAAA,CAAA;CACxE,OAAO,mBAAmB,WAAW;AACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,gBAAgB,OAAO,IAAI,gCAAgC;AAExE,SAAS,wBAA6D;CACpE,MAAM,QAAQ;CACd,MAAM,mBAAmB,IAAI,IAC3B;EACE,gBAAgB,aAAa,+BAA8B,MAAK,sBAAsB,EAAE,OAAO,CAAC;EAChG,gBAAgB,gBAAgB,8BAA6B,MAAK,wBAAwB,EAAE,OAAO,CAAC;EAWpG,gBAAgB,aAAa,qCAAqC,mBAAmB;EAIrF,gBAAgB,gBAAgB,UAAU,sBAAsB;CAClE,CAAC,CAAC,KAAI,aAAY,CAAC,SAAS,IAAI,QAAQ,CAAC,CAC3C;CACA,OAAO,MAAM;AACf;;AAGA,SAAgB,sBAAsB,UAAwC;CAC5E,sBAAsB,CAAC,CAAC,IAAI,SAAS,IAAI,QAAQ;AACnD;;AAGA,SAAgB,iBAAiB,IAAgD;CAC/E,OAAO,sBAAsB,CAAC,CAAC,IAAI,EAAE;AACvC;;;;;;;;;;;;;;;;;AAkBA,eAAsB,eACpB,YACA,aACA,SACsE;CACtE,MAAM,WAAW,sBAAsB,CAAC,CAAC,IAAI,UAAU;CACvD,IAAI,CAAC,UACH,MAAM,IAAI,MAAM,2BAA2B,YAAY;CAEzD,IAAI,QAAQ,YAAY;CACxB,IAAI,CAAC,OACH,OAAO;CAET,IAAI,SAAS,SAAS,KAAK,IAAI,KAAK,MAAM,SACxC,IAAI;EACF,QAAQ,MAAM,SAAS,aAAa,KAAK;CAC3C,SACO,KAAK;EACV,MAAM,IAAI,MAAM,qCAAqC,WAAW,IAAI,aAAa,GAAG,KAAK,EAAE,OAAO,IAAI,CAAC;CACzG;CAGF,OAAO;EAAE,gBAAgB;EAAO,QAAQ,SAAS,UAAU,KAAK;CAAE;AACpE;;;;;;;;;;;;;;;;;;;;;;;AC9QA,SAAgB,sBAA8B;CAC5C,OAAO,QAAQ,IAAI,2BAA2B,QAAQ,QAAQ,GAAG,mBAAmB;AACtF;;;;;;AAOA,MAAM,wBAAwB;AAO9B,MAAM,+BAAe,IAAI,IAAoC;AAC7D,MAAM,2BAAW,IAAI,QAAwB;AAC7C,IAAI,cAAc;AAClB,SAAS,SAAS,OAAuB;CACvC,IAAI,KAAK,SAAS,IAAI,KAAK;CAC3B,IAAI,OAAO,KAAA,GAAW;EACpB,KAAK,EAAE;EACP,SAAS,IAAI,OAAO,EAAE;CACxB;CACA,OAAO;AACT;;;;;;;;;;;AAYA,eAAsB,4BACpB,UACe;CACf,sBAAsB,QAAQ;AAChC;;;;;;;;;;;;;AAqBA,SAAgB,mBAAmB,OAAwB;CACzD,OAAO,MAAM,WAAW,YAAY,KAAK,qBAAqB,KAAK;AACrE;AAEA,SAAS,qBAAqB,OAAwB;CACpD,MAAM,QAAQ,MAAM,MAAM,GAAG;CAC7B,IAAI,MAAM,WAAW,KAAK,CAAC,MAAM,EAAE,EAAE,WAAW,KAAK,GACnD,OAAO;CACT,IAAI;EACF,MAAM,SAAS,KAAK,MAAM,OAAO,KAAK,MAAM,IAAI,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC;EAC7E,OAAO,QAAQ,UAAU,OAAO,WAAW,YAAY,SAAS,MAAM;CACxE,QACM;EACJ,OAAO;CACT;AACF;AAEA,SAAgB,0BACd,QACkE;CAClE,IACE,OAAO,QAAQ,WAAW,YACvB,OAAO,OAAO,YAAY,YAC1B,OAAO,OAAO,YAAY,UAE7B,OAAO;EAAE,QAAQ,OAAO;EAAQ,SAAS,OAAO;EAAS,SAAS,OAAO;CAAQ;AAGrF;;;;;;;;;;;;;;;;;AAyCA,SAAgB,uBAAqE;CACnF,OAAO,uBAAuB,oBAAoB,CAAC;AACrD;AAEA,SAAS,uBAAuB,MAA4D;CAC1F,IAAI,CAAC,WAAW,IAAI,GAClB,OAAO,CAAC;CAEV,IAAI;EACF,MAAM,MAAM,aAAa,MAAM,OAAO;EACtC,MAAM,SAAS,KAAK,MAAM,GAAG;EAC7B,IAAI,CAAC,UAAU,OAAO,WAAW,YAAY,MAAM,QAAQ,MAAM,GAC/D,OAAO,CAAC;EACV,MAAM,SAAuD,CAAC;EAC9D,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAAG;GACjD,IAAI,CAAC,SAAS,OAAO,UAAU,YAAY,MAAM,QAAQ,KAAK,GAC5D;GACF,MAAM,IAAI;GAEV,IAAI,EAAE,SAAS,UACb;GAKF,IACE,OAAO,EAAE,WAAW,YACjB,OAAO,EAAE,YAAY,YACrB,OAAO,EAAE,YAAY,UAExB,OAAO,OAAO;IAAE,GAAG;IAAG,QAAQ,EAAE;IAAQ,SAAS,EAAE;IAAS,SAAS,EAAE;GAAQ;EAEnF;EACA,OAAO;CACT,QACM;EACJ,OAAO,CAAC;CACV;AACF;;AAGA,SAAS,eAAe,UAA4C;CAClE,MAAM,QAAQ,GAAG,QAAQ,IAAI,GAAG,WAAW;CAC3C,IAAI;EACF,cAAc,UAAU,OAAO;GAAE,MAAM;GAAM,MAAM;EAAsB,CAAC;CAC5E,SACO,KAAK;EACV,IAAK,IAA8B,SAAS,UAC1C,OAAO,KAAA;EACT,MAAM;CACR;CACA,aAAa;EACX,IAAI;GACF,IAAI,aAAa,UAAU,MAAM,MAAM,OACrC,WAAW,QAAQ;EACvB,SACO,KAAK;GACV,IAAK,IAA8B,SAAS,UAC1C,MAAM;EACV;CACF;AACF;;AAGA,SAAgB,oBAAuB,MAAc,IAAgB;CACnE,UAAU,QAAQ,IAAI,GAAG;EAAE,WAAW;EAAM,MAAM;CAAM,CAAC;CACzD,MAAM,WAAW,KAAK,IAAI,IAAI;CAC9B,IAAI,UAAU,eAAe,GAAG,KAAK,MAAM;CAC3C,OAAO,CAAC,SAAS;EACf,IAAI,KAAK,IAAI,KAAK,UAChB,MAAM,IAAI,MAAM,wCAAwC;EAC1D,QAAQ,KAAK,IAAI,WAAW,IAAI,kBAAkB,CAAC,CAAC,GAAG,GAAG,GAAG,EAAE;EAC/D,UAAU,eAAe,GAAG,KAAK,MAAM;CACzC;CACA,IAAI;EACF,OAAO,GAAG;CACZ,UACQ;EACN,QAAQ;CACV;AACF;AAEA,eAAe,mBAAmB,UAAuC;CACvE,UAAU,QAAQ,QAAQ,GAAG;EAAE,WAAW;EAAM,MAAM;CAAM,CAAC;CAC7D,MAAM,WAAW,KAAK,IAAI,IAAI;CAC9B,OAAO,MAAM;EACX,MAAM,UAAU,eAAe,QAAQ;EACvC,IAAI,SACF,OAAO;EACT,IAAI,KAAK,IAAI,KAAK,UAChB,MAAM,IAAI,MAAM,0CAA0C;EAC5D,MAAM,IAAI,SAAQ,YAAW,WAAW,SAAS,EAAE,CAAC;CACtD;AACF;AAEA,SAAS,mBAAmB,MAAuC;CACjE,IAAI;EACF,MAAM,SAAS,KAAK,MAAM,aAAa,MAAM,MAAM,CAAC;EACpD,IAAI,UAAU,OAAO,WAAW,YAAY,CAAC,MAAM,QAAQ,MAAM,GAC/D,OAAO;CACX,QACM,CAAiC;CACvC,OAAO,CAAC;AACV;AAEA,SAAS,qBAAqB,MAAc,aAA4C;CACtF,MAAM,SAAS;EAAE,GAAG,mBAAmB,IAAI;EAAG,GAAG;CAAY;CAC7D,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAC9C,IAAI,UAAU,KAAA,GACZ,OAAO,OAAO;CAElB,gBAAgB,MAAM,KAAK,UAAU,QAAQ,MAAM,CAAC,GAAG,EAAE,MAAM,sBAAsB,CAAC;AACxF;;AAGA,SAAgB,sBAAsB,aAA2D;CAC/F,MAAM,OAAO,oBAAoB;CACjC,oBAAoB,YAAY,qBAAqB,MAAM,WAAW,CAAC;AACzE;AAEA,SAAgB,sBAAmD,QAAkB,YAAwC,CAAC,GAAiC;CAC7J,IAAI,OAAO,QAAQ,WAAW,YAAY,OAAO,OAAO,YAAY,YAAY,OAAO,OAAO,YAAY,UACxG,OAAO,KAAA;CAET,MAAM,SAAS,OAAO,YACpB,UACG,KAAI,QAAO,CAAC,KAAK,OAAO,IAAI,CAAC,CAAC,CAC9B,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAC9C;CAEA,OAAO;EACL,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB,SAAS,OAAO;EAChB,GAAG;CACL;AACF;AAEA,eAAsB,mBACpB,SACA,WACiB;CACjB,IAAI,OAAO,QAAQ,QAAQ,WAAW,UACpC,OAAO,QAAQ,OAAO;CACxB,MAAM,oBAAoB,sBAAsB,QAAQ,QAAQ,QAAQ,mBAAmB;CAC3F,IAAI,CAAC,qBAAqB,OAAO,QAAQ,QAAQ,WAAW,UAC1D,OAAO,QAAQ,OAAO;CAGxB,MAAM,OAAO,QAAQ,oBAAoB,CAAC;CAC1C,MAAM,oBAAoB,CAAC,QAAQ,mBAAmB,CAAC,QAAQ;CAC/D,MAAM,OAAO,QAAQ,0BAA0B,uBAAuB,IAAI;CAC1E,MAAM,QAAQ,QAAQ,sBAAqB,UAAS,oBAAoB,YAAY,qBAAqB,MAAM,KAAK,CAAC;CACrH,MAAM,WAAW,QAAQ,SAAS,QAAQ,IAAI,QAAQ,UAAU,KAAA;CAChE,IAAI,CAAC,qBAAqB,aAAa,CAAC,mBAAmB,QAAQ,KAAK,CAAC,KAAK,CAAC,CAAC,QAAQ,cACtF,OAAO;CAET,MAAM,SAAS,oBAAoB,WAAW;CAC9C,MAAM,UAAU,qBAAqB,KAAK,CAAC,CAAC,QAAQ;CACpD,MAAM,QAAQ,oBAAoB,OAAO,CAAC,SAAS,QAAQ,mBAAmB,oBAAoB,GAAG,SAAS,QAAQ,oBAAoB,qBAAqB,CAAC;CAChK,MAAM,MAAM,KAAK,UAAU;EAAC;EAAQ,QAAQ;EAAY,WAAW,SAAS,QAAQ;EAAM;EAAS,QAAQ,iBAAiB;EAAM,QAAQ;EAAgB,SAAS,QAAQ,kBAAkB,cAAc;CAAC,CAAC;CAC7M,IAAI,OAAO,aAAa,IAAI,GAAG;CAC/B,IAAI,CAAC,MAAM;EACT,OAAO,IAAI;EACX,aAAa,IAAI,KAAK,IAAI;EAE1B,KAAU,cAAc,aAAa,OAAO,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;CAClE;CACA,MAAM,SAAS,MAAM;CACrB,IAAI,OAAO,OACT,MAAM,WAAW,iBAAiB;EAChC,GAAG,gBAAgB,OAAO,KAAK;EAC/B,UAAU,QAAQ;CACpB,CAAC;CAEH,OAAO,OAAO;CAEd,eAAe,MAA8B;EAC3C,MAAM,UAAU,WAAW,UAAU,oBACjC,MAAM,mBAAmB,GAAG,KAAK,WAAW,mBAAmB,QAAQ,UAAU,EAAE,MAAM,IACzF,KAAA;EACJ,IAAI;GACF,MAAM,UAAU,qBAAqB,KAAK,CAAC,CAAC,QAAQ;GACpD,IAAI,CAAC,SACH,MAAM,IAAI,MAAM,QAAQ,YAAY;GACtC,MAAM,aAAa,gBAAgB,OAAO;GAC1C,IAAI;GACJ,IAAI;IACF,MAAM,gBAAgB,QAAQ,mBAAmB,KAAA,KAAa,QAAQ,WAAW,QAAQ;IACzF,SAAS,OAAO,QAAQ,kBAAkB,eAAA,CACxC,QAAQ,YACR,GAAG,QAAQ,aAAa,QAAQ,GAChC,EAAE,OAAO,QAAQ,iBAAiB,QAAQ,cAAc,CAC1D;GACF,SACO,KAAK;IACV,MAAM,IAAI,MAAM,QAAQ,aAAa,aAAa,GAAG,CAAC,GAAG,EAAE,OAAO,IAAI,CAAC;GACzE;GACA,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,QAAQ,aAAa,QAAQ,YAAY,CAAC;GAC5D,MAAM,YAAY;IAAE,GAAG;IAAY,GAAG,OAAO;GAAe;GAC5D,IAAI,WAAW,QAAQ;IACrB,MAAM,gBAAgB;KACpB,IAAI,CAAC,kBAAkB,KAAK,CAAC,CAAC,QAAQ,aAAa,UAAU,GAC3D,MAAM,IAAI,MAAM,0EAA0E;KAC5F,IAAI,OAAO,mBAAmB,SAAS;MACrC,MAAM,QAAQ,GAAG,QAAQ,aAAa,UAAU;MAChD,IAAI,mBACF,qBAAqB,MAAM,KAAK;WAEhC,MAAM,KAAK;KACf;IACF;IACA,IAAI,mBACF,oBAAoB,MAAM,OAAO;SAEjC,QAAQ;GACZ;GACA,OAAO;IACL,QAAQ,OAAO;IACf,GAAI,OAAO,mBAAmB,UAC1B,EAAE,OAAO;KACP,UAAU,QAAQ;KAClB,YAAY,QAAQ;KACpB;KACA,qBAAqB;KACrB,aAAa;IACf,EAAE,IACF,CAAC;GACP;EACF,UACQ;GACN,UAAU;EACZ;CACF;AACF"}

package/dist/output/stream-json.d.ts

@@ -1,4 +1,4 @@
-import { $n as HeadlessResult, Jn as FormattedHeadlessTurnEvent, Qn as HeadlessOutputFormat, Xn as HeadlessEvent, qi as Agent, qn as FormattedHeadlessResult } from "../index-CfEJ5Vf9.js";
+import { $n as HeadlessResult, Jn as FormattedHeadlessTurnEvent, Qn as HeadlessOutputFormat, Xn as HeadlessEvent, qi as Agent, qn as FormattedHeadlessResult } from "../index-C4mY0oKE.js";
 
 //#region src/output/stream-json.d.ts
 type StreamJsonOutputFormat = HeadlessOutputFormat;

package/dist/output/terminal.d.ts

@@ -1,4 +1,4 @@
-import { Yi as AgentHooks, qi as Agent, t as Preset } from "../index-CfEJ5Vf9.js";
+import { Yi as AgentHooks, qi as Agent, t as Preset } from "../index-C4mY0oKE.js";
 
 //#region src/output/terminal.d.ts
 interface TerminalOutputOptions {

package/dist/plugins.d.ts

@@ -1,2 +1,2 @@
-import { Ac as PLUGIN_MANIFEST_FILE, Bc as PluginSchemaKind, Dc as ManifestValidation, Ec as expandPluginVars, Fc as LoadedPlugin, Hc as agentPluginsSchemaId, Ic as PluginAuthor, Lc as PluginComponentStatus, Mc as loadAgentPlugin, Nc as AgentPluginsVersion, Oc as parsePluginManifest, Pc as LoadAgentPluginOptions, Rc as PluginDiagnostic, Tc as PLUGIN_MCP_FILE, Uc as isSupportedAgentPluginsVersion, Vc as SUPPORTED_AGENT_PLUGINS_VERSIONS, Wc as parseSchemaId, jc as defaultPluginDataRoot, kc as validatePluginManifest, wc as PLUGIN_SKILLS_DIR, zc as PluginManifest } from "./index-CfEJ5Vf9.js";
+import { Ac as PLUGIN_MANIFEST_FILE, Bc as PluginSchemaKind, Dc as ManifestValidation, Ec as expandPluginVars, Fc as LoadedPlugin, Hc as agentPluginsSchemaId, Ic as PluginAuthor, Lc as PluginComponentStatus, Mc as loadAgentPlugin, Nc as AgentPluginsVersion, Oc as parsePluginManifest, Pc as LoadAgentPluginOptions, Rc as PluginDiagnostic, Tc as PLUGIN_MCP_FILE, Uc as isSupportedAgentPluginsVersion, Vc as SUPPORTED_AGENT_PLUGINS_VERSIONS, Wc as parseSchemaId, jc as defaultPluginDataRoot, kc as validatePluginManifest, wc as PLUGIN_SKILLS_DIR, zc as PluginManifest } from "./index-C4mY0oKE.js";
 export { type AgentPluginsVersion, type LoadAgentPluginOptions, type LoadedPlugin, type ManifestValidation, PLUGIN_MANIFEST_FILE, PLUGIN_MCP_FILE, PLUGIN_SKILLS_DIR, type PluginAuthor, type PluginComponentStatus, type PluginDiagnostic, type PluginManifest, type PluginSchemaKind, SUPPORTED_AGENT_PLUGINS_VERSIONS, agentPluginsSchemaId, defaultPluginDataRoot, expandPluginVars, isSupportedAgentPluginsVersion, loadAgentPlugin, parsePluginManifest, parseSchemaId, validatePluginManifest };

package/dist/presets.d.ts

@@ -1,2 +1,2 @@
-import { Ji as AgentHookMap, Ki as _default, a as basicTools, i as _default$1, n as composePresets, r as definePreset, t as Preset } from "./index-CfEJ5Vf9.js";
+import { Ji as AgentHookMap, Ki as _default, a as basicTools, i as _default$1, n as composePresets, r as definePreset, t as Preset } from "./index-C4mY0oKE.js";
 export { type AgentHookMap, Preset, _default as artifacts, _default$1 as basic, basicTools, composePresets, definePreset };

package/dist/presets.js

@@ -1,2 +1,2 @@
-import { Jt as artifacts_default, bt as basicTools, vt as composePresets, xt as basic_default, yt as definePreset } from "./agent-Djzx-1kD.js";
+import { Jt as artifacts_default, bt as basicTools, vt as composePresets, xt as basic_default, yt as definePreset } from "./agent-LC2c1ue-.js";
 export { artifacts_default as artifacts, basic_default as basic, basicTools, composePresets, definePreset };

package/dist/providers/anthropic.d.ts

@@ -1,2 +1,2 @@
-import { Ah as anthropic, Bh as resolveAnthropicMaxOutput, Dh as AnthropicParams, Eh as AnthropicContextManagement, Fh as credentialIdentity, Ih as defaultAnthropicMaxTokens, Lh as planAnthropicThinking, Mh as buildAnthropicClientOptions, Nh as cacheWriteTtlMultiplier, Oh as AnthropicThinkingPlan, Ph as classifyAnthropicError, Rh as resolveAnthropicAuthShape, Th as AnthropicBedrockConfig, jh as applyAnthropicCacheBreakpoints, kh as EXTENDED_CACHE_TTL_BETA, zh as resolveAnthropicBetas } from "../index-CfEJ5Vf9.js";
+import { Ah as anthropic, Bh as resolveAnthropicMaxOutput, Dh as AnthropicParams, Eh as AnthropicContextManagement, Fh as credentialIdentity, Ih as defaultAnthropicMaxTokens, Lh as planAnthropicThinking, Mh as buildAnthropicClientOptions, Nh as cacheWriteTtlMultiplier, Oh as AnthropicThinkingPlan, Ph as classifyAnthropicError, Rh as resolveAnthropicAuthShape, Th as AnthropicBedrockConfig, jh as applyAnthropicCacheBreakpoints, kh as EXTENDED_CACHE_TTL_BETA, zh as resolveAnthropicBetas } from "../index-C4mY0oKE.js";
 export { AnthropicBedrockConfig, AnthropicContextManagement, AnthropicParams, AnthropicThinkingPlan, EXTENDED_CACHE_TTL_BETA, anthropic, applyAnthropicCacheBreakpoints, buildAnthropicClientOptions, cacheWriteTtlMultiplier, classifyAnthropicError, credentialIdentity, defaultAnthropicMaxTokens, planAnthropicThinking, resolveAnthropicAuthShape, resolveAnthropicBetas, resolveAnthropicMaxOutput };

package/dist/providers/anthropic.js

@@ -1,2 +1,2 @@
-import { a as cacheWriteTtlMultiplier, c as defaultAnthropicMaxTokens, d as resolveAnthropicBetas, f as resolveAnthropicMaxOutput, i as buildAnthropicClientOptions, l as planAnthropicThinking, n as anthropic, o as classifyAnthropicError, r as applyAnthropicCacheBreakpoints, s as credentialIdentity, t as EXTENDED_CACHE_TTL_BETA, u as resolveAnthropicAuthShape } from "../anthropic-DATE-m9f.js";
+import { a as cacheWriteTtlMultiplier, c as defaultAnthropicMaxTokens, d as resolveAnthropicBetas, f as resolveAnthropicMaxOutput, i as buildAnthropicClientOptions, l as planAnthropicThinking, n as anthropic, o as classifyAnthropicError, r as applyAnthropicCacheBreakpoints, s as credentialIdentity, t as EXTENDED_CACHE_TTL_BETA, u as resolveAnthropicAuthShape } from "../anthropic-BSbDiW0J.js";
 export { EXTENDED_CACHE_TTL_BETA, anthropic, applyAnthropicCacheBreakpoints, buildAnthropicClientOptions, cacheWriteTtlMultiplier, classifyAnthropicError, credentialIdentity, defaultAnthropicMaxTokens, planAnthropicThinking, resolveAnthropicAuthShape, resolveAnthropicBetas, resolveAnthropicMaxOutput };

package/dist/providers/arcee.d.ts

@@ -1,2 +1,2 @@
-import { Ch as ArceeParams, wh as arcee } from "../index-CfEJ5Vf9.js";
+import { Ch as ArceeParams, wh as arcee } from "../index-C4mY0oKE.js";
 export { ArceeParams, arcee };

package/dist/providers/baseten.d.ts

@@ -1,2 +1,2 @@
-import { Sh as planBasetenReasoning, bh as BasetenParams, xh as baseten } from "../index-CfEJ5Vf9.js";
+import { Sh as planBasetenReasoning, bh as BasetenParams, xh as baseten } from "../index-C4mY0oKE.js";
 export { BasetenParams, baseten, planBasetenReasoning };

package/dist/providers/cerebras.d.ts

@@ -1,2 +1,2 @@
-import { vh as CerebrasParams, yh as cerebras } from "../index-CfEJ5Vf9.js";
+import { vh as CerebrasParams, yh as cerebras } from "../index-C4mY0oKE.js";
 export { CerebrasParams, cerebras };

package/dist/providers/local.d.ts

@@ -1,2 +1,2 @@
-import { hh as local, mh as LocalParams } from "../index-CfEJ5Vf9.js";
+import { hh as local, mh as LocalParams } from "../index-C4mY0oKE.js";
 export { LocalParams, local };

package/dist/providers/openai-compat.d.ts

@@ -1,2 +1,2 @@
-import { $m as formatTools, Bm as OAIMessage, Gm as OpenAICompatStreamError, Hm as OpenAICompatAuthHeader, Jm as applyOAIToolCacheBreakpoint, Km as TOOL_RESULTS_TAG, Qm as consumeSSE, Um as OpenAICompatHttpError, Vm as OAITool, Wm as OpenAICompatParams, Xm as buildAssistantContent, Ym as assistantMessage, Zm as classifyOpenAICompatError, ah as userMessage, eh as mapOAIFinishReason, ih as toolResultsMessage, nh as openaiCompat, qm as applyOAICacheBreakpoints, rh as toOAIMessages, th as openAICompatPromptMessage, zm as ASSISTANT_TOOL_CALLS_TAG } from "../index-CfEJ5Vf9.js";
+import { $m as formatTools, Bm as OAIMessage, Gm as OpenAICompatStreamError, Hm as OpenAICompatAuthHeader, Jm as applyOAIToolCacheBreakpoint, Km as TOOL_RESULTS_TAG, Qm as consumeSSE, Um as OpenAICompatHttpError, Vm as OAITool, Wm as OpenAICompatParams, Xm as buildAssistantContent, Ym as assistantMessage, Zm as classifyOpenAICompatError, ah as userMessage, eh as mapOAIFinishReason, ih as toolResultsMessage, nh as openaiCompat, qm as applyOAICacheBreakpoints, rh as toOAIMessages, th as openAICompatPromptMessage, zm as ASSISTANT_TOOL_CALLS_TAG } from "../index-C4mY0oKE.js";
 export { ASSISTANT_TOOL_CALLS_TAG, OAIMessage, OAITool, OpenAICompatAuthHeader, OpenAICompatHttpError, OpenAICompatParams, OpenAICompatStreamError, TOOL_RESULTS_TAG, applyOAICacheBreakpoints, applyOAIToolCacheBreakpoint, assistantMessage, buildAssistantContent, classifyOpenAICompatError, consumeSSE, formatTools, mapOAIFinishReason, openAICompatPromptMessage, openaiCompat, toOAIMessages, toolResultsMessage, userMessage };

package/dist/providers/openai.d.ts

@@ -1,2 +1,2 @@
-import { ch as mapCodexStopReason, lh as openai, oh as OpenAIParams, sh as classifyOpenAIError, uh as toPiMessages } from "../index-CfEJ5Vf9.js";
+import { ch as mapCodexStopReason, lh as openai, oh as OpenAIParams, sh as classifyOpenAIError, uh as toPiMessages } from "../index-C4mY0oKE.js";
 export { OpenAIParams, classifyOpenAIError, mapCodexStopReason, openai, toPiMessages };

package/dist/providers/openai.js

@@ -3,7 +3,7 @@ import { a as documentBlockMarker, r as assertResolvedMediaBlock } from "../type
 import { f as isRetryableHttpStatus, h as matchesToolPairingError, l as classifyErrorPrelude, m as matchesContextExceeded } from "../errors-DKiMrOKq.js";
 import { renderSystemForWire } from "../prompt.js";
 import { f as reasoningWireAction, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER } from "../messages-aORUmIKe.js";
-import { r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "../oauth-D-LZ4ic-.js";
+import { r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "../oauth-CmtlmCzi.js";
 import { stream } from "@earendil-works/pi-ai/api/openai-codex-responses";
 import { stream as stream$1 } from "@earendil-works/pi-ai/api/openai-responses";
 import { getBuiltinModel } from "@earendil-works/pi-ai/providers/all";

package/dist/providers/openrouter.d.ts

@@ -1,2 +1,2 @@
-import { Im as OpenRouterParams, Lm as normalizeOpenRouterModelId, Rm as openrouter } from "../index-CfEJ5Vf9.js";
+import { Im as OpenRouterParams, Lm as normalizeOpenRouterModelId, Rm as openrouter } from "../index-C4mY0oKE.js";
 export { OpenRouterParams, normalizeOpenRouterModelId, openrouter };

package/dist/providers/xai.d.ts

@@ -1,2 +1,2 @@
-import { Am as xai, km as XaiParams } from "../index-CfEJ5Vf9.js";
+import { Am as xai, km as XaiParams } from "../index-C4mY0oKE.js";
 export { XaiParams, xai };

package/dist/providers/xai.js

@@ -1,5 +1,5 @@
 import { m as openaiCompat } from "../openai-compat-cIeLSED_.js";
-import { i as isOAuthAccessToken, r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "../oauth-D-LZ4ic-.js";
+import { i as isOAuthAccessToken, r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "../oauth-CmtlmCzi.js";
 import { r as xaiBaseUrl, t as XAI_OAUTH_PROVIDER_ID } from "../xai-CazjStOK.js";
 //#region src/providers/xai.ts
 const DEFAULT_MODEL = "grok-4.6";