zidane 6.2.36 → 6.3.1

package/dist/{oauth-CBi9eymX.js → oauth-CuFPhsHY.js}

@@ -1,12 +1,119 @@
-import { t as lazyAsync } from "./lazy-DLOurOC_.js";
 import { l as errorMessage } from "./errors-DJUxZg9b.js";
 import { t as writeFileAtomic } from "./atomic-write-B7zr1ddF.js";
 import { resolve } from "node:path";
 import { Buffer } from "node:buffer";
 import { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
+//#region src/providers/oauth-registry.ts
+/**
+* Run a canonical pi-ai `OAuthAuth.refresh` from a bare refresh token.
+* pi-ai's built-in refresh implementations only read `credential.refresh`,
+* so the placeholder access/expires fields are never observed.
+*
+* The canonical result is an `OAuthCredential` tagged `type: 'oauth'`. Strip
+* the tag before returning: refresh results get merged into stored
+* `.credentials.json` entries and `onOAuthRefresh` hook payloads (see
+* `resolveCredentialSource` in `./oauth.ts`), whose documented shape carries
+* zidane's own `kind` tag — letting pi-ai's `type` leak through would
+* silently drift the on-disk shape.
+*/
+async function refreshViaCanonicalFlow(providerId, oauth, refreshToken) {
+	if (!oauth) throw new Error(`pi-ai provider ${providerId} exposes no OAuth flow`);
+	const { type: _type, ...credentials } = await oauth.refresh({
+		type: "oauth",
+		access: "",
+		refresh: refreshToken,
+		expires: 0
+	});
+	return credentials;
+}
+/**
+* Refresh an Anthropic (Claude Pro/Max) OAuth token. Drop-in replacement for
+* the `refreshAnthropicToken` pi-ai exported until 0.80.6; delegates to the
+* canonical flow on `anthropicProvider().auth.oauth`.
+*/
+async function refreshAnthropicToken(refreshToken) {
+	const { anthropicProvider } = await import("@earendil-works/pi-ai/providers/anthropic");
+	return refreshViaCanonicalFlow("anthropic", anthropicProvider().auth.oauth, refreshToken);
+}
+/**
+* Refresh an OpenAI Codex (ChatGPT) OAuth token. Drop-in replacement for the
+* removed `refreshOpenAICodexToken`; the canonical flow still derives
+* `accountId` from the refreshed access token's JWT claims, so the returned
+* credentials keep the extra field older callers persisted.
+*/
+async function refreshOpenAICodexToken(refreshToken) {
+	const { openaiCodexProvider } = await import("@earendil-works/pi-ai/providers/openai-codex");
+	return refreshViaCanonicalFlow("openai-codex", openaiCodexProvider().auth.oauth, refreshToken);
+}
+/**
+* Built-in registry seeds. pi-ai's removed registry pre-seeded Anthropic and
+* OpenAI Codex, and zidane's lazy token refresh (`getOAuthApiKey` inside
+* `resolveOAuthApiKey`) relied on that — so the local registry seeds the same
+* ids. Login is intentionally unsupported here: interactive login always goes
+* through `ProviderDescriptor.oauthProvider` (the themed flows in
+* `src/chat/oauth-page/`), never through the registry.
+*/
+function builtinProvider(id, name, refreshToken) {
+	return {
+		id,
+		name,
+		login: async () => {
+			throw new Error(`OAuth login for ${id} must run through a provider descriptor flow, not the registry`);
+		},
+		refreshToken: (credentials) => refreshToken(credentials.refresh),
+		getApiKey: (credentials) => credentials.access
+	};
+}
+/**
+* The registry map is anchored on a process-wide `globalThis` slot rather
+* than module state. The pi-ai registry this replaces lived in pi-ai's own
+* module, so every copy of zidane code in a process shared one map — and two
+* copies is a real configuration, not a hypothetical: a host running from
+* `src` while a disk-loaded extension resolves `'zidane'` to `dist` through
+* ordinary node_modules resolution (see `import()` in
+* `src/extensions/discovery.ts`). The extension registers its flow at setup;
+* `resolveOAuthApiKey` looks it up only once a stored token expires — with
+* per-module maps that fails as a deferred "Unknown OAuth provider", which is
+* nasty to debug. `Symbol.for` restores the process-wide sharing. Whichever
+* copy touches the slot first seeds the built-ins; the seeds are pure
+* delegations to pi-ai's canonical flows, so first-copy-wins is harmless.
+*/
+const REGISTRY_SLOT = Symbol.for("zidane.oauth-provider-registry");
+function oauthProviderRegistry() {
+	const slots = globalThis;
+	slots[REGISTRY_SLOT] ??= new Map([builtinProvider("anthropic", "Anthropic (Claude Pro/Max)", refreshAnthropicToken), builtinProvider("openai-codex", "OpenAI (ChatGPT Plus/Pro)", refreshOpenAICodexToken)].map((provider) => [provider.id, provider]));
+	return slots[REGISTRY_SLOT];
+}
+/** Register (or replace) an OAuth provider by id. */
+function registerOAuthProvider(provider) {
+	oauthProviderRegistry().set(provider.id, provider);
+}
+/**
+* Get an API key for a provider from OAuth credentials, refreshing expired
+* tokens through the registered flow. Same contract as the pi-ai original
+* (`null` when no credentials are stored for the provider, throws on unknown
+* provider or refresh failure), except refresh failures keep the underlying
+* reason — the original discarded it, leaving invalid_grant (needs re-login)
+* indistinguishable from a transient network error.
+*/
+async function getOAuthApiKey(providerId, credentials) {
+	const provider = oauthProviderRegistry().get(providerId);
+	if (!provider) throw new Error(`Unknown OAuth provider: ${providerId}`);
+	let creds = credentials[providerId];
+	if (!creds) return null;
+	if (Date.now() >= creds.expires) try {
+		creds = await provider.refreshToken(creds);
+	} catch (err) {
+		throw new Error(`Failed to refresh OAuth token for ${providerId}: ${errorMessage(err)}`, { cause: err });
+	}
+	return {
+		newCredentials: creds,
+		apiKey: provider.getApiKey(creds)
+	};
+}
+//#endregion
 //#region src/providers/oauth.ts
-const loadGetOAuthApiKey = lazyAsync(async () => (await import("@earendil-works/pi-ai/oauth")).getOAuthApiKey);
 /**
 * Resolve the creds-file path at call time rather than module-load time, so
 * env changes between import and first OAuth use (test suites, multi-project
@@ -46,17 +153,16 @@ const CREDENTIALS_FILE_MODE = 384;
 */
 const refreshLocks = /* @__PURE__ */ new Map();
 /**
-* Register a custom OAuth flow with pi-ai's registry so lazy refresh through
-* {@link resolveOAuthApiKey} can resolve `providerId`.
+* Register a custom OAuth flow with the local registry (`./oauth-registry`)
+* so lazy refresh through {@link resolveOAuthApiKey} can resolve `providerId`.
 *
 * Public because provider extensions need it: without registration,
 * `getOAuthApiKey('<id>', …)` throws `Unknown OAuth provider` the first time a
-* stored token expires. Idempotent per id (the registry is a keyed map), and
-* lazily imported so importing this module never pulls pi-ai's OAuth surface
-* into processes that don't authenticate.
+* stored token expires. Idempotent per id (the registry is a keyed map). Kept
+* async for API stability — it awaited a dynamic pi-ai import before pi-ai
+* 0.80.8 removed its global registry and this moved in-repo.
 */
 async function registerCustomOAuthProvider(provider) {
-	const { registerOAuthProvider } = await import("@earendil-works/pi-ai/oauth");
 	registerOAuthProvider(provider);
 }
 /**
@@ -320,7 +426,7 @@ async function resolveOAuthApiKey(options, callbacks) {
 	async function resolveCredentialSource(source, current, allCredentials, persistCredentials) {
 		let result;
 		try {
-			result = await (options.getOAuthApiKey ?? await loadGetOAuthApiKey())(options.providerId, { [options.providerId]: current });
+			result = await (options.getOAuthApiKey ?? getOAuthApiKey)(options.providerId, { [options.providerId]: current });
 		} catch (err) {
 			throw new Error(options.refreshError(errorMessage(err)));
 		}
@@ -364,6 +470,6 @@ async function withRefreshLock(key, fn) {
 	return task;
 }
 //#endregion
-export { readOAuthCredentials as a, writeOAuthCredentials as c, isOAuthAccessToken as i, credentialsFromParams as n, registerCustomOAuthProvider as o, extractRuntimeCredentials as r, resolveOAuthApiKey as s, credentialsFilePath as t };
+export { readOAuthCredentials as a, writeOAuthCredentials as c, registerOAuthProvider as d, isOAuthAccessToken as i, refreshAnthropicToken as l, credentialsFromParams as n, registerCustomOAuthProvider as o, extractRuntimeCredentials as r, resolveOAuthApiKey as s, credentialsFilePath as t, refreshOpenAICodexToken as u };
 
-//# sourceMappingURL=oauth-CBi9eymX.js.map
+//# sourceMappingURL=oauth-CuFPhsHY.js.map

package/dist/oauth-CuFPhsHY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth-CuFPhsHY.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  const { type: _type, ...credentials }\n    = await oauth.refresh({ type: 'oauth', access: '', refresh: refreshToken, expires: 0 })\n  return credentials\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  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  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. pi-ai's removed registry pre-seeded Anthropic and\n * OpenAI Codex, and zidane's lazy token refresh (`getOAuthApiKey` inside\n * `resolveOAuthApiKey`) relied on that — so the local registry seeds the same\n * ids. 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: (token: string) => 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: credentials => refreshToken(credentials.refresh),\n    getApiKey: credentials => credentials.access,\n  }\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; the seeds are pure\n * delegations to pi-ai's canonical flows, so first-copy-wins is harmless.\n */\nconst 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)', refreshAnthropicToken),\n      builtinProvider('openai-codex', 'OpenAI (ChatGPT Plus/Pro)', refreshOpenAICodexToken),\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), except refresh failures keep the underlying\n * reason — the original discarded it, leaving invalid_grant (needs re-login)\n * indistinguishable from a transient network error.\n */\nexport async function getOAuthApiKey(\n  providerId: string,\n  credentials: Record<string, OAuthCredentials>,\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 (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 { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs'\nimport { homedir } from 'node:os'\nimport { resolve } from 'node:path'\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\n/**\n * In-process mutex table keyed by provider id. Concurrent `resolveOAuthApiKey`\n * calls for the same provider (typical when a host fans out multiple streams\n * at once) coalesce onto a single refresh. Without this, N concurrent calls\n * each hit `getOAuthApiKey`, producing N writes to `.credentials.json` with\n * last-write-wins semantics — and, in worst-case interleaving, a corrupted\n * file.\n */\nconst refreshLocks = new Map<string, Promise<string>>()\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  writeCredentials?: (credentials: Record<string, OAuthCredentials | undefined>) => void\n  getOAuthApiKey?: GetOAuthApiKey\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  const path = credentialsFilePath()\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/**\n * Cross-process lockfile parameters for the credentials read-merge-write.\n * A holder normally completes in well under a millisecond (read + JSON merge\n * + atomic write of a tiny file), so the stale threshold is generous and the\n * total wait short — on timeout we proceed without the lock rather than fail\n * the refresh (degrades to the historic last-write-wins behavior).\n */\nconst CREDENTIALS_LOCK_STALE_MS = 5000\nconst CREDENTIALS_LOCK_RETRY_MS = 20\nconst CREDENTIALS_LOCK_MAX_WAIT_MS = 2000\n\n/** Synchronous sleep without spinning — works on Bun and Node main threads. */\nfunction sleepSync(ms: number): void {\n  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms)\n}\n\n/**\n * Best-effort exclusive lock via `O_EXCL` create of `<file>.lock`. Returns\n * `true` when the lock was acquired (caller must release), `false` on\n * timeout (caller proceeds unlocked — see threshold rationale above). Locks\n * older than {@link CREDENTIALS_LOCK_STALE_MS} are treated as leftovers from\n * a crashed process and broken.\n */\nfunction acquireCredentialsLock(lockPath: string): boolean {\n  const deadline = Date.now() + CREDENTIALS_LOCK_MAX_WAIT_MS\n  while (true) {\n    try {\n      writeFileSync(lockPath, String(process.pid), { flag: 'wx', mode: CREDENTIALS_FILE_MODE })\n      return true\n    }\n    catch (err) {\n      // Only EEXIST means \"lock held\" — anything else (EPERM, ENOENT for a\n      // missing parent dir, read-only fs) won't resolve by waiting, so bail\n      // immediately and let the subsequent write surface the real error.\n      if ((err as NodeJS.ErrnoException).code !== 'EEXIST')\n        return false\n      try {\n        const age = Date.now() - statSync(lockPath).mtimeMs\n        if (age > CREDENTIALS_LOCK_STALE_MS) {\n          unlinkSync(lockPath)\n          continue\n        }\n      }\n      catch { /* lock vanished between create-fail and stat — retry */ }\n      if (Date.now() >= deadline)\n        return false\n      sleepSync(CREDENTIALS_LOCK_RETRY_MS)\n    }\n  }\n}\n\nfunction releaseCredentialsLock(lockPath: string): void {\n  try {\n    unlinkSync(lockPath)\n  }\n  catch { /* already gone */ }\n}\n\n/**\n * Cross-process lock parameters for the REFRESH critical section (read →\n * check expiry → refresh → persist), held per provider around file-backed\n * resolves in {@link resolveOAuthApiKey}.\n *\n * This is a different beast from the write lock above: the holder performs a\n * network call, so it can legitimately hold the lock for seconds. Hence its\n * own generous thresholds — and async waiting, because blocking the event\n * loop for a peer's refresh round-trip is not acceptable. The stakes are\n * higher too: providers with single-use rotating refresh tokens (Bolt) treat\n * a replayed token as theft and revoke the WHOLE grant, so two processes\n * refreshing the same provider concurrently don't just race a write — they\n * self-revoke. A process that loses the race re-reads under the lock, finds\n * the winner's fresh token, and skips its own refresh entirely.\n *\n * On timeout we proceed without the lock (degrades to the pre-lock racy\n * behavior) rather than fail a resolve that would probably have succeeded.\n */\nconst REFRESH_LOCK_STALE_MS = 60_000\nconst REFRESH_LOCK_RETRY_MS = 50\nconst REFRESH_LOCK_MAX_WAIT_MS = 30_000\n\nfunction refreshLockPath(providerId: string): string {\n  return `${credentialsFilePath()}.refresh-${providerId.replace(/[^\\w.-]/g, '_')}.lock`\n}\n\n/** Async sibling of {@link acquireCredentialsLock} with refresh-scale thresholds. */\nasync function acquireRefreshLock(lockPath: string): Promise<boolean> {\n  const deadline = Date.now() + REFRESH_LOCK_MAX_WAIT_MS\n  while (true) {\n    try {\n      writeFileSync(lockPath, String(process.pid), { flag: 'wx', mode: CREDENTIALS_FILE_MODE })\n      return true\n    }\n    catch (err) {\n      if ((err as NodeJS.ErrnoException).code !== 'EEXIST')\n        return false\n      try {\n        const age = Date.now() - statSync(lockPath).mtimeMs\n        if (age > REFRESH_LOCK_STALE_MS) {\n          unlinkSync(lockPath)\n          continue\n        }\n      }\n      catch { /* lock vanished between create-fail and stat — retry */ }\n      if (Date.now() >= deadline)\n        return false\n      await new Promise(resolve => setTimeout(resolve, REFRESH_LOCK_RETRY_MS))\n    }\n  }\n}\n\n/**\n * Atomically write `.credentials.json` with mode 0o600.\n *\n * Writes to a sibling temp file first, then renames. `rename(2)` is atomic on\n * the same filesystem, so readers either see the old file or the new one —\n * never a half-written one. This matters when a host has multiple processes\n * pointed at the same creds file.\n *\n * Merges the incoming OAuth entries on top of the raw file contents so that\n * entries this layer doesn't manage (e.g. `kind: 'apikey'` from the TUI\n * wizard) survive an OAuth refresh cycle. Without this merge,\n * `readOAuthCredentials` filters those entries out, and a naive overwrite\n * would delete them.\n *\n * The read-merge-write runs under a best-effort cross-process lockfile\n * (`<file>.lock`) so two processes refreshing different providers at the\n * same moment can't drop each other's rotated refresh tokens. On lock\n * timeout the write proceeds unlocked (last-write-wins, the pre-lock\n * behavior) rather than failing the refresh.\n */\nexport function writeOAuthCredentials(credentials: Record<string, OAuthCredentials | undefined>) {\n  const path = credentialsFilePath()\n  const lockPath = `${path}.lock`\n  const locked = acquireCredentialsLock(lockPath)\n\n  try {\n    let existing: Record<string, unknown> = {}\n    try {\n      if (existsSync(path)) {\n        const raw = readFileSync(path, 'utf-8')\n        const parsed = JSON.parse(raw)\n        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))\n          existing = parsed as Record<string, unknown>\n      }\n    }\n    catch { /* corrupt file — start fresh */ }\n\n    const merged = { ...existing, ...credentials }\n    // Remove keys explicitly set to undefined (provider was deleted).\n    for (const [key, value] of Object.entries(merged)) {\n      if (value === undefined)\n        delete merged[key]\n    }\n\n    writeFileAtomic(path, JSON.stringify(merged, null, 2), { mode: CREDENTIALS_FILE_MODE })\n  }\n  finally {\n    if (locked)\n      releaseCredentialsLock(lockPath)\n  }\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\n  const paramsCredentials = credentialsFromParams(options.params, options.extraCredentialKeys)\n  if (paramsCredentials) {\n    return await withRefreshLock(\n      `params:${options.providerId}`,\n      () => resolveCredentialSource('params', paramsCredentials),\n    )\n  }\n\n  if (typeof options.params?.access === 'string')\n    return options.params.access\n\n  const readCredentials = options.readCredentials ?? readOAuthCredentials\n  const writeCredentials = options.writeCredentials ?? writeOAuthCredentials\n  // The cross-process refresh lock only means something when we're actually\n  // backed by the shared credentials file; injected stores (tests, embedders)\n  // have no cross-process story to protect and must not touch real lock files.\n  const usingDefaultStore = !options.readCredentials && !options.writeCredentials\n\n  // Env key handling. A real API key (e.g. `sk-ant-api…`) is used as-is. But an\n  // OAuth *access token* (`sk-ant-oat…`) pasted into the API-key env var can't\n  // be refreshed and will 401 once expired — so if refreshable OAuth creds for\n  // this provider exist on disk, prefer those (they self-heal via refresh).\n  const envValue = options.envKey ? process.env[options.envKey] : undefined\n  if (envValue) {\n    if (!isOAuthAccessToken(envValue))\n      return envValue\n    if (!readCredentials()[options.providerId])\n      return envValue // no refreshable creds — fall back to the raw token\n    return await withRefreshLock(`file:${options.providerId}`, () => withCrossProcessRefreshLock(async () => {\n      // Re-read under the locks — a concurrent resolve (in this process or\n      // another) may have rotated the refresh token between the pre-check\n      // above and lock acquisition, and refreshing with the stale token would\n      // invalidate the new one.\n      const allCredentials = readCredentials()\n      const stored = allCredentials[options.providerId]\n      if (!stored)\n        return envValue\n      return await resolveCredentialSource('file', stored, allCredentials, writeCredentials)\n    }))\n  }\n\n  return await withRefreshLock(`file:${options.providerId}`, () => withCrossProcessRefreshLock(async () => {\n    // Read under the locks so we're always operating on the latest file state\n    // and never interleave read/refresh/write against another concurrent\n    // resolve — in-process (withRefreshLock) or cross-process (the lockfile).\n    const allCredentials = readCredentials()\n    const storedCredentials = allCredentials[options.providerId]\n    if (!storedCredentials)\n      throw new Error(options.missingError)\n\n    return await resolveCredentialSource('file', storedCredentials, allCredentials, writeCredentials)\n  }))\n\n  /**\n   * Hold the per-provider cross-process lockfile across the WHOLE file-backed\n   * critical section, not just the persist. Guarding only the write (as\n   * `writeOAuthCredentials` does) still lets two processes both spend a\n   * single-use rotating refresh token — which self-revokes providers with\n   * replay-detecting rotation. See the {@link REFRESH_LOCK_STALE_MS} note.\n   */\n  async function withCrossProcessRefreshLock(fn: () => Promise<string>): Promise<string> {\n    if (!usingDefaultStore)\n      return fn()\n    const lockPath = refreshLockPath(options.providerId)\n    const locked = await acquireRefreshLock(lockPath)\n    try {\n      return await fn()\n    }\n    finally {\n      if (locked)\n        releaseCredentialsLock(lockPath)\n    }\n  }\n\n  async function resolveCredentialSource(\n    source: OAuthRefreshHookContext['source'],\n    current: OAuthCredentials,\n    allCredentials?: Record<string, OAuthCredentials | undefined>,\n    persistCredentials?: (credentials: Record<string, OAuthCredentials | undefined>) => void,\n  ): Promise<string> {\n    // Only the refresh call itself maps to `refreshError` — a throwing\n    // persist or onOAuthRefresh hook after a SUCCESSFUL refresh must not be\n    // misreported as a refresh failure, so those run outside the try.\n    let result: Awaited<ReturnType<GetOAuthApiKey>>\n    try {\n      const refreshOAuthApiKey = options.getOAuthApiKey ?? getOAuthApiKey\n      result = await refreshOAuthApiKey(options.providerId, { [options.providerId]: current } as Record<string, OAuthCredentials>)\n    }\n    catch (err) {\n      throw new Error(options.refreshError(errorMessage(err)))\n    }\n    if (!result)\n      throw new Error(options.refreshError(options.missingError))\n\n    if (result.newCredentials !== current) {\n      // pi-ai's refresh returns only `{ access, refresh, expires }`. Merge it\n      // onto the current credential so the persisted entry keeps its on-disk\n      // `kind: 'oauth'` tag and any provider extras (e.g. openai-codex\n      // `accountId`). A bare overwrite strips `kind`, and the TUI's auth-state\n      // detection keys on `kind === 'oauth'` — so without this the provider\n      // reads as signed out after every token refresh, forcing a daily re-login.\n      const refreshed = { ...current, ...result.newCredentials }\n      if (source === 'file' && allCredentials && persistCredentials) {\n        allCredentials[options.providerId] = refreshed\n        persistCredentials(allCredentials)\n      }\n\n      await callbacks?.onOAuthRefresh?.({\n        provider: options.provider,\n        providerId: options.providerId,\n        source,\n        previousCredentials: { ...current },\n        credentials: { ...refreshed },\n      })\n    }\n\n    return result.apiKey\n  }\n}\n\n/**\n * Coalesce concurrent refresh calls onto a single in-flight promise per key.\n * The key combines the source (`params` vs `file`) and provider id, so a\n * per-agent param-only refresh does not starve a separate file-backed one.\n */\nasync function withRefreshLock(key: string, fn: () => Promise<string>): Promise<string> {\n  const existing = refreshLocks.get(key)\n  if (existing)\n    return existing\n\n  const task = (async () => {\n    try {\n      return await fn()\n    }\n    finally {\n      refreshLocks.delete(key)\n    }\n  })()\n  refreshLocks.set(key, task)\n  return task\n}\n"],"mappings":"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"}

package/dist/{openai-compat-C77gOaHh.js → openai-compat-DHlBIjj9.js}

@@ -1,7 +1,7 @@
 import { a as rewriteMessagesToWire, n as buildAliasMaps, o as toCanonicalName, r as buildSanitizedWireAliases, s as toWireName } from "./aliasing-lVFbm81n.js";
 import { i as documentBlockMarker, n as assertResolvedMediaBlock } from "./types-BIarq1qE.js";
 import { n as estimateTokens } from "./utils-ngQzYzZD.js";
-import { c as classifyErrorPrelude, d as isRetryableHttpStatus, f as matchesContextExceeded, l as errorMessage, p as matchesToolPairingError } from "./errors-DJUxZg9b.js";
+import { c as classifyErrorPrelude, d as isRetryableHttpStatus, f as matchesContextExceeded, p as matchesToolPairingError } from "./errors-DJUxZg9b.js";
 import { t as audioFormatFromMediaType } from "./media-sniff-Bn76JxAu.js";
 import { renderSystemForWire, splitSystemPrompt } from "./prompt.js";
 //#region src/prompt.ts
@@ -222,6 +222,32 @@ const EXTRA_COST_RATES = {
 * will drift until the dep updates. An optional `multiplier` scales the
 * base rates for premium modes (e.g. fast mode) before totaling.
 */
+/**
+* Dollar cost of a prompt-cache break's re-billed prefix.
+*
+* The `rebilledTokens` were WRITTEN at the cache-write rate when a healthy
+* turn would have READ them at the cache-read rate, so the waste is
+* `(write − read) × tokens`. Same registry + fallback-table resolution and
+* the same doctrine as {@link fillEstimatedCost}: returns `undefined` on a
+* rate miss (unknown provider/model, or no published cache-write rate) —
+* better than fabricating a $0. An optional `multiplier` scales the base
+* rates for premium modes (e.g. Anthropic fast mode, 1h-TTL writes at 2x).
+*/
+async function estimateRebilledCostUsd(provider, modelId, rebilledTokens, multiplier) {
+	if (!modelId || rebilledTokens <= 0) return void 0;
+	const getModel = await loadGetModel();
+	let model;
+	if (getModel) try {
+		model = getModel(provider, modelId);
+	} catch {
+		model = void 0;
+	}
+	const rates = model?.cost ?? EXTRA_COST_RATES[`${provider}:${modelId}`];
+	if (!rates || rates.cacheWrite === void 0) return void 0;
+	const write = rates.cacheWrite * (multiplier?.cacheWrite ?? 1);
+	const read = (rates.cacheRead ?? 0) * (multiplier?.cacheRead ?? 1);
+	return Math.max(0, (write - read) * rebilledTokens / 1e6);
+}
 async function fillEstimatedCost(usage, provider, multiplier) {
 	if (usage.cost !== void 0) return usage;
 	if (!usage.modelId) return usage;
@@ -243,19 +269,6 @@ async function fillEstimatedCost(usage, provider, multiplier) {
 	};
 }
 //#endregion
-//#region src/providers/openai-tool-names.ts
-function createOpenAIToolNameBoundary(messages, currentToolNames = []) {
-	const names = new Set(currentToolNames);
-	for (const message of messages) for (const block of message.content) if (block.type === "tool_call") names.add(block.name);
-	const maps = buildAliasMaps(buildSanitizedWireAliases(names, void 0), names);
-	return {
-		messages: rewriteMessagesToWire([...messages], maps),
-		toWire: (name) => toWireName(name, maps),
-		fromWire: (name) => toCanonicalName(name, maps),
-		changed: maps.aliasByCanonical.size > 0
-	};
-}
-//#endregion
 //#region src/providers/schema-sanitize.ts
 /**
 * Provider tool-name constraint. The charset (`[A-Za-z0-9_-]`) is universal
@@ -607,6 +620,113 @@ function defaultWarn(line) {
 	console.warn(`[zidane:schema] ${line}`);
 }
 //#endregion
+//#region src/providers/tool-args.ts
+/**
+* Parse a tool-call arguments payload, repairing truncation and trailing
+* garbage when strict parsing fails. Returns `undefined` when no bounded
+* repair produces valid JSON.
+*/
+function parseToolCallArguments(raw) {
+	try {
+		return {
+			input: JSON.parse(raw),
+			repaired: false
+		};
+	} catch {}
+	for (const { candidate, fabricated } of repairCandidates(raw)) try {
+		const parsed = JSON.parse(candidate);
+		if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+			if (fabricated && Object.keys(parsed).length === 0) continue;
+			return {
+				input: parsed,
+				repaired: true
+			};
+		}
+	} catch {}
+}
+/**
+* Bounded, ordered repair candidates:
+* 1. longest complete top-level object prefix (trailing-garbage case)
+* 2. payload + structural closers (truncated mid-string / mid-object)
+* 3. payload minus a dangling partial token, + closers (truncated mid-token)
+*
+* `fabricated` marks candidates whose closure was invented here (2 and 3) —
+* the caller holds those to a stricter acceptance bar than a prefix that was
+* complete in the payload itself.
+*/
+function* repairCandidates(raw) {
+	const text = raw.trim();
+	if (!text.startsWith("{")) return;
+	const scan = scanJson(text);
+	if (scan.completeAt !== void 0) yield {
+		candidate: text.slice(0, scan.completeAt),
+		fabricated: false
+	};
+	yield {
+		candidate: close(text, scan),
+		fabricated: true
+	};
+	let trimmed = text;
+	for (let step = 0; step < 6; step++) {
+		const next = (scanJson(trimmed).inString ? trimmed.replace(/"(?:[^"\\]|\\.)*$/, "") : trimmed.replace(/(?:"(?:[^"\\]|\\.)*"|[^\s{}[\],:"]+|[,:])\s*$/, "")).trimEnd();
+		if (next === trimmed || !next.startsWith("{")) break;
+		trimmed = next;
+		yield {
+			candidate: close(trimmed, scanJson(trimmed)),
+			fabricated: true
+		};
+	}
+}
+function scanJson(text) {
+	const stack = [];
+	let inString = false;
+	let escaped = false;
+	let completeAt;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (ch === "\\") escaped = true;
+			else if (ch === "\"") inString = false;
+			continue;
+		}
+		if (ch === "\"") inString = true;
+		else if (ch === "{") stack.push("}");
+		else if (ch === "[") stack.push("]");
+		else if (ch === "}" || ch === "]") {
+			stack.pop();
+			if (stack.length === 0 && completeAt === void 0) completeAt = i + 1;
+		}
+	}
+	return {
+		stack,
+		inString,
+		completeAt
+	};
+}
+function close(text, scan) {
+	let out = text;
+	if (scan.inString) {
+		if (/(?:^|[^\\])(?:\\\\)*\\$/.test(out)) out = out.slice(0, -1);
+		out += "\"";
+	}
+	for (let i = scan.stack.length - 1; i >= 0; i--) out += scan.stack[i];
+	return out;
+}
+//#endregion
+//#region src/providers/tool-name-boundary.ts
+function createToolNameBoundary(messages, currentToolNames = []) {
+	const names = new Set(currentToolNames);
+	for (const message of messages) for (const block of message.content) if (block.type === "tool_call") names.add(block.name);
+	const maps = buildAliasMaps(buildSanitizedWireAliases(names, void 0), names);
+	return {
+		messages: rewriteMessagesToWire([...messages], maps),
+		toWire: (name) => toWireName(name, maps),
+		fromWire: (name) => toCanonicalName(name, maps),
+		changed: maps.aliasByCanonical.size > 0
+	};
+}
+//#endregion
 //#region src/providers/openai-compat.ts
 const TOOL_RESULTS_TAG = "__zidane_tool_results__";
 const ASSISTANT_TOOL_CALLS_TAG = "__zidane_assistant_tc__";
