opencode-anthropic-fix 0.2.1 → 0.3.0

package/lib/request-headers.test.mjs

@@ -1,164 +0,0 @@
-/**
- * Smoke tests for lib/request-headers.mjs exports.
- * Verifies version constants, beta shortcuts, and user-agent builder.
- */
-import { describe, it, expect, afterEach } from "vitest";
-import {
-  FALLBACK_CLAUDE_CLI_VERSION,
-  ANTHROPIC_SDK_VERSION,
-  getSdkVersion,
-  BETA_SHORTCUTS,
-  EXPERIMENTAL_BETA_FLAGS,
-  resolveBetaShortcut,
-  buildExtendedUserAgent,
-} from "./request-headers.mjs";
-
-describe("request-headers constants", () => {
-  it("FALLBACK_CLAUDE_CLI_VERSION is 2.1.195", () => {
-    expect(FALLBACK_CLAUDE_CLI_VERSION).toBe("2.1.195");
-  });
-
-  it("ANTHROPIC_SDK_VERSION matches expected value", () => {
-    expect(typeof ANTHROPIC_SDK_VERSION).toBe("string");
-    expect(ANTHROPIC_SDK_VERSION).toMatch(/^\d+\.\d+\.\d+$/);
-    // The wire SDK version did NOT bump for 2.1.195.
-    expect(ANTHROPIC_SDK_VERSION).toBe("0.94.0");
-  });
-});
-
-describe("getSdkVersion", () => {
-  it("returns known SDK version for CLI version 2.1.143", () => {
-    // 2.1.143 is in the VERSION_TO_SDK_MAP
-    const v = getSdkVersion("2.1.143");
-    expect(typeof v).toBe("string");
-    expect(v).toMatch(/^\d+\.\d+\.\d+$/);
-  });
-
-  it("resolves 2.1.195 (and the 2.1.160-2.1.194 range) to 0.94.0", () => {
-    expect(getSdkVersion("2.1.195")).toBe("0.94.0");
-    expect(getSdkVersion("2.1.160")).toBe("0.94.0");
-    expect(getSdkVersion("2.1.180")).toBe("0.94.0");
-  });
-
-  it("falls back to ANTHROPIC_SDK_VERSION for an unknown CLI version", () => {
-    expect(getSdkVersion("9.99.999")).toBe(ANTHROPIC_SDK_VERSION);
-  });
-
-  it("falls back for undefined/null input", () => {
-    expect(getSdkVersion(undefined)).toBe(ANTHROPIC_SDK_VERSION);
-    expect(getSdkVersion(null)).toBe(ANTHROPIC_SDK_VERSION);
-  });
-});
-
-describe("BETA_SHORTCUTS", () => {
-  it("is a Map", () => {
-    expect(BETA_SHORTCUTS).toBeInstanceOf(Map);
-  });
-
-  it("has cache-diagnosis shortcut resolving to cache-diagnosis-2026-04-07", () => {
-    expect(BETA_SHORTCUTS.get("cache-diagnosis")).toBe("cache-diagnosis-2026-04-07");
-  });
-
-  it("has a cache-diag alias for cache-diagnosis-2026-04-07", () => {
-    expect(BETA_SHORTCUTS.get("cache-diag")).toBe("cache-diagnosis-2026-04-07");
-  });
-
-  it("has server-side-fallback / fallback aliases for server-side-fallback-2026-06-01", () => {
-    expect(BETA_SHORTCUTS.get("server-side-fallback")).toBe("server-side-fallback-2026-06-01");
-    expect(BETA_SHORTCUTS.get("fallback")).toBe("server-side-fallback-2026-06-01");
-  });
-
-  it("has a fallback-credit alias for fallback-credit-2026-06-01", () => {
-    expect(BETA_SHORTCUTS.get("fallback-credit")).toBe("fallback-credit-2026-06-01");
-  });
-});
-
-describe("EXPERIMENTAL_BETA_FLAGS", () => {
-  it("is a Set", () => {
-    expect(EXPERIMENTAL_BETA_FLAGS).toBeInstanceOf(Set);
-  });
-
-  it("includes the 2.1.195 refusal-fallback registry betas", () => {
-    expect(EXPERIMENTAL_BETA_FLAGS.has("server-side-fallback-2026-06-01")).toBe(true);
-    expect(EXPERIMENTAL_BETA_FLAGS.has("fallback-credit-2026-06-01")).toBe(true);
-  });
-});
-
-describe("resolveBetaShortcut", () => {
-  it("expands cache-diagnosis shortcut", () => {
-    expect(resolveBetaShortcut("cache-diagnosis")).toBe("cache-diagnosis-2026-04-07");
-  });
-
-  it("expands cache-diag alias", () => {
-    expect(resolveBetaShortcut("cache-diag")).toBe("cache-diagnosis-2026-04-07");
-  });
-
-  it("expands 1m shortcut", () => {
-    expect(resolveBetaShortcut("1m")).toBe("context-1m-2025-08-07");
-  });
-
-  it("expands fast shortcut", () => {
-    expect(resolveBetaShortcut("fast")).toBe("fast-mode-2026-02-01");
-  });
-
-  it("expands server-side-fallback / fallback shortcuts", () => {
-    expect(resolveBetaShortcut("server-side-fallback")).toBe("server-side-fallback-2026-06-01");
-    expect(resolveBetaShortcut("fallback")).toBe("server-side-fallback-2026-06-01");
-  });
-
-  it("expands fallback-credit shortcut", () => {
-    expect(resolveBetaShortcut("fallback-credit")).toBe("fallback-credit-2026-06-01");
-  });
-
-  it("returns the input unchanged when no alias matches", () => {
-    expect(resolveBetaShortcut("context-hint-2026-04-09")).toBe("context-hint-2026-04-09");
-    expect(resolveBetaShortcut("no-such-beta")).toBe("no-such-beta");
-  });
-
-  it("returns empty string for falsy/empty input", () => {
-    expect(resolveBetaShortcut(undefined)).toBe("");
-    expect(resolveBetaShortcut("")).toBe("");
-    expect(resolveBetaShortcut(null)).toBe("");
-  });
-});
-
-describe("buildExtendedUserAgent", () => {
-  afterEach(() => {
-    delete process.env.CLAUDE_CODE_ENTRYPOINT;
-    delete process.env.CLAUDE_AGENT_SDK_VERSION;
-    delete process.env.CLAUDE_AGENT_SDK_CLIENT_APP;
-  });
-
-  it("returns default cli format without env vars", () => {
-    delete process.env.CLAUDE_CODE_ENTRYPOINT;
-    delete process.env.CLAUDE_AGENT_SDK_VERSION;
-    delete process.env.CLAUDE_AGENT_SDK_CLIENT_APP;
-    const ua = buildExtendedUserAgent("2.1.143");
-    expect(ua).toBe("claude-cli/2.1.143 (external, cli)");
-  });
-
-  it("uses CLAUDE_CODE_ENTRYPOINT when set", () => {
-    process.env.CLAUDE_CODE_ENTRYPOINT = "vscode";
-    const ua = buildExtendedUserAgent("2.1.143");
-    expect(ua).toBe("claude-cli/2.1.143 (external, vscode)");
-  });
-
-  it("appends agent-sdk suffix when CLAUDE_AGENT_SDK_VERSION is set", () => {
-    process.env.CLAUDE_AGENT_SDK_VERSION = "1.2.3";
-    const ua = buildExtendedUserAgent("2.1.143");
-    expect(ua).toContain("agent-sdk/1.2.3");
-    expect(ua).toMatch(/^claude-cli\/2\.1\.143/);
-  });
-
-  it("appends client-app suffix when CLAUDE_AGENT_SDK_CLIENT_APP is set", () => {
-    process.env.CLAUDE_AGENT_SDK_CLIENT_APP = "myapp";
-    const ua = buildExtendedUserAgent("2.1.143");
-    expect(ua).toContain("client-app/myapp");
-  });
-
-  it("uses FALLBACK_CLAUDE_CLI_VERSION when explicitly passed as the version", () => {
-    const ua = buildExtendedUserAgent(FALLBACK_CLAUDE_CLI_VERSION);
-    expect(ua).toContain(FALLBACK_CLAUDE_CLI_VERSION);
-    expect(ua).toBe("claude-cli/2.1.195 (external, cli)");
-  });
-});

