pi-model-fallback 0.4.0 → 0.5.1

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## Unreleased
 
+## [0.5.1] - 2026-09-30
+
+### Changed
+
+- Update `@earendil-works/pi-*` dependencies to `0.99.1`.
+
+## [0.5.0] - 2026-09-22
+
+### Added
+
+- `reasons` rule option: match optional failure reason codes (for example `context_length_exceeded`) parsed from provider error messages, so status codes like `400` can trigger fallback only for specific causes such as context-length overflow. Reason-aware rules participate in shadowing analysis, and unrestricted earlier rules still shadow later reason-scoped rules.
+- Never fall back to the failing model itself: rules whose fallback target equals the failing model are skipped so the next matching rule applies.
+- Cascading fallback chains: when the active fallback model fails, other matching rules can move the session onward (for example `free → kimi-k2.6 → glm-5.3-flash`). Cascades never revisit a model already used in the current run, so circular rules cannot loop.
+
+### Fixed
+
+- Parse `Error: <status>` messages that carry no colon after the status, such as GitHub Copilot's `Error: 429 quota exceeded`. These fell between the leading-bare-status pattern, which requires a colon after the status, and the `error <status>` pattern, which requires whitespace directly after `error`, so Copilot quota exhaustion never triggered a fallback.
+- Recognise a bare status followed by a quota noun, such as `429 quota exceeded`.
+
+### Changed
+
+- Bump Pi dev dependencies to `@earendil-works/*` 0.86.1 and `@types/node` 26.5.1.
+- Refresh the fallback retry example in the README and usage docs.
+
 ## [0.4.0] - 2026-09-11
 
 ### Added

package/README.md

@@ -90,13 +90,14 @@ Rule fields:
 - `matchProviders`: match all models from a provider
 - `matchModels`: match specific `provider` + `model` pairs
 - `statuses`: optional; defaults to `429, 500, 502, 503, 504`
+- `reasons`: optional list of failure reason codes (for example `context_length_exceeded`); when set, the rule only fires if the parsed failure reason is listed. Reasons come from quoted machine codes in the error message (for example `"provider_error_code":"context_length_exceeded"`) or prose such as `exceeds this model's context length`. Useful for status codes like `400` that should only trigger a fallback for specific causes, such as context-length overflow.
 - `cooldownMs`: optional persistent fallback window
 - `fallback`: target model Pi should switch to
 
 Top-level fields:
 
 - `enabled`: toggle the extension without deleting rules
-- `autoRetry`: when a fallback fires from a failed turn, automatically re-queue the failed user prompt so the turn retries on the fallback model (defaults to `true`; set to `false` to only switch models)
+- `autoRetry`: when a fallback fires from a failed turn, automatically re-queue the failed user prompt so the turn retries on the fallback model (defaults to `true`; set to `false` to only switch models). The failed prompt is queued once per fallback transition, so a fallback chain may replay it more than once.
 
 Rules use first-match order: the first rule whose provider/model and status match wins. Put specific `matchModels` rules before broad `matchProviders` rules when they should take priority. `model_fallback_config validate`, `save`, `read`, and `status` report warning-only diagnostics when a later rule or model entry is completely shadowed by an earlier rule; `/model-fallback:status` also includes a concise warning summary for the current config. Warning-bearing config remains valid and can still be saved.
 
@@ -123,7 +124,11 @@ If the package is installed project-locally and the current project references i
 - Successful responses do nothing.
 - Matching failures from `after_provider_response` can trigger fallback immediately.
 - Assistant error messages parsed at `turn_end` can also persist fallback state for SDK/provider failures that do not emit the normal response hook. Status extraction looks for HTTP-style tokens (for example `status 429`, `HTTP 503`, or `rate limit`) rather than any bare 3-digit number in the message.
-- The failed request is not automatically replayed.
+- With the default `autoRetry: true`, the failed prompt is automatically queued once per fallback transition on the fallback model. A fallback chain may therefore replay the prompt more than once. Set `autoRetry: false` to switch models without replaying it.
+
+Rules never fall back to the failing model itself; a rule whose fallback target equals the failing model is skipped so the next matching rule (or no rule) applies.
+
+Fallback chains cascade: when the active fallback model itself fails, another matching rule may move the session further (for example `free model → kimi-k2.6 → glm-5.3-flash`). A cascade never revisits a model already used in the current run (the original or an earlier fallback), so circular rule configurations cannot ping-pong; when no unvisited target remains, the failure surfaces normally.
 
 ## Development
 

