opencode-anthropic-multi-account 0.2.21 → 0.2.23

package/dist/index.js

@@ -25,8 +25,8 @@ import {
   showToast,
   sleep,
   updateConfigField
-} from "./chunk-RVXWLAVK.js";
-import "./chunk-IETVH43F.js";
+} from "./chunk-2SN3UVSM.js";
+import "./chunk-RAX4SFCO.js";
 
 // src/index.ts
 import { tool } from "@opencode-ai/plugin";
@@ -719,7 +719,7 @@ function buildCascadePrompt(input, init) {
 }
 function createQueueAwareManager(manager, queue, cascadeStateManager) {
   return Object.create(manager, {
-    selectAccount: { value: async function selectAccount() {
+    selectAccount: { value: async function selectAccount(stickyKey) {
       await manager.refresh();
       while (queue.length > 0) {
         const next = queue.shift();
@@ -734,7 +734,7 @@ function createQueueAwareManager(manager, queue, cascadeStateManager) {
         }
         return account;
       }
-      return manager.selectAccount();
+      return manager.selectAccount(stickyKey);
     } }
   });
 }
@@ -1394,6 +1394,7 @@ function getModelOverride(modelId) {
 
 // src/betas.ts
 var LONG_CONTEXT_BETAS = config.longContextBetas;
+var OAUTH_BETA = "oauth-2025-04-20";
 var excludedBetas = /* @__PURE__ */ new Map();
 var lastBetaFlagsEnv = process.env.ANTHROPIC_BETA_FLAGS;
 var lastModelId;
@@ -1417,6 +1418,19 @@ function addExcludedBeta(modelId, beta) {
 function isLongContextError(responseBody) {
   return responseBody.includes("Extra usage is required for long context requests") || responseBody.includes("long context beta is not yet available");
 }
+function isUnexpectedBetaError(responseBody) {
+  return responseBody.includes("Unexpected value") && responseBody.includes("anthropic-beta");
+}
+function extractRejectedBetas(responseBody) {
+  const match = /Unexpected value\(s\):\s*([^\n]+?)\s*for the anthropic-beta header/i.exec(responseBody);
+  if (!match?.[1]) {
+    return [];
+  }
+  return match[1].split(",").map((value) => value.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+function ensureOauthBeta(betas) {
+  return betas.includes(OAUTH_BETA) ? betas : [OAUTH_BETA, ...betas];
+}
 function getNextBetaToExclude(modelId) {
   const excluded = getExcludedBetas(modelId);
   for (const beta of LONG_CONTEXT_BETAS) {
@@ -1703,7 +1717,7 @@ function hasMeaningfulContent(content) {
     if (!isRecord2(block)) {
       return false;
     }
-    if (block.type === "tool_use") {
+    if (block.type === "tool_use" || block.type === "tool_result") {
       return true;
     }
     if (typeof block.text === "string" && block.text.trim().length > 0) {
@@ -1736,13 +1750,46 @@ function compactMessageContent(messages) {
       if (block.type === "text") {
         return typeof block.text !== "string" || block.text.trim().length > 0;
       }
-      if (block.type === "tool_result" && Array.isArray(block.content)) {
-        return block.content.length > 0;
-      }
       return true;
     });
   }
 }
+function collectToolUseIds(message) {
+  if (!Array.isArray(message.content)) {
+    return [];
+  }
+  return message.content.filter((block) => isRecord2(block) && block.type === "tool_use" && typeof block.id === "string").map((block) => String(block.id));
+}
+function collectToolResultIds(message) {
+  if (!Array.isArray(message.content)) {
+    return /* @__PURE__ */ new Set();
+  }
+  return new Set(
+    message.content.filter((block) => isRecord2(block) && block.type === "tool_result" && typeof block.tool_use_id === "string").map((block) => String(block.tool_use_id))
+  );
+}
+function getDanglingToolUseError(messages) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const current = messages[index];
+    if (!current || current.role !== "assistant") {
+      continue;
+    }
+    const toolUseIds = collectToolUseIds(current);
+    if (toolUseIds.length === 0) {
+      continue;
+    }
+    const next = messages[index + 1];
+    if (!next || next.role !== "user") {
+      return `Dangling tool_use after assistant turn ${index}: ${toolUseIds.join(", ")}`;
+    }
+    const toolResultIds = collectToolResultIds(next);
+    const missing = toolUseIds.filter((toolUseId) => !toolResultIds.has(toolUseId));
+    if (missing.length > 0) {
+      return `Missing tool_result for assistant turn ${index}: ${missing.join(", ")}`;
+    }
+  }
+  return null;
+}
 function stripUnsupportedSamplingFields(body) {
   delete body.temperature;
   delete body.top_p;
@@ -1758,12 +1805,7 @@ var ADAPTIVE_THINKING_MODEL_MATCHERS = [
   (modelId) => modelId.includes("claude-opus-4-6") || modelId.includes("claude-opus-4.6"),
   (modelId) => /claude-opus-4[-._]([7-9]|\d{2,})/.test(modelId)
 ];
-var LARGE_OUTPUT_MODEL_MATCHERS = [
-  (modelId) => modelId.includes("claude-opus-4-6") || modelId.includes("claude-opus-4.6"),
-  (modelId) => /claude-opus-4[-._]([7-9]|\d{2,})/.test(modelId)
-];
 var DEFAULT_MAX_OUTPUT_TOKENS = 64e3;
-var LARGE_MODEL_MAX_OUTPUT_TOKENS = 128e3;
 function normalizeModelId2(modelId) {
   return modelId.trim().toLowerCase();
 }
@@ -1778,16 +1820,11 @@ function supportsAdaptiveThinking(modelId) {
   }
   return ADAPTIVE_THINKING_MODEL_MATCHERS.some((matches) => matches(normalized));
 }
-function getModelMaxOutputTokens(modelId) {
-  const runtimeCapability = getRuntimeModelCapability(modelId);
-  if (typeof runtimeCapability?.maxOutputTokens === "number") {
-    return runtimeCapability.maxOutputTokens;
-  }
-  const normalized = normalizeModelId2(modelId);
-  return LARGE_OUTPUT_MODEL_MATCHERS.some((matches) => matches(normalized)) ? LARGE_MODEL_MAX_OUTPUT_TOKENS : DEFAULT_MAX_OUTPUT_TOKENS;
+function getModelMaxOutputTokens() {
+  return DEFAULT_MAX_OUTPUT_TOKENS;
 }
-function resolveMaxTokens(modelId, requestedMaxTokens) {
-  const modelCap = getModelMaxOutputTokens(modelId);
+function resolveMaxTokens(requestedMaxTokens) {
+  const modelCap = getModelMaxOutputTokens();
   if (typeof requestedMaxTokens !== "number" || !Number.isFinite(requestedMaxTokens)) {
     return modelCap;
   }
@@ -2036,7 +2073,7 @@ function buildUpstreamRequest(inputBody, identity, template, options) {
     body.context_management = DEFAULT_CONTEXT_MANAGEMENT;
     body.output_config = DEFAULT_OUTPUT_CONFIG;
   }
-  body.max_tokens = resolveMaxTokens(modelId, body.max_tokens);
+  body.max_tokens = resolveMaxTokens(body.max_tokens);
   return orderBodyForOutbound(body, template.body_field_order);
 }
 function orderBodyForOutbound(body, overrideOrder) {
@@ -2122,25 +2159,8 @@ function shouldMaskToolName(name, claudeToolNames) {
   }
   return !claudeToolNames.has(name) && !name.startsWith("mcp__") && !name.startsWith(TOOL_MASK_PREFIX);
 }
-function extractFirstUserText(parsed) {
-  if (!Array.isArray(parsed.messages)) {
-    return "";
-  }
-  const firstUser = parsed.messages.find((message) => message.role === "user");
-  if (!isRecord3(firstUser)) {
-    return "";
-  }
-  const content = firstUser.content;
-  if (typeof content === "string") {
-    return content.trim();
-  }
-  if (!Array.isArray(content)) {
-    return "";
-  }
-  return content.filter((block) => isRecord3(block) && block.type === "text" && typeof block.text === "string").map((block) => String(block.text)).join("\n\n").trim();
-}
-function buildMaskedToolName(seed, toolName, length = 8) {
-  const digest = createHash3("sha256").update(`tool-mask:${seed}:${toolName}`).digest("hex").slice(0, length);
+function buildMaskedToolName(toolName, length = 8) {
+  const digest = createHash3("sha256").update(`tool-mask:${toolName}`).digest("hex").slice(0, length);
   return `${TOOL_MASK_PREFIX}${digest}`;
 }
 function collectToolNames(parsed) {
@@ -2175,7 +2195,6 @@ function buildClaudeToolNameSet(claudeToolNames) {
 function buildRequestScopedToolLookup(parsed, claudeToolNames) {
   const lookup = /* @__PURE__ */ new Map();
   const usedOutgoing = /* @__PURE__ */ new Set();
-  const seed = extractFirstUserText(parsed);
   const claudeToolSet = buildClaudeToolNameSet(claudeToolNames);
   for (const originalName of collectToolNames(parsed)) {
     if (!shouldMaskToolName(originalName, claudeToolSet)) {
@@ -2184,10 +2203,10 @@ function buildRequestScopedToolLookup(parsed, claudeToolNames) {
       continue;
     }
     let length = 8;
-    let masked = buildMaskedToolName(seed, originalName, length);
+    let masked = buildMaskedToolName(originalName, length);
     while (usedOutgoing.has(masked)) {
       length += 2;
-      masked = buildMaskedToolName(seed, originalName, length);
+      masked = buildMaskedToolName(originalName, length);
     }
     lookup.set(masked, originalName);
     usedOutgoing.add(masked);
@@ -2552,7 +2571,7 @@ function transformBodyToUpstream(body, identity, sessionId2) {
   try {
     const parsed = JSON.parse(body);
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      return { body, reverseLookup: /* @__PURE__ */ new Map() };
+      return { body, reverseLookup: /* @__PURE__ */ new Map(), validationError: null };
     }
     const template = loadTemplate();
     const upstreamRequest = buildUpstreamRequest(
@@ -2561,9 +2580,16 @@ function transformBodyToUpstream(body, identity, sessionId2) {
       template,
       { sessionId: sessionId2 }
     );
-    return applyRequestToolMasking(upstreamRequest, template.tool_names);
+    const validationError = getDanglingToolUseError(
+      Array.isArray(upstreamRequest.messages) ? upstreamRequest.messages : []
+    );
+    const maskedRequest = applyRequestToolMasking(upstreamRequest, template.tool_names);
+    return {
+      ...maskedRequest,
+      validationError
+    };
   } catch {
-    return { body, reverseLookup: /* @__PURE__ */ new Map() };
+    return { body, reverseLookup: /* @__PURE__ */ new Map(), validationError: null };
   }
 }
 async function applyResponseReverseLookup(response, reverseLookup) {
@@ -2675,11 +2701,11 @@ var AccountRuntimeFactory = class {
     return { accessToken: refreshed.patch.accessToken, expiresAt: refreshed.patch.expiresAt };
   }
   buildOutboundHeaders(incomingHeaders, sessionId2, accessToken, modelId, excludedBetas2) {
-    const mergedBetas = deduplicateBetas([
+    const mergedBetas = deduplicateBetas(ensureOauthBeta([
       ...excludeBetas(splitBetaValues(getBetaHeader()), excludedBetas2),
       ...getModelBetas(modelId, excludedBetas2),
       ...excludeBetas(splitBetaValues(incomingHeaders["anthropic-beta"]), excludedBetas2)
-    ]).join(",");
+    ])).join(",");
     const outbound = {
       ...incomingHeaders,
       ...getStaticHeaders(),
@@ -2707,7 +2733,18 @@ var AccountRuntimeFactory = class {
       void recordObservedToolNames(extractToolNamesFromRequestBody(init.body)).catch(() => {
       });
     }
-    const transformedRequest = typeof init?.body === "string" ? transformBodyToUpstream(init.body, this.identity, sessionId2) : { body: init?.body, reverseLookup: /* @__PURE__ */ new Map() };
+    const transformedRequest = typeof init?.body === "string" ? transformBodyToUpstream(init.body, this.identity, sessionId2) : { body: init?.body, reverseLookup: /* @__PURE__ */ new Map(), validationError: null };
+    if (transformedRequest.validationError) {
+      return new Response(JSON.stringify({
+        error: {
+          message: transformedRequest.validationError,
+          type: "invalid_request_error"
+        }
+      }), {
+        status: 400,
+        headers: { "content-type": "application/json" }
+      });
+    }
     const pacingCfg = resolvePacingConfig();
     const getNow = this.pacingTestOverrides.now ?? Date.now;
     const sleepFn = this.pacingTestOverrides.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
@@ -2750,14 +2787,24 @@ var AccountRuntimeFactory = class {
         break;
       }
       const responseBody = await response.clone().text();
-      if (!isLongContextError(responseBody)) {
+      if (!isLongContextError(responseBody) && !isUnexpectedBetaError(responseBody)) {
         break;
       }
-      const betaToExclude = getNextBetaToExclude(modelId);
-      if (!betaToExclude) {
-        break;
+      if (isUnexpectedBetaError(responseBody)) {
+        const rejectedBetas = extractRejectedBetas(responseBody);
+        if (rejectedBetas.length === 0) {
+          break;
+        }
+        for (const rejectedBeta of rejectedBetas) {
+          addExcludedBeta(modelId, rejectedBeta);
+        }
+      } else {
+        const betaToExclude = getNextBetaToExclude(modelId);
+        if (!betaToExclude) {
+          break;
+        }
+        addExcludedBeta(modelId, betaToExclude);
       }
-      addExcludedBeta(modelId, betaToExclude);
       const retryHeaders = this.buildOutboundHeaders(
         incomingHeaders,
         sessionId2,
@@ -2939,7 +2986,10 @@ var EMPTY_OAUTH_CREDENTIALS = {
   access: "",
   expires: 0
 };
-function extractFirstUserText2(input) {
+if (process.env.CLAUDE_MULTI_ACCOUNT_TRACE_PLUGIN === "1") {
+  console.error("[anthropic-multi-account] module loaded");
+}
+function extractFirstUserText(input) {
   try {
     const raw = input;
     const messages = raw.messages ?? raw.request?.messages;
@@ -2974,6 +3024,9 @@ function applyOrderedHeaders(output, headers) {
   output.headers = Array.isArray(orderedHeaders) ? Object.fromEntries(orderedHeaders) : orderedHeaders;
 }
 var ClaudeMultiAuthPlugin = async (ctx) => {
+  if (process.env.CLAUDE_MULTI_ACCOUNT_TRACE_PLUGIN === "1") {
+    console.error("[anthropic-multi-account] plugin function called");
+  }
   const { client } = ctx;
   await loadConfig();
   const requestProfile = loadCCDerivedRequestProfile();
@@ -3070,7 +3123,20 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
     });
   });
   const store = new AccountStore();
-  await syncBootstrapAuth(client, store).catch(() => {
+  await syncBootstrapAuth(client, store).then((synced) => {
+    debugLog(client, "Bootstrap auth sync completed", { synced });
+  }).catch((error) => {
+    client.app.log({
+      body: {
+        service: ANTHROPIC_OAUTH_ADAPTER.serviceLogName,
+        level: "debug",
+        message: "bootstrap auth sync failed",
+        extra: {
+          error: sanitizeError(error)
+        }
+      }
+    }).catch(() => {
+    });
   });
   let manager = null;
   let runtimeFactory = null;
@@ -3132,7 +3198,7 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
   });
   return {
     "experimental.chat.system.transform": (input, output) => {
-      const billingHeader = composeBillingSystemEntry(extractFirstUserText2(input), claudeCodeVersion);
+      const billingHeader = composeBillingSystemEntry(extractFirstUserText(input), claudeCodeVersion);
       prependMissingSystemEntries(output, [
         billingHeader,
         upstreamAgentIdentity,
@@ -3207,13 +3273,90 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
         { type: "api", label: "Manually enter API Key" }
       ],
       async loader(getAuth, provider) {
-        ingestProviderModelsCapabilities(provider.models ?? {});
+        const providerModels = provider.models ?? {};
+        ingestProviderModelsCapabilities(providerModels);
+        debugLog(client, "Auth loader received provider metadata", {
+          providerId: typeof provider.id === "string" ? provider.id : void 0,
+          providerName: typeof provider.name === "string" ? provider.name : void 0,
+          modelCount: Object.keys(providerModels).length,
+          modelIds: Object.keys(providerModels)
+        });
         const auth = await getAuth();
+        debugLog(client, "Auth loader resolved auth payload", {
+          authType: typeof auth.type === "string" ? auth.type : void 0,
+          authKeys: Object.keys(auth)
+        });
         if (auth.type !== "oauth") {
-          stopHeartbeat();
-          return { apiKey: "", fetch };
+          await syncBootstrapAuth(client, store).then((synced) => {
+            debugLog(client, "Auth loader requested bootstrap auth sync", { synced });
+          }).catch((error) => {
+            client.app.log({
+              body: {
+                service: ANTHROPIC_OAUTH_ADAPTER.serviceLogName,
+                level: "debug",
+                message: "auth loader bootstrap sync failed",
+                extra: {
+                  error: sanitizeError(error)
+                }
+              }
+            }).catch(() => {
+            });
+          });
+          const recoveredFromStore = await initializeManagerFromStore();
+          debugLog(client, "Auth loader attempted store recovery", {
+            recoveredFromStore
+          });
+          if (!recoveredFromStore || !manager || !runtimeFactory) {
+            stopHeartbeat();
+            return { apiKey: "", fetch };
+          }
+          const authProfile2 = await loadCCDerivedAuthProfile();
+          return {
+            apiKey: "",
+            baseURL: authProfile2.apiV1BaseUrl,
+            "chat.headers": async (input, output) => {
+              if (input.provider?.info?.id !== ANTHROPIC_OAUTH_ADAPTER.authProviderId) return;
+              const sessionId2 = getUpstreamSessionId();
+              applyOrderedHeaders(output, {
+                ...output.headers,
+                ...getStaticHeaders(),
+                ...getPerRequestHeaders(sessionId2),
+                "anthropic-beta": getBetaHeader()
+              });
+            },
+            async fetch(input, init) {
+              if (!manager || !runtimeFactory) {
+                stopHeartbeat();
+                return fetch(input, init);
+              }
+              if (manager.getAccountCount() === 0) {
+                stopHeartbeat();
+                throw new Error(
+                  "No Anthropic accounts configured. Run `opencode auth login` to add an account."
+                );
+              }
+              ensureHeartbeat(manager.getActiveAccount()?.accessToken);
+              if (!poolManager || !cascadeStateManager) {
+                poolManager = new PoolManager();
+                poolManager.loadPools(poolChainConfig.pools);
+                cascadeStateManager = new CascadeStateManager();
+              }
+              return executeWithAccountRotation(
+                manager,
+                runtimeFactory,
+                client,
+                input,
+                init,
+                {
+                  poolManager,
+                  cascadeStateManager,
+                  poolChainConfig
+                }
+              );
+            }
+          };
         }
-        for (const model of Object.values(provider.models ?? {})) {
+        for (const model of Object.values(providerModels)) {
           if (model) {
             model.cost = { input: 0, output: 0, cache: { read: 0, write: 0 } };
           }
@@ -3226,6 +3369,10 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
         if (!initializedManager) {
           return { apiKey: "", fetch };
         }
+        debugLog(client, "Auth loader initialized manager state", {
+          accountCount: initializedManager.getAccountCount(),
+          activeAccountUuid: initializedManager.getActiveAccount()?.uuid
+        });
         if (initializedManager.getAccountCount() > 0) {
           const activeAccount = initializedManager.getActiveAccount();
           const activeLabel = activeAccount ? getAccountLabel(activeAccount) : "none";