package/lib/retry/overload-loop.test.mjs

@@ -1,107 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  computeServiceRetrySleepMs,
-  selectFallbackModel,
-  shouldServiceRetry,
-  isTransientRateLimit,
-} from "./overload-loop.mjs";
-import {
-  SERVICE_RETRY_BASE_DELAY_SEC,
-  SERVICE_RETRY_MAX_DELAY_SEC,
-  SERVICE_RETRY_JITTER_FRACTION,
-} from "../tuning.mjs";
-
-describe("overload-loop: computeServiceRetrySleepMs", () => {
-  const noJitter = () => 0; // jitter factor = 1 (no reduction)
-  const maxJitter = () => 1; // jitter factor = 1 - jitterFraction
-
-  it("applies capped exponential backoff with zero jitter", () => {
-    expect(computeServiceRetrySleepMs(0, {}, noJitter)).toBe(500);
-    expect(computeServiceRetrySleepMs(1, {}, noJitter)).toBe(1000);
-    expect(computeServiceRetrySleepMs(2, {}, noJitter)).toBe(2000);
-  });
-
-  it("caps the base delay at the configured maximum", () => {
-    // 0.5 * 2^3 = 4s, capped to SERVICE_RETRY_MAX_DELAY_SEC (3s) -> 3000ms
-    expect(SERVICE_RETRY_MAX_DELAY_SEC).toBe(3);
-    expect(computeServiceRetrySleepMs(3, {}, noJitter)).toBe(3000);
-    expect(computeServiceRetrySleepMs(10, {}, noJitter)).toBe(3000);
-  });
-
-  it("applies maximum downward jitter", () => {
-    // n=0: base 500ms * (1 - 0.25) = 375ms
-    expect(SERVICE_RETRY_JITTER_FRACTION).toBe(0.25);
-    expect(computeServiceRetrySleepMs(0, {}, maxJitter)).toBe(375);
-  });
-
-  it("honors option overrides", () => {
-    const ms = computeServiceRetrySleepMs(
-      1,
-      { baseDelaySec: 1, backoffMultiplier: 3, maxDelaySec: 100, jitterFraction: 0 },
-      maxJitter,
-    );
-    // 1 * 3^1 = 3s, jitter 1 - 1*0 = 1 -> 3000ms
-    expect(ms).toBe(3000);
-  });
-
-  it("defaults to the tuning base delay for the first attempt", () => {
-    expect(computeServiceRetrySleepMs(0, {}, noJitter)).toBe(SERVICE_RETRY_BASE_DELAY_SEC * 1000);
-  });
-});
-
-describe("overload-loop: selectFallbackModel", () => {
-  it("steps opus -> sonnet", () => {
-    expect(selectFallbackModel("claude-opus-4-6")).toBe("claude-sonnet-4-6");
-    expect(selectFallbackModel("claude-opus-4")).toBe("claude-sonnet-4");
-  });
-
-  it("steps sonnet -> haiku", () => {
-    expect(selectFallbackModel("claude-sonnet-4-6")).toBe("claude-haiku-4-6");
-    expect(selectFallbackModel("claude-sonnet-4-5")).toBe("claude-haiku-4-5");
-  });
-
-  it("returns null for haiku (bottom of the chain)", () => {
-    expect(selectFallbackModel("claude-haiku-4-5")).toBeNull();
-  });
-
-  it("returns null for empty or unknown models", () => {
-    expect(selectFallbackModel("")).toBeNull();
-    expect(selectFallbackModel(null)).toBeNull();
-    expect(selectFallbackModel(undefined)).toBeNull();
-    expect(selectFallbackModel("gpt-4o")).toBeNull();
-  });
-});
-
-describe("overload-loop: shouldServiceRetry", () => {
-  it("retries 529/503 while under the budget", () => {
-    expect(shouldServiceRetry(529, 0, 2)).toBe(true);
-    expect(shouldServiceRetry(503, 1, 2)).toBe(true);
-  });
-
-  it("stops at the budget", () => {
-    expect(shouldServiceRetry(529, 2, 2)).toBe(false);
-  });
-
-  it("ignores non-overload statuses", () => {
-    expect(shouldServiceRetry(500, 0, 2)).toBe(false);
-    expect(shouldServiceRetry(429, 0, 2)).toBe(false);
-    expect(shouldServiceRetry(200, 0, 2)).toBe(false);
-  });
-});
-
-describe("overload-loop: isTransientRateLimit", () => {
-  const T = 10000;
-  it("is true for a short-retry-after RATE_LIMIT_EXCEEDED 429", () => {
-    expect(isTransientRateLimit(429, "RATE_LIMIT_EXCEEDED", 5000, T)).toBe(true);
-    expect(isTransientRateLimit(429, "RATE_LIMIT_EXCEEDED", T, T)).toBe(true);
-  });
-
-  it("is false when any condition is not met", () => {
-    expect(isTransientRateLimit(529, "RATE_LIMIT_EXCEEDED", 5000, T)).toBe(false);
-    expect(isTransientRateLimit(429, "QUOTA_EXHAUSTED", 5000, T)).toBe(false);
-    expect(isTransientRateLimit(429, "RATE_LIMIT_EXCEEDED", null, T)).toBe(false);
-    expect(isTransientRateLimit(429, "RATE_LIMIT_EXCEEDED", undefined, T)).toBe(false);
-    expect(isTransientRateLimit(429, "RATE_LIMIT_EXCEEDED", 0, T)).toBe(false);
-    expect(isTransientRateLimit(429, "RATE_LIMIT_EXCEEDED", 15000, T)).toBe(false);
-  });
-});

