opencode-anthropic-multi-account 0.2.13 → 0.2.15

package/dist/index.js

@@ -10,6 +10,16 @@ import {
 // src/account-manager.ts
 import { createAccountManagerForProvider } from "opencode-multi-account-core";
 
+// src/config.ts
+import {
+  createConfigLoader
+} from "opencode-multi-account-core";
+var configLoader = createConfigLoader("claude-multiauth.json");
+var { getConfig, loadConfig, resetConfigCache, updateConfigField } = configLoader;
+
+// src/claims.ts
+import { createClaimsManager } from "opencode-multi-account-core";
+
 // src/constants.ts
 import { anthropicOAuthAdapter } from "opencode-multi-account-core";
 var ANTHROPIC_OAUTH_ADAPTER = anthropicOAuthAdapter;
@@ -21,10 +31,20 @@ var ANTHROPIC_BETA_HEADER = ANTHROPIC_OAUTH_ADAPTER.requestBetaHeader;
 var CLAUDE_CLI_USER_AGENT = ANTHROPIC_OAUTH_ADAPTER.cliUserAgent;
 var TOOL_PREFIX = ANTHROPIC_OAUTH_ADAPTER.toolPrefix;
 var ACCOUNTS_FILENAME = ANTHROPIC_OAUTH_ADAPTER.accountStorageFilename;
+var CLAIMS_FILENAME = "anthropic-multi-account-claims.json";
 var PLAN_LABELS = ANTHROPIC_OAUTH_ADAPTER.planLabels;
 var TOKEN_EXPIRY_BUFFER_MS = 6e4;
 var TOKEN_REFRESH_TIMEOUT_MS = 3e4;
 
+// src/claims.ts
+var claimsManager = createClaimsManager(CLAIMS_FILENAME);
+var {
+  isClaimedByOther,
+  readClaims,
+  releaseClaim,
+  writeClaim
+} = claimsManager;
+
 // src/pi-ai-adapter.ts
 import { AsyncLocalStorage } from "async_hooks";
 import * as piAiOauth from "@mariozechner/pi-ai/oauth";
@@ -118,31 +138,29 @@ async function runNodeTokenRequest(options) {
   return await nodeTokenRequestRunner(options);
 }
 
-// src/utils.ts
-import { setConfigGetter } from "opencode-multi-account-core";
-
-// src/config.ts
-import {
-  getConfig,
-  initCoreConfig,
-  loadConfig,
-  resetConfigCache,
-  updateConfigField
-} from "opencode-multi-account-core";
-initCoreConfig("claude-multiauth.json");
-
 // src/utils.ts
 import {
   createMinimalClient,
-  debugLog,
   formatWaitTime,
   getAccountLabel,
   getConfigDir,
   getErrorCode,
-  showToast,
   sleep
 } from "opencode-multi-account-core";
-setConfigGetter(getConfig);
+async function showToast(client, message, variant) {
+  if (getConfig().quiet_mode) return;
+  try {
+    await client.tui.showToast({ body: { message, variant } });
+  } catch {
+  }
+}
+function debugLog(client, message, extra) {
+  if (!getConfig().debug) return;
+  client.app.log({
+    body: { service: ANTHROPIC_OAUTH_ADAPTER.serviceLogName, level: "debug", message, extra }
+  }).catch(() => {
+  });
+}
 
 // src/usage.ts
 import * as v2 from "valibot";
@@ -319,6 +337,7 @@ function fromPiAiCredentials(creds) {
   };
 }
 var ANTHROPIC_REFRESH_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
+var ANTHROPIC_TOKEN_HOST = "platform.claude.com";
 var REFRESH_NODE_EXECUTABLE = process.env.OPENCODE_REFRESH_NODE_EXECUTABLE || "node";
 var tokenProxyContext = new AsyncLocalStorage();
 var tokenProxyInstalled = false;
