opencode-anthropic-fix 0.0.20 → 0.0.22

package/README.md

@@ -46,6 +46,8 @@ The [original plugin](https://github.com/anomalyco/opencode-anthropic-auth) prov
 - **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
 
@@ -279,8 +281,6 @@ Add or remove beta flags that get included in every `anthropic-beta` header. Per
 | `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         |
-| `code-execution-2025-08-25`       | Python sandbox execution by the model             |
-| `files-api-2025-04-14`            | Upload once, reuse file ID across requests        |
 | `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)                  |
@@ -293,6 +293,31 @@ Example workflow:
 /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 files across ALL accounts
+/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.
+
+**Multi-account behavior:** Files on Anthropic are per-account. With multiple accounts:
+
+- `/anthropic files list` (no `--account`) queries **all** enabled accounts, labeling each file with its owner email
+- Use `--account <email|index>` to target a specific account for any action:
+  ```text
+  /anthropic files list --account alice@example.com
+  /anthropic files upload ./data.csv --account 2
+  ```
+- **Auto-pinning:** When you upload or list files, the plugin remembers which account owns each `file_id`. If a subsequent Messages API request references that `file_id`, the plugin automatically routes it to the correct account — even with round-robin or hybrid strategies.
+
 ### OAuth flows from slash command
 
 Login and reauth are two-step flows in slash mode:
@@ -318,11 +343,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                                              |
-| --------------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------- |
-| **`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            |
+| Strategy               | Behavior                                                                                  | Best For                                                                            |
+| ---------------------- | ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| **`sticky`** (default) | Stay on one account until it fails or is rate-limited                                     | Single account, predictable behavior, full feature compatibility                    |
+| **`round-robin`**      | Rotate through accounts on every request                                                  | Spreading load evenly across accounts (see [limitations](#round-robin-limitations)) |
+| **`hybrid`**           | Score-based selection with stickiness bias. Considers health, token budget, and freshness | Multiple accounts with varying rate limits                                          |
 
 ### Change Strategy
 
@@ -337,14 +362,37 @@ export OPENCODE_ANTHROPIC_STRATEGY=hybrid
 # Edit ~/.config/opencode/anthropic-auth.json
 ```
 