@@ -658,6 +778,7 @@ async function consumeSSE(response, callbacks, signal) {
 	let text = "";
 	let thinking = "";
 	let finishReason = "stop";
+	let sawTerminator = false;
 	let usage = {
 		input: 0,
 		output: 0
@@ -678,7 +799,10 @@ async function consumeSSE(response, callbacks, signal) {
 			for (const line of lines) {
 				if (!line.startsWith("data:")) continue;
 				const data = line.slice(5).trim();
-				if (data === "[DONE]") continue;
+				if (data === "[DONE]") {
+					sawTerminator = true;
+					continue;
+				}
 				let chunk;
 				try {
 					chunk = JSON.parse(data);
@@ -690,7 +814,10 @@ async function consumeSSE(response, callbacks, signal) {
 				const choice = chunk.choices?.[0];
 				if (!choice) continue;
 				const fr = choice.finish_reason;
-				if (fr) finishReason = fr;
+				if (fr) {
+					finishReason = fr;
+					sawTerminator = true;
+				}
 				const delta = choice.delta;
 				const reasoningDeltaArr = delta?.reasoning_details;
 				if (reasoningDeltaArr && reasoningDeltaArr.length > 0) {
@@ -757,6 +884,7 @@ async function consumeSSE(response, callbacks, signal) {
 	} finally {
 		reader.releaseLock();
 	}
+	const clipForError = (args) => args.length > 200 ? `${args.slice(0, 200)}… [${args.length} chars]` : args;
 	const toolCalls = [];
 	for (const tc of tcMap.values()) {
 		if (!tc.args) {
@@ -767,15 +895,14 @@ async function consumeSSE(response, callbacks, signal) {
 			});
 			continue;
 		}
-		try {
-			toolCalls.push({
-				id: tc.id,
-				name: tc.name,
-				input: JSON.parse(tc.args)
-			});
-		} catch (err) {
-			throw new OpenAICompatStreamError(`Tool call "${tc.name}" (${tc.id}) arguments were truncated or malformed: ${errorMessage(err)}`);
-		}
+		const parsed = parseToolCallArguments(tc.args);
+		if (!parsed) throw new OpenAICompatStreamError(`Tool call "${tc.name}" (${tc.id}) arguments were truncated or malformed beyond repair: ${clipForError(tc.args)}`);
+		if (parsed.repaired && !sawTerminator) throw new OpenAICompatStreamError(`Tool call "${tc.name}" (${tc.id}) arguments were cut off by a truncated stream: ${clipForError(tc.args)}`);
+		toolCalls.push({
+			id: tc.id,
+			name: tc.name,
+			input: parsed.input
+		});
 	}
 	const reasoningDetails = Array.from(reasoningMap.entries()).sort(([a], [b]) => a - b).map(([, item]) => item);
 	return {
@@ -1110,6 +1237,21 @@ function toOAIMessages(system, messages, options = {}) {
 }
 const EPHEMERAL = { type: "ephemeral" };
 /**
+* `cache_control` for the requested TTL. Same contract as the Anthropic
+* provider's `cacheControlFor`: `'5m'`/unset keeps the bare ephemeral shape so
+* default requests stay byte-identical to every prior zidane version; `'1h'`
+* adds the `ttl` field, which OpenRouter forwards to Anthropic-family routes
+* (measured: accepted with normal cache writes/reads, no beta header needed on
+* that path — OpenRouter manages upstream headers itself). Routes that ignore
+* `cache_control` entirely ignore the ttl with it.
+*/
+function oaiCacheControlFor(ttl) {
+	return ttl === "1h" ? {
+		type: "ephemeral",
+		ttl: "1h"
+	} : EPHEMERAL;
+}
+/**
 * Add `cache_control: { type: 'ephemeral' }` breakpoints to the system message's
 * last text part and the last message's final content part.
 *
@@ -1133,12 +1275,13 @@ const EPHEMERAL = { type: "ephemeral" };
 * omit it (or pass a marker-free string) for the single-block historic
 * behavior.
 */
-function applyOAICacheBreakpoints(messages, originalSystem) {
+function applyOAICacheBreakpoints(messages, originalSystem, ttl) {
 	if (messages.length === 0) return;
+	const cacheControl = oaiCacheControlFor(ttl);
 	const first = messages[0];
-	if (first.role === "system") markSystemMessage(first, originalSystem);
+	if (first.role === "system") markSystemMessage(first, cacheControl, originalSystem);
 	const lastIdx = messages.length - 1;
-	if (lastIdx > 0) markLastContentPart(messages[lastIdx]);
+	if (lastIdx > 0) markLastContentPart(messages[lastIdx], cacheControl);
 }
 /**
 * Place the cache marker on the static prefix of the system message. When
@@ -1152,9 +1295,9 @@ function applyOAICacheBreakpoints(messages, originalSystem) {
 * that supply pre-built multi-part system messages bypass this branch and
 * get the generic last-block treatment.
 */
-function markSystemMessage(msg, originalSystem) {
+function markSystemMessage(msg, cacheControl, originalSystem) {
 	if (typeof msg.content !== "string" || msg.content.length === 0) {
-		markLastContentPart(msg);
+		markLastContentPart(msg, cacheControl);
 		return;
 	}
 	const parts = splitSystemPrompt(originalSystem && originalSystem.length > 0 ? originalSystem : msg.content);
@@ -1162,7 +1305,7 @@ function markSystemMessage(msg, originalSystem) {
 		msg.content = [{
 			type: "text",
 			text: parts.static,
-			cache_control: EPHEMERAL
+			cache_control: cacheControl
 		}];
 		return;
 	}
@@ -1170,7 +1313,7 @@ function markSystemMessage(msg, originalSystem) {
 	if (parts.static.length > 0) next.push({
 		type: "text",
 		text: parts.static,
-		cache_control: EPHEMERAL
+		cache_control: cacheControl
 	});
 	next.push({
 		type: "text",
@@ -1186,13 +1329,13 @@ function markSystemMessage(msg, originalSystem) {
 * No-op for messages without string or array content (tool-call-only assistant
 * messages fall through; the system/tools breakpoints carry the cache prefix).
 */
-function markLastContentPart(msg) {
+function markLastContentPart(msg, cacheControl = EPHEMERAL) {
 	if (typeof msg.content === "string") {
 		if (msg.content.length === 0) return;
 		msg.content = [{
 			type: "text",
 			text: msg.content,
-			cache_control: EPHEMERAL
+			cache_control: cacheControl
 		}];
 		return;
 	}
@@ -1201,7 +1344,7 @@ function markLastContentPart(msg) {
 	const lastBlockIdx = parts.length - 1;
 	parts[lastBlockIdx] = {
 		...parts[lastBlockIdx],
-		cache_control: EPHEMERAL
+		cache_control: cacheControl
 	};
 }
 /**
@@ -1211,12 +1354,13 @@ function markLastContentPart(msg) {
 * and forwards it when routing to Anthropic/Gemini. Leaves the non-cached tools
 * unchanged so the caller's reference is not mutated.
 */
-function applyOAIToolCacheBreakpoint(tools) {
+function applyOAIToolCacheBreakpoint(tools, ttl) {
 	if (tools.length === 0) return tools;
+	const cacheControl = oaiCacheControlFor(ttl);
 	const lastIdx = tools.length - 1;
 	return tools.map((tool, i) => i === lastIdx ? {
 		...tool,
-		cache_control: EPHEMERAL
+		cache_control: cacheControl
 	} : tool);
 }
 function formatTools(tools) {
@@ -1537,7 +1681,7 @@ function openaiCompat(params) {
 		async stream(options, callbacks) {
 			const modelId = options.model || defaultModel;
 			const inputTools = options.tools ?? [];
-			const nameBoundary = createOpenAIToolNameBoundary(options.messages, inputTools.map((tool) => tool.function.name));
+			const nameBoundary = createToolNameBoundary(options.messages, inputTools.map((tool) => tool.function.name));
 			const messages = toOAIMessages(options.system, nameBoundary.messages, {
 				imageInToolResult: capabilities.imageInToolResult === true,
 				audio: capabilities.audio === true,
@@ -1550,7 +1694,7 @@ function openaiCompat(params) {
 				model: modelId
 			});
 			const shouldCache = cacheBreakpointsEnabled && options.cache !== false;
-			if (shouldCache) applyOAICacheBreakpoints(messages, options.system);
+			if (shouldCache) applyOAICacheBreakpoints(messages, options.system, options.cacheTtl);
 			const maxTokens = options.maxTokens === void 0 ? void 0 : options.thinkingBudget ? options.thinkingBudget + options.maxTokens : options.maxTokens;
 			const reasoningBody = params.planReasoningRequest?.({
 				model: modelId,
@@ -1584,7 +1728,7 @@ function openaiCompat(params) {
 						name: nameBoundary.toWire(tool.function.name)
 					}
 				}));
-				body.tools = shouldCache ? applyOAIToolCacheBreakpoint(tools) : tools;
+				body.tools = shouldCache ? applyOAIToolCacheBreakpoint(tools, options.cacheTtl) : tools;
 			}
 			if (options.toolChoice) if (options.toolChoice.type === "tool" && options.toolChoice.name) body.tool_choice = {
 				type: "function",
@@ -1652,6 +1796,6 @@ function openaiCompat(params) {
 	};
 }
 //#endregion
-export { canonicalizePrompt as C, buildPromptMessage as S, unsupportedMediaError as T, userMessage as _, applyOAICacheBreakpoints as a, createOpenAIToolNameBoundary as b, buildAssistantContent as c, formatTools as d, mapOAIFinishReason as f, toolResultsMessage as g, toOAIMessages as h, TOOL_RESULTS_TAG as i, classifyOpenAICompatError as l, openaiCompat as m, OpenAICompatHttpError as n, applyOAIToolCacheBreakpoint as o, openAICompatPromptMessage as p, OpenAICompatStreamError as r, assistantMessage as s, ASSISTANT_TOOL_CALLS_TAG as t, consumeSSE as u, sanitizeToolSchema as v, defaultPromptMessage as w, fillEstimatedCost as x, sanitizeToolSpecs as y };
+export { buildPromptMessage as C, unsupportedMediaError as E, fillEstimatedCost as S, defaultPromptMessage as T, userMessage as _, applyOAICacheBreakpoints as a, sanitizeToolSpecs as b, buildAssistantContent as c, formatTools as d, mapOAIFinishReason as f, toolResultsMessage as g, toOAIMessages as h, TOOL_RESULTS_TAG as i, classifyOpenAICompatError as l, openaiCompat as m, OpenAICompatHttpError as n, applyOAIToolCacheBreakpoint as o, openAICompatPromptMessage as p, OpenAICompatStreamError as r, assistantMessage as s, ASSISTANT_TOOL_CALLS_TAG as t, consumeSSE as u, createToolNameBoundary as v, canonicalizePrompt as w, estimateRebilledCostUsd as x, sanitizeToolSchema as y };
 
-//# sourceMappingURL=openai-compat-C77gOaHh.js.map
+//# sourceMappingURL=openai-compat-DHlBIjj9.js.map