package/docs/usage.md

@@ -6,7 +6,7 @@ Install:
 pi install npm:pi-model-fallback
 ```
 
-Default behavior: when a `zai/*` model receives `429`, `500`, `502`, `503`, or `504`, Pi switches to `deepseek/deepseek-v4-flash` for the next prompt.
+Default behavior: when a `zai/*` model receives `429`, `500`, `502`, `503`, or `504`, Pi switches to `deepseek/deepseek-v4-flash` for the next prompt. The failed prompt is automatically queued once per fallback transition on the fallback model, so a fallback chain may replay it more than once; set `"autoRetry": false` in `model-fallback/config.json` to switch models without retrying it.
 
 Commands:
 
@@ -17,6 +17,8 @@ Commands:
 
 Rule order is first-match: the first rule whose provider/model and status match wins. Place specific `matchModels` rules before broad `matchProviders` rules when the model-specific fallback should take priority. `model_fallback_config validate`, `save`, `read`, and `status` expose warning-only details for completely shadowed later rules or model entries, and `/model-fallback:status` includes a concise current-config warning summary; these warnings do not make the config invalid.
 
+Rules can also match on failure reasons with `reasons`, for example `"reasons": ["context_length_exceeded"]` on a `400` rule so only context-overflow failures switch models while other `400`s stay errors. Reasons are parsed from quoted provider error codes (for example `"provider_error_code":"context_length_exceeded"`) or prose such as `exceeds this model's context length`. A rule never falls back to the failing model itself.
+
 Cooldown defaults when a rule omits `cooldownMs`:
 
 - `429` → 72 hours
@@ -24,4 +26,4 @@ Cooldown defaults when a rule omits `cooldownMs`:
 
 `Retry-After` and `x-ratelimit-reset*` response headers override `cooldownMs` and those defaults.
 
-The failed request is not automatically replayed.
+If `autoRetry` is disabled, the failed request is not automatically replayed.

package/extensions/index.ts

@@ -15,7 +15,7 @@ import {
   type ModelRef,
   type RuleWarning,
 } from "../lib/config.js";
-import { parseStatusFromErrorMessage } from "../lib/error-status.js";
+import { parseReasonFromErrorMessage, parseStatusFromErrorMessage } from "../lib/error-status.js";
 import { emptyState, findActiveStateEntry, pruneExpiredState, readState, upsertStateEntry, validateStateShape, writeState, type FallbackState } from "../lib/state.js";
 import { isRecord } from "../lib/internal.ts";
 import { modelFallbackPaths, readConfig, writeConfig, type ModelFallbackPaths } from "../lib/storage.js";
@@ -33,6 +33,10 @@ export default function modelFallback(pi: ExtensionAPI) {
   let originalModelKey: string | undefined;
   let activeFallbackKey: string | undefined;
   let lastFallbackReason: string | undefined;
+  // Models already fallen back to during this run (plus the original). A cascade may only
+  // target a model never visited, which makes chains (free → kimi → glm) safe while
+  // preventing A→B→A ping-pong with circular rules.
+  let visitedFallbackKeys = new Set<string>();
 
   function syncPaths(ctx: ExtensionContext): void {
     if (pathsResolvedForCwd === ctx.cwd) return;
@@ -94,28 +98,30 @@ export default function modelFallback(pi: ExtensionAPI) {
       return;
     }
 
+    originalModelKey = modelKey(current);
+    activeFallbackKey = modelRefKey(active.fallback);
+    visitedFallbackKeys = new Set([originalModelKey, activeFallbackKey]);
+    lastFallbackReason = `persistent ${active.status} from ${originalModelKey} until ${active.until}`;
+    updateStatus(ctx);
     const ok = await pi.setModel(fallbackModel);
     if (!ok) {
       ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(active.fallback)}`, "warning");
+      originalModelKey = undefined;
+      activeFallbackKey = undefined;
+      lastFallbackReason = undefined;
+      visitedFallbackKeys = new Set();
+      updateStatus(ctx);
       return;
     }
-
-    originalModelKey = modelKey(current);
-    activeFallbackKey = modelRefKey(active.fallback);
-    lastFallbackReason = `persistent ${active.status} from ${originalModelKey} until ${active.until}`;
     updateStatus(ctx);
     ctx.ui.notify(`Model fallback preselected: ${originalModelKey} → ${activeFallbackKey} until ${active.until}.`, "warning");
   }
 
-  async function persistFailure(source: ModelRef, status: number, headers: Record<string, string>, ctx: ExtensionContext): Promise<boolean> {
+  async function persistFailure(source: ModelRef, status: number, headers: Record<string, string>, ctx: ExtensionContext, reason?: string): Promise<boolean> {
     const loaded = config ?? (await loadConfig(ctx));
     if (!loaded) return false;
-    const match = findFallback(loaded, { provider: source.provider, id: source.model }, status);
+    const match = findFallback(loaded, { provider: source.provider, id: source.model }, status, reason);
     if (!match) return false;
-    // Only skip when the failing model IS the active fallback (its own failure should not
-    // re-trigger). A failure on the original model while the fallback is merely preselected
-    // must still proceed so auto-retry can run on the fallback.
-    if (activeFallbackKey && modelRefKey(source) === activeFallbackKey) return false;
 
     const fallbackModel = ctx.modelRegistry.find(match.fallback.provider, match.fallback.model);
     if (!fallbackModel) {
@@ -123,6 +129,18 @@ export default function modelFallback(pi: ExtensionAPI) {
       return false;
     }
 
+    // Loop guard: never fall back to a model already visited this run (the original or an
+    // earlier fallback). This both blocks circular rules from ping-ponging and stops the
+    // current fallback from re-selecting itself, while still allowing onward cascades
+    // (free → kimi → glm) when a different rule matches the fallback's own failure.
+    // Exception: when the failing model is the remembered original and the candidate is the
+    // already-preselected fallback, re-applying the same hop is idempotent and stays allowed
+    // (turn attribution can lag behind the preselection).
+    const fallbackKey = modelRefKey(match.fallback);
+    const sourceKey = modelRefKey(source);
+    const idempotentReapply = fallbackKey === activeFallbackKey && sourceKey === originalModelKey;
+    if (visitedFallbackKeys.has(fallbackKey) && !idempotentReapply) return false;
+
     const now = new Date();
     const until = new Date(now.getTime() + cooldownMsFor(match.rule.cooldownMs, status, headers)).toISOString();
     const loadedState = state ?? (await loadState(ctx)) ?? { version: 1 as const, entries: [] };
@@ -136,16 +154,29 @@ export default function modelFallback(pi: ExtensionAPI) {
     });
     await writeState(paths.state, state);
 
+    const prevOriginal = originalModelKey;
+    const prevActive = activeFallbackKey;
+    const prevReason = lastFallbackReason;
+    const prevVisited = visitedFallbackKeys;
+    // Mark before setModel so the model_select handler keeps fallback bookkeeping.
+    if (!originalModelKey) originalModelKey = sourceKey;
+    activeFallbackKey = fallbackKey;
+    visitedFallbackKeys = new Set(prevVisited);
+    visitedFallbackKeys.add(sourceKey);
+    visitedFallbackKeys.add(fallbackKey);
+    lastFallbackReason = `${status} from ${sourceKey}${reason ? ` (${reason})` : ""}; persistent until ${until}`;
+    updateStatus(ctx);
+
     const ok = await pi.setModel(fallbackModel);
     if (!ok) {
+      originalModelKey = prevOriginal;
+      activeFallbackKey = prevActive;
+      lastFallbackReason = prevReason;
+      visitedFallbackKeys = prevVisited;
+      updateStatus(ctx);
       ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(match.fallback)}`, "warning");
       return false;
     }
-
-    originalModelKey = modelRefKey(source);
-    activeFallbackKey = modelRefKey(match.fallback);
-    lastFallbackReason = `${status} from ${originalModelKey}; persistent until ${until}`;
-    updateStatus(ctx);
     ctx.ui.notify(`Model fallback: ${originalModelKey} → ${activeFallbackKey} (${status}). Future sessions preselect fallback until ${until}.`, "warning");
     return true;
   }
@@ -153,6 +184,7 @@ export default function modelFallback(pi: ExtensionAPI) {
   pi.on("agent_start", async (_event, ctx) => {
     await loadConfig(ctx);
     await loadState(ctx);
+    visitedFallbackKeys = new Set();
     await applyPersistentFallback(ctx);
     updateStatus(ctx);
   });
@@ -162,6 +194,7 @@ export default function modelFallback(pi: ExtensionAPI) {
       activeFallbackKey = undefined;
       originalModelKey = undefined;
       lastFallbackReason = undefined;
+      visitedFallbackKeys = new Set();
       updateStatus(ctx);
     }
   });
@@ -171,7 +204,6 @@ export default function modelFallback(pi: ExtensionAPI) {
     const loaded = config ?? (await loadConfig(ctx));
     if (!current || !loaded) return;
     if (event.status >= 200 && event.status < 300) return;
-    if (activeFallbackKey && modelKey(current) === activeFallbackKey) return;
 
     await persistFailure(modelToRef(current), event.status, event.headers, ctx);
   });
@@ -183,11 +215,11 @@ export default function modelFallback(pi: ExtensionAPI) {
     if (!errorMessage) return;
     const status = parseStatusFromErrorMessage(errorMessage);
     if (status === undefined) return;
+    const reason = parseReasonFromErrorMessage(errorMessage);
     const provider = typeof message.provider === "string" ? message.provider : ctx.model?.provider;
     const model = typeof message.model === "string" ? message.model : ctx.model?.id;
     if (!provider || !model) return;
-    if (activeFallbackKey && `${provider}/${model}` === activeFallbackKey) return;
-    const switched = await persistFailure({ provider, model }, status, {}, ctx);
+    const switched = await persistFailure({ provider, model }, status, {}, ctx, reason);
     if (!switched) return;
     const loaded = config;
     if (!loaded || loaded.autoRetry === false) return;
@@ -216,6 +248,7 @@ export default function modelFallback(pi: ExtensionAPI) {
         ctx.ui.notify("Model fallback: persistent state cleared; no remembered original model.", "info");
         activeFallbackKey = undefined;
         lastFallbackReason = undefined;
+        visitedFallbackKeys = new Set();
         updateStatus(ctx);
         return;
       }
@@ -233,6 +266,7 @@ export default function modelFallback(pi: ExtensionAPI) {
       activeFallbackKey = undefined;
       originalModelKey = undefined;
       lastFallbackReason = undefined;
+      visitedFallbackKeys = new Set();
       updateStatus(ctx);
       ctx.ui.notify(`Model fallback reset: ${modelKey(model)}; persistent state cleared.`, "info");
     },

package/lib/config.ts

@@ -14,6 +14,8 @@ export interface FallbackRule {
   matchProviders?: string[];
   matchModels?: ModelRef[];
   statuses?: number[];
+  /** Failure reason codes (for example `context_length_exceeded`); when set, the rule only fires if the parsed reason is listed. */
+  reasons?: string[];
   /** Persistent failover cooldown in milliseconds after a matching failure. Defaults: 429 => 72h, 5xx => 10m. */
   cooldownMs?: number;
   fallback: ModelRef;
