zidane 6.5.4 → 6.5.6

package/dist/agent.d.ts

@@ -1,2 +1,2 @@
-import { $r as createRunSummaryCollector, Af as CacheDriftInfo, Df as CacheDimensionDiff, Ef as CacheBreakLoggerOptions, Ff as snapshotCacheDimensions, Gi as AgentHookMap, Gr as RunSummaryBudget, Hh as ReadStateEntry, Jh as readStateKey, Ji as McpConnector, Jr as RunSummaryCollectorOptions, Kh as hydrateReadStateFromSession, Ki as AgentHooks, Kr as RunSummaryByModel, Mf as fnv1a32, Nf as hashMessages, Of as CacheDimensionName, Pf as installCacheBreakLogger, Qr as RunSummaryValidation, Tf as CacheBreakInfo, Uh as ReadStateMap, Ur as RunSummary, Vh as HydrateReadStateOptions, Wh as getReadState, Wi as Agent, Wr as RunSummaryBlock, Xi as McpToolWrap, Xr as RunSummaryRepeatGuard, Yh as resolveReadStateMap, Yi as McpToolMeta, Yr as RunSummaryError, Zi as createAgent, Zr as RunSummaryTokens, jf as diffCacheDimensions, kf as CacheDimensionSnapshot, qh as hydrateReadStateFromSessionAsync, qi as AgentOptions, qr as RunSummaryCollector } from "./index-BSNr0OQn.js";
+import { $h as hydrateReadStateFromSessionAsync, $r as createRunSummaryCollector, Bf as installCacheBreakLogger, Ff as CacheDimensionSnapshot, Gi as AgentHookMap, Gr as RunSummaryBudget, If as CacheDriftInfo, Jh as ReadStateEntry, Ji as McpConnector, Jr as RunSummaryCollectorOptions, Ki as AgentHooks, Kr as RunSummaryByModel, Lf as diffCacheDimensions, Mf as CacheBreakLoggerOptions, Nf as CacheDimensionDiff, Pf as CacheDimensionName, Qh as hydrateReadStateFromSession, Qr as RunSummaryValidation, Rf as fnv1a32, Ur as RunSummary, Vf as snapshotCacheDimensions, Wi as Agent, Wr as RunSummaryBlock, Xh as getReadState, Xi as McpToolWrap, Xr as RunSummaryRepeatGuard, Yh as ReadStateMap, Yi as McpToolMeta, Yr as RunSummaryError, Zi as createAgent, Zr as RunSummaryTokens, eg as readStateKey, jf as CacheBreakInfo, qh as HydrateReadStateOptions, qi as AgentOptions, qr as RunSummaryCollector, tg as resolveReadStateMap, zf as hashMessages } from "./index-ZWibV230.js";
 export { type Agent, type AgentHookMap, type AgentHooks, type AgentOptions, type CacheBreakInfo, type CacheBreakLoggerOptions, type CacheDimensionDiff, type CacheDimensionName, type CacheDimensionSnapshot, type CacheDriftInfo, type HydrateReadStateOptions, type McpConnector, type McpToolMeta, type McpToolWrap, type ReadStateEntry, type ReadStateMap, type RunSummary, type RunSummaryBlock, type RunSummaryBudget, type RunSummaryByModel, type RunSummaryCollector, type RunSummaryCollectorOptions, type RunSummaryError, type RunSummaryRepeatGuard, type RunSummaryTokens, type RunSummaryValidation, createAgent, createRunSummaryCollector, diffCacheDimensions, fnv1a32, getReadState, hashMessages, hydrateReadStateFromSession, hydrateReadStateFromSessionAsync, installCacheBreakLogger, readStateKey, resolveReadStateMap, snapshotCacheDimensions };

package/dist/agent.js

@@ -1,4 +1,4 @@
-import { In as hydrateReadStateFromSession, Ln as hydrateReadStateFromSessionAsync, Pn as getReadState, Rn as readStateKey, t as createAgent, zn as resolveReadStateMap } from "./agent-8kfGIDb_.js";
+import { Bn as hydrateReadStateFromSessionAsync, Hn as resolveReadStateMap, Ln as getReadState, Vn as readStateKey, t as createAgent, zn as hydrateReadStateFromSession } from "./agent-CcTWL-Z6.js";
 import { a as snapshotCacheDimensions, i as installCacheBreakLogger, n as fnv1a32, r as hashMessages, t as diffCacheDimensions } from "./cache-telemetry-ehVdWsg2.js";
 import { t as createRunSummaryCollector } from "./run-summary-BU_NgwUT.js";
 export { createAgent, createRunSummaryCollector, diffCacheDimensions, fnv1a32, getReadState, hashMessages, hydrateReadStateFromSession, hydrateReadStateFromSessionAsync, installCacheBreakLogger, readStateKey, resolveReadStateMap, snapshotCacheDimensions };

