@lawaty/lacode 2.3.0-beta.5 → 2.3.0-beta.6

package/dist/index.js

@@ -45,9 +45,10 @@ var PROVIDER_DEGRADED_MIN_MODELS = 2;
 var TRANSIENT_DEGRADATION_REASONS = /^(?:no answer|no-answer|hang|timeout|timed out|endpoint-unavailable|provider-degraded|empty response|network|server)$/i;
 var FLAT_OUTAGE_REASONS = /* @__PURE__ */ new Set([UNAVAILABLE_REASON, PROVIDER_DEGRADED_REASON]);
 var MAX_WEIGHT = 100;
+var MAX_CEILING = MAX_WEIGHT;
 var MIN_SLOT_CONTEXT = 1e5;
 var MIN_SLOT_TPM = 2e4;
-var slotCeiling = (slot) => slot.weight;
+var slotCeiling = (slot) => slot.ceiling ?? slot.weight;
 var slotBucket = (slot) => slot.bucket ?? slot.model;
 var NOTIFY_DEFAULT_ON_PROVIDERS = /* @__PURE__ */ new Set(["opencode", "opencode-go"]);
 var notifyDefault = (model) => {
@@ -67,7 +68,7 @@ var QUOTA_COOLDOWN_BASE_MS = 15 * 60 * 1e3;
 var QUOTA_COOLDOWN_MAX_MS = 6 * 60 * 60 * 1e3;
 var STRIKE_DECAY_MS = 30 * 60 * 1e3;
 var STATED_COOLDOWN_MAX_MS = QUOTA_COOLDOWN_MAX_MS;
-var isQuotaReason = (reason) => /quota|limit|rate|too-many|overloaded|429/i.test(reason);
+var isQuotaReason = (reason) => /quota|limit|rate|too-many|overloaded|budget|429/i.test(reason);
 var MODEL_MISSING_REASON = "model-missing";
 var MODEL_MISSING_COOLDOWN_MS = QUOTA_COOLDOWN_MAX_MS;
 var AUTH_FAILURE_REASON = "auth-failed";
@@ -76,6 +77,16 @@ var MODEL_MISSING_PATTERN = /model\s+(?:not\s+found|does\s+not\s+exist|is\s+not\
 var isModelMissingText = (text) => MODEL_MISSING_PATTERN.test(text);
 var AUTH_FAILURE_PATTERN = /\b401\b|\b403\b|unauthori[sz]ed|not\s+authori[sz]ed|invalid[\s_-]+(?:api[\s_-]?(?:key|token)|token|credential|bearer)|api[\s_-]?key\s+(?:is\s+)?(?:invalid|missing|expired|not\s+valid)|authentication\s+(?:failed|error|required)|incorrect[\s_-]+api[\s_-]?key/i;
 var isAuthFailureText = (text) => AUTH_FAILURE_PATTERN.test(text);
+var ABORT_PATTERN = /MessageAbortedError|"name"\s*:\s*"[^"]*Abort/i;
+var isAbortText = (text) => ABORT_PATTERN.test(text);
+var INVALID_REQUEST_REASON = "invalid-request";
+var INVALID_REQUEST_COOLDOWN_MS = MODEL_MISSING_COOLDOWN_MS;
+var UNSUPPORTED_PARAMETER_PATTERN = /not\s+a\s+supported\s+value|unsupported\s+(?:value|parameter|field)|(?:invalid|unknown)\s+(?:value|parameter)\s+for|is\s+not\s+supported/i;
+var isUnsupportedParameterText = (text) => UNSUPPORTED_PARAMETER_PATTERN.test(text);
+var TRANSIENT_UPSTREAM_REASON = "upstream-transient";
+var TRANSIENT_UPSTREAM_COOLDOWN_MS = 60 * 1e3;
+var TRANSIENT_UPSTREAM_PATTERN = /reasoning_display/i;
+var isTransientUpstreamText = (text) => TRANSIENT_UPSTREAM_PATTERN.test(text);
 var BASES = ["explore", "implement", "context"];
 var LEARNED_TPM_FILE = "learned-tpm.json";
 var PRESETS_DIR = join2(PACKAGE_ROOT, "presets");
@@ -102,64 +113,100 @@ var coerceNotify = (raw, at, model, problems) => {
   problems.push(`${at} (${model}): notify must be a boolean or one of on/off, got ${JSON.stringify(raw)}; keeping the provider default`);
   return notifyDefault(model);
 };
+var FALLBACK_MARKER = /^(?:#\s*-*\s*fallback(?:\s+slots)?\s*-*|\[fallback\])$/i;
+var isFallbackMarker = (line) => FALLBACK_MARKER.test(String(line).trim());
+function parseSlotEntry(entry, at, problems) {
+  const model = typeof entry?.model === "string" ? entry.model.trim() : "";
+  if (!model.includes("/")) {
+    problems.push(`${at}: model must be written provider/model-id, got "${model}"`);
+    return void 0;
+  }
+  const weight = readWeight(entry, at, model, problems);
+  const ceiling = readCeiling(entry, weight, at, model, problems);
+  const rawBucket = entry?.bucket;
+  const bucket = typeof rawBucket === "string" ? rawBucket.trim() : void 0;
+  if (rawBucket !== void 0 && !bucket) {
+    problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
+  }
+  const notify = coerceNotify(entry.notify, at, model, problems);
+  const rawContext = entry?.context;
+  let context;
+  if (rawContext !== void 0) {
+    const parsedContext = typeof rawContext === "number" ? rawContext : Number(rawContext);
+    if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
+    else problems.push(`${at} (${model}): context must be a positive number, got ${JSON.stringify(rawContext)}; ignoring it`);
+  }
+  if (context !== void 0 && context < MIN_SLOT_CONTEXT) {
+    problems.push(`${at} (${model}): context ${context} is below the ${MIN_SLOT_CONTEXT}-token minimum; dropping the slot`);
+    return void 0;
+  }
+  const rawTpm = entry?.tpm;
+  let tpm;
+  if (rawTpm !== void 0) {
+    const parsedTpm = typeof rawTpm === "number" ? rawTpm : Number(rawTpm);
+    if (Number.isFinite(parsedTpm) && parsedTpm > 0) tpm = parsedTpm;
+    else problems.push(`${at} (${model}): tpm must be a positive number, got ${JSON.stringify(rawTpm)}; ignoring it`);
+  }
+  if (tpm !== void 0 && tpm < MIN_SLOT_TPM) {
+    problems.push(`${at} (${model}): tpm ${tpm} is below the ${MIN_SLOT_TPM}-token/minute minimum; dropping the slot`);
+    return void 0;
+  }
+  return { index: 0, model, weight, ...ceiling === void 0 ? {} : { ceiling }, ...bucket ? { bucket } : {}, notify, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } };
+}
 function parseSlots(parsed, origin) {
   const problems = [];
-  const entries = parsed?.slots;
-  if (!Array.isArray(entries) || entries.length === 0) {
+  const primaryEntries = parsed?.slots;
+  const fallbackEntries = parsed?.fallbackSlots;
+  if ((!Array.isArray(primaryEntries) || primaryEntries.length === 0) && (!Array.isArray(fallbackEntries) || fallbackEntries.length === 0)) {
     return { slots: FALLBACK_SLOTS, problems: [`${origin} has no non-empty "slots" array; using built-in defaults`] };
   }
-  const slots = [];
-  entries.forEach((entry, i) => {
-    const model = typeof entry?.model === "string" ? entry.model.trim() : "";
-    const at = `slot ${i + 1}`;
-    if (!model.includes("/")) return problems.push(`${at}: model must be written provider/model-id, got "${model}"`);
-    const weight = readWeight(entry, at, model, problems);
-    const rawBucket = entry?.bucket;
-    const bucket = typeof rawBucket === "string" ? rawBucket.trim() : void 0;
-    if (rawBucket !== void 0 && !bucket) {
-      problems.push(`${at} (${model}): bucket must be a non-empty name; using the model id`);
-    }
-    const notify = coerceNotify(entry.notify, at, model, problems);
-    const rawContext = entry?.context;
-    let context;
-    if (rawContext !== void 0) {
-      const parsedContext = typeof rawContext === "number" ? rawContext : Number(rawContext);
-      if (Number.isFinite(parsedContext) && parsedContext > 0) context = parsedContext;
-      else problems.push(`${at} (${model}): context must be a positive number, got ${JSON.stringify(rawContext)}; ignoring it`);
-    }
-    if (context !== void 0 && context < MIN_SLOT_CONTEXT) {
-      problems.push(`${at} (${model}): context ${context} is below the ${MIN_SLOT_CONTEXT}-token minimum; dropping the slot`);
-      return;
-    }
-    const rawTpm = entry?.tpm;
-    let tpm;
-    if (rawTpm !== void 0) {
-      const parsedTpm = typeof rawTpm === "number" ? rawTpm : Number(rawTpm);
-      if (Number.isFinite(parsedTpm) && parsedTpm > 0) tpm = parsedTpm;
-      else problems.push(`${at} (${model}): tpm must be a positive number, got ${JSON.stringify(rawTpm)}; ignoring it`);
-    }
-    if (tpm !== void 0 && tpm < MIN_SLOT_TPM) {
-      problems.push(`${at} (${model}): tpm ${tpm} is below the ${MIN_SLOT_TPM}-token/minute minimum; dropping the slot`);
-      return;
+  const parseList = (list, fallback2) => {
+    if (!Array.isArray(list)) return [];
+    const out = [];
+    list.forEach((entry, i) => {
+      const slot = parseSlotEntry(entry, `${fallback2 ? "fallback slot" : "slot"} ${i + 1}`, problems);
+      if (slot) out.push({ ...slot, ...fallback2 ? { fallback: true } : {} });
+    });
+    return out;
+  };
+  const primary = parseList(primaryEntries, false);
+  let fallback = parseList(fallbackEntries, true);
+  const primaryBuckets = new Set(primary.map((slot) => slotBucket(slot)));
+  const primaryModels = new Set(primary.map((slot) => slot.model));
+  fallback = fallback.filter((slot) => {
+    const shared = primaryModels.has(slot.model) || primaryBuckets.has(slotBucket(slot));
+    if (shared) {
+      problems.push(
+        `fallback slot (${slot.model}): shares a limit window with the primary pool (${slotBucket(slot)}); dropping it`
+      );
+      return false;
     }
-    slots.push({ index: slots.length + 1, model, weight, ...bucket ? { bucket } : {}, notify, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } });
+    return true;
   });
+  const slots = [...primary, ...fallback].map((slot, i) => ({ ...slot, index: i + 1 }));
   if (slots.length > SLOTS_WARN_AT) {
     problems.push(`${origin}: ${slots.length} slots is unusually large, but every entry is kept (the pool has no slot cap)`);
   }
-  if (slots.length === 0) {
-    problems.push(`${origin} yielded no usable slot; using built-in defaults`);
+  if (primary.length === 0) {
+    problems.push(`${origin} yielded no usable primary slot; using built-in defaults`);
     return { slots: FALLBACK_SLOTS, problems };
   }
   return { slots, problems };
 }
 function parseTextSlots(text, origin) {
   const entries = [];
+  const fallbackEntries = [];
+  let section = "primary";
   for (const raw of text.split(/\r?\n/)) {
+    if (isFallbackMarker(raw)) {
+      section = "fallback";
+      continue;
+    }
     const line = raw.split("#")[0].trim();
     if (!line) continue;
     const [model, ...rest] = line.split(/\s+/);
     let weight;
+    let ceiling;
     let bucket;
     let notify;
     let context;
@@ -169,6 +216,13 @@ function parseTextSlots(text, origin) {
         if (notify === void 0) notify = token.slice("notify:".length);
         continue;
       }
+      if (token.startsWith("ceil:")) {
+        if (ceiling === void 0) {
+          const parsedCeiling = Number(token.slice("ceil:".length));
+          if (Number.isFinite(parsedCeiling) && parsedCeiling > 0) ceiling = parsedCeiling;
+        }
+        continue;
+      }
       if (token.startsWith("c:")) {
         if (context === void 0) {
           const parsedContext = Number(token.slice(2));
@@ -189,9 +243,11 @@ function parseTextSlots(text, origin) {
         weight = token;
       }
     }
-    entries.push({ model, ...weight === void 0 ? {} : { weight }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify }, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } });
+    const entry = { model, ...weight === void 0 ? {} : { weight }, ...ceiling === void 0 ? {} : { ceiling }, ...bucket === void 0 ? {} : { bucket }, ...notify === void 0 ? {} : { notify }, ...context === void 0 ? {} : { context }, ...tpm === void 0 ? {} : { tpm } };
+    if (section === "fallback") fallbackEntries.push(entry);
+    else entries.push(entry);
   }
-  return parseSlots({ slots: entries }, origin);
+  return parseSlots({ slots: entries, ...fallbackEntries.length > 0 ? { fallbackSlots: fallbackEntries } : {} }, origin);
 }
 function parseSlotText(text, origin) {
   if (text.trimStart().startsWith("{")) {
@@ -296,6 +352,20 @@ function readWeight(entry, at, model, problems) {
   }
   return weight;
 }
+function readCeiling(entry, weight, at, model, problems) {
+  const raw = entry?.ceiling;
+  if (raw === void 0) return void 0;
+  const ceiling = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isFinite(ceiling) || ceiling <= 0 || ceiling > MAX_CEILING) {
+    problems.push(`${at} (${model}): ceiling must be a number in (0, ${MAX_CEILING}], got ${JSON.stringify(raw)}; using the weight`);
+    return void 0;
+  }
+  if (ceiling < weight) {
+    problems.push(`${at} (${model}): ceiling ${ceiling} is below weight ${weight}; using the weight as the ceiling`);
+    return void 0;
+  }
+  return Math.floor(ceiling);
+}
 var UNAVAILABLE_PATTERN = /endpoint\s+is\s+unavailable/i;
 var LIMIT_PATTERNS = [
   /rate[\s_-]?limit/i,
@@ -303,6 +373,7 @@ var LIMIT_PATTERNS = [
   /too many requests/i,
   /\b429\b/,
   /quota/i,
+  /budget\s+exhausted|api\s+budget/i,
   /freelimiterror/i,
   /overloaded/i,
   UNAVAILABLE_PATTERN
@@ -346,7 +417,7 @@ function parseRateLimitHeaders(headers) {
   }
   return void 0;
 }
-var LIMIT_REASON_PATTERN = /rate[\s_-]?limit|usage limit|too many requests|quota|freelimiterror|overloaded|limits?[\s_-]?(?:reached|exceeded)/i;
+var LIMIT_REASON_PATTERN = /rate[\s_-]?limit|usage limit|too many requests|quota|budget\s+exhausted|freelimiterror|overloaded|limits?[\s_-]?(?:reached|exceeded)/i;
 var isLimitText = (text) => LIMIT_PATTERNS.some((re) => re.test(text)) || LIMIT_REACHED_PATTERN.test(text) && !CONTEXT_LIMIT_PATTERN.test(text);
 var limitReason = (text) => {
   if (!isLimitText(text)) return void 0;
@@ -436,7 +507,7 @@ function ensureSlots(s, onWarn) {
   for (const problem of problems) onWarn(problem);
   return slots;
 }
-var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}:${slot.tpm ?? ""}`).join("|")}`;
+var slotSignature = (origin, slots) => `${origin}\0${slots.map((slot) => `${slot.index}:${slot.model}:${slot.weight}:${slot.ceiling ?? ""}:${slot.bucket ?? ""}:${slotNotify(slot) ? "1" : "0"}:${slot.tpm ?? ""}:${slot.fallback ? "f" : "p"}`).join("|")}`;
 function reloadSlots(s, onWarn) {
   const { slots, problems, origin } = resolveModels({ models: s.inlineModels, modelsFile: s.modelsFile });
   const effective = applyLearnedTpm(s, slots, onWarn);
@@ -850,52 +921,54 @@ function snapshot(s) {
 }
 var loadOf = (counts, slot) => counts.get(slot) ?? 0;
 var underCeiling = (slot, counts) => loadOf(counts, slot.index) < slotCeiling(slot);
+var fillPassIndex = (slot, counts) => Math.floor(loadOf(counts, slot.index) / Math.max(1, slot.weight));
+var pickByPass = (group, counts, prefer) => {
+  const open = group.filter((slot) => underCeiling(slot, counts));
+  if (open.length === 0) return void 0;
+  const lowest = Math.min(...open.map((slot) => fillPassIndex(slot, counts)));
+  const atPass = open.filter((slot) => fillPassIndex(slot, counts) === lowest);
+  return prefer ? atPass.reduce(prefer, atPass[0]) : atPass[0];
+};
 function pickSlot(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
-  const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const primary = slots.filter((slot) => !slot.fallback);
+  const fallback = slots.filter((slot) => slot.fallback);
+  const usablePrimary = primary.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const usable = usablePrimary.length > 0 ? usablePrimary : fallback.filter((slot) => isAvailable(s, slot.model, snap.cooling));
   if (usable.length === 0) return void 0;
   const effective = (slot) => Math.min(slot.context ?? Number.POSITIVE_INFINITY, slot.tpm ?? Number.POSITIVE_INFINITY);
+  const leastLoaded = (best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best;
   if (neededContext === void 0) {
-    for (const slot of usable) {
-      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
-    }
-    return usable.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, usable[0]);
+    return pickByPass(usable, snap.counts) ?? usable.reduce(leastLoaded, usable[0]);
   }
   const adequate = usable.filter((slot) => effective(slot) >= neededContext);
   const adequateKnown = adequate.filter((slot) => Number.isFinite(effective(slot)));
   const candidates = adequate.length > 0 ? adequate : usable;
+  const smallest = (best, slot) => Number.isFinite(effective(slot)) && effective(slot) < effective(best) ? slot : best;
   if (adequateKnown.length === 0) {
     const known = usable.filter((slot) => Number.isFinite(effective(slot)));
     if (known.length > 0) {
       const largest = Math.max(...known.map((slot) => effective(slot)));
       const largestSlots = known.filter((slot) => effective(slot) === largest);
-      for (const slot of largestSlots) {
-        if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
-      }
-      return largestSlots.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, largestSlots[0]);
-    }
-    for (const slot of candidates) {
-      if (loadOf(snap.counts, slot.index) < slot.weight) return slot;
+      return pickByPass(largestSlots, snap.counts) ?? largestSlots.reduce(leastLoaded, largestSlots[0]);
     }
-    return candidates.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, candidates[0]);
+    return pickByPass(candidates, snap.counts) ?? candidates.reduce(leastLoaded, candidates[0]);
   }
-  const underWeight = candidates.filter((slot) => loadOf(snap.counts, slot.index) < slot.weight);
-  if (underWeight.length > 0) {
-    const known = underWeight.filter((slot) => Number.isFinite(effective(slot)));
-    if (known.length === 0) return underWeight[0];
-    return known.reduce((best, slot) => effective(slot) < effective(best) ? slot : best, known[0]);
-  }
-  return candidates.reduce((best, slot) => loadOf(snap.counts, slot.index) < loadOf(snap.counts, best.index) ? slot : best, candidates[0]);
+  return pickByPass(candidates, snap.counts, smallest) ?? candidates.reduce(leastLoaded, candidates[0]);
 }
 function poolPass(s, snap, neededContext) {
   const slots = s.slots.length > 0 ? s.slots : FALLBACK_SLOTS;
-  const usable = slots.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const primary = slots.filter((slot) => !slot.fallback);
+  const fallback = slots.filter((slot) => slot.fallback);
+  const usablePrimary = primary.filter((slot) => isAvailable(s, slot.model, snap.cooling));
+  const usable = usablePrimary.length > 0 ? usablePrimary : fallback.filter((slot) => isAvailable(s, slot.model, snap.cooling));
   if (usable.length === 0) return "none";
   const effective = (slot) => Math.min(slot.context ?? Number.POSITIVE_INFINITY, slot.tpm ?? Number.POSITIVE_INFINITY);
   const candidates = neededContext === void 0 ? usable : usable.filter((slot) => effective(slot) >= neededContext);
   const pool = candidates.length > 0 ? candidates : usable;
-  if (pool.some((slot) => loadOf(snap.counts, slot.index) < slot.weight)) return 1;
-  return "overflow";
+  const open = pool.filter((slot) => underCeiling(slot, snap.counts));
+  if (open.length === 0) return "overflow";
+  return Math.min(...open.map((slot) => fillPassIndex(slot, snap.counts))) + 1;
 }
 function agentFor(base, slot) {
   return `${base}-${slot}`;
@@ -2167,7 +2240,7 @@ Follow the rules for the file in your system prompt, then report what you change
 Print one PASS/FAIL line per check below, with the exact fix for any FAIL.
 
 1. Pool status \u2014 call the \`pool_status\` tool. Report the slot list, each
-   slot's load against its budget (its weight), and which models
+   slot's load against its ceiling, and which models
    are cooling.
 
 2. OmniRoute configured \u2014 inspect the \`@lawaty/lacode\` plugin options in the
@@ -2203,9 +2276,11 @@ The pool is ONE global slot table shared by every pooled base (explore, implemen
 1. Establish the baseline. Read \`${USER_MODELS_TXT}\`. If it is absent, the pool is resolving from the bundled preset \`presets/free-tier.json\`; read that file to learn what is in effect. Call the \`pool_status\` tool only if you need live load or cooldown state.
 
 2. Resolve the instruction above into a target slot table. These are the rules the loader enforces \u2014 never write a file that breaks one:
-   - one slot per line: \`<provider>/<model-id>  [weight]\`
+   - one slot per line: \`<provider>/<model-id>  [weight]  [ceil:<max-parallel>]  [c:<context>]  [b:<bucket>]\`
    - any number of slots; a model may appear on more than one line, and each line is its own slot with its own budget
-   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's active-session budget \u2014 how many concurrent sessions it may hold. The pool's total capacity is the sum of the weights. NOT a priority; pick order follows line order.
+   - weight is optional (default 1) and must be a number in (0, ${MAX_WEIGHT}]. It is the slot's per-pass budget \u2014 how many concurrent sessions one pass may add. The pool's total capacity is the sum of the ceilings (which equals the sum of the weights when no ceiling is set). NOT a priority; pick order follows line order.
+   - \`ceil:<max-parallel>\` is optional and is the slot's hard concurrency cap (its max parallel sessions). It must be at least the weight; later passes deepen a slot toward it after every slot has had its weight. Absent means the ceiling equals the weight (one pass).
+   - a line that is exactly \`# --- fallback ---\` starts the fallback section. Keep it and the slots below it when rewriting the file: those slots are used only when no primary slot is usable, and each must not share a bucket or model with the primary.
    - \`#\` starts a comment (whole-line or trailing); blank lines are ignored.
    If the instruction names a model ambiguously, stop and ask rather than guessing.
 
@@ -3902,6 +3977,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           const auth2 = isAuthFailureText(haystack2) || status2 === 401 || status2 === 403;
           const limited2 = isLimitText(haystack2) || status2 === 429;
           const outage = isUnavailableText(haystack2);
+          const transientUpstream2 = status2 === 400 && isTransientUpstreamText(haystack2) && !auth2 && !limited2 && !outage;
+          const unsupported2 = status2 === 400 && error?.data?.isRetryable === false && isUnsupportedParameterText(haystack2) && !transientUpstream2 && !auth2 && !limited2 && !outage;
           if (missing2) {
             const unbound = !own && sessionID ? [...s.own.entries()].find(([, claim]) => !claim.g && claim.s === sessionID && haystack2.includes(claim.m)) : void 0;
             const target = own ?? (unbound ? { key: unbound[0], claim: unbound[1] } : void 0);
@@ -3927,6 +4004,30 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
             }
             return;
           }
+          if (transientUpstream2) {
+            if (own) {
+              const transient = coolUnavailable(s, own.claim.m, TRANSIENT_UPSTREAM_COOLDOWN_MS, TRANSIENT_UPSTREAM_REASON);
+              recordFailure(s, {
+                ts: Date.now(),
+                source: "observed",
+                base: own.claim.v,
+                slot: own.claim.k,
+                model: own.claim.m,
+                session: sessionID,
+                reason: TRANSIENT_UPSTREAM_REASON,
+                elapsedMs: Date.now() - own.claim.t,
+                released: true,
+                detail: haystack2.slice(0, 400)
+              });
+              release(s, own.key);
+              await log(
+                "warn",
+                transient ? `cooling ${own.claim.m} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${TRANSIENT_UPSTREAM_REASON}) after a flaky upstream error` : `released ${own.claim.v} claim on ${own.claim.m} after a flaky upstream error`,
+                { base: own.claim.v, model: own.claim.m, slot: own.claim.k, session: sessionID }
+              );
+            }
+            return;
+          }
           const isTpm2 = isRequestTooLargeText(haystack2);
           const statedLimit2 = isTpm2 ? parseStatedTokenLimit(haystack2) : void 0;
           const headers2 = error?.data?.responseHeaders;
@@ -3953,23 +4054,40 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           if (!limited2 && !outage && !auth2) {
             if (own) {
               const detail = haystack2.slice(0, 400);
-              recordFailure(s, {
-                ts: Date.now(),
-                source: "observed",
-                base: own.claim.v,
-                slot: own.claim.k,
-                model: own.claim.m,
-                session: sessionID,
-                reason: "provider error",
-                elapsedMs: Date.now() - own.claim.t,
-                released: true,
-                detail
-              });
-              if (!observedErrors.has(own.key)) {
-                observedErrors.set(own.key, { reason: "provider error", detail });
-                if (observedErrors.size > 32) {
-                  const oldest = observedErrors.keys().next().value;
-                  if (oldest !== void 0) observedErrors.delete(oldest);
+              const aborted = isAbortText(haystack2);
+              const reason2 = unsupported2 ? INVALID_REQUEST_REASON : "provider error";
+              if (!aborted) {
+                recordFailure(s, {
+                  ts: Date.now(),
+                  source: "observed",
+                  base: own.claim.v,
+                  slot: own.claim.k,
+                  model: own.claim.m,
+                  session: sessionID,
+                  reason: reason2,
+                  elapsedMs: Date.now() - own.claim.t,
+                  released: true,
+                  detail
+                });
+                if (!observedErrors.has(own.key)) {
+                  observedErrors.set(own.key, { reason: reason2, detail });
+                  if (observedErrors.size > 32) {
+                    const oldest = observedErrors.keys().next().value;
+                    if (oldest !== void 0) observedErrors.delete(oldest);
+                  }
+                }
+                const strike2 = recordStrike(
+                  s,
+                  own.claim.m,
+                  reason2,
+                  unsupported2 ? INVALID_REQUEST_COOLDOWN_MS : void 0
+                );
+                if (strike2) {
+                  await log(
+                    "warn",
+                    `bench ${own.claim.m} (${reason2}, strike ${strike2.strikes}, ${Math.round((strike2.until - Date.now()) / 1e3)}s) after a terminal session error`,
+                    { model: own.claim.m, slot: own.claim.k, session: sessionID, reason: detail }
+                  );
                 }
               }
               release(s, own.key);
@@ -4094,6 +4212,8 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         const gateway5xx = status !== void 0 && status >= 500 && status <= 599;
         const transientGateway = gateway5xx || isTransientGatewayText(haystack);
         const missing = isModelMissingText(haystack);
+        const transientUpstream = status === 400 && isTransientUpstreamText(haystack) && !auth && !limited && !transientGateway;
+        const unsupported = status === 400 && info.error.data?.isRetryable === false && isUnsupportedParameterText(haystack) && !transientUpstream && !auth && !limited && !transientGateway;
         const model = `${info.providerID ?? "?"}/${info.modelID ?? "?"}`;
         const ownMsg = claimFor(info.sessionID);
         const isTpm = isRequestTooLargeText(haystack);
@@ -4120,24 +4240,36 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
         if (!limited && !transientGateway && !auth && !missing) {
           const ownMsgUnclassified = ownMsg;
           if (ownMsgUnclassified) {
-            recordFailure(s, {
-              ts: Date.now(),
-              source: "observed",
-              base: ownMsgUnclassified.claim.v,
-              slot: ownMsgUnclassified.claim.k,
-              model: ownMsgUnclassified.claim.m,
-              session: info.sessionID,
-              reason: "provider error",
-              elapsedMs: Date.now() - ownMsgUnclassified.claim.t,
-              released: false,
-              detail: haystack.slice(0, 400)
-            });
-            if (!observedErrors.has(ownMsgUnclassified.key)) {
-              observedErrors.set(ownMsgUnclassified.key, { reason: "provider error", detail: haystack.slice(0, 400) });
-              if (observedErrors.size > 32) {
-                const oldest = observedErrors.keys().next().value;
-                if (oldest !== void 0) observedErrors.delete(oldest);
+            const aborted = isAbortText(haystack);
+            if (!aborted) {
+              recordFailure(s, {
+                ts: Date.now(),
+                source: "observed",
+                base: ownMsgUnclassified.claim.v,
+                slot: ownMsgUnclassified.claim.k,
+                model: ownMsgUnclassified.claim.m,
+                session: info.sessionID,
+                reason: "provider error",
+                elapsedMs: Date.now() - ownMsgUnclassified.claim.t,
+                released: true,
+                detail: haystack.slice(0, 400)
+              });
+              if (!observedErrors.has(ownMsgUnclassified.key)) {
+                observedErrors.set(ownMsgUnclassified.key, { reason: "provider error", detail: haystack.slice(0, 400) });
+                if (observedErrors.size > 32) {
+                  const oldest = observedErrors.keys().next().value;
+                  if (oldest !== void 0) observedErrors.delete(oldest);
+                }
+              }
+              const strike2 = recordStrike(s, ownMsgUnclassified.claim.m, "provider error");
+              if (strike2) {
+                await log(
+                  "warn",
+                  `bench ${ownMsgUnclassified.claim.m} (provider error, strike ${strike2.strikes}) after an unclassified terminal error`,
+                  { model: ownMsgUnclassified.claim.m, slot: ownMsgUnclassified.claim.k, session: info.sessionID, reason: haystack.slice(0, 400) }
+                );
               }
+              release(s, ownMsgUnclassified.key);
             }
           }
           return;
@@ -4170,6 +4302,39 @@ var agentPoolHooks = (async ({ client, serverUrl, directory }, options) => {
           }
           return;
         }
+        if (unsupported) {
+          const ownUnsupported = ownMsg;
+          if (ownUnsupported) {
+            const strike2 = recordStrike(s, ownUnsupported.claim.m, INVALID_REQUEST_REASON, INVALID_REQUEST_COOLDOWN_MS);
+            if (strike2) {
+              await log(
+                "warn",
+                `bench ${ownUnsupported.claim.m} (${INVALID_REQUEST_REASON}, ${Math.round((strike2.until - Date.now()) / 1e3)}s) after a non-retryable unsupported-parameter error`,
+                { model: ownUnsupported.claim.m, slot: ownUnsupported.claim.k, session: info.sessionID, reason: haystack.slice(0, 400) }
+              );
+            }
+            recordFailure(s, {
+              ts: Date.now(),
+              source: "observed",
+              base: ownUnsupported.claim.v,
+              slot: ownUnsupported.claim.k,
+              model: ownUnsupported.claim.m,
+              session: info.sessionID,
+              reason: INVALID_REQUEST_REASON,
+              elapsedMs: Date.now() - ownUnsupported.claim.t,
+              released: true,
+              detail: haystack.slice(0, 400)
+            });
+            release(s, ownUnsupported.key);
+            await log("warn", `released ${ownUnsupported.claim.v} claim on ${ownUnsupported.claim.m} after an unsupported-parameter error`, {
+              base: ownUnsupported.claim.v,
+              model: ownUnsupported.claim.m,
+              slot: ownUnsupported.claim.k,
+              session: info.sessionID
+            });
+          }
+          return;
+        }
         if (isUnavailableText(haystack) || !limited && !auth && transientGateway) {
           const transient = coolUnavailable(s, model);
           if (transient) await log("warn", `cooling ${model} for ${Math.round((transient.until - Date.now()) / 1e3)}s (${transient.reason})`);
@@ -4326,8 +4491,11 @@ ${detail}` : detail;
             ].filter(Boolean);
             const marker = next && slot.index === next.index ? " <- next" : "";
             const load = entry?.total ?? 0;
+            const ceiling = slotCeiling(slot);
             const atCeiling = !underCeiling(slot, snap.counts);
-            return `  slot ${slot.index} w${slot.weight}  ${slot.model}  load=${load}/${slotCeiling(slot)}${atCeiling ? " FULL" : ""}${marker}  [${users}${notes.length ? "; " + notes.join("; ") : ""}]`;
+            const cap = ceiling === slot.weight ? `w${slot.weight}` : `w${slot.weight} c${ceiling}`;
+            const tier = slot.fallback ? " [fallback]" : "";
+            return `  slot ${slot.index} ${cap}  ${slot.model}${tier}  load=${load}/${ceiling}${atCeiling ? " FULL" : ""}${marker}  [${users}${notes.length ? "; " + notes.join("; ") : ""}]`;
           };
           const total = [...snap.counts.values()].reduce((sum, n) => sum + n, 0);
           const coolingNow = [...snap.cooling.entries()].filter(([, st]) => st.until > now);
@@ -4336,7 +4504,7 @@ ${detail}` : detail;
           for (const slot of slots) {
             const name = slotBucket(slot);
             const entry = buckets.get(name) ?? { seats: 0, slots: 0, cooling: false };
-            entry.seats += slot.weight;
+            entry.seats += slotCeiling(slot);
             entry.slots++;
             if (snap.cooling.has(slot.model)) entry.cooling = true;
             buckets.set(name, entry);
@@ -4348,13 +4516,13 @@ ${detail}` : detail;
           return {
             title: `agent-pool: ${total} task(s) in flight, ${coolingNow.length} model(s) cooling`,
             output: [
-              `shared pool over ${slots.length} slot(s) from ${s.origin}; state ${pass}; bases: ${BASES.join(", ")}
-one ordered pass in slot order: each slot fills to its weight, then overflow goes to the least-loaded slot. Capacity is the sum of the weights; repeat a model on another line to give it more (FULL = at weight).`,
+              `shared pool over ${slots.filter((slot) => !slot.fallback).length} primary slot(s) + ${slots.filter((slot) => slot.fallback).length} fallback slot(s) from ${s.origin}; state ${pass}; bases: ${BASES.join(", ")}
+ordered fill in declaration order: each pass fills every usable slot to its weight, then the next pass deepens a slot toward its ceiling (max parallel sessions). The fallback section is used only when no primary slot is usable. Capacity is the sum of the ceilings; weight alone is the per-pass budget (FULL = at ceiling).`,
               ...next ? [] : ["next: none - no routable slot; every slot is cooling, catalog-retired, or provider-unconfigured. A spawn will fail explicitly instead of routing."],
               ...sharedBuckets.length ? [`buckets: ${sharedBuckets.map(([name, entry]) => `${name} ${entry.seats} seat(s)${entry.cooling ? " COOLING" : ""}`).join("; ")}`] : [],
               ...degradedProviders.length ? [`provider degraded: ${degradedProviders.join(", ")} (flat window; a probe re-admits a model when it answers)`] : [],
               ...slots.map(line),
-              ...poolHealthLines(slots, now),
+              ...poolHealthLines(slots.filter((slot) => !slot.fallback), now),
               "",
               "by process:",
               `  ${s.id} (this process): ${snap.own.size} claim(s)`,
@@ -7355,6 +7523,43 @@ function normalizeChunk(value) {
   }
   return changed;
 }
+var UPSTREAM_ATTEMPTS = 3;
+var UPSTREAM_RETRY_DELAY_MS = 250;
+var TRANSIENT_UPSTREAM_PATTERN2 = /reasoning_display/i;
+function requestUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.toString();
+  if (input && typeof input === "object") {
+    const url = input.url;
+    if (typeof url === "string") return url;
+  }
+  return "";
+}
+function isOpencodeInferenceChat(raw) {
+  if (!raw) return false;
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  if (url.hostname !== "opencode.ai" && !url.hostname.endsWith(".opencode.ai")) return false;
+  return url.pathname.includes("/inference/") && url.pathname.endsWith("/chat/completions");
+}
+function isReplayableInit(init2) {
+  if (!init2 || typeof init2 !== "object") return false;
+  const body = init2.body;
+  return typeof body === "string" || body instanceof Uint8Array || body instanceof ArrayBuffer;
+}
+async function isTransientUpstreamResponse(response) {
+  if (response.status !== 400) return false;
+  try {
+    const text = await response.clone().text();
+    return TRANSIENT_UPSTREAM_PATTERN2.test(text) && /not\s+a\s+supported\s+value|unsupported/i.test(text);
+  } catch {
+    return false;
+  }
+}
 function normalizeSseLine(line) {
   const trimmed = line.trim();
   if (!trimmed.startsWith("data:")) return line;
@@ -7391,9 +7596,22 @@ function createChunkNormalizer() {
     }
   });
 }
-function wrapFetch(original) {
+var sleep = (ms) => ms > 0 ? new Promise((resolve5) => setTimeout(resolve5, ms)) : Promise.resolve();
+function wrapFetch(original, options = {}) {
+  const attempts = Math.max(1, Math.trunc(options.attempts ?? UPSTREAM_ATTEMPTS));
+  const delayMs = Math.max(0, Math.trunc(options.delayMs ?? UPSTREAM_RETRY_DELAY_MS));
   const wrapped = async (input, init2) => {
-    const response = await original(input, init2);
+    const retryable = attempts > 1 && isReplayableInit(init2) && isOpencodeInferenceChat(requestUrl(input));
+    let response = await original(input, init2);
+    for (let attempt = 1; retryable && attempt < attempts; attempt++) {
+      if (!await isTransientUpstreamResponse(response)) break;
+      try {
+        await response.body?.cancel();
+      } catch {
+      }
+      await sleep(delayMs);
+      response = await original(input, init2);
+    }
     try {
       const contentType = response.headers.get("content-type") ?? "";
       if (!contentType.includes("text/event-stream") || !response.body) return response;