opencode-anthropic-fix 0.0.31 → 0.0.33

package/index.mjs

@@ -590,6 +590,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
         `fast-mode: ${fresh.fast_mode ? "on" : "off"}`,
         `telemetry-emulation: ${fresh.telemetry?.emulate_minimal ? "on (silent observer)" : "off"}`,
         `usage-toast: ${fresh.usage_toast ? "on" : "off"}`,
+        `adaptive-context: ${fresh.adaptive_context?.enabled ? `on (↑${Math.round((fresh.adaptive_context.escalation_threshold || 150000) / 1000)}K ↓${Math.round((fresh.adaptive_context.deescalation_threshold || 100000) / 1000)}K)${adaptiveContextState.active ? " [ACTIVE]" : ""}` : "off"}`,
       ];
       await sendCommandMessage(input.sessionID, lines.join("\n"));
       return;
@@ -818,6 +819,23 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
           saveConfig({ usage_toast: enabled });
           config.usage_toast = enabled;
         },
+        "adaptive-context": () => {
+          const enabled = value === "on" || value === "true" || value === "1";
+          saveConfig({ adaptive_context: { ...config.adaptive_context, enabled } });
+          if (!config.adaptive_context)
+            config.adaptive_context = {
+              enabled: false,
+              escalation_threshold: 150_000,
+              deescalation_threshold: 100_000,
+            };
+          config.adaptive_context.enabled = enabled;
+          // Reset state when toggled off
+          if (!enabled) {
+            adaptiveContextState.active = false;
+            adaptiveContextState.escalatedByError = false;
+            adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
+          }
+        },
       };
 
       if (!key || !setters[key]) {
@@ -1808,6 +1826,8 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
               let serviceWideRetryCount = 0; // Track 529/503 retries (max 2 per RE doc §5.5)
               let shouldRetryCount = 0; // Track x-should-retry forced retries (cap at 3)
               let consecutive529Count = 0;
+              let _adaptiveDecisionMade = false; // Ensure adaptive context decision is made only once per logical request
+              let _adaptiveOverrideForRequest; // Cached adaptive override for all retry attempts
               for (let attempt = 0; attempt < maxAttempts; attempt++) {
                 // Select account — use pinned account on first attempt if available
                 const account =
@@ -1956,6 +1976,36 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                   requestInit.body,
                 );
                 const _reqProvider = detectProvider(requestUrl);
+
+                // --- Adaptive 1M context decision (once per logical request, not per retry) ---
+                if (!_adaptiveDecisionMade) {
+                  _adaptiveDecisionMade = true;
+                  const _prevAdaptiveState = adaptiveContextState.active;
+                  const _use1MContext = resolveAdaptiveContext(
+                    requestInit.body,
+                    _reqModel,
+                    config.adaptive_context || {
+                      enabled: true,
+                      escalation_threshold: 150_000,
+                      deescalation_threshold: 100_000,
+                    },
+                  );
+                  // Emit visual cue on state transitions (only when adaptive mode is on)
+                  if (config.adaptive_context?.enabled && _prevAdaptiveState !== adaptiveContextState.active) {
+                    const label = adaptiveContextState.active ? "1M context ON" : "1M context OFF";
+                    const variant = adaptiveContextState.active ? "info" : "success";
+                    const est = estimatePromptTokens(requestInit.body);
+                    toast(`⬡ ${label} (est. ${Math.round(est / 1000)}K tokens)`, variant, {
+                      debounceKey: "adaptive-ctx",
+                    }).catch(() => {});
+                  }
+                  _adaptiveOverrideForRequest = config.adaptive_context?.enabled
+                    ? { use1MContext: _use1MContext }
+                    : undefined;
+                }
+
+                const _adaptiveOverride = _adaptiveOverrideForRequest;
+
                 const computedBetaHeader = buildAnthropicBetaHeader(
                   "",
                   getSignatureEmulationEnabled(),
@@ -1965,6 +2015,7 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                   getEffectiveStrategy(),
                   requestUrl?.pathname,
                   _reqHasFileRefs,
+                  _adaptiveOverride,
                 );
 
                 let body = transformRequestBody(
@@ -1988,12 +2039,20 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                 logTransformedSystemPrompt(body);
 
                 // Build headers with the selected account's token
-                const requestHeaders = buildRequestHeaders(input, requestInit, accessToken, body, requestUrl, {
-                  enabled: getSignatureEmulationEnabled(),
-                  claudeCliVersion,
-                  customBetas: config.custom_betas,
-                  strategy: getEffectiveStrategy(),
-                });
+                const requestHeaders = buildRequestHeaders(
+                  input,
+                  requestInit,
+                  accessToken,
+                  body,
+                  requestUrl,
+                  {
+                    enabled: getSignatureEmulationEnabled(),
+                    claudeCliVersion,
+                    customBetas: config.custom_betas,
+                    strategy: getEffectiveStrategy(),
+                  },
+                  _adaptiveOverride,
+                );
                 // Execute the request
                 let response;
                 try {
@@ -2144,29 +2203,45 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
                     !requestInit._reactiveCompactAttempted
                   ) {
                     debugLog("prompt too long — attempting reactive message trimming");
+                    // Auto-escalate adaptive context on prompt_too_long so the retry
+                    // includes the 1M beta header (if model supports it).
+                    if (config.adaptive_context?.enabled) {
+                      forceEscalateAdaptiveContext();
+                      toast("⬡ 1M context force-activated (prompt too long)", "warning", {
+                        debounceKey: "adaptive-ctx",
+                      }).catch(() => {});
+                    }
                     try {
                       const parsedBody = JSON.parse(body);
                       if (Array.isArray(parsedBody.messages) && parsedBody.messages.length > 4) {
-                        // Keep first 2 messages (initial context) and last N messages (recent work).
+                        // Keep first 2 messages (initial context) and last 2 messages (recent work).
                         // Ensure the trimmed array never ends with an assistant message (prefill),
                         // which would cause "does not support assistant message prefill" errors.
-                        let tailCount = 2;
                         const msgs = parsedBody.messages;
-                        // Expand tail if it would end with an assistant message
-                        while (
-                          tailCount < msgs.length - 2 &&
-                          msgs[msgs.length - tailCount]?.role !== "user" &&
-                          msgs.length - tailCount > 0
-                        ) {
-                          tailCount++;
-                        }
-                        const tail = msgs.slice(-tailCount);
-                        // If tail still starts/ends badly, force a user wrapper
+                        const tail = msgs.slice(-2);
+                        // If tail ends with assistant, append a user message to fix the prefill issue.
+                        // Check if the assistant's last content block is tool_use — if so, synthesize
+                        // a tool_result instead of bare "Continue." to respect the tool protocol.
                         if (tail.length > 0 && tail[tail.length - 1]?.role === "assistant") {
-                          tail.push({
-                            role: "user",
-                            content: [{ type: "text", text: "Continue." }],
-                          });
+                          const lastAssistant = tail[tail.length - 1];
+                          const lastContent = Array.isArray(lastAssistant.content) ? lastAssistant.content : [];
+                          const toolUseBlocks = lastContent.filter((b) => b.type === "tool_use");
+                          if (toolUseBlocks.length > 0) {
+                            // Synthesize tool_result for each pending tool_use
+                            tail.push({
+                              role: "user",
+                              content: toolUseBlocks.map((tu) => ({
+                                type: "tool_result",
+                                tool_use_id: tu.id,
+                                content: "[Context trimmed — previous result unavailable]",
+                              })),
+                            });
+                          } else {
+                            tail.push({
+                              role: "user",
+                              content: [{ type: "text", text: "Continue." }],
+                            });
+                          }
                         }
                         const trimmed = [
                           ...msgs.slice(0, 2),
@@ -2575,6 +2650,12 @@ export async function AnthropicAuthPlugin({ client, project, directory, worktree
       ],
     },
     "experimental.session.compacting": async (input, output) => {
+      // Reset adaptive context state on session compaction (new conversation boundary).
+      // This prevents sticky escalation from leaking across conversations.
+      adaptiveContextState.active = false;
+      adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
+      adaptiveContextState.escalatedByError = false;
+
       // Inject Anthropic-specific context into compaction
       if (!accountManager) return;
       const account = accountManager.getCurrentAccount();
@@ -2618,6 +2699,161 @@ const sessionMetrics = {
   lastQuota: { tokens: 0, requests: 0, inputTokens: 0, updatedAt: 0 },
 };
 
+// ---------------------------------------------------------------------------
+// Adaptive 1M context state
+// ---------------------------------------------------------------------------
+
+/**
+ * Tracks whether the 1M context beta is currently active for adaptive mode.
+ * When adaptive_context.enabled is true, the context-1m-2025-08-07 beta is
+ * toggled per-request based on estimated prompt size.
+ *
+ * @type {{ active: boolean, lastTransitionTurn: number, escalatedByError: boolean }}
+ */
+const adaptiveContextState = {
+  /** Whether 1M context beta is currently being sent. */
+  active: false,
+  /** Turn number of the last transition (to avoid flapping). */
+  lastTransitionTurn: 0,
+  /** Set when escalation was triggered by a prompt_too_long error. */
+  escalatedByError: false,
+};
+
+/**
+ * Estimate prompt token count from the raw request body string.
+ * Uses a 4-character-per-token heuristic (conservative for English + code).
+ * @param {string} bodyString - JSON string of the request body
+ * @returns {number} Estimated token count
+ */
+function estimatePromptTokens(bodyString) {
+  if (!bodyString || typeof bodyString !== "string") return 0;
+  try {
+    const parsed = JSON.parse(bodyString);
+    let charCount = 0;
+
+    // Count system prompt text
+    if (Array.isArray(parsed.system)) {
+      for (const block of parsed.system) {
+        if (block.type === "text" && typeof block.text === "string") {
+          charCount += block.text.length;
+        }
+      }
+    } else if (typeof parsed.system === "string") {
+      charCount += parsed.system.length;
+    }
+
+    // Count messages content (text blocks, tool results) — skip tool definitions
+    if (Array.isArray(parsed.messages)) {
+      for (const msg of parsed.messages) {
+        if (typeof msg.content === "string") {
+          charCount += msg.content.length;
+        } else if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text" && typeof block.text === "string") {
+              charCount += block.text.length;
+            } else if (block.type === "tool_result" && typeof block.content === "string") {
+              charCount += block.content.length;
+            } else if (block.type === "tool_use") {
+              // Count serialized input as tokens
+              charCount += JSON.stringify(block.input || {}).length;
+            } else if (block.type === "image" || block.type === "image_url") {
+              // Images: ~2000 tokens per image (Anthropic tile-based counting)
+              charCount += 8000; // 2000 tokens * 4 chars/token
+            }
+          }
+        }
+      }
+    }
+
+    // 4 chars/token heuristic for text content (reasonable for English + code + JSON)
+    return Math.ceil(charCount / 4);
+  } catch {
+    // Fallback: raw body length / 4 if JSON parsing fails
+    return Math.ceil(bodyString.length / 4);
+  }
+}
+
+/**
+ * Decide whether to include the context-1m beta for this request.
+ * Returns true if 1M context should be activated.
+ *
+ * Decision logic:
+ *   - If adaptive_context is disabled, defer to hasOneMillionContext(model) as before.
+ *   - If model does not support 1M context, always false.
+ *   - Escalate when estimated prompt tokens exceed escalation_threshold.
+ *   - De-escalate when estimated prompt tokens drop below deescalation_threshold.
+ *   - Never de-escalate if escalation was triggered by a prompt_too_long error
+ *     (sticky until session compacts or drops far below threshold).
+ *   - Hysteresis: require at least 2 turns between transitions to avoid flapping.
+ *
+ * @param {string} bodyString - JSON request body
+ * @param {string} model - Model ID
+ * @param {import('./lib/config.mjs').AdaptiveContextConfig} adaptiveConfig
+ * @returns {boolean}
+ */
+function resolveAdaptiveContext(bodyString, model, adaptiveConfig) {
+  // Non-adaptive: use static check
+  if (!adaptiveConfig.enabled) {
+    return hasOneMillionContext(model);
+  }
+
+  // If experimental betas are disabled, context-1m will be stripped anyway — skip adaptive logic
+  if (isTruthyEnv(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS)) {
+    return false;
+  }
+
+  // Model must be eligible for 1M context at all
+  if (!hasOneMillionContext(model)) {
+    return false;
+  }
+
+  const estimatedTokens = estimatePromptTokens(bodyString);
+  const turnsSinceTransition = sessionMetrics.turns - adaptiveContextState.lastTransitionTurn;
+
+  if (adaptiveContextState.active) {
+    // Currently active — consider de-escalation
+    // Don't de-escalate if error-escalated (sticky)
+    if (adaptiveContextState.escalatedByError) {
+      return true;
+    }
+    // Hysteresis: require at least 2 turns before considering de-escalation
+    if (turnsSinceTransition < 2) {
+      return true;
+    }
+    if (estimatedTokens < adaptiveConfig.deescalation_threshold) {
+      // De-escalate
+      adaptiveContextState.active = false;
+      adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
+      return false;
+    }
+    return true;
+  } else {
+    // Currently inactive — consider escalation
+    // Symmetric hysteresis: require at least 2 turns before re-escalation too
+    if (turnsSinceTransition < 2 && adaptiveContextState.lastTransitionTurn > 0) {
+      return false;
+    }
+    if (estimatedTokens > adaptiveConfig.escalation_threshold) {
+      // Escalate
+      adaptiveContextState.active = true;
+      adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
+      return true;
+    }
+    return false;
+  }
+}
+
+/**
+ * Force-escalate adaptive context (e.g. after prompt_too_long error).
+ */
+function forceEscalateAdaptiveContext() {
+  if (!adaptiveContextState.active) {
+    adaptiveContextState.active = true;
+    adaptiveContextState.lastTransitionTurn = sessionMetrics.turns;
+  }
+  adaptiveContextState.escalatedByError = true;
+}
+
 const MODEL_PRICING = {
   "claude-opus-4-6": { input: 15.0, output: 75.0, cacheRead: 1.5, cacheWrite: 18.75 },
   "claude-sonnet-4-6": { input: 3.0, output: 15.0, cacheRead: 0.3, cacheWrite: 3.75 },
@@ -3644,6 +3880,7 @@ function buildSystemPromptBlocks(system, signature) {
  * @param {import('./lib/config.mjs').AccountSelectionStrategy} [strategy]
  * @param {string} [requestPath]
  * @param {boolean} [hasFileReferences]
+ * @param {{ use1MContext?: boolean }} [adaptiveOverride] - When set, overrides the static hasOneMillionContext() check.
  * @returns {string}
  */
 function buildAnthropicBetaHeader(
@@ -3655,6 +3892,7 @@ function buildAnthropicBetaHeader(
   strategy,
   requestPath,
   hasFileReferences,
+  adaptiveOverride,
 ) {
   const incomingBetasList = incomingBeta
     .split(",")
@@ -3696,9 +3934,15 @@ function buildAnthropicBetaHeader(
     betas.push("interleaved-thinking-2025-05-14");
   }
 
-  // Context 1M — always-on for eligible models (Claude Code includes this for OAuth too)
-  if (hasOneMillionContext(model)) {
-    betas.push("context-1m-2025-08-07");
+  // Context 1M — when adaptive override is provided, use it; otherwise fall back to static check.
+  {
+    const use1M =
+      adaptiveOverride && typeof adaptiveOverride.use1MContext === "boolean"
+        ? adaptiveOverride.use1MContext
+        : hasOneMillionContext(model);
+    if (use1M) {
+      betas.push("context-1m-2025-08-07");
+    }
   }
 
   // Prompt caching scope — always-on EXCEPT in round-robin (per-workspace state conflicts)
@@ -3887,7 +4131,7 @@ async function fetchLatestClaudeCodeVersion(timeoutMs = 1200) {
  * @param {{enabled: boolean, claudeCliVersion: string, strategy?: import('./lib/config.mjs').AccountSelectionStrategy, customBetas?: string[]}} signature
  * @returns {Headers}
  */
-function buildRequestHeaders(input, requestInit, accessToken, requestBody, requestUrl, signature) {
+function buildRequestHeaders(input, requestInit, accessToken, requestBody, requestUrl, signature, adaptiveOverride) {
   const requestHeaders = new Headers();
   if (input instanceof Request) {
     input.headers.forEach((value, key) => {
@@ -3927,6 +4171,7 @@ function buildRequestHeaders(input, requestInit, accessToken, requestBody, reque
     signature.strategy,
     requestUrl?.pathname,
     hasFileReferences,
+    adaptiveOverride,
   );
 
   const authTokenOverride = process.env.ANTHROPIC_AUTH_TOKEN?.trim();
@@ -4119,10 +4364,26 @@ function transformRequestBody(body, signature, runtime, betaHeader) {
     if (Array.isArray(parsed.messages) && parsed.messages.length > 0) {
       const lastMsg = parsed.messages[parsed.messages.length - 1];
       if (lastMsg && lastMsg.role === "assistant") {
-        parsed.messages.push({
-          role: "user",
-          content: [{ type: "text", text: "Continue." }],
-        });
+        // Check if the assistant message contains tool_use blocks — if so,
+        // synthesize tool_result responses instead of bare "Continue." to
+        // respect the Anthropic tool protocol.
+        const lastContent = Array.isArray(lastMsg.content) ? lastMsg.content : [];
+        const toolUseBlocks = lastContent.filter((b) => b.type === "tool_use");
+        if (toolUseBlocks.length > 0) {
+          parsed.messages.push({
+            role: "user",
+            content: toolUseBlocks.map((tu) => ({
+              type: "tool_result",
+              tool_use_id: tu.id,
+              content: "[Result unavailable — conversation was restructured]",
+            })),
+          });
+        } else {
+          parsed.messages.push({
+            role: "user",
+            content: [{ type: "text", text: "Continue." }],
+          });
+        }
       }
     }
 
@@ -4577,9 +4838,12 @@ async function refreshAccountToken(account, client, source = "foreground", { onT
     const { readCCCredentials } = await import("./lib/cc-credentials.mjs");
     const ccCreds = readCCCredentials();
     const match = ccCreds.find((c) => c.refreshToken === account.refreshToken);
-    if (match && match.expiresAt > Date.now()) {
+    // Accept CC credential if:
+    //   - expiresAt is in the future (normal case), OR
+    //   - expiresAt is 0/missing (CC didn't provide expiry — trust the token, let API 401 if stale)
+    if (match && (match.expiresAt === 0 || match.expiresAt > Date.now())) {
       account.access = match.accessToken;
-      account.expires = match.expiresAt;
+      account.expires = match.expiresAt || Date.now() + 3600_000; // default 1h if unknown
       markTokenStateUpdated(account);
       if (onTokensUpdated) {
         try {

package/lib/accounts.mjs

@@ -807,6 +807,7 @@ export class AccountManager {
           lastFailureTime: acc.lastFailureTime,
           lastSwitchReason: acc.lastSwitchReason || existing?.lastSwitchReason || "initial",
           stats: acc.stats ?? existing?.stats ?? createDefaultStats(),
+          source: acc.source || existing?.source || "oauth",
         };
       });
 

package/lib/cc-credentials.mjs

@@ -16,7 +16,7 @@
  * @module cc-credentials
  */
 
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
@@ -77,7 +77,7 @@ function listKeychainServices() {
  */
 function readKeychainService(service) {
   try {
-    const raw = execSync(`security find-generic-password -s "${service}" -w`, {
+    const raw = execFileSync("security", ["find-generic-password", "-s", service, "-w"], {
       timeout: 5_000,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],

package/lib/cc-credentials.test.mjs

@@ -12,6 +12,7 @@ import {
 
 vi.mock("node:child_process", () => ({
   execSync: vi.fn(),
+  execFileSync: vi.fn(),
 }));
 
 vi.mock("node:fs", () => ({
@@ -23,7 +24,7 @@ vi.mock("node:os", () => ({
   homedir: vi.fn(() => "/home/testuser"),
 }));
 
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import { readFileSync, existsSync } from "node:fs";
 import { homedir } from "node:os";
 
@@ -149,10 +150,14 @@ describe("readCCCredentialsFromKeychain", () => {
   it("reads single keychain service on macOS", () => {
     Object.defineProperty(process, "platform", { value: "darwin" });
 
+    // dump-keychain uses execSync, find-generic-password uses execFileSync
     execSync.mockImplementation((cmd) => {
       if (cmd === "security dump-keychain") return KEYCHAIN_DUMP_SINGLE;
-      if (cmd.includes("find-generic-password")) return JSON.stringify(VALID_CRED);
-      throw new Error("unexpected cmd");
+      throw new Error("unexpected execSync cmd");
+    });
+    execFileSync.mockImplementation((_bin, args) => {
+      if (args && args.includes("find-generic-password")) return JSON.stringify(VALID_CRED);
+      throw new Error("unexpected execFileSync cmd");
     });
 
     const result = readCCCredentialsFromKeychain();
@@ -168,12 +173,15 @@ describe("readCCCredentialsFromKeychain", () => {
     let callIdx = 0;
     execSync.mockImplementation((cmd) => {
       if (cmd === "security dump-keychain") return KEYCHAIN_DUMP_MULTI;
-      if (cmd.includes("find-generic-password")) {
+      throw new Error("unexpected execSync cmd");
+    });
+    execFileSync.mockImplementation((_bin, args) => {
+      if (args && args.includes("find-generic-password")) {
         callIdx++;
         const cred = callIdx === 1 ? VALID_CRED : VALID_CRED_2;
         return JSON.stringify(cred);
       }
-      throw new Error("unexpected cmd");
+      throw new Error("unexpected execFileSync cmd");
     });
 
     const result = readCCCredentialsFromKeychain();
@@ -197,13 +205,13 @@ describe("readCCCredentialsFromKeychain", () => {
 
     execSync.mockImplementation((cmd) => {
       if (cmd === "security dump-keychain") return KEYCHAIN_DUMP_SINGLE;
-      if (cmd.includes("find-generic-password")) {
-        const err = new Error("not found");
-        err.status = 44;
-        throw err;
-      }
       throw new Error("unexpected");
     });
+    execFileSync.mockImplementation(() => {
+      const err = new Error("not found");
+      err.status = 44;
+      throw err;
+    });
 
     expect(readCCCredentialsFromKeychain()).toEqual([]);
   });
@@ -317,11 +325,14 @@ describe("readCCCredentials", () => {
   it("combines keychain and file sources on macOS", () => {
     Object.defineProperty(process, "platform", { value: "darwin" });
 
-    // Keychain returns one credential
+    // Keychain: dump-keychain via execSync, find-generic-password via execFileSync
     execSync.mockImplementation((cmd) => {
       if (cmd === "security dump-keychain") return KEYCHAIN_DUMP_SINGLE;
-      if (cmd.includes("find-generic-password")) return JSON.stringify(VALID_CRED);
-      throw new Error("unexpected");
+      throw new Error("unexpected execSync cmd");
+    });
+    execFileSync.mockImplementation((_bin, args) => {
+      if (args && args.includes("find-generic-password")) return JSON.stringify(VALID_CRED);
+      throw new Error("unexpected execFileSync cmd");
     });
 
     // File returns a different credential
@@ -343,8 +354,11 @@ describe("readCCCredentials", () => {
 
     execSync.mockImplementation((cmd) => {
       if (cmd === "security dump-keychain") return KEYCHAIN_DUMP_SINGLE;
-      if (cmd.includes("find-generic-password")) return JSON.stringify(keychainCred);
-      throw new Error("unexpected");
+      throw new Error("unexpected execSync cmd");
+    });
+    execFileSync.mockImplementation((_bin, args) => {
+      if (args && args.includes("find-generic-password")) return JSON.stringify(keychainCred);
+      throw new Error("unexpected execFileSync cmd");
     });
 
     existsSync.mockReturnValue(true);

package/lib/config.mjs

@@ -53,6 +53,13 @@ import { randomBytes } from "node:crypto";
  * @property {number} hit_rate_warning_threshold - Warn when avg cache hit rate falls below this (0-1). Default: 0.3
  */
 
+/**
+ * @typedef {object} AdaptiveContextConfig
+ * @property {boolean} enabled - When true, context-1m beta is toggled per-request based on prompt size.  Default: false.
+ * @property {number} escalation_threshold - Token count (input+cache) above which 1M context is activated. Default: 150_000.
+ * @property {number} deescalation_threshold - Token count below which 1M context is deactivated. Default: 100_000.
+ */
+
 /**
  * @typedef {object} CCCredentialReuseConfig
  * @property {boolean} enabled - Master switch for CC credential reuse.  Default: false.
@@ -78,6 +85,7 @@ import { randomBytes } from "node:crypto";
  * @property {{emulate_minimal: boolean}} telemetry
  * @property {boolean} usage_toast
  * @property {CCCredentialReuseConfig} cc_credential_reuse
+ * @property {AdaptiveContextConfig} adaptive_context
  */
 
 /** @type {AnthropicAuthConfig} */
@@ -141,6 +149,11 @@ export const DEFAULT_CONFIG = {
     auto_detect: true,
     prefer_over_oauth: false,
   },
+  adaptive_context: {
+    enabled: true,
+    escalation_threshold: 150_000,
+    deescalation_threshold: 100_000,
+  },
 };
 
 export const VALID_STRATEGIES = ["sticky", "round-robin", "hybrid"];
@@ -167,6 +180,7 @@ function createDefaultConfig() {
     telemetry: { ...DEFAULT_CONFIG.telemetry },
     headers: { ...DEFAULT_CONFIG.headers, overrides: {}, disable: [] },
     cc_credential_reuse: { ...DEFAULT_CONFIG.cc_credential_reuse },
+    adaptive_context: { ...DEFAULT_CONFIG.adaptive_context },
   };
 }
 
@@ -385,6 +399,33 @@ function validateConfig(raw) {
     };
   }
 
+  // Adaptive context sub-config
+  if (raw.adaptive_context && typeof raw.adaptive_context === "object") {
+    const ac = /** @type {Record<string, unknown>} */ (raw.adaptive_context);
+    config.adaptive_context = {
+      enabled: typeof ac.enabled === "boolean" ? ac.enabled : DEFAULT_CONFIG.adaptive_context.enabled,
+      escalation_threshold: clampNumber(
+        ac.escalation_threshold,
+        50_000,
+        500_000,
+        DEFAULT_CONFIG.adaptive_context.escalation_threshold,
+      ),
+      deescalation_threshold: clampNumber(
+        ac.deescalation_threshold,
+        20_000,
+        400_000,
+        DEFAULT_CONFIG.adaptive_context.deescalation_threshold,
+      ),
+    };
+    // Cross-validate: deescalation must be strictly less than escalation to maintain hysteresis gap
+    if (config.adaptive_context.deescalation_threshold >= config.adaptive_context.escalation_threshold) {
+      config.adaptive_context.deescalation_threshold = Math.max(
+        20_000,
+        config.adaptive_context.escalation_threshold - 50_000,
+      );
+    }
+  }
+
   return config;
 }
 
@@ -464,6 +505,13 @@ function applyEnvOverrides(config) {
     config.cc_credential_reuse.enabled = false;
   }
 
+  if (env.OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT === "1" || env.OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT === "true") {
+    config.adaptive_context.enabled = true;
+  }
+  if (env.OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT === "0" || env.OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT === "false") {
+    config.adaptive_context.enabled = false;
+  }
+
   return config;
 }
 

package/lib/config.test.mjs

@@ -70,6 +70,7 @@ describe("loadConfig", () => {
     delete process.env.OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE;
     delete process.env.OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION;
     delete process.env.OPENCODE_ANTHROPIC_PROMPT_COMPACTION;
+    delete process.env.OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT;
   });
 
   afterEach(() => {
@@ -304,4 +305,77 @@ describe("loadConfig", () => {
     const config = loadConfig();
     expect(config.toasts.quiet).toBe(false);
   });
+
+  // --- adaptive_context config tests ---
+
+  it("has adaptive_context defaults (enabled)", () => {
+    existsSync.mockReturnValue(false);
+    const config = loadConfig();
+    expect(config.adaptive_context).toEqual({
+      enabled: true,
+      escalation_threshold: 150_000,
+      deescalation_threshold: 100_000,
+    });
+  });
+
+  it("merges adaptive_context from config file", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(
+      JSON.stringify({ adaptive_context: { enabled: true, escalation_threshold: 200_000 } }),
+    );
+    const config = loadConfig();
+    expect(config.adaptive_context.enabled).toBe(true);
+    expect(config.adaptive_context.escalation_threshold).toBe(200_000);
+    expect(config.adaptive_context.deescalation_threshold).toBe(100_000); // default preserved
+  });
+
+  it("clamps adaptive_context thresholds to valid ranges", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(
+      JSON.stringify({
+        adaptive_context: {
+          enabled: true,
+          escalation_threshold: 999_999, // above 500K max → clamped
+          deescalation_threshold: 1, // below 20K min → clamped
+        },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.adaptive_context.escalation_threshold).toBe(500_000);
+    expect(config.adaptive_context.deescalation_threshold).toBe(20_000);
+  });
+
+  it("ignores non-boolean adaptive_context.enabled", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ adaptive_context: { enabled: "yes" } }));
+    const config = loadConfig();
+    expect(config.adaptive_context.enabled).toBe(true);
+  });
+
+  it("ignores non-number adaptive_context thresholds", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(
+      JSON.stringify({
+        adaptive_context: { escalation_threshold: "high", deescalation_threshold: null },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.adaptive_context.escalation_threshold).toBe(150_000);
+    expect(config.adaptive_context.deescalation_threshold).toBe(100_000);
+  });
+
+  it("enables adaptive context from OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT=1", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT = "1";
+    const config = loadConfig();
+    expect(config.adaptive_context.enabled).toBe(true);
+  });
+
+  it("disables adaptive context from OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT=0", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ adaptive_context: { enabled: true } }));
+    process.env.OPENCODE_ANTHROPIC_ADAPTIVE_CONTEXT = "0";
+    const config = loadConfig();
+    expect(config.adaptive_context.enabled).toBe(false);
+  });
 });

package/lib/storage.mjs

@@ -183,6 +183,10 @@ function validateAccount(raw, now) {
       typeof acc.consecutiveFailures === "number" ? Math.max(0, Math.floor(acc.consecutiveFailures)) : 0,
     lastFailureTime: typeof acc.lastFailureTime === "number" ? acc.lastFailureTime : null,
     lastSwitchReason: typeof acc.lastSwitchReason === "string" ? acc.lastSwitchReason : undefined,
+    source:
+      typeof acc.source === "string" && ["oauth", "cc-keychain", "cc-file"].includes(acc.source)
+        ? acc.source
+        : undefined,
     stats: validateStats(acc.stats, now),
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-fix",
-  "version": "0.0.31",
+  "version": "0.0.33",
   "license": "GPL-3.0-or-later",
   "main": "./index.mjs",
   "files": [