opencode-anthropic-fix 0.0.19 → 0.0.21

package/README.md

@@ -43,8 +43,11 @@ The [original plugin](https://github.com/anomalyco/opencode-anthropic-auth) prov
 - **Standalone CLI** — manage accounts without opening OpenCode
 - **Configurable strategies** — sticky, round-robin, or hybrid account selection
 - **Claude Code signature emulation** — full HTTP header, system prompt, beta flag, and metadata mimicry derived from Claude Code's open source code
-- **Adaptive thinking for Opus 4.6** — automatically uses `adaptive-thinking-2026-01-28` and maps `budgetTokens` to effort levels (`low`/`medium`/`high`/`max`)
+- **Adaptive thinking for Opus 4.6** — automatically uses `adaptive-thinking-2026-01-28` and maps `budgetTokens` to effort levels (`low`/`medium`/`high`)
 - **1M context limit override** — patches `model.limit.context` so OpenCode compacts at the right threshold while `models.dev` catches up
+- **Runtime config + custom betas** — `/anthropic set`, `/anthropic config`, and `/anthropic betas` slash commands for live feature toggling without restarting OpenCode
+- **Files API integration** — upload, list, download, and manage files via `/anthropic files` with auto-included `files-api-2025-04-14` beta
+- **Code execution support** — auto-includes `code-execution-2025-08-25` beta for sandbox code execution (non-Haiku models)
 
 ## Installation
 
@@ -231,22 +234,80 @@ Most commands have short aliases: `ln`, `lo`, `ra`, `rf`, `ls`, `st`, `sw`, `en`
 
 ## Slash Commands in OpenCode
 
-The plugin also registers a built-in `/anthropic` slash command so you can manage accounts without leaving OpenCode.
+The plugin registers a built-in `/anthropic` slash command for account management, feature toggles, and custom beta headers — all without leaving OpenCode.
 
-### Common examples
+### Account management
 
 ```text
-/anthropic                # list (default)
+/anthropic                # list accounts (default)
 /anthropic usage          # full account list + quota windows
 /anthropic switch 2
 /anthropic refresh 1
 /anthropic logout 2       # revoke tokens and remove account 2
 /anthropic logout --all   # revoke all tokens and clear all accounts
-/anthropic strategy hybrid
 /anthropic stats
-/anthropic config
 ```
 
+### Runtime configuration
+
+Toggle features live without restarting OpenCode. Changes are persisted to `anthropic-auth.json`.
+
+```text
+/anthropic config                  # show all current settings
+/anthropic set emulation on        # enable/disable Claude signature emulation
+/anthropic set compaction minimal  # set prompt compaction mode (minimal/off)
+/anthropic set 1m-context on       # enable/disable 1M context limit override
+/anthropic set idle-refresh on     # enable/disable idle account refresh
+/anthropic set strategy round-robin # change account selection strategy
+/anthropic set debug on            # enable/disable debug logging
+/anthropic set quiet on            # suppress non-error toasts
+```
+
+### Custom beta headers
+
+Add or remove beta flags that get included in every `anthropic-beta` header. Persisted across sessions.
+
+```text
+/anthropic betas                   # show active betas (auto + custom) with presets
+/anthropic betas add <beta-name>   # add a custom beta
+/anthropic betas remove <beta-name> # remove a custom beta
+```
+
+**Available preset betas** (shown by `/anthropic betas`):
+
+| Beta                              | Description                                       |
+| --------------------------------- | ------------------------------------------------- |
+| `prompt-caching-scope-2026-01-05` | Cache control with `scope: "org"` — free perf win |
+| `context-management-2025-06-27`   | Server-side auto-summarization when context fills |
+| `structured-outputs-2025-12-15`   | Strict JSON schema output enforcement             |
+| `tool-examples-2025-10-29`        | Input/output examples in tool definitions         |
+| `compact-2026-01-12`              | Conversation compaction endpoint                  |
+| `mcp-servers-2025-12-04`          | MCP servers in API request payload                |
+| `web-search-2025-03-05`           | Web search (Vertex/Foundry only)                  |
+
+Example workflow:
+
+```text
+/anthropic betas add prompt-caching-scope-2026-01-05
+/anthropic betas add context-management-2025-06-27
+/anthropic betas   # verify
+```
+
+### Files API management
+
+Upload, list, download, and delete files via the Anthropic Files API. The `files-api-2025-04-14` beta is auto-included in every request.
+
+```text
+/anthropic files                       # list uploaded files
+/anthropic files upload ./report.pdf   # upload a file
+/anthropic files get file_abc123       # get file metadata
+/anthropic files download file_abc123  # download to current directory
+/anthropic files download file_abc123 ./out.pdf  # download to specific path
+/anthropic files delete file_abc123    # delete a file
+```
+
+Supported formats: PDF, DOCX, TXT, CSV, Excel, Markdown, images (max 350 MB per file). Uploaded files can be referenced by `file_id` in Messages API requests.
+
 ### OAuth flows from slash command
 
 Login and reauth are two-step flows in slash mode:
@@ -272,11 +333,11 @@ Pending slash OAuth flows expire after 10 minutes. If completion fails with an e
 
 Control how the plugin picks which account to use for each request.
 
-| Strategy               | Behavior                                                                                  | Best For                                              |
-| ---------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------- |
-| **`sticky`** (default) | Stay on one account until it fails or is rate-limited                                     | Single account, or when you want predictable behavior |
-| **`round-robin`**      | Rotate through accounts on every request                                                  | Spreading load evenly across accounts                 |
-| **`hybrid`**           | Score-based selection with stickiness bias. Considers health, token budget, and freshness | Multiple accounts with varying rate limits            |
+| Strategy                    | Behavior                                                                                  | Best For                                              |
+| --------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------- |
+| **`round-robin`** (default) | Rotate through accounts on every request                                                  | Spreading load evenly across accounts                 |
+| **`sticky`**                | Stay on one account until it fails or is rate-limited                                     | Single account, or when you want predictable behavior |
+| **`hybrid`**                | Score-based selection with stickiness bias. Considers health, token budget, and freshness | Multiple accounts with varying rate limits            |
 
 ### Change Strategy
 
@@ -297,8 +358,8 @@ Configuration is stored at `~/.config/opencode/anthropic-auth.json`. All setting
 
 ```jsonc
 {
-  // Account selection strategy: "sticky" | "round-robin" | "hybrid"
-  "account_selection_strategy": "sticky",
+  // Account selection strategy: "round-robin" | "sticky" | "hybrid"
+  "account_selection_strategy": "round-robin",
 
   // Seconds before consecutive failure count resets (60-7200)
   "failure_ttl_seconds": 3600,
@@ -325,8 +386,8 @@ Configuration is stored at `~/.config/opencode/anthropic-auth.json`. All setting
   // Only applied for OAuth (Max Plan) sessions — API key users use the
   // context-1m-2025-08-07 beta header instead.
   "override_model_limits": {
-    // Enable/disable the override
-    "enabled": true,
+    // Enable/disable the override (default: off — enable if you need 1M context)
+    "enabled": false,
     // Context window to inject (tokens). Default: 1_000_000.
     "context": 1000000,
     // Max output tokens to inject. 0 = leave the model's default unchanged.
@@ -351,6 +412,9 @@ Configuration is stored at `~/.config/opencode/anthropic-auth.json`. All setting
     "initial_tokens": 50,
   },
 
+  // Custom beta headers (added to every request via /anthropic betas add)
+  "custom_betas": [],
+
   // Toast notification settings
   "toasts": {
     // Suppress non-error toasts (account status, switching)

package/index.mjs

@@ -2,10 +2,10 @@ import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { join, resolve, basename } from "node:path";
 import { AccountManager } from "./lib/accounts.mjs";
 import { authorize, exchange, refreshToken } from "./lib/oauth.mjs";
-import { loadConfig, CLIENT_ID, getConfigDir } from "./lib/config.mjs";
+import { loadConfig, loadConfigFresh, saveConfig, CLIENT_ID, getConfigDir } from "./lib/config.mjs";
 import { loadAccounts, saveAccounts, clearAccounts, createDefaultStats } from "./lib/storage.mjs";
 import { applyOAuthCredentials, resetAccountTracking } from "./lib/account-state.mjs";
 import { acquireRefreshLock, releaseRefreshLock } from "./lib/refresh-lock.mjs";
@@ -119,6 +119,8 @@ const BEDROCK_UNSUPPORTED_BETAS = new Set([
   "context-1m-2025-08-07",
   "tool-search-tool-2025-10-19",
   "tool-examples-2025-10-29",
+  "code-execution-2025-08-25",
+  "files-api-2025-04-14",
 ]);
 const STAINLESS_HELPER_KEYS = [
   "x_stainless_helper",
@@ -659,9 +661,10 @@ function buildSystemPromptBlocks(system, signature, messages) {
  * @param {boolean} signatureEnabled
  * @param {string} model
  * @param {"anthropic" | "bedrock" | "vertex" | "foundry"} provider
+ * @param {string[]} [customBetas]
  * @returns {string}
  */
-function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provider) {
+function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provider, customBetas) {
   const incomingBetasList = incomingBeta
     .split(",")
     .map((b) => b.trim())
@@ -679,8 +682,12 @@ function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provide
 
   if (!haiku) {
     betas.push(CLAUDE_CODE_BETA_FLAG);
+    betas.push("code-execution-2025-08-25");
   }
 
+  // Files API is model-independent; enables /v1/files endpoint and file_id references.
+  betas.push("files-api-2025-04-14");
+
   if (isOpus46Model(model)) {
     // Opus 4.6 uses adaptive thinking — model decides how much to think based on task complexity.
     // The effort parameter guides it; budgetTokens/interleaved-thinking are for older models.
@@ -729,6 +736,10 @@ function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provide
 
   betas.push("fine-grained-tool-streaming-2025-05-14");
 
+  if (Array.isArray(customBetas)) {
+    betas.push(...customBetas.filter(Boolean));
+  }
+
   const mergedBetas = [...new Set([...betas, ...incomingBetasList])];
   if (provider === "bedrock") {
     return mergedBetas.filter((beta) => !BEDROCK_UNSUPPORTED_BETAS.has(beta)).join(",");
@@ -887,7 +898,7 @@ function buildRequestHeaders(input, requestInit, accessToken, requestBody, reque
   const incomingBeta = requestHeaders.get("anthropic-beta") || "";
   const { model, tools, messages } = parseRequestBodyMetadata(requestBody);
   const provider = detectProvider(requestUrl);
-  const mergedBetas = buildAnthropicBetaHeader(incomingBeta, signature.enabled, model, provider);
+  const mergedBetas = buildAnthropicBetaHeader(incomingBeta, signature.enabled, model, provider, signature.customBetas);
 
   const authTokenOverride = process.env.ANTHROPIC_AUTH_TOKEN?.trim();
   const bearerToken = authTokenOverride || accessToken;
@@ -1900,6 +1911,362 @@ export async function AnthropicAuthPlugin({ client }) {
       return;
     }
 
+    // /anthropic config — show effective config
+    if (primary === "config") {
+      const fresh = loadConfigFresh();
+      const lines = [
+        "▣ Anthropic Config",
+        "",
+        `strategy: ${fresh.account_selection_strategy}`,
+        `emulation: ${fresh.signature_emulation.enabled ? "on" : "off"}`,
+        `compaction: ${fresh.signature_emulation.prompt_compaction}`,
+        `1m-context: ${fresh.override_model_limits.enabled ? "on" : "off"}`,
+        `idle-refresh: ${fresh.idle_refresh.enabled ? "on" : "off"}`,
+        `debug: ${fresh.debug ? "on" : "off"}`,
+        `quiet: ${fresh.toasts.quiet ? "on" : "off"}`,
+        `custom_betas: ${fresh.custom_betas.length ? fresh.custom_betas.join(", ") : "(none)"}`,
+      ];
+      await sendCommandMessage(input.sessionID, lines.join("\n"));
+      return;
+    }
+
+    // /anthropic set <key> <value> — toggle features at runtime
+    if (primary === "set") {
+      const key = (args[1] || "").toLowerCase();
+      const value = (args[2] || "").toLowerCase();
+      /** @type {Record<string, () => void>} */
+      const setters = {
+        emulation: () =>
+          saveConfig({ signature_emulation: { enabled: value === "on" || value === "1" || value === "true" } }),
+        compaction: () =>
+          saveConfig({ signature_emulation: { prompt_compaction: value === "off" ? "off" : "minimal" } }),
+        "1m-context": () =>
+          saveConfig({ override_model_limits: { enabled: value === "on" || value === "1" || value === "true" } }),
+        "idle-refresh": () =>
+          saveConfig({ idle_refresh: { enabled: value === "on" || value === "1" || value === "true" } }),
+        debug: () => saveConfig({ debug: value === "on" || value === "1" || value === "true" }),
+        quiet: () => saveConfig({ toasts: { quiet: value === "on" || value === "1" || value === "true" } }),
+        strategy: () => {
+          const valid = ["sticky", "round-robin", "hybrid"];
+          if (valid.includes(value)) saveConfig({ account_selection_strategy: value });
+          else throw new Error(`Invalid strategy. Valid: ${valid.join(", ")}`);
+        },
+      };
+
+      if (!key || !setters[key]) {
+        const keys = Object.keys(setters).join(", ");
+        await sendCommandMessage(
+          input.sessionID,
+          `▣ Anthropic Set\n\nUsage: /anthropic set <key> <value>\nKeys: ${keys}\nValues: on/off (or specific values for strategy/compaction)`,
+        );
+        return;
+      }
+      if (!value) {
+        await sendCommandMessage(input.sessionID, `▣ Anthropic Set\n\nMissing value for "${key}".`);
+        return;
+      }
+      setters[key]();
+      // Reload config into runtime
+      Object.assign(config, loadConfigFresh());
+      await sendCommandMessage(input.sessionID, `▣ Anthropic Set\n\n${key} = ${value}`);
+      return;
+    }
+
+    // /anthropic betas [add|remove <beta>] — show/manage custom betas
+    if (primary === "betas") {
+      const action = (args[1] || "").toLowerCase();
+
+      if (!action || action === "list") {
+        const fresh = loadConfigFresh();
+        const lines = [
+          "▣ Anthropic Betas",
+          "",
+          "Preset betas (auto-computed per model/provider):",
+          "  oauth-2025-04-20, claude-code-20250219,",
+          "  interleaved-thinking-2025-05-14 OR adaptive-thinking-2026-01-28,",
+          "  fine-grained-tool-streaming-2025-05-14,",
+          "  code-execution-2025-08-25 (non-Haiku),",
+          "  files-api-2025-04-14",
+          "",
+          `Custom betas: ${fresh.custom_betas.length ? fresh.custom_betas.join(", ") : "(none)"}`,
+          "",
+          "Toggleable presets:",
+          "  /anthropic betas add structured-outputs-2025-12-15",
+          "  /anthropic betas add context-management-2025-06-27",
+          "  /anthropic betas add prompt-caching-scope-2026-01-05",
+          "  /anthropic betas add tool-examples-2025-10-29",
+          "  /anthropic betas add web-search-2025-03-05",
+          "  /anthropic betas add compact-2026-01-12",
+          "  /anthropic betas add mcp-servers-2025-12-04",
+          "",
+          "Remove: /anthropic betas remove <beta>",
+        ];
+        await sendCommandMessage(input.sessionID, lines.join("\n"));
+        return;
+      }
+
+      if (action === "add") {
+        const beta = args[2]?.trim();
+        if (!beta) {
+          await sendCommandMessage(input.sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas add <beta-name>");
+          return;
+        }
+        const fresh = loadConfigFresh();
+        const current = fresh.custom_betas || [];
+        if (current.includes(beta)) {
+          await sendCommandMessage(input.sessionID, `▣ Anthropic Betas\n\n"${beta}" already added.`);
+          return;
+        }
+        saveConfig({ custom_betas: [...current, beta] });
+        Object.assign(config, loadConfigFresh());
+        await sendCommandMessage(input.sessionID, `▣ Anthropic Betas\n\nAdded: ${beta}`);
+        return;
+      }
+
+      if (action === "remove" || action === "rm") {
+        const beta = args[2]?.trim();
+        if (!beta) {
+          await sendCommandMessage(input.sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas remove <beta-name>");
+          return;
+        }
+        const fresh = loadConfigFresh();
+        const current = fresh.custom_betas || [];
+        if (!current.includes(beta)) {
+          await sendCommandMessage(input.sessionID, `▣ Anthropic Betas\n\n"${beta}" not in custom betas.`);
+          return;
+        }
+        saveConfig({ custom_betas: current.filter((b) => b !== beta) });
+        Object.assign(config, loadConfigFresh());
+        await sendCommandMessage(input.sessionID, `▣ Anthropic Betas\n\nRemoved: ${beta}`);
+        return;
+      }
+
+      await sendCommandMessage(input.sessionID, "▣ Anthropic Betas\n\nUsage: /anthropic betas [add|remove <beta>]");
+      return;
+    }
+
+    // /anthropic files [list|upload|get|delete|download] — Files API management
+    if (primary === "files") {
+      const action = (args[1] || "").toLowerCase();
+
+      // Get current account and ensure valid token
+      const account = accountManager?.getCurrentAccount();
+      if (!account) {
+        await sendCommandMessage(
+          input.sessionID,
+          "▣ Anthropic Files (error)\n\nNo accounts configured. Use /anthropic login first.",
+        );
+        return;
+      }
+
+      let token = account.access;
+      if (!token || !account.expires || account.expires < Date.now()) {
+        try {
+          token = await refreshAccountTokenSingleFlight(account);
+        } catch (err) {
+          await sendCommandMessage(
+            input.sessionID,
+            `▣ Anthropic Files (error)\n\nToken refresh failed: ${err.message}`,
+          );
+          return;
+        }
+      }
+
+      const apiBase = "https://api.anthropic.com";
+      const authHeaders = {
+        authorization: `Bearer ${token}`,
+        "anthropic-beta": "files-api-2025-04-14",
+      };
+
+      try {
+        // /anthropic files list — list all uploaded files
+        if (!action || action === "list") {
+          const res = await fetch(`${apiBase}/v1/files`, { headers: authHeaders });
+          if (!res.ok) {
+            const errBody = await res.text();
+            await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\nHTTP ${res.status}: ${errBody}`);
+            return;
+          }
+          const data = await res.json();
+          const files = data.data || [];
+          if (files.length === 0) {
+            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nNo files uploaded.");
+            return;
+          }
+          const lines = ["▣ Anthropic Files", "", `${files.length} file(s):`, ""];
+          for (const f of files) {
+            const sizeKB = (f.size / 1024).toFixed(1);
+            lines.push(`  ${f.id}  ${f.filename}  (${sizeKB} KB, ${f.purpose})`);
+          }
+          await sendCommandMessage(input.sessionID, lines.join("\n"));
+          return;
+        }
+
+        // /anthropic files upload <path> — upload a file
+        if (action === "upload") {
+          const filePath = args.slice(2).join(" ").trim();
+          if (!filePath) {
+            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nUsage: /anthropic files upload <path>");
+            return;
+          }
+          const resolvedPath = resolve(filePath);
+          if (!existsSync(resolvedPath)) {
+            await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\nFile not found: ${resolvedPath}`);
+            return;
+          }
+          const content = readFileSync(resolvedPath);
+          const filename = basename(resolvedPath);
+          const blob = new Blob([content]);
+          const form = new FormData();
+          form.append("file", blob, filename);
+          form.append("purpose", "assistants");
+
+          const res = await fetch(`${apiBase}/v1/files`, {
+            method: "POST",
+            headers: {
+              authorization: `Bearer ${token}`,
+              "anthropic-beta": "files-api-2025-04-14",
+            },
+            body: form,
+          });
+          if (!res.ok) {
+            const errBody = await res.text();
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Files (error)\n\nUpload failed (HTTP ${res.status}): ${errBody}`,
+            );
+            return;
+          }
+          const file = await res.json();
+          const sizeKB = ((file.size || 0) / 1024).toFixed(1);
+          await sendCommandMessage(
+            input.sessionID,
+            `▣ Anthropic Files\n\nUploaded: ${file.id}\n  Filename: ${file.filename}\n  Size: ${sizeKB} KB`,
+          );
+          return;
+        }
+
+        // /anthropic files get <file_id> — get file metadata
+        if (action === "get" || action === "info") {
+          const fileId = args[2]?.trim();
+          if (!fileId) {
+            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nUsage: /anthropic files get <file_id>");
+            return;
+          }
+          const res = await fetch(`${apiBase}/v1/files/${encodeURIComponent(fileId)}`, { headers: authHeaders });
+          if (!res.ok) {
+            const errBody = await res.text();
+            await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\nHTTP ${res.status}: ${errBody}`);
+            return;
+          }
+          const file = await res.json();
+          const lines = [
+            "▣ Anthropic Files",
+            "",
+            `  ID:       ${file.id}`,
+            `  Filename: ${file.filename}`,
+            `  Purpose:  ${file.purpose}`,
+            `  Size:     ${((file.size || 0) / 1024).toFixed(1)} KB`,
+            `  Type:     ${file.mime_type || "unknown"}`,
+            `  Created:  ${file.created_at || "unknown"}`,
+          ];
+          await sendCommandMessage(input.sessionID, lines.join("\n"));
+          return;
+        }
+
+        // /anthropic files delete <file_id> — delete a file
+        if (action === "delete" || action === "rm") {
+          const fileId = args[2]?.trim();
+          if (!fileId) {
+            await sendCommandMessage(input.sessionID, "▣ Anthropic Files\n\nUsage: /anthropic files delete <file_id>");
+            return;
+          }
+          const res = await fetch(`${apiBase}/v1/files/${encodeURIComponent(fileId)}`, {
+            method: "DELETE",
+            headers: authHeaders,
+          });
+          if (!res.ok) {
+            const errBody = await res.text();
+            await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\nHTTP ${res.status}: ${errBody}`);
+            return;
+          }
+          await sendCommandMessage(input.sessionID, `▣ Anthropic Files\n\nDeleted: ${fileId}`);
+          return;
+        }
+
+        // /anthropic files download <file_id> [output_path] — download file content
+        if (action === "download" || action === "dl") {
+          const fileId = args[2]?.trim();
+          if (!fileId) {
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files download <file_id> [output_path]",
+            );
+            return;
+          }
+          const outputPath = args.slice(3).join(" ").trim();
+
+          // Get file metadata first for the filename
+          const metaRes = await fetch(`${apiBase}/v1/files/${encodeURIComponent(fileId)}`, {
+            headers: authHeaders,
+          });
+          if (!metaRes.ok) {
+            const errBody = await metaRes.text();
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Files (error)\n\nHTTP ${metaRes.status}: ${errBody}`,
+            );
+            return;
+          }
+          const meta = await metaRes.json();
+          const savePath = outputPath ? resolve(outputPath) : resolve(meta.filename);
+
+          // Download file content
+          const res = await fetch(`${apiBase}/v1/files/${encodeURIComponent(fileId)}/content`, {
+            headers: authHeaders,
+          });
+          if (!res.ok) {
+            const errBody = await res.text();
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Files (error)\n\nDownload failed (HTTP ${res.status}): ${errBody}`,
+            );
+            return;
+          }
+          const buffer = Buffer.from(await res.arrayBuffer());
+          writeFileSync(savePath, buffer);
+          const sizeKB = (buffer.length / 1024).toFixed(1);
+          await sendCommandMessage(
+            input.sessionID,
+            `▣ Anthropic Files\n\nDownloaded: ${meta.filename}\n  Saved to: ${savePath}\n  Size: ${sizeKB} KB`,
+          );
+          return;
+        }
+
+        // Unknown action — show help
+        const helpLines = [
+          "▣ Anthropic Files",
+          "",
+          "Usage: /anthropic files <action>",
+          "",
+          "Actions:",
+          "  list                          List uploaded files",
+          "  upload <path>                 Upload a file (max 350MB)",
+          "  get <file_id>                 Get file metadata",
+          "  delete <file_id>              Delete a file",
+          "  download <file_id> [path]     Download file content",
+          "",
+          "Supported formats: PDF, DOCX, TXT, CSV, Excel, Markdown, images",
+          "Files can be referenced by file_id in Messages API requests.",
+        ];
+        await sendCommandMessage(input.sessionID, helpLines.join("\n"));
+        return;
+      } catch (err) {
+        await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\n${err.message}`);
+        return;
+      }
+    }
+
     // Interactive CLI command is not compatible with slash flow.
     if (primary === "manage" || primary === "mg") {
       await sendCommandMessage(
@@ -2160,7 +2527,7 @@ export async function AnthropicAuthPlugin({ client }) {
       input.command ??= {};
       input.command["anthropic"] = {
         template: "/anthropic",
-        description: "Manage Anthropic multi-account auth (status, usage, switch, login, reauth, logout)",
+        description: "Manage Anthropic auth, config, and betas (usage, login, config, set, betas, switch)",
       };
     },
     "command.execute.before": async (input) => {
@@ -2388,6 +2755,7 @@ export async function AnthropicAuthPlugin({ client }) {
                 const requestHeaders = buildRequestHeaders(input, requestInit, accessToken, body, requestUrl, {
                   enabled: signatureEmulationEnabled,
                   claudeCliVersion,
+                  customBetas: config.custom_betas,
                 });
                 // Execute the request
                 let response;

package/lib/config.mjs

@@ -51,6 +51,7 @@ import { homedir } from "node:os";
  * @property {boolean} debug
  * @property {{ enabled: boolean, fetch_claude_code_version_on_startup: boolean, prompt_compaction: 'minimal' | 'off' }} signature_emulation
  * @property {OverrideModelLimitsConfig} override_model_limits
+ * @property {string[]} custom_betas
  * @property {HealthScoreConfig} health_score
  * @property {TokenBucketConfig} token_bucket
  * @property {ToastConfig} toasts
@@ -60,7 +61,7 @@ import { homedir } from "node:os";
 
 /** @type {AnthropicAuthConfig} */
 export const DEFAULT_CONFIG = {
-  account_selection_strategy: "sticky",
+  account_selection_strategy: "round-robin",
   failure_ttl_seconds: 3600,
   debug: false,
   signature_emulation: {
@@ -69,10 +70,11 @@ export const DEFAULT_CONFIG = {
     prompt_compaction: "minimal",
   },
   override_model_limits: {
-    enabled: true,
+    enabled: false,
     context: 1_000_000,
     output: 0,
   },
+  custom_betas: [],
   health_score: {
     initial: 70,
     success_reward: 1,
@@ -112,6 +114,7 @@ function createDefaultConfig() {
     ...DEFAULT_CONFIG,
     signature_emulation: { ...DEFAULT_CONFIG.signature_emulation },
     override_model_limits: { ...DEFAULT_CONFIG.override_model_limits },
+    custom_betas: [...DEFAULT_CONFIG.custom_betas],
     health_score: { ...DEFAULT_CONFIG.health_score },
     token_bucket: { ...DEFAULT_CONFIG.token_bucket },
     toasts: { ...DEFAULT_CONFIG.toasts },
@@ -197,6 +200,11 @@ function validateConfig(raw) {
     };
   }
 
+  // Custom betas
+  if (Array.isArray(raw.custom_betas)) {
+    config.custom_betas = raw.custom_betas.filter((b) => typeof b === "string" && b.trim()).map((b) => b.trim());
+  }
+
   // Health score sub-config
   if (raw.health_score && typeof raw.health_score === "object") {
     const hs = /** @type {Record<string, unknown>} */ (raw.health_score);
@@ -408,19 +416,56 @@ export function loadRawConfig() {
  * Uses atomic write (temp + rename) for safety.
  * @param {Record<string, unknown>} updates - Keys to merge into the config file
  */
+/**
+ * Deep merge source into target (one level deep for objects, replace for arrays/primitives).
+ * @param {Record<string, unknown>} target
+ * @param {Record<string, unknown>} source
+ * @returns {Record<string, unknown>}
+ */
+function deepMergeConfig(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (
+      value &&
+      typeof value === "object" &&
+      !Array.isArray(value) &&
+      typeof result[key] === "object" &&
+      result[key] &&
+      !Array.isArray(result[key])
+    ) {
+      result[key] = {
+        .../** @type {Record<string, unknown>} */ (result[key]),
+        .../** @type {Record<string, unknown>} */ (value),
+      };
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 export function saveConfig(updates) {
   const configPath = getConfigPath();
   const dir = dirname(configPath);
   mkdirSync(dir, { recursive: true });
 
-  // Read existing raw config
+  // Re-read from disk to avoid clobbering concurrent writes
   const existing = loadRawConfig();
 
-  // Merge updates
-  const merged = { ...existing, ...updates };
+  // Deep merge (one level) so sub-config objects are merged, not replaced
+  const merged = deepMergeConfig(existing, updates);
 
   // Atomic write: temp file + rename
   const tmpPath = configPath + `.tmp.${process.pid}`;
   writeFileSync(tmpPath, JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 0o600 });
   renameSync(tmpPath, configPath);
 }
+
+/**
+ * Load config fresh from disk (bypassing any startup cache).
+ * Useful for slash commands that need current on-disk state.
+ * @returns {AnthropicAuthConfig}
+ */
+export function loadConfigFresh() {
+  return loadConfig();
+}

package/lib/config.test.mjs

@@ -10,7 +10,7 @@ vi.mock("node:fs", () => ({
 
 describe("DEFAULT_CONFIG", () => {
   it("has expected default strategy", () => {
-    expect(DEFAULT_CONFIG.account_selection_strategy).toBe("sticky");
+    expect(DEFAULT_CONFIG.account_selection_strategy).toBe("round-robin");
   });
 
   it("has expected health score defaults", () => {
@@ -114,7 +114,7 @@ describe("loadConfig", () => {
     existsSync.mockReturnValue(true);
     readFileSync.mockReturnValue(JSON.stringify({ account_selection_strategy: "invalid" }));
     const config = loadConfig();
-    expect(config.account_selection_strategy).toBe("sticky");
+    expect(config.account_selection_strategy).toBe("round-robin");
   });
 
   it("accepts boolean debug", () => {
@@ -199,7 +199,7 @@ describe("loadConfig", () => {
     existsSync.mockReturnValue(false);
     process.env.OPENCODE_ANTHROPIC_STRATEGY = "invalid";
     const config = loadConfig();
-    expect(config.account_selection_strategy).toBe("sticky");
+    expect(config.account_selection_strategy).toBe("round-robin");
   });
 
   it("enables debug from OPENCODE_ANTHROPIC_DEBUG=1", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "main": "./index.mjs",
   "files": [
     "index.mjs",