package/lib/rotation.test.mjs

@@ -1,392 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { HealthScoreTracker, TokenBucketTracker, selectAccount } from "./rotation.mjs";
-
-// ---------------------------------------------------------------------------
-// HealthScoreTracker
-// ---------------------------------------------------------------------------
-
-describe("HealthScoreTracker", () => {
-  /** @type {HealthScoreTracker} */
-  let tracker;
-
-  beforeEach(() => {
-    tracker = new HealthScoreTracker();
-  });
-
-  it("returns initial score for unknown account", () => {
-    expect(tracker.getScore(0)).toBe(70);
-  });
-
-  it("increases score on success", () => {
-    tracker.recordSuccess(0);
-    expect(tracker.getScore(0)).toBe(71);
-  });
-
-  it("decreases score on rate limit", () => {
-    tracker.recordRateLimit(0);
-    expect(tracker.getScore(0)).toBe(60);
-  });
-
-  it("decreases score on failure", () => {
-    tracker.recordFailure(0);
-    expect(tracker.getScore(0)).toBe(50);
-  });
-
-  it("does not go below 0", () => {
-    for (let i = 0; i < 10; i++) {
-      tracker.recordFailure(0);
-    }
-    expect(tracker.getScore(0)).toBe(0);
-  });
-
-  it("caps at max_score", () => {
-    for (let i = 0; i < 50; i++) {
-      tracker.recordSuccess(0);
-    }
-    expect(tracker.getScore(0)).toBe(100);
-  });
-
-  it("isUsable returns true when score >= min_usable", () => {
-    expect(tracker.isUsable(0)).toBe(true); // 70 >= 50
-  });
-
-  it("isUsable returns false when score < min_usable", () => {
-    // 70 - 20 = 50 (still usable), need one more
-    tracker.recordFailure(0); // 50
-    expect(tracker.isUsable(0)).toBe(true);
-    tracker.recordRateLimit(0); // 40
-    expect(tracker.isUsable(0)).toBe(false);
-  });
-
-  it("reset removes tracking for an account", () => {
-    tracker.recordFailure(0);
-    tracker.reset(0);
-    expect(tracker.getScore(0)).toBe(70); // Back to initial
-  });
-
-  it("tracks accounts independently", () => {
-    tracker.recordFailure(0);
-    tracker.recordSuccess(1);
-    expect(tracker.getScore(0)).toBe(50);
-    expect(tracker.getScore(1)).toBe(71);
-  });
-
-  it("applies passive recovery over time", () => {
-    tracker.recordFailure(0); // Score = 50
-    // Simulate 1 hour passing
-    const state = tracker.getScore(0);
-    expect(state).toBe(50);
-
-    // We can't easily test time-based recovery without mocking Date.now
-    // but we can verify the formula works by checking the code path
-  });
-
-  it("uses custom config", () => {
-    const custom = new HealthScoreTracker({
-      initial: 100,
-      success_reward: 5,
-      rate_limit_penalty: -5,
-      failure_penalty: -10,
-      min_usable: 80,
-      max_score: 100,
-    });
-    expect(custom.getScore(0)).toBe(100);
-    custom.recordRateLimit(0);
-    expect(custom.getScore(0)).toBe(95);
-    expect(custom.isUsable(0)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// TokenBucketTracker
-// ---------------------------------------------------------------------------
-
-describe("TokenBucketTracker", () => {
-  /** @type {TokenBucketTracker} */
-  let tracker;
-
-  beforeEach(() => {
-    tracker = new TokenBucketTracker();
-  });
-
-  it("returns initial tokens for unknown account", () => {
-    expect(tracker.getTokens(0)).toBe(50);
-  });
-
-  it("hasTokens returns true when tokens available", () => {
-    expect(tracker.hasTokens(0)).toBe(true);
-  });
-
-  it("consume reduces tokens", () => {
-    tracker.consume(0);
-    expect(tracker.getTokens(0)).toBeCloseTo(49, 1);
-  });
-
-  it("consume returns false when insufficient tokens", () => {
-    // Drain all tokens
-    for (let i = 0; i < 50; i++) {
-      tracker.consume(0);
-    }
-    expect(tracker.consume(0)).toBe(false);
-    expect(tracker.hasTokens(0)).toBe(false);
-  });
-
-  it("refund adds tokens back", () => {
-    tracker.consume(0);
-    tracker.consume(0);
-    tracker.refund(0);
-    expect(tracker.getTokens(0)).toBeCloseTo(49, 0);
-  });
-
-  it("refund does not exceed max", () => {
-    tracker.refund(0, 100);
-    expect(tracker.getTokens(0)).toBe(50);
-  });
-
-  it("getMaxTokens returns configured max", () => {
-    expect(tracker.getMaxTokens()).toBe(50);
-  });
-
-  it("uses custom config", () => {
-    const custom = new TokenBucketTracker({
-      max_tokens: 10,
-      initial_tokens: 5,
-      regeneration_rate_per_minute: 1,
-    });
-    expect(custom.getTokens(0)).toBe(5);
-    expect(custom.getMaxTokens()).toBe(10);
-  });
-
-  it("tracks accounts independently", () => {
-    tracker.consume(0);
-    expect(tracker.getTokens(0)).toBe(49);
-    expect(tracker.getTokens(1)).toBe(50);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// selectAccount
-// ---------------------------------------------------------------------------
-
-describe("selectAccount", () => {
-  /** @type {HealthScoreTracker} */
-  let healthTracker;
-  /** @type {TokenBucketTracker} */
-  let tokenTracker;
-
-  beforeEach(() => {
-    healthTracker = new HealthScoreTracker();
-    tokenTracker = new TokenBucketTracker();
-  });
-
-  /**
-   * @param {Partial<import('./rotation.mjs').AccountCandidate>} overrides
-   * @returns {import('./rotation.mjs').AccountCandidate}
-   */
-  function makeCandidate(overrides = {}) {
-    return {
-      index: 0,
-      lastUsed: 0,
-      healthScore: 70,
-      isRateLimited: false,
-      enabled: true,
-      ...overrides,
-    };
-  }
-
-  it("returns null when no candidates", () => {
-    expect(selectAccount([], "sticky", null, healthTracker, tokenTracker, 0)).toBeNull();
-  });
-
-  it("returns null when all candidates are rate-limited", () => {
-    const candidates = [
-      makeCandidate({ index: 0, isRateLimited: true }),
-      makeCandidate({ index: 1, isRateLimited: true }),
-    ];
-    expect(selectAccount(candidates, "sticky", null, healthTracker, tokenTracker, 0)).toBeNull();
-  });
-
-  it("returns null when all candidates are disabled", () => {
-    const candidates = [makeCandidate({ index: 0, enabled: false })];
-    expect(selectAccount(candidates, "sticky", null, healthTracker, tokenTracker, 0)).toBeNull();
-  });
-
-  // Sticky strategy
-  describe("sticky strategy", () => {
-    it("returns current account if available", () => {
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-    });
-
-    it("switches when current is rate-limited", () => {
-      const candidates = [makeCandidate({ index: 0, isRateLimited: true }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(1);
-    });
-
-    it("does not switch when current is unhealthy", () => {
-      // Make account 0 unhealthy
-      for (let i = 0; i < 5; i++) {
-        healthTracker.recordFailure(0);
-      }
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-      expect(result?.cursor).toBe(0);
-    });
-
-    it("keeps current even when cursor points elsewhere", () => {
-      // Make account 0 unhealthy
-      for (let i = 0; i < 5; i++) {
-        healthTracker.recordFailure(0);
-      }
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      // Even with cursor=1, sticky should keep the current account
-      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 1);
-      expect(result?.index).toBe(0);
-      expect(result?.cursor).toBe(1);
-    });
-
-    it("selects first available when no current", () => {
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "sticky", null, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-    });
-  });
-
-  // Round-robin strategy
-  describe("round-robin strategy", () => {
-    it("rotates through accounts", () => {
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 }), makeCandidate({ index: 2 })];
-
-      const r1 = selectAccount(candidates, "round-robin", null, healthTracker, tokenTracker, 0);
-      expect(r1?.index).toBe(0);
-
-      const r2 = selectAccount(candidates, "round-robin", 0, healthTracker, tokenTracker, r1.cursor);
-      expect(r2?.index).toBe(1);
-
-      const r3 = selectAccount(candidates, "round-robin", 1, healthTracker, tokenTracker, r2.cursor);
-      expect(r3?.index).toBe(2);
-
-      // Wraps around
-      const r4 = selectAccount(candidates, "round-robin", 2, healthTracker, tokenTracker, r3.cursor);
-      expect(r4?.index).toBe(0);
-    });
-
-    it("skips rate-limited accounts", () => {
-      const candidates = [
-        makeCandidate({ index: 0, isRateLimited: true }),
-        makeCandidate({ index: 1 }),
-        makeCandidate({ index: 2 }),
-      ];
-      const result = selectAccount(candidates, "round-robin", null, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(1);
-    });
-  });
-
-  // Hybrid strategy
-  describe("hybrid strategy", () => {
-    it("selects the account with highest composite score", () => {
-      const candidates = [
-        makeCandidate({ index: 0, lastUsed: Date.now() }),
-        makeCandidate({ index: 1, lastUsed: Date.now() - 120_000 }), // 2 min ago = more fresh
-      ];
-      // Account 1 should have higher freshness score (120s * 0.1 = 12pt bonus)
-      const result = selectAccount(candidates, "hybrid", null, healthTracker, tokenTracker, 0);
-      // Both have same health and tokens, but account 1 has more freshness
-      expect(result?.index).toBe(1);
-    });
-
-    it("applies stickiness bonus to current account", () => {
-      const candidates = [
-        makeCandidate({ index: 0, lastUsed: Date.now() }),
-        makeCandidate({ index: 1, lastUsed: Date.now() - 1000 }),
-      ];
-      // Account 0 is current — stickiness bonus should keep it
-      const result = selectAccount(candidates, "hybrid", 0, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-    });
-
-    it("falls back to any available when all are unhealthy", () => {
-      // Make all accounts unhealthy
-      for (let i = 0; i < 10; i++) {
-        healthTracker.recordFailure(0);
-        healthTracker.recordFailure(1);
-      }
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "hybrid", null, healthTracker, tokenTracker, 0);
-      // Should fall back to first available
-      expect(result).not.toBeNull();
-    });
-
-    it("switches when advantage exceeds threshold", () => {
-      // Make account 0 very unhealthy
-      for (let i = 0; i < 4; i++) {
-        healthTracker.recordFailure(0);
-      }
-      // Drain account 0's tokens
-      for (let i = 0; i < 50; i++) {
-        tokenTracker.consume(0);
-      }
-
-      const candidates = [makeCandidate({ index: 0, lastUsed: Date.now() }), makeCandidate({ index: 1, lastUsed: 0 })];
-      const result = selectAccount(candidates, "hybrid", 0, healthTracker, tokenTracker, 0);
-      // Account 1 should win despite stickiness bonus because account 0 is very degraded
-      expect(result?.index).toBe(1);
-    });
-  });
-
-  // Single strategy (issue #20)
-  describe("single strategy", () => {
-    it("selects first available account when no current index", () => {
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "single", null, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-    });
-
-    it("stays on the current account when it is available", () => {
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "single", 0, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-      expect(result?.cursor).toBe(0);
-    });
-
-    it("returns null when current is rate-limited (does NOT switch)", () => {
-      const candidates = [makeCandidate({ index: 0, isRateLimited: true }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "single", 0, healthTracker, tokenTracker, 0);
-      // Unlike sticky, single must NOT fall through to account 1.
-      expect(result).toBeNull();
-    });
-
-    it("returns null when the current account is gone (disabled/removed)", () => {
-      const candidates = [makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "single", 0, healthTracker, tokenTracker, 0);
-      expect(result).toBeNull();
-    });
-
-    it("ignores health score and stays on current", () => {
-      for (let i = 0; i < 5; i++) {
-        healthTracker.recordFailure(0);
-      }
-      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(candidates, "single", 0, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-    });
-
-    it("auto-resumes the current account once its rate-limit clears", () => {
-      const limited = [makeCandidate({ index: 0, isRateLimited: true }), makeCandidate({ index: 1 })];
-      expect(selectAccount(limited, "single", 0, healthTracker, tokenTracker, 0)).toBeNull();
-      const cleared = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-      const result = selectAccount(cleared, "single", 0, healthTracker, tokenTracker, 0);
-      expect(result?.index).toBe(0);
-    });
-  });
-
-  // Default/unknown strategy
-  it("falls back to first available for unknown strategy", () => {
-    const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
-    const result = selectAccount(candidates, "unknown", null, healthTracker, tokenTracker, 0);
-    expect(result?.index).toBe(0);
-  });
-});