opencode-anthropic-multi-account 0.2.92 → 0.2.94

package/dist/{chunk-5ADYNYT2.js → chunk-BRY7MF6N.js}

@@ -21,7 +21,7 @@ import {
 var data_default = {
   _version: 1,
   _schemaVersion: 1,
-  _captured: "2026-07-15T20:48:36.607Z",
+  _captured: "2026-07-15T23:20:51.699Z",
   _source: "bundled",
   agent_identity: "You are a Claude agent, built on Anthropic's Claude Agent SDK.",
   system_prompt: `You are an interactive agent that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
@@ -132,10 +132,11 @@ If the target is already known, use the direct tool: Read for a known path, \`gr
 ## Usage notes
 
 - Always include a short description summarizing what the agent will do
-- When the agent is done, it will return a single message back to you. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
+- When the agent is done, its final report is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.
 - Trust but verify: an agent's summary describes what it intended to do, not necessarily what it did. When an agent writes or edits code, check the actual changes before reporting the work as done.
 - Agents run in the background by default. When an agent runs in the background, you will be automatically notified when it completes \u2014 do NOT sleep, poll, or proactively check on its progress. Continue with other work or respond to the user instead.
 - **Foreground vs background**: Pass \`run_in_background: false\` to run an agent in the foreground when you need its results before you can proceed \u2014 e.g., research agents whose findings inform your next steps. Otherwise let it run in the background (the default) so you can keep working in parallel.
+- **Don't race**: after launching a background agent, you know nothing about its results. Never fabricate or predict them in any format \u2014 not as prose, summary, or structured output. The completion notification arrives in a later turn; it is never something you write yourself. If the user asks before it lands, say the agent is still running \u2014 give status, not a guess.
 - To continue a previously spawned agent, use SendMessage with the agent's ID or name as the \`to\` field \u2014 that resumes it with full context. A new Agent call starts a fresh agent with no memory of prior runs, so the prompt must be self-contained.
 - Each agent type's model, reasoning effort, and tool access are set in its definition (\`.claude/agents/*.md\` frontmatter, or the SDK \`agents\` option); the \`model\` parameter here overrides the definition for this one call.
 - Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, web fetches, etc.), since a fresh agent is not aware of the user's intent
@@ -165,9 +166,20 @@ Agent({
   description: "Branch ship-readiness audit",
   prompt: "Audit what's left before this branch can ship. Check: uncommitted changes, commits ahead of main, whether tests exist, whether the GrowthBook gate is wired up, whether CI-relevant files changed. Report a punch list \u2014 done vs. missing. Under 200 words."
 })
+assistant: Ship-readiness audit running in the background.
 <commentary>
-The prompt is self-contained: it states the goal, lists what to check, and caps the response length. The agent's report comes back as the tool result; relay the findings to the user.
+The prompt is self-contained: it states the goal, lists what to check, and caps the response length. The agent runs in the background (the default), so the turn ends here \u2014 nothing about its findings is known yet. The report arrives in a SEPARATE turn, as a completion notification from outside; it is never something you write yourself.
 </commentary>
+[later turn \u2014 notification arrives as user message]
+assistant: Audit's back. Three blockers: no tests for the new prompt path, GrowthBook gate wired but not in build_flags.yaml, and one uncommitted file.
+</example>
+
+<example>
+user: "so is the gate wired up or not"
+<commentary>
+User asks mid-wait. The audit was launched to answer exactly this, and it hasn't returned. Give status, not a fabricated result.
+</commentary>
+assistant: Still waiting on the audit \u2014 that's one of the things it's checking. Should land shortly.
 </example>
 
 <example>
@@ -1595,7 +1607,7 @@ IMPORTANT - Use the correct year in search queries:
     "Write"
   ],
   anthropic_beta: "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,thinking-token-count-2026-05-13,context-management-2025-06-27,prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07,advisor-tool-2026-03-01,effort-2025-11-24,extended-cache-ttl-2025-04-11",
-  cc_version: "2.1.210",
+  cc_version: "2.1.211",
   header_order: [
     "Accept",
     "Authorization",
@@ -1625,7 +1637,7 @@ IMPORTANT - Use the correct year in search queries:
     "anthropic-dangerous-direct-browser-access": "true",
     "anthropic-version": "2023-06-01",
     "content-type": "application/json",
-    "user-agent": "claude-cli/2.1.210 (external, sdk-cli)",
+    "user-agent": "claude-cli/2.1.211 (external, sdk-cli)",
     "x-app": "cli",
     "x-stainless-timeout": "600"
   },
@@ -1756,6 +1768,594 @@ function compareVersionStrings(left, right) {
 
 // ../providers/claude-code/src/fingerprint-capture.ts
 import { getConfigDir } from "opencode-multi-account-core";
+
+// ../providers/claude-code/src/opencode-shared.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+
+// ../providers/claude-code/src/fingerprint-template.ts
+var template = fingerprint_data_default;
+var toolNames = new Set(template.tools.map((tool) => tool.name));
+function getClaudeCodeTemplateMetadata() {
+  return {
+    agentIdentity: template.agent_identity,
+    anthropicBeta: template.anthropic_beta,
+    bodyFieldOrder: template.body_field_order ? [...template.body_field_order] : void 0,
+    ccVersion: template.cc_version,
+    headerValues: { ...template.header_values },
+    headerOrder: template.header_order ? [...template.header_order] : void 0,
+    systemPrompt: template.system_prompt,
+    systemPromptFable: template.system_prompt_fable,
+    toolNames: template.tool_names ? [...template.tool_names] : template.tools.map((tool) => tool.name)
+  };
+}
+
+// ../providers/claude-code/src/cch.ts
+var CCH_SEEDS = {
+  "2.1.177": 0x4d659218e32a3268n
+  // 2.1.178 was checked during the issue #91 review; the 2.1.177 seed did
+  // not reproduce the captured cch, so leave it unstamped until a new seed is
+  // independently extracted and verified.
+};
+var MASK = 0xfffffn;
+var U64 = (1n << 64n) - 1n;
+var P1 = 0x9e3779b185ebca87n;
+var P2 = 0xc2b2ae3d27d4eb4fn;
+var P3 = 0x165667b19e3779f9n;
+var P4 = 0x85ebca77c2b2ae63n;
+var P5 = 0x27d4eb2f165667c5n;
+var BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
+var CCH_RE = /(cc_entrypoint=[a-z0-9-]{1,32}; cch=)[0-9a-fA-F]{5}(?=;)/;
+var CC_VERSION_RE = /\bcc_version=([0-9]+(?:\.[0-9]+){2})(?:\.[0-9a-f]+)?;/;
+function rotl(value, bits) {
+  return (value << bits | value >> 64n - bits) & U64;
+}
+function round(accumulator, input) {
+  let next = accumulator + input * P2 & U64;
+  next = rotl(next, 31n);
+  return next * P1 & U64;
+}
+function mergeRound(accumulator, value) {
+  const rounded = round(0n, value);
+  const next = (accumulator ^ rounded) & U64;
+  return next * P1 + P4 & U64;
+}
+function xxh64(data, seed) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const length = data.length;
+  let offset = 0;
+  let hash;
+  if (length >= 32) {
+    let v1 = seed + P1 + P2 & U64;
+    let v2 = seed + P2 & U64;
+    let v3 = seed & U64;
+    let v4 = seed - P1 & U64;
+    const limit = length - 32;
+    while (offset <= limit) {
+      v1 = round(v1, view.getBigUint64(offset, true));
+      offset += 8;
+      v2 = round(v2, view.getBigUint64(offset, true));
+      offset += 8;
+      v3 = round(v3, view.getBigUint64(offset, true));
+      offset += 8;
+      v4 = round(v4, view.getBigUint64(offset, true));
+      offset += 8;
+    }
+    hash = rotl(v1, 1n) + rotl(v2, 7n) + rotl(v3, 12n) + rotl(v4, 18n) & U64;
+    hash = mergeRound(hash, v1);
+    hash = mergeRound(hash, v2);
+    hash = mergeRound(hash, v3);
+    hash = mergeRound(hash, v4);
+  } else {
+    hash = seed + P5 & U64;
+  }
+  hash = hash + BigInt(length) & U64;
+  while (offset + 8 <= length) {
+    const k1 = round(0n, view.getBigUint64(offset, true));
+    hash = (hash ^ k1) & U64;
+    hash = rotl(hash, 27n) * P1 + P4 & U64;
+    offset += 8;
+  }
+  if (offset + 4 <= length) {
+    hash = (hash ^ BigInt(view.getUint32(offset, true)) * P1 & U64) & U64;
+    hash = rotl(hash, 23n) * P2 + P3 & U64;
+    offset += 4;
+  }
+  while (offset < length) {
+    hash = (hash ^ BigInt(data[offset] ?? 0) * P5 & U64) & U64;
+    hash = rotl(hash, 11n) * P1 & U64;
+    offset += 1;
+  }
+  hash = (hash ^ hash >> 33n) & U64;
+  hash = hash * P2 & U64;
+  hash = (hash ^ hash >> 29n) & U64;
+  hash = hash * P3 & U64;
+  hash = (hash ^ hash >> 32n) & U64;
+  return hash;
+}
+function replaceBillingCch(body, cch) {
+  const system = body.system;
+  if (!Array.isArray(system)) return { replaced: false };
+  for (const entry of system) {
+    if (!entry || typeof entry !== "object") continue;
+    const systemEntry = entry;
+    if (typeof systemEntry.text !== "string") continue;
+    if (!systemEntry.text.startsWith(BILLING_HEADER_PREFIX)) continue;
+    if (!CCH_RE.test(systemEntry.text)) continue;
+    const version = CC_VERSION_RE.exec(systemEntry.text)?.[1];
+    systemEntry.text = systemEntry.text.replace(CCH_RE, (_match, prefix) => `${prefix}${cch}`);
+    return { replaced: true, version };
+  }
+  return { replaced: false };
+}
+function cchMaterial(bodyText) {
+  const body = JSON.parse(bodyText);
+  const { replaced, version } = replaceBillingCch(body, "00000");
+  if (!replaced) return null;
+  body.model = "";
+  delete body.fallbacks;
+  delete body.fallback_credit_token;
+  delete body.max_tokens;
+  return { bytes: new TextEncoder().encode(JSON.stringify(body)), version };
+}
+function cchForBody(bodyText, version) {
+  let material;
+  try {
+    material = cchMaterial(bodyText);
+  } catch {
+    return null;
+  }
+  if (!material) return null;
+  const seed = CCH_SEEDS[material.version ?? version ?? ""];
+  if (seed === void 0) return null;
+  const hash = xxh64(material.bytes, seed) & MASK;
+  return hash.toString(16).padStart(5, "0");
+}
+function stampClaudeCodeCch(bodyText, version) {
+  const cch = cchForBody(bodyText, version);
+  if (cch === null) return bodyText;
+  try {
+    const body = JSON.parse(bodyText);
+    const { replaced } = replaceBillingCch(body, cch);
+    return replaced ? JSON.stringify(body) : bodyText;
+  } catch {
+    return bodyText;
+  }
+}
+
+// ../providers/claude-code/src/effort-capability.ts
+var EFFORT_PREFERENCE = ["xhigh", "max", "high", "medium", "low"];
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function normalizeEffortValue(value) {
+  return value.trim().toLowerCase().replace(/[^a-z_-]+$/g, "");
+}
+function parseEffortCapabilityRejection(body) {
+  const match = /does not support effort level\s+['"`]?([^'"`.\s]+)['"`]?\.?\s*Supported levels:\s*([a-z,\s_-]+)/i.exec(body);
+  if (!match?.[1] || !match[2]) {
+    return null;
+  }
+  const supported = match[2].split(",").map(normalizeEffortValue).filter(Boolean);
+  return supported.length > 0 ? { rejected: normalizeEffortValue(match[1]), supported } : null;
+}
+function bestSupportedEffort(supported) {
+  for (const effort of EFFORT_PREFERENCE) {
+    if (supported.includes(effort)) {
+      return effort;
+    }
+  }
+  return supported[0] ?? "high";
+}
+function clampUnsupportedEffortInBody(body, supportedEffortsByModel) {
+  if (typeof body !== "string") {
+    return { body, changed: false };
+  }
+  try {
+    const parsed = JSON.parse(body);
+    const record = readRecord(parsed);
+    const modelId = typeof record?.model === "string" ? record.model : void 0;
+    const outputConfig = readRecord(record?.output_config);
+    const effort = typeof outputConfig?.effort === "string" ? outputConfig.effort : void 0;
+    if (!modelId || !outputConfig || !effort) {
+      return { body, changed: false, modelId };
+    }
+    const supported = supportedEffortsByModel.get(modelId);
+    if (!supported || supported.includes(effort)) {
+      return { body, changed: false, modelId, effort };
+    }
+    const clamped = bestSupportedEffort(supported);
+    outputConfig.effort = clamped;
+    return { body: JSON.stringify(record), changed: true, modelId, effort: clamped };
+  } catch {
+    return { body, changed: false };
+  }
+}
+function clampEffortAfterRejection(body, rejection, supportedEffortsByModel) {
+  if (typeof body !== "string") {
+    return { body, changed: false };
+  }
+  try {
+    const parsed = JSON.parse(body);
+    const record = readRecord(parsed);
+    const modelId = typeof record?.model === "string" ? record.model : void 0;
+    const outputConfig = readRecord(record?.output_config);
+    const effort = typeof outputConfig?.effort === "string" ? outputConfig.effort : void 0;
+    if (!modelId || !outputConfig || !effort) {
+      return { body, changed: false, modelId };
+    }
+    supportedEffortsByModel.set(modelId, [...rejection.supported]);
+    if (rejection.supported.includes(effort)) {
+      return { body, changed: false, modelId, effort };
+    }
+    const clamped = bestSupportedEffort(rejection.supported);
+    outputConfig.effort = clamped;
+    return { body: JSON.stringify(record), changed: true, modelId, effort: clamped };
+  } catch {
+    return { body, changed: false };
+  }
+}
+
+// ../providers/claude-code/src/model-aliases.ts
+var MODEL_FAMILIES = ["fable", "opus", "sonnet", "haiku"];
+var FAMILY_RANK = { fable: 0, opus: 1, sonnet: 2, haiku: 3 };
+var CLAUDE_FABLE_MODEL_ID = "claude-fable-5";
+var CLAUDE_FABLE_1M_MODEL_ID = `${CLAUDE_FABLE_MODEL_ID}[1m]`;
+var CLAUDE_SONNET_MODEL_ID = "claude-sonnet-5";
+var CLAUDE_SONNET_1M_MODEL_ID = `${CLAUDE_SONNET_MODEL_ID}[1m]`;
+var FALLBACK_CLAUDE_CODE_BASE_MODEL_IDS = [
+  CLAUDE_FABLE_MODEL_ID,
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  CLAUDE_SONNET_MODEL_ID,
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5"
+];
+var STATIC_MODEL_ALIASES = {
+  opus47: "claude-opus-4-7",
+  opus46: "claude-opus-4-6",
+  sonnet46: "claude-sonnet-4-6"
+};
+var cachedBaseModelIds = [...FALLBACK_CLAUDE_CODE_BASE_MODEL_IDS];
+function stripClaudeCodeProviderPrefix(modelId) {
+  const slash = modelId.indexOf("/");
+  if (slash === -1) return modelId;
+  const provider = modelId.slice(0, slash).toLowerCase();
+  return provider === "anthropic" || provider === "claude-code" ? modelId.slice(slash + 1) : modelId;
+}
+function resolveClaudeCodeModelAlias(modelId) {
+  const unprefixed = stripClaudeCodeProviderPrefix(modelId.trim());
+  return resolveAliasAgainst(unprefixed, cachedBaseModelIds) ?? STATIC_MODEL_ALIASES[unprefixed.toLowerCase()] ?? unprefixed;
+}
+function stripClaudeCodeContext1mTag(modelId) {
+  return modelId.replace(/\[1m\]$/i, "");
+}
+function toClaudeCodeWireModelId(modelId) {
+  return stripClaudeCodeContext1mTag(resolveClaudeCodeModelAlias(modelId));
+}
+function isClaudeCode1mModelLabel(modelId) {
+  return /\[1m\]$/i.test(resolveClaudeCodeModelAlias(modelId));
+}
+function isClaudeFableModel(modelId) {
+  return resolveClaudeCodeModelAlias(modelId).toLowerCase().includes("fable");
+}
+function resolveFamilyBase(family, baseIds) {
+  return baseIds.filter((id) => modelFamily(id) === family && !id.includes("[")).sort(compareClaudeCodeBaseModelIds)[0];
+}
+function longContextEligible(id) {
+  const normalized = id.toLowerCase();
+  return normalized.startsWith("claude-") && !normalized.includes("haiku") && !normalized.endsWith("[1m]");
+}
+function compareClaudeCodeBaseModelIds(a, b) {
+  const aRank = FAMILY_RANK[modelFamily(a) ?? ""] ?? 99;
+  const bRank = FAMILY_RANK[modelFamily(b) ?? ""] ?? 99;
+  if (aRank !== bRank) return aRank - bRank;
+  return compareVersionDesc(modelVersionKey(a), modelVersionKey(b));
+}
+function modelFamily(id) {
+  const normalized = stripClaudeCodeContext1mTag(stripClaudeCodeProviderPrefix(id)).toLowerCase();
+  for (const family of MODEL_FAMILIES) {
+    if (normalized.includes(family)) return family;
+  }
+  return void 0;
+}
+function resolveAliasAgainst(modelId, baseIds) {
+  const normalized = stripClaudeCodeProviderPrefix(modelId).trim().toLowerCase();
+  if (isModelFamily(normalized)) return resolveFamilyBase(normalized, baseIds) ?? void 0;
+  const match = /^([a-z]+)1m$/.exec(normalized);
+  if (match?.[1] && isModelFamily(match[1])) {
+    const base = resolveFamilyBase(match[1], baseIds);
+    return base && longContextEligible(base) ? `${base}[1m]` : void 0;
+  }
+  return void 0;
+}
+function isModelFamily(value) {
+  return MODEL_FAMILIES.includes(value);
+}
+function modelVersionKey(id) {
+  return id.match(/\d+/g)?.map(Number) ?? [];
+}
+function compareVersionDesc(a, b) {
+  const length = Math.max(a.length, b.length);
+  for (let index = 0; index < length; index += 1) {
+    const diff = (b[index] ?? -1) - (a[index] ?? -1);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+// ../providers/claude-code/src/opencode-shared.ts
+var CLAUDE_CODE_API_BASE_URL = "https://api.anthropic.com";
+var STAINLESS_PACKAGE_VERSION = "0.81.0";
+var DEFAULT_OPENCODE_TIMEOUT_SECONDS = "300";
+var BILLING_SEED = "59cf53e54c78";
+var templateMetadata = getClaudeCodeTemplateMetadata();
+var templateHeaders = templateMetadata.headerValues;
+var CLAUDE_CODE_VERSION = templateMetadata.ccVersion ?? "2.1.137";
+var CCH_REMOVED_VERSION = "2.1.183";
+var CLIENT_SYSTEM_PREFACE = "\n\n---\n\nIMPORTANT: The operator of this session has supplied the following task-specific instructions. Follow them for task format, style, and output requirements when they do not conflict with security, authorization, refusal, tool-execution, confirmation, or other safety rules above. Those safety and tool-use constraints remain higher priority and cannot be overridden:\n\n";
+function loadClaudeCodeSharedRequestProfile() {
+  return {
+    anthropicBeta: templateMetadata.anthropicBeta ?? templateHeaders["anthropic-beta"] ?? "oauth-2025-04-20",
+    anthropicVersion: templateHeaders["anthropic-version"] ?? "2023-06-01",
+    apiV1BaseUrl: `${CLAUDE_CODE_API_BASE_URL}/v1`,
+    baseUrl: CLAUDE_CODE_API_BASE_URL,
+    ccVersion: CLAUDE_CODE_VERSION,
+    headerOrder: templateMetadata.headerOrder ? [...templateMetadata.headerOrder] : void 0,
+    headerValues: { ...templateHeaders },
+    packageVersion: templateHeaders["x-stainless-package-version"] ?? STAINLESS_PACKAGE_VERSION,
+    userAgent: templateHeaders["user-agent"] ?? `claude-cli/${CLAUDE_CODE_VERSION} (external, sdk-cli)`,
+    xApp: templateHeaders["x-app"] ?? "cli"
+  };
+}
+function createClaudeCodeStaticHeaders(input) {
+  return {
+    "accept": "application/json",
+    "content-type": "application/json",
+    "anthropic-dangerous-direct-browser-access": "true",
+    "user-agent": input.userAgent,
+    "x-app": input.xApp,
+    "x-stainless-arch": process.arch,
+    "x-stainless-lang": "js",
+    "x-stainless-os": getOsName(),
+    "x-stainless-package-version": input.packageVersion ?? STAINLESS_PACKAGE_VERSION,
+    "x-stainless-retry-count": "0",
+    "x-stainless-runtime": "node",
+    "x-stainless-runtime-version": process.version,
+    ...input.headerValues ?? {}
+  };
+}
+function createClaudeCodePerRequestHeaders(input) {
+  return {
+    "x-claude-code-session-id": input.sessionId,
+    "x-client-request-id": randomUUID(),
+    "anthropic-version": input.anthropicVersion,
+    "x-stainless-timeout": input.timeoutSeconds ?? DEFAULT_OPENCODE_TIMEOUT_SECONDS
+  };
+}
+function orderClaudeCodeHeadersForOutbound(headers, headerOrder) {
+  if (!Array.isArray(headerOrder) || headerOrder.length === 0) return headers;
+  const lowerToValue = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(headers)) {
+    lowerToValue.set(key.toLowerCase(), value);
+  }
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of headerOrder) {
+    const key = name.toLowerCase();
+    const value = lowerToValue.get(key);
+    if (value === void 0 || seen.has(key)) continue;
+    ordered.push([name, value]);
+    seen.add(key);
+  }
+  for (const [key, value] of Object.entries(headers)) {
+    if (seen.has(key.toLowerCase())) continue;
+    ordered.push([key, value]);
+  }
+  return ordered;
+}
+function computeClaudeCodeBuildTag(userMessage, version) {
+  const chars = [4, 7, 20].map((index) => userMessage[index] ?? "0").join("");
+  return createHash2("sha256").update(`${BILLING_SEED}${chars}${version}`).digest("hex").slice(0, 3);
+}
+function composeClaudeCodeBillingSystemEntry(firstUserMessage, version, cch = "00000") {
+  const buildTag = computeClaudeCodeBuildTag(firstUserMessage, version);
+  const base = `x-anthropic-billing-header: cc_version=${version}.${buildTag}; cc_entrypoint=sdk-cli;`;
+  return claudeCodeBillingUsesCch(version) ? `${base} cch=${cch};` : base;
+}
+function claudeCodeBillingUsesCch(version) {
+  const comparison = compareSemver(version, CCH_REMOVED_VERSION);
+  return comparison === null || comparison < 0;
+}
+function compareSemver(left, right) {
+  const leftParts = parseSemver(left);
+  const rightParts = parseSemver(right);
+  if (!leftParts || !rightParts) return null;
+  for (let index = 0; index < leftParts.length; index += 1) {
+    const diff = leftParts[index] - rightParts[index];
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function parseSemver(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function summarizeClaudeCodeCacheControls(body) {
+  const observations = [];
+  const observe = (value, path) => {
+    const record = readRecord2(value);
+    if (!record || !Object.hasOwn(record, "cache_control")) {
+      return;
+    }
+    const cacheControl = readRecord2(record.cache_control);
+    observations.push({
+      path,
+      type: typeof cacheControl?.type === "string" ? cacheControl.type : null,
+      ttl: typeof cacheControl?.ttl === "string" ? cacheControl.ttl : null
+    });
+  };
+  if (Array.isArray(body.system)) {
+    body.system.forEach((block, index) => {
+      observe(block, `system[${index}].cache_control`);
+    });
+  }
+  if (Array.isArray(body.tools)) {
+    body.tools.forEach((tool, index) => {
+      observe(tool, `tools[${index}].cache_control`);
+    });
+  }
+  if (Array.isArray(body.messages)) {
+    body.messages.forEach((message, messageIndex) => {
+      const content = readRecord2(message)?.content;
+      if (!Array.isArray(content)) return;
+      content.forEach((block, contentIndex) => {
+        observe(
+          block,
+          `messages[${messageIndex}].content[${contentIndex}].cache_control`
+        );
+      });
+    });
+  }
+  return observations;
+}
+function resolveClaudeCodeCacheControl(body) {
+  const observations = summarizeClaudeCodeCacheControls(body);
+  return observations.length > 0 && observations.every(
+    (cacheControl) => cacheControl.type === "ephemeral" && cacheControl.ttl === "1h"
+  ) ? { type: "ephemeral", ttl: "1h" } : { type: "ephemeral" };
+}
+function applyClaudeCodePromptCaching(body, cacheControl = { type: "ephemeral" }) {
+  const tools = body.tools;
+  if (Array.isArray(tools) && tools.length > 0) {
+    const clonedTools = tools.map((tool) => {
+      const cloned = { ...tool };
+      delete cloned.cache_control;
+      return cloned;
+    });
+    clonedTools[clonedTools.length - 1] = {
+      ...clonedTools[clonedTools.length - 1],
+      cache_control: cacheControl
+    };
+    body.tools = clonedTools;
+  }
+  const messages = body.messages;
+  if (!Array.isArray(messages) || messages.length === 0) {
+    return;
+  }
+  const lastMessage = messages[messages.length - 1];
+  const content = lastMessage?.content;
+  if (!Array.isArray(content) || content.length === 0) {
+    return;
+  }
+  content[content.length - 1] = {
+    ...content[content.length - 1],
+    cache_control: cacheControl
+  };
+}
+function applyClaudeCodeUpstreamBodyFields(body, input) {
+  const cacheControl = input.cacheControl ?? { type: "ephemeral" };
+  const firstUserMessage = input.firstUserMessage ?? extractFirstUserText(body.messages);
+  const billingHeader = composeClaudeCodeBillingSystemEntry(
+    firstUserMessage,
+    input.ccVersion,
+    input.cch
+  );
+  const systemTexts = input.systemTexts ?? normalizeClaudeCodeSystemTexts(body.system);
+  const injectedSystemTexts = filterInjectedSystemTexts(systemTexts, {
+    agentIdentity: input.agentIdentity,
+    billingHeader,
+    systemPrompt: input.systemPrompt
+  });
+  const mergedSystemPrompt = injectedSystemTexts.length > 0 ? `${input.systemPrompt}${CLIENT_SYSTEM_PREFACE}${injectedSystemTexts.join("\n\n")}` : input.systemPrompt;
+  body.system = [
+    { type: "text", text: billingHeader },
+    {
+      type: "text",
+      text: input.agentIdentity,
+      cache_control: cacheControl
+    },
+    {
+      type: "text",
+      text: mergedSystemPrompt,
+      cache_control: cacheControl
+    }
+  ];
+  body.metadata = {
+    ...readRecord2(body.metadata),
+    user_id: JSON.stringify({
+      device_id: input.identity.deviceId,
+      account_uuid: input.identity.accountUuid,
+      session_id: input.sessionId
+    })
+  };
+  if (input.defaultTools && (!Array.isArray(body.tools) || body.tools.length === 0)) {
+    body.tools = input.defaultTools.map((tool) => ({ ...tool }));
+  }
+  applyClaudeCodePromptCaching(body, cacheControl);
+  return orderClaudeCodeBodyForOutbound(body, input.bodyFieldOrder);
+}
+function orderClaudeCodeBodyForOutbound(body, fieldOrder) {
+  if (!Array.isArray(fieldOrder) || fieldOrder.length === 0) return body;
+  const ordered = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fieldOrder) {
+    if (seen.has(field)) continue;
+    if (Object.prototype.hasOwnProperty.call(body, field)) {
+      ordered[field] = body[field];
+      seen.add(field);
+    }
+  }
+  for (const [field, value] of Object.entries(body)) {
+    if (seen.has(field)) continue;
+    ordered[field] = value;
+  }
+  return ordered;
+}
+function normalizeClaudeCodeSystemTexts(system) {
+  if (typeof system === "string" && system.length > 0) return [system];
+  if (!Array.isArray(system)) return [];
+  const texts = [];
+  for (const entry of system) {
+    if (typeof entry === "string" && entry.length > 0) {
+      texts.push(entry);
+      continue;
+    }
+    const record = readRecord2(entry);
+    const text = typeof record?.text === "string" && record.text.length > 0 ? record.text : void 0;
+    if (text) texts.push(text);
+  }
+  return texts;
+}
+function filterInjectedSystemTexts(systemTexts, input) {
+  return systemTexts.filter((entry) => entry !== input.billingHeader && entry !== input.agentIdentity && entry !== input.systemPrompt && !entry.startsWith("x-anthropic-billing-header:"));
+}
+function extractFirstUserText(messages) {
+  if (!Array.isArray(messages)) return "";
+  for (const message of messages) {
+    const record = readRecord2(message);
+    if (record?.role !== "user") continue;
+    if (typeof record.content === "string") return record.content;
+    if (!Array.isArray(record.content)) return "";
+    return record.content.map((block) => {
+      const text = readRecord2(block)?.text;
+      return typeof text === "string" && text.length > 0 ? text : void 0;
+    }).filter((text) => Boolean(text)).join("\n\n");
+  }
+  return "";
+}
+function readRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function getOsName() {
+  const platform2 = process.platform;
+  if (platform2 === "win32") return "Windows";
+  if (platform2 === "darwin") return "MacOS";
+  return "Linux";
+}
+
+// ../providers/claude-code/src/fingerprint-capture.ts
 var CURRENT_SCHEMA_VERSION = 1;
 var LIVE_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_CAPTURE_TIMEOUT_MS = 1e4;
@@ -1802,35 +2402,35 @@ function isTemplateData(value) {
   }
   return typeof value._version === "number" && typeof value._captured === "string" && typeof value._source === "string" && typeof value.agent_identity === "string" && typeof value.system_prompt === "string" && Array.isArray(value.tools) && value.tools.every(isTemplateTool) && Array.isArray(value.tool_names) && value.tool_names.every((toolName) => typeof toolName === "string");
 }
-function hasUsableToolSchemas(template) {
-  return template.tools.length > 0 && template.tools.every((tool) => tool.name.startsWith("mcp__") || isRecord(tool.input_schema));
+function hasUsableToolSchemas(template2) {
+  return template2.tools.length > 0 && template2.tools.every((tool) => tool.name.startsWith("mcp__") || isRecord(tool.input_schema));
 }
-function isUsableTemplate(template) {
-  return template._schemaVersion === CURRENT_SCHEMA_VERSION && hasUsableToolSchemas(template);
+function isUsableTemplate(template2) {
+  return template2._schemaVersion === CURRENT_SCHEMA_VERSION && hasUsableToolSchemas(template2);
 }
-function cloneTemplate(template, sourceOverride) {
+function cloneTemplate(template2, sourceOverride) {
   return {
-    ...template,
-    _source: sourceOverride ?? template._source,
-    tools: template.tools.map((tool) => ({ ...tool })),
-    tool_names: [...template.tool_names],
-    header_order: template.header_order ? [...template.header_order] : void 0,
-    header_values: template.header_values ? { ...template.header_values } : void 0,
-    body_field_order: template.body_field_order ? [...template.body_field_order] : void 0
+    ...template2,
+    _source: sourceOverride ?? template2._source,
+    tools: template2.tools.map((tool) => ({ ...tool })),
+    tool_names: [...template2.tool_names],
+    header_order: template2.header_order ? [...template2.header_order] : void 0,
+    header_values: template2.header_values ? { ...template2.header_values } : void 0,
+    body_field_order: template2.body_field_order ? [...template2.body_field_order] : void 0
   };
 }
-function applyBundledTemplateFallbacks(template) {
+function applyBundledTemplateFallbacks(template2) {
   const bundledFablePrompt = bundledTemplate.system_prompt_fable;
-  if (template.system_prompt_fable || typeof bundledFablePrompt !== "string" || bundledFablePrompt.length === 0) {
-    return template;
+  if (template2.system_prompt_fable || typeof bundledFablePrompt !== "string" || bundledFablePrompt.length === 0) {
+    return template2;
   }
   return {
-    ...template,
+    ...template2,
     system_prompt_fable: bundledFablePrompt
   };
 }
-function prepareBundledTemplate(template) {
-  const rest = cloneTemplate(template, "bundled");
+function prepareBundledTemplate(template2) {
+  const rest = cloneTemplate(template2, "bundled");
   return {
     ...rest,
     _version: CURRENT_SCHEMA_VERSION,
@@ -1839,14 +2439,14 @@ function prepareBundledTemplate(template) {
     tool_names: rest.tools.map((tool) => tool.name)
   };
 }
-function matchesBundledClaudeCodeFingerprint(template, reference = bundledTemplate) {
+function matchesBundledClaudeCodeFingerprint(template2, reference = bundledTemplate) {
   const expectedToolNames = comparableHeadlessToolNames(reference.tool_names);
-  const actualToolNames = comparableHeadlessToolNames(template.tools.map((tool) => tool.name));
+  const actualToolNames = comparableHeadlessToolNames(template2.tools.map((tool) => tool.name));
   const matchesExpectedTools = actualToolNames.length === expectedToolNames.length && expectedToolNames.every((name, index) => actualToolNames[index] === name);
-  return template.agent_identity === reference.agent_identity && matchesExpectedTools;
+  return template2.agent_identity === reference.agent_identity && matchesExpectedTools;
 }
-function comparableHeadlessToolNames(toolNames) {
-  return toolNames.filter((toolName) => !INTERACTIVE_ONLY_TOOL_NAMES.has(toolName));
+function comparableHeadlessToolNames(toolNames2) {
+  return toolNames2.filter((toolName) => !INTERACTIVE_ONLY_TOOL_NAMES.has(toolName));
 }
 function loadBundledTemplate() {
   if (bundledTemplate._schemaVersion !== CURRENT_SCHEMA_VERSION) {
@@ -1888,11 +2488,11 @@ function readLiveCacheSync(sourceOverride = "cached") {
     return null;
   }
 }
-function getCapturedAt(template) {
-  return Date.parse(template._captured);
+function getCapturedAt(template2) {
+  return Date.parse(template2._captured);
 }
-function isFreshTemplate(template) {
-  const capturedAt = getCapturedAt(template);
+function isFreshTemplate(template2) {
+  const capturedAt = getCapturedAt(template2);
   return Number.isFinite(capturedAt) && now() - capturedAt < LIVE_TTL_MS;
 }
 function pickTemplate(cached, bundled) {
@@ -1916,8 +2516,8 @@ async function atomicWriteJson(targetPath, payload) {
 `, "utf8");
   await rename(tmpPath, targetPath);
 }
-async function writeLiveCache(template) {
-  await atomicWriteJson(getCachePath(), cloneTemplate(template, "live"));
+async function writeLiveCache(template2) {
+  await atomicWriteJson(getCachePath(), cloneTemplate(template2, "live"));
 }
 function toText(value) {
   if (typeof value === "string") {
@@ -2091,7 +2691,7 @@ function extractTemplate(captured) {
   if (!billingHeader || !agentIdentity || !systemPrompt || extractedTools.length === 0) {
     return null;
   }
-  const toolNames = extractedTools.map((tool) => tool.name);
+  const toolNames2 = extractedTools.map((tool) => tool.name);
   const headerValues = extractStaticHeaderValues(captured.headers);
   const bodyFieldOrder = Object.keys(captured.body);
   return {
@@ -2102,7 +2702,7 @@ function extractTemplate(captured) {
     agent_identity: agentIdentity,
     system_prompt: systemPrompt,
     tools: extractedTools,
-    tool_names: toolNames,
+    tool_names: toolNames2,
     anthropic_beta: captured.headers["anthropic-beta"],
     cc_version: extractCCVersion(billingHeader, captured.headers["user-agent"]),
     header_order: extractHeaderOrder(captured.rawHeaders),
@@ -2152,10 +2752,23 @@ async function captureLiveTemplateAsync(timeoutMs = DEFAULT_CAPTURE_TIMEOUT_MS,
     });
     const baseUrl = `http://${LOOPBACK_HOST}:${address.port}`;
     await runClaudeCapture({ binaryPath, baseUrl, timeoutMs, model: options.model });
-    if (!capturedRequest) {
+    const captured = capturedRequest;
+    if (!captured) {
       return null;
     }
-    return extractTemplate(capturedRequest);
+    const template2 = extractTemplate(captured);
+    if (template2 && options.cacheControlEvidencePath) {
+      await writeFile2(
+        options.cacheControlEvidencePath,
+        `${JSON.stringify({
+          cc_version: template2.cc_version,
+          cache_controls: summarizeClaudeCodeCacheControls(captured.body)
+        }, null, 2)}
+`,
+        "utf8"
+      );
+    }
+    return template2;
   } catch {
     return null;
   } finally {
@@ -2217,8 +2830,8 @@ function compareVersions(left, right) {
   }
   return leftPatch - rightPatch;
 }
-function detectDrift(template, installedOverride) {
-  const cachedVersion = template.cc_version ?? null;
+function detectDrift(template2, installedOverride) {
+  const cachedVersion = template2.cc_version ?? null;
   const installedVersion = installedOverride ?? probeInstalledCCVersion();
   if (!cachedVersion) {
     return {
@@ -2303,6 +2916,21 @@ function resetFingerprintCaptureForTest() {
 
 export {
   fingerprint_data_default,
+  stampClaudeCodeCch,
+  parseEffortCapabilityRejection,
+  clampUnsupportedEffortInBody,
+  clampEffortAfterRejection,
+  resolveClaudeCodeModelAlias,
+  toClaudeCodeWireModelId,
+  isClaudeCode1mModelLabel,
+  isClaudeFableModel,
+  loadClaudeCodeSharedRequestProfile,
+  createClaudeCodeStaticHeaders,
+  createClaudeCodePerRequestHeaders,
+  orderClaudeCodeHeadersForOutbound,
+  composeClaudeCodeBillingSystemEntry,
+  resolveClaudeCodeCacheControl,
+  applyClaudeCodeUpstreamBodyFields,
   detectCliVersion,
   LIVE_TTL_MS,
   SUPPORTED_CC_RANGE,
@@ -2318,4 +2946,4 @@ export {
   setFingerprintCaptureTestOverridesForTest,
   resetFingerprintCaptureForTest
 };
-//# sourceMappingURL=chunk-5ADYNYT2.js.map
+//# sourceMappingURL=chunk-BRY7MF6N.js.map