opencode-anthropic-multi-account 0.2.5 → 0.2.6

package/dist/constants.d.ts

@@ -1,6 +1,9 @@
 /** Anthropic OAuth adapter config */
 export declare const ANTHROPIC_OAUTH_ADAPTER: import("opencode-multi-account-core").OAuthAdapter;
 export declare const ANTHROPIC_CLIENT_ID: string;
+export declare const ANTHROPIC_AUTHORIZE_ENDPOINT: string;
+export declare const ANTHROPIC_REDIRECT_URI: string;
+export declare const ANTHROPIC_SCOPES: string;
 /** Token exchange / refresh endpoint */
 export declare const ANTHROPIC_TOKEN_ENDPOINT: string;
 /** OAuth usage stats endpoint */

package/dist/index.js

@@ -1820,6 +1820,33 @@ async function confirm(message, defaultYes = false) {
 }
 
 // ../multi-account-core/src/adapters/anthropic.ts
+var ANTHROPIC_DEFAULT_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var ANTHROPIC_DEFAULT_CLI_VERSION = "2.1.80";
+var ANTHROPIC_DEFAULT_USER_AGENT = "claude-cli/2.1.2 (external, cli)";
+var ANTHROPIC_DEFAULT_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+var ANTHROPIC_DEFAULT_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var ANTHROPIC_DEFAULT_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callback";
+var ANTHROPIC_DEFAULT_SCOPES = "org:create_api_key user:profile user:inference";
+var ANTHROPIC_DEFAULT_BETA_FLAGS = "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,prompt-caching-scope-2026-01-05";
+function buildCliUserAgent(cliVersion) {
+  return `claude-cli/${cliVersion} (external, cli)`;
+}
+function resolveAnthropicOAuthEnv(env = process.env) {
+  const cliVersion = env.ANTHROPIC_CLI_VERSION || ANTHROPIC_DEFAULT_CLI_VERSION;
+  const composedUserAgent = buildCliUserAgent(cliVersion);
+  const userAgent = env.ANTHROPIC_USER_AGENT || (env.ANTHROPIC_CLI_VERSION ? composedUserAgent : "") || ANTHROPIC_DEFAULT_USER_AGENT;
+  return {
+    clientId: env.ANTHROPIC_CLIENT_ID || ANTHROPIC_DEFAULT_CLIENT_ID,
+    cliVersion,
+    userAgent,
+    authorizeUrl: env.ANTHROPIC_AUTHORIZE_URL || ANTHROPIC_DEFAULT_AUTHORIZE_URL,
+    tokenUrl: env.ANTHROPIC_TOKEN_URL || ANTHROPIC_DEFAULT_TOKEN_URL,
+    redirectUri: env.ANTHROPIC_REDIRECT_URI || ANTHROPIC_DEFAULT_REDIRECT_URI,
+    scopes: env.ANTHROPIC_SCOPES || ANTHROPIC_DEFAULT_SCOPES,
+    betaFlags: env.ANTHROPIC_BETA_FLAGS || ANTHROPIC_DEFAULT_BETA_FLAGS
+  };
+}
+var anthropicEnv = resolveAnthropicOAuthEnv();
 var anthropicOAuthAdapter = {
   id: "anthropic",
   authProviderId: "anthropic",
@@ -1827,14 +1854,14 @@ var anthropicOAuthAdapter = {
   statusToolName: "claude_multiauth_status",
   authMethodLabel: "Claude Pro/Max (Multi-Auth)",
   serviceLogName: "claude-multiauth",
-  oauthClientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
-  tokenEndpoint: "https://console.anthropic.com/v1/oauth/token",
+  oauthClientId: anthropicEnv.clientId,
+  tokenEndpoint: anthropicEnv.tokenUrl,
   usageEndpoint: "https://api.anthropic.com/api/oauth/usage",
   profileEndpoint: "https://api.anthropic.com/api/oauth/profile",
   oauthBetaHeader: "oauth-2025-04-20",
-  requestBetaHeader: "oauth-2025-04-20,interleaved-thinking-2025-05-14",
-  cliUserAgent: "claude-cli/2.1.2 (external, cli)",
-  cliVersion: "2.1.80",
+  requestBetaHeader: anthropicEnv.betaFlags,
+  cliUserAgent: anthropicEnv.userAgent,
+  cliVersion: anthropicEnv.cliVersion,
   billingSalt: "59cf53e54c78",
   toolPrefix: "mcp_",
   accountStorageFilename: "anthropic-multi-account-accounts.json",
@@ -2183,8 +2210,12 @@ var CascadeStateManager = class {
 };
 
 // src/constants.ts
+var resolvedAnthropicOAuthEnv = resolveAnthropicOAuthEnv();
 var ANTHROPIC_OAUTH_ADAPTER = anthropicOAuthAdapter;
 var ANTHROPIC_CLIENT_ID = ANTHROPIC_OAUTH_ADAPTER.oauthClientId;
+var ANTHROPIC_AUTHORIZE_ENDPOINT = resolvedAnthropicOAuthEnv.authorizeUrl;
+var ANTHROPIC_REDIRECT_URI = resolvedAnthropicOAuthEnv.redirectUri;
+var ANTHROPIC_SCOPES = resolvedAnthropicOAuthEnv.scopes;
 var ANTHROPIC_TOKEN_ENDPOINT = ANTHROPIC_OAUTH_ADAPTER.tokenEndpoint;
 var ANTHROPIC_USAGE_ENDPOINT = ANTHROPIC_OAUTH_ADAPTER.usageEndpoint;
 var ANTHROPIC_PROFILE_ENDPOINT = ANTHROPIC_OAUTH_ADAPTER.profileEndpoint;
@@ -2469,12 +2500,14 @@ function fromPiAiCredentials(creds) {
     expiresAt: creds.expires
   };
 }
-var ANTHROPIC_REFRESH_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
+var ANTHROPIC_REFRESH_ENDPOINT = ANTHROPIC_TOKEN_ENDPOINT;
+var LEGACY_ANTHROPIC_TOKEN_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
 var REFRESH_NODE_EXECUTABLE = process.env.OPENCODE_REFRESH_NODE_EXECUTABLE || "node";
 var tokenProxyContext = new AsyncLocalStorage();
 var tokenProxyInstalled = false;
 var tokenProxyOriginalFetch = null;
 var refreshEndpointUrl = new URL(ANTHROPIC_REFRESH_ENDPOINT);
+var legacyRefreshEndpointUrl = new URL(LEGACY_ANTHROPIC_TOKEN_ENDPOINT);
 function buildRefreshRequestError(details) {
   return new Error(`Anthropic token refresh request failed. url=${ANTHROPIC_REFRESH_ENDPOINT}; details=${details}`);
 }
@@ -2490,9 +2523,65 @@ function isAnthropicTokenEndpoint(input) {
   const rawUrl = getRequestUrlString(input);
   try {
     const url = new URL(rawUrl);
-    return url.origin === refreshEndpointUrl.origin && url.pathname === refreshEndpointUrl.pathname;
+    const isConfiguredEndpoint = url.origin === refreshEndpointUrl.origin && url.pathname === refreshEndpointUrl.pathname;
+    const isLegacyEndpoint = url.origin === legacyRefreshEndpointUrl.origin && url.pathname === legacyRefreshEndpointUrl.pathname;
+    return isConfiguredEndpoint || isLegacyEndpoint;
+  } catch {
+    return rawUrl === ANTHROPIC_REFRESH_ENDPOINT || rawUrl === LEGACY_ANTHROPIC_TOKEN_ENDPOINT;
+  }
+}
+function applyOverridesToTokenParams(params) {
+  params.set("client_id", ANTHROPIC_CLIENT_ID);
+  if (params.get("grant_type") === "authorization_code") {
+    params.set("redirect_uri", ANTHROPIC_REDIRECT_URI);
+    params.set("scope", ANTHROPIC_SCOPES);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function applyAnthropicTokenRequestOverrides(rawBody) {
+  const trimmed = rawBody.trim();
+  if (trimmed.length === 0) {
+    return rawBody;
+  }
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (!isRecord(parsed)) {
+        return rawBody;
+      }
+      const grantType = typeof parsed.grant_type === "string" ? parsed.grant_type : "";
+      parsed.client_id = ANTHROPIC_CLIENT_ID;
+      if (grantType === "authorization_code") {
+        parsed.redirect_uri = ANTHROPIC_REDIRECT_URI;
+        parsed.scope = ANTHROPIC_SCOPES;
+      }
+      return JSON.stringify(parsed);
+    } catch {
+      return rawBody;
+    }
+  }
+  const params = new URLSearchParams(rawBody);
+  applyOverridesToTokenParams(params);
+  return params.toString();
+}
+function rewriteAnthropicAuthUrl(rawUrl) {
+  try {
+    const configuredAuthorizeUrl = new URL(ANTHROPIC_AUTHORIZE_ENDPOINT);
+    const rewritten = new URL(rawUrl);
+    rewritten.protocol = configuredAuthorizeUrl.protocol;
+    rewritten.host = configuredAuthorizeUrl.host;
+    rewritten.pathname = configuredAuthorizeUrl.pathname;
+    for (const [key, value] of configuredAuthorizeUrl.searchParams.entries()) {
+      rewritten.searchParams.set(key, value);
+    }
+    rewritten.searchParams.set("client_id", ANTHROPIC_CLIENT_ID);
+    rewritten.searchParams.set("redirect_uri", ANTHROPIC_REDIRECT_URI);
+    rewritten.searchParams.set("scope", ANTHROPIC_SCOPES);
+    return rewritten.toString();
   } catch {
-    return rawUrl === ANTHROPIC_REFRESH_ENDPOINT;
+    return rawUrl;
   }
 }
 function getRequestBodySource(input, init) {
@@ -2530,10 +2619,11 @@ function shouldProxyTokenRequest(input) {
   return tokenProxyContext.getStore() === true && isAnthropicTokenEndpoint(input);
 }
 async function postAnthropicTokenViaNode(body) {
+  const overriddenBody = applyAnthropicTokenRequestOverrides(body);
   let output;
   try {
     output = await runNodeTokenRequest({
-      body,
+      body: overriddenBody,
       endpoint: ANTHROPIC_REFRESH_ENDPOINT,
       executable: REFRESH_NODE_EXECUTABLE,
       timeoutMs: TOKEN_REFRESH_TIMEOUT_MS
@@ -2596,7 +2686,12 @@ async function fetchProfileWithSingleRetry(accessToken) {
 }
 async function loginWithPiAi(callbacks) {
   const piCreds = await withAnthropicTokenProxyFetch(() => piAiOauth.loginAnthropic({
-    onAuth: callbacks.onAuth,
+    onAuth: (info) => {
+      callbacks.onAuth({
+        ...info,
+        url: info.url ? rewriteAnthropicAuthUrl(info.url) : info.url
+      });
+    },
     onPrompt: callbacks.onPrompt,
     onProgress: callbacks.onProgress,
     onManualCodeInput: callbacks.onManualCodeInput
@@ -2976,7 +3071,7 @@ function printUsageEntry(name, entry, isLast) {
     return;
   }
   const bar = createProgressBar(entry.utilization);
-  const reset = entry.utilization >= 100 && entry.resets_at ? formatResetTime(entry.resets_at) : "";
+  const reset = entry.resets_at ? formatResetTime(entry.resets_at) : "";
   console.log(`     ${connector} ${name.padEnd(16)} ${bar}${reset}`);
 }
 function printQuotaReport(account, usage) {
@@ -3535,11 +3630,30 @@ function buildBillingHeader(firstUserMessage) {
   if (!version || !salt) return "";
   const sampled = sampleCodeUnits(firstUserMessage, [4, 7, 20]);
   const hash = createHash("sha256").update(`${salt}${sampled}${version}`).digest("hex").slice(0, 3);
-  return `x-anthropic-billing-header: cc_version=${version}.${hash}; cc_entrypoint=cli; cch=00000;`;
+  return `cc_version=${version}.${hash}; cc_entrypoint=cli; cch=00000;`;
 }
 var OPENCODE_CAMEL_RE = /OpenCode/g;
 var OPENCODE_LOWER_RE = /(?<!\/)opencode/gi;
 var TOOL_PREFIX_RESPONSE_RE = /"name"\s*:\s*"mcp_([^"]+)"/g;
+function extractFirstUserTextFromBody(body) {
+  if (!body) return "";
+  try {
+    const parsed = JSON.parse(body);
+    if (!Array.isArray(parsed.messages)) return "";
+    for (const message of parsed.messages) {
+      if (message.role !== "user") continue;
+      if (typeof message.content === "string") return message.content;
+      if (!Array.isArray(message.content)) continue;
+      for (const block of message.content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          return block.text;
+        }
+      }
+    }
+  } catch {
+  }
+  return "";
+}
 function addToolPrefix(name) {
   if (!ANTHROPIC_OAUTH_ADAPTER.transform.addToolPrefix) {
     return name;
@@ -3565,7 +3679,7 @@ function processCompleteLines(buffer) {
 `;
   return { output, remaining };
 }
-function buildRequestHeaders(input, init, accessToken) {
+function buildRequestHeaders(input, init, accessToken, bodyString) {
   const headers = new Headers();
   if (input instanceof Request) {
     input.headers.forEach((value, key) => {
@@ -3597,6 +3711,13 @@ function buildRequestHeaders(input, init, accessToken) {
   headers.set("user-agent", CLAUDE_CLI_USER_AGENT);
   headers.set("anthropic-dangerous-direct-browser-access", "true");
   headers.set("x-app", "cli");
+  const resolvedBody = bodyString ?? (typeof init?.body === "string" ? init.body : void 0);
+  const billingHeader = buildBillingHeader(
+    extractFirstUserTextFromBody(resolvedBody)
+  );
+  if (billingHeader) {
+    headers.set("x-anthropic-billing-header", billingHeader);
+  }
   headers.delete("x-api-key");
   return headers;
 }
@@ -3775,8 +3896,9 @@ var AccountRuntimeFactory = class {
   }
   async executeTransformedFetch(input, init, accessToken) {
     const transformedInput = transformRequestUrl(input);
-    const headers = buildRequestHeaders(transformedInput, init, accessToken);
-    const transformedBody = typeof init?.body === "string" ? transformRequestBody(init.body) : init?.body;
+    const rawBody = typeof init?.body === "string" ? init.body : void 0;
+    const headers = buildRequestHeaders(transformedInput, init, accessToken, rawBody);
+    const transformedBody = rawBody !== void 0 ? transformRequestBody(rawBody) : init?.body;
     const response = await fetch(transformedInput, {
       ...init,
       headers,
@@ -3807,24 +3929,6 @@ var AccountRuntimeFactory = class {
 };
 
 // src/index.ts
-function extractFirstUserText(input) {
-  try {
-    const raw = input;
-    const messages = raw.messages ?? raw.request?.messages;
-    if (!Array.isArray(messages)) return "";
-    for (const msg of messages) {
-      if (msg.role !== "user") continue;
-      if (typeof msg.content === "string") return msg.content;
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === "text" && block.text) return block.text;
-        }
-      }
-    }
-  } catch {
-  }
-  return "";
-}
 function injectSystemPrompt(output) {
   const systemPrompt = getSystemPrompt();
   if (!Array.isArray(output.system)) {
@@ -3846,12 +3950,8 @@ var ClaudeMultiAuthPlugin = async (ctx) => {
   let cascadeStateManager = null;
   let poolChainConfig = { pools: [], chains: [] };
   return {
-    "experimental.chat.system.transform": (input, output) => {
+    "experimental.chat.system.transform": (_input, output) => {
       injectSystemPrompt(output);
-      const billingHeader = buildBillingHeader(extractFirstUserText(input));
-      if (billingHeader && !output.system?.includes(billingHeader)) {
-        output.system?.unshift(billingHeader);
-      }
     },
     tool: {
       [ANTHROPIC_OAUTH_ADAPTER.statusToolName]: tool({

package/dist/pi-ai-adapter.d.ts

@@ -11,6 +11,8 @@ export interface LoginWithPiAiCallbacks {
     onProgress?: (message: string) => void;
     onManualCodeInput?: () => Promise<string>;
 }
+export declare function applyAnthropicTokenRequestOverrides(rawBody: string): string;
+export declare function rewriteAnthropicAuthUrl(rawUrl: string): string;
 export declare function withAnthropicTokenProxyFetch<T>(operation: () => Promise<T>): Promise<T>;
 export declare function resetAnthropicTokenProxyStateForTest(): void;
 export declare function loginWithPiAi(callbacks: LoginWithPiAiCallbacks): Promise<Partial<StoredAccount>>;

package/dist/request-transform.d.ts

@@ -1,6 +1,6 @@
 export declare function getSystemPrompt(): string;
 export declare function buildBillingHeader(firstUserMessage: string): string;
-export declare function buildRequestHeaders(input: RequestInfo | URL, init: RequestInit | undefined, accessToken: string): Headers;
+export declare function buildRequestHeaders(input: RequestInfo | URL, init: RequestInit | undefined, accessToken: string, bodyString?: string): Headers;
 export declare function transformRequestBody(body: string | undefined): string | undefined;
 export declare function transformRequestUrl(input: RequestInfo | URL): RequestInfo | URL;
 export declare function createResponseStreamTransform(response: Response): Response;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-multi-account",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "OpenCode plugin for Anthropic multi-account management with automatic rate limit switching",
   "main": "./dist/index.js",
   "type": "module",
@@ -39,7 +39,7 @@
     "directory": "packages/anthropic-multi-account"
   },
   "dependencies": {
-    "opencode-multi-account-core": "^0.2.5",
+    "opencode-multi-account-core": "^0.2.6",
     "@mariozechner/pi-ai": "^0.61.0",
     "valibot": "^1.2.0"
   },