@dylanrussell/agent-router 1.0.7 → 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,6 +14714,157 @@ 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";
@@ -15312,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;
 }
@@ -15391,7 +15558,7 @@ async function applyStack(paths, name, options = {}) {
   }
   const prevState = await readState(paths.statePath);
   const prevActive = prevState?.active ?? null;
-  const displaced = { agents: entriesToStackAgents(await readAgentEntries(paths.agentsDir)) };
+  const displaced = { agents: await captureAgents(paths) };
   const historyId = await appendHistory(
     paths.historyDir,
     prevActive ?? "(none)",
@@ -15409,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(() => {
   });
@@ -15425,7 +15605,7 @@ function entryOptions(entry) {
   const rec = entry;
   const out = {};
   for (const [k, v] of Object.entries(rec)) {
-    if (k === "model" || RESERVED_AGENT_KEYS.has(k)) continue;
+    if (k === "model" || k === "fallbacks" || RESERVED_AGENT_KEYS.has(k)) continue;
     out[k] = v;
   }
   return out;
@@ -15437,11 +15617,24 @@ function entriesToStackAgents(entries) {
     if (!entry) continue;
     const { model, options } = entry;
     const stackEntry = { model };
-    for (const [k, v] of Object.entries(options)) stackEntry[k] = v;
+    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);
@@ -15475,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 entries = await readAgentEntries(paths.agentsDir);
-  const agents = entriesToStackAgents(entries);
+  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}.`
@@ -15488,11 +15680,17 @@ async function captureStack(paths, name, options = {}) {
 }
 
 // src/version.ts
-var VERSION = "1.0.7";
+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;
@@ -15514,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",
@@ -15528,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.",
@@ -15568,6 +15795,7 @@ var AgentRouterPlugin = async (ctx) => {
         },
         async execute(args) {
           try {
+            failover.disable();
             const r = await applyStack(paths, args.name, {
               validate: args.validate ?? true
             });
@@ -15611,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 {
@@ -15640,6 +15863,7 @@ var AgentRouterPlugin = async (ctx) => {
         },
         async execute(args) {
           try {
+            failover.disable();
             const r = await back(paths, args.n ?? 1);
             await safeToast(
               client,