opencode-anthropic-multi-account 0.2.93 → 0.2.94

package/dist/{chunk-KQ5RHIZP.js → chunk-BRY7MF6N.js}

@@ -1768,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;
@@ -1814,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,
@@ -1851,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) {
@@ -1900,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) {
@@ -1928,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") {
@@ -2103,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 {
@@ -2114,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),
@@ -2164,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 {
@@ -2229,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 {
@@ -2315,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,
@@ -2330,4 +2946,4 @@ export {
   setFingerprintCaptureTestOverridesForTest,
   resetFingerprintCaptureForTest
 };
-//# sourceMappingURL=chunk-KQ5RHIZP.js.map
+//# sourceMappingURL=chunk-BRY7MF6N.js.map