@dylanrussell/agent-router 1.0.6 → 1.1.0

package/dist/plugin.js

@@ -5,6 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/plugin.ts
+import { readFileSync } from "fs";
 import { tool } from "@opencode-ai/plugin";
 
 // src/core/config.ts
@@ -14618,14 +14619,26 @@ function date4(params) {
 config(en_default());
 
 // src/core/schema.ts
+var FallbackSchema = external_exports.object({
+  model: external_exports.string().regex(/^[^/\s]+\/\S+$/, "Expected provider/model"),
+  variant: external_exports.string().min(1).optional()
+}).strict();
+var RoutingEntrySchema = external_exports.object({
+  model: external_exports.string().min(1),
+  variant: external_exports.string().min(1).nullable().optional(),
+  fallbacks: external_exports.array(FallbackSchema).max(8).optional()
+}).strict();
 var StateFileSchema = external_exports.object({
   version: external_exports.literal(1),
   active: external_exports.string().min(1),
   previousActive: external_exports.string().min(1).nullable(),
-  lastSwitchedAt: external_exports.string().min(1)
+  lastSwitchedAt: external_exports.string().min(1),
+  fallbackAgents: external_exports.record(external_exports.string(), RoutingEntrySchema).optional()
 }).strict();
 var AgentEntrySchema = external_exports.object({
-  model: external_exports.string().min(1)
+  model: external_exports.string().min(1),
+  variant: external_exports.string().min(1).nullable().optional(),
+  fallbacks: external_exports.array(FallbackSchema).max(8).optional()
 }).passthrough();
 var StackFileSchema = external_exports.object({
   agents: external_exports.record(external_exports.string(), AgentEntrySchema)
@@ -14701,12 +14714,455 @@ async function resolvePathsWithConfig(options = {}) {
   return resolvePaths(next);
 }
 
+// src/core/failover.ts
+var Model = external_exports.object({
+  providerID: external_exports.string(),
+  modelID: external_exports.string(),
+  variant: external_exports.string().optional()
+});
+var ErrorInfo = external_exports.object({
+  name: external_exports.string(),
+  data: external_exports.object({ statusCode: external_exports.number().optional(), isRetryable: external_exports.boolean().optional() }).passthrough()
+});
+var Event = external_exports.object({
+  type: external_exports.string(),
+  properties: external_exports.object({
+    sessionID: external_exports.string().optional(),
+    error: ErrorInfo.optional(),
+    info: external_exports.object({
+      id: external_exports.string().optional(),
+      sessionID: external_exports.string().optional(),
+      role: external_exports.string().optional(),
+      parentID: external_exports.string().optional(),
+      agent: external_exports.string().optional(),
+      providerID: external_exports.string().optional(),
+      modelID: external_exports.string().optional(),
+      variant: external_exports.string().optional(),
+      error: ErrorInfo.optional()
+    }).passthrough().optional()
+  }).passthrough()
+});
+function selection(entry) {
+  const slash = entry.model.indexOf("/");
+  return {
+    providerID: entry.model.slice(0, slash),
+    modelID: entry.model.slice(slash + 1),
+    variant: entry.variant ?? void 0
+  };
+}
+function same(a, b) {
+  return a.providerID === b.providerID && a.modelID === b.modelID && a.variant === b.variant;
+}
+function createFailover(routes, notice) {
+  const sessions = /* @__PURE__ */ new Map();
+  let enabled = true;
+  const chains = new Map(
+    Object.entries(routes).map(([agent, entry]) => {
+      const chain = [entry, ...entry.fallbacks ?? []].map(selection);
+      return [
+        agent,
+        chain.filter((value, i) => !chain.slice(0, i).some((previous) => same(previous, value)))
+      ];
+    })
+  );
+  const notify = (message) => notice(`agent-router: ${message}`).catch(() => {
+  });
+  return {
+    disable() {
+      enabled = false;
+      sessions.clear();
+    },
+    async message(input, output) {
+      if (!enabled) return;
+      const message = output.message;
+      const chain = chains.get(message.agent);
+      if (!chain || chain.length < 2) {
+        const existing = sessions.get(input.sessionID);
+        if (existing) {
+          existing.turn = void 0;
+          existing.pending = void 0;
+        }
+        return;
+      }
+      let state = sessions.get(input.sessionID);
+      if (!state) {
+        if (sessions.size >= 1024) return;
+        state = { disabled: false, indices: /* @__PURE__ */ new Map() };
+        sessions.set(input.sessionID, state);
+      }
+      if (state.disabled) return;
+      const current = chain[state.indices.get(message.agent) ?? 0];
+      const primary = chain[0];
+      if (!current || !primary) return;
+      const incoming = message.model;
+      const previous = state.turn?.agent === message.agent ? state.turn : void 0;
+      const pending = previous ? state.pending : void 0;
+      if (!same(incoming, current) && !same(incoming, primary) && !(pending && previous && same(incoming, previous.model))) {
+        state.disabled = true;
+        state.pending = void 0;
+        return;
+      }
+      state.pending = void 0;
+      if (pending) message.model = { ...pending };
+      else message.model = { ...current };
+      state.turn = {
+        agent: message.agent,
+        parent: message.id,
+        model: { ...message.model },
+        handled: false
+      };
+      if (pending)
+        await notify(
+          `[${input.sessionID}] selected ${pending.providerID}/${pending.modelID} for this new turn. No previous prompt or tool was replayed.`
+        );
+    },
+    async event(input) {
+      if (!enabled) return;
+      const parsed = Event.safeParse(input.event);
+      if (!parsed.success) return;
+      const { type, properties: p } = parsed.data;
+      const sessionID = p.sessionID ?? p.info?.sessionID ?? (type === "session.deleted" ? p.info?.id : void 0);
+      if (!sessionID) return;
+      const state = sessions.get(sessionID);
+      if (!state || state.disabled) return;
+      if (type === "session.deleted" || type === "session.next.model.switched" || type === "session.next.agent.switched" || type === "session.error" && p.error?.name === "MessageAbortedError") {
+        state.disabled = true;
+        state.pending = void 0;
+        return;
+      }
+      if (type !== "message.updated") return;
+      const info = p.info;
+      const turn = state.turn;
+      if (!info || !turn || info.role !== "assistant" || info.parentID !== turn.parent || info.agent !== turn.agent || info.providerID !== turn.model.providerID || info.modelID !== turn.model.modelID || !info.error)
+        return;
+      if (info.error.name === "MessageAbortedError") {
+        state.disabled = true;
+        state.pending = void 0;
+        return;
+      }
+      if (turn.handled) return;
+      turn.handled = true;
+      const error51 = info.error;
+      const status = error51.data.statusCode;
+      if (error51.name !== "APIError" || !error51.data.isRetryable || status === void 0 || ![429, 500, 502, 503, 504].includes(status))
+        return;
+      const chain = chains.get(turn.agent);
+      if (!chain) return;
+      const index = (state.indices.get(turn.agent) ?? 0) + 1;
+      const next = chain[index];
+      if (!next) {
+        await notify(
+          `[${sessionID}] fallback chain exhausted for ${turn.agent}. Choose a model manually; no retry was sent.`
+        );
+        return;
+      }
+      state.indices.set(turn.agent, index);
+      state.pending = next;
+      await notify(
+        `[${sessionID}] ${turn.agent} failed (HTTP ${status}). Next user turn will use ${next.providerID}/${next.modelID}${next.variant ? ` (${next.variant})` : ""}. Send an explicit retry/continue instruction after reviewing partial output and completed tools. Nothing was retried automatically.`
+      );
+    }
+  };
+}
+
 // src/core/frontmatter.ts
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2, readdir } from "fs/promises";
 import path3 from "path";
+
+// src/core/yaml-lite.ts
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "null",
+  "true",
+  "false",
+  "yes",
+  "no",
+  "on",
+  "off",
+  "~",
+  // YAML 1.1 nulls
+  "Null",
+  "NULL",
+  "True",
+  "False",
+  "Yes",
+  "No",
+  "On",
+  "Off"
+]);
+var BARE_STRING_RE = /^[A-Za-z0-9._\-\/+@$%^&()~]+$/;
+function needsQuoting(s) {
+  if (s === "") return true;
+  if (RESERVED_WORDS.has(s)) return true;
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s)) return true;
+  if (/^0x[0-9A-Fa-f]+$/.test(s)) return true;
+  if (/^[+-]?\.(inf|Inf|INF|nan|NaN|NAN)$/.test(s)) return true;
+  if (!BARE_STRING_RE.test(s)) return true;
+  return false;
+}
+function serializeOptionValue(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return String(value);
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "string") return needsQuoting(value) ? JSON.stringify(value) : value;
+  return JSON.stringify(value);
+}
+function stripComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (ch === "#" && !inSingle && !inDouble) {
+      if (i === 0 || /\s/.test(line[i - 1] ?? "")) return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function tokenize(block) {
+  const out = [];
+  for (const raw of block.split(/\r?\n/)) {
+    if (raw.trim() === "") continue;
+    const indentMatch = /^( *)/.exec(raw);
+    const indent = indentMatch?.[1]?.length ?? 0;
+    const content = stripComment(raw.slice(indent));
+    if (content.trim() === "") continue;
+    out.push({ indent, text: content.trimEnd(), raw });
+  }
+  return out;
+}
+function coerceScalar(raw) {
+  const v = raw.trim();
+  if (v === "" || v === "null" || v === "~" || v === "Null" || v === "NULL") return null;
+  if (v === "true" || v === "True" || v === "TRUE") return true;
+  if (v === "false" || v === "False" || v === "FALSE") return false;
+  if (v === "yes" || v === "Yes" || v === "YES") return true;
+  if (v === "no" || v === "No" || v === "NO") return false;
+  if (v === "on" || v === "On" || v === "ON") return true;
+  if (v === "off" || v === "Off" || v === "OFF") return false;
+  if (/^[+-]?\d+$/.test(v)) return Number.parseInt(v, 10);
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(v)) return Number.parseFloat(v);
+  if (/^0x[0-9A-Fa-f]+$/.test(v)) return Number.parseInt(v, 16);
+  return v;
+}
+function parseQuoted(s) {
+  const quote = s[0] ?? "";
+  if (quote !== '"' && quote !== "'") return null;
+  if (quote === '"') {
+    let out2 = "";
+    for (let i = 1; i < s.length; i++) {
+      const ch = s[i] ?? "";
+      if (ch === "\\" && i + 1 < s.length) {
+        const next = s[i + 1] ?? "";
+        const map2 = {
+          n: "\n",
+          t: "	",
+          r: "\r",
+          '"': '"',
+          "\\": "\\",
+          "/": "/",
+          b: "\b",
+          f: "\f"
+        };
+        out2 += map2[next] ?? next;
+        i++;
+      } else if (ch === '"') {
+        return { value: out2, rest: s.slice(i + 1) };
+      } else {
+        out2 += ch;
+      }
+    }
+    return null;
+  }
+  let out = "";
+  for (let i = 1; i < s.length; i++) {
+    const ch = s[i] ?? "";
+    if (ch === "'") {
+      if (s[i + 1] === "'") {
+        out += "'";
+        i++;
+      } else {
+        return { value: out, rest: s.slice(i + 1) };
+      }
+    } else {
+      out += ch;
+    }
+  }
+  return null;
+}
+function splitFlow(raw) {
+  const parts = [];
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let start = 0;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (ch === "{" || ch === "[") depth++;
+      else if (ch === "}" || ch === "]") depth--;
+      else if (ch === "," && depth === 0) {
+        parts.push(raw.slice(start, i));
+        start = i + 1;
+      }
+    }
+  }
+  parts.push(raw.slice(start));
+  return parts;
+}
+function parseFlowValue(raw) {
+  const s = raw.trim();
+  if (s === "") return null;
+  const first = s[0] ?? "";
+  if (first === "{") {
+    const inner = s.slice(1, s.length - 1);
+    const obj = {};
+    for (const part of splitFlow(inner)) {
+      const t = part.trim();
+      if (t === "") continue;
+      const colon = findColon(t);
+      if (colon < 0) {
+        obj[t] = null;
+      } else {
+        const k = t.slice(0, colon).trim();
+        const v = t.slice(colon + 1).trim();
+        obj[stripKeyQuotes(k)] = parseFlowValue(v);
+      }
+    }
+    return obj;
+  }
+  if (first === "[") {
+    const inner = s.slice(1, s.length - 1);
+    return splitFlow(inner).filter((p) => p.trim() !== "").map((p) => parseFlowValue(p));
+  }
+  if (first === '"' || first === "'") {
+    const q = parseQuoted(s);
+    return q ? q.value : s;
+  }
+  return coerceScalar(s);
+}
+function findColon(s) {
+  let inSingle = false;
+  let inDouble = false;
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (ch === "{" || ch === "[") depth++;
+      else if (ch === "}" || ch === "]") depth--;
+      else if (ch === ":" && depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function stripKeyQuotes(k) {
+  if (k.length >= 2 && (k[0] === '"' && k.at(-1) === '"' || k[0] === "'" && k.at(-1) === "'")) {
+    return k.slice(1, -1);
+  }
+  return k;
+}
+function parseMapping(lines, startIdx, indent) {
+  const out = {};
+  let i = startIdx;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line) break;
+    if (line.indent < indent) break;
+    if (line.indent > indent) {
+      i++;
+      continue;
+    }
+    const colon = findColon(line.text);
+    if (colon < 0) {
+      i++;
+      continue;
+    }
+    const key = stripKeyQuotes(line.text.slice(0, colon).trim());
+    if (key === "") {
+      i++;
+      continue;
+    }
+    const rest = line.text.slice(colon + 1).trim();
+    if (rest !== "") {
+      out[key] = parseFlowValue(rest);
+      i++;
+    } else {
+      const childIndent = lines[i + 1]?.indent ?? line.indent + 1;
+      let j = i + 1;
+      while (j < lines.length && (lines[j]?.indent ?? -1) >= childIndent) j++;
+      if (j === i + 1) {
+        out[key] = null;
+        i++;
+      } else {
+        const childBlock = lines.slice(i + 1, j);
+        const firstChild = childBlock[0];
+        if (firstChild?.text.trimStart().startsWith("- ")) {
+          out[key] = parseSequence(childBlock, childIndent);
+        } else {
+          out[key] = parseMapping(childBlock, 0, childIndent).value;
+        }
+        i = j;
+      }
+    }
+  }
+  return { value: out, next: i };
+}
+function parseSequence(lines, indent) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line) break;
+    if (line.indent < indent) break;
+    const t = line.text.trimStart();
+    if (!t.startsWith("- ")) {
+      i++;
+      continue;
+    }
+    const item = t.slice(2).trim();
+    if (item === "") {
+      const childIndent = lines[i + 1]?.indent ?? line.indent + 1;
+      let j = i + 1;
+      while (j < lines.length && (lines[j]?.indent ?? -1) >= childIndent) j++;
+      out.push(parseMapping(lines.slice(i + 1, j), 0, childIndent).value);
+      i = j;
+    } else {
+      out.push(parseFlowValue(item));
+      i++;
+    }
+  }
+  return out;
+}
+function parseFrontmatterBlock(block) {
+  const lines = tokenize(block);
+  if (lines.length === 0) return null;
+  const { value } = parseMapping(lines, 0, 0);
+  return value;
+}
+
+// src/core/frontmatter.ts
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 var MODEL_LINE_RE = /^model:[ \t]*(.*)$/m;
+var RESERVED_AGENT_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "mode",
+  "description",
+  "permission",
+  "color",
+  "tools",
+  "prompt",
+  "steps",
+  "maxSteps"
+]);
 function cleanModelValue(raw) {
   let v = raw;
   const hash2 = v.search(/[ \t]#/);
@@ -14735,6 +15191,55 @@ function setFrontmatterModel(content, model) {
   const nextFm = fm[0].slice(0, blockStart) + nextBlock + fm[0].slice(blockStart + block.length);
   return nextFm + content.slice(fm[0].length);
 }
+function getFrontmatterOptions(content) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) return {};
+  const parsed = parseFrontmatterBlock(fm[1]);
+  if (!parsed) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(parsed)) {
+    if (k === "model" || RESERVED_AGENT_KEYS.has(k)) continue;
+    out[k] = v;
+  }
+  return out;
+}
+function setFrontmatterOptions(content, options) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) throw new Error("no frontmatter block");
+  const block = fm[1];
+  const keys = Object.keys(options);
+  if (keys.length === 0) return content;
+  const eol = block.includes("\r\n") ? "\r\n" : "\n";
+  const lines = block.split(/\r?\n/);
+  const handled = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^([A-Za-z0-9_-]+):[ \t]*(.*)$/.exec(lines[i] ?? "");
+    if (!m) continue;
+    const key = m[1] ?? "";
+    if (!(key in options)) continue;
+    handled.add(key);
+    let end = i + 1;
+    while (end < lines.length && /^[ \t]+/.test(lines[end] ?? "")) end++;
+    const value = options[key];
+    if (value === null || value === void 0) {
+      lines.splice(i, end - i);
+      i--;
+    } else {
+      lines.splice(i, end - i, `${key}: ${serializeOptionValue(value)}`);
+    }
+  }
+  const appended = [];
+  for (const [key, value] of Object.entries(options)) {
+    if (handled.has(key)) continue;
+    if (value === null || value === void 0) continue;
+    appended.push(`${key}: ${serializeOptionValue(value)}`);
+  }
+  const nextBlock = appended.length > 0 ? lines.join(eol) + eol + appended.join(eol) : lines.join(eol);
+  if (nextBlock === block) return content;
+  const blockStart = fm[0].indexOf(block);
+  const nextFm = fm[0].slice(0, blockStart) + nextBlock + fm[0].slice(blockStart + block.length);
+  return nextFm + content.slice(fm[0].length);
+}
 function agentFilePath(agentsDir, name) {
   return path3.join(agentsDir, `${name}.md`);
 }
