opencode-anthropic-fix 0.0.14

package/lib/config.mjs

@@ -0,0 +1,366 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+
+/**
+ * @typedef {'sticky' | 'round-robin' | 'hybrid'} AccountSelectionStrategy
+ */
+
+/**
+ * @typedef {object} HealthScoreConfig
+ * @property {number} initial
+ * @property {number} success_reward
+ * @property {number} rate_limit_penalty
+ * @property {number} failure_penalty
+ * @property {number} recovery_rate_per_hour
+ * @property {number} min_usable
+ * @property {number} max_score
+ */
+
+/**
+ * @typedef {object} TokenBucketConfig
+ * @property {number} max_tokens
+ * @property {number} regeneration_rate_per_minute
+ * @property {number} initial_tokens
+ */
+
+/**
+ * @typedef {object} ToastConfig
+ * @property {boolean} quiet - Suppress non-error toasts
+ * @property {number} debounce_seconds - Minimum seconds between account-switch toasts
+ */
+
+/**
+ * @typedef {object} OverrideModelLimitsConfig
+ * @property {boolean} enabled - When true, overrides model context limits for 1M-window models so OpenCode compacts at the right threshold.
+ * @property {number} context - Context window size to inject (tokens). Default: 1_000_000.
+ * @property {number} output - Max output tokens to inject. 0 = leave model default unchanged.
+ */
+
+/**
+ * @typedef {object} AnthropicAuthConfig
+ * @property {AccountSelectionStrategy} account_selection_strategy
+ * @property {number} failure_ttl_seconds
+ * @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 {HealthScoreConfig} health_score
+ * @property {TokenBucketConfig} token_bucket
+ * @property {ToastConfig} toasts
+ */
+
+/** @type {AnthropicAuthConfig} */
+export const DEFAULT_CONFIG = {
+  account_selection_strategy: "sticky",
+  failure_ttl_seconds: 3600,
+  debug: false,
+  signature_emulation: {
+    enabled: true,
+    fetch_claude_code_version_on_startup: true,
+    prompt_compaction: "minimal",
+  },
+  override_model_limits: {
+    enabled: true,
+    context: 1_000_000,
+    output: 0,
+  },
+  health_score: {
+    initial: 70,
+    success_reward: 1,
+    rate_limit_penalty: -10,
+    failure_penalty: -20,
+    recovery_rate_per_hour: 2,
+    min_usable: 50,
+    max_score: 100,
+  },
+  token_bucket: {
+    max_tokens: 50,
+    regeneration_rate_per_minute: 6,
+    initial_tokens: 50,
+  },
+  toasts: {
+    quiet: false,
+    debounce_seconds: 30,
+  },
+};
+
+export const VALID_STRATEGIES = ["sticky", "round-robin", "hybrid"];
+
+/** OpenCode's OAuth client ID for Anthropic console auth flows. */
+export const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+/**
+ * Build a deep-cloned config object from defaults.
+ * @returns {AnthropicAuthConfig}
+ */
+function createDefaultConfig() {
+  return {
+    ...DEFAULT_CONFIG,
+    signature_emulation: { ...DEFAULT_CONFIG.signature_emulation },
+    override_model_limits: { ...DEFAULT_CONFIG.override_model_limits },
+    health_score: { ...DEFAULT_CONFIG.health_score },
+    token_bucket: { ...DEFAULT_CONFIG.token_bucket },
+    toasts: { ...DEFAULT_CONFIG.toasts },
+  };
+}
+
+/**
+ * Get the OpenCode config directory (XDG-compliant).
+ * @returns {string}
+ */
+export function getConfigDir() {
+  const platform = process.platform;
+  if (platform === "win32") {
+    return join(process.env.APPDATA || join(homedir(), "AppData", "Roaming"), "opencode");
+  }
+  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(xdgConfig, "opencode");
+}
+
+/**
+ * Get the path to the config file.
+ * @returns {string}
+ */
+export function getConfigPath() {
+  return join(getConfigDir(), "anthropic-auth.json");
+}
+
+/**
+ * Clamp a number to a range.
+ * @param {unknown} value
+ * @param {number} min
+ * @param {number} max
+ * @param {number} fallback
+ * @returns {number}
+ */
+function clampNumber(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, value));
+}
+
+/**
+ * Validate and merge a partial config with defaults.
+ * @param {Record<string, unknown>} raw
+ * @returns {AnthropicAuthConfig}
+ */
+function validateConfig(raw) {
+  const config = createDefaultConfig();
+
+  if (typeof raw.account_selection_strategy === "string" && VALID_STRATEGIES.includes(raw.account_selection_strategy)) {
+    config.account_selection_strategy = /** @type {AccountSelectionStrategy} */ (raw.account_selection_strategy);
+  }
+
+  config.failure_ttl_seconds = clampNumber(raw.failure_ttl_seconds, 60, 7200, DEFAULT_CONFIG.failure_ttl_seconds);
+
+  if (typeof raw.debug === "boolean") {
+    config.debug = raw.debug;
+  }
+
+  // Signature emulation sub-config
+  if (raw.signature_emulation && typeof raw.signature_emulation === "object") {
+    const se = /** @type {Record<string, unknown>} */ (raw.signature_emulation);
+    config.signature_emulation = {
+      enabled: typeof se.enabled === "boolean" ? se.enabled : DEFAULT_CONFIG.signature_emulation.enabled,
+      fetch_claude_code_version_on_startup:
+        typeof se.fetch_claude_code_version_on_startup === "boolean"
+          ? se.fetch_claude_code_version_on_startup
+          : DEFAULT_CONFIG.signature_emulation.fetch_claude_code_version_on_startup,
+      prompt_compaction:
+        se.prompt_compaction === "off" || se.prompt_compaction === "minimal"
+          ? se.prompt_compaction
+          : DEFAULT_CONFIG.signature_emulation.prompt_compaction,
+    };
+  }
+
+  // Override model limits sub-config
+  if (raw.override_model_limits && typeof raw.override_model_limits === "object") {
+    const oml = /** @type {Record<string, unknown>} */ (raw.override_model_limits);
+    config.override_model_limits = {
+      enabled: typeof oml.enabled === "boolean" ? oml.enabled : DEFAULT_CONFIG.override_model_limits.enabled,
+      context: clampNumber(oml.context, 200_000, 2_000_000, DEFAULT_CONFIG.override_model_limits.context),
+      output: clampNumber(oml.output, 0, 128_000, DEFAULT_CONFIG.override_model_limits.output),
+    };
+  }
+
+  // Health score sub-config
+  if (raw.health_score && typeof raw.health_score === "object") {
+    const hs = /** @type {Record<string, unknown>} */ (raw.health_score);
+    config.health_score = {
+      initial: clampNumber(hs.initial, 0, 100, DEFAULT_CONFIG.health_score.initial),
+      success_reward: clampNumber(hs.success_reward, 0, 10, DEFAULT_CONFIG.health_score.success_reward),
+      rate_limit_penalty: clampNumber(hs.rate_limit_penalty, -50, 0, DEFAULT_CONFIG.health_score.rate_limit_penalty),
+      failure_penalty: clampNumber(hs.failure_penalty, -100, 0, DEFAULT_CONFIG.health_score.failure_penalty),
+      recovery_rate_per_hour: clampNumber(
+        hs.recovery_rate_per_hour,
+        0,
+        20,
+        DEFAULT_CONFIG.health_score.recovery_rate_per_hour,
+      ),
+      min_usable: clampNumber(hs.min_usable, 0, 100, DEFAULT_CONFIG.health_score.min_usable),
+      max_score: clampNumber(hs.max_score, 50, 100, DEFAULT_CONFIG.health_score.max_score),
+    };
+  }
+
+  // Toast sub-config
+  if (raw.toasts && typeof raw.toasts === "object") {
+    const t = /** @type {Record<string, unknown>} */ (raw.toasts);
+    config.toasts = {
+      quiet: typeof t.quiet === "boolean" ? t.quiet : DEFAULT_CONFIG.toasts.quiet,
+      debounce_seconds: clampNumber(t.debounce_seconds, 0, 300, DEFAULT_CONFIG.toasts.debounce_seconds),
+    };
+  }
+
+  // Token bucket sub-config
+  if (raw.token_bucket && typeof raw.token_bucket === "object") {
+    const tb = /** @type {Record<string, unknown>} */ (raw.token_bucket);
+    config.token_bucket = {
+      max_tokens: clampNumber(tb.max_tokens, 1, 1000, DEFAULT_CONFIG.token_bucket.max_tokens),
+      regeneration_rate_per_minute: clampNumber(
+        tb.regeneration_rate_per_minute,
+        0.1,
+        60,
+        DEFAULT_CONFIG.token_bucket.regeneration_rate_per_minute,
+      ),
+      initial_tokens: clampNumber(tb.initial_tokens, 1, 1000, DEFAULT_CONFIG.token_bucket.initial_tokens),
+    };
+  }
+
+  return config;
+}
+
+/**
+ * Apply environment variable overrides.
+ * @param {AnthropicAuthConfig} config
+ * @returns {AnthropicAuthConfig}
+ */
+function applyEnvOverrides(config) {
+  const env = process.env;
+
+  if (env.OPENCODE_ANTHROPIC_STRATEGY && VALID_STRATEGIES.includes(env.OPENCODE_ANTHROPIC_STRATEGY)) {
+    config.account_selection_strategy = /** @type {AccountSelectionStrategy} */ (env.OPENCODE_ANTHROPIC_STRATEGY);
+  }
+
+  if (env.OPENCODE_ANTHROPIC_DEBUG === "1" || env.OPENCODE_ANTHROPIC_DEBUG === "true") {
+    config.debug = true;
+  }
+  if (env.OPENCODE_ANTHROPIC_DEBUG === "0" || env.OPENCODE_ANTHROPIC_DEBUG === "false") {
+    config.debug = false;
+  }
+
+  if (env.OPENCODE_ANTHROPIC_QUIET === "1" || env.OPENCODE_ANTHROPIC_QUIET === "true") {
+    config.toasts.quiet = true;
+  }
+  if (env.OPENCODE_ANTHROPIC_QUIET === "0" || env.OPENCODE_ANTHROPIC_QUIET === "false") {
+    config.toasts.quiet = false;
+  }
+
+  if (
+    env.OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE === "1" ||
+    env.OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE === "true"
+  ) {
+    config.signature_emulation.enabled = true;
+  }
+  if (
+    env.OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE === "0" ||
+    env.OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE === "false"
+  ) {
+    config.signature_emulation.enabled = false;
+  }
+
+  if (
+    env.OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION === "1" ||
+    env.OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION === "true"
+  ) {
+    config.signature_emulation.fetch_claude_code_version_on_startup = true;
+  }
+  if (
+    env.OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION === "0" ||
+    env.OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION === "false"
+  ) {
+    config.signature_emulation.fetch_claude_code_version_on_startup = false;
+  }
+
+  if (env.OPENCODE_ANTHROPIC_PROMPT_COMPACTION === "off") {
+    config.signature_emulation.prompt_compaction = "off";
+  }
+  if (env.OPENCODE_ANTHROPIC_PROMPT_COMPACTION === "minimal") {
+    config.signature_emulation.prompt_compaction = "minimal";
+  }
+
+  if (env.OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS === "1" || env.OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS === "true") {
+    config.override_model_limits.enabled = true;
+  }
+  if (
+    env.OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS === "0" ||
+    env.OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS === "false"
+  ) {
+    config.override_model_limits.enabled = false;
+  }
+
+  return config;
+}
+
+/**
+ * Load config from disk, validate, apply env overrides.
+ * @returns {AnthropicAuthConfig}
+ */
+export function loadConfig() {
+  const configPath = getConfigPath();
+
+  if (!existsSync(configPath)) {
+    return applyEnvOverrides(createDefaultConfig());
+  }
+
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const raw = JSON.parse(content);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      return applyEnvOverrides(createDefaultConfig());
+    }
+    const config = validateConfig(raw);
+    return applyEnvOverrides(config);
+  } catch {
+    return applyEnvOverrides(createDefaultConfig());
+  }
+}
+
+/**
+ * Load the raw config JSON from disk (without validation or env overrides).
+ * Returns an empty object if the file doesn't exist or is invalid.
+ * @returns {Record<string, unknown>}
+ */
+export function loadRawConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync(configPath)) return {};
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const raw = JSON.parse(content);
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+    return raw;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Save a partial config update to disk (read-modify-write).
+ * Only writes the keys you provide; other keys are preserved.
+ * Uses atomic write (temp + rename) for safety.
+ * @param {Record<string, unknown>} updates - Keys to merge into the config file
+ */
+export function saveConfig(updates) {
+  const configPath = getConfigPath();
+  const dir = dirname(configPath);
+  mkdirSync(dir, { recursive: true });
+
+  // Read existing raw config
+  const existing = loadRawConfig();
+
+  // Merge updates
+  const merged = { ...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);
+}

