@dylanrussell/agent-router 1.1.2 → 2.0.0

package/dist/plugin.js

@@ -5,104 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/plugin.ts
-import { readFileSync } from "fs";
-import { tool } from "@opencode-ai/plugin";
-
-// src/core/config.ts
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import path2 from "path";
-
-// src/core/errors.ts
-var RouterError = class extends Error {
-  /** CLI exit code for this error class. Subclasses override. */
-  static exitCode = 1;
-  name = "RouterError";
-};
-var StackNotFoundError = class extends RouterError {
-  constructor(stackName, available) {
-    super(
-      `Stack "${stackName}" not found. Available: ${available.length ? available.join(", ") : "(none)"}.`
-    );
-    this.stackName = stackName;
-    this.available = available;
-  }
-  stackName;
-  available;
-  static exitCode = 2;
-  name = "StackNotFoundError";
-};
-var AgentFileError = class extends RouterError {
-  constructor(agentName, filePath, reason) {
-    super(`Agent "${agentName}" (${filePath}): ${reason}`);
-    this.agentName = agentName;
-    this.filePath = filePath;
-  }
-  agentName;
-  filePath;
-  static exitCode = 2;
-  name = "AgentFileError";
-};
-var ValidationError = class extends RouterError {
-  constructor(message, path8, issues) {
-    super(message);
-    this.path = path8;
-    this.issues = issues;
-  }
-  path;
-  issues;
-  static exitCode = 4;
-  name = "ValidationError";
-};
-var ModelValidationError = class extends RouterError {
-  constructor(stackName, missing) {
-    super(
-      `Stack "${stackName}" references ${missing.length} unreachable model ID${missing.length === 1 ? "" : "s"}.`
-    );
-    this.stackName = stackName;
-    this.missing = missing;
-  }
-  stackName;
-  missing;
-  static exitCode = 4;
-  name = "ModelValidationError";
-};
-var IOError = class extends RouterError {
-  static exitCode = 3;
-  name = "IOError";
-  causedBy;
-  constructor(message, causedBy) {
-    super(message);
-    this.causedBy = causedBy;
-  }
-};
-var UserError = class extends RouterError {
-  static exitCode = 1;
-  name = "UserError";
-};
-
-// src/core/paths.ts
-import { homedir } from "os";
-import path from "path";
-function resolvePaths(options = {}) {
-  const env = options.env ?? process.env;
-  const opencodeConfigDir = options.opencodeConfigDir ?? path.join(env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config"), "opencode");
-  const routerHome = options.routerHome ?? env.AGENT_ROUTER_HOME ?? env.OMO_ROUTER_HOME ?? path.join(opencodeConfigDir, "agent-router");
-  const agentsDir = options.agentsDir ?? env.AGENT_ROUTER_AGENTS_DIR ?? path.join(opencodeConfigDir, "agents");
-  const stacksDir = options.stacksDir ?? env.AGENT_ROUTER_STACKS_DIR ?? path.join(routerHome, "stacks");
-  return {
-    opencodeConfigDir,
-    opencodeJsonPath: path.join(opencodeConfigDir, "opencode.json"),
-    tuiJsonPath: path.join(opencodeConfigDir, "tui.json"),
-    agentsDir,
-    opencodeBackupsDir: path.join(opencodeConfigDir, ".backups"),
-    routerHome,
-    statePath: path.join(routerHome, "state.json"),
-    stacksDir,
-    historyDir: path.join(routerHome, "history")
-  };
-}
+import { readFileSync as readFileSync2 } from "fs";
 
 // node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -14618,6 +14521,105 @@ function date4(params) {
 // node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 
+// src/v2.ts
+import { readFileSync } from "fs";
+
+// src/core/config.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path2 from "path";
+
+// src/core/errors.ts
+var RouterError = class extends Error {
+  /** CLI exit code for this error class. Subclasses override. */
+  static exitCode = 1;
+  name = "RouterError";
+};
+var StackNotFoundError = class extends RouterError {
+  constructor(stackName, available) {
+    super(
+      `Stack "${stackName}" not found. Available: ${available.length ? available.join(", ") : "(none)"}.`
+    );
+    this.stackName = stackName;
+    this.available = available;
+  }
+  stackName;
+  available;
+  static exitCode = 2;
+  name = "StackNotFoundError";
+};
+var AgentFileError = class extends RouterError {
+  constructor(agentName, filePath, reason) {
+    super(`Agent "${agentName}" (${filePath}): ${reason}`);
+    this.agentName = agentName;
+    this.filePath = filePath;
+  }
+  agentName;
+  filePath;
+  static exitCode = 2;
+  name = "AgentFileError";
+};
+var ValidationError = class extends RouterError {
+  constructor(message, path8, issues) {
+    super(message);
+    this.path = path8;
+    this.issues = issues;
+  }
+  path;
+  issues;
+  static exitCode = 4;
+  name = "ValidationError";
+};
+var ModelValidationError = class extends RouterError {
+  constructor(stackName, missing) {
+    super(
+      `Stack "${stackName}" references ${missing.length} unreachable model ID${missing.length === 1 ? "" : "s"}.`
+    );
+    this.stackName = stackName;
+    this.missing = missing;
+  }
+  stackName;
+  missing;
+  static exitCode = 4;
+  name = "ModelValidationError";
+};
+var IOError = class extends RouterError {
+  static exitCode = 3;
+  name = "IOError";
+  causedBy;
+  constructor(message, causedBy) {
+    super(message);
+    this.causedBy = causedBy;
+  }
+};
+var UserError = class extends RouterError {
+  static exitCode = 1;
+  name = "UserError";
+};
+
+// src/core/paths.ts
+import { homedir } from "os";
+import path from "path";
+function resolvePaths(options = {}) {
+  const env = options.env ?? process.env;
+  const opencodeConfigDir = options.opencodeConfigDir ?? path.join(env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config"), "opencode");
+  const routerHome = options.routerHome ?? env.AGENT_ROUTER_HOME ?? env.OMO_ROUTER_HOME ?? path.join(opencodeConfigDir, "agent-router");
+  const agentsDir = options.agentsDir ?? env.AGENT_ROUTER_AGENTS_DIR ?? path.join(opencodeConfigDir, "agents");
+  const stacksDir = options.stacksDir ?? env.AGENT_ROUTER_STACKS_DIR ?? path.join(routerHome, "stacks");
+  return {
+    opencodeConfigDir,
+    opencodeJsonPath: path.join(opencodeConfigDir, "opencode.json"),
+    tuiJsonPath: path.join(opencodeConfigDir, "cli.json"),
+    agentsDir,
+    opencodeBackupsDir: path.join(opencodeConfigDir, ".backups"),
+    routerHome,
+    statePath: path.join(routerHome, "state.json"),
+    stacksDir,
+    historyDir: path.join(routerHome, "history")
+  };
+}
+
 // src/core/schema.ts
 var FallbackSchema = external_exports.object({
   model: external_exports.string().regex(/^[^/\s]+\/\S+$/, "Expected provider/model"),
@@ -14652,7 +14654,13 @@ var ConfigFileSchema = external_exports.object({
   stacksDir: external_exports.string().min(1).optional()
 }).strict();
 var OpencodeJsonSchema = external_exports.object({
-  plugin: external_exports.array(external_exports.string()).optional()
+  plugin: external_exports.array(external_exports.string()).optional(),
+  plugins: external_exports.array(
+    external_exports.union([
+      external_exports.string(),
+      external_exports.object({ package: external_exports.string(), options: external_exports.record(external_exports.string(), external_exports.unknown()).optional() }).passthrough()
+    ])
+  ).optional()
 }).passthrough();
 
 // src/core/config.ts
@@ -14768,6 +14776,10 @@ function createFailover(routes, notice) {
   const notify = (message) => notice(`agent-router: ${message}`).catch(() => {
   });
   return {
+    active(sessionID) {
+      const state = sessions.get(sessionID);
+      return enabled && Boolean(state?.turn) && !state?.disabled;
+    },
     disable() {
       enabled = false;
       sessions.clear();
@@ -14865,10 +14877,54 @@ function createFailover(routes, notice) {
   };
 }
 
+// src/core/stack-manager.ts
+import { existsSync as existsSync5 } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir4, readFile as readFile4, readdir as readdir3, unlink as unlink3 } from "fs/promises";
+import path7 from "path";
+
+// src/core/atomic-write.ts
+import { randomBytes } from "crypto";
+import { mkdir, realpath, rename, unlink, writeFile } from "fs/promises";
+import path3 from "path";
+async function resolveDestination(destPath) {
+  try {
+    return await realpath(destPath);
+  } catch {
+    try {
+      const dir = await realpath(path3.dirname(destPath));
+      return path3.join(dir, path3.basename(destPath));
+    } catch {
+      return destPath;
+    }
+  }
+}
+async function atomicWriteFile(destPath, contents) {
+  await mkdir(path3.dirname(destPath), { recursive: true });
+  const dest = await resolveDestination(destPath);
+  const dir = path3.dirname(dest);
+  const tmp = path3.join(
+    dir,
+    `.${path3.basename(dest)}.artmp-${process.pid}-${randomBytes(4).toString("hex")}`
+  );
+  try {
+    await writeFile(tmp, contents, { encoding: "utf8", mode: 420 });
+    await rename(tmp, dest);
+  } catch (cause) {
+    await unlink(tmp).catch(() => {
+    });
+    throw new IOError(`Atomic write failed for ${destPath}: ${cause.message}`, cause);
+  }
+}
+async function atomicWriteJson(destPath, value) {
+  const text = `${JSON.stringify(value, null, 2)}
+`;
+  await atomicWriteFile(destPath, text);
+}
+
 // src/core/frontmatter.ts
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2, readdir } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 
 // src/core/yaml-lite.ts
 var RESERVED_WORDS = /* @__PURE__ */ new Set([
@@ -15157,6 +15213,11 @@ var RESERVED_AGENT_KEYS = /* @__PURE__ */ new Set([
   "mode",
   "description",
   "permission",
+  "permissions",
+  "disabled",
+  "disable",
+  "system",
+  "hidden",
   "color",
   "tools",
   "prompt",
@@ -15241,7 +15302,7 @@ function setFrontmatterOptions(content, options) {
   return nextFm + content.slice(fm[0].length);
 }
 function agentFilePath(agentsDir, name) {
-  return path3.join(agentsDir, `${name}.md`);
+  return path4.join(agentsDir, `${name}.md`);
 }
 async function listAgentFiles(agentsDir) {
   if (!existsSync2(agentsDir)) return [];
@@ -15293,50 +15354,6 @@ async function readAgentFileStrict(agentsDir, name) {
   return { filePath, content, model, options: getFrontmatterOptions(content) };
 }
 
-// src/core/stack-manager.ts
-import { existsSync as existsSync5 } from "fs";
-import { copyFile as copyFile2, mkdir as mkdir4, readFile as readFile4, readdir as readdir3, unlink as unlink3 } from "fs/promises";
-import path7 from "path";
-
-// src/core/atomic-write.ts
-import { randomBytes } from "crypto";
-import { mkdir, realpath, rename, unlink, writeFile } from "fs/promises";
-import path4 from "path";
-async function resolveDestination(destPath) {
-  try {
-    return await realpath(destPath);
-  } catch {
-    try {
-      const dir = await realpath(path4.dirname(destPath));
-      return path4.join(dir, path4.basename(destPath));
-    } catch {
-      return destPath;
-    }
-  }
-}
-async function atomicWriteFile(destPath, contents) {
-  await mkdir(path4.dirname(destPath), { recursive: true });
-  const dest = await resolveDestination(destPath);
-  const dir = path4.dirname(dest);
-  const tmp = path4.join(
-    dir,
-    `.${path4.basename(dest)}.artmp-${process.pid}-${randomBytes(4).toString("hex")}`
-  );
-  try {
-    await writeFile(tmp, contents, { encoding: "utf8", mode: 420 });
-    await rename(tmp, dest);
-  } catch (cause) {
-    await unlink(tmp).catch(() => {
-    });
-    throw new IOError(`Atomic write failed for ${destPath}: ${cause.message}`, cause);
-  }
-}
-async function atomicWriteJson(destPath, value) {
-  const text = `${JSON.stringify(value, null, 2)}
-`;
-  await atomicWriteFile(destPath, text);
-}
-
 // src/core/history.ts
 import { mkdir as mkdir3, readdir as readdir2, unlink as unlink2 } from "fs/promises";
 import path6 from "path";
@@ -15455,7 +15472,7 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var DEFAULT_RUNNER = async () => {
-  const { stdout } = await execFileAsync("opencode", ["models"], {
+  const { stdout } = await execFileAsync("opencode", ["api", "model.list"], {
     encoding: "utf8",
     timeout: 3e4,
     maxBuffer: 4 * 1024 * 1024
@@ -15464,6 +15481,17 @@ var DEFAULT_RUNNER = async () => {
 };
 function parseModelList(stdout) {
   const out = /* @__PURE__ */ new Set();
+  if (/^[\[{]/.test(stdout.trimStart())) {
+    const parsed = JSON.parse(stdout);
+    const models = Array.isArray(parsed) ? parsed : parsed.data;
+    for (const model of models) {
+      if (model.enabled === false) continue;
+      const id = `${model.providerID}/${model.id}`;
+      out.add(id);
+      for (const variant of model.variants ?? []) out.add(`${id}#${variant.id}`);
+    }
+    return out;
+  }
   for (const raw of stdout.split(/\r?\n/)) {
     const line = raw.trim();
     if (!line) continue;
@@ -15488,6 +15516,19 @@ async function validateStack(stack, options = {}) {
   const available = parseModelList(stdout);
   const refs = collectModelRefs(stack);
   const missing = refs.filter((r) => !available.has(r.modelId));
+  if (/^[\[{]/.test(stdout.trimStart())) {
+    for (const [agent, entry] of Object.entries(stack.agents)) {
+      for (const [index, candidate] of [entry, ...entry.fallbacks ?? []].entries()) {
+        if (!candidate.variant) continue;
+        const modelId = `${candidate.model}#${candidate.variant}`;
+        if (!available.has(modelId))
+          missing.push({
+            path: index === 0 ? `agents.${agent}.variant` : `agents.${agent}.fallbacks.${index - 1}.variant`,
+            modelId
+          });
+      }
+    }
+  }
   return { ok: missing.length === 0, checked: refs.length, missing, available };
 }
 async function validateStackOrThrow(stackName, stack, options = {}) {
@@ -15552,8 +15593,15 @@ async function applyStack(paths, name, options = {}) {
   for (const [agent, entry] of Object.entries(target.agents)) {
     const { filePath, content, model } = await readAgentFileStrict(paths.agentsDir, agent);
     const wantOptions = entryOptions(entry);
+    let wantModel = entry.model;
+    if (model.includes("#") || wantModel.includes("#")) {
+      const [base, inline] = wantModel.split("#");
+      const variant = "variant" in entry ? entry.variant : inline ?? model.split("#")[1];
+      wantModel = `${base}${variant ? `#${variant}` : ""}`;
+      wantOptions.variant = null;
+    }
     const afterOptions = setFrontmatterOptions(content, wantOptions);
-    const nextContent = entry.model === model ? afterOptions : setFrontmatterModel(afterOptions, entry.model);
+    const nextContent = wantModel === model ? afterOptions : setFrontmatterModel(afterOptions, wantModel);
     pending.push({ agent, filePath, next: nextContent === content ? null : nextContent });
   }
   const prevState = await readState(paths.statePath);
@@ -15620,6 +15668,10 @@ function entriesToStackAgents(entries) {
     for (const [k, v] of Object.entries(options)) {
       if (k !== "fallbacks") stackEntry[k] = v;
     }
+    if (model.includes("#")) {
+      stackEntry.model = model.slice(0, model.indexOf("#"));
+      stackEntry.variant = model.slice(model.indexOf("#") + 1);
+    }
     out[name] = stackEntry;
   }
   return out;
@@ -15679,10 +15731,186 @@ async function captureStack(paths, name, options = {}) {
   return { name, path: dest, agents: Object.keys(agents).length };
 }
 
+// src/v2.ts
+async function setupV2(ctx) {
+  const legacy = await AgentRouterPlugin(
+    { client: {} },
+    {
+      runOpencodeModels: async () => JSON.stringify(await ctx.model.list())
+    }
+  );
+  await ctx.tool.transform((editor) => {
+    for (const [name, definition] of Object.entries(legacy.tool ?? {})) {
+      editor.add({
+        name,
+        description: definition.description,
+        input: external_exports.toJSONSchema(external_exports.object(definition.args)),
+        async execute(input) {
+          const execute = definition.execute;
+          const result = await execute(external_exports.object(definition.args).parse(input));
+          return { content: typeof result === "string" ? result : result.output };
+        }
+      });
+    }
+  });
+  const paths = await resolvePathsWithConfig();
+  const state = () => {
+    try {
+      return readFileSync(paths.statePath, "utf8");
+    } catch {
+      return void 0;
+    }
+  };
+  const initial = state();
+  const captured = await captureAgents(paths);
+  const routes = Object.fromEntries(
+    Object.entries(captured).flatMap(([id, entry]) => {
+      const parsed = RoutingEntrySchema.safeParse({
+        model: entry.model,
+        variant: entry.variant,
+        fallbacks: entry.fallbacks
+      });
+      return parsed.success && parsed.data.fallbacks?.length ? [[id, parsed.data]] : [];
+    })
+  );
+  const failover = createFailover(routes, async (message) => {
+    console.warn(message);
+  });
+  const turns = /* @__PURE__ */ new Map();
+  const kinds = /* @__PURE__ */ new Map();
+  const ownSelections = /* @__PURE__ */ new Map();
+  const controller = new AbortController();
+  const events = (async () => {
+    for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+      if (!("sessionID" in event.data)) continue;
+      const sessionID = String(event.data.sessionID);
+      if (!turns.has(sessionID)) continue;
+      if (event.type === "session.model.selected") {
+        const model = event.data.model;
+        if (ownSelections.get(sessionID) === `${model.providerID}/${model.id}#${model.variant ?? ""}`) {
+          ownSelections.delete(sessionID);
+          continue;
+        }
+      }
+      if ([
+        "session.model.selected",
+        "session.agent.selected",
+        "session.execution.interrupted",
+        "session.deleted"
+      ].includes(event.type)) {
+        await failover.event({
+          event: { type: "session.next.model.switched", properties: { sessionID } }
+        });
+        turns.delete(sessionID);
+        kinds.delete(sessionID);
+      }
+    }
+  })().catch((error51) => {
+    if (!controller.signal.aborted) console.warn("agent-router event subscription failed", error51);
+  });
+  await ctx.session.hook("model.request", (event) => {
+    if (turns.has(event.sessionID)) kinds.set(event.sessionID, event.kind);
+  });
+  await ctx.session.hook("prompt", async (event) => {
+    if (turns.get(event.sessionID)?.id === event.messageID) return;
+    if (state() !== initial) {
+      failover.disable();
+      turns.clear();
+      return;
+    }
+    const session = await ctx.session.get({ sessionID: event.sessionID });
+    if (!session.agent || !session.model || !routes[session.agent]) return;
+    const message = {
+      id: event.messageID,
+      agent: session.agent,
+      model: {
+        providerID: session.model.providerID,
+        modelID: session.model.id,
+        variant: session.model.variant
+      }
+    };
+    const before = JSON.stringify(message.model);
+    await failover.message({ sessionID: event.sessionID }, { message });
+    if (!failover.active(event.sessionID)) {
+      turns.delete(event.sessionID);
+      return;
+    }
+    if (before !== JSON.stringify(message.model)) {
+      const latest = await ctx.session.get({ sessionID: event.sessionID });
+      if (!failover.active(event.sessionID) || latest.agent !== session.agent || JSON.stringify(latest.model) !== JSON.stringify(session.model)) {
+        await failover.event({
+          event: {
+            type: "session.next.model.switched",
+            properties: { sessionID: event.sessionID }
+          }
+        });
+        turns.delete(event.sessionID);
+        return;
+      }
+      ownSelections.set(
+        event.sessionID,
+        `${message.model.providerID}/${message.model.modelID}#${message.model.variant ?? ""}`
+      );
+      try {
+        await ctx.session.switchModel({
+          sessionID: event.sessionID,
+          model: {
+            providerID: message.model.providerID,
+            id: message.model.modelID,
+            ...message.model.variant ? { variant: message.model.variant } : {}
+          }
+        });
+      } catch (error51) {
+        ownSelections.delete(event.sessionID);
+        throw error51;
+      }
+    }
+    turns.set(event.sessionID, message);
+  });
+  await ctx.session.hook("retry", async (event) => {
+    const turn = turns.get(event.sessionID);
+    if (!turn || kinds.get(event.sessionID) !== "primary" || turn.agent !== event.agent || turn.model.providerID !== event.model.providerID || turn.model.modelID !== event.model.id)
+      return;
+    if (!event.decision.retry || ![429, 500, 502, 503, 504].includes(event.error.status ?? 0))
+      return;
+    event.decision = { retry: false };
+    await failover.event({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            sessionID: event.sessionID,
+            role: "assistant",
+            parentID: turn.id,
+            agent: turn.agent,
+            ...turn.model,
+            error: {
+              name: "APIError",
+              data: { statusCode: event.error.status, isRetryable: true }
+            }
+          }
+        }
+      }
+    });
+  });
+  return async () => {
+    controller.abort();
+    failover.disable();
+    turns.clear();
+    kinds.clear();
+    ownSelections.clear();
+    await events;
+  };
+}
+
 // src/version.ts
-var VERSION = "1.1.2";
+var VERSION = "2.0.0";
 
 // src/plugin.ts
+var tool = Object.assign(
+  (definition) => definition,
+  { schema: external_exports }
+);
 async function safeToast(client, message, variant = "success") {
   try {
     if (client.tui?.showToast) {
@@ -15709,12 +15937,12 @@ function errOut(e) {
   const msg = e instanceof RouterError ? `${e.name}: ${e.message}` : `${e.name ?? "Error"}: ${e.message}`;
   return { output: JSON.stringify({ error: msg }, null, 2), metadata: { error: msg } };
 }
-var AgentRouterPlugin = async (ctx) => {
+var AgentRouterPlugin = async (ctx, validateOptions) => {
   const paths = await resolvePathsWithConfig();
   const client = ctx.client;
   const stateBytes = () => {
     try {
-      return readFileSync(paths.statePath, "utf8");
+      return readFileSync2(paths.statePath, "utf8");
     } catch {
       return void 0;
     }
@@ -15797,7 +16025,8 @@ var AgentRouterPlugin = async (ctx) => {
           try {
             failover.disable();
             const r = await applyStack(paths, args.name, {
-              validate: args.validate ?? true
+              validate: args.validate ?? true,
+              ...validateOptions ? { validateOptions } : {}
             });
             await safeToast(
               client,
@@ -15845,7 +16074,7 @@ var AgentRouterPlugin = async (ctx) => {
             } else {
               return errOut(new Error("Pass `name` or `active: true`."));
             }
-            const r = await validateStack(StackFileSchema.parse(stack));
+            const r = await validateStack(StackFileSchema.parse(stack), validateOptions);
             return ok({
               ok: r.ok,
               checked: r.checked,
@@ -15882,7 +16111,7 @@ var AgentRouterPlugin = async (ctx) => {
     }
   };
 };
-var plugin_default = AgentRouterPlugin;
+var plugin_default = { id: "agent-router", setup: setupV2 };
 export {
   AgentRouterPlugin,
   plugin_default as default