zidane 6.5.5 → 6.5.7

package/dist/agent.d.ts

@@ -1,2 +1,2 @@
-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-BYKzzYzi.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-gZjHsUft.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-D3le2d-s.js → anthropic-BomWPIYw.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-hmZzpDrB.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, 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-CVVg5jUL.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
@@ -55,6 +58,18 @@ function fastModeCostMultiplier(modelId) {
 	return FAST_MODE_OPTIONS[modelId]?.costMultiplier;
 }
 /**
+* Claude Fable 5.1 — GA 2026-09-01, `claude-fable-5-1`. Same input/output price
+* as Fable 5 ($10/$50 per MTok) with cache reads cut 75% ($1 → $0.25); 1M
+* context, 128k output, adaptive thinking always on, vision. Rates are the
+* published table, not inferred: input $10, 5m cache write $12.50, 1h cache
+* write $20, cache hit $0.25, output $50.
+* See https://platform.claude.com/docs/en/models/fable-5-1/overview.
+*
+* CAVEAT — this model REJECTS forced tool use: `tool_choice` of `any` or `tool`
+* returns 400. Zidane pins a forced tool for structured output (`loop.ts`,
+* `generate-data.ts`, the eval judge), so those paths fail on this model. Not
+* handled here; adding the entry only makes the model selectable.
+*
 * Claude Opus 5 — GA 2026-07-24. The announcement confirms $5/$25 per MTok
 * (same as Opus 4.8) and fast mode at 2×; the 1M context, 128k output, and
 * cache rates are ASSUMED from Opus 4.8 — verify against the model docs once
@@ -68,12 +83,28 @@ function fastModeCostMultiplier(modelId) {
 * ($5/$25 per MTok, 1M context, 128k output), adaptive thinking, vision.
 * See https://www.anthropic.com/news/claude-opus-4-8.
 *
-* Claude Mythos 5 is deliberately absent: it's invitation-only (Project
-* Glasswing), so it would be a dead picker entry for virtually all users.
+* Claude Mythos 5 / 5.1 are deliberately absent: invitation-only (Project
+* Glasswing) despite sharing Fable's specs and pricing, so they would be dead
+* picker entries for virtually all users.
 *
 * See https://platform.claude.com/docs/en/about-claude/models/overview.
 */
 const ANTHROPIC_EXTRA_MODELS = [
+	{
+		id: "claude-fable-5-1",
+		name: "Claude Fable 5.1",
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: 10,
+			output: 50,
+			cacheRead: .25,
+			cacheWrite: 12.5
+		},
+		contextWindow: 1e6,
+		maxTokens: 128e3,
+		provider: "anthropic"
+	},
 	{
 		id: "claude-opus-5",
 		name: "Claude Opus 5",
@@ -123,6 +154,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,23 +505,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"];
 /**
-* Claude Code identity advertised on subscription-OAuth requests. Anthropic's
-* subscription endpoint checks the Claude CLI identity; zidane's package
-* version is not a compatible user agent.
-*
-* Mirrors `claudeCodeVersion` in the pinned pi-ai
-* (`@earendil-works/pi-ai@0.84.2`, `dist/api/anthropic-messages.js`), which is
-* module-private there — there is no constant to import, so this has to be
-* re-checked by hand whenever pi-ai is bumped. The version is named here so
-* that check has an anchor instead of "the pinned release".
+* Beta flags sent unconditionally on the OAuth path (Claude Code parity).
 *
-* Note this is parity-improving, not parity-complete: the SDK still stamps its
-* own `X-Stainless-*` platform headers, which the real CLI does not send.
+* 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 CLAUDE_CODE_USER_AGENT = "claude-cli/2.1.75";
+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
@@ -187,6 +528,16 @@ const API_KEY_RESERVED_EXTRA_HEADER_NAMES = /* @__PURE__ */ new Set(["anthropic-
 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"
@@ -296,10 +647,8 @@ function buildAnthropicClientOptions(apiKey, auth, baseURL, extraBetas, extraHea
 	if (auth.claudeCode) {
 		const defaultHeaders = {
 			...filterReservedExtraHeaders(extraHeaders, OAUTH_RESERVED_EXTRA_HEADER_NAMES),
-			"accept": "application/json",
-			"anthropic-dangerous-direct-browser-access": "true",
-			"user-agent": CLAUDE_CODE_USER_AGENT,
-			"x-app": "cli"
+			accept: "application/json",
+			...buildClaudeCodeHeaders()
 		};
 		if (betaHeader) defaultHeaders["anthropic-beta"] = betaHeader;
 		return {
@@ -307,6 +656,7 @@ function buildAnthropicClientOptions(apiKey, auth, baseURL, extraBetas, extraHea
 			authToken: apiKey,
 			dangerouslyAllowBrowser: true,
 			defaultHeaders,
+			fetch: wrapFetchForCch(globalThis.fetch),
 			...base
 		};
 	}
@@ -1086,7 +1436,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,
@@ -1150,8 +1500,9 @@ function anthropic(anthropicParams) {
 			* far — `callAuth.bearer` is false for both.
 			*/
 			const callCanRotateAuth = callAuth.bearer;
-			const extendedTtl = options.cache !== false && options.cacheTtl === "1h" && !callIsOAuth && !bedrockConfig;
-			const conditionalBetas = [...options.modelOptions?.fast ? [FAST_MODE_BETA] : [], ...extendedTtl ? [EXTENDED_CACHE_TTL_BETA] : []];
+			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);
 			let client = bedrockConfig ? await createBedrockClient(bedrockConfig, anthropicParams, resolvedExtraHeaders) : createClient(await loadAnthropicSdk(), apiKey, callAuth, anthropicParams?.baseURL, requestBetas, resolvedExtraHeaders);
@@ -1176,7 +1527,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)
@@ -1193,7 +1544,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"];
@@ -1235,6 +1586,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;
@@ -1243,7 +1605,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)
@@ -1373,11 +1735,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-D3le2d-s.js.map
+//# sourceMappingURL=anthropic-BomWPIYw.js.map