@@ -14748,7 +15253,7 @@ async function listAgentFiles(agentsDir) {
   }
   return names.filter((n) => n.endsWith(".md")).map((n) => n.slice(0, -".md".length)).sort();
 }
-async function readAgentModels(agentsDir) {
+async function readAgentEntries(agentsDir) {
   const out = {};
   for (const name of await listAgentFiles(agentsDir)) {
     const filePath = agentFilePath(agentsDir, name);
@@ -14759,10 +15264,17 @@ async function readAgentModels(agentsDir) {
       throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
     }
     const model = getFrontmatterModel(content);
-    if (model !== null) out[name] = model;
+    if (model === null) continue;
+    out[name] = { model, options: getFrontmatterOptions(content) };
   }
   return out;
 }
+async function readAgentModels(agentsDir) {
+  const entries = await readAgentEntries(agentsDir);
+  const out = {};
+  for (const [name, entry] of Object.entries(entries)) out[name] = entry.model;
+  return out;
+}
 async function readAgentFileStrict(agentsDir, name) {
   const filePath = agentFilePath(agentsDir, name);
   if (!existsSync2(filePath)) {
@@ -14778,7 +15290,7 @@ async function readAgentFileStrict(agentsDir, name) {
   if (model === null) {
     throw new AgentFileError(name, filePath, "no frontmatter `model:` line to rewrite");
   }
-  return { filePath, content, model };
+  return { filePath, content, model, options: getFrontmatterOptions(content) };
 }
 
 // src/core/stack-manager.ts
@@ -14964,6 +15476,9 @@ function collectModelRefs(stack) {
   const refs = [];
   for (const [k, v] of Object.entries(stack.agents)) {
     refs.push({ path: `agents.${k}.model`, modelId: v.model });
+    for (const [index, candidate] of (v.fallbacks ?? []).entries()) {
+      refs.push({ path: `agents.${k}.fallbacks.${index}.model`, modelId: candidate.model });
+    }
   }
   return refs;
 }
@@ -15036,15 +15551,14 @@ async function applyStack(paths, name, options = {}) {
   const pending = [];
   for (const [agent, entry] of Object.entries(target.agents)) {
     const { filePath, content, model } = await readAgentFileStrict(paths.agentsDir, agent);
-    pending.push({
-      agent,
-      filePath,
-      next: model === entry.model ? null : setFrontmatterModel(content, entry.model)
-    });
+    const wantOptions = entryOptions(entry);
+    const afterOptions = setFrontmatterOptions(content, wantOptions);
+    const nextContent = entry.model === model ? afterOptions : setFrontmatterModel(afterOptions, entry.model);
+    pending.push({ agent, filePath, next: nextContent === content ? null : nextContent });
   }
   const prevState = await readState(paths.statePath);
   const prevActive = prevState?.active ?? null;
-  const displaced = { agents: modelsToStackAgents(await readAgentModels(paths.agentsDir)) };
+  const displaced = { agents: await captureAgents(paths) };
   const historyId = await appendHistory(
     paths.historyDir,
     prevActive ?? "(none)",
@@ -15062,7 +15576,20 @@ async function applyStack(paths, name, options = {}) {
     version: 1,
     active: name,
     previousActive: prevActive,
-    lastSwitchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    lastSwitchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fallbackAgents: Object.fromEntries(
+      Object.entries(target.agents).filter(([, entry]) => entry.fallbacks?.length).map(([agent, entry]) => {
+        const variant = "variant" in entry ? entry.variant : displaced.agents[agent]?.variant;
+        return [
+          agent,
+          {
+            model: entry.model,
+            variant: typeof variant === "string" ? variant : void 0,
+            fallbacks: entry.fallbacks
+          }
+        ];
+      })
+    )
   });
   await trimHistory(paths.historyDir).catch(() => {
   });
@@ -15074,14 +15601,40 @@ async function applyStack(paths, name, options = {}) {
     restartRequired: true
   };
 }
-function modelsToStackAgents(models) {
+function entryOptions(entry) {
+  const rec = entry;
   const out = {};
-  for (const k of Object.keys(models).sort()) {
-    const model = models[k];
-    if (model !== void 0) out[k] = { model };
+  for (const [k, v] of Object.entries(rec)) {
+    if (k === "model" || k === "fallbacks" || RESERVED_AGENT_KEYS.has(k)) continue;
+    out[k] = v;
   }
   return out;
 }
+function entriesToStackAgents(entries) {
+  const out = {};
+  for (const name of Object.keys(entries).sort()) {
+    const entry = entries[name];
+    if (!entry) continue;
+    const { model, options } = entry;
+    const stackEntry = { model };
+    for (const [k, v] of Object.entries(options)) {
+      if (k !== "fallbacks") stackEntry[k] = v;
+    }
+    out[name] = stackEntry;
+  }
+  return out;
+}
+async function captureAgents(paths) {
+  const agents = entriesToStackAgents(await readAgentEntries(paths.agentsDir));
+  const state = await readState(paths.statePath);
+  for (const [name, entry] of Object.entries(agents)) {
+    const routing = state?.fallbackAgents?.[name];
+    if (routing && routing.model === entry.model && (routing.variant ?? void 0) === (entry.variant ?? void 0)) {
+      entry.fallbacks = routing.fallbacks;
+    }
+  }
+  return agents;
+}
 async function back(paths, n = 1, options = {}) {
   if (n < 1) throw new UserError("`back -n` must be at least 1.");
   const state = await readState(paths.statePath);
@@ -15115,8 +15668,7 @@ async function captureStack(paths, name, options = {}) {
   if (existsSync5(dest) && !options.force) {
     throw new UserError(`Stack "${name}" already exists. Use --force to overwrite.`);
   }
-  const models = await readAgentModels(paths.agentsDir);
-  const agents = modelsToStackAgents(models);
+  const agents = await captureAgents(paths);
   if (Object.keys(agents).length === 0) {
     throw new UserError(
       `No agent .md files with a frontmatter \`model:\` line found in ${paths.agentsDir}.`
@@ -15128,11 +15680,17 @@ async function captureStack(paths, name, options = {}) {
 }
 
 // src/version.ts
-var VERSION = "1.0.6";
+var VERSION = "1.1.0";
 
 // src/plugin.ts
 async function safeToast(client, message, variant = "success") {
   try {
+    if (client.tui?.showToast) {
+      const result = await client.tui.showToast({ body: { message, variant, duration: 15e3 } });
+      if (result && typeof result === "object" && "error" in result && result.error)
+        throw result.error;
+      return;
+    }
     if (client.tui?.toast?.show) {
       await client.tui.toast.show({ body: { message, variant } });
       return;
@@ -15154,6 +15712,30 @@ function errOut(e) {
 var AgentRouterPlugin = async (ctx) => {
   const paths = await resolvePathsWithConfig();
   const client = ctx.client;
+  const stateBytes = () => {
+    try {
+      return readFileSync(paths.statePath, "utf8");
+    } catch {
+      return void 0;
+    }
+  };
+  const initialState = stateBytes();
+  const captured = await captureAgents(paths).catch(() => ({}));
+  const routes = Object.fromEntries(
+    Object.entries(captured).flatMap(([agent, entry]) => {
+      const parsed = RoutingEntrySchema.safeParse({
+        model: entry.model,
+        variant: entry.variant,
+        fallbacks: entry.fallbacks
+      });
+      return parsed.success && parsed.data.fallbacks?.length ? [[agent, parsed.data]] : [];
+    })
+  );
+  const failover = createFailover(routes, async (message) => {
+    await client.app?.log?.({ body: { service: "agent-router", level: "warn", message } }).catch(() => {
+    });
+    await safeToast(client, message, "warning");
+  });
   await client.app?.log?.({
     body: {
       service: "agent-router",
@@ -15168,6 +15750,11 @@ var AgentRouterPlugin = async (ctx) => {
   }).catch(() => {
   });
   return {
+    event: failover.event,
+    "chat.message": async (input, output) => {
+      if (stateBytes() !== initialState) failover.disable();
+      await failover.message(input, output);
+    },
     tool: {
       router_status: tool({
         description: "Report the active agent-router stack, the current agent \u2192 model frontmatter mapping, and all available stacks.",
@@ -15208,6 +15795,7 @@ var AgentRouterPlugin = async (ctx) => {
         },
         async execute(args) {
           try {
+            failover.disable();
             const r = await applyStack(paths, args.name, {
               validate: args.validate ?? true
             });
@@ -15251,12 +15839,7 @@ var AgentRouterPlugin = async (ctx) => {
           try {
             let stack;
             if (args.active) {
-              const models = await readAgentModels(paths.agentsDir);
-              stack = {
-                agents: Object.fromEntries(
-                  Object.entries(models).map(([k, model]) => [k, { model }])
-                )
-              };
+              stack = { agents: await captureAgents(paths) };
             } else if (args.name) {
               stack = await readStack(paths, args.name);
             } else {
@@ -15280,6 +15863,7 @@ var AgentRouterPlugin = async (ctx) => {
         },
         async execute(args) {
           try {
+            failover.disable();
             const r = await back(paths, args.n ?? 1);
             await safeToast(
               client,