@pragma-sh/opencode-plugin 1.0.2 → 1.1.0

package/dist/index.mjs

@@ -1,17 +1,4 @@
 // ../sdk/dist/index.js
-var PRAGMA_ENV_KEYS = {
-  gatewayUrl: "PRAGMA_GATEWAY_URL",
-  gatewayToken: "PRAGMA_GATEWAY_TOKEN",
-  tabId: "PRAGMA_TAB_ID",
-  worktreeId: "PRAGMA_WORKTREE_ID"
-};
-function readEnv(name, env) {
-  const globalProcess = globalThis.process;
-  return env?.[name] ?? globalProcess?.env?.[name];
-}
-function hasPragmaEnvironment(env) {
-  return Boolean(readEnv(PRAGMA_ENV_KEYS.gatewayUrl, env) && readEnv(PRAGMA_ENV_KEYS.gatewayToken, env) && readEnv(PRAGMA_ENV_KEYS.tabId, env) && readEnv(PRAGMA_ENV_KEYS.worktreeId, env));
-}
 var routes = {
   health: "/v1/health",
   version: "/v1/version",
@@ -39,6 +26,19 @@ var routes = {
   pushTest: "/v1/push/test",
   pushPresence: "/v1/push/presence"
 };
+var PRAGMA_ENV_KEYS = {
+  gatewayUrl: "PRAGMA_GATEWAY_URL",
+  gatewayToken: "PRAGMA_GATEWAY_TOKEN",
+  tabId: "PRAGMA_TAB_ID",
+  worktreeId: "PRAGMA_WORKTREE_ID"
+};
+function readEnv(name, env) {
+  const globalProcess = globalThis.process;
+  return env?.[name] ?? globalProcess?.env?.[name];
+}
+function hasPragmaEnvironment(env) {
+  return Boolean(readEnv(PRAGMA_ENV_KEYS.gatewayUrl, env) && readEnv(PRAGMA_ENV_KEYS.gatewayToken, env) && readEnv(PRAGMA_ENV_KEYS.tabId, env) && readEnv(PRAGMA_ENV_KEYS.worktreeId, env));
+}
 
 class PragmaGatewayError extends Error {
   code;
@@ -267,6 +267,18 @@ class AgentsClient {
       signal: options.signal
     });
   }
