crosscheck-mcp 0.2.13 → 0.2.15

package/dist/browser-ext.cjs

@@ -472,11 +472,18 @@ var ProviderError = class extends Error {
   status;
   transient;
   retryAfterS;
+  /** True specifically for "the key is fine but this model isn't
+   *  available to this account/project" (see http-errors.ts's
+   *  isModelAccessFailure) — the one failure a model fallback chain can
+   *  actually fix. Distinct from `transient`: this is never worth
+   *  retrying the SAME model, but IS worth trying a different one. */
+  modelAccessFailure;
   constructor(kind, message, opts) {
     super(message);
     this.kind = kind;
     this.status = opts?.status;
     this.transient = opts?.transient ?? defaultTransient(kind);
+    this.modelAccessFailure = opts?.modelAccessFailure ?? false;
     if (opts?.retryAfterS !== void 0) {
       this.retryAfterS = opts.retryAfterS;
     }
@@ -495,8 +502,21 @@ function isCreditsFailure(status, bodyText) {
   }
   return false;
 }
-function httpFailureToProviderError(provider, status, bodyText, retryAfterS) {
+var MODEL_ACCESS_RE = /model_not_found|does not have access to model|does not exist|model[\s_]not[\s_]found|invalid model|unknown model|unsupported model/i;
+function isModelAccessFailure(status, bodyText) {
+  if (status < 400 || status >= 500) return false;
+  return MODEL_ACCESS_RE.test(bodyText);
+}
+function httpFailureToProviderError(provider, status, bodyText, retryAfterS, model) {
   const detail = bodyText.slice(0, 512);
+  if (isModelAccessFailure(status, bodyText)) {
+    const modelRef = model ? `"${model}"` : "the configured model";
+    return new ProviderError(
+      "client",
+      `${provider}: your account/project doesn't have access to ${modelRef} (HTTP ${status}). This is a model-access problem, not a key problem \u2014 your ${provider} API key is fine, ${modelRef} just isn't enabled for this account/project. Fix: run \`crosscheck models set ${provider} <a-model-you-have-access-to>\` (or set ${provider.toUpperCase()}_MODEL in your .env until that's available). Detail: ${detail}`,
+      { status, modelAccessFailure: true }
+    );
+  }
   if (isCreditsFailure(status, bodyText)) {
     return new ProviderError(
       "auth",
@@ -701,6 +721,14 @@ function buildAnthropicRequest(opts) {
   if (system !== void 0) {
     body.system = system;
   }
+  if (isReasoningModel("anthropic", opts.model)) {
+    if (opts.model.toLowerCase().startsWith("claude-fable-5")) {
+      body.thinking = { type: "adaptive" };
+      body.output_config = { effort: "low" };
+    } else {
+      body.thinking = { type: "disabled" };
+    }
+  }
   if (opts.jsonSchema) {
     body.tools = [{
       name: ANTHROPIC_STRUCTURED_TOOL_NAME,
@@ -768,7 +796,12 @@ function parseAnthropicResponse(opts) {
     purpose: opts.purpose
   };
   usage.total_tokens = usage.prompt_tokens + usage.completion_tokens;
-  return { text, usage };
+  const stopReasonRaw = r["stop_reason"];
+  const stopReason = typeof stopReasonRaw === "string" ? stopReasonRaw : void 0;
+  return { text, usage, ...stopReason !== void 0 ? { stopReason } : {} };
+}
+function isEmptyDueToMaxTokens(text, stopReason) {
+  return text.trim() === "" && stopReason === "max_tokens";
 }
 function applyPricing(usage, pricing) {
   const { cost_usd, estimated } = calculateCost(
@@ -786,49 +819,64 @@ function applyPricing(usage, pricing) {
     estimated: usage.estimated || estimated
   };
 }
+var MAX_TOKENS_ESCALATIONS = 2;
+var ESCALATION_MULTIPLIER = 2;
 async function sendAnthropic(args) {
-  const { url, headers, body } = buildAnthropicRequest({
-    model: args.model,
-    apiKey: args.apiKey,
-    messages: args.messages,
-    maxTokens: args.maxTokens,
-    temperature: args.temperature,
-    ...args.jsonSchema ? { jsonSchema: args.jsonSchema } : {}
-  });
   const doFetch = args.fetchImpl ?? globalThis.fetch;
-  const init = {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  };
-  if (args.signal) init.signal = args.signal;
-  const attemptOnce = async () => {
-    let respLike;
-    try {
-      respLike = await doFetch(url, init);
-    } catch (e) {
-      throw new ProviderError("network", `anthropic: fetch failed: ${e.message}`);
-    }
-    const status = respLike.status;
-    if (status >= 200 && status < 300) {
-      let parsed;
+  let maxTokens = args.maxTokens;
+  let result = null;
+  let totalAttempts = 0;
+  for (let escalation = 0; escalation <= MAX_TOKENS_ESCALATIONS; escalation += 1) {
+    const { url, headers, body } = buildAnthropicRequest({
+      model: args.model,
+      apiKey: args.apiKey,
+      messages: args.messages,
+      maxTokens,
+      temperature: args.temperature,
+      ...args.jsonSchema ? { jsonSchema: args.jsonSchema } : {}
+    });
+    const init = {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    };
+    if (args.signal) init.signal = args.signal;
+    let stopReason;
+    const attemptOnce = async () => {
+      let respLike;
       try {
-        parsed = await respLike.json();
+        respLike = await doFetch(url, init);
       } catch (e) {
-        throw new ProviderError("parse", `anthropic: response body not JSON: ${e.message}`);
+        throw new ProviderError("network", `anthropic: fetch failed: ${e.message}`);
       }
-      const { text, usage } = parseAnthropicResponse({
-        resp: parsed,
-        model: args.model,
-        purpose: args.purpose ?? "worker"
-      });
-      return { text, attempts: 1, usage: applyPricing(usage, args.pricing) };
+      const status = respLike.status;
+      if (status >= 200 && status < 300) {
+        let parsed;
+        try {
+          parsed = await respLike.json();
+        } catch (e) {
+          throw new ProviderError("parse", `anthropic: response body not JSON: ${e.message}`);
+        }
+        const { text, usage, stopReason: sr } = parseAnthropicResponse({
+          resp: parsed,
+          model: args.model,
+          purpose: args.purpose ?? "worker"
+        });
+        stopReason = sr;
+        return { text, attempts: 1, usage: applyPricing(usage, args.pricing) };
+      }
+      const bodyText = await respLike.text().catch(() => "");
+      throw httpFailureToProviderError("anthropic", status, bodyText, parseRetryAfter(respLike), args.model);
+    };
+    await acquireRateLimit("anthropic", args.signal ? { signal: args.signal } : void 0);
+    result = await sendWithRetry(attemptOnce, resolveRetryConfig(), args.signal);
+    totalAttempts += result.attempts;
+    if (escalation >= MAX_TOKENS_ESCALATIONS || !isEmptyDueToMaxTokens(result.text, stopReason)) {
+      break;
     }
-    const bodyText = await respLike.text().catch(() => "");
-    throw httpFailureToProviderError("anthropic", status, bodyText, parseRetryAfter(respLike));
-  };
-  await acquireRateLimit("anthropic", args.signal ? { signal: args.signal } : void 0);
-  return sendWithRetry(attemptOnce, resolveRetryConfig(), args.signal);
+    maxTokens *= ESCALATION_MULTIPLIER;
+  }
+  return { ...result, attempts: totalAttempts };
 }
 
 // src/providers/gemini.ts
@@ -1003,7 +1051,7 @@ async function sendGemini(args) {
       return { text, attempts: 1, usage: applyPricing2(usage, args.pricing) };
     }
     const bodyText = await respLike.text().catch(() => "");
-    throw httpFailureToProviderError("gemini", status, bodyText, parseRetryAfter(respLike));
+    throw httpFailureToProviderError("gemini", status, bodyText, parseRetryAfter(respLike), args.model);
   };
   await acquireRateLimit("gemini", args.signal ? { signal: args.signal } : void 0);
   return sendWithRetry(attemptOnce, resolveRetryConfig(), args.signal);
@@ -1176,7 +1224,7 @@ async function sendOpenAICompatible(args) {
       return { text, attempts: 1, usage: applyPricing3(usage, args.pricing) };
     }
     const bodyText = await respLike.text().catch(() => "");
-    throw httpFailureToProviderError(args.provider, status, bodyText, parseRetryAfter(respLike));
+    throw httpFailureToProviderError(args.provider, status, bodyText, parseRetryAfter(respLike), args.model);
   };
   await acquireRateLimit(args.provider, args.signal ? { signal: args.signal } : void 0);
   return sendWithRetry(attemptOnce, resolveRetryConfig(), args.signal);
@@ -1185,7 +1233,10 @@ async function sendOpenAICompatible(args) {
 // src/providers/registry.ts
 var DEFAULT_MODELS = {
   anthropic: "claude-opus-5",
-  openai: "gpt-5.5",
+  // gpt-5.5 is not enabled on every OpenAI account/project (some are still
+  // capped at gpt-5) — gpt-5 is the safer, more broadly available default
+  // until a user/org explicitly opts into 5.5 via `crosscheck models set`.
+  openai: "gpt-5",
   xai: "grok-4-latest",
   mistral: "mistral-large-latest",
   groq: "llama-3.3-70b-versatile",
@@ -1194,12 +1245,31 @@ var DEFAULT_MODELS = {
   kimi: "kimi-k3",
   qwen: "qwen3.8-max"
 };
+var MODEL_ENV_VARS = {
+  anthropic: "ANTHROPIC_MODEL",
+  openai: "OPENAI_MODEL",
+  xai: "XAI_MODEL",
+  mistral: "MISTRAL_MODEL",
+  groq: "GROQ_MODEL",
+  deepseek: "DEEPSEEK_MODEL",
+  gemini: "GEMINI_MODEL",
+  kimi: "KIMI_MODEL",
+  qwen: "QWEN_MODEL"
+};
+function parseFallbackModels(raw) {
+  if (!raw) return [];
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function fallbackModelsFor(env, provider) {
+  const envVar = MODEL_ENV_VARS[provider];
+  return envVar ? parseFallbackModels(env[`${envVar}_FALLBACKS`]) : [];
+}
 function buildProviders(opts) {
   const out = {};
   const anthropicKey = opts.env["ANTHROPIC_API_KEY"];
   if (anthropicKey) {
     const model = opts.env["ANTHROPIC_MODEL"] ?? DEFAULT_MODELS.anthropic;
-    out["anthropic"] = makeAnthropicProvider(model, anthropicKey, opts);
+    out["anthropic"] = makeAnthropicProvider(model, anthropicKey, opts, fallbackModelsFor(opts.env, "anthropic"));
   }
   const openAiCompatSpec = [
     { name: "openai", keyEnv: "OPENAI_API_KEY", modelEnv: "OPENAI_MODEL", defaultModel: DEFAULT_MODELS["openai"] },
@@ -1214,19 +1284,20 @@ function buildProviders(opts) {
     const apiKey = opts.env[s.keyEnv];
     if (!apiKey) continue;
     const model = opts.env[s.modelEnv] ?? s.defaultModel;
-    out[s.name] = makeOpenAICompatibleProvider(s.name, model, apiKey, opts);
+    out[s.name] = makeOpenAICompatibleProvider(s.name, model, apiKey, opts, fallbackModelsFor(opts.env, s.name));
   }
   const geminiKey = opts.env["GEMINI_API_KEY"];
   if (geminiKey) {
     const model = opts.env["GEMINI_MODEL"] ?? DEFAULT_MODELS.gemini;
-    out["gemini"] = makeGeminiProvider(model, geminiKey, opts);
+    out["gemini"] = makeGeminiProvider(model, geminiKey, opts, fallbackModelsFor(opts.env, "gemini"));
   }
   return out;
 }
-function makeAnthropicProvider(model, apiKey, opts) {
+function makeAnthropicProvider(model, apiKey, opts, fallbackModels = []) {
   return {
     name: "anthropic",
     model,
+    fallbackModels,
     send: async (args) => {
       const sendOpts = {
         ...args,
@@ -1239,11 +1310,12 @@ function makeAnthropicProvider(model, apiKey, opts) {
     }
   };
 }
-function makeOpenAICompatibleProvider(name, model, apiKey, opts) {
+function makeOpenAICompatibleProvider(name, model, apiKey, opts, fallbackModels = []) {
   const url = OPENAI_COMPAT_DEFAULT_URLS[name];
   return {
     name,
     model,
+    fallbackModels,
     send: async (args) => {
       const sendOpts = {
         ...args,
@@ -1258,10 +1330,11 @@ function makeOpenAICompatibleProvider(name, model, apiKey, opts) {
     }
   };
 }
-function makeGeminiProvider(model, apiKey, opts) {
+function makeGeminiProvider(model, apiKey, opts, fallbackModels = []) {
   return {
     name: "gemini",
     model,
+    fallbackModels,
     send: async (args) => {
       const sendOpts = {
         ...args,
@@ -1280,7 +1353,7 @@ var import_zod = require("zod");
 
 // src/server-meta.ts
 var SERVER_NAME = "crosscheck-agent";
-var SERVER_VERSION = true ? "0.2.13" : "0.0.0-dev";
+var SERVER_VERSION = true ? "0.2.15" : "0.0.0-dev";
 
 // src/tools/audit.ts
 var import_node_fs4 = require("fs");
@@ -1931,6 +2004,51 @@ function operatorCeiling(purpose, provider) {
   return null;
 }
 
+// src/core/retarget.ts
+function retargetProvider(p, newModel) {
+  if (p.model === newModel) return p;
+  return {
+    name: p.name,
+    model: newModel,
+    send: (args) => p.send({ ...args, modelOverride: newModel })
+  };
+}
+async function loadProviderWeights(storage, names) {
+  const out = {};
+  for (const raw of names) {
+    const name = raw.toLowerCase();
+    if (name in out) continue;
+    const row = await storage.getProviderStats(name);
+    if (!row) {
+      out[name] = 0.5;
+      continue;
+    }
+    const total = row.wins + row.losses + row.abstains;
+    out[name] = total <= 0 ? 0.5 : (row.wins + 0.5 * row.abstains) / total;
+  }
+  return out;
+}
+
+// src/core/model-fallback.ts
+async function sendWithModelFallback(provider, args) {
+  const chain = [provider.model, ...provider.fallbackModels ?? []];
+  let lastErr;
+  for (let i = 0; i < chain.length; i += 1) {
+    const candidate = chain[i];
+    const p = i === 0 ? provider : retargetProvider(provider, candidate);
+    try {
+      const result = await p.send(args);
+      return { result, modelUsed: candidate };
+    } catch (e) {
+      lastErr = e;
+      const isModelAccessFailure2 = e instanceof ProviderError && e.modelAccessFailure;
+      const hasMoreCandidates = i < chain.length - 1;
+      if (!isModelAccessFailure2 || !hasMoreCandidates) throw e;
+    }
+  }
+  throw lastErr;
+}
+
 // src/core/structured.ts
 async function requestStructured(provider, baseMessages, schema, opts) {
   const maxRetries = opts.maxRetries ?? 1;
@@ -2009,7 +2127,7 @@ async function askOne(provider, messages, opts) {
   const ceiling = operatorCeiling(opts.purpose, provider.name);
   if (ceiling !== null && ceiling < maxTokens) maxTokens = ceiling;
   try {
-    const r = await provider.send({
+    const { result: r, modelUsed } = await sendWithModelFallback(provider, {
       messages,
       maxTokens,
       temperature: opts.temperature,
@@ -2022,7 +2140,10 @@ async function askOne(provider, messages, opts) {
     const cpuMs = Math.trunc((cpu.user + cpu.system) / 1e3);
     return {
       provider: provider.name,
-      model: provider.model,
+      // modelUsed reflects whichever model actually answered — the
+      // primary, or a fallback if one was needed. Equivalent to the old
+      // `provider.model` whenever no fallback occurred.
+      model: modelUsed,
       response: r.text,
       attempts: r.attempts,
       usage: r.usage,
@@ -2732,31 +2853,6 @@ function numberOrNull(v) {
 // src/tools/audit.ts
 var import_node_perf_hooks = require("perf_hooks");
 
-// src/core/retarget.ts
-function retargetProvider(p, newModel) {
-  if (p.model === newModel) return p;
-  return {
-    name: p.name,
-    model: newModel,
-    send: (args) => p.send({ ...args, modelOverride: newModel })
-  };
-}
-async function loadProviderWeights(storage, names) {
-  const out = {};
-  for (const raw of names) {
-    const name = raw.toLowerCase();
-    if (name in out) continue;
-    const row = await storage.getProviderStats(name);
-    if (!row) {
-      out[name] = 0.5;
-      continue;
-    }
-    const total = row.wins + row.losses + row.abstains;
-    out[name] = total <= 0 ? 0.5 : (row.wins + 0.5 * row.abstains) / total;
-  }
-  return out;
-}
-
 // src/core/co-reason.ts
 var CO_REASON_MODEL = "gpt-5.6";
 var CO_REASON_PROVIDER = "openai";
@@ -11490,7 +11586,7 @@ var CHECK_INTERVAL_SECONDS = 3 * 24 * 60 * 60;
 var DEFAULT_PACKAGE = "crosscheck-cli";
 var FETCH_TIMEOUT_MS = 3e3;
 function engineVersion() {
-  return true ? "0.2.13" : "0.0.0-dev";
+  return true ? "0.2.15" : "0.0.0-dev";
 }
 function defaultUpdateCachePath() {
   const base = process.env["CROSSCHECK_DATA_DIR"] || import_node_path12.default.join(import_node_os2.default.homedir() || import_node_os2.default.tmpdir(), ".crosscheck");