@cleocode/core 2026.8.1 → 2026.8.2

package/dist/llm/plugin-facade.js

@@ -15722,6 +15722,18 @@ var init_service_provider = __esm({
   }
 });
 
+// packages/contracts/src/caamp-markers.ts
+var H, damagedMarkerSource, CAAMP_DAMAGED_START_PATTERN_SOURCE, CAAMP_DAMAGED_END_PATTERN_SOURCE;
+var init_caamp_markers = __esm({
+  "packages/contracts/src/caamp-markers.ts"() {
+    "use strict";
+    H = "[ \\t\\r]";
+    damagedMarkerSource = (keyword) => `^${H}*[<!-]{1,4}${H}*CAAMP${H}*:${H}*${keyword}${H}*[->]{1,3}${H}*$`;
+    CAAMP_DAMAGED_START_PATTERN_SOURCE = damagedMarkerSource("START");
+    CAAMP_DAMAGED_END_PATTERN_SOURCE = damagedMarkerSource("END");
+  }
+});
+
 // packages/contracts/src/index.ts
 var init_src = __esm({
   "packages/contracts/src/index.ts"() {
@@ -15789,6 +15801,7 @@ var init_src = __esm({
     init_validator();
     init_service_provider();
     init_workgraph();
+    init_caamp_markers();
   }
 });
 
@@ -23511,7 +23524,7 @@ function resolveDbIdentity(db) {
   return identity;
 }
 function sleepAsync(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, Math.max(0, Math.round(ms))));
+  return new Promise((resolve7) => setTimeout(resolve7, Math.max(0, Math.round(ms))));
 }
 function isPidAlive(pid) {
   try {
@@ -24329,7 +24342,7 @@ async function sendResourceRelease(socketPath, cls, holderId) {
   return { unavailable: true, reason: `unexpected response kind: ${result.kind}` };
 }
 function sendLeaseRequest(socketPath, request, expectedKind) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const id = `ra-${process.pid}-${request.kind}`;
     const envelope = LeaseIpcRequestEnvelopeSchema.parse({
       protocol_version: LEASE_IPC_PROTOCOL_VERSION,
@@ -24347,7 +24360,7 @@ function sendLeaseRequest(socketPath, request, expectedKind) {
       settled = true;
       socket.removeAllListeners();
       socket.destroy();
-      resolve6(value);
+      resolve7(value);
     };
     const degrade = (reason) => done({ unavailable: true, reason });
     socket.setTimeout(REQUEST_TIMEOUT_MS);
@@ -27772,8 +27785,8 @@ async function openDualScopeDbAtPath(scope, dbPath, exodusCwd, options) {
   }
   let initResolve = null;
   let initReject = null;
-  const initPromise = new Promise((resolve6, reject) => {
-    initResolve = resolve6;
+  const initPromise = new Promise((resolve7, reject) => {
+    initResolve = resolve7;
     initReject = reject;
   });
   _cache.set(key, {
@@ -28026,24 +28039,35 @@ var init_dual_scope_db = __esm({
       async openProject(dbPath, options) {
         const normalized = resolve3(dbPath);
         if (options?.dedicated) {
-          const handle = await openDualScopeDbAtPath("project", normalized, void 0, {
+          const handle = await openDualScopeDbAtPath("project", normalized, options?.exodusCwd, {
             dedicated: true
           });
           return this.buildStore("project", handle, 0);
         }
-        return this.openEntry("project", normalized);
+        return this.openEntry("project", normalized, 0, options?.exodusCwd);
       }
       /** @inheritdoc */
       async openGlobal(options) {
         const dbPath = resolveDualScopeDbPath("global");
         const normalized = resolve3(dbPath);
         if (options?.dedicated) {
-          const handle = await openDualScopeDbAtPath("global", normalized, void 0, {
+          const handle = await openDualScopeDbAtPath("global", normalized, options?.exodusCwd, {
+            dedicated: true
+          });
+          return this.buildStore("global", handle, 0);
+        }
+        return this.openEntry("global", normalized, 0, options?.exodusCwd);
+      }
+      /** @inheritdoc */
+      async openGlobalAt(dbPath, options) {
+        const normalized = resolve3(dbPath);
+        if (options?.dedicated) {
+          const handle = await openDualScopeDbAtPath("global", normalized, options?.exodusCwd, {
             dedicated: true
           });
           return this.buildStore("global", handle, 0);
         }
-        return this.openEntry("global", normalized);
+        return this.openEntry("global", normalized, 0, options?.exodusCwd);
       }
       /** @inheritdoc */
       closeProject(dbPath) {
@@ -28069,7 +28093,7 @@ var init_dual_scope_db = __esm({
        *   retry calls this with `depth + 1`. A second dead handle at depth 1
        *   throws {@link LivenessExhaustedError} instead of recursing further.
        */
-      async openEntry(scope, dbPath, depth = 0) {
+      async openEntry(scope, dbPath, depth = 0, exodusCwd) {
         const key = cacheKey(scope, dbPath);
         const existing = this._registry.get(key);
         if (existing) {
@@ -28084,8 +28108,8 @@ var init_dual_scope_db = __esm({
         const entryId = ++this._nextId;
         let initResolve;
         let initReject;
-        const initPromise = new Promise((resolve6, reject) => {
-          initResolve = resolve6;
+        const initPromise = new Promise((resolve7, reject) => {
+          initResolve = resolve7;
           initReject = reject;
         });
         this._registry.set(key, { id: entryId, store: null, initPromise });
@@ -28096,7 +28120,7 @@ var init_dual_scope_db = __esm({
           }
         });
         try {
-          const dualHandle = scope === "project" ? await this.openDualScopeFn("project", dbPath) : await this.openDualScopeFn("global", dbPath);
+          const dualHandle = scope === "project" ? await this.openDualScopeFn("project", dbPath, exodusCwd) : await this.openDualScopeFn("global", dbPath, exodusCwd);
           const current = this._registry.get(key);
           if (!current || current.id !== entryId) {
             throw new EntryCancelledError(scope, dbPath);
@@ -28107,7 +28131,7 @@ var init_dual_scope_db = __esm({
             if (depth >= 1) {
               throw new LivenessExhaustedError(scope, dbPath);
             }
-            const retryStore = await this.openEntry(scope, dbPath, depth + 1);
+            const retryStore = await this.openEntry(scope, dbPath, depth + 1, exodusCwd);
             initResolve(retryStore);
             return retryStore;
           }
@@ -28203,6 +28227,151 @@ var init_dual_scope_db = __esm({
   }
 });
 
+// packages/core/src/store/ports/domain-binding.ts
+import { resolve as resolve4 } from "node:path";
+function getCleoRuntime() {
+  if (!_runtime) {
+    _runtime = createCleoRuntime();
+  }
+  return _runtime;
+}
+function bindingKey(scope, dbPath, domain2) {
+  return `${scope}::${dbPath}::${domain2}`;
+}
+function nativeOf(store) {
+  const native = store.db.$client;
+  if (!native) {
+    throw new Error(
+      `T12037: CleoRuntime store for ${store.scope}::${store.dbPath} exposed no $client \u2014 cannot bind a domain schema to it.`
+    );
+  }
+  return native;
+}
+function reuseValid(key, store) {
+  const row = _bindings.get(key);
+  if (!row) return void 0;
+  if (row.store !== store || !store.isOpen || !row.native.isOpen) {
+    _bindings.delete(key);
+    return void 0;
+  }
+  return row;
+}
+async function bindAgainst(key, store, establish) {
+  const cached2 = reuseValid(key, store);
+  if (cached2) return cached2;
+  const pending = _inflight.get(key);
+  if (pending) {
+    const row = await pending;
+    if (row.store === store && row.native.isOpen) return row;
+    return bindAgainst(key, store, establish);
+  }
+  const native = nativeOf(store);
+  const flight = (async () => {
+    const db = await establish(native, store);
+    const row = { store, native, db };
+    if (store.isOpen && native.isOpen) {
+      _bindings.set(key, row);
+    }
+    return row;
+  })();
+  _inflight.set(key, flight);
+  try {
+    return await flight;
+  } finally {
+    if (_inflight.get(key) === flight) {
+      _inflight.delete(key);
+    }
+  }
+}
+async function bindLive(scope, key, dbPath, openStore, establish) {
+  let lastError;
+  for (let attempt = 0; attempt < MAX_LIVENESS_ATTEMPTS; attempt += 1) {
+    let store;
+    try {
+      store = await openStore();
+    } catch (err) {
+      lastError = err;
+      releaseDomainBindings({ scope, dbPath });
+      if (attempt + 1 >= MAX_LIVENESS_ATTEMPTS) throw err;
+      continue;
+    }
+    try {
+      const row = await bindAgainst(key, store, establish);
+      if (row.store.isOpen && row.native.isOpen) return row;
+    } catch (err) {
+      lastError = err;
+      if (store.isOpen) throw err;
+    }
+    releaseDomainBindings({ scope, dbPath });
+    try {
+      store.close();
+    } catch {
+    }
+  }
+  if (lastError !== void 0) throw lastError;
+  throw new Error(
+    `T12037: could not bind ${key} over a live connection after ${MAX_LIVENESS_ATTEMPTS} attempts \u2014 the consolidated handle was closed each time.`
+  );
+}
+async function bindProjectDomain(domain2, cwd, establish) {
+  const dbPath = resolve4(resolveDualScopeDbPath("project", cwd));
+  const row = await bindLive(
+    "project",
+    bindingKey("project", dbPath, domain2),
+    dbPath,
+    () => getCleoRuntime().openProject(dbPath, { exodusCwd: cwd }),
+    establish
+  );
+  return row;
+}
+function releaseDomainBindings(filter2) {
+  if (!filter2) {
+    _bindings.clear();
+    return;
+  }
+  const wantPath = filter2.dbPath === void 0 ? void 0 : resolve4(filter2.dbPath);
+  for (const key of [..._bindings.keys()]) {
+    const sep = key.indexOf("::");
+    const lastSep = key.lastIndexOf("::");
+    const scope = key.slice(0, sep);
+    const dbPath = key.slice(sep + 2, lastSep);
+    const domain2 = key.slice(lastSep + 2);
+    if (filter2.scope !== void 0 && scope !== filter2.scope) continue;
+    if (wantPath !== void 0 && dbPath !== wantPath) continue;
+    if (filter2.domain !== void 0 && domain2 !== filter2.domain) continue;
+    _bindings.delete(key);
+  }
+}
+function boundProjectNative(domain2, cwd) {
+  return peekProjectDomain(domain2, cwd)?.native ?? null;
+}
+function peekProjectDomain(domain2, cwd) {
+  const dbPath = resolve4(resolveDualScopeDbPath("project", cwd));
+  const row = _bindings.get(bindingKey("project", dbPath, domain2));
+  if (row?.native.isOpen) return row;
+  if (cwd !== void 0) return null;
+  const suffix = `::${domain2}`;
+  let sole;
+  for (const [key, candidate] of _bindings) {
+    if (!key.startsWith("project::") || !key.endsWith(suffix)) continue;
+    if (!candidate.native.isOpen) continue;
+    if (sole) return null;
+    sole = candidate;
+  }
+  return sole ?? null;
+}
+var _runtime, _bindings, _inflight, MAX_LIVENESS_ATTEMPTS;
+var init_domain_binding = __esm({
+  "packages/core/src/store/ports/domain-binding.ts"() {
+    "use strict";
+    init_dual_scope_db();
+    _runtime = null;
+    _bindings = /* @__PURE__ */ new Map();
+    _inflight = /* @__PURE__ */ new Map();
+    MAX_LIVENESS_ATTEMPTS = 2;
+  }
+});
+
 // packages/core/src/store/schema/nexus-schema.ts
 var nexus_schema_exports = {};
 __export(nexus_schema_exports, {
@@ -28711,6 +28880,7 @@ var nexus_sqlite_exports = {};
 __export(nexus_sqlite_exports, {
   NEXUS_SCHEMA_VERSION: () => NEXUS_SCHEMA_VERSION,
   _resetNestedNexusWarningGate: () => _resetNestedNexusWarningGate,
+  bindNexusDomain: () => bindNexusDomain,
   closeNexusDb: () => closeNexusDb,
   detectAndWarnOnNestedNexus: () => detectAndWarnOnNestedNexus,
   getNestedNexusSentinelPath: () => getNestedNexusSentinelPath,
@@ -28919,13 +29089,13 @@ function ensureNexusRelationWeights(nativeDb) {
     nativeDb.exec(`PRAGMA foreign_keys=${fkWasOn ? "ON" : "OFF"}`);
   }
 }
-function runNexusMigrations(nativeDb, db) {
+function runNexusMigrations(nativeDb, db, dbPath) {
   const migrationsFolder = resolveNexusMigrationsFolder();
-  if (tableExists4(nativeDb, "nexus_nodes") && _nexusDbPath) {
-    const backupPath = _nexusDbPath.replace(/\.db$/, "-pre-cleo.db.bak");
+  if (tableExists4(nativeDb, "nexus_nodes")) {
+    const backupPath = dbPath.replace(/\.db$/, "-pre-cleo.db.bak");
     if (!existsSync14(backupPath)) {
       try {
-        copyFileSync4(_nexusDbPath, backupPath);
+        copyFileSync4(dbPath, backupPath);
       } catch {
       }
     }
@@ -28967,75 +29137,45 @@ function runNexusMigrations(nativeDb, db) {
   ensureNexusFts5(nativeDb);
 }
 async function getNexusDb() {
-  const requestedPath = getNexusDbPath();
+  return (await bindNexusDomain()).db.drizzle;
+}
+async function bindNexusDomain() {
   const requestedRegistryPath = getNexusRegistryDbPath();
-  if (_nexusDb && _nexusDbPath !== requestedPath) {
-    resetNexusDbState();
-  }
-  if (_nexusDb && _nexusRegistryPath !== requestedRegistryPath) {
-    resetNexusDbState();
+  const bound = peekProjectDomain("nexus");
+  if (bound && bound.db.registryPath !== requestedRegistryPath) {
+    releaseDomainBindings({ scope: "project", domain: "nexus" });
   }
-  if (_nexusDb && (_nexusNativeDb === null || !_nexusNativeDb.isOpen)) {
-    resetNexusDbState();
-  }
-  if (_nexusDb) {
-    if (_nexusNativeDb) {
-      try {
-        ensureGlobalRegistryAttached(_nexusNativeDb);
-      } catch {
-        resetNexusDbState();
-      }
-    }
-    if (_nexusDb) return _nexusDb;
-  }
-  if (_nexusInitPromise) return _nexusInitPromise;
-  _nexusInitPromise = (async () => {
-    const dbPath = requestedPath;
-    _nexusDbPath = dbPath;
-    _nexusRegistryPath = requestedRegistryPath;
-    detectAndWarnOnNestedNexus();
-    await openDualScopeDb("global");
-    const dualHandle = await openDualScopeDb("project");
-    const nativeDb = dualHandle.db.$client ?? null;
-    if (!nativeDb) {
-      throw new Error(
-        "T11648: openDualScopeDb returned a handle without $client \u2014 cannot extract DatabaseSync for the nexus-schema drizzle wrapping."
-      );
-    }
-    _nexusNativeDb = nativeDb;
+  detectAndWarnOnNestedNexus();
+  await openDualScopeDb("global");
+  const binding = await bindProjectDomain("nexus", void 0, (nativeDb, store) => {
     ensureGlobalRegistryAttached(nativeDb);
     const db = drizzle({ client: nativeDb });
-    runNexusMigrations(nativeDb, db);
+    runNexusMigrations(nativeDb, db, store.dbPath);
     nativeDb.prepare(
       `INSERT OR IGNORE INTO nexus_schema_meta (key, value) VALUES ('schemaVersion', '${NEXUS_SCHEMA_VERSION}')`
     ).run();
-    _nexusDb = db;
-    return db;
-  })();
+    return { drizzle: db, registryPath: requestedRegistryPath };
+  });
   try {
-    return await _nexusInitPromise;
-  } finally {
-    _nexusInitPromise = null;
+    ensureGlobalRegistryAttached(binding.native);
+  } catch {
+    releaseDomainBindings({ scope: "project", domain: "nexus" });
+    throw new Error(
+      "T12039: nexus binding lost its GLOBAL registry ATTACH and could not re-attach."
+    );
   }
+  return binding;
 }
 function closeNexusDb() {
-  _nexusNativeDb = null;
-  _nexusDb = null;
-  _nexusDbPath = null;
-  _nexusRegistryPath = null;
-  _nexusInitPromise = null;
+  releaseDomainBindings({ scope: "project", domain: "nexus" });
 }
 function resetNexusDbState() {
-  _nexusNativeDb = null;
-  _nexusDb = null;
-  _nexusDbPath = null;
-  _nexusRegistryPath = null;
-  _nexusInitPromise = null;
+  releaseDomainBindings({ scope: "project", domain: "nexus" });
 }
 function getNexusNativeDb() {
-  return _nexusNativeDb;
+  return boundProjectNative("nexus");
 }
-var NEXUS_SCHEMA_VERSION, _nexusDb, _nexusNativeDb, _nexusDbPath, _nexusRegistryPath, _nexusInitPromise, NEXUS_GLOBAL_ATTACH_ALIAS, NESTED_NEXUS_SENTINEL, _warnedNestedPaths;
+var NEXUS_SCHEMA_VERSION, NEXUS_GLOBAL_ATTACH_ALIAS, NESTED_NEXUS_SENTINEL, _warnedNestedPaths;
 var init_nexus_sqlite = __esm({
   "packages/core/src/store/nexus-sqlite.ts"() {
     "use strict";
@@ -29044,15 +29184,11 @@ var init_nexus_sqlite = __esm({
     init_paths();
     init_dual_scope_db();
     init_migration_manager();
+    init_domain_binding();
     init_resolve_migrations_folder();
     init_nexus_schema();
     init_with_retry();
     NEXUS_SCHEMA_VERSION = "1.0.0";
-    _nexusDb = null;
-    _nexusNativeDb = null;
-    _nexusDbPath = null;
-    _nexusRegistryPath = null;
-    _nexusInitPromise = null;
     NEXUS_GLOBAL_ATTACH_ALIAS = "nexus_global";
     NESTED_NEXUS_SENTINEL = "nexus.db";
     _warnedNestedPaths = /* @__PURE__ */ new Set();
@@ -29064,7 +29200,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync as existsSync15, readFileSync as readFileSync4, statSync as statSync5 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir } from "node:os";
-import { basename as basename4, dirname as dirname6, join as join15, resolve as resolve4 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join15, resolve as resolve5 } from "node:path";
 import {
   computeCanonicalProjectId as _computeCanonicalProjectId,
   getCanonicalTemplatesTildePath as _getCanonicalTemplatesTildePath,
@@ -29131,24 +29267,24 @@ function getCleoDirAbsolute(cwd, opts) {
     try {
       const projectRoot = getProjectRoot(cwd);
       const canonical = _resolveCanonicalCleoDir(project.projectId);
-      if (canonical !== null && canonical === resolve4(projectRoot, cleoDir)) {
+      if (canonical !== null && canonical === resolve5(projectRoot, cleoDir)) {
         return canonical;
       }
-      return resolve4(projectRoot, cleoDir);
+      return resolve5(projectRoot, cleoDir);
     } catch {
-      return resolve4(project.projectRoot, cleoDir);
+      return resolve5(project.projectRoot, cleoDir);
     }
   }
   try {
-    return resolve4(getProjectRoot(cwd), cleoDir);
+    return resolve5(getProjectRoot(cwd), cleoDir);
   } catch (err) {
     if (opts?.bootstrap) {
-      return resolve4(cwd ?? process.cwd(), cleoDir);
+      return resolve5(cwd ?? process.cwd(), cleoDir);
     }
     if (_cwdHasGitAncestor(cwd)) {
       throw err;
     }
-    return resolve4(cwd ?? process.cwd(), cleoDir);
+    return resolve5(cwd ?? process.cwd(), cleoDir);
   }
 }
 function _resolveProjectByCwdFromNexus(cwd) {
@@ -29156,7 +29292,7 @@ function _resolveProjectByCwdFromNexus(cwd) {
     const cleoHome = getCleoHome();
     const globalDbPath = join15(cleoHome, "cleo.db");
     if (!existsSync15(globalDbPath)) return null;
-    const start = resolve4(cwd ?? process.cwd());
+    const start = resolve5(cwd ?? process.cwd());
     let current = start;
     const DatabaseSync2 = _getDatabaseSyncCtor();
     const db = new DatabaseSync2(globalDbPath, { readOnly: true });
@@ -29189,7 +29325,7 @@ function _cleoDirEnvOverride() {
 }
 function _findCleoDirRoot(cwd) {
   const homeRoot = homedir();
-  let current = resolve4(cwd ?? process.cwd());
+  let current = resolve5(cwd ?? process.cwd());
   while (true) {
     const isDangerousRoot = current === homeRoot || current === "/" || current === "";
     if (!isDangerousRoot) {
@@ -29219,7 +29355,7 @@ function resolveCleoDir(cwd) {
   if (root !== null) {
     return join15(root, ".cleo");
   }
-  const start = resolve4(cwd ?? process.cwd());
+  const start = resolve5(cwd ?? process.cwd());
   let current = start;
   while (true) {
     const mainRepo = _resolveMainRepoFromGitlink(current);
@@ -29255,15 +29391,15 @@ function _resolveCleoDir(cwd) {
   const project = _pathsResolveProjectByCwd(cwd);
   if (project !== null) {
     try {
-      return resolve4(getProjectRoot(cwd), cleoDir);
+      return resolve5(getProjectRoot(cwd), cleoDir);
     } catch {
-      return resolve4(project.projectRoot, cleoDir);
+      return resolve5(project.projectRoot, cleoDir);
     }
   }
   return getCleoDirAbsolute(cwd);
 }
 function _cwdHasGitAncestor(cwd) {
-  const start = resolve4(cwd ?? process.cwd());
+  const start = resolve5(cwd ?? process.cwd());
   let current = start;
   while (true) {
     const gitMarker = join15(current, ".git");
@@ -29363,7 +29499,7 @@ function getProjectRoot(cwd) {
     }
     return cleoDirEnv;
   }
-  const start = resolve4(cwd ?? process.cwd());
+  const start = resolve5(cwd ?? process.cwd());
   let current = start;
   const mainRepoFromStart = _resolveMainRepoFromGitlink(start);
   if (mainRepoFromStart !== null) return mainRepoFromStart;
@@ -29456,7 +29592,7 @@ async function registerProjectOnEncounter(projectRoot, infoProjectId) {
     const db = await getNexusDb2();
     const existingRows = await db.select().from(projectRegistry2).where(eq2(projectRegistry2.projectId, immutableId)).limit(1);
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    const resolvedPath = resolve4(projectRoot);
+    const resolvedPath = resolve5(projectRoot);
     const projectName = _readProjectNameFromInfo(resolvedPath) || basename4(projectRoot) || "unnamed";
     if (existingRows.length > 0) {
       const existingPath = existingRows[0].projectPath;
@@ -33317,7 +33453,7 @@ function storedToResolved(stored) {
   };
 }
 function sleep2(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 function backoffMs(policy, attempt) {
   const base = policy.baseDelayMs * 2 ** attempt;
@@ -37211,7 +37347,7 @@ function normalizeOllamaToolCall(tc) {
   };
 }
 function sleep3(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 var OLLAMA_DEFAULT_BASE_URL, MAX_RETRIES, INITIAL_BACKOFF_MS, RETRYABLE_STATUS_CODES, OllamaTransport;
 var init_ollama2 = __esm({
@@ -57725,7 +57861,7 @@ function createProviderToolFactoryWithOutputSchema({
     supportsDeferredResults
   });
 }
-async function resolve5(value) {
+async function resolve6(value) {
   if (typeof value === "function") {
     value = value();
   }
@@ -61759,14 +61895,14 @@ var init_dist4 = __esm({
         headers
       }) {
         return combineHeaders(
-          await resolve5(this.config.headers),
+          await resolve6(this.config.headers),
           headers,
           betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {}
         );
       }
       async getBetasFromHeaders(requestHeaders) {
         var _a17, _b16;
-        const configHeaders = await resolve5(this.config.headers);
+        const configHeaders = await resolve6(this.config.headers);
         const configBetaHeader = (_a17 = configHeaders["anthropic-beta"]) != null ? _a17 : "";
         const requestBetaHeader = (_b16 = requestHeaders == null ? void 0 : requestHeaders["anthropic-beta"]) != null ? _b16 : "";
         return new Set(