+  async launchOptions(agentId, options = {}) {
+    const catalog = await this.catalog(options);
+    const agent = catalog.agents.find((candidate) => candidate.id === agentId);
+    if (!agent) {
+      throw new Error(`agent not found in catalog: ${agentId}`);
+    }
+    return {
+      slashCommands: agent.slashCommands ?? [],
+      modes: agent.modes ?? [],
+      permissionModes: agent.permissionModes ?? []
+    };
+  }
   launch(payload, options = {}) {
     return this.transport.request(routes.control("agentSessionLaunch"), {
       method: "POST",
@@ -506,6 +518,7 @@ function createPragmaOpencodeHooks(reporter) {
   const messageText = new Map;
   const childSessions = new Map;
   const activeChildSessions = new Set;
+  const activeShellCalls = new Set;
   let pendingLegacyQuestion = null;
   let activeCanonicalQuestionId = null;
   const EVENT_HANDLERS = {
@@ -513,6 +526,8 @@ function createPragmaOpencodeHooks(reporter) {
     "session.idle": applySessionIdleEvent,
     "session.error": applySessionErrorEvent,
     "session.deleted": applySessionDeletedEvent,
+    "session.next.shell.started": applyShellStartedEvent,
+    "session.next.shell.ended": applyShellEndedEvent,
     "server.instance.disposed": () => "clear",
     "permission.replied": applyPermissionRepliedEvent,
     "question.replied": applyQuestionRepliedEvent,
@@ -703,6 +718,7 @@ function createPragmaOpencodeHooks(reporter) {
     attention = false;
     childSessions.clear();
     activeChildSessions.clear();
+    activeShellCalls.clear();
     if (lastReported === "cleared") {
       return;
     }
@@ -713,7 +729,7 @@ function createPragmaOpencodeHooks(reporter) {
     if (attention) {
       return `attention:${attentionKind}`;
     }
-    if (busy) {
+    if (busy || activeShellCalls.size > 0) {
       return "started";
     }
     return "stopped";
@@ -761,15 +777,38 @@ function createPragmaOpencodeHooks(reporter) {
     }
     busy = false;
     attention = false;
+    removeShellCalls(sessionIdFromEvent(event));
     removeChildren(sessionIdFromEvent(event));
     return "sync";
   }
   function applySessionDeletedEvent(event) {
     busy = false;
     attention = false;
+    removeShellCalls(sessionIdFromEvent(event));
     removeChildren(sessionIdFromEvent(event));
     return "sync";
   }
+  function applyShellStartedEvent(event) {
+    const key = shellCallKey(event);
+    if (!key)
+      return "none";
+    activeShellCalls.add(key);
+    return "sync";
+  }
+  function applyShellEndedEvent(event) {
+    const key = shellCallKey(event);
+    if (!key || !activeShellCalls.delete(key))
+      return "none";
+    return "sync";
+  }
+  function removeShellCalls(sessionId) {
+    if (!sessionId)
+      return;
+    for (const key of activeShellCalls) {
+      if (key.startsWith(`${sessionId}:`))
+        activeShellCalls.delete(key);
+    }
+  }
   function hasActiveChildren(parentId) {
     for (const childId of activeChildSessions) {
       if (!parentId || childSessions.get(childId) === parentId) {
@@ -985,6 +1024,10 @@ function sessionIdFromEvent(event) {
   }
   return;
 }
+function shellCallKey(event) {
+  const properties = event.properties;
+  return isRecord(properties) && typeof properties.sessionID === "string" && typeof properties.callID === "string" ? `${properties.sessionID}:${properties.callID}` : undefined;
+}
 function assistantTextPart(part) {
   const partType = typeof part.type === "string" ? part.type : undefined;
   if (partType !== "text" && partType !== "reasoning")

package/dist/pragma-plugin.mjs

@@ -1,15 +1,900 @@
-// ../plugin/dist/shared/chunk-e222xk1w.js
-var PLUGIN_API_VERSION = "1.0.1";
+// ../plugin/dist/shared/chunk-b8hkp0vs.js
+var PLUGIN_API_VERSION = "1.2.0";
 
-// ../plugin/dist/shared/chunk-6qx2xj9p.js
+// ../plugin/dist/shared/chunk-whqa76q3.js
 function defineAgent(input) {
   return input;
 }
+function dedupeSlashCommands(commands) {
+  const seen = new Set;
+  return commands.filter((command) => {
+    if (!command.name || seen.has(command.name))
+      return false;
+    seen.add(command.name);
+    return true;
+  });
+}
+var DEFAULT_TIMEOUT_SECONDS = 30;
+var ACP_COMMANDS_TTL_MS = 5 * 60000;
+var MAX_CONCURRENT_PROBES = 2;
+var SETTLE_SECONDS = "1.5";
+var UPDATE_MARKER = "available_commands_update";
+var STATE_KEY = Symbol.for("pragma.acpDiscovery");
+var state = globalThis[STATE_KEY] ??= { cache: new Map, inflight: new Map, running: 0, waiting: [] };
+var { cache, inflight } = state;
+async function discoverAcpSlashCommands(ctx, source) {
+  const cwd = ctx.project?.path ?? "/tmp";
+  const key = `${cwd}\x00${source.command.join("\x00")}`;
+  const cached = cache.get(key);
+  if (cached && Date.now() - cached.at < ACP_COMMANDS_TTL_MS)
+    return cached.commands;
+  const probe = inflight.get(key) ?? startProbe(ctx, source, cwd, key);
+  return cached ? cached.commands : probe;
+}
+function startProbe(ctx, source, cwd, key) {
+  const probe = withProbeSlot(async () => {
+    const [result] = await ctx.sdk.exec.run({ cwd, commands: [acpCommandsScript(source)] });
+    return result?.status === 0 ? parseAcpCommands(result.stdout) : [];
+  }).catch(() => []).then((commands) => {
+    if (commands.length > 0)
+      cache.set(key, { commands, at: Date.now() });
+    return commands;
+  }).finally(() => inflight.delete(key));
+  inflight.set(key, probe);
+  return probe;
+}
+async function withProbeSlot(work) {
+  if (state.running >= MAX_CONCURRENT_PROBES) {
+    await new Promise((resolve) => state.waiting.push(resolve));
+  }
+  state.running += 1;
+  try {
+    return await work();
+  } finally {
+    state.running -= 1;
+    state.waiting.shift()?.();
+  }
+}
+function acpCommandsScript(source) {
+  const ticks = Math.round((source.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 10);
+  const [binary] = source.command;
+  const initialize = JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: { protocolVersion: 1, clientCapabilities: {} }
+  });
+  return [
+    `command -v ${shellQuote(binary ?? "")} >/dev/null 2>&1 || exit 0`,
+    "work=$(mktemp -d) || exit 0",
+    `trap 'rm -rf "$work"' 0`,
+    'mkfifo "$work/in" || exit 0',
+    ': >"$work/out"',
+    "{",
+    `  printf '%s\\n' ${shellQuote(initialize)}`,
+    "  n=0",
+    `  while ! grep -q '"id":1' "$work/out" && [ ! -e "$work/done" ] && [ "$n" -lt ${ticks} ]; do sleep 0.1; n=$((n + 1)); done`,
+    `  printf '{"jsonrpc":"2.0","id":2,"method":"session/new","params":{"cwd":"%s","mcpServers":[]}}\\n' "$PWD"`,
+    `  while [ ! -e "$work/done" ] && [ "$n" -lt ${ticks * 2} ]; do sleep 0.1; n=$((n + 1)); done`,
+    '} >"$work/in" &',
+    "writer=$!",
+    `${source.command.map(shellArg).join(" ")} <"$work/in" >"$work/out" 2>/dev/null &`,
+    "agent=$!",
+    "n=0",
+    `while [ "$n" -lt ${ticks} ]; do`,
+    `  if grep -q ${UPDATE_MARKER} "$work/out"; then sleep ${SETTLE_SECONDS}; break; fi`,
+    "  sleep 0.1; n=$((n + 1))",
+    "done",
+    ': >"$work/done"',
+    'kill "$agent" 2>/dev/null',
+    'wait "$writer" 2>/dev/null',
+    `grep ${UPDATE_MARKER} "$work/out" | tail -n 1`,
+    "exit 0"
+  ].join(`
+`);
+}
+function parseAcpCommands(stdout) {
+  let commands = [];
+  for (const line of stdout.split(`
+`)) {
+    if (!line.includes(UPDATE_MARKER))
+      continue;
+    const parsed = updateCommands(line);
+    if (parsed)
+      commands = parsed;
+  }
+  return commands;
+}
+function updateCommands(line) {
+  let message;
+  try {
+    message = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  const update = record(record(record(message)?.params)?.update);
+  if (update?.sessionUpdate !== UPDATE_MARKER || !Array.isArray(update.availableCommands)) {
+    return null;
+  }
+  return update.availableCommands.flatMap((entry) => {
+    const command = acpCommand(entry);
+    return command ? [command] : [];
+  });
+}
+function acpCommand(entry) {
+  const command = record(entry);
+  const name = text(command?.name).replace(/^\//, "");
+  if (!name)
+    return null;
+  const description = text(command?.description);
+  const argumentHint = text(record(command?.input)?.hint);
+  return {
+    name,
+    ...description ? { description } : {},
+    ...argumentHint ? { argumentHint } : {}
+  };
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function shellArg(value) {
+  return value.split("{tmp}").map((part) => part ? shellQuote(part) : "").join('"$work/tmp"');
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+var RECORD_SEPARATOR = "\x1E";
+var HEAD_LINES = 40;
+var MAX_DEPTH = 8;
+async function discoverMarkdownEntries(ctx, sources) {
+  if (sources.length === 0)
+    return [];
+  const [result] = await ctx.sdk.exec.run({
+    cwd: ctx.project?.path ?? "/tmp",
+    commands: [markdownScanScript(sources)]
+  });
+  if (!result || result.status !== 0)
+    return [];
+  return parseMarkdownScan(result.stdout, sources);
+}
+async function discoverSlashCommands(ctx, sources) {
+  return markdownSlashCommands(await discoverMarkdownEntries(ctx, sources));
+}
+function markdownSlashCommands(entries) {
+  const seen = new Set;
+  const commands = [];
+  for (const entry of entries) {
+    if (entry.frontmatter["user-invocable"] === "false" || seen.has(entry.name))
+      continue;
+    seen.add(entry.name);
+    const description = entry.frontmatter.description;
+    const argumentHint = entry.frontmatter["argument-hint"];
+    commands.push({
+      name: entry.name,
+      ...description ? { description } : {},
+      ...argumentHint ? { argumentHint } : {}
+    });
+  }
+  return commands;
+}
+function commandAndSkillDirs(roots) {
+  return roots.flatMap((root) => [
+    { dir: `${root}/commands`, layout: "files" },
+    { dir: `${root}/skills`, layout: "skills" }
+  ]);
+}
+var noCommands = () => [];
+function slashCommandProvider(builtins, sources, discovery = {}) {
+  return async (ctx) => {
+    const [acp, loaded, files] = await Promise.all([
+      discovery.acp ? discoverAcpSlashCommands(ctx, discovery.acp).catch(noCommands) : [],
+      discovery.load ? discovery.load(ctx).catch(noCommands) : [],
+      discoverSlashCommands(ctx, sources).catch(noCommands)
+    ]);
+    return dedupeSlashCommands([...builtins, ...acp, ...loaded, ...files]);
+  };
+}
+function markdownScanScript(sources) {
+  const lines = [
+    "pragma_scan() {",
+    '  [ -d "$2" ] || return 0',
+    '  find -L "$2" -maxdepth "$3" -type f -name "$4" 2>/dev/null | sort | while IFS= read -r f; do',
+    `    printf '\\036%s\\t%s\\n' "$1" "\${f#"$2"/}"; head -n ${HEAD_LINES} "$f" 2>/dev/null; printf '\\n'`,
+    "  done",
+    "}"
+  ];
+  sources.forEach((source, index) => {
+    const skills = source.layout === "skills";
+    const depth = skills ? 2 : source.recursive === false ? 1 : MAX_DEPTH;
+    const pattern = skills ? "SKILL.md" : `*${source.suffix ?? ".md"}`;
+    lines.push(`pragma_scan ${index} ${shellDir(source.dir)} ${depth} ${shellQuote2(pattern)}`);
+  });
+  lines.push("exit 0");
+  return lines.join(`
+`);
+}
+function parseMarkdownScan(stdout, sources) {
+  const entries = [];
+  for (const record2 of stdout.split(RECORD_SEPARATOR).slice(1)) {
+    const newline = record2.indexOf(`
+`);
+    const header = newline === -1 ? record2 : record2.slice(0, newline);
+    const [indexText, relativePath] = header.split("\t");
+    const source = sources[Number(indexText)];
+    if (!source || !relativePath)
+      continue;
+    const frontmatter = parseFrontmatter(newline === -1 ? "" : record2.slice(newline + 1));
+    const name = entryName(source, relativePath, frontmatter);
+    if (name)
+      entries.push({ name: `${source.prefix ?? ""}${name}`, frontmatter, source });
+  }
+  return entries;
+}
+function parseFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---")
+    return {};
+  const result = {};
+  let blockKey = null;
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "---")
+      break;
+    if (blockKey && /^\s+\S/.test(line)) {
+      const previous = result[blockKey];
+      result[blockKey] = previous ? `${previous} ${line.trim()}` : line.trim();
+      continue;
+    }
+    blockKey = null;
+    const match = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(line);
+    if (!match)
+      continue;
+    const value = unquote(match[2].trim());
+    if (/^[|>][+-]?$/.test(value)) {
+      blockKey = match[1];
+    } else if (value) {
+      result[match[1]] = value;
+    }
+  }
+  return result;
+}
+function entryName(source, relativePath, frontmatter) {
+  if (source.layout === "skills") {
+    const directory = relativePath.split("/").slice(0, -1).join("/");
+    return frontmatter.name ?? (directory || null);
+  }
+  if (source.nameFromFrontmatter && frontmatter.name)
+    return frontmatter.name;
+  const suffix = source.suffix ?? ".md";
+  if (!relativePath.endsWith(suffix))
+    return null;
+  return relativePath.slice(0, -suffix.length).split("/").join(":") || null;
+}
+function unquote(value) {
+  const quoted = /^(["'])(.*)\1$/.exec(value);
+  return quoted ? quoted[2] : value;
+}
+function shellDir(dir) {
+  if (dir === "~")
+    return '"$HOME"';
+  if (dir.startsWith("~/"))
+    return `"$HOME"/${shellQuote2(dir.slice(2))}`;
+  return shellQuote2(dir);
+}
+function shellQuote2(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
 function definePlugin(input) {
   return { ...input, __apiVersion: PLUGIN_API_VERSION };
 }
-function defineUsageLimitProvider(input) {
-  return input;
+var ACCOUNT_PROVIDERS = {
+  anthropic: { title: "Anthropic", modelsDevIds: ["anthropic"] },
+  openai: { title: "OpenAI", modelsDevIds: ["openai"] },
+  cursor: { title: "Cursor" },
+  "github-copilot": { title: "GitHub Copilot" },
+  xai: { title: "xAI", dashboardUrl: "https://console.x.ai", modelsDevIds: ["xai"] },
+  jetbrains: { title: "JetBrains" },
+  "opencode-go": { title: "OpenCode Go", modelsDevIds: ["opencode-go"] },
+  "opencode-zen": {
+    title: "OpenCode Zen",
+    dashboardUrl: "https://opencode.ai/auth",
+    modelsDevIds: ["opencode"]
+  },
+  moonshot: { title: "Moonshot", modelsDevIds: ["kimi-code-plan-global", "kimi-code-plan-cn"] },
+  "moonshot-platform": {
+    title: "Moonshot AI Platform",
+    dashboardUrl: "https://platform.moonshot.ai/console/api-keys",
+    modelsDevIds: ["moonshotai", "moonshotai-cn"]
+  },
+  google: {
+    title: "Google Gemini API",
+    dashboardUrl: "https://aistudio.google.com/apikey",
+    modelsDevIds: ["google"]
+  },
+  openrouter: {
+    title: "OpenRouter",
+    dashboardUrl: "https://openrouter.ai/settings/keys",
+    modelsDevIds: ["openrouter"]
+  },
+  deepseek: {
+    title: "DeepSeek",
+    dashboardUrl: "https://platform.deepseek.com/api_keys",
+    modelsDevIds: ["deepseek"]
+  },
+  groq: { title: "Groq", dashboardUrl: "https://console.groq.com/keys", modelsDevIds: ["groq"] },
+  mistral: {
+    title: "Mistral",
+    dashboardUrl: "https://console.mistral.ai/api-keys",
+    modelsDevIds: ["mistral"]
+  },
+  cerebras: {
+    title: "Cerebras",
+    dashboardUrl: "https://cloud.cerebras.ai",
+    modelsDevIds: ["cerebras"]
+  },
+  fireworks: {
+    title: "Fireworks AI",
+    dashboardUrl: "https://fireworks.ai/account/api-keys",
+    modelsDevIds: ["fireworks-ai"]
+  },
+  together: {
+    title: "Together AI",
+    dashboardUrl: "https://api.together.ai/settings/api-keys",
+    modelsDevIds: ["togetherai"]
+  },
+  huggingface: {
+    title: "Hugging Face",
+    dashboardUrl: "https://huggingface.co/settings/tokens",
+    modelsDevIds: ["huggingface"]
+  },
+  nvidia: { title: "NVIDIA", dashboardUrl: "https://build.nvidia.com", modelsDevIds: ["nvidia"] },
+  "vercel-ai-gateway": {
+    title: "Vercel AI Gateway",
+    dashboardUrl: "https://vercel.com/dashboard/ai-gateway",
+    modelsDevIds: ["vercel"]
+  },
+  zai: {
+    title: "Z.ai",
+    dashboardUrl: "https://z.ai/manage-apikey/apikey-list",
+    modelsDevIds: ["zai-coding-plan", "zai", "zhipuai"]
+  },
+  minimax: {
+    title: "MiniMax",
+    dashboardUrl: "https://platform.minimax.io",
+    modelsDevIds: ["minimax-coding-plan", "minimax", "minimax-cn-coding-plan", "minimax-cn"]
+  },
+  xiaomi: {
+    title: "Xiaomi MiMo",
+    dashboardUrl: "https://platform.xiaomimimo.com",
+    modelsDevIds: [
+      "xiaomi",
+      "xiaomi-token-plan-ams",
+      "xiaomi-token-plan-sgp",
+      "xiaomi-token-plan-cn"
+    ]
+  }
+};
+function modelsDevAccountProviders(except = []) {
+  return Object.keys(ACCOUNT_PROVIDERS).flatMap((provider) => {
+    const { modelsDevIds } = ACCOUNT_PROVIDERS[provider];
+    return modelsDevIds && !except.includes(provider) ? [{ provider, modelsDevIds }] : [];
+  });
+}
+function apiKeyTokenKind(provider) {
+  return `key:${provider}`;
+}
+function defineAccounts(providers) {
+  return providers;
+}
+function accountProviderTitle(provider, title) {
+  if (title)
+    return title;
+  return wellKnownProvider(provider)?.title ?? provider;
+}
+function wellKnownProvider(provider) {
+  return Object.hasOwn(ACCOUNT_PROVIDERS, provider) ? ACCOUNT_PROVIDERS[provider] : undefined;
+}
+function hostProcess() {
+  return globalThis.process;
+}
+function hostBuiltin(id) {
+  const load = hostProcess()?.getBuiltinModule;
+  if (!load)
+    throw new Error(`${id} is only available on the host`);
+  return load(id);
+}
+async function expandHome(path) {
+  if (path !== "~" && !path.startsWith("~/"))
+    return path;
+  const { homedir } = hostBuiltin("node:os");
+  return `${homedir()}${path.slice(1)}`;
+}
+function recordValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+var STATE_SUFFIX = ".pragma.json";
+var LOCK_SUFFIX = ".lock";
+var LOCK_RETRIES = 50;
+var LOCK_RETRY_MS = 100;
+var LOCK_STALE_MS = 30000;
+var PRIVATE_FILE_MODE = 384;
+async function sharedCredentialFile(store, env) {
+  const dir = env[store.dirEnv] ?? hostProcess()?.env?.[store.dirEnv] ?? store.defaultDir;
+  return `${await expandHome(dir)}/${store.file}`;
+}
+function loginCredentialFile(store, home) {
+  return `${home}/${store.file}`;
+}
+async function readLoginEntries(store, provider, entries, account) {
+  const shared = await sharedCredentialFile(store, account.env);
+  const state2 = await readState(shared);
+  await settleSwitches(store, shared, state2);
+  const slot = state2.providers[provider];
+  if (holdsShared(slot, account.home)) {
+    const current = await readJson(shared);
+    return current ? pick(current, entries) : null;
+  }
+  if (account.home === null)
+    return slot?.own ?? {};
+  const own = await readJson(loginCredentialFile(store, account.home));
+  return own ? pick(own, entries) : null;
+}
+async function writeLoginEntries(store, provider, account, updates) {
+  const shared = await sharedCredentialFile(store, account.env);
+  const fs = hostBuiltin("node:fs/promises");
+  await fs.mkdir(parentDir(shared), { recursive: true, mode: 448 });
+  await withLock(fs, shared, async () => {
+    const state2 = await readState(shared);
+    const settled = await settleSwitches(store, shared, state2);
+    const slot = state2.providers[provider];
+    let ownChanged = false;
+    if (holdsShared(slot, account.home)) {
+      await mergeJson(fs, shared, updates);
+    } else if (account.home !== null) {
+      await mergeJson(fs, loginCredentialFile(store, account.home), updates);
+    } else if (slot) {
+      slot.own = { ...slot.own, ...updates };
+      ownChanged = true;
+    }
+    if (settled || ownChanged)
+      await writeJson(fs, `${shared}${STATE_SUFFIX}`, state2);
+  });
+}
+function holdsShared(slot, home) {
+  return !slot?.unattributed && (slot?.active ?? null) === home;
+}
+async function mergeJson(fs, path, updates) {
+  await fs.mkdir(parentDir(path), { recursive: true, mode: 448 });
+  await writeJson(fs, path, { ...await readJson(path), ...updates });
+}
+async function activateCredentialSwap(store, provider, entries, account) {
+  const shared = await sharedCredentialFile(store, account.env);
+  const fs = hostBuiltin("node:fs/promises");
+  await fs.mkdir(parentDir(shared), { recursive: true, mode: 448 });
+  await withLock(fs, shared, () => swapLocked({ fs, store, shared, provider, entries, target: account.home }));
+}
+async function swapLocked(swap) {
+  const { fs, store, shared, provider, entries, target } = swap;
+  const stateFile = `${shared}${STATE_SUFFIX}`;
+  const state2 = await readState(shared);
+  const settled = await settleSwitches(store, shared, state2);
+  const slot = state2.providers[provider] ?? { active: null };
+  if (slot.active === target && !slot.unattributed) {
+    if (settled)
+      await writeJson(fs, stateFile, state2);
+    return;
+  }
+  const current = await readJson(shared) ?? {};
+  const outgoing = pick(current, entries);
+  const incoming = await savedEntries(store, slot, target, entries);
+  const own = await saveOutgoing(swap, slot, outgoing);
+  state2.providers[provider] = {
+    active: slot.active,
+    ...own ? { own } : {},
+    switching: { target, outgoing, entries: [...entries] }
+  };
+  await writeJson(fs, stateFile, state2);
+  await writeJson(fs, shared, { ...omit(current, entries), ...incoming });
+  completeSwitch(state2, provider, target, false);
+  await writeJson(fs, stateFile, state2);
+}
+async function savedEntries(store, slot, target, entries) {
+  if (target === null)
+    return slot.own ?? {};
+  const stored = await readJson(loginCredentialFile(store, target));
+  return pick(stored ?? {}, entries);
+}
+async function settleSwitches(store, shared, state2) {
+  let changed = false;
+  let current;
+  for (const [provider, slot] of Object.entries(state2.providers)) {
+    const pending = slot.switching;
+    if (!pending)
+      continue;
+    changed = true;
+    current ??= await readJson(shared) ?? {};
+    const inShared = pick(current, pending.entries);
+    const incoming = await savedEntries(store, slot, pending.target, pending.entries);
+    if (sameEntries(inShared, incoming)) {
+      completeSwitch(state2, provider, pending.target, false);
+    } else if (sameEntries(inShared, pending.outgoing)) {
+      delete slot.switching;
+    } else {
+      completeSwitch(state2, provider, pending.target, true);
+    }
+  }
+  return changed;
+}
+function completeSwitch(state2, provider, target, unattributed) {
+  const own = state2.providers[provider]?.own;
+  if (target === null && !unattributed) {
+    delete state2.providers[provider];
+    return;
+  }
+  state2.providers[provider] = {
+    active: target,
+    ...own ? { own } : {},
+    ...unattributed ? { unattributed } : {}
+  };
+}
+async function saveOutgoing(swap, slot, outgoing) {
+  if (slot.unattributed)
+    return slot.own;
+  if (slot.active !== null) {
+    await saveBack(swap.fs, loginCredentialFile(swap.store, slot.active), outgoing, swap.entries);
+    return slot.own;
+  }
+  return outgoing;
+}
+async function saveBack(fs, path, outgoing, entries) {
+  const existing = await readJson(path);
+  if (existing === null) {
+    try {
+      await fs.stat(parentDir(path));
+    } catch {
+      return;
+    }
+  }
+  await writeJson(fs, path, { ...omit(existing ?? {}, entries), ...outgoing });
+}
+async function withLock(fs, file, run) {
+  const lock = `${file}${LOCK_SUFFIX}`;
+  for (let attempt = 0;; attempt += 1) {
+    try {
+      await fs.mkdir(lock);
+      break;
+    } catch (error) {
+      if (!isExists(error) || attempt >= LOCK_RETRIES)
+        throw error;
+      if (await isStale(fs, lock)) {
+        await fs.rmdir(lock).catch(() => {
+          return;
+        });
+        continue;
+      }
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    }
+  }
+  try {
+    return await run();
+  } finally {
+    await fs.rmdir(lock).catch(() => {
+      return;
+    });
+  }
+}
+async function isStale(fs, lock) {
+  try {
+    return Date.now() - (await fs.stat(lock)).mtimeMs > LOCK_STALE_MS;
+  } catch {
+    return false;
+  }
+}
+function isExists(error) {
+  return recordValue(error)?.code === "EEXIST";
+}
+async function readState(shared) {
+  const value = await readJson(`${shared}${STATE_SUFFIX}`);
+  const providers = recordValue(value?.providers);
+  return { providers: providers ?? {} };
+}
+async function readJson(path) {
+  const { readFile } = hostBuiltin("node:fs/promises");
+  try {
+    return recordValue(JSON.parse(await readFile(path, "utf8"))) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function writeJson(fs, path, value) {
+  await fs.writeFile(path, `${JSON.stringify(value, null, 2)}
+`, { mode: PRIVATE_FILE_MODE });
+  await fs.chmod(path, PRIVATE_FILE_MODE);
+}
+function sameEntries(a, b) {
+  return stableJson(a) === stableJson(b);
+}
+function stableJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  const record2 = recordValue(value);
+  if (!record2)
+    return JSON.stringify(value) ?? "null";
+  const keys = Object.keys(record2).toSorted();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableJson(record2[key])}`).join(",")}}`;
+}
+function pick(source, keys) {
+  return Object.fromEntries(keys.filter((key) => (key in source)).map((key) => [key, source[key]]));
+}
+function omit(source, keys) {
+  return Object.fromEntries(Object.entries(source).filter(([key]) => !keys.includes(key)));
+}
+function parentDir(path) {
+  const index = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+  return index > 0 ? path.slice(0, index) : path;
+}
+var CHATGPT_PROFILE_CLAIM = "https://api.openai.com/profile";
+var CHATGPT_AUTH_CLAIM = "https://api.openai.com/auth";
+var ANTHROPIC_PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
+var ANTHROPIC_OAUTH_BETA = "oauth-2025-04-20";
+var GITHUB_USER_URL = "https://api.github.com/user";
+var API_KEY_DIGEST_LENGTH = 16;
+function chatGptIdentity(accessToken) {
+  const claims = decodeJwtPayload(accessToken);
+  if (!claims)
+    return null;
+  const profile = recordValue(claims[CHATGPT_PROFILE_CLAIM]);
+  const auth = recordValue(claims[CHATGPT_AUTH_CLAIM]);
+  const email = stringValue(profile?.email);
+  if (!email)
+    return null;
+  const name = stringValue(profile?.name);
+  const plan = stringValue(auth?.chatgpt_plan_type);
+  return {
+    id: email,
+    email,
+    ...name ? { name } : {},
+    ...plan ? { plan: capitalize(plan) } : {}
+  };
+}
+async function anthropicOAuthIdentity(accessToken, fetcher = fetch) {
+  const response = await fetcher(ANTHROPIC_PROFILE_URL, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "anthropic-beta": ANTHROPIC_OAUTH_BETA
+    }
+  });
+  if (!response.ok)
+    return null;
+  return parseAnthropicProfile(await response.json());
+}
+function parseAnthropicProfile(value) {
+  const account = recordValue(recordValue(value)?.account);
+  const organization = recordValue(recordValue(value)?.organization);
+  const email = stringValue(account?.email);
+  const orgId = stringValue(organization?.uuid);
+  const id = orgId && email ? `${orgId}:${email}` : orgId ?? email;
+  if (!id)
+    return null;
+  const name = stringValue(organization?.name);
+  return { id, ...email ? { email } : {}, ...name ? { name } : {} };
+}
+async function gitHubIdentity(token, fetcher = fetch) {
+  const response = await fetcher(GITHUB_USER_URL, {
+    headers: { Authorization: `Bearer ${token}`, Accept: "application/vnd.github+json" }
+  });
+  if (!response.ok)
+    return null;
+  const user = recordValue(await response.json());
+  const login = stringValue(user?.login);
+  if (!login)
+    return null;
+  const name = stringValue(user?.name);
+  const email = stringValue(user?.email);
+  return { id: login.toLowerCase(), ...name ? { name } : {}, ...email ? { email } : {} };
+}
+async function apiKeyIdentity(key) {
+  const trimmed = key.trim();
+  if (!trimmed)
+    return null;
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(trimmed));
+  const hex = [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, API_KEY_DIGEST_LENGTH);
+  return { id: `key:${hex}`, name: `API key …${trimmed.slice(-4)}` };
+}
+async function credentialDir(ctx, envVar, fallback) {
+  const configured = ctx.account.env[envVar] ?? hostProcess()?.env?.[envVar];
+  if (configured)
+    return configured;
+  return expandHome(fallback);
+}
+async function readCredentialFile(path) {
+  const { readFile } = hostBuiltin("node:fs/promises");
+  try {
+    return recordValue(JSON.parse(await readFile(await expandHome(path), "utf8"))) ?? null;
+  } catch {
+    return null;
+  }
+}
+async function writeCredentialFile(path, value) {
+  const fs = hostBuiltin("node:fs/promises");
+  const target = await expandHome(path);
+  const slash = Math.max(target.lastIndexOf("/"), target.lastIndexOf("\\"));
+  if (slash > 0)
+    await fs.mkdir(target.slice(0, slash), { recursive: true, mode: 448 });
+  await fs.writeFile(target, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  await fs.chmod(target, 384);
+}
+function credentialStorePath(store, home) {
+  return `${home ?? `$${store.dirEnv} or ${store.defaultDir}`}/${store.file}`;
+}
+function identifyFromCredentialStore(store, entryKey, provider, options = {}) {
+  const entryKeys = typeof entryKey === "string" ? [entryKey] : entryKey;
+  return async (ctx) => {
+    const dir = await credentialDir(ctx, store.dirEnv, store.defaultDir);
+    const credentials = await readCredentialFile(`${dir}/${store.file}`);
+    return identifyEntries(provider, credentials, entryKeys, options.apiKeyOnly ?? false);
+  };
+}
+function credentialStoreAccount(options) {
+  const { store, entries, provider } = options;
+  const apiKeyOnly = options.apiKeyOnly ?? false;
+  const shared = sharedTokenOptions(options);
+  const base = {
+    provider,
+    agent: options.agent,
+    ...options.login ? { login: options.login } : {},
+    credentialPath: (home) => home === null ? credentialStorePath(store, null) : loginCredentialFile(store, home)
+  };
+  if (!(options.switchable ?? shared !== null)) {
+    return {
+      ...base,
+      identify: identifyFromCredentialStore(store, entries, provider, { apiKeyOnly })
+    };
+  }
+  return {
+    ...base,
+    swap: {
+      activate: (ctx) => activateCredentialSwap(store, provider, entries, ctx.account)
+    },
+    identify: async (ctx) => {
+      const stored = await readLoginEntries(store, provider, entries, ctx.account);
+      return identifyEntries(provider, stored, entries, apiKeyOnly);
+    },
+    ...shared ? {
+      sharedToken: {
+        kind: shared.kind,
+        read: async (ctx) => {
+          const stored = await readLoginEntries(store, provider, entries, ctx.account);
+          const keys = options.sharedToken ? [shared.entry] : entries;
+          for (const key of keys) {
+            const token = entryToken(stored?.[key], shared.type);
+            if (token)
+              return token;
+          }
+          return null;
+        },
+        write: (ctx, token) => writeLoginEntries(store, provider, ctx.account, {
+          [shared.entry]: tokenEntry(token, shared.type, store)
+        })
+      }
+    } : {}
+  };
+}
+function sharedTokenOptions(options) {
+  if (options.sharedToken === false)
+    return null;
+  const shared = options.sharedToken ?? {
+    kind: apiKeyTokenKind(options.provider),
+    entry: options.entries[0] ?? options.provider,
+    type: "api"
+  };
+  return shared.type === "oauth" && options.apiKeyOnly ? null : shared;
+}
+function entryToken(entry, type) {
+  const credential = recordValue(entry);
+  if (!credential)
+    return null;
+  if (type === "api") {
+    if (credential.type === "oauth")
+      return null;
+    const key = stringValue(credential.key);
+    return key ? { type: "api", key } : null;
+  }
+  return oauthEntryToken(credential);
+}
+function tokenEntry(token, type, store) {
+  if (token.type !== type) {
+    throw new Error(`expected a shared ${type} token, got ${token.type}`);
+  }
+  if (token.type === "api")
+    return { type: store.apiKeyType ?? "api", key: token.key };
+  return {
+    type: "oauth",
+    access: token.access,
+    refresh: token.refresh,
+    expires: token.expires,
+    ...token.accountId ? { accountId: token.accountId } : {}
+  };
+}
+function credentialFileSharedToken(store, shared) {
+  const path = async (ctx) => ctx.account.home === null ? `${await credentialDir(ctx, store.dirEnv, store.defaultDir)}/${store.file}` : loginCredentialFile(store, ctx.account.home);
+  return {
+    kind: shared.kind,
+    read: async (ctx) => entryToken((await readCredentialFile(await path(ctx)))?.[shared.entry], shared.type),
+    write: async (ctx, token) => {
+      const file = await path(ctx);
+      const current = await readCredentialFile(file) ?? {};
+      await writeCredentialFile(file, {
+        ...current,
+        [shared.entry]: tokenEntry(token, shared.type, store)
+      });
+    }
+  };
+}
+function oauthEntryToken(entry) {
+  const credential = recordValue(entry);
+  if (credential?.type !== "oauth")
+    return null;
+  const access = stringValue(credential.access);
+  const refresh = stringValue(credential.refresh);
+  if (!access || !refresh)
+    return null;
+  const expires = typeof credential.expires === "number" ? credential.expires : 0;
+  const accountId = stringValue(credential.accountId);
+  return { type: "oauth", access, refresh, expires, ...accountId ? { accountId } : {} };
+}
+async function identifyEntries(provider, stored, entries, apiKeyOnly) {
+  for (const key of entries) {
+    const entry = stored?.[key];
+    if (apiKeyOnly && recordValue(entry)?.type === "oauth")
+      continue;
+    const identity = await storedCredentialIdentity(provider, entry);
+    if (identity)
+      return identity;
+  }
+  return null;
+}
+async function storedCredentialIdentity(provider, entry, fetcher = fetch) {
+  const credential = recordValue(entry);
+  if (!credential)
+    return null;
+  const key = stringValue(credential.key);
+  if (credential.type !== "oauth")
+    return key ? apiKeyIdentity(key) : null;
+  const access = stringValue(credential.access);
+  const refresh = stringValue(credential.refresh);
+  switch (provider) {
+    case "openai":
+      return access ? chatGptIdentity(access) : null;
+    case "anthropic":
+      return access ? anthropicOAuthIdentity(access, fetcher) : null;
+    case "github-copilot":
+      return refresh && !credential.enterpriseUrl ? gitHubIdentity(refresh, fetcher) : null;
+    default:
+      return null;
+  }
+}
+function decodeJwtPayload(token) {
+  const payload = token.split(".")[1];
+  if (!payload)
+    return null;
+  try {
+    const base64 = payload.replaceAll("-", "+").replaceAll("_", "/");
+    const padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, "=");
+    const bytes = Uint8Array.from(atob(padded), (char) => char.charCodeAt(0));
+    return recordValue(JSON.parse(new TextDecoder().decode(bytes))) ?? null;
+  } catch {
+    return null;
+  }
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 
 // ../watcher-kit/src/index.ts
@@ -210,8 +1095,8 @@ async function finalizeQuestionAnswers(ctx, runtime) {
   if (!ctx.signal.aborted)
     await writeKeys(ctx, runtime.questionFinalizeKeys);
 }
-async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text) {
-  const input = mode === "plain" ? text : `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text2) {
+  const input = mode === "plain" ? text2 : `${BRACKETED_PASTE_START}${text2}${BRACKETED_PASTE_END}`;
   await writeKeys(ctx, input);
   if (!submitKeys) {
     return;
@@ -229,15 +1114,15 @@ function rememberCommandAttention(runtime, event) {
     runtime.outstandingCommandRequestId = null;
   }
 }
-function rememberQuestion(cache, event) {
+function rememberQuestion(cache2, event) {
   if (event.status === "attention" && event.attentionKind === "question" && typeof event.requestId === "string" && event.requestId.length > 0) {
     const entries = (event.questions ?? []).flatMap(questionEntry);
     if (entries.length > 0) {
-      cache.set(event.requestId, { questions: entries });
+      cache2.set(event.requestId, { questions: entries });
       return;
     }
     const options = (event.options ?? []).map((option) => option.label).filter((option) => option.trim() !== "");
-    cache.set(event.requestId, {
+    cache2.set(event.requestId, {
       questions: [{ question: event.question ?? "", options }]
     });
   }
@@ -246,12 +1131,12 @@ function questionEntry(value) {
   if (typeof value !== "object" || value === null || !("question" in value)) {
     return [];
   }
-  const record = value;
-  if (typeof record.question !== "string" || !record.question.trim()) {
+  const record2 = value;
+  if (typeof record2.question !== "string" || !record2.question.trim()) {
     return [];
   }
-  const options = Array.isArray(record.options) ? record.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
-  return [{ question: record.question, options }];
+  const options = Array.isArray(record2.options) ? record2.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
+  return [{ question: record2.question, options }];
 }
 function questionAnswerKeys(input) {
   if (input.dismissed || input.reply === null) {
@@ -347,7 +1232,7 @@ SELECT
 FROM usage
 `.trim();
 function usageCommand() {
-  return globalThis.process?.platform === "win32" ? `if (-not (Get-Command opencode -ErrorAction SilentlyContinue)) { exit 20 }; opencode db ${powershellQuote(USAGE_QUERY)} --format json` : "command -v opencode >/dev/null 2>&1 || exit 20; " + `opencode db ${shellQuote(USAGE_QUERY)} --format json`;
+  return globalThis.process?.platform === "win32" ? `if (-not (Get-Command opencode -ErrorAction SilentlyContinue)) { exit 20 }; opencode db ${powershellQuote(USAGE_QUERY)} --format json` : "command -v opencode >/dev/null 2>&1 || exit 20; " + `opencode db ${shellQuote3(USAGE_QUERY)} --format json`;
 }
 async function loadOpenCodeGoUsageLimits(ctx) {
   const [result] = await ctx.sdk.exec.run({
@@ -420,7 +1305,7 @@ function finiteNumber(value) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function shellQuote(value) {
+function shellQuote3(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 function powershellQuote(value) {
@@ -428,7 +1313,47 @@ function powershellQuote(value) {
 }
 
 // src/pragma-plugin.ts
+var OPENCODE_STORE = {
+  dirEnv: "XDG_DATA_HOME",
+  defaultDir: "~/.local/share",
+  file: "opencode/auth.json"
+};
+var OPENCODE_API_KEY_PROVIDERS = modelsDevAccountProviders([
+  "openai",
+  "opencode-go"
+]);
+function openCodeApiKeyProvider({
+  provider,
+  modelsDevIds
+}) {
+  return credentialStoreAccount({
+    provider,
+    agent: "opencode",
+    store: OPENCODE_STORE,
+    entries: modelsDevIds,
+    apiKeyOnly: true,
+    login: {
+      command: ["opencode", "auth", "login", "--provider", modelsDevIds[0]],
+      instructions: `Paste your ${accountProviderTitle(provider)} API key here, then send.`
+    }
+  });
+}
+var OPENCODE_GITHUB_CLIENT_ID = "Ov23li8tweQw6odWQebz";
 var ansiEscapePattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*[A-Za-z]`, "g");
+var DEFAULT_MODES = [
+  { id: "build", name: "Build" },
+  { id: "plan", name: "Plan" }
+];
+var HIDDEN_AGENTS = new Set(["compaction", "summary", "title"]);
+var BUILTIN_SLASH_COMMANDS = [
+  { name: "init", description: "Create or update AGENTS.md" },
+  { name: "review", description: "Review changes", argumentHint: "[commit|branch|pr]" }
+];
+var SLASH_COMMAND_SOURCES = [
+  ...commandAndSkillDirs([".opencode", "~/.config/opencode"]),
+  { dir: ".opencode/command", layout: "files" },
+  { dir: "~/.config/opencode/command", layout: "files" }
+];
 var opencodeAgentPlugin = definePlugin({
   name: "OpenCode",
   description: "Launch OpenCode from Pragma.",
@@ -439,16 +1364,74 @@ var opencodeAgentPlugin = definePlugin({
       questionFinalizeKeys: "\r"
     })
   ],
-  usageLimits: [
-    defineUsageLimitProvider({
-      id: "opencode-go",
-      title: "OpenCode Go",
+  accounts: defineAccounts([
+    {
+      provider: "opencode-go",
+      agent: "opencode",
       dashboardUrl: "https://opencode.ai/auth",
       iconPath: "assets/opencode.svg",
-      primaryLimitId: "rolling",
-      load: loadOpenCodeGoUsageLimits
-    })
-  ],
+      login: {
+        command: ["opencode", "auth", "login"],
+        instructions: "Pick OpenCode Go when asked (type to filter, then send), then paste the key from opencode.ai/auth."
+      },
+      env: (home) => ({ XDG_DATA_HOME: home }),
+      credentialPath: (home) => credentialStorePath(OPENCODE_STORE, home),
+      identify: identifyFromCredentialStore(OPENCODE_STORE, "opencode-go", "opencode-go"),
+      sharedToken: credentialFileSharedToken(OPENCODE_STORE, {
+        kind: apiKeyTokenKind("opencode-go"),
+        entry: "opencode-go",
+        type: "api"
+      }),
+      usageLimits: {
+        primaryLimitId: "rolling",
+        load: loadOpenCodeGoUsageLimits
+      }
+    },
+    {
+      ...credentialStoreAccount({
+        provider: "openai",
+        agent: "opencode",
+        store: OPENCODE_STORE,
+        entries: ["openai"],
+        switchable: true,
+        sharedToken: { kind: "chatgpt", entry: "openai", type: "oauth" },
+        login: {
+          command: [
+            "opencode",
+            "auth",
+            "login",
+            "--provider",
+            "openai",
+            "--method",
+            "ChatGPT Pro/Plus (browser)"
+          ],
+          instructions: "Sign in with ChatGPT in the browser tab that opens."
+        }
+      }),
+      dashboardUrl: "https://chatgpt.com/codex/settings/usage"
+    },
+    {
+      ...credentialStoreAccount({
+        provider: "github-copilot",
+        agent: "opencode",
+        store: OPENCODE_STORE,
+        entries: ["github-copilot"],
+        switchable: true,
+        sharedToken: {
+          kind: `github-copilot:${OPENCODE_GITHUB_CLIENT_ID}`,
+          entry: "github-copilot",
+          type: "oauth"
+        },
+        login: {
+          command: ["opencode", "auth", "login", "--provider", "github-copilot"],
+          input: [""],
+          instructions: "Enter the code shown here on the GitHub page that opens."
+        }
+      }),
+      dashboardUrl: "https://github.com/settings/copilot"
+    },
+    ...OPENCODE_API_KEY_PROVIDERS.map(openCodeApiKeyProvider)
+  ]),
   agents: [
     defineAgent({
       id: "opencode",
@@ -459,10 +1442,15 @@ var opencodeAgentPlugin = definePlugin({
       prefillDelayMs: 6000,
       models: async (ctx) => parseOpenCodeModels(await execFirst(ctx, "opencode models --json 2>/dev/null || opencode models --verbose 2>/dev/null || opencode models 2>/dev/null")),
       permissionModes: [],
+      modes: async (ctx) => parseOpenCodeAgents(await execFirst(ctx, "opencode agent list 2>/dev/null")),
+      slashCommands: slashCommandProvider(BUILTIN_SLASH_COMMANDS, SLASH_COMMAND_SOURCES, {
+        acp: { command: ["opencode", "acp"] }
+      }),
       args: {
         model: (modelId) => ["--model", modelId],
         reasoning: () => [],
-        permissionMode: () => []
+        permissionMode: () => [],
+        mode: (modeId) => ["--agent", modeId]
       }
     })
   ]
@@ -472,6 +1460,20 @@ async function execFirst(ctx, command) {
   const [result] = await ctx.sdk.exec.run({ cwd: pluginCwd(ctx), commands: [command] });
   return result?.stdout ?? "";
 }
+function parseOpenCodeAgents(output) {
+  const names = output.replaceAll(ansiEscapePattern, "").split(`
+`).flatMap((line) => {
+    const match = /^(\S+) \((primary|all|subagent)\)$/.exec(line.trim());
+    return match && match[2] !== "subagent" && !HIDDEN_AGENTS.has(match[1]) ? [match[1]] : [];
+  });
+  if (names.length === 0)
+    return DEFAULT_MODES;
+  const rank = (name) => {
+    const index = DEFAULT_MODES.findIndex((mode) => mode.id === name);
+    return index === -1 ? DEFAULT_MODES.length : index;
+  };
+  return [...new Set(names)].toSorted((a, b) => rank(a) - rank(b)).map((id) => ({ id, name: id[0].toUpperCase() + id.slice(1) }));
+}
 function parseOpenCodeModels(output) {
   const jsonModels = parseJsonModels(output);
   if (jsonModels.length > 0) {
@@ -534,27 +1536,27 @@ function walk(value, models) {
 function isRecord2(value) {
   return Boolean(value) && typeof value === "object";
 }
-function modelFromRecord(record) {
-  const id = firstString(record.id, record.model);
-  const name = modelName(record, id);
-  if (!id || !name || !hasModelMetadata(record)) {
+function modelFromRecord(record2) {
+  const id = firstString(record2.id, record2.model);
+  const name = modelName(record2, id);
+  if (!id || !name || !hasModelMetadata(record2)) {
     return null;
   }
-  return { id, name: withProvider(id, name, stringValue(record.provider)) };
+  return { id, name: withProvider(id, name, stringValue2(record2.provider)) };
 }
 function firstString(...values) {
   for (const value of values) {
-    const string = stringValue(value);
+    const string = stringValue2(value);
     if (string)
       return string;
   }
   return;
 }
-function modelName(record, id) {
-  return stringValue(record.name) ?? stringValue(record.displayName) ?? stringValue(record.label) ?? id;
+function modelName(record2, id) {
+  return stringValue2(record2.name) ?? stringValue2(record2.displayName) ?? stringValue2(record2.label) ?? id;
 }
-function hasModelMetadata(record) {
-  return Boolean(record.provider || record.cost || record.limits || record.modalities);
+function hasModelMetadata(record2) {
+  return Boolean(record2.provider || record2.cost || record2.limits || record2.modalities);
 }
 function uniqueModels(models) {
   const seen = new Set;
@@ -565,7 +1567,7 @@ function uniqueModels(models) {
     return true;
   });
 }
-function stringValue(value) {
+function stringValue2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
 function splitWhitespaceModel(line) {
@@ -585,6 +1587,8 @@ function withProvider(id, name, provider = id.includes("/") ? id.split("/", 1)[0
 }
 export {
   parseOpenCodeModels,
+  parseOpenCodeAgents,
   opencodeAgentPlugin,
-  pragma_plugin_default as default
+  pragma_plugin_default as default,
+  OPENCODE_API_KEY_PROVIDERS
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pragma-sh/opencode-plugin",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "opencode plugin that reports agent status to Pragma automatically.",
   "license": "AGPL-3.0-only",
   "repository": {