package/dist/{anthropic-qaw8XAc9.js → anthropic-DLc_Kw-1.js}

@@ -1,9 +1,12 @@
-import { F as unsupportedMediaError, S as resolvePromptCacheKey, b as sanitizeToolSpecs, k as lookupModel, v as createToolNameBoundary, w as fillEstimatedCost } from "./openai-compat-CnHeo4Lz.js";
+import { F as unsupportedMediaError, S as resolvePromptCacheKey, b as sanitizeToolSpecs, k as lookupModel, v as createToolNameBoundary, w as fillEstimatedCost } from "./openai-compat-BoTi-9fd.js";
 import { t as lazyAsync } from "./lazy-DLOurOC_.js";
-import { f as isRetryableHttpStatus, l as classifyErrorPrelude, m as matchesToolPairingError, p as matchesContextExceeded, u as errorMessage } from "./errors-BwBxu3zD.js";
+import { f as isRetryableHttpStatus, h as matchesToolPairingError, l as classifyErrorPrelude, m as matchesContextExceeded, u as errorMessage } from "./errors-DKiMrOKq.js";
 import { renderSystemForWire, splitSystemPrompt } from "./prompt.js";
-import { g as toAnthropic, u as fromAnthropic } from "./messages-C_H9soi5.js";
-import { a as readOAuthCredentials, r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "./oauth-ZebH9NHb.js";
+import { g as toAnthropic, u as fromAnthropic } from "./messages-CZMUuKzo.js";
+import { a as readOAuthCredentials, r as extractRuntimeCredentials, s as resolveOAuthApiKey } from "./oauth-C4GvY_p1.js";
+import { Buffer } from "node:buffer";
+import { arch, homedir, hostname, platform, userInfo } from "node:os";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/chat/anthropic-models.ts
 /**
 * Anthropic "fast mode" — `speed: "fast"` on the Messages API. ~2.5× output
@@ -123,6 +126,324 @@ const ANTHROPIC_EXTRA_MODELS = [
 	}
 ];
 //#endregion
+//#region src/providers/anthropic-claude-code.ts
+/**
+* Claude Code client alignment for Anthropic subscription OAuth.
+*
+* Anthropic's subscription endpoint serves the Claude Code CLI. Requests that
+* do not look like that client are, at best, treated as a different product; at
+* worst they miss features the CLI relies on. This module holds every surface
+* that has to match, in one file, so a client bump is one edit rather than a
+* scavenger hunt through the provider.
+*
+* Modelled on `@pi-plugins/claude-oauth`, which maintains the same alignment
+* for pi and verifies its pins against a live client trace. Everything here is
+* scoped to the OAuth path — API-key, gateway-bearer and Bedrock requests never
+* reach it.
+*/
+/**
+* Pinned Claude Code client versions.
+*
+* These travel together: the billing fingerprint below hashes
+* {@link CLAUDE_CODE_VERSION}, so bumping one without the others produces a
+* value that does not correspond to any real client. Re-check all five against
+* the upstream plugin's `constants.ts` when bumping.
+*/
+const CLAUDE_CODE_VERSION = "2.1.165";
+const CLAUDE_AGENT_SDK_VERSION = "0.3.165";
+const CLAUDE_CLIENT_VERSION = "1.11187.4";
+const CLAUDE_CODE_STAINLESS_PACKAGE_VERSION = "0.94.0";
+const CLAUDE_CODE_STAINLESS_RUNTIME_VERSION = "v24.3.0";
+/**
+* Claude Code caps requested output at 64k even where the model ceiling is
+* higher (Opus allows 128k). Requests above the cap are clamped to match.
+*/
+const CLAUDE_CODE_MAX_OUTPUT_TOKENS = 64e3;
+/**
+* Tool names the Claude subscription backend reserves.
+*
+* A tool named exactly `todowrite` is classified as a paid Claude product
+* surface: the otherwise-valid OAuth request is refused with "You're out of
+* extra usage" when the account has no purchased usage credits. The same body
+* succeeds when only that wire name changes.
+*/
+const CLAUDE_CODE_RESERVED_TOOL_NAMES = ["todowrite"];
+const RESERVED_TOOL_ALIAS_PREFIX = "zidane_";
+/**
+* Request-local wire aliases that move reserved names out of the way, for
+* Claude subscription OAuth only.
+*
+* Resolved against the request's FULL name set (history + current specs) rather
+* than hardcoded, because the obvious alias is itself a legal tool name: an
+* extension shipping `zidane_todowrite` alongside `todowrite` would otherwise
+* make the boundary throw on a collision it can trivially avoid. Suffixing is
+* deterministic, so the wire bytes — and the provider prompt cache — stay
+* stable across turns with the same tool set.
+*
+* Canonical names are restored at the provider boundary, so dispatch, hooks,
+* persistence, and other auth modes never see the alias.
+*/
+function claudeCodeToolAliases(names) {
+	let aliases;
+	const taken = new Set(names);
+	for (const reserved of CLAUDE_CODE_RESERVED_TOOL_NAMES) {
+		if (!names.has(reserved)) continue;
+		let candidate = `${RESERVED_TOOL_ALIAS_PREFIX}${reserved}`;
+		for (let n = 2; taken.has(candidate); n++) candidate = `${RESERVED_TOOL_ALIAS_PREFIX}${reserved}_${n}`;
+		taken.add(candidate);
+		aliases ??= {};
+		aliases[reserved] = candidate;
+	}
+	return aliases;
+}
+/**
+* Beta set the Claude Code agent sends, in client order.
+*
+* Sent as one unit: the endpoint is configured for this combination, and
+* trimming it to "the ones we think we use" is how a client stops looking like
+* the client. Betas without matching request fields are inert.
+*/
+const CLAUDE_CODE_BETAS = [
+	"claude-code-20250219",
+	"oauth-2025-04-20",
+	"interleaved-thinking-2025-05-14",
+	"fine-grained-tool-streaming-2025-05-14",
+	"context-management-2025-06-27",
+	"prompt-caching-scope-2026-01-05",
+	"mid-conversation-system-2026-04-07",
+	"advanced-tool-use-2025-11-20",
+	"effort-2025-11-24",
+	"extended-cache-ttl-2025-04-11"
+];
+/** Billing-header pins. See {@link claudeCodeBillingText}. */
+const BILLING_FINGERPRINT_SALT = "59cf53e54c78";
+const BILLING_FINGERPRINT_INDICES = [
+	4,
+	7,
+	20
+];
+const BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
+const CCH_PLACEHOLDER = "cch=00000";
+const CCH_SEED = 5577024349156291176n;
+/** `os.arch()` values mapped to the labels Stainless emits. */
+function stainlessArch(value) {
+	switch (value.toLowerCase()) {
+		case "amd64":
+		case "x64": return "x64";
+		case "arm64":
+		case "aarch64": return "arm64";
+		case "386":
+		case "x86":
+		case "ia32": return "x86";
+		default: return `other::${value.toLowerCase()}`;
+	}
+}
+/** `os.platform()` values mapped to the labels Stainless emits. */
+function stainlessOs(value) {
+	switch (value.toLowerCase()) {
+		case "darwin": return "MacOS";
+		case "win32":
+		case "windows": return "Windows";
+		case "linux": return "Linux";
+		case "freebsd": return "FreeBSD";
+		default: return `Other::${value.toLowerCase()}`;
+	}
+}
+/**
+* Headers a Claude Code OAuth request carries.
+*
+* The `x-stainless-*` entries deliberately OVERRIDE the ones the Anthropic SDK
+* generates about itself: left alone they advertise `Anthropic/JS <sdk version>`
+* on a request claiming to be the CLI, which is a contradiction no real client
+* produces.
+*/
+function buildClaudeCodeHeaders() {
+	return {
+		"user-agent": `claude-cli/${CLAUDE_CODE_VERSION} (external, local-agent, agent-sdk/${CLAUDE_AGENT_SDK_VERSION})`,
+		"x-app": "cli",
+		"anthropic-dangerous-direct-browser-access": "true",
+		"x-stainless-retry-count": "0",
+		"x-stainless-runtime-version": CLAUDE_CODE_STAINLESS_RUNTIME_VERSION,
+		"x-stainless-package-version": CLAUDE_CODE_STAINLESS_PACKAGE_VERSION,
+		"x-stainless-runtime": "node",
+		"x-stainless-lang": "js",
+		"x-stainless-arch": stainlessArch(arch()),
+		"x-stainless-os": stainlessOs(platform()),
+		"x-stainless-timeout": "900",
+		"anthropic-client-platform": "desktop_app",
+		"anthropic-client-version": CLAUDE_CLIENT_VERSION
+	};
+}
+/**
+* Text of the `system[0]` billing block.
+*
+* The version suffix is `sha256(salt + msg[4] + msg[7] + msg[20] + version)`
+* truncated to 3 hex chars, where the indices sample the first user message.
+* Missing characters (a first message shorter than 21 chars) contribute `'0'`,
+* matching the client rather than throwing.
+*
+* The `cch` field ships as {@link CCH_PLACEHOLDER} and is overwritten by
+* {@link patchCch} once the body is serialized — it hashes those very bytes, so
+* it cannot be computed here.
+*/
+function claudeCodeBillingText(firstUserMessage) {
+	const seed = BILLING_FINGERPRINT_INDICES.map((i) => firstUserMessage[i] ?? "0").join("");
+	const suffix = createHash("sha256").update(`${BILLING_FINGERPRINT_SALT}${seed}${CLAUDE_CODE_VERSION}`).digest("hex").slice(0, 3);
+	return `${BILLING_HEADER_PREFIX} cc_version=${CLAUDE_CODE_VERSION}.${suffix}; cc_entrypoint=local-agent; ${CCH_PLACEHOLDER};`;
+}
+/** Concatenated text of the first user message — the fingerprint's sample source. */
+function firstUserMessageText(messages) {
+	const content = messages.find((m) => m.role === "user")?.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content.filter((b) => !!b && typeof b === "object" && b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+}
+/**
+* Machine-stable device id + per-process session id, sent as
+* `metadata.user_id`'s JSON envelope.
+*
+* `userInfo()` throws in locked-down sandboxes, so the seed degrades to the
+* hostname rather than taking the process down.
+*/
+function machineSeed() {
+	try {
+		return `${hostname()}:${userInfo().username}:${homedir()}`;
+	} catch {
+		return `${hostname()}:zidane-claude-code-fallback`;
+	}
+}
+const DEVICE_ID = createHash("sha256").update(`zidane-claude-code-device-v1:${machineSeed()}`).digest("hex");
+const SESSION_ID = randomUUID();
+/** The `metadata.user_id` envelope Claude Code sends. */
+function claudeCodeUserId() {
+	return JSON.stringify({
+		device_id: DEVICE_ID,
+		session_id: SESSION_ID
+	});
+}
+const MASK = (1n << 64n) - 1n;
+const PRIME64_1 = 11400714785074694791n;
+const PRIME64_2 = 14029467366897019727n;
+const PRIME64_3 = 1609587929392839161n;
+const PRIME64_4 = 9650029242287828579n;
+const PRIME64_5 = 2870177450012600261n;
+const rotl = (x, r) => (x << r | x >> 64n - r) & MASK;
+function round(acc, input) {
+	const next = acc + input * PRIME64_2 & MASK;
+	return rotl(next, 31n) * PRIME64_1 & MASK;
+}
+function mergeRound(acc, val) {
+	return ((acc ^ round(0n, val)) * PRIME64_1 & MASK) + PRIME64_4 & MASK;
+}
+/**
+* XXH64, reproducing Claude Code's `cch` request-integrity value.
+*
+* Ported rather than delegated to `Bun.hash.xxHash64` so the result cannot
+* drift with a runtime's hash implementation or seed handling, and so the
+* provider still works off-Bun. Verified against published XXH64 vectors.
+*/
+function xxHash64(input, seed) {
+	const len = input.length;
+	const dv = new DataView(input.buffer, input.byteOffset, input.byteLength);
+	let h64;
+	let p = 0;
+	if (len >= 32) {
+		let v1 = seed + PRIME64_1 + PRIME64_2 & MASK;
+		let v2 = seed + PRIME64_2 & MASK;
+		let v3 = seed & MASK;
+		let v4 = seed - PRIME64_1 & MASK;
+		const limit = len - 32;
+		while (p <= limit) {
+			v1 = round(v1, dv.getBigUint64(p, true));
+			p += 8;
+			v2 = round(v2, dv.getBigUint64(p, true));
+			p += 8;
+			v3 = round(v3, dv.getBigUint64(p, true));
+			p += 8;
+			v4 = round(v4, dv.getBigUint64(p, true));
+			p += 8;
+		}
+		h64 = rotl(v1, 1n) + rotl(v2, 7n) + rotl(v3, 12n) + rotl(v4, 18n) & MASK;
+		h64 = mergeRound(h64, v1);
+		h64 = mergeRound(h64, v2);
+		h64 = mergeRound(h64, v3);
+		h64 = mergeRound(h64, v4);
+	} else h64 = seed + PRIME64_5 & MASK;
+	h64 = h64 + BigInt(len) & MASK;
+	while (p + 8 <= len) {
+		h64 ^= round(0n, dv.getBigUint64(p, true));
+		h64 = rotl(h64, 27n) * PRIME64_1 & MASK;
+		h64 = h64 + PRIME64_4 & MASK;
+		p += 8;
+	}
+	if (p + 4 <= len) {
+		h64 ^= BigInt(dv.getUint32(p, true)) * PRIME64_1 & MASK;
+		h64 = rotl(h64, 23n) * PRIME64_2 & MASK;
+		h64 = h64 + PRIME64_3 & MASK;
+		p += 4;
+	}
+	while (p < len) {
+		h64 ^= BigInt(input[p] ?? 0) * PRIME64_5 & MASK;
+		h64 = rotl(h64, 11n) * PRIME64_1 & MASK;
+		p += 1;
+	}
+	h64 ^= h64 >> 33n;
+	h64 = h64 * PRIME64_2 & MASK;
+	h64 ^= h64 >> 29n;
+	h64 = h64 * PRIME64_3 & MASK;
+	h64 ^= h64 >> 32n;
+	return h64 & MASK;
+}
+const encoder = new TextEncoder();
+/**
+* Anchor for the placeholder search. The SDK serializes `messages` before
+* `system`, so these bytes can only belong to the block we injected — user
+* content that happens to contain `cch=00000` can never match.
+*/
+const BILLING_SYSTEM_MARKER = encoder.encode(`"system":[{"type":"text","text":"${BILLING_HEADER_PREFIX}`);
+const CCH_PLACEHOLDER_BYTES = encoder.encode(CCH_PLACEHOLDER);
+/** The placeholder must sit this close to the marker, else system[0] was reshaped. */
+const CCH_SEARCH_WINDOW = 150;
+/**
+* Overwrite the `cch` placeholder with `XXH64(body) & 0xfffff`, in place.
+*
+* Returns the original bytes untouched when the placeholder is absent or not
+* anchored to `system[0]` — a request that goes out with the placeholder intact
+* is far better than one whose user content was corrupted by a stray patch.
+*/
+function patchCch(encoded) {
+	const view = Buffer.from(encoded.buffer, encoded.byteOffset, encoded.byteLength);
+	const markerIdx = view.indexOf(BILLING_SYSTEM_MARKER);
+	if (markerIdx === -1) return encoded;
+	const searchFrom = markerIdx + BILLING_SYSTEM_MARKER.length;
+	const placeholderIdx = view.indexOf(CCH_PLACEHOLDER_BYTES, searchFrom);
+	if (placeholderIdx === -1 || placeholderIdx - searchFrom > CCH_SEARCH_WINDOW) return encoded;
+	const cch = (xxHash64(encoded, CCH_SEED) & 1048575n).toString(16).padStart(5, "0");
+	for (let i = 0; i < 5; i++) encoded[placeholderIdx + 4 + i] = cch.charCodeAt(i);
+	return encoded;
+}
+/**
+* Wrap a `fetch` so bodies carrying the placeholder get their attestation
+* patched after serialization.
+*
+* Handed to the Anthropic SDK per client rather than installed on
+* `globalThis` — every other request in the process stays untouched, and two
+* providers cannot fight over the global.
+*/
+function wrapFetchForCch(base) {
+	const wrapped = (input, init) => {
+		const body = init?.body;
+		let finalBody = body;
+		if (typeof body === "string" && body.includes("cch=00000")) finalBody = patchCch(encoder.encode(body));
+		return base(input, finalBody === body ? init : {
+			...init,
+			body: finalBody
+		});
+	};
+	wrapped.preconnect = base.preconnect?.bind(base) ?? (() => {});
+	return wrapped;
+}
+//#endregion
 //#region src/providers/anthropic.ts
 const loadAnthropicSdk = lazyAsync(async () => {
 	try {
@@ -156,8 +477,15 @@ function normalizeBedrock(value) {
 	if (!value) return void 0;
 	return value === true ? {} : value;
 }
-/** Beta flags sent unconditionally on the OAuth path (Claude Code parity). */
-const OAUTH_DEFAULT_BETAS = ["claude-code-20250219", "oauth-2025-04-20"];
+/**
+* Beta flags sent unconditionally on the OAuth path (Claude Code parity).
+*
+* The full client set, sent as one unit — see `CLAUDE_CODE_BETAS`. Betas whose
+* request fields we never populate are inert, so the cost of matching the
+* client exactly is nil while the cost of guessing a subset is looking like a
+* different client.
+*/
+const OAUTH_DEFAULT_BETAS = CLAUDE_CODE_BETAS;
 /**
 * Beta flag that enables the `speed: "fast"` request field (fast mode — up to
 * 2.5× output tokens/sec at premium pricing; supported models are enumerated
@@ -170,7 +498,18 @@ const OAUTH_DEFAULT_BETAS = ["claude-code-20250219", "oauth-2025-04-20"];
 const FAST_MODE_BETA = "fast-mode-2026-02-01";
 const API_KEY_RESERVED_EXTRA_HEADER_NAMES = /* @__PURE__ */ new Set(["anthropic-beta"]);
 const OAUTH_RESERVED_EXTRA_HEADER_NAMES = /* @__PURE__ */ new Set([
+	"accept",
 	"anthropic-beta",
+	"anthropic-client-platform",
+	"anthropic-client-version",
+	"x-stainless-arch",
+	"x-stainless-lang",
+	"x-stainless-os",
+	"x-stainless-package-version",
+	"x-stainless-retry-count",
+	"x-stainless-runtime",
+	"x-stainless-runtime-version",
+	"x-stainless-timeout",
 	"anthropic-dangerous-direct-browser-access",
 	"user-agent",
 	"x-app"
@@ -280,9 +619,8 @@ function buildAnthropicClientOptions(apiKey, auth, baseURL, extraBetas, extraHea
 	if (auth.claudeCode) {
 		const defaultHeaders = {
 			...filterReservedExtraHeaders(extraHeaders, OAUTH_RESERVED_EXTRA_HEADER_NAMES),
-			"anthropic-dangerous-direct-browser-access": "true",
-			"user-agent": "zidane/2.0.0",
-			"x-app": "cli"
+			accept: "application/json",
+			...buildClaudeCodeHeaders()
 		};
 		if (betaHeader) defaultHeaders["anthropic-beta"] = betaHeader;
 		return {
@@ -290,6 +628,7 @@ function buildAnthropicClientOptions(apiKey, auth, baseURL, extraBetas, extraHea
 			authToken: apiKey,
 			dangerouslyAllowBrowser: true,
 			defaultHeaders,
+			fetch: wrapFetchForCch(globalThis.fetch),
 			...base
 		};
 	}
@@ -711,6 +1050,12 @@ function classifyAnthropicError(err) {
 		...retryable !== void 0 ? { retryable } : {}
 	};
 }
+/** True only for a provider authentication rejection eligible for one OAuth refresh retry. */
+function isAnthropicAuthenticationError(err) {
+	if (!err || typeof err !== "object") return false;
+	const candidate = err;
+	return candidate.status === 401 || candidate.error?.type === "authentication_error" || candidate.error?.error?.type === "authentication_error";
+}
 function shouldFallbackFromFastMode(err) {
 	const classified = classifyAnthropicError(err);
 	if (classified?.kind === "provider_error" && classified.retryable === true) return true;
@@ -1063,7 +1408,7 @@ function anthropic(anthropicParams) {
 					...payload.messages
 				] : [...payload.messages];
 				const countTools = payload.tools;
-				const countBoundary = createToolNameBoundary(messages, countTools.map((t) => t.name));
+				const countBoundary = createToolNameBoundary(messages, countTools.map((t) => t.name), callIsOAuth ? claudeCodeToolAliases : void 0);
 				return (await client.messages.countTokens({
 					model: payload.model,
 					system,
@@ -1080,9 +1425,9 @@ function anthropic(anthropicParams) {
 		},
 		async stream(options, callbacks) {
 			let apiKey = "";
-			if (!bedrockConfig) {
+			const resolveCallApiKey = async (forceRefresh = false, rejectedAccess) => {
 				const identity = credentialIdentity(anthropicParams);
-				apiKey = await resolveOAuthApiKey({
+				return await resolveOAuthApiKey({
 					provider: identity.providerId,
 					providerId: identity.providerId,
 					params: runtimeCredentials ? {
@@ -1091,7 +1436,9 @@ function anthropic(anthropicParams) {
 					} : anthropicParams,
 					envKey: identity.envKey,
 					missingError: identity.missingError,
-					refreshError: identity.refreshError
+					refreshError: identity.refreshError,
+					forceRefresh,
+					rejectedAccess
 				}, {
 					...callbacks,
 					async onOAuthRefresh(ctx) {
@@ -1103,14 +1450,34 @@ function anthropic(anthropicParams) {
 						await callbacks.onOAuthRefresh?.(ctx);
 					}
 				});
-			}
+			};
+			if (!bedrockConfig) apiKey = await resolveCallApiKey();
 			const callAuth = resolveAnthropicAuthShape(apiKey, bedrockConfig ? "api-key" : anthropicParams?.authMode);
 			const callIsOAuth = callAuth.claudeCode;
-			const extendedTtl = options.cache !== false && options.cacheTtl === "1h" && !callIsOAuth && !bedrockConfig;
-			const conditionalBetas = [...options.modelOptions?.fast ? [FAST_MODE_BETA] : [], ...extendedTtl ? [EXTENDED_CACHE_TTL_BETA] : []];
+			/**
+			* Whether a provider auth rejection on this call is worth ATTEMPTING one
+			* forced credential rotation. A bearer-authenticated call MAY resolve its
+			* token through the refreshable OAuth store — subscription OAuth and
+			* `authMode: 'bearer'` gateways (`extensions/bolt`) both do — so a 401
+			* arriving before the local expiry is recoverable for them. Deliberately
+			* WIDER than {@link callIsOAuth}, which additionally means "wear the
+			* Claude Code persona"; a gateway is not Claude Code but its token still
+			* rotates.
+			*
+			* The ones that cannot rotate stop at the identical-credential guard in
+			* the recovery below rather than being excluded here: a static bearer
+			* token supplied as `apiKey` short-circuits `resolveOAuthApiKey` and never
+			* reaches the store, so the re-resolve returns the same value and costs
+			* nothing but a function call. API-key and Bedrock calls never get that
+			* far — `callAuth.bearer` is false for both.
+			*/
+			const callCanRotateAuth = callAuth.bearer;
+			const effectiveCacheTtl = options.cacheTtl ?? (callIsOAuth ? "1h" : void 0);
+			const extendedTtl = options.cache !== false && effectiveCacheTtl === "1h" && !bedrockConfig;
+			const conditionalBetas = [...options.modelOptions?.fast && !callIsOAuth ? [FAST_MODE_BETA] : [], ...extendedTtl ? [EXTENDED_CACHE_TTL_BETA] : []];
 			const requestBetas = conditionalBetas.length > 0 ? [...anthropicParams?.extraBetas ?? [], ...conditionalBetas] : anthropicParams?.extraBetas;
 			const resolvedExtraHeaders = await resolveExtraHeaders(anthropicParams?.extraHeaders);
-			const client = bedrockConfig ? await createBedrockClient(bedrockConfig, anthropicParams, resolvedExtraHeaders) : createClient(await loadAnthropicSdk(), apiKey, callAuth, anthropicParams?.baseURL, requestBetas, resolvedExtraHeaders);
+			let client = bedrockConfig ? await createBedrockClient(bedrockConfig, anthropicParams, resolvedExtraHeaders) : createClient(await loadAnthropicSdk(), apiKey, callAuth, anthropicParams?.baseURL, requestBetas, resolvedExtraHeaders);
 			const wireSystem = renderSystemForWire(options.system);
 			const system = callIsOAuth ? `You are Claude Code, Anthropic's official CLI for Claude.` : wireSystem;
 			const messages = callIsOAuth && options.system ? [
@@ -1132,7 +1499,7 @@ function anthropic(anthropicParams) {
 			] : [...options.messages];
 			const thinking = options.thinking ?? "off";
 			const inputTools = options.tools ?? [];
-			const nameBoundary = createToolNameBoundary(messages, inputTools.map((t) => t.name));
+			const nameBoundary = createToolNameBoundary(messages, inputTools.map((t) => t.name), callIsOAuth ? claudeCodeToolAliases : void 0);
 			const wireTools = nameBoundary.changed ? inputTools.map((t) => t.name === nameBoundary.toWire(t.name) ? t : {
 				...t,
 				name: nameBoundary.toWire(t.name)
@@ -1149,7 +1516,7 @@ function anthropic(anthropicParams) {
 				stream: true
 			};
 			if (anthropicParams?.contextManagement && !bedrockConfig) params.context_management = anthropicParams.contextManagement;
-			if (options.cache !== false) applyAnthropicCacheBreakpoints(params, callIsOAuth ? void 0 : options.system, extendedTtl ? options.cacheTtl : void 0);
+			if (options.cache !== false) applyAnthropicCacheBreakpoints(params, callIsOAuth ? void 0 : options.system, extendedTtl ? effectiveCacheTtl : void 0);
 			const plan = planAnthropicThinking(thinking, options.thinkingBudget, options.taskBudget, options.effortHint !== false);
 			if (plan && bedrockConfig) {
 				const budget = plan.kind === "enabled" ? plan.budgetTokens : BEDROCK_THINKING_BUDGETS[plan.effort ?? "medium"];
@@ -1191,6 +1558,17 @@ function anthropic(anthropicParams) {
 				params.temperature = 1;
 			}
 			params.max_tokens = Math.min(params.max_tokens, modelMaxOutput);
+			if (callIsOAuth) {
+				params.max_tokens = Math.min(params.max_tokens, CLAUDE_CODE_MAX_OUTPUT_TOKENS);
+				if (Array.isArray(params.system)) params.system = [{
+					type: "text",
+					text: claudeCodeBillingText(firstUserMessageText(params.messages))
+				}, ...params.system];
+				if (typeof params.metadata?.user_id !== "string") params.metadata = {
+					...params.metadata,
+					user_id: claudeCodeUserId()
+				};
+			}
 			if (params.thinking?.type === "enabled" && params.thinking.budget_tokens >= params.max_tokens) {
 				const fitted = params.max_tokens - THINKING_RESPONSE_RESERVE_TOKENS;
 				if (fitted >= 1024) params.thinking.budget_tokens = fitted;
@@ -1199,7 +1577,7 @@ function anthropic(anthropicParams) {
 					delete params.temperature;
 				}
 			}
-			if (options.modelOptions?.fast) params.speed = "fast";
+			if (options.modelOptions?.fast && !callIsOAuth) params.speed = "fast";
 			if (options.toolChoice) if (options.toolChoice.type === "tool" && options.toolChoice.name) params.tool_choice = {
 				type: "tool",
 				name: nameBoundary.toWire(options.toolChoice.name)
@@ -1217,7 +1595,7 @@ function anthropic(anthropicParams) {
 			};
 			const affinityHeaderName = anthropicParams?.promptCacheKeyHeader?.toLowerCase();
 			const affinityHeader = anthropicParams?.promptCacheKeyHeader !== void 0 && promptCacheKey !== void 0 && !Object.keys(resolvedExtraHeaders ?? {}).some((k) => k.toLowerCase() === affinityHeaderName) ? { [anthropicParams.promptCacheKeyHeader]: promptCacheKey } : void 0;
-			const runStream = async (requestParams, fastRequested, scrubPass = 0) => {
+			const runStream = async (requestParams, fastRequested, scrubPass = 0, authPass = 0) => {
 				const s = client.messages.stream(requestParams, {
 					signal: options.signal,
 					...affinityHeader ? { headers: affinityHeader } : {}
@@ -1270,13 +1648,30 @@ function anthropic(anthropicParams) {
 							return await runStream({
 								...requestParams,
 								messages: scrubbed.messages
-							}, fastRequested, scrubPass + 1);
+							}, fastRequested, scrubPass + 1, authPass);
+						}
+					}
+					if (callCanRotateAuth && authPass === 0 && !observedOutput && isAnthropicAuthenticationError(err)) {
+						const rejectedAccess = apiKey;
+						let refreshedApiKey;
+						try {
+							refreshedApiKey = await resolveCallApiKey(true, rejectedAccess);
+						} catch (refreshErr) {
+							if (err !== null && typeof err === "object" && err.cause === void 0) try {
+								err.cause = refreshErr;
+							} catch {}
+							if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/anthropic] forced OAuth refresh after 401 failed: ${errorMessage(refreshErr)}\n`);
+							throw err;
 						}
+						if (refreshedApiKey === rejectedAccess) throw err;
+						apiKey = refreshedApiKey;
+						client = createClient(await loadAnthropicSdk(), apiKey, callAuth, anthropicParams?.baseURL, requestBetas, resolvedExtraHeaders);
+						return await runStream(requestParams, fastRequested, scrubPass, authPass + 1);
 					}
 					if (fastRequested && !observedOutput && shouldFallbackFromFastMode(err)) {
 						const standardParams = { ...requestParams };
 						delete standardParams.speed;
-						return await runStream(standardParams, false);
+						return await runStream(standardParams, false, scrubPass, authPass);
 					}
 					throw err;
 				}
@@ -1312,11 +1707,11 @@ function anthropic(anthropicParams) {
 					usage
 				};
 			};
-			return await runStream(params, options.modelOptions?.fast === true);
+			return await runStream(params, options.modelOptions?.fast === true && !callIsOAuth);
 		}
 	};
 }
 //#endregion
 export { classifyAnthropicError as a, planAnthropicThinking as c, resolveAnthropicMaxOutput as d, ANTHROPIC_EXTRA_MODELS as f, buildAnthropicClientOptions as i, resolveAnthropicAuthShape as l, anthropic as n, credentialIdentity as o, FAST_MODE_OPTIONS as p, applyAnthropicCacheBreakpoints as r, defaultAnthropicMaxTokens as s, EXTENDED_CACHE_TTL_BETA as t, resolveAnthropicBetas as u };
 
-//# sourceMappingURL=anthropic-qaw8XAc9.js.map
+//# sourceMappingURL=anthropic-DLc_Kw-1.js.map