pi-model-fallback 0.5.1 → 0.5.3

package/CHANGELOG.md

@@ -1,6 +1,28 @@
 # Changelog
 
-## Unreleased
+## [0.5.3] - 2026-10-12
+
+### Changed
+
+- Require Pi 1.1 for the continuation boundary API and align Pi development dependencies with that release line.
+
+### Fixed
+
+- Continue failed requests after Pi's own retries without replaying the user prompt or dropping image inputs and completed tool results.
+- Keep fallback-chain visitation across continuation loops, respect interruption and aborted settlement, and persist cooldowns only after successful target activation.
+- Retain observed HTTP status and retry headers for the matching request when provider error text omits a status.
+- Keep fallback active for the rest of the run after a config save mid-run; superseding pending fallback work no longer disables fallback until the next user prompt.
+- Recognize Anthropic SDK status-plus-JSON and streaming errors so configured rate-limit and outage rules are evaluated. Treat interrupted Anthropic streams as `502` and supported connection failures as `503`, without changing rule defaults or matching cancellation.
+
+## [0.5.2] - 2026-10-07
+
+### Changed
+
+- Update `@earendil-works/pi-*` development dependencies to `1.0.4`.
+
+### Fixed
+
+- Recognize a status in parentheses when a provider error wrapper precedes it, for example `omni API error (503): ...`. Previously such messages yielded no status, so rules listing `503` were never evaluated even when configured.
 
 ## [0.5.1] - 2026-09-30
 

package/README.md

@@ -26,6 +26,8 @@ When a failure matches, the extension also stores persistent fallback state so f
 
 ## Install
 
+Requires Pi 1.1 or later for the continuation boundary API.
+
 Install from npm:
 
 ```bash
@@ -97,7 +99,7 @@ Rule fields:
 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). The failed prompt is queued once per fallback transition, so a fallback chain may replay it more than once.
+- `autoRetry`: after Pi exhausts its own retries, continue the existing conversation on the fallback model without re-queueing the user prompt (defaults to `true`; set to `false` to only switch models). Completed tool results and image inputs remain in context; only the failed assistant entry is excluded.
 
 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.
 
@@ -122,9 +124,12 @@ If the package is installed project-locally and the current project references i
 ## Behavior notes
 
 - 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.
-- 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.
+- Failed HTTP responses are recorded by `after_provider_response`; model switching waits until Pi's retry/recovery paths finish at `agent_before_settle`.
+- Assistant error messages parsed at `turn_end` identify SDK/provider failures that do not emit the normal response hook. When friendly error text omits a status, the extension uses the observed HTTP status and headers from the same model request. 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. A status in parentheses is only recognized when an error wrapper keyword precedes it, as in `omni API error (503): ...`; a parenthesized number with no such wrapper, such as `(503) items processed`, stays unmatched.
+- Anthropic SDK errors with a bare status followed by JSON (for example `429 {"type":"error",...}`) are recognized. Status-free Anthropic streaming errors map `rate_limit_error` to `429`, `overloaded_error` to `529`, and `api_error` to `500`; an interrupted stream maps to `502`. Add `529` to a rule's `statuses` if it should cover Anthropic overloads. Supported connection failures without an HTTP response map to `503`; cancellation, refusals, and ordinary numeric prose stay unmatched, and explicit HTTP statuses take precedence.
+- With the default `autoRetry: true`, the existing run continues on the fallback model without a second user request. Set `autoRetry: false` to switch models without continuing.
+- Interrupting a pending fallback prevents continuation. An in-flight model change is not atomic with cancellation: the selected model may change, but the extension will not request another inference after the interrupt.
+- Switching providers sends the existing model context to the target provider. Preserving completed tool results prevents extension-level replay, not a model independently choosing to repeat an action.
 
 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.
 

package/docs/usage.md

@@ -1,12 +1,14 @@
 # Usage
 
-Install:
+Requires Pi 1.1 or later. Install:
 
 ```bash
 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. 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.