@@ -52,6 +54,8 @@ interface NormalizedRuleForWarnings {
   modelKeys: Set<string>;
   models: ModelRef[];
   statuses: Set<number>;
+  /** undefined = the rule matches any failure reason. */
+  reasons?: Set<string>;
 }
 
 export function defaultConfig(): ModelFallbackConfig {
@@ -85,11 +89,19 @@ export function validateConfigShape(value: unknown): ModelFallbackConfig {
   };
 }
 
-export function findFallback(config: ModelFallbackConfig, model: Pick<Model<any>, "provider" | "id">, status: number): MatchedFallback | undefined {
+export function findFallback(
+  config: ModelFallbackConfig,
+  model: Pick<Model<any>, "provider" | "id">,
+  status: number,
+  reason?: string,
+): MatchedFallback | undefined {
   if (!config.enabled) return undefined;
   for (const rule of config.rules) {
     if (!statusesFor(rule).has(status)) continue;
     if (!modelMatches(rule, model)) continue;
+    if (!reasonMatches(rule, reason)) continue;
+    // Never "fall back" to the failing model itself; that would only re-trigger the same failure.
+    if (modelKey(model) === modelRefKey(rule.fallback)) continue;
     return { rule, fallback: rule.fallback };
   }
   return undefined;
@@ -109,17 +121,17 @@ export function analyzeRuleWarnings(config: ModelFallbackConfig): RuleWarning[]
       const earlierRule = config.rules[earlierIndex];
       const earlier = normalizedRules[earlierIndex];
 
-      if (setsEqual(earlier.statuses, later.statuses) && ruleScopesEqual(earlier, later)) {
+      if (setsEqual(earlier.statuses, later.statuses) && ruleScopesEqual(earlier, later) && reasonsEqual(earlier, later)) {
         warnings.push(duplicateRuleWarning(laterRule, ruleIndex, later, earlierRule, earlierIndex));
         continue rules;
       }
 
-      if (statusSetCovers(earlier.statuses, later.statuses) && ruleScopeCovers(earlier, later)) {
+      if (statusSetCovers(earlier.statuses, later.statuses) && ruleScopeCovers(earlier, later) && reasonsCover(earlier, later)) {
         warnings.push(scopeShadowWarning(laterRule, ruleIndex, later, earlierRule, earlierIndex, earlier));
         continue rules;
       }
 
-      if (earlier.providers.size === 0 || later.models.length === 0 || !statusSetCovers(earlier.statuses, later.statuses)) continue;
+      if (earlier.providers.size === 0 || later.models.length === 0 || !statusSetCovers(earlier.statuses, later.statuses) || !reasonsCover(earlier, later)) continue;
 
       const shadowedModels = later.models.filter((entry) => earlier.providers.has(entry.provider) && !reportedModelShadowKeys.has(modelRefKey(entry)));
       if (shadowedModels.length === 0) continue;
@@ -147,6 +159,7 @@ function validateRule(value: unknown, index: number): FallbackRule {
   if (value.matchProviders !== undefined) rule.matchProviders = readStringArray(value.matchProviders, `rules[${index}].matchProviders`);
   if (value.matchModels !== undefined) rule.matchModels = readModelRefArray(value.matchModels, `rules[${index}].matchModels`);
   if (value.statuses !== undefined) rule.statuses = readStatuses(value.statuses, `rules[${index}].statuses`);
+  if (value.reasons !== undefined) rule.reasons = readStringArray(value.reasons, `rules[${index}].reasons`);
   if (value.cooldownMs !== undefined) rule.cooldownMs = readPositiveInteger(value.cooldownMs, `rules[${index}].cooldownMs`);
   if ((!rule.matchProviders || rule.matchProviders.length === 0) && (!rule.matchModels || rule.matchModels.length === 0)) {
     throw new Error(`rules[${index}] must define matchProviders or matchModels.`);
@@ -160,6 +173,11 @@ function modelMatches(rule: FallbackRule, model: Pick<Model<any>, "provider" | "
   return false;
 }
 
+function reasonMatches(rule: FallbackRule, reason: string | undefined): boolean {
+  if (!rule.reasons || rule.reasons.length === 0) return true;
+  return reason !== undefined && rule.reasons.includes(reason);
+}
+
 function statusesFor(rule: FallbackRule): Set<number> {
   return new Set(rule.statuses && rule.statuses.length > 0 ? rule.statuses : DEFAULT_FALLBACK_STATUSES);
 }
@@ -171,6 +189,7 @@ function normalizeRuleForWarnings(rule: FallbackRule): NormalizedRuleForWarnings
     modelKeys: new Set(modelsByKey.keys()),
     models: [...modelsByKey.values()],
     statuses: statusesFor(rule),
+    reasons: rule.reasons && rule.reasons.length > 0 ? new Set(rule.reasons) : undefined,
   };
 }
 
@@ -249,6 +268,17 @@ function statusSetCovers(earlier: Set<number>, later: Set<number>): boolean {
   return setCovers(earlier, later);
 }
 
+function reasonsCover(earlier: NormalizedRuleForWarnings, later: NormalizedRuleForWarnings): boolean {
+  if (earlier.reasons === undefined) return true;
+  if (later.reasons === undefined) return false;
+  return setCovers(earlier.reasons, later.reasons);
+}
+
+function reasonsEqual(earlier: NormalizedRuleForWarnings, later: NormalizedRuleForWarnings): boolean {
+  if (earlier.reasons === undefined || later.reasons === undefined) return earlier.reasons === later.reasons;
+  return setsEqual(earlier.reasons, later.reasons);
+}
+
 function setsEqual<T>(left: Set<T>, right: Set<T>): boolean {
   return left.size === right.size && setCovers(left, right);
 }

package/lib/error-status.ts

@@ -1,12 +1,59 @@
+const REASON_TEXT_PATTERNS: Array<[RegExp, string]> = [
+  [/exceeds\s+(?:this|the)\s+model'?s?\s+context\s+length/i, "context_length_exceeded"],
+  [/context[\s_-]*length[\s_-]*exceeded/i, "context_length_exceeded"],
+];
+
+export function parseReasonFromErrorMessage(message: string): string | undefined {
+  // Quoted machine-readable codes relayed by routers, for example
+  // "code":"context_length_exceeded" or "provider_error_code":"context_length_exceeded".
+  // Numeric "code":400 values are ignored; parseStatusFromErrorMessage handles the status.
+  const quoted = message.match(/"(?:[a-z0-9_]+_)?code"\s*:\s*"([a-z0-9_.:-]+)"/i);
+  if (quoted) return quoted[1];
+  for (const [pattern, reason] of REASON_TEXT_PATTERNS) {
+    if (pattern.test(message)) return reason;
+  }
+  return undefined;
+}
+
+// Failure modes where the transport reports HTTP success but the provider
+// yields nothing usable — no numeric status is present in any of them, so the
+// status parser must synthesize one for the fallback rules to fire:
+// - "Provider returned an empty response" (OpenRouter stealth/pool models)
+// - "Stream ended without finish_reason" (chunk stream truncated mid-flight)
+// - "<provider> response has no body" (Anthropic/Mistral/generic, 200 empty body)
+// - "<provider> stream ended without a terminal event" (SSE stream dies silently)
+const EMPTY_PROVIDER_RESPONSE_PATTERNS: RegExp[] = [
+  /provider returned an empty response/i,
+  /response (has|with) no body/i,
+  /stream ended without a terminal event/i,
+  /stream ended without finish_reason/i,
+];
+
 export function parseStatusFromErrorMessage(message: string): number | undefined {
+  for (const pattern of EMPTY_PROVIDER_RESPONSE_PATTERNS) {
+    if (pattern.test(message)) {
+      // Synthesize 502 so status-based fallback rules fire instead of the
+      // agent silently retrying the same model. 502 is deliberately chosen
+      // over a novel code: it lands in the 5xx status lists users already
+      // configure and inherits the standard 10-minute cooldown.
+      return 502;
+    }
+  }
   const patterns: RegExp[] = [
     // Leading bare status code, optionally prefixed with "Error:", e.g. "401: {\"type\":\"CreditsError\"...}"
     // or "Error: 401: {\"type\":\"CreditsError\"...}" (OpenCode Go, OpenRouter relays)
     /^\s*(?:error\s*:?\s*)?([1-5][0-9]{2})\s*:/i,
+    // Anchored "Error: <status> <prose>", e.g. "Error: 429 quota exceeded"
+    // (GitHub Copilot). The pattern above needs a colon AFTER the status and the
+    // "error <status>" pattern below needs whitespace directly after "error", so
+    // a message carrying both the prefix and a colon fell between them. The
+    // "error" prefix is required: without it this would also match prose such as
+    // "429 tokens remaining in context window", which must stay unmatched.
+    /^\s*error\s*:?\s*([1-5][0-9]{2})\b/i,
     /\b(?:status|code|http)\s*[:\s]?\s*([1-5][0-9]{2})\b/i,
     /\bHTTP\/\d(?:\.\d)?\s+([1-5][0-9]{2})\b/,
     /\b(?:rate[\s-]?limit(?:ed)?|too many requests)[^0-9]{0,40}([45][0-9]{2})\b/i,
-    /\b([45][0-9]{2})\s+(?:error|too many requests|service unavailable|bad gateway|gateway timeout|internal server error)\b/i,
+    /\b([45][0-9]{2})\s+(?:error|quota|too many requests|service unavailable|bad gateway|gateway timeout|internal server error)\b/i,
     /\berror\s+([45][0-9]{2})\b/i,
   ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-model-fallback",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Pi extension that switches to a fallback model after provider failures such as 429 rate limits.",
   "type": "module",
   "license": "MIT",
@@ -50,11 +50,11 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.84.1",
-    "@earendil-works/pi-ai": "^0.84.1",
-    "@earendil-works/pi-coding-agent": "^0.84.1",
-    "@earendil-works/pi-tui": "^0.84.1",
-    "@types/node": "^26.0.0",
+    "@earendil-works/pi-agent-core": "^0.99.1",
+    "@earendil-works/pi-ai": "^0.99.1",
+    "@earendil-works/pi-coding-agent": "^0.99.1",
+    "@earendil-works/pi-tui": "^0.99.1",
+    "@types/node": "^26.6.3",
     "jiti": "^2.7.0",
     "typebox": "latest",
     "typescript": "^7.0.2"