@dylanrussell/agent-router 1.0.0

package/dist/plugin.js

@@ -0,0 +1,787 @@
+// src/plugin.ts
+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")
+  };
+}
+
+// src/core/schema.ts
+import { z } from "zod";
+var StateFileSchema = z.object({
+  version: z.literal(1),
+  active: z.string().min(1),
+  previousActive: z.string().min(1).nullable(),
+  lastSwitchedAt: z.string().min(1)
+}).strict();
+var AgentEntrySchema = z.object({
+  model: z.string().min(1)
+}).passthrough();
+var StackFileSchema = z.object({
+  agents: z.record(z.string(), AgentEntrySchema)
+}).passthrough().refine((s) => Object.keys(s.agents).length > 0, {
+  message: "Stack file must map at least one agent in `agents`."
+});
+var ConfigFileSchema = z.object({
+  /** Where the agent .md files live. Default: `${opencodeConfigDir}/agents`. */
+  agentsDir: z.string().min(1).optional(),
+  /** Where named stacks live. Default: `${routerHome}/stacks`. */
+  stacksDir: z.string().min(1).optional()
+}).strict();
+var OpencodeJsonSchema = z.object({
+  plugin: z.array(z.string()).optional()
+}).passthrough();
+
+// src/core/config.ts
+var CONFIG_FILE_NAME = "config.json";
+function expandHome(p) {
+  if (p === "~") return homedir2();
+  if (p.startsWith("~/")) return path2.join(homedir2(), p.slice(2));
+  return p;
+}
+async function readConfigFile(routerHome) {
+  const configPath = path2.join(routerHome, CONFIG_FILE_NAME);
+  if (!existsSync(configPath)) return null;
+  let raw;
+  try {
+    raw = await readFile(configPath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${configPath}: ${cause.message}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `agent-router config.json is not valid JSON: ${cause.message}`,
+      configPath
+    );
+  }
+  const result = ConfigFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `agent-router config.json failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      configPath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+function normalizeConfigPath(routerHome, p) {
+  const expanded = expandHome(p);
+  return path2.isAbsolute(expanded) ? expanded : path2.resolve(routerHome, expanded);
+}
+async function resolvePathsWithConfig(options = {}) {
+  const base = resolvePaths(options);
+  const config = await readConfigFile(base.routerHome);
+  if (!config) return base;
+  const next = { ...options };
+  if (options.agentsDir === void 0 && config.agentsDir) {
+    next.agentsDir = normalizeConfigPath(
+      base.routerHome,
+      config.agentsDir
+    );
+  }
+  if (options.stacksDir === void 0 && config.stacksDir) {
+    next.stacksDir = normalizeConfigPath(
+      base.routerHome,
+      config.stacksDir
+    );
+  }
+  return resolvePaths(next);
+}
+
+// src/core/frontmatter.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, readdir } from "fs/promises";
+import path3 from "path";
+var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+var MODEL_LINE_RE = /^model:[ \t]*(.*)$/m;
+function cleanModelValue(raw) {
+  let v = raw;
+  const hash = v.search(/[ \t]#/);
+  if (hash >= 0) v = v.slice(0, hash);
+  v = v.trim();
+  if (v.startsWith('"') && v.endsWith('"') && v.length >= 2 || v.startsWith("'") && v.endsWith("'") && v.length >= 2) {
+    v = v.slice(1, -1);
+  }
+  return v;
+}
+function getFrontmatterModel(content) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) return null;
+  const line = MODEL_LINE_RE.exec(fm[1]);
+  if (!line) return null;
+  const value = cleanModelValue(line[1] ?? "");
+  return value.length > 0 ? value : null;
+}
+function setFrontmatterModel(content, model) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) throw new Error("no frontmatter block");
+  const block = fm[1];
+  if (!MODEL_LINE_RE.test(block)) throw new Error("no `model:` line in frontmatter");
+  const nextBlock = block.replace(MODEL_LINE_RE, () => `model: ${model}`);
+  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`);
+}
+async function listAgentFiles(agentsDir) {
+  if (!existsSync2(agentsDir)) return [];
+  let names;
+  try {
+    names = await readdir(agentsDir);
+  } catch (cause) {
+    throw new IOError(`Failed to read agents dir: ${cause.message}`, cause);
+  }
+  return names.filter((n) => n.endsWith(".md")).map((n) => n.slice(0, -".md".length)).sort();
+}
+async function readAgentModels(agentsDir) {
+  const out = {};
+  for (const name of await listAgentFiles(agentsDir)) {
+    const filePath = agentFilePath(agentsDir, name);
+    let content;
+    try {
+      content = await readFile2(filePath, "utf8");
+    } catch (cause) {
+      throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+    }
+    const model = getFrontmatterModel(content);
+    if (model !== null) out[name] = model;
+  }
+  return out;
+}
+async function readAgentFileStrict(agentsDir, name) {
+  const filePath = agentFilePath(agentsDir, name);
+  if (!existsSync2(filePath)) {
+    throw new AgentFileError(name, filePath, "file does not exist");
+  }
+  let content;
+  try {
+    content = await readFile2(filePath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+  }
+  const model = getFrontmatterModel(content);
+  if (model === null) {
+    throw new AgentFileError(name, filePath, "no frontmatter `model:` line to rewrite");
+  }
+  return { filePath, content, model };
+}
+
+// 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";
+
+// src/core/backups.ts
+import { existsSync as existsSync3 } from "fs";
+import { copyFile, mkdir as mkdir2 } from "fs/promises";
+import path5 from "path";
+function timestampStamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+
+// src/core/history.ts
+function filename(fromStack, toStack, when = /* @__PURE__ */ new Date()) {
+  const stamp = timestampStamp(when);
+  const safe = (s) => s.replace(/[^A-Za-z0-9._()-]/g, "_");
+  return `${stamp}__${safe(fromStack)}-to-${safe(toStack)}.json`;
+}
+function parseHistoryFilename(name) {
+  if (!name.endsWith(".json")) return null;
+  const stem = name.slice(0, -".json".length);
+  const sep = stem.indexOf("__");
+  if (sep < 0) return null;
+  const stamp = stem.slice(0, sep);
+  const rest = stem.slice(sep + 2);
+  const toIdx = rest.lastIndexOf("-to-");
+  if (toIdx < 0) return null;
+  return {
+    id: stem,
+    timestamp: stamp,
+    fromStack: rest.slice(0, toIdx),
+    toStack: rest.slice(toIdx + "-to-".length)
+  };
+}
+async function appendHistory(historyDir, fromStack, toStack, displacedContent) {
+  await mkdir3(historyDir, { recursive: true });
+  const name = filename(fromStack, toStack);
+  await atomicWriteFile(path6.join(historyDir, name), displacedContent);
+  return name.slice(0, -".json".length);
+}
+async function listHistory(historyDir) {
+  let names;
+  try {
+    names = await readdir2(historyDir);
+  } catch (cause) {
+    if (cause.code === "ENOENT") return [];
+    throw new IOError(`Failed to read history dir: ${cause.message}`, cause);
+  }
+  const entries = [];
+  for (const n of names) {
+    const parsed = parseHistoryFilename(n);
+    if (parsed) entries.push({ ...parsed, path: path6.join(historyDir, n) });
+  }
+  entries.sort((a, b) => a.timestamp < b.timestamp ? 1 : a.timestamp > b.timestamp ? -1 : 0);
+  return entries;
+}
+async function trimHistory(historyDir, keep = 20) {
+  const all = await listHistory(historyDir);
+  if (all.length <= keep) return [];
+  const toDelete = all.slice(keep);
+  const deleted = [];
+  for (const e of toDelete) {
+    try {
+      await unlink2(e.path);
+      deleted.push(e.id);
+    } catch (cause) {
+      void cause;
+    }
+  }
+  return deleted;
+}
+
+// src/core/state.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+async function readState(statePath) {
+  if (!existsSync4(statePath)) return null;
+  let raw;
+  try {
+    raw = await readFile3(statePath, "utf8");
+  } catch (cause) {
+    throw new IOError(`Failed to read ${statePath}: ${cause.message}`, cause);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `state.json is not valid JSON: ${cause.message}`,
+      statePath
+    );
+  }
+  const result = StateFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `state.json failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      statePath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+async function writeState(statePath, state) {
+  const result = StateFileSchema.safeParse(state);
+  if (!result.success) {
+    throw new ValidationError(
+      `Refusing to write invalid state.json: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      statePath
+    );
+  }
+  await atomicWriteJson(statePath, result.data);
+}
+
+// src/core/validator.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var DEFAULT_RUNNER = async () => {
+  const { stdout } = await execFileAsync("opencode", ["models"], {
+    encoding: "utf8",
+    timeout: 3e4,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  return stdout;
+};
+function parseModelList(stdout) {
+  const out = /* @__PURE__ */ new Set();
+  for (const raw of stdout.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("#")) continue;
+    out.add(line);
+  }
+  return out;
+}
+function collectModelRefs(stack) {
+  const refs = [];
+  for (const [k, v] of Object.entries(stack.agents)) {
+    refs.push({ path: `agents.${k}.model`, modelId: v.model });
+  }
+  return refs;
+}
+async function validateStack(stack, options = {}) {
+  const runner = options.runOpencodeModels ?? DEFAULT_RUNNER;
+  const stdout = await runner();
+  const available = parseModelList(stdout);
+  const refs = collectModelRefs(stack);
+  const missing = refs.filter((r) => !available.has(r.modelId));
+  return { ok: missing.length === 0, checked: refs.length, missing, available };
+}
+async function validateStackOrThrow(stackName, stack, options = {}) {
+  const result = await validateStack(stack, options);
+  if (!result.ok) throw new ModelValidationError(stackName, result.missing);
+  return result;
+}
+
+// src/core/stack-manager.ts
+async function listStacks(paths) {
+  if (!existsSync5(paths.stacksDir)) return [];
+  let names;
+  try {
+    names = await readdir3(paths.stacksDir);
+  } catch (cause) {
+    throw new IOError(`Failed to read stacks dir: ${cause.message}`, cause);
+  }
+  return names.filter((n) => n.endsWith(".json")).map((n) => n.slice(0, -".json".length)).sort();
+}
+function stackPath(paths, name) {
+  return path7.join(paths.stacksDir, `${name}.json`);
+}
+async function readStack(paths, name) {
+  const filePath = stackPath(paths, name);
+  if (!existsSync5(filePath)) {
+    throw new StackNotFoundError(name, await listStacks(paths));
+  }
+  const raw = await readFile4(filePath, "utf8").catch((cause) => {
+    throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (cause) {
+    throw new ValidationError(
+      `Stack "${name}" is not valid JSON: ${cause.message}`,
+      filePath
+    );
+  }
+  const result = StackFileSchema.safeParse(parsed);
+  if (!result.success) {
+    throw new ValidationError(
+      `Stack "${name}" failed validation: ${result.error.issues.map((i) => i.message).join("; ")}`,
+      filePath,
+      result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`)
+    );
+  }
+  return result.data;
+}
+async function getActiveStackName(paths) {
+  const state = await readState(paths.statePath);
+  return state?.active ?? null;
+}
+async function applyStack(paths, name, options = {}) {
+  const validate = options.validate ?? true;
+  const forceInvalid = options.forceInvalid ?? false;
+  const target = await readStack(paths, name);
+  if (validate && !forceInvalid) {
+    await validateStackOrThrow(name, target, options.validateOptions);
+  }
+  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 prevState = await readState(paths.statePath);
+  const prevActive = prevState?.active ?? null;
+  const displaced = { agents: modelsToStackAgents(await readAgentModels(paths.agentsDir)) };
+  const historyId = await appendHistory(
+    paths.historyDir,
+    prevActive ?? "(none)",
+    name,
+    `${JSON.stringify(displaced, null, 2)}
+`
+  );
+  const changed = [];
+  for (const p of pending) {
+    if (p.next === null) continue;
+    await atomicWriteFile(p.filePath, p.next);
+    changed.push(p.agent);
+  }
+  await writeState(paths.statePath, {
+    version: 1,
+    active: name,
+    previousActive: prevActive,
+    lastSwitchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await trimHistory(paths.historyDir).catch(() => {
+  });
+  return {
+    previous: prevActive,
+    current: name,
+    changed,
+    historyId,
+    restartRequired: true
+  };
+}
+function modelsToStackAgents(models) {
+  const out = {};
+  for (const k of Object.keys(models).sort()) {
+    const model = models[k];
+    if (model !== void 0) out[k] = { model };
+  }
+  return out;
+}
+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);
+  if (!state || !state.previousActive) {
+    throw new UserError("No previous stack to revert to.");
+  }
+  if (n === 1) return applyStack(paths, state.previousActive, options);
+  const entries = await listHistory(paths.historyDir);
+  if (entries.length < n) {
+    throw new UserError(
+      `Cannot go back ${n} steps; only ${entries.length} switch${entries.length === 1 ? "" : "es"} in history.`
+    );
+  }
+  const target = entries[n - 1]?.fromStack;
+  if (!target || target === "(none)") {
+    throw new UserError(`Cannot go back ${n} steps to a non-stack target ("${target}").`);
+  }
+  return applyStack(paths, target, options);
+}
+var STACK_NAME_RE = /^[A-Za-z0-9._-]+$/;
+function assertValidStackName(name) {
+  if (!STACK_NAME_RE.test(name)) {
+    throw new UserError(
+      `Stack name "${name}" contains invalid characters. Allowed: A-Z a-z 0-9 . _ -`
+    );
+  }
+}
+async function captureStack(paths, name, options = {}) {
+  assertValidStackName(name);
+  const dest = stackPath(paths, name);
+  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);
+  if (Object.keys(agents).length === 0) {
+    throw new UserError(
+      `No agent .md files with a frontmatter \`model:\` line found in ${paths.agentsDir}.`
+    );
+  }
+  await mkdir4(paths.stacksDir, { recursive: true });
+  await atomicWriteJson(dest, { agents });
+  return { name, path: dest, agents: Object.keys(agents).length };
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/plugin.ts
+async function safeToast(client, message, variant = "success") {
+  try {
+    if (client.tui?.toast?.show) {
+      await client.tui.toast.show({ body: { message, variant } });
+      return;
+    }
+  } catch {
+  }
+  await client.app?.log?.({
+    body: { service: "agent-router", level: "info", message: `[toast-fallback] ${message}` }
+  }).catch(() => {
+  });
+}
+function ok(value) {
+  return { output: JSON.stringify(value, null, 2), metadata: value };
+}
+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) => {
+  const paths = await resolvePathsWithConfig();
+  const client = ctx.client;
+  await client.app?.log?.({
+    body: {
+      service: "agent-router",
+      level: "info",
+      message: "init",
+      extra: {
+        version: VERSION,
+        active: await getActiveStackName(paths).catch(() => null) ?? "(none)",
+        routerHome: paths.routerHome
+      }
+    }
+  }).catch(() => {
+  });
+  return {
+    tool: {
+      router_status: tool({
+        description: "Report the active agent-router stack, the current agent \u2192 model frontmatter mapping, and all available stacks.",
+        args: {},
+        async execute() {
+          try {
+            const [active, available, current] = await Promise.all([
+              getActiveStackName(paths),
+              listStacks(paths),
+              readAgentModels(paths.agentsDir)
+            ]);
+            return ok({ active, available, current });
+          } catch (e) {
+            return errOut(e);
+          }
+        }
+      }),
+      router_list: tool({
+        description: "List all agent-router stacks with isActive flags.",
+        args: {},
+        async execute() {
+          try {
+            const [active, available] = await Promise.all([
+              getActiveStackName(paths),
+              listStacks(paths)
+            ]);
+            return ok(available.map((name) => ({ name, isActive: name === active })));
+          } catch (e) {
+            return errOut(e);
+          }
+        }
+      }),
+      router_use: tool({
+        description: "Apply an agent-router stack: rewrite each agent file's frontmatter model. Validates model IDs first. Restart opencode for changes to take effect.",
+        args: {
+          name: tool.schema.string().describe("Stack name to apply (see router_list)."),
+          validate: tool.schema.boolean().optional().describe("Default true. Reject the switch if any model ID is unreachable.")
+        },
+        async execute(args) {
+          try {
+            const r = await applyStack(paths, args.name, {
+              validate: args.validate ?? true
+            });
+            await safeToast(
+              client,
+              `agent-router: switched to "${r.current}". Restart opencode for change to take effect.`
+            );
+            return ok({
+              previous: r.previous,
+              current: r.current,
+              changed: r.changed,
+              restartRequired: true
+            });
+          } catch (e) {
+            return errOut(e);
+          }
+        }
+      }),
+      router_capture: tool({
+        description: "Snapshot the current agent \u2192 model frontmatter mapping into a named agent-router stack.",
+        args: {
+          name: tool.schema.string().describe("Name for the new stack."),
+          force: tool.schema.boolean().optional().describe("Default false. Overwrite an existing stack of the same name.")
+        },
+        async execute(args) {
+          try {
+            const r = await captureStack(paths, args.name, { force: args.force ?? false });
+            return ok({ name: r.name, path: r.path, agents: r.agents });
+          } catch (e) {
+            return errOut(e);
+          }
+        }
+      }),
+      router_validate: tool({
+        description: "Validate that every model ID in a stack (or the current frontmatter) is reachable through current opencode auth.",
+        args: {
+          name: tool.schema.string().optional().describe("Stack name; omit when using `active`."),
+          active: tool.schema.boolean().optional().describe("Validate the models currently in agent frontmatter instead.")
+        },
+        async execute(args) {
+          try {
+            let stack;
+            if (args.active) {
+              const models = await readAgentModels(paths.agentsDir);
+              stack = {
+                agents: Object.fromEntries(
+                  Object.entries(models).map(([k, model]) => [k, { model }])
+                )
+              };
+            } else if (args.name) {
+              stack = await readStack(paths, args.name);
+            } else {
+              return errOut(new Error("Pass `name` or `active: true`."));
+            }
+            const r = await validateStack(StackFileSchema.parse(stack));
+            return ok({
+              ok: r.ok,
+              checked: r.checked,
+              missing: r.missing.map((m) => ({ path: m.path, modelId: m.modelId }))
+            });
+          } catch (e) {
+            return errOut(e);
+          }
+        }
+      }),
+      router_back: tool({
+        description: "Undo the last N agent-router switches (default 1). Restart opencode for changes to take effect.",
+        args: {
+          n: tool.schema.number().optional().describe("How many switches to undo.")
+        },
+        async execute(args) {
+          try {
+            const r = await back(paths, args.n ?? 1);
+            await safeToast(
+              client,
+              `agent-router: reverted to "${r.current}". Restart opencode for change to take effect.`
+            );
+            return ok({
+              previous: r.previous,
+              current: r.current,
+              restartRequired: true
+            });
+          } catch (e) {
+            return errOut(e);
+          }
+        }
+      })
+    }
+  };
+};
+var plugin_default = AgentRouterPlugin;
+export {
+  AgentRouterPlugin,
+  plugin_default as default
+};
+//# sourceMappingURL=plugin.js.map