+Default behavior: when a `zai/*` model fails with `429`, `500`, `502`, `503`, or `504`, Pi finishes its own retries, switches to `deepseek/deepseek-v4-flash`, and continues the existing conversation without replaying the user prompt. Completed tool results and images remain in context. Set `"autoRetry": false` in `model-fallback/config.json` to switch models without continuing.
+
+The selected session model changes; subsequent requests use that model directly. Interrupting a pending fallback prevents continuation, although a model change already in progress may remain. A chain never revisits a model within the same user run.
 
 Commands:
 
@@ -26,4 +28,4 @@ Cooldown defaults when a rule omits `cooldownMs`:
 
 `Retry-After` and `x-ratelimit-reset*` response headers override `cooldownMs` and those defaults.
 
-If `autoRetry` is disabled, the failed request is not automatically replayed.
+If `autoRetry` is disabled, the existing run is not automatically continued.

package/extensions/index.ts

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getKeybindings } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import {
   analyzeRuleWarnings,
@@ -37,6 +38,45 @@ export default function modelFallback(pi: ExtensionAPI) {
   // 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>();
+  let cancelled = false;
+  let generation = 0;
+  let switching = false;
+  let uiPromptOpen = false;
+  let removeTerminalListener: (() => void) | undefined;
+  let responseFailure: { modelKey: string; status: number; headers: Record<string, string> } | undefined;
+  let pendingFailure: { source: ModelRef; status: number; reason?: string; entryId: string; headers: Record<string, string> } | undefined;
+
+  function cancelFallback(): void {
+    cancelled = true;
+    invalidatePending();
+  }
+
+  // Drop fallback work computed from superseded state without disabling fallback
+  // for the rest of the run (unlike cancelFallback).
+  function invalidatePending(): void {
+    generation += 1;
+    pendingFailure = undefined;
+  }
+
+  pi.on("session_start", (_event, ctx) => {
+    removeTerminalListener?.();
+    if (ctx.mode === "tui") {
+      removeTerminalListener = ctx.ui.onTerminalInput((data) => {
+        if ((pendingFailure || switching) && !uiPromptOpen && getKeybindings().matches(data, "app.interrupt")) cancelFallback();
+        // Observe cancellation without consuming autocomplete, overlay, or editor input.
+        return undefined;
+      });
+    }
+  });
+  pi.on("ui_prompt_start", () => { uiPromptOpen = true; });
+  pi.on("ui_prompt_end", () => { uiPromptOpen = false; });
+  pi.on("session_shutdown", () => {
+    cancelFallback();
+    removeTerminalListener?.();
+    removeTerminalListener = undefined;
+  });
+  pi.on("session_before_switch", cancelFallback);
+  pi.on("session_before_tree", cancelFallback);
 
   function syncPaths(ctx: ExtensionContext): void {
     if (pathsResolvedForCwd === ctx.cwd) return;
@@ -103,7 +143,13 @@ export default function modelFallback(pi: ExtensionAPI) {
     visitedFallbackKeys = new Set([originalModelKey, activeFallbackKey]);
     lastFallbackReason = `persistent ${active.status} from ${originalModelKey} until ${active.until}`;
     updateStatus(ctx);
-    const ok = await pi.setModel(fallbackModel);
+    let ok = false;
+    switching = true;
+    try {
+      ok = await pi.setModel(fallbackModel);
+    } finally {
+      switching = false;
+    }
     if (!ok) {
       ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(active.fallback)}`, "warning");
       originalModelKey = undefined;
@@ -117,7 +163,7 @@ export default function modelFallback(pi: ExtensionAPI) {
     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, reason?: string): Promise<boolean> {
+  async function persistFailure(source: ModelRef, status: number, headers: Record<string, string>, ctx: ExtensionContext, isCancelled: () => boolean, 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, reason);
@@ -129,30 +175,12 @@ 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;
+    if (visitedFallbackKeys.has(fallbackKey) || isCancelled()) 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: [] };
-    state = upsertStateEntry(loadedState, {
-      source,
-      fallback: match.fallback,
-      status,
-      until,
-      createdAt: now.toISOString(),
-      ruleName: match.rule.name,
-    });
-    await writeState(paths.state, state);
 
     const prevOriginal = originalModelKey;
     const prevActive = activeFallbackKey;
@@ -167,30 +195,49 @@ export default function modelFallback(pi: ExtensionAPI) {
     lastFallbackReason = `${status} from ${sourceKey}${reason ? ` (${reason})` : ""}; persistent until ${until}`;
     updateStatus(ctx);
 
-    const ok = await pi.setModel(fallbackModel);
-    if (!ok) {
+    let ok = false;
+    try {
+      ok = await pi.setModel(fallbackModel);
+    } catch (error) {
+      ctx.ui.notify(`Model fallback switch failed: ${errorMessage(error)}`, "warning");
+    }
+    if (!ok || isCancelled()) {
       originalModelKey = prevOriginal;
       activeFallbackKey = prevActive;
       lastFallbackReason = prevReason;
       visitedFallbackKeys = prevVisited;
       updateStatus(ctx);
-      ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(match.fallback)}`, "warning");
+      if (!ok) ctx.ui.notify(`Model fallback auth unavailable: ${modelRefKey(match.fallback)}`, "warning");
       return false;
     }
-    ctx.ui.notify(`Model fallback: ${originalModelKey} → ${activeFallbackKey} (${status}). Future sessions preselect fallback until ${until}.`, "warning");
+    const loadedState = state ?? (await loadState(ctx)) ?? emptyState();
+    if (isCancelled()) return false;
+    state = upsertStateEntry(loadedState, { source, fallback: match.fallback, status, until, createdAt: now.toISOString(), ruleName: match.rule.name });
+    await writeState(paths.state, state);
+    ctx.ui.notify(`Model fallback: ${sourceKey} → ${activeFallbackKey} (${status}). Future sessions preselect fallback until ${until}.`, "warning");
     return true;
   }
 
-  pi.on("agent_start", async (_event, ctx) => {
+  pi.on("before_agent_start", async (_event, ctx) => {
+    cancelled = false;
+    generation += 1;
+    pendingFailure = undefined;
+    responseFailure = undefined;
     await loadConfig(ctx);
     await loadState(ctx);
-    visitedFallbackKeys = new Set();
+    visitedFallbackKeys = new Set(ctx.model ? [modelKey(ctx.model)] : []);
     await applyPersistentFallback(ctx);
     updateStatus(ctx);
   });
 
+  pi.on("agent_start", (_event, ctx) => {
+    // Preselection happens before a run exists; abort once its controller is active.
+    if (cancelled) ctx.abort();
+  });
+
   pi.on("model_select", async (event, ctx) => {
-    if (activeFallbackKey && modelKey(event.model) !== activeFallbackKey) {
+    if (modelKey(event.model) !== activeFallbackKey) {
+      cancelFallback();
       activeFallbackKey = undefined;
       originalModelKey = undefined;
       lastFallbackReason = undefined;
@@ -199,34 +246,53 @@ export default function modelFallback(pi: ExtensionAPI) {
     }
   });
 
-  pi.on("after_provider_response", async (event, ctx) => {
-    const current = ctx.model;
-    const loaded = config ?? (await loadConfig(ctx));
-    if (!current || !loaded) return;
-    if (event.status >= 200 && event.status < 300) return;
+  pi.on("before_provider_request", () => { responseFailure = undefined; });
+  pi.on("after_provider_response", (event, ctx) => {
+    responseFailure = event.status >= 400 && ctx.model
+      ? { modelKey: modelKey(ctx.model), status: event.status, headers: event.headers }
+      : undefined;
+  });
 
-    await persistFailure(modelToRef(current), event.status, event.headers, ctx);
+  pi.on("turn_end", (event) => {
+    const response = responseFailure;
+    responseFailure = undefined;
+    pendingFailure = undefined;
+    const message = event.message;
+    if (message.role !== "assistant" || message.stopReason !== "error") return;
+    const source = { provider: message.provider, model: message.model };
+    const observed = response?.modelKey === modelRefKey(source) ? response : undefined;
+    const errorText = message.errorMessage ?? "";
+    const status = parseStatusFromErrorMessage(errorText) ?? observed?.status;
+    if (status !== undefined) {
+      pendingFailure = { source, status, reason: parseReasonFromErrorMessage(errorText),
+        entryId: event.messageEntryId, headers: observed?.headers ?? {} };
+    }
+  });
+
+  pi.on("agent_before_settle", async (event, ctx) => {
+    const failure = pendingFailure;
+    if (event.outcome !== "error" || cancelled || !failure || !ctx.model || modelKey(ctx.model) !== modelRefKey(failure.source)) return;
+    const visibleFailure = event.context.contextEntries.some((entry) => entry.sourceEntry.id === failure.entryId && entry.messages.some((message) => message.role === "assistant" && message.stopReason === "error"));
+    if (!visibleFailure && !event.context.canContinue) return;
+    pendingFailure = undefined;
+    const currentGeneration = generation;
+    const isCancelled = () => cancelled || generation !== currentGeneration;
+    switching = true;
+    try {
+      const switched = await persistFailure(failure.source, failure.status, failure.headers, ctx, isCancelled, failure.reason);
+      if (!switched || isCancelled() || config?.autoRetry === false) return;
+      return {
+        entries: visibleFailure ? [...event.entries, { type: "context_edit" as const, targetId: failure.entryId, replacement: null }] : event.entries,
+        continue: true,
+      };
+    } finally {
+      switching = false;
+    }
   });
 
-  pi.on("turn_end", async (event, ctx) => {
-    const message = event.message as unknown;
-    if (!isRecord(message) || message.role !== "assistant") return;
-    const errorMessage = typeof message.errorMessage === "string" ? message.errorMessage : undefined;
-    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;
-    const switched = await persistFailure({ provider, model }, status, {}, ctx, reason);
-    if (!switched) return;
-    const loaded = config;
-    if (!loaded || loaded.autoRetry === false) return;
-    const prompt = lastUserPromptText(ctx);
-    if (!prompt) return;
-    ctx.ui.notify(`Model fallback: retrying failed prompt on ${activeFallbackKey}.`, "info");
-    await pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+  pi.on("agent_settled", () => {
+    pendingFailure = undefined;
+    responseFailure = undefined;
   });
 
   pi.registerCommand("model-fallback:status", {
@@ -241,6 +307,7 @@ export default function modelFallback(pi: ExtensionAPI) {
   pi.registerCommand("model-fallback:reset", {
     description: "Return from fallback model to the pre-fallback model when remembered and clear persistent state",
     handler: async (_args, ctx) => {
+      cancelFallback();
       syncPaths(ctx);
       state = { version: 1, entries: [] };
       await writeState(paths.state, state);
@@ -305,6 +372,7 @@ export default function modelFallback(pi: ExtensionAPI) {
       if (!ctx.hasUI) return textResult("Config not saved: confirmation UI is unavailable.", { configPath: paths.config, ...warningDetails(warnings) });
       const ok = await ctx.ui.confirm("Save model fallback config?", summarizeConfig(nextConfig, warnings));
       if (!ok) return textResult("Config not saved.", { configPath: paths.config, ...warningDetails(warnings) });
+      invalidatePending();
       await writeConfig(paths.config, nextConfig);
       config = nextConfig;
       return textResult(configResultText("Config saved.", warnings), { configPath: paths.config, ...warningDetails(warnings) });
@@ -316,29 +384,6 @@ function autoRetryEnabled(config: ModelFallbackConfig): boolean {
   return config.autoRetry !== false;
 }
 
-function lastUserPromptText(ctx: ExtensionContext): string | undefined {
-  const entries = ctx.sessionManager.getEntries() as unknown[];
-  for (let index = entries.length - 1; index >= 0; index -= 1) {
-    const entry = entries[index];
-    if (!isRecord(entry) || !isRecord(entry.message)) continue;
-    const message = entry.message;
-    if (message.role !== "user") continue;
-    return userMessageText(message.content);
-  }
-  return undefined;
-}
-
-function userMessageText(content: unknown): string | undefined {
-  if (typeof content === "string") return content.trim() || undefined;
-  if (!Array.isArray(content)) return undefined;
-  const parts: string[] = [];
-  for (const block of content) {
-    if (isRecord(block) && block.type === "text" && typeof block.text === "string") parts.push(block.text);
-  }
-  const text = parts.join("\n").trim();
-  return text || undefined;
-}
-
 function shouldUseProjectLocalState(ctx: ExtensionContext): boolean {
   const projectSettingsPath = join(ctx.cwd, ".pi", "settings.json");
   return existsSync(projectSettingsPath) && projectSettingsIncludesThisPackage(projectSettingsPath);

package/lib/config.ts

@@ -24,7 +24,7 @@ export interface FallbackRule {
 export interface ModelFallbackConfig {
   version: 1;
   enabled: boolean;
-  /** Re-queue the failed user prompt after switching to the fallback model so the turn retries automatically. Defaults to true. */
+  /** Continue the existing conversation after switching without replaying the user prompt. Defaults to true. */
   autoRetry?: boolean;
   rules: FallbackRule[];
 }

package/lib/error-status.ts

@@ -1,3 +1,5 @@
+import { isRecord } from "./internal.ts";
+
 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"],
@@ -27,9 +29,24 @@ const EMPTY_PROVIDER_RESPONSE_PATTERNS: RegExp[] = [
   /response (has|with) no body/i,
   /stream ended without a terminal event/i,
   /stream ended without finish_reason/i,
+  /^Anthropic stream ended before message_stop$/,
 ];
 
 export function parseStatusFromErrorMessage(message: string): number | undefined {
+  if (message.trimStart().startsWith("{")) {
+    try {
+      const payload: unknown = JSON.parse(message);
+      if (isRecord(payload) && payload.type === "error" && isRecord(payload.error)) {
+        switch (payload.error.type) {
+          case "overloaded_error": return 529;
+          case "rate_limit_error": return 429;
+          case "api_error": return 500;
+        }
+      }
+    } catch {
+      // Non-JSON error text still uses the status patterns below.
+    }
+  }
   for (const pattern of EMPTY_PROVIDER_RESPONSE_PATTERNS) {
     if (pattern.test(message)) {
       // Synthesize 502 so status-based fallback rules fire instead of the
@@ -40,9 +57,8 @@ export function parseStatusFromErrorMessage(message: string): number | undefined
     }
   }
   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,
+    // SDKs use either "429: ..." or "429 {JSON}"; keep ordinary numeric prose unmatched.
+    /^\s*(?:error\s*:?\s*)?([1-5][0-9]{2})(?:\s*:|\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
@@ -51,6 +67,13 @@ export function parseStatusFromErrorMessage(message: string): number | undefined
     // "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,
+    // Parenthesized status inside a provider error wrapper, e.g.
+    // "omni API error (503): overloaded" or "chat_completion_error (429): ...".
+    // Without this the wrapper text sits between "error" and the number, so the
+    // anchored "error <status>" pattern cannot see it and the rule set never
+    // sees a status at all. The wrapper keyword and the parentheses are both
+    // required so prose such as "(503) items processed" stays unmatched.
+    /\b\w*(?:error|failure|failed)\s*\(\s*([1-5][0-9]{2})\s*\)/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|quota|too many requests|service unavailable|bad gateway|gateway timeout|internal server error)\b/i,
@@ -64,5 +87,8 @@ export function parseStatusFromErrorMessage(message: string): number | undefined
     if (Number.isInteger(status) && status >= 100 && status <= 599) return status;
   }
 
+  // Connection failures have no HTTP response; use the existing unavailable-service rules.
+  if (/^\s*(?:error:\s*)?(?:connection error|request timed out|fetch failed)[.!]?\s*$/i.test(message) ||
+      /\b(?:ECONNRESET|ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT)\b/.test(message)) return 503;
   return undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-model-fallback",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "Pi extension that switches to a fallback model after provider failures such as 429 rate limits.",
   "type": "module",
   "license": "MIT",
@@ -45,15 +45,15 @@
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-coding-agent": ">=1.1.0",
     "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
   "devDependencies": {
-    "@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",
+    "@earendil-works/pi-agent-core": "^1.1.0",
+    "@earendil-works/pi-ai": "^1.1.0",
+    "@earendil-works/pi-coding-agent": "^1.1.0",
+    "@earendil-works/pi-tui": "^1.1.0",
     "@types/node": "^26.6.3",
     "jiti": "^2.7.0",
     "typebox": "latest",