opencode-auth-load-balancer 0.4.0 → 0.4.1

package/dist/providers/anthropic/constants.d.ts

@@ -83,6 +83,33 @@ export declare const FALLBACK_CLAUDE_CODE_VERSION = "2.1.258";
  * `cch` fingerprint algorithm and the newest version starts 400ing).
  */
 export declare const CLAUDE_CODE_VERSION_ENV = "OPENCODE_AUTH_LB_ANTHROPIC_CLAUDE_CODE_VERSION";
+/**
+ * The structured error code Anthropic answers a version-gated model with:
+ *
+ * ```json
+ * {"type":"error","error":{"type":"invalid_request_error",
+ *  "message":"Claude Code 2.1.278 does not support this model; version 2.1.280 or newer is required.",
+ *  "details":{"error_code":"claude_code_version_too_old"}}}
+ * ```
+ *
+ * Matched as a SUBSTRING of the raw body rather than through a parsed path
+ * (`error.details.error_code`): the envelope's shape is Anthropic's to change,
+ * and this string appearing anywhere in a rejection is both sufficient — no
+ * other error carries it — and immune to a reshuffle that would silently break
+ * a path lookup. See `recoverClaudeCodeVersion` in version.ts.
+ */
+export declare const CLAUDE_CODE_VERSION_GATE_CODE = "claude_code_version_too_old";
+/**
+ * The MINIMUM version that rejection's human-readable message demands.
+ *
+ * Anchored on the `or newer is required` tail rather than the first version in
+ * the string, because the message names TWO: the one we just sent ("Claude
+ * Code 2.1.278 does not support this model") and the one being asked for
+ * ("version 2.1.280 or newer is required"). Capturing the leading one would
+ * adopt the version that just failed — a no-op the recovery would correctly
+ * refuse to retry, i.e. a silent regression to the old stuck behavior.
+ */
+export declare const CLAUDE_CODE_REQUIRED_VERSION_RE: RegExp;
 /**
  * npm dist-tags for the Claude Code CLI — `{"latest":"2.1.258",…}`, ~56 bytes.
  * Deliberately NOT `/@anthropic-ai/claude-code/latest`, which returns the whole

package/dist/providers/anthropic/version.d.ts

@@ -20,6 +20,27 @@ export declare function usageUserAgent(): string;
  * usable answer, so a failure does NOT refresh the TTL).
  */
 export declare function refreshClaudeCodeVersion(now: number): Promise<void>;
+/**
+ * REACTIVE recovery, driven by the gate's own rejection.
+ *
+ * `primeClaudeCodeVersion` resolves once at startup and then trusts the cache
+ * for `CLAUDE_CODE_VERSION_TTL_MS`. A model that launches INSIDE that window is
+ * therefore rejected for as long as the TTL has left to run — up to a full day
+ * of hard failures — even when npm already tags the version Anthropic is asking
+ * for, and even though the rejection itself NAMES that version. No polling
+ * cadence fixes this in general either: Anthropic can gate a model before npm
+ * tags the release, which is why the env pin exists as a manual escape hatch.
+ *
+ * So learn from the rejection instead. Adopt the minimum it demands, then ask
+ * npm for the real `latest` in the same breath — the minimum only clears the
+ * model that just failed, whereas `latest` is what the NEXT launch will want.
+ *
+ * Returns whether the reported version actually MOVED, which is precisely the
+ * condition under which a retry can succeed; the caller spends a second
+ * round-trip on true and passes the rejection through untouched on false.
+ * `res` is consumed, so callers that still need the body must pass a clone.
+ */
+export declare function recoverClaudeCodeVersion(res: Response, now: number): Promise<boolean>;
 /**
  * Startup hook. Awaits only the LOCAL cache read — cheap, and enough to have
  * the right version in hand before the loader returns the fetch — then leaves

package/dist/providers/types.d.ts

@@ -136,4 +136,24 @@ export interface ProviderAdapter {
      * downgraded body. null = treat the 429 as a normal account rotation.
      */
     planReactiveFallback?(res: Response, body: string, now: number, models: readonly string[]): ReactiveModelFallback | null;
+    /**
+     * REACTIVE recovery from a CLIENT-VERSION gate: a provider may reject an
+     * otherwise-valid request until the plugin claims to be a newer client
+     * (Anthropic answers a too-new model with 400 `claude_code_version_too_old`,
+     * naming the minimum it wants). Such a status classifies as `ok` — the fetch
+     * loop is one statement away from handing it to the caller — so this is the
+     * last point at which it can become a recoverable event instead of a failed
+     * turn.
+     *
+     * Return true ONLY when the version the adapter will now report actually
+     * changed: the fetch loop reads that as "a retry can succeed" and restarts
+     * the request once. Returning true without a change would buy a second,
+     * byte-identical round-trip and the same rejection.
+     *
+     * `res` is a CLONE the implementation may consume freely; the original is
+     * still returned to the caller when this resolves false. Absent on providers
+     * with no such gate (OpenAI) — the fetch loop treats that as "nothing to
+     * recover".
+     */
+    recoverClientVersion?(res: Response, now: number): Promise<boolean>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-auth-load-balancer",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Load-balance opencode requests across multiple Anthropic (Claude) and OpenAI (Codex) OAuth accounts, weighted primarily by weekly usage with drain-before-reset scheduling.",
   "type": "module",
   "license": "MIT",