+### Round-Robin Limitations
+
+Some Anthropic API features maintain server-side per-account state that breaks when requests alternate between accounts:
+
+| Feature                                                | Impact                                                                                                           | Plugin Mitigation                                                                                        |
+| ------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
+| **Files API** (`files-api-2025-04-14`)                 | `file_id` is per-account; referencing Account A's file from Account B = `file_not_found`                         | **Auto-pinning**: the plugin tracks which account owns each `file_id` and routes the request accordingly |
+| **Prompt Caching** (`prompt-caching-scope-2026-01-05`) | Cache is per-workspace; alternating accounts means zero cache hits, doubling token costs                         | **Auto-skipped** in round-robin: the `prompt-caching-scope` beta is excluded from the header             |
+| **Code Execution** (`code-execution-2025-08-25`)       | Sandbox state is ephemeral per-request; multi-step workflows lose files/state when routed to a different account | **Auto-skipped** in round-robin: the `code-execution` beta is excluded from the header                   |
+| **Message Batches** (`message-batches-2024-09-24`)     | `batch_id` is per-account; polling from wrong account = 404                                                      | No automatic mitigation (not auto-included)                                                              |
+
+**Recommendation for round-robin users:** If you need prompt caching or code execution, pin each OpenCode session to a single account:
+
+```bash
+# Terminal 1 — uses account 1
+OPENCODE_ANTHROPIC_INITIAL_ACCOUNT=1 opencode
+
+# Terminal 2 — uses account 2
+OPENCODE_ANTHROPIC_INITIAL_ACCOUNT=2 opencode
+```
+
+This automatically overrides the strategy to `sticky` for that session, re-enabling all betas. Other sessions are unaffected.
+
 ## Configuration
 
 Configuration is stored at `~/.config/opencode/anthropic-auth.json`. All settings are optional &mdash; defaults work well for most users.
 
 ```jsonc
 {
-  // Account selection strategy: "round-robin" | "sticky" | "hybrid"
-  "account_selection_strategy": "round-robin",
+  // Account selection strategy: "sticky" | "round-robin" | "hybrid"
+  "account_selection_strategy": "sticky",
 
   // Seconds before consecutive failure count resets (60-7200)
   "failure_ttl_seconds": 3600,
@@ -412,16 +460,17 @@ Configuration is stored at `~/.config/opencode/anthropic-auth.json`. All setting
 
 ### Environment Variables
 
-| Variable                                           | Description                                                                                                 |
-| -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
-| `OPENCODE_ANTHROPIC_STRATEGY`                      | Override the account selection strategy at runtime.                                                         |
-| `OPENCODE_ANTHROPIC_DEBUG`                         | Set to `1` to enable debug logging.                                                                         |
-| `OPENCODE_ANTHROPIC_QUIET`                         | Set to `1` to suppress non-error toasts (account status, switching).                                        |
-| `OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE` | Set to `0` to disable Claude signature emulation (legacy mode).                                             |
-| `OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION`     | Set to `0` to skip npm version lookup at startup.                                                           |
-| `OPENCODE_ANTHROPIC_PROMPT_COMPACTION`             | Set to `off` to disable default minimal system prompt compaction.                                           |
-| `OPENCODE_ANTHROPIC_DEBUG_SYSTEM_PROMPT`           | Set to `1` to log the final transformed `system` prompt to stderr (title-generator requests are skipped).   |
-| `OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS`         | Set to `0` to disable context limit overrides for 1M-window models (e.g. when models.dev has been updated). |
+| Variable                                           | Description                                                                                                                                               |
+| -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OPENCODE_ANTHROPIC_STRATEGY`                      | Override the account selection strategy at runtime.                                                                                                       |
+| `OPENCODE_ANTHROPIC_DEBUG`                         | Set to `1` to enable debug logging.                                                                                                                       |
+| `OPENCODE_ANTHROPIC_QUIET`                         | Set to `1` to suppress non-error toasts (account status, switching).                                                                                      |
+| `OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE` | Set to `0` to disable Claude signature emulation (legacy mode).                                                                                           |
+| `OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION`     | Set to `0` to skip npm version lookup at startup.                                                                                                         |
+| `OPENCODE_ANTHROPIC_PROMPT_COMPACTION`             | Set to `off` to disable default minimal system prompt compaction.                                                                                         |
+| `OPENCODE_ANTHROPIC_DEBUG_SYSTEM_PROMPT`           | Set to `1` to log the final transformed `system` prompt to stderr (title-generator requests are skipped).                                                 |
+| `OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS`         | Set to `0` to disable context limit overrides for 1M-window models (e.g. when models.dev has been updated).                                               |
+| `OPENCODE_ANTHROPIC_INITIAL_ACCOUNT`               | Pin this session to a specific account (1-based index or email). Overrides strategy to `sticky`. See [Round-Robin Limitations](#round-robin-limitations). |
 
 ### OAuth-only behavior
 

package/index.mjs

@@ -2,7 +2,7 @@ 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, loadConfigFresh, saveConfig, CLIENT_ID, getConfigDir } from "./lib/config.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",
@@ -660,9 +662,10 @@ function buildSystemPromptBlocks(system, signature, messages) {
  * @param {string} model
  * @param {"anthropic" | "bedrock" | "vertex" | "foundry"} provider
  * @param {string[]} [customBetas]
+ * @param {import('./lib/config.mjs').AccountSelectionStrategy} [strategy]
  * @returns {string}
  */
-function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provider, customBetas) {
+function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provider, customBetas, strategy) {
   const incomingBetasList = incomingBeta
     .split(",")
     .map((b) => b.trim())
@@ -677,11 +680,21 @@ function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provide
 
   const nonInteractive = isNonInteractiveMode();
   const haiku = isHaikuModel(model);
+  const isRoundRobin = strategy === "round-robin";
 
   if (!haiku) {
     betas.push(CLAUDE_CODE_BETA_FLAG);
+    // Code execution sandbox state is per-account; skip in round-robin to avoid
+    // losing sandbox state mid-workflow when requests rotate between accounts.
+    if (!isRoundRobin) {
+      betas.push("code-execution-2025-08-25");
+    }
   }
 
+  // Files API is model-independent; enables /v1/files endpoint and file_id references.
+  // Safe in round-robin because file-ID account pinning routes requests to the correct account.
+  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.
@@ -717,7 +730,9 @@ function buildAnthropicBetaHeader(incomingBeta, signatureEnabled, model, provide
     betas.push("web-search-2025-03-05");
   }
 
-  if (nonInteractive) {
+  // Prompt caching is per-workspace (since Feb 2026); round-robin across accounts
+  // means zero cache hits and doubled token costs. Skip in round-robin.
+  if (nonInteractive && !isRoundRobin) {
     betas.push("prompt-caching-scope-2026-01-05");
   }
 
@@ -858,7 +873,7 @@ async function fetchLatestClaudeCodeVersion(timeoutMs = 1200) {
  * @param {string} accessToken
  * @param {string | undefined} requestBody
  * @param {URL | null} requestUrl
- * @param {{enabled: boolean, claudeCliVersion: string}} signature
+ * @param {{enabled: boolean, claudeCliVersion: string, strategy?: import('./lib/config.mjs').AccountSelectionStrategy}} signature
  * @returns {Headers}
  */
 function buildRequestHeaders(input, requestInit, accessToken, requestBody, requestUrl, signature) {
@@ -892,7 +907,14 @@ 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, signature.customBetas);
+  const mergedBetas = buildAnthropicBetaHeader(
+    incomingBeta,
+    signature.enabled,
+    model,
+    provider,
+    signature.customBetas,
+    signature.strategy,
+  );
 
   const authTokenOverride = process.env.ANTHROPIC_AUTH_TOKEN?.trim();
   const bearerToken = authTokenOverride || accessToken;
@@ -1560,6 +1582,30 @@ function parseCommandArgs(raw) {
   return parts;
 }
 
+/**
+ * Extract all file_id values from a parsed Messages API request body.
+ * Walks messages and system arrays looking for file content blocks.
+ * @param {any} body - Parsed JSON body
+ * @returns {string[]}
+ */
+function extractFileIds(body) {
+  const ids = [];
+  if (!body || typeof body !== "object") return ids;
+  function walk(obj) {
+    if (Array.isArray(obj)) {
+      for (const item of obj) walk(item);
+    } else if (obj && typeof obj === "object") {
+      if (obj.source?.file_id) ids.push(obj.source.file_id);
+      for (const val of Object.values(obj)) {
+        if (val && typeof val === "object") walk(val);
+      }
+    }
+  }
+  walk(body.messages);
+  walk(body.system);
+  return ids;
+}
+
 /**
  * @type {import('@opencode-ai/plugin').Plugin}
  */
@@ -1590,12 +1636,27 @@ export async function AnthropicAuthPlugin({ client }) {
   const IDLE_REFRESH_WINDOW_MS = config.idle_refresh.window_minutes * 60 * 1000;
   const IDLE_REFRESH_MIN_INTERVAL_MS = config.idle_refresh.min_interval_minutes * 60 * 1000;
 
+  /**
+   * Whether OPENCODE_ANTHROPIC_INITIAL_ACCOUNT env var pinned this session to a
+   * specific account. When true, syncActiveIndexFromDisk is skipped and strategy
+   * is forced to sticky.
+   */
+  let initialAccountPinned = false;
+
   /**
    * Pending slash-command OAuth flows keyed by session ID.
    * @type {Map<string, { mode: "login" | "reauth", verifier: string, targetIndex?: number, createdAt: number }>}
    */
   const pendingSlashOAuth = new Map();
 
+  /**
+   * In-memory mapping of file_id → account index for file-ID account pinning.
+   * Populated by /anthropic files commands, consumed by the fetch interceptor
+   * to route Messages API requests referencing file_ids to the correct account.
+   * @type {Map<string, number>}
+   */
+  const fileAccountMap = new Map();
+
   /**
    * Send an informational message into the current session.
    * @param {string} sessionID
@@ -1972,26 +2033,28 @@ export async function AnthropicAuthPlugin({ client }) {
 
       if (!action || action === "list") {
         const fresh = loadConfigFresh();
+        const strategy = fresh.account_selection_strategy || config.account_selection_strategy;
         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",
+          "  fine-grained-tool-streaming-2025-05-14,",
+          `  code-execution-2025-08-25 (non-Haiku${strategy === "round-robin" ? ", skipped in round-robin" : ""}),`,
+          "  files-api-2025-04-14,",
+          `  prompt-caching-scope-2026-01-05 (non-interactive${strategy === "round-robin" ? ", skipped in round-robin" : ""})`,
           "",
+          `Strategy: ${strategy}${initialAccountPinned ? " (pinned via OPENCODE_ANTHROPIC_INITIAL_ACCOUNT)" : ""}`,
           `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 code-execution-2025-08-25",
           "  /anthropic betas add compact-2026-01-12",
           "  /anthropic betas add mcp-servers-2025-12-04",
-          "  /anthropic betas add files-api-2025-04-14",
           "",
           "Remove: /anthropic betas remove <beta>",
         ];
@@ -2039,6 +2102,359 @@ export async function AnthropicAuthPlugin({ client }) {
       return;
     }
 
+    // /anthropic files [list|upload|get|delete|download] — Files API management
+    // Supports --account <email|index> to target a specific account.
+    // Without --account, list aggregates from ALL accounts; other actions use the current account.
+    if (primary === "files") {
+      // Parse --account flag from args
+      let targetAccountId = null;
+      const filteredArgs = [];
+      for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--account" && i + 1 < args.length) {
+          targetAccountId = args[i + 1];
+          i++;
+        } else {
+          filteredArgs.push(args[i]);
+        }
+      }
+      const action = (filteredArgs[1] || "").toLowerCase();
+
+      if (!accountManager || accountManager.getAccountCount() === 0) {
+        await sendCommandMessage(
+          input.sessionID,
+          "▣ Anthropic Files (error)\n\nNo accounts configured. Use /anthropic login first.",
+        );
+        return;
+      }
+
+      /**
+       * Resolve a single account by email or 1-based index.
+       * If identifier is null, falls back to the current account.
+       * @param {string | null} identifier
+       * @returns {{ account: import('./lib/accounts.mjs').ManagedAccount, label: string } | null}
+       */
+      function resolveTargetAccount(identifier) {
+        const accounts = accountManager.getEnabledAccounts();
+        if (identifier) {
+          // Try by email
+          const byEmail = accounts.find((a) => a.email === identifier);
+          if (byEmail) return { account: byEmail, label: byEmail.email || `Account ${byEmail.index + 1}` };
+          // Try by 1-based index
+          const idx = parseInt(identifier, 10);
+          if (!isNaN(idx) && idx >= 1) {
+            const byIdx = accounts.find((a) => a.index === idx - 1);
+            if (byIdx) return { account: byIdx, label: byIdx.email || `Account ${byIdx.index + 1}` };
+          }
+          return null;
+        }
+        // Default to current
+        const current = accountManager.getCurrentAccount();
+        if (!current) return null;
+        return { account: current, label: current.email || `Account ${current.index + 1}` };
+      }
+
+      /**
+       * Get authenticated headers for a specific account, refreshing token if needed.
+       * @param {import('./lib/accounts.mjs').ManagedAccount} acct
+       */
+      async function getFilesAuth(acct) {
+        let tok = acct.access;
+        if (!tok || !acct.expires || acct.expires < Date.now()) {
+          tok = await refreshAccountTokenSingleFlight(acct);
+        }
+        return {
+          authorization: `Bearer ${tok}`,
+          "anthropic-beta": "files-api-2025-04-14",
+        };
+      }
+
+      const apiBase = "https://api.anthropic.com";
+
+      try {
+        // /anthropic files list — list uploaded files
+        if (!action || action === "list") {
+          if (targetAccountId) {
+            // List for a specific account
+            const resolved = resolveTargetAccount(targetAccountId);
+            if (!resolved) {
+              await sendCommandMessage(
+                input.sessionID,
+                `▣ Anthropic Files (error)\n\nAccount not found: ${targetAccountId}`,
+              );
+              return;
+            }
+            const { account, label } = resolved;
+            const headers = await getFilesAuth(account);
+            const res = await fetch(`${apiBase}/v1/files`, { headers });
+            if (!res.ok) {
+              const errBody = await res.text();
+              await sendCommandMessage(
+                input.sessionID,
+                `▣ Anthropic Files (error) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+              );
+              return;
+            }
+            const data = await res.json();
+            const files = data.data || [];
+            for (const f of files) fileAccountMap.set(f.id, account.index);
+            if (files.length === 0) {
+              await sendCommandMessage(input.sessionID, `▣ Anthropic Files [${label}]\n\nNo files uploaded.`);
+              return;
+            }
+            const lines = [`▣ Anthropic Files [${label}]`, "", `${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;
+          }
+
+          // List files from ALL enabled accounts
+          const accounts = accountManager.getEnabledAccounts();
+          const allLines = ["▣ Anthropic Files (all accounts)", ""];
+          let totalFiles = 0;
+          for (const acct of accounts) {
+            const label = acct.email || `Account ${acct.index + 1}`;
+            try {
+              const headers = await getFilesAuth(acct);
+              const res = await fetch(`${apiBase}/v1/files`, { headers });
+              if (!res.ok) {
+                allLines.push(`[${label}] Error: HTTP ${res.status}`);
+                allLines.push("");
+                continue;
+              }
+              const data = await res.json();
+              const files = data.data || [];
+              for (const f of files) fileAccountMap.set(f.id, acct.index);
+              totalFiles += files.length;
+              if (files.length === 0) {
+                allLines.push(`[${label}] No files`);
+              } else {
+                allLines.push(`[${label}] ${files.length} file(s):`);
+                for (const f of files) {
+                  const sizeKB = (f.size / 1024).toFixed(1);
+                  allLines.push(`  ${f.id}  ${f.filename}  (${sizeKB} KB, ${f.purpose})`);
+                }
+              }
+              allLines.push("");
+            } catch (err) {
+              allLines.push(`[${label}] Error: ${err.message}`);
+              allLines.push("");
+            }
+          }
+          if (totalFiles === 0 && accounts.length > 0) {
+            allLines.push(`Total: No files across ${accounts.length} account(s).`);
+          } else {
+            allLines.push(`Total: ${totalFiles} file(s) across ${accounts.length} account(s).`);
+          }
+          if (accounts.length > 1) {
+            allLines.push("", "Tip: Use --account <email> to target a specific account.");
+          }
+          await sendCommandMessage(input.sessionID, allLines.join("\n"));
+          return;
+        }
+
+        // For all non-list actions, resolve to a single account
+        const resolved = resolveTargetAccount(targetAccountId);
+        if (!resolved) {
+          const errMsg = targetAccountId ? `Account not found: ${targetAccountId}` : "No accounts available.";
+          await sendCommandMessage(input.sessionID, `▣ Anthropic Files (error)\n\n${errMsg}`);
+          return;
+        }
+        const { account, label } = resolved;
+        const authHeaders = await getFilesAuth(account);
+
+        // /anthropic files upload <path> — upload a file
+        if (action === "upload") {
+          const filePath = filteredArgs.slice(2).join(" ").trim();
+          if (!filePath) {
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files upload <path> [--account <email>]",
+            );
+            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: authHeaders.authorization,
+              "anthropic-beta": "files-api-2025-04-14",
+            },
+            body: form,
+          });
+          if (!res.ok) {
+            const errBody = await res.text();
+            await sendCommandMessage(
+              input.sessionID,
+              `▣ Anthropic Files (error) [${label}]\n\nUpload failed (HTTP ${res.status}): ${errBody}`,
+            );
+            return;
+          }
+          const file = await res.json();
+          const sizeKB = ((file.size || 0) / 1024).toFixed(1);
+          // Cache file_id → account mapping for auto-pinning
+          fileAccountMap.set(file.id, account.index);
+          await sendCommandMessage(
+            input.sessionID,
+            `▣ Anthropic Files [${label}]\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 = filteredArgs[2]?.trim();
+          if (!fileId) {
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files get <file_id> [--account <email>]",
+            );
+            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) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+            );
+            return;
+          }
+          const file = await res.json();
+          fileAccountMap.set(file.id, account.index);
+          const lines = [
+            `▣ Anthropic Files [${label}]`,
+            "",
+            `  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 = filteredArgs[2]?.trim();
+          if (!fileId) {
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files delete <file_id> [--account <email>]",
+            );
+            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) [${label}]\n\nHTTP ${res.status}: ${errBody}`,
+            );
+            return;
+          }
+          fileAccountMap.delete(fileId);
+          await sendCommandMessage(input.sessionID, `▣ Anthropic Files [${label}]\n\nDeleted: ${fileId}`);
+          return;
+        }
+
+        // /anthropic files download <file_id> [output_path] — download file content
+        if (action === "download" || action === "dl") {
+          const fileId = filteredArgs[2]?.trim();
+          if (!fileId) {
+            await sendCommandMessage(
+              input.sessionID,
+              "▣ Anthropic Files\n\nUsage: /anthropic files download <file_id> [output_path] [--account <email>]",
+            );
+            return;
+          }
+          const outputPath = filteredArgs.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) [${label}]\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) [${label}]\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 [${label}]\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> [--account <email|index>]",
+          "",
+          "Actions:",
+          "  list                          List uploaded files (all accounts if no --account)",
+          "  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",
+          "",
+          "Options:",
+          "  --account <email|index>       Target a specific account (1-based index)",
+          "",
+          "Supported formats: PDF, DOCX, TXT, CSV, Excel, Markdown, images",
+          "Files can be referenced by file_id in Messages API requests.",
+          "",
+          "When using round-robin, file_ids are automatically pinned to the",
+          "account that owns them for 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(
@@ -2356,6 +2772,39 @@ export async function AnthropicAuthPlugin({ client }) {
             await accountManager.saveToDisk();
           }
 
+          // OPENCODE_ANTHROPIC_INITIAL_ACCOUNT: pin this session to a specific account.
+          // Accepts 1-based index or email. Overrides strategy to sticky and disables
+          // syncActiveIndexFromDisk so other sessions can't override this one.
+          // Use case: terminal 1 with INITIAL_ACCOUNT=1, terminal 2 with =2.
+          const initialAccountEnv = process.env.OPENCODE_ANTHROPIC_INITIAL_ACCOUNT?.trim();
+          if (initialAccountEnv && accountManager.getAccountCount() > 1) {
+            const accounts = accountManager.getEnabledAccounts();
+            let target = null;
+
+            // Try as 1-based index
+            const asIndex = parseInt(initialAccountEnv, 10);
+            if (!isNaN(asIndex) && asIndex >= 1 && asIndex <= accounts.length) {
+              target = accounts[asIndex - 1];
+            }
+
+            // Try as email
+            if (!target) {
+              target = accounts.find((a) => a.email && a.email.toLowerCase() === initialAccountEnv.toLowerCase());
+            }
+
+            if (target && accountManager.forceCurrentIndex(target.index)) {
+              config.account_selection_strategy = "sticky";
+              initialAccountPinned = true;
+              debugLog("OPENCODE_ANTHROPIC_INITIAL_ACCOUNT: pinned to account", {
+                index: target.index + 1,
+                email: target.email,
+                strategy: "sticky (overridden)",
+              });
+            } else {
+              debugLog("OPENCODE_ANTHROPIC_INITIAL_ACCOUNT: could not resolve account", initialAccountEnv);
+            }
+          }
+
           return {
             apiKey: "",
             /**
@@ -2384,7 +2833,9 @@ export async function AnthropicAuthPlugin({ client }) {
               const transientRefreshSkips = new Set();
 
               // Sync with CLI changes at request start.
-              if (accountManager) {
+              // Skip when OPENCODE_ANTHROPIC_INITIAL_ACCOUNT pinned this session —
+              // other sessions' CLI changes must not override the pinned account.
+              if (accountManager && !initialAccountPinned) {
                 await accountManager.syncActiveIndexFromDisk();
               }
 
@@ -2392,9 +2843,42 @@ export async function AnthropicAuthPlugin({ client }) {
               // switch to the next account. If it's service-wide, return immediately.
               const maxAttempts = accountManager.getTotalAccountCount();
 
+              // File-ID account pinning: if the request body references file_ids
+              // that we've mapped to a specific account (via /anthropic files),
+              // pin the first attempt to that account so files are accessible.
+              // Without this, round-robin could route to an account that doesn't
+              // have the referenced files, causing file_not_found errors.
+              let pinnedAccount = null;
+              if (typeof requestInit.body === "string" && fileAccountMap.size > 0) {
+                try {
+                  const bodyObj = JSON.parse(requestInit.body);
+                  const fileIds = extractFileIds(bodyObj);
+                  for (const fid of fileIds) {
+                    const pinnedIndex = fileAccountMap.get(fid);
+                    if (pinnedIndex !== undefined) {
+                      const candidates = accountManager.getEnabledAccounts();
+                      pinnedAccount = candidates.find((a) => a.index === pinnedIndex) ?? null;
+                      if (pinnedAccount) {
+                        debugLog("file-id pinning: routing to account", {
+                          fileId: fid,
+                          accountIndex: pinnedIndex,
+                          email: pinnedAccount.email,
+                        });
+                        break;
+                      }
+                    }
+                  }
+                } catch {
+                  // Non-JSON body or parse error — skip pinning
+                }
+              }
+
               for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                // Select account
-                const account = accountManager.getCurrentAccount(transientRefreshSkips);
+                // Select account — use pinned account on first attempt if available
+                const account =
+                  attempt === 0 && pinnedAccount && !transientRefreshSkips.has(pinnedAccount.index)
+                    ? pinnedAccount
+                    : accountManager.getCurrentAccount(transientRefreshSkips);
 
                 // Toast account usage on first use and whenever the account changes
                 if (showUsageToast && account && accountManager) {
@@ -2528,6 +3012,7 @@ export async function AnthropicAuthPlugin({ client }) {
                   enabled: signatureEmulationEnabled,
                   claudeCliVersion,
                   customBetas: config.custom_betas,
+                  strategy: config.account_selection_strategy,
                 });
                 // Execute the request
                 let response;

package/lib/accounts.mjs

@@ -193,6 +193,20 @@ export class AccountManager {
     return this.#currentIndex;
   }
 
+  /**
+   * Force the active account to a specific index.
+   * Used by OPENCODE_ANTHROPIC_INITIAL_ACCOUNT to pin a session to one account.
+   * @param {number} index
+   * @returns {boolean} Whether the index was valid and set
+   */
+  forceCurrentIndex(index) {
+    const account = this.#accounts[index];
+    if (!account || !account.enabled) return false;
+    this.#currentIndex = index;
+    this.#cursor = index;
+    return true;
+  }
+
   /**
    * Get enabled account references for internal plugin operations.
    * Returned objects are mutable managed accounts.

package/lib/config.mjs

@@ -61,7 +61,7 @@ import { homedir } from "node:os";
 
 /** @type {AnthropicAuthConfig} */
 export const DEFAULT_CONFIG = {
-  account_selection_strategy: "round-robin",
+  account_selection_strategy: "sticky",
   failure_ttl_seconds: 3600,
   debug: false,
   signature_emulation: {

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("round-robin");
+    expect(DEFAULT_CONFIG.account_selection_strategy).toBe("sticky");
   });
 
   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("round-robin");
+    expect(config.account_selection_strategy).toBe("sticky");
   });
 
   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("round-robin");
+    expect(config.account_selection_strategy).toBe("sticky");
   });
 
   it("enables debug from OPENCODE_ANTHROPIC_DEBUG=1", () => {

package/package.json

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