package/lib/config.test.mjs

@@ -0,0 +1,307 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { loadConfig, DEFAULT_CONFIG, getConfigDir, getConfigPath } from "./config.mjs";
+import { existsSync, readFileSync } from "node:fs";
+
+// Mock fs module
+vi.mock("node:fs", () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+describe("DEFAULT_CONFIG", () => {
+  it("has expected default strategy", () => {
+    expect(DEFAULT_CONFIG.account_selection_strategy).toBe("sticky");
+  });
+
+  it("has expected health score defaults", () => {
+    expect(DEFAULT_CONFIG.health_score.initial).toBe(70);
+    expect(DEFAULT_CONFIG.health_score.success_reward).toBe(1);
+    expect(DEFAULT_CONFIG.health_score.rate_limit_penalty).toBe(-10);
+    expect(DEFAULT_CONFIG.health_score.failure_penalty).toBe(-20);
+    expect(DEFAULT_CONFIG.health_score.min_usable).toBe(50);
+    expect(DEFAULT_CONFIG.health_score.max_score).toBe(100);
+  });
+
+  it("has expected token bucket defaults", () => {
+    expect(DEFAULT_CONFIG.token_bucket.max_tokens).toBe(50);
+    expect(DEFAULT_CONFIG.token_bucket.regeneration_rate_per_minute).toBe(6);
+    expect(DEFAULT_CONFIG.token_bucket.initial_tokens).toBe(50);
+  });
+
+  it("has debug disabled by default", () => {
+    expect(DEFAULT_CONFIG.debug).toBe(false);
+  });
+
+  it("enables signature emulation defaults", () => {
+    expect(DEFAULT_CONFIG.signature_emulation.enabled).toBe(true);
+    expect(DEFAULT_CONFIG.signature_emulation.fetch_claude_code_version_on_startup).toBe(true);
+    expect(DEFAULT_CONFIG.signature_emulation.prompt_compaction).toBe("minimal");
+  });
+
+  it("has toast defaults", () => {
+    expect(DEFAULT_CONFIG.toasts.quiet).toBe(false);
+    expect(DEFAULT_CONFIG.toasts.debounce_seconds).toBe(30);
+  });
+});
+
+describe("getConfigDir", () => {
+  it("returns a path ending with opencode", () => {
+    const dir = getConfigDir();
+    expect(dir.endsWith("opencode")).toBe(true);
+  });
+});
+
+describe("getConfigPath", () => {
+  it("returns a path ending with anthropic-auth.json", () => {
+    const path = getConfigPath();
+    expect(path.endsWith("anthropic-auth.json")).toBe(true);
+  });
+});
+
+describe("loadConfig", () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    // Clean env overrides
+    delete process.env.OPENCODE_ANTHROPIC_STRATEGY;
+    delete process.env.OPENCODE_ANTHROPIC_DEBUG;
+    delete process.env.OPENCODE_ANTHROPIC_QUIET;
+    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;
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  it("returns defaults when config file does not exist", () => {
+    existsSync.mockReturnValue(false);
+    const config = loadConfig();
+    expect(config).toEqual(DEFAULT_CONFIG);
+  });
+
+  it("returns defaults when config file is invalid JSON", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue("not json {{{");
+    const config = loadConfig();
+    expect(config).toEqual(DEFAULT_CONFIG);
+  });
+
+  it("returns defaults when config file is an array", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue("[]");
+    const config = loadConfig();
+    expect(config).toEqual(DEFAULT_CONFIG);
+  });
+
+  it("returns defaults when config file is null", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue("null");
+    const config = loadConfig();
+    expect(config).toEqual(DEFAULT_CONFIG);
+  });
+
+  it("merges valid strategy from config file", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ account_selection_strategy: "sticky" }));
+    const config = loadConfig();
+    expect(config.account_selection_strategy).toBe("sticky");
+  });
+
+  it("ignores invalid strategy", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ account_selection_strategy: "invalid" }));
+    const config = loadConfig();
+    expect(config.account_selection_strategy).toBe("sticky");
+  });
+
+  it("accepts boolean debug", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ debug: true }));
+    const config = loadConfig();
+    expect(config.debug).toBe(true);
+  });
+
+  it("merges signature emulation sub-config", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(
+      JSON.stringify({
+        signature_emulation: {
+          enabled: false,
+          fetch_claude_code_version_on_startup: false,
+          prompt_compaction: "off",
+        },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.signature_emulation.enabled).toBe(false);
+    expect(config.signature_emulation.fetch_claude_code_version_on_startup).toBe(false);
+    expect(config.signature_emulation.prompt_compaction).toBe("off");
+  });
+
+  it("merges health_score sub-config", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(
+      JSON.stringify({
+        health_score: {
+          initial: 80,
+          success_reward: 5,
+        },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.health_score.initial).toBe(80);
+    expect(config.health_score.success_reward).toBe(5);
+    // Other fields should be defaults
+    expect(config.health_score.rate_limit_penalty).toBe(-10);
+  });
+
+  it("clamps health_score values to valid ranges", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(
+      JSON.stringify({
+        health_score: {
+          initial: 200, // max 100
+          rate_limit_penalty: -999, // min -50
+        },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.health_score.initial).toBe(100);
+    expect(config.health_score.rate_limit_penalty).toBe(-50);
+  });
+
+  it("merges token_bucket sub-config", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(
+      JSON.stringify({
+        token_bucket: {
+          max_tokens: 100,
+        },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.token_bucket.max_tokens).toBe(100);
+    expect(config.token_bucket.regeneration_rate_per_minute).toBe(6);
+  });
+
+  // Environment variable overrides
+  it("overrides strategy from OPENCODE_ANTHROPIC_STRATEGY", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_STRATEGY = "round-robin";
+    const config = loadConfig();
+    expect(config.account_selection_strategy).toBe("round-robin");
+  });
+
+  it("ignores invalid OPENCODE_ANTHROPIC_STRATEGY", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_STRATEGY = "invalid";
+    const config = loadConfig();
+    expect(config.account_selection_strategy).toBe("sticky");
+  });
+
+  it("enables debug from OPENCODE_ANTHROPIC_DEBUG=1", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_DEBUG = "1";
+    const config = loadConfig();
+    expect(config.debug).toBe(true);
+  });
+
+  it("enables debug from OPENCODE_ANTHROPIC_DEBUG=true", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_DEBUG = "true";
+    const config = loadConfig();
+    expect(config.debug).toBe(true);
+  });
+
+  it("disables debug from OPENCODE_ANTHROPIC_DEBUG=0", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ debug: true }));
+    process.env.OPENCODE_ANTHROPIC_DEBUG = "0";
+    const config = loadConfig();
+    expect(config.debug).toBe(false);
+  });
+
+  it("disables signature emulation from OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE=0", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_EMULATE_CLAUDE_CODE_SIGNATURE = "0";
+    const config = loadConfig();
+    expect(config.signature_emulation.enabled).toBe(false);
+  });
+
+  it("disables version fetch from OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION=0", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_FETCH_CLAUDE_CODE_VERSION = "0";
+    const config = loadConfig();
+    expect(config.signature_emulation.fetch_claude_code_version_on_startup).toBe(false);
+  });
+
+  it("disables prompt compaction from OPENCODE_ANTHROPIC_PROMPT_COMPACTION=off", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_PROMPT_COMPACTION = "off";
+    const config = loadConfig();
+    expect(config.signature_emulation.prompt_compaction).toBe("off");
+  });
+
+  it("env overrides take precedence over config file", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ account_selection_strategy: "sticky" }));
+    process.env.OPENCODE_ANTHROPIC_STRATEGY = "round-robin";
+    const config = loadConfig();
+    expect(config.account_selection_strategy).toBe("round-robin");
+  });
+
+  // Toast config
+  it("has toast defaults", () => {
+    existsSync.mockReturnValue(false);
+    const config = loadConfig();
+    expect(config.toasts.quiet).toBe(false);
+    expect(config.toasts.debounce_seconds).toBe(30);
+  });
+
+  it("merges toasts sub-config", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ toasts: { quiet: true, debounce_seconds: 10 } }));
+    const config = loadConfig();
+    expect(config.toasts.quiet).toBe(true);
+    expect(config.toasts.debounce_seconds).toBe(10);
+  });
+
+  it("clamps debounce_seconds to valid range", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ toasts: { debounce_seconds: 999 } }));
+    const config = loadConfig();
+    expect(config.toasts.debounce_seconds).toBe(300);
+  });
+
+  it("clamps negative debounce_seconds to 0", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ toasts: { debounce_seconds: -5 } }));
+    const config = loadConfig();
+    expect(config.toasts.debounce_seconds).toBe(0);
+  });
+
+  it("ignores non-boolean quiet", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ toasts: { quiet: "yes" } }));
+    const config = loadConfig();
+    expect(config.toasts.quiet).toBe(false);
+  });
+
+  it("enables quiet from OPENCODE_ANTHROPIC_QUIET=1", () => {
+    existsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_QUIET = "1";
+    const config = loadConfig();
+    expect(config.toasts.quiet).toBe(true);
+  });
+
+  it("disables quiet from OPENCODE_ANTHROPIC_QUIET=0", () => {
+    existsSync.mockReturnValue(true);
+    readFileSync.mockReturnValue(JSON.stringify({ toasts: { quiet: true } }));
+    process.env.OPENCODE_ANTHROPIC_QUIET = "0";
+    const config = loadConfig();
+    expect(config.toasts.quiet).toBe(false);
+  });
+});