@@ -376,7 +395,18 @@ function getRequestMethod(input, init) {
   return init?.method ?? (input instanceof Request ? input.method : "GET");
 }
 function shouldProxyTokenRequest(input) {
-  return tokenProxyContext.getStore() === true && isAnthropicTokenEndpoint(input);
+  return tokenProxyContext.getStore()?.proxyTokenRequests === true && isAnthropicTokenEndpoint(input);
+}
+function shouldInjectAnthropicUserAgent(input) {
+  const userAgent = tokenProxyContext.getStore()?.userAgent;
+  if (!userAgent) return false;
+  const rawUrl = getRequestUrlString(input);
+  try {
+    const url = new URL(rawUrl);
+    return url.host === ANTHROPIC_TOKEN_HOST;
+  } catch {
+    return rawUrl.includes(ANTHROPIC_TOKEN_HOST);
+  }
 }
 async function postAnthropicTokenViaNode(body) {
   let output;
@@ -414,14 +444,19 @@ async function postAnthropicTokenViaNode(body) {
 }
 function createAnthropicTokenProxyFetch(originalFetch) {
   return (async (input, init) => {
-    if (!shouldProxyTokenRequest(input)) {
-      return originalFetch(input, init);
+    if (shouldProxyTokenRequest(input)) {
+      const method = getRequestMethod(input, init).toUpperCase();
+      if (method !== "POST") {
+        throw buildRefreshRequestError(`Unsupported token endpoint method: ${method}`);
+      }
+      return await postAnthropicTokenViaNode(await getRequestBody(input, init));
     }
-    const method = getRequestMethod(input, init).toUpperCase();
-    if (method !== "POST") {
-      throw buildRefreshRequestError(`Unsupported token endpoint method: ${method}`);
+    if (shouldInjectAnthropicUserAgent(input)) {
+      const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : void 0));
+      headers.set("user-agent", tokenProxyContext.getStore().userAgent);
+      return originalFetch(input, { ...init, headers });
     }
-    return await postAnthropicTokenViaNode(await getRequestBody(input, init));
+    return originalFetch(input, init);
   });
 }
 function ensureAnthropicTokenProxyFetchInstalled() {
@@ -430,9 +465,9 @@ function ensureAnthropicTokenProxyFetchInstalled() {
   globalThis.fetch = createAnthropicTokenProxyFetch(tokenProxyOriginalFetch);
   tokenProxyInstalled = true;
 }
-async function withAnthropicTokenProxyFetch(operation) {
+async function withAnthropicTokenProxyFetch(operation, options) {
   ensureAnthropicTokenProxyFetchInstalled();
-  return await tokenProxyContext.run(true, operation);
+  return await tokenProxyContext.run({ proxyTokenRequests: true, userAgent: options?.userAgent }, operation);
 }
 async function fetchProfileWithSingleRetry(accessToken) {
   let profileResult = await fetchProfile(accessToken);
@@ -444,12 +479,15 @@ async function fetchProfileWithSingleRetry(accessToken) {
   return profileResult;
 }
 async function loginWithPiAi(callbacks) {
-  const piCreds = await withAnthropicTokenProxyFetch(() => piAiOauth.loginAnthropic({
-    onAuth: callbacks.onAuth,
-    onPrompt: callbacks.onPrompt,
-    onProgress: callbacks.onProgress,
-    onManualCodeInput: callbacks.onManualCodeInput
-  }));
+  const piCreds = await withAnthropicTokenProxyFetch(
+    () => piAiOauth.loginAnthropic({
+      onAuth: callbacks.onAuth,
+      onPrompt: callbacks.onPrompt,
+      onProgress: callbacks.onProgress,
+      onManualCodeInput: callbacks.onManualCodeInput
+    }),
+    { userAgent: callbacks.userAgent }
+  );
   const base = fromPiAiCredentials(piCreds);
   const profileResult = await fetchProfileWithSingleRetry(piCreds.access);
   const profileData = profileResult.ok ? profileResult.data : void 0;
@@ -520,8 +558,12 @@ async function refreshToken(currentRefreshToken, accountId, client) {
 // src/account-manager.ts
 var AccountManager = createAccountManagerForProvider({
   providerAuthId: "anthropic",
+  getConfig,
   isTokenExpired,
-  refreshToken
+  isClaimedByOther,
+  readClaims,
+  refreshToken,
+  writeClaim
 });
 
 // src/executor.ts
@@ -947,18 +989,7 @@ function promptLine(message) {
 function normalizePromptMessage(prompt) {
   return prompt.message ?? prompt.text ?? prompt.label ?? prompt.title ?? prompt.placeholder ?? "Continue authentication: ";
 }
-var ANTHROPIC_TOKEN_HOST = "platform.claude.com";
 async function startPiAiFlow() {
-  const originalFetch = globalThis.fetch;
-  globalThis.fetch = ((input, init) => {
-    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    if (url.includes(ANTHROPIC_TOKEN_HOST)) {
-      const headers = new Headers(init?.headers);
-      headers.set("user-agent", CLAUDE_CLI_USER_AGENT);
-      return originalFetch(input, { ...init, headers });
-    }
-    return originalFetch(input, init);
-  });
   try {
     const completedAccount = await loginWithPiAi({
       onAuth: (info) => {
@@ -975,7 +1006,8 @@ ${instruction}${urlLine}
       onPrompt: async (prompt) => {
         const text = normalizePromptMessage(prompt);
         return promptLine(text.endsWith(":") || text.endsWith("?") ? `${text} ` : `${text}: `);
-      }
+      },
+      userAgent: CLAUDE_CLI_USER_AGENT
     });
     const completedResult = asOAuthCallbackResponse(completedAccount);
     const accountEmail = completedAccount.email;
@@ -988,8 +1020,6 @@ ${instruction}${urlLine}
     };
   } catch {
     return makeFailedFlowResult("Failed to start OAuth flow");
-  } finally {
-    globalThis.fetch = originalFetch;
   }
 }
 function wrapCallbackWithAccountReplace(result, manager, targetAccount) {
@@ -998,7 +1028,7 @@ function wrapCallbackWithAccountReplace(result, manager, targetAccount) {
     ...result,
     callback: async function(code) {
       const callbackResult = await originalCallback(code);
-      if (callbackResult?.type === "success" && callbackResult.refresh) {
+      if (callbackResult.type === "success" && callbackResult.refresh) {
         if (targetAccount.uuid) {
           await manager.replaceAccountCredentials(targetAccount.uuid, toOAuthCredentials(callbackResult));
         }
@@ -1017,7 +1047,7 @@ function wrapCallbackWithManagerSync(result, manager) {
     ...result,
     callback: async function(code) {
       const callbackResult = await originalCallback(code);
-      if (callbackResult?.type === "success" && callbackResult.refresh) {
+      if (callbackResult.type === "success" && callbackResult.refresh) {
         const auth = toOAuthCredentials(callbackResult);
         if (manager) {
           const countBefore = manager.getAccounts().length;
@@ -1082,8 +1112,7 @@ async function loadManagerFromDisk(client) {
   const stored = await store.load();
   if (stored.accounts.length === 0) return null;
   const emptyAuth = { type: "oauth", refresh: "", access: "", expires: 0 };
-  const mgr = await AccountManager.create(store, emptyAuth, client);
-  return mgr;
+  return AccountManager.create(store, emptyAuth, client);
 }
 async function runAccountManagementMenu(manager, client) {
   while (true) {
@@ -1531,20 +1560,169 @@ function buildBillingHeader(firstUserMessage) {
 }
 var OPENCODE_CAMEL_RE = /OpenCode/g;
 var OPENCODE_LOWER_RE = /(?<!\/)opencode/gi;
-var TOOL_PREFIX_RESPONSE_RE = /"name"\s*:\s*"mcp_([^"]+)"/g;
+var TOOL_MASK_PREFIX = "tool_";
 var PARAGRAPH_REMOVAL_ANCHORS = [
   "github.com/anomalyco/opencode",
   "opencode.ai/docs"
 ];
 var BILLING_HEADER_PREFIX = "x-anthropic-billing-header:";
-function addToolPrefix(name) {
-  if (!ANTHROPIC_OAUTH_ADAPTER.transform.addToolPrefix) {
-    return name;
+var DOCUMENTED_BUILTIN_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "Agent",
+  "AskUserQuestion",
+  "Bash",
+  "CronCreate",
+  "CronDelete",
+  "CronList",
+  "Edit",
+  "EnterPlanMode",
+  "EnterWorktree",
+  "ExitPlanMode",
+  "ExitWorktree",
+  "Glob",
+  "Grep",
+  "ListMcpResourcesTool",
+  "LSP",
+  "Monitor",
+  "NotebookEdit",
+  "PowerShell",
+  "Read",
+  "ReadMcpResourceTool",
+  "SendMessage",
+  "Skill",
+  "TaskCreate",
+  "TaskGet",
+  "TaskList",
+  "TaskOutput",
+  "TaskStop",
+  "TaskUpdate",
+  "TeamCreate",
+  "TeamDelete",
+  "TodoWrite",
+  "ToolSearch",
+  "WebFetch",
+  "WebSearch",
+  "Write"
+]);
+function isTypedTool(tool2) {
+  return typeof tool2.type === "string" && tool2.type.trim().length > 0;
+}
+function shouldMaskToolName(name) {
+  if (!name) {
+    return false;
+  }
+  return !DOCUMENTED_BUILTIN_TOOL_NAMES.has(name) && !name.startsWith(TOOL_MASK_PREFIX);
+}
+function extractFirstUserTextFromMessageContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter((block) => isRecord(block) && block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join("\n\n");
+}
+function extractFirstUserText(parsed) {
+  if (!Array.isArray(parsed.messages)) {
+    return "";
+  }
+  const firstUserMessage = parsed.messages.find((message) => message.role === "user");
+  if (!firstUserMessage) {
+    return "";
+  }
+  return extractFirstUserTextFromMessageContent(firstUserMessage.content).trim();
+}
+function buildMaskedToolName(seed, toolName, length = 8) {
+  const digest = createHash("sha256").update(`tool-mask:${seed}:${toolName}`).digest("hex").slice(0, length);
+  return `${TOOL_MASK_PREFIX}${digest}`;
+}
+function collectMaskCandidates(parsed) {
+  const candidates = /* @__PURE__ */ new Set();
+  if (Array.isArray(parsed.tools)) {
+    for (const tool2 of parsed.tools) {
+      if (!isRecord(tool2) || isTypedTool(tool2) || !shouldMaskToolName(tool2.name)) {
+        continue;
+      }
+      candidates.add(tool2.name);
+    }
   }
-  if (!name || name.startsWith(TOOL_PREFIX)) {
+  if (Array.isArray(parsed.messages)) {
+    for (const message of parsed.messages) {
+      if (!Array.isArray(message.content)) {
+        continue;
+      }
+      for (const contentBlock of message.content) {
+        if (contentBlock.type !== "tool_use" || !shouldMaskToolName(contentBlock.name)) {
+          continue;
+        }
+        candidates.add(contentBlock.name);
+      }
+    }
+  }
+  if (parsed.tool_choice?.type === "tool" && shouldMaskToolName(parsed.tool_choice.name)) {
+    candidates.add(parsed.tool_choice.name);
+  }
+  return [...candidates];
+}
+function buildToolMaskMap(parsed) {
+  const maskMap = /* @__PURE__ */ new Map();
+  const candidates = collectMaskCandidates(parsed);
+  const firstUserText = extractFirstUserText(parsed);
+  const usedMaskedNames = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    let hashLength = 8;
+    let maskedName = buildMaskedToolName(firstUserText, candidate, hashLength);
+    while (usedMaskedNames.has(maskedName)) {
+      hashLength += 2;
+      maskedName = buildMaskedToolName(firstUserText, candidate, hashLength);
+    }
+    maskMap.set(candidate, maskedName);
+    usedMaskedNames.add(maskedName);
+  }
+  return maskMap;
+}
+function extractRequestToolMaskMap(body) {
+  if (!body) {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const parsed = JSON.parse(body);
+    return buildToolMaskMap(parsed);
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
+function renameMaskedToolName(name, maskMap) {
+  if (!name) {
     return name;
   }
-  return `${TOOL_PREFIX}${name}`;
+  return maskMap.get(name) ?? name;
+}
+function remapToolUseNames(messages, maskMap) {
+  if (!Array.isArray(messages)) {
+    return messages;
+  }
+  return messages.map((message) => {
+    if (!Array.isArray(message.content)) {
+      return message;
+    }
+    return {
+      ...message,
+      content: message.content.map((contentBlock) => {
+        if (contentBlock.type !== "tool_use" || !contentBlock.name) {
+          return contentBlock;
+        }
+        const nextName = renameMaskedToolName(contentBlock.name, maskMap);
+        return nextName === contentBlock.name ? contentBlock : { ...contentBlock, name: nextName };
+      })
+    };
+  });
+}
+function remapToolChoice(toolChoice, maskMap) {
+  if (!toolChoice || toolChoice.type !== "tool" || typeof toolChoice.name !== "string") {
+    return toolChoice;
+  }
+  const nextName = renameMaskedToolName(toolChoice.name, maskMap);
+  return nextName === toolChoice.name ? toolChoice : { ...toolChoice, name: nextName };
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null;
@@ -1655,19 +1833,40 @@ function relocateSystemTextToFirstUser(parsed, systemEntries) {
   parsed.messages = nextMessages;
   return preservedEntries;
 }
-function stripToolPrefixFromLine(line) {
+function extractToolNamesFromRequestBody(body) {
+  if (!body) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(body);
+    if (!Array.isArray(parsed.tools)) {
+      return [];
+    }
+    return parsed.tools.map((tool2) => typeof tool2.name === "string" ? tool2.name : null).filter((toolName) => Boolean(toolName));
+  } catch {
+    return [];
+  }
+}
+function stripToolPrefixFromLine(line, maskMap) {
   if (!ANTHROPIC_OAUTH_ADAPTER.transform.stripToolPrefixInResponse) {
     return line;
   }
-  return line.replace(TOOL_PREFIX_RESPONSE_RE, '"name": "$1"');
+  let nextLine = line;
+  for (const [originalName, maskedName] of maskMap) {
+    nextLine = nextLine.replace(
+      new RegExp(`"name"\\s*:\\s*"${maskedName}"`, "g"),
+      `"name": "${originalName}"`
+    );
+  }
+  return nextLine;
 }
-function processCompleteLines(buffer) {
+function processCompleteLines(buffer, maskMap) {
   const lines = buffer.split("\n");
   const remaining = lines.pop() ?? "";
   if (lines.length === 0) {
     return { output: "", remaining };
   }
-  const output = `${lines.map(stripToolPrefixFromLine).join("\n")}
+  const output = `${lines.map((line) => stripToolPrefixFromLine(line, maskMap)).join("\n")}
 `;
   return { output, remaining };
 }
@@ -1711,6 +1910,7 @@ function transformRequestBody(body) {
   if (!body) return body;
   try {
     const parsed = JSON.parse(body);
+    const toolMaskMap = buildToolMaskMap(parsed);
     if (ANTHROPIC_OAUTH_ADAPTER.transform.rewriteOpenCodeBranding) {
       const normalizedSystemEntries = normalizeSystemEntries(parsed.system);
       parsed.system = relocateSystemTextToFirstUser(parsed, normalizedSystemEntries);
@@ -1718,22 +1918,11 @@ function transformRequestBody(body) {
     if (parsed.tools && Array.isArray(parsed.tools)) {
       parsed.tools = parsed.tools.map((tool2) => ({
         ...tool2,
-        name: addToolPrefix(tool2.name)
+        name: renameMaskedToolName(tool2.name, toolMaskMap)
       }));
     }
-    if (parsed.messages && Array.isArray(parsed.messages)) {
-      parsed.messages = parsed.messages.map((message) => {
-        if (message.content && Array.isArray(message.content)) {
-          message.content = message.content.map((contentBlock) => {
-            if (contentBlock.type === "tool_use" && contentBlock.name) {
-              return { ...contentBlock, name: addToolPrefix(contentBlock.name) };
-            }
-            return contentBlock;
-          });
-        }
-        return message;
-      });
-    }
+    parsed.messages = remapToolUseNames(parsed.messages, toolMaskMap);
+    parsed.tool_choice = remapToolChoice(parsed.tool_choice, toolMaskMap);
     return JSON.stringify(parsed);
   } catch {
     return body;
@@ -1767,7 +1956,7 @@ function transformRequestUrl(input) {
   }
   return input;
 }
-function createResponseStreamTransform(response) {
+function createResponseStreamTransform(response, maskMap = /* @__PURE__ */ new Map()) {
   if (!response.body) return response;
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
@@ -1781,14 +1970,14 @@ function createResponseStreamTransform(response) {
           if (done) {
             buffer += decoder.decode();
             if (buffer) {
-              controller.enqueue(encoder.encode(stripToolPrefixFromLine(buffer)));
+              controller.enqueue(encoder.encode(stripToolPrefixFromLine(buffer, maskMap)));
               buffer = "";
             }
             controller.close();
             return;
           }
           buffer += decoder.decode(value, { stream: true });
-          const { output, remaining } = processCompleteLines(buffer);
+          const { output, remaining } = processCompleteLines(buffer, maskMap);
           buffer = remaining;
           if (output) {
             controller.enqueue(encoder.encode(output));
@@ -1827,6 +2016,55 @@ var ProactiveRefreshQueue = createProactiveRefreshQueueForProvider({
 
 // src/runtime-factory.ts
 import { TokenRefreshError } from "opencode-multi-account-core";
+
+// src/tool-observation.ts
+import { promises as fs } from "fs";
+import { dirname, join } from "path";
+var OBSERVED_TOOL_FILE = "anthropic-observed-tools.json";
+var FILE_MODE = 384;
+function getObservedToolPath() {
+  return join(getConfigDir(), OBSERVED_TOOL_FILE);
+}
+async function loadObservedToolInventory() {
+  try {
+    const content = await fs.readFile(getObservedToolPath(), "utf8");
+    const parsed = JSON.parse(content);
+    return typeof parsed === "object" && parsed && typeof parsed.observedTools === "object" ? parsed : { observedTools: {} };
+  } catch {
+    return { observedTools: {} };
+  }
+}
+async function saveObservedToolInventory(inventory) {
+  const targetPath = getObservedToolPath();
+  await fs.mkdir(dirname(targetPath), { recursive: true });
+  await fs.writeFile(targetPath, `${JSON.stringify(inventory, null, 2)}
+`, { mode: FILE_MODE });
+  await fs.chmod(targetPath, FILE_MODE).catch(() => {
+  });
+}
+async function recordObservedToolNames(toolNames) {
+  if (toolNames.length === 0) {
+    return;
+  }
+  const inventory = await loadObservedToolInventory();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const toolName of toolNames) {
+    const entry = inventory.observedTools[toolName];
+    if (!entry) {
+      inventory.observedTools[toolName] = {
+        count: 1,
+        firstSeenAt: now,
+        lastSeenAt: now
+      };
+      continue;
+    }
+    entry.count += 1;
+    entry.lastSeenAt = now;
+  }
+  await saveObservedToolInventory(inventory);
+}
+
+// src/runtime-factory.ts
 var TOKEN_REFRESH_PERMANENT_FAILURE_STATUS = 401;
 var AccountRuntimeFactory = class {
   constructor(store, client) {
@@ -1893,6 +2131,11 @@ var AccountRuntimeFactory = class {
     const modelId = extractModelIdFromBody(init?.body);
     const excludedBetas2 = getExcludedBetas(modelId);
     const headers = buildRequestHeaders(transformedInput, init, accessToken, modelId, excludedBetas2);
+    if (typeof init?.body === "string") {
+      void recordObservedToolNames(extractToolNamesFromRequestBody(init.body)).catch(() => {
+      });
+    }
+    const toolMaskMap = typeof init?.body === "string" ? extractRequestToolMaskMap(init.body) : /* @__PURE__ */ new Map();
     const transformedBody = typeof init?.body === "string" ? transformRequestBody(init.body) : init?.body;
     let response = await fetch(transformedInput, {
       ...init,
@@ -1925,7 +2168,7 @@ var AccountRuntimeFactory = class {
         body: transformedBody
       });
     }
-    return createResponseStreamTransform(response);
+    return createResponseStreamTransform(response, toolMaskMap);
   }
   async createRuntime(uuid) {
     const fetchWithAccount = async (input, init) => {
@@ -1950,8 +2193,8 @@ var AccountRuntimeFactory = class {
 };
 
 // src/bootstrap-auth.ts
-import { promises as fs } from "fs";
-import { join } from "path";
+import { promises as fs2 } from "fs";
+import { join as join2 } from "path";
 import { getConfigDir as getConfigDir2 } from "opencode-multi-account-core";
 var AUTH_JSON_FILENAME = "auth.json";
 function hasCompleteOAuthCredential(account) {
@@ -1972,10 +2215,10 @@ function selectBootstrapAccount(accounts, activeAccountUuid) {
   return firstUsableAccount ?? completeAccounts[0] ?? null;
 }
 async function readCurrentAuth(providerId) {
-  const authPath = join(getConfigDir2(), AUTH_JSON_FILENAME);
+  const authPath = join2(getConfigDir2(), AUTH_JSON_FILENAME);
   let raw;
   try {
-    raw = await fs.readFile(authPath, "utf-8");
+    raw = await fs2.readFile(authPath, "utf-8");
   } catch {
     return null;
   }
@@ -2034,7 +2277,7 @@ var EMPTY_OAUTH_CREDENTIALS = {
   access: "",
   expires: 0
 };
-function extractFirstUserText(input) {
+function extractFirstUserText2(input) {
   try {
     const raw = input;
     const messages = raw.messages ?? raw.request?.messages;
@@ -2128,7 +2371,7 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
   return {
     "experimental.chat.system.transform": (input, output) => {
       injectSystemPrompt(output);
-      const billingHeader = buildBillingHeader(extractFirstUserText(input));
+      const billingHeader = buildBillingHeader(extractFirstUserText2(input));
       if (billingHeader && !output.system?.includes(billingHeader)) {
         output.system?.unshift(billingHeader);
       }
@@ -2237,6 +2480,7 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
         }
         return {
           apiKey: "",
+          baseURL: "https://api.anthropic.com/v1",
           "chat.headers": async (input, output) => {
             if (input.provider?.info?.id !== ANTHROPIC_OAUTH_ADAPTER.authProviderId) return;
             output.headers["user-agent"] = getUserAgent();