@khalilgharbaoui/opencode-claude-code-plugin 0.25.0 → 0.26.1

package/dist/index.js

@@ -386,6 +386,134 @@ function mapTool(name, input, opts) {
   return { name, input, executed: true };
 }
 
+// src/host-tools.ts
+function defined(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+var V2_TOOLS = {
+  bash: {
+    name: "shell",
+    // V2's shell takes no `description`; `workdir`, `timeout` and
+    // `background` keep their names.
+    input: (input) => defined({
+      command: input.command,
+      workdir: input.workdir,
+      timeout: input.timeout,
+      background: input.background
+    })
+  },
+  edit: {
+    name: "edit",
+    input: (input) => defined({
+      path: input.filePath ?? input.path,
+      oldString: input.oldString,
+      newString: input.newString,
+      replaceAll: input.replaceAll
+    })
+  },
+  write: {
+    name: "write",
+    input: (input) => defined({ path: input.filePath ?? input.path, content: input.content })
+  },
+  read: {
+    name: "read",
+    input: (input) => defined({ path: input.filePath ?? input.path, offset: input.offset, limit: input.limit })
+  },
+  glob: { name: "glob" },
+  grep: { name: "grep" },
+  webfetch: { name: "webfetch" },
+  websearch: { name: "websearch" },
+  question: { name: "question" },
+  task: {
+    name: "subagent",
+    input: (input) => defined({
+      agent: input.subagent_type ?? input.agent,
+      description: input.description,
+      prompt: input.prompt,
+      sessionID: input.task_id ?? input.sessionID,
+      background: input.background
+    })
+  },
+  todowrite: null,
+  plan_enter: null,
+  plan_exit: null,
+  notebookedit: null
+};
+function parseInput(raw) {
+  if (typeof raw !== "string") return raw ?? {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function createHostToolPartTranslator(dialect = "v1") {
+  if (dialect !== "v2") return (part) => part;
+  const dropped = /* @__PURE__ */ new Set();
+  const translated = /* @__PURE__ */ new Map();
+  const classify2 = (id, name) => {
+    if (dropped.has(id)) return null;
+    const known = translated.get(id);
+    if (known) return known;
+    if (typeof name !== "string") return void 0;
+    const tool = V2_TOOLS[name];
+    if (tool === null) {
+      dropped.add(id);
+      return null;
+    }
+    if (tool) translated.set(id, tool);
+    return tool;
+  };
+  return (part) => {
+    switch (part.type) {
+      case "tool-input-start": {
+        const tool = classify2(String(part.id), part.toolName);
+        if (tool === null) return null;
+        return tool ? { ...part, toolName: tool.name } : part;
+      }
+      case "tool-input-delta": {
+        const tool = classify2(String(part.id), void 0);
+        if (tool === null) return null;
+        return tool?.input ? null : part;
+      }
+      case "tool-input-end": {
+        return classify2(String(part.id), void 0) === null ? null : part;
+      }
+      case "tool-call": {
+        const tool = classify2(String(part.toolCallId), part.toolName);
+        if (tool === null) return null;
+        if (!tool) return part;
+        const input = tool.input ? tool.input(parseInput(part.input)) : parseInput(part.input);
+        return {
+          ...part,
+          toolName: tool.name,
+          input: typeof part.input === "string" ? JSON.stringify(input) : input
+        };
+      }
+      case "tool-result": {
+        const tool = classify2(String(part.toolCallId), part.toolName);
+        if (tool === null) return null;
+        return tool ? { ...part, toolName: tool.name } : part;
+      }
+      default:
+        return part;
+    }
+  };
+}
+function translateStreamForHost(stream, dialect = "v1") {
+  if (dialect !== "v2") return stream;
+  const translate = createHostToolPartTranslator(dialect);
+  return stream.pipeThrough(
+    new TransformStream({
+      transform(part, controller) {
+        const next = translate(part);
+        if (next) controller.enqueue(next);
+      }
+    })
+  );
+}
+
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
 import path from "path";
@@ -596,7 +724,9 @@ function rateLimitKey(info) {
   ].join("|");
 }
 function isRateLimitRejected(info) {
-  return info.status === "rejected" || info.overageStatus === "rejected";
+  if (info.status === "rejected") return true;
+  if (info.status === "allowed" || info.status === "allowed_warning") return false;
+  return info.overageStatus === "rejected";
 }
 function describeRateLimit(info) {
   if (!info.status && !info.overageStatus) return null;
@@ -3254,6 +3384,7 @@ var BtwHandledError = class extends Error {
     super(message);
   }
 };
+var BTW_COMMAND_DESCRIPTION = "Ask a side question in the live Claude Code session without changing its context";
 var BTW_NO_SESSION_MESSAGE = "/btw needs a live Claude Code session in this conversation. Send a normal message with a Claude Code model first, then ask again.";
 var BTW_INLINE_HANDLED_MESSAGE = "/btw was answered inside the running turn; nothing to add to this conversation.";
 var BTW_TURN_TOO_LONG_MESSAGE = "/btw gave up waiting for this turn to end. Ask again once it is over.";
@@ -3781,14 +3912,14 @@ function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
     excludeServers
   });
 }
-function mergeOpencodeMcp(cwd, runtimeStatus) {
+function opencodeConfigLayers(cwd) {
   const worktree = detectWorktree(cwd);
-  let merged = {};
-  merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
+  const layers = [];
+  layers.push(loadGlobalConfig());
   const explicitConfig = process.env.OPENCODE_CONFIG;
   if (explicitConfig && fileExists(explicitConfig)) {
     const parsed = readAndParse(explicitConfig);
-    if (parsed) merged = mergeMcp(merged, extractMcpBlock(parsed));
+    if (parsed) layers.push(parsed);
   }
   const projectFiles = walkUp({
     start: cwd,
@@ -3806,10 +3937,22 @@ function mergeOpencodeMcp(cwd, runtimeStatus) {
     }
   }
   for (const dir of projectDirs.slice().reverse()) {
-    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
+    layers.push(loadProjectFilesInDir(dir));
   }
   for (const dir of dotOpencodeDirs(cwd, worktree)) {
-    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
+    layers.push(loadProjectFilesInDir(dir));
+  }
+  return layers;
+}
+function loadMergedOpencodeConfig(cwd) {
+  let merged = {};
+  for (const layer of opencodeConfigLayers(cwd)) merged = deepMerge(merged, layer);
+  return merged;
+}
+function mergeOpencodeMcp(cwd, runtimeStatus) {
+  let merged = {};
+  for (const layer of opencodeConfigLayers(cwd)) {
+    merged = mergeMcp(merged, extractMcpBlock(layer));
   }
   if (runtimeStatus) {
     for (const name of Object.keys(merged)) {
@@ -3945,6 +4088,39 @@ async function fetchSessionParentId(sessionID) {
     return void 0;
   }
 }
+async function fetchSessionRunState(sessionID) {
+  if (!sessionID || sessionID === "default") return "unknown";
+  const status = opencodeClient?.session?.status;
+  if (!status) return "unknown";
+  try {
+    const res = await status.call(opencodeClient.session);
+    const data = res.data;
+    if (!data || typeof data !== "object") return "unknown";
+    const entry = data[sessionID];
+    if (!entry || typeof entry !== "object") return "idle";
+    const type = entry.type;
+    return type === "idle" ? "idle" : "busy";
+  } catch (err) {
+    log.debug("failed to read opencode session status", {
+      sessionID,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return "unknown";
+  }
+}
+async function settleSessionRunState(sessionID, options = {}) {
+  const pollMs = options.pollMs ?? 150;
+  const windowMs = options.windowMs ?? 1500;
+  const started = Date.now();
+  let last = "unknown";
+  for (; ; ) {
+    const state = await fetchSessionRunState(sessionID);
+    if (state === "busy") return "busy";
+    if (state !== "unknown") last = state;
+    if (Date.now() - started >= windowMs) return last;
+    await new Promise((resolve5) => setTimeout(resolve5, pollMs));
+  }
+}
 async function getRuntimeMcpStatus() {
   const client = opencodeClient;
   if (!client?.mcp?.status) return void 0;
@@ -4129,6 +4305,7 @@ function logStartupDiagnostics(providers, opencodeVersion) {
 
 // src/doctor.ts
 var DOCTOR_COMMAND = "claude-code-doctor";
+var DOCTOR_COMMAND_DESCRIPTION = "Report what the Claude Code plugin sees: versions, cwd, live processes, pending proxy calls";
 var DOCTOR_MARKER = "\u258C **claude-code doctor**";
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -5340,6 +5517,33 @@ function registerBundledSkillPath(config) {
   paths.push(dir);
   return true;
 }
+function readBundledSkillInfos() {
+  return discoverBundledSkills().flatMap((skill) => {
+    const file = path7.join(skill.dir, "SKILL.md");
+    let text;
+    try {
+      text = fs5.readFileSync(file, "utf8");
+    } catch {
+      return [];
+    }
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    const frontmatter = match?.[1] ?? "";
+    const field = (key) => {
+      const line = new RegExp(`^${key}:\\s*(.+)$`, "m").exec(frontmatter)?.[1]?.trim();
+      return line ? line.replace(/^(["'])(.*)\1$/, "$2") : void 0;
+    };
+    const description = field("description");
+    return [
+      {
+        id: skill.name,
+        name: field("name") ?? skill.name,
+        ...description ? { description } : {},
+        path: file,
+        content: match ? text.slice(match[0].length) : text
+      }
+    ];
+  });
+}
 function linkSkill(source, target) {
   try {
     fs5.symlinkSync(source, target, process.platform === "win32" ? "junction" : "dir");
@@ -5989,7 +6193,7 @@ function spawnInteractiveProcess(opts) {
 }
 
 // src/claude-code-language-model.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { unlink as unlink3 } from "fs/promises";
 import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID5 } from "crypto";
@@ -6018,6 +6222,32 @@ function resolveSessionAffinity(headers, providerOptions, providerKey) {
   }
   return "default";
 }
+function resolveOpencodeAgent(headers, providerOptions, providerKey) {
+  if (providerOptions) {
+    const bag = providerOptions[providerKey] ?? providerOptions["claude-code"];
+    const agent = bag?.opencodeAgent;
+    if (typeof agent === "string") return agent;
+  }
+  if (headers) {
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === "x-opencode-agent") {
+        const value = headers[key];
+        if (typeof value === "string" && value.length > 0) return value;
+      }
+    }
+  }
+  return void 0;
+}
+function describeAbortReason(reason) {
+  if (reason === void 0) return "undefined";
+  if (reason instanceof Error) return `${reason.name}: ${reason.message}`;
+  if (typeof reason === "string") return reason;
+  try {
+    return JSON.stringify(reason) ?? typeof reason;
+  } catch {
+    return typeof reason;
+  }
+}
 var KNOWN_DELTA_TYPES = /* @__PURE__ */ new Set([
   "thinking_delta",
   "text_delta",
@@ -6217,9 +6447,9 @@ ${body}`;
     }
   });
 }
-function readPromptFileIfPresent(path9) {
+function readPromptFileIfPresent(path10) {
   try {
-    const content = readFileSync4(path9, "utf8").trim();
+    const content = readFileSync5(path10, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -6334,10 +6564,10 @@ ${options.compressionSummary.trim()}`
   if (includeMultiStepHint) parts.push(MULTI_STEP_TASK_HINT);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path9 = join8(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
+  const path10 = join8(tmpdir2(), `opencode-cc-sys-${randomUUID5()}.md`);
   try {
-    writeFileSync4(path9, content, "utf8");
-    return path9;
+    writeFileSync4(path10, content, "utf8");
+    return path10;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -6423,6 +6653,19 @@ var ClaudeCodeLanguageModel = class {
       raw: reason
     };
   }
+  /**
+   * Whether this call only names the session, which gets the synthetic stub
+   * rather than a `claude` spawn. opencode 1.x sends a title request with no
+   * tools, and that is the whole test there. opencode 2 sends its tool set
+   * along with it (measured on 2.0.11: `scope: "tools"`, agent `title`), so
+   * every new V2 session paid for a second `claude` process just to title
+   * itself; for a V2 model the request kind, carried as the `title` agent,
+   * decides instead.
+   */
+  isTitleRequest(scope, options) {
+    if (scope === "no-tools") return true;
+    return this.config.hostApi === "v2" && this.getOpencodeAgent(options) === "title";
+  }
   requestScope(options) {
     const tools = options?.tools;
     if (Array.isArray(tools)) return "tools";
@@ -6834,15 +7077,15 @@ var ClaudeCodeLanguageModel = class {
     ];
     return valid.includes(effort) ? effort : void 0;
   }
-  getOpencodeAgent(providerOptions) {
-    if (!providerOptions) return void 0;
-    const ownKey = this.config.provider;
-    const bag = providerOptions[ownKey] ?? providerOptions["claude-code"];
-    const agent = bag?.opencodeAgent;
-    return typeof agent === "string" ? agent : void 0;
+  getOpencodeAgent(options) {
+    return resolveOpencodeAgent(
+      options?.headers,
+      options.providerOptions,
+      this.config.provider
+    );
   }
   isCompactionCall(options) {
-    return this.getOpencodeAgent(options.providerOptions) === "compaction";
+    return this.getOpencodeAgent(options) === "compaction";
   }
   /**
    * Pick the model used to handle /compact. Precedence:
@@ -6978,6 +7221,18 @@ var ClaudeCodeLanguageModel = class {
     };
   }
   async doGenerate(options) {
+    const result = await this.doGenerateForHost(options);
+    if (this.config.hostApi !== "v2") return result;
+    const translate = createHostToolPartTranslator("v2");
+    return {
+      ...result,
+      content: result.content.flatMap((part) => {
+        const next = translate(part);
+        return next ? [next] : [];
+      })
+    };
+  }
+  async doGenerateForHost(options) {
     if (!this.isCompactionCall(options) && this.requestScope(options) !== "no-tools" && parseSideQuestion(options.prompt)) {
       return this.doGenerateViaStream(options);
     }
@@ -6986,16 +7241,16 @@ var ClaudeCodeLanguageModel = class {
     const affinity = this.sessionAffinity(options);
     const cwd = await resolveSpawnCwdForSession(this.config.cwd, affinity);
     const effectiveModelId = resolveAgentModel(
-      this.getOpencodeAgent(options.providerOptions),
+      this.getOpencodeAgent(options),
       this.modelId
     );
     const reasoningEffort = resolveAgentEffort(
-      this.getOpencodeAgent(options.providerOptions),
+      this.getOpencodeAgent(options),
       this.getReasoningEffort(options.providerOptions)
     );
     const baseKey = sessionKey(
       cwd,
-      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options.providerOptions) ?? null])}`
+      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options) ?? null])}`
     );
     const sk = effortSessionKey(baseKey, reasoningEffort);
     const compactionMode = this.isCompactionCall(options);
@@ -7005,10 +7260,10 @@ var ClaudeCodeLanguageModel = class {
     if (compactionMode) {
       return this.doGenerateViaStream(options);
     }
-    if (scope === "no-tools") {
+    if (this.isTitleRequest(scope, options)) {
       log.info("doGenerate no-tools title stub", {
         compactionMode,
-        opencodeAgent: this.getOpencodeAgent(options.providerOptions),
+        opencodeAgent: this.getOpencodeAgent(options),
         providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
       });
       const text = this.synthesizeTitle(options.prompt);
@@ -7408,7 +7663,19 @@ ${plan}
       warnings
     };
   }
+  /**
+   * Tool parts leave in opencode 1.x's vocabulary; on opencode 2.x they are
+   * renamed at this one edge (src/host-tools.ts). On V1 the stream is
+   * returned untouched.
+   */
   async doStream(options) {
+    const result = await this.doStreamForHost(options);
+    return {
+      ...result,
+      stream: translateStreamForHost(result.stream, this.config.hostApi ?? "v1")
+    };
+  }
+  async doStreamForHost(options) {
     const warnings = [];
     const skipPermissions = this.config.skipPermissions !== false;
     const scope = this.requestScope(options);
@@ -7416,16 +7683,16 @@ ${plan}
     const cwd = await resolveSpawnCwdForSession(this.config.cwd, affinity);
     const compactionMode = this.isCompactionCall(options);
     const effectiveModelId = compactionMode ? this.resolveCompactionModel() : resolveAgentModel(
-      this.getOpencodeAgent(options.providerOptions),
+      this.getOpencodeAgent(options),
       this.modelId
     );
     const reasoningEffort = compactionMode ? void 0 : resolveAgentEffort(
-      this.getOpencodeAgent(options.providerOptions),
+      this.getOpencodeAgent(options),
       this.getReasoningEffort(options.providerOptions)
     );
     const baseKey = sessionKey(
       cwd,
-      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options.providerOptions) ?? null])}`
+      `${effectiveModelId}::${scope}::${affinity}::context=${JSON.stringify([this.config.provider, this.getOpencodeAgent(options) ?? null])}`
     );
     const sk = compactionMode ? sessionKey(cwd, `${effectiveModelId}::compaction::${affinity}`) : effortSessionKey(baseKey, reasoningEffort);
     const toUsage = this.toUsage.bind(this);
@@ -7526,10 +7793,10 @@ ${plan}
       });
       return { stream: stream2, request: { body: { text: aside.question } } };
     }
-    if (scope === "no-tools" && !compactionMode) {
+    if (this.isTitleRequest(scope, options) && !compactionMode) {
       log.info("doStream no-tools title stub", {
         compactionMode,
-        opencodeAgent: this.getOpencodeAgent(options.providerOptions),
+        opencodeAgent: this.getOpencodeAgent(options),
         providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
       });
       const text = this.synthesizeTitle(options.prompt);
@@ -7719,7 +7986,7 @@ ${plan}
       proxyTools: resolvedProxy?.map((t) => t.name) ?? null,
       compactionMode,
       scope,
-      opencodeAgent: this.getOpencodeAgent(options.providerOptions),
+      opencodeAgent: this.getOpencodeAgent(options),
       providerOptionsKeys: options.providerOptions ? Object.keys(options.providerOptions) : []
     });
     const stream = new ReadableStream({
@@ -8381,7 +8648,7 @@ ${plan}
               });
             }
             activeProcess?.pendingProxyCompletions?.clear();
-            if (accountLimitHit && failoverAskActive) {
+            if (accountLimitHit && failoverAskActive && msg.is_error === true) {
               const call = createAccountFailoverQuestionCall(sk, {
                 sourceAccount,
                 candidates: failoverAccounts,
@@ -9354,14 +9621,28 @@ ${plan}
             options.abortSignal.addEventListener("abort", () => {
               autoContinueState.aborted = true;
               if (turnCompleted || controllerClosed) {
-                if (activeProcess && activeProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
-                  log.info("abort between proxy tool boundaries; releasing pending calls", { sk });
-                  void interruptTurn(activeProcess).then((idle) => {
-                    log.info("interrupt sent for aborted turn", { sk, idle });
+                const stoppedProcess = activeProcess;
+                if (stoppedProcess && stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0) {
+                  const reason = describeAbortReason(options.abortSignal?.reason);
+                  void settleSessionRunState(affinity).then((stopped) => {
+                    const stillParked = stoppedProcess.lineEmitter.listenerCount("line") === 0 && getPendingProxyCalls(sk).length > 0;
+                    if (stopped === "busy" || !stillParked) {
+                      log.debug("abort at a tool boundary while opencode is still running the turn; keeping pending calls", {
+                        sk,
+                        session: stopped,
+                        stillParked,
+                        reason
+                      });
+                      return;
+                    }
+                    log.info("abort between proxy tool boundaries; releasing pending calls", { sk, reason });
+                    void interruptTurn(stoppedProcess).then((idle) => {
+                      log.info("interrupt sent for aborted turn", { sk, idle });
+                    });
+                    releaseAbandonedProxyCalls(
+                      "Provider stream was aborted while opencode was running its proxy tool calls"
+                    );
                   });
-                  releaseAbandonedProxyCalls(
-                    "Provider stream was aborted while opencode was running its proxy tool calls"
-                  );
                 }
                 return;
               }
@@ -9487,7 +9768,7 @@ ${plan}
 // src/cleanup-stale.ts
 import {
   existsSync as existsSync4,
-  readFileSync as readFileSync5,
+  readFileSync as readFileSync6,
   realpathSync,
   rmSync as rmSync3,
   writeFileSync as writeFileSync5
@@ -9514,7 +9795,7 @@ function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
   if (!existsSync4(cfg)) return false;
   try {
-    const json = JSON.parse(readFileSync5(cfg, "utf8"));
+    const json = JSON.parse(readFileSync6(cfg, "utf8"));
     const plugins = json.plugin;
     if (!Array.isArray(plugins)) return false;
     return plugins.some(
@@ -9563,7 +9844,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!existsSync4(pkgJsonPath)) return;
   let pkg = {};
   try {
-    pkg = JSON.parse(readFileSync5(pkgJsonPath, "utf8"));
+    pkg = JSON.parse(readFileSync6(pkgJsonPath, "utf8"));
   } catch {
     return;
   }
@@ -9582,7 +9863,7 @@ function cleanupOne(cacheRoot, ourDir) {
   const cachePkgJson = join9(cacheRoot, "package.json");
   if (!existsSync4(cachePkgJson)) return;
   try {
-    const cfg = JSON.parse(readFileSync5(cachePkgJson, "utf8"));
+    const cfg = JSON.parse(readFileSync6(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
       delete cfg.dependencies[STALE_PACKAGE_NAME];
       writeFileSync5(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
@@ -9595,6 +9876,414 @@ function cleanupOne(cacheRoot, ourDir) {
   }
 }
 
+// src/v2-client.ts
+import path9 from "path";
+function formatAgentTypeList(agents) {
+  const lines = agents.flatMap((agent) => {
+    if (agent.hidden === true || agent.mode === "primary") return [];
+    const name = typeof agent.id === "string" ? agent.id : agent.name;
+    if (typeof name !== "string" || name.length === 0) return [];
+    const blurb = typeof agent.description === "string" ? agent.description.trim() : "";
+    return [`- ${name}: ${blurb || "(no description)"}`];
+  });
+  if (lines.length === 0) return void 0;
+  return `Available agent types and the tools they have access to:
+${lines.join("\n")}`;
+}
+function describe(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "function") {
+    try {
+      const result = value();
+      return typeof result === "string" ? result : "";
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+function toV1Session(info) {
+  if (!info || typeof info !== "object") return void 0;
+  const session = info;
+  const root = session.location?.directory;
+  const directory = typeof root === "string" ? typeof session.subpath === "string" && session.subpath.length > 0 ? path9.resolve(root, session.subpath) : root : void 0;
+  return { ...info, directory, parentID: session.parentID };
+}
+function createV1ClientShim(ctx) {
+  const client = {};
+  const mcpList = ctx.mcp?.list;
+  if (typeof mcpList === "function") {
+    client.mcp = {
+      // V1: `{ data: { [server]: { status } } }`. V2: `{ data: [{ name, status: { status } }] }`.
+      status: async () => {
+        const result = await mcpList.call(ctx.mcp);
+        const data = {};
+        for (const server2 of result?.data ?? []) {
+          const status = server2?.status?.status;
+          if (typeof server2?.name === "string" && typeof status === "string") {
+            data[server2.name] = { status };
+          }
+        }
+        return { data };
+      }
+    };
+  }
+  const toolList = ctx.tool?.list;
+  if (typeof toolList === "function") {
+    client.tool = {
+      // V1: `{ data: [{ id, description, parameters }] }`. V2 returns the tools
+      // themselves, with an Effect schema for input rather than JSON Schema, so
+      // `parameters` is empty; only `proxyOpencodeTools` reads it.
+      list: async () => {
+        const tools = await toolList.call(ctx.tool);
+        const data = (tools ?? []).flatMap((tool) => {
+          const id = typeof tool?.id === "string" ? tool.id : tool?.name;
+          return typeof id === "string" ? [{ id, description: describe(tool.description), parameters: {} }] : [];
+        });
+        const subagent = data.find((tool) => tool.id === "subagent");
+        if (subagent && !data.some((tool) => tool.id === "task")) {
+          let agentList;
+          const agentApi = ctx.agent?.list;
+          if (typeof agentApi === "function") {
+            try {
+              agentList = formatAgentTypeList((await agentApi.call(ctx.agent))?.data ?? []);
+            } catch {
+              agentList = void 0;
+            }
+          }
+          const description = agentList ? `${subagent.description}
+
+${agentList}` : subagent.description;
+          data.push({ ...subagent, id: "task", description });
+        }
+        return { data };
+      }
+    };
+  }
+  const sessionGet = ctx.session?.get;
+  if (typeof sessionGet === "function") {
+    client.session = {
+      get: async (options) => ({
+        data: toV1Session(await sessionGet.call(ctx.session, { sessionID: options.path.id }))
+      })
+    };
+  }
+  return client;
+}
+
+// src/v2.ts
+var V2_PLUGIN_PACKAGE = "aisdk:@khalilgharbaoui/opencode-claude-code-plugin";
+var SESSION_AFFINITY_HEADER = "x-session-affinity";
+var OPENCODE_AGENT_HEADER = "x-opencode-agent";
+var PLUGIN_ONLY_SETTINGS = ["accounts", "defaultSubagentModel"];
+var OPENCODE_SDK_OPTION_KEYS = ["fetch", "headers", "body", "name"];
+function isClaudeCodeProviderId(providerID) {
+  if (typeof providerID !== "string") return false;
+  return providerID === BASE_PROVIDER_ID || providerID.startsWith(`${BASE_PROVIDER_ID}-`);
+}
+function agentForRequest(kind, agent) {
+  if (kind === "compaction") return "compaction";
+  if (kind === "title") return "title";
+  return agent;
+}
+function releasedAt(date) {
+  const ms = date ? Date.parse(date) : Number.NaN;
+  return Number.isFinite(ms) ? ms : 0;
+}
+function modalities(flags) {
+  return Object.entries(flags).filter(([, enabled]) => enabled === true).map(([name]) => name);
+}
+function toV2Model(model, providerID, modelId) {
+  return {
+    id: modelId,
+    modelID: modelId,
+    providerID,
+    name: model.name,
+    family: model.family,
+    capabilities: {
+      tools: model.capabilities.toolcall,
+      input: modalities(model.capabilities.input),
+      output: modalities(model.capabilities.output)
+    },
+    variants: Object.entries(model.variants ?? {}).map(([id, settings]) => ({
+      id,
+      settings: { ...settings }
+    })),
+    time: { released: releasedAt(model.release_date) },
+    cost: [
+      {
+        input: model.cost.input,
+        output: model.cost.output,
+        cache: { read: model.cost.cache.read, write: model.cost.cache.write }
+      }
+    ],
+    status: model.status ?? "active",
+    enabled: true,
+    limit: { context: model.limit.context, output: model.limit.output },
+    package: V2_PLUGIN_PACKAGE
+  };
+}
+function v2ModelsForProvider(providerID, modelSuffix) {
+  return Object.entries(defaultModels).map(
+    ([id, model]) => toV2Model(model, providerID, modelSuffix ? `${id}@${modelSuffix}` : id)
+  );
+}
+function stripPluginOnly(settings) {
+  const result = { ...settings ?? {} };
+  for (const key of PLUGIN_ONLY_SETTINGS) delete result[key];
+  return result;
+}
+function planV2Providers(seedSettings, defaultProxyTools) {
+  const base = {
+    cliPath: "claude",
+    proxyTools: [...defaultProxyTools],
+    ...stripPluginOnly(seedSettings)
+  };
+  const accounts = resolveAccounts(seedSettings?.accounts);
+  if (!accounts) {
+    return [
+      {
+        info: {
+          id: BASE_PROVIDER_ID,
+          name: "Claude Code",
+          activation: "enabled",
+          package: V2_PLUGIN_PACKAGE,
+          settings: { ...base, providerID: BASE_PROVIDER_ID }
+        },
+        models: v2ModelsForProvider(BASE_PROVIDER_ID)
+      }
+    ];
+  }
+  return accounts.map((account) => {
+    const providerID = accountProviderId(account);
+    return {
+      info: {
+        id: providerID,
+        name: accountDisplayName(account),
+        activation: "enabled",
+        package: V2_PLUGIN_PACKAGE,
+        settings: {
+          ...base,
+          account,
+          // The resolved list, so this account's language model can offer the
+          // others when it runs out of usage (src/account-failover.ts).
+          failoverAccounts: accounts,
+          providerID,
+          // Kept separately because the wrapper replaces `cliPath`, and a
+          // failover builds another account's wrapper on the same base.
+          baseCliPath: String(base.cliPath ?? "claude")
+        }
+      },
+      models: v2ModelsForProvider(providerID, accountModelSuffix(account))
+    };
+  });
+}
+async function resolveSdkSettings(providerID, planned, eventOptions) {
+  const fromEvent = { ...eventOptions };
+  for (const key of OPENCODE_SDK_OPTION_KEYS) delete fromEvent[key];
+  const merged = {
+    ...stripPluginOnly({ ...planned ?? {}, ...fromEvent }),
+    providerID,
+    // The only place a model is told it serves opencode 2.
+    hostApi: "v2"
+  };
+  const account = typeof merged.account === "string" ? merged.account : void 0;
+  if (account) {
+    const base = String(merged.baseCliPath ?? merged.cliPath ?? "claude");
+    const runtime = await ensureAccountRuntime(account, base);
+    Object.assign(merged, runtime, { baseCliPath: base });
+  }
+  return merged;
+}
+function plainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function configuredSeedSettings(config, pluginOptions) {
+  const provider = plainObject(plainObject(config.provider)?.[BASE_PROVIDER_ID]);
+  return {
+    ...plainObject(provider?.options) ?? {},
+    ...plainObject(provider?.settings) ?? {},
+    ...pluginOptions ?? {}
+  };
+}
+function isOpencodeV2Context(ctx) {
+  const context = plainObject(ctx);
+  if (!context) return false;
+  const version = plainObject(context.app)?.version;
+  if (typeof version === "string") {
+    const major = Number.parseInt(version.replace(/^v/, ""), 10);
+    if (Number.isFinite(major) && major < 2) return false;
+  }
+  const hasHook = (domain, name) => typeof plainObject(domain)?.[name] === "function";
+  return hasHook(context.provider, "transform") && hasHook(context.aisdk, "hook") && hasHook(context.session, "hook");
+}
+function commandPromptText(command, args) {
+  const rest = (args ?? "").trim();
+  return rest ? `/${command} ${rest}` : `/${command}`;
+}
+function deletedSessionIdV2(event) {
+  if (!event || event.type !== "session.deleted") return void 0;
+  const id = event.data?.sessionID;
+  return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+async function releaseDeletedSessions(subscribe, signal) {
+  try {
+    for await (const event of subscribe({ signal })) {
+      if (signal.aborted) break;
+      const sessionID = deletedSessionIdV2(event);
+      if (!sessionID) continue;
+      const released = deleteActiveProcessesForSession(sessionID);
+      if (released.length > 0) {
+        log.info("released claude state for deleted session", { sessionID, released });
+      }
+    }
+  } catch (err) {
+    if (!signal.aborted) {
+      log.warn("opencode 2 event subscription ended; deleted sessions keep their claude process until idle eviction", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+}
+function createV2Setup(deps) {
+  return async (ctx) => {
+    if (!isOpencodeV2Context(ctx)) {
+      log.debug("setup called outside opencode 2; leaving it to server()", {
+        version: ctx?.app?.version
+      });
+      return () => void 0;
+    }
+    ensureProcessExitCleanup();
+    setOpencodeClient(createV1ClientShim(ctx));
+    const directory = ctx.location?.directory;
+    setOpencodeProjectDirectory(isUsableDirectory(directory) ? directory : void 0);
+    if (deps.buildAgentRegistry) {
+      try {
+        const config = deps.loadConfig(directory ?? process.cwd());
+        await deps.buildAgentRegistry({
+          ...config,
+          provider: {
+            ...plainObject(config.provider) ?? {},
+            [BASE_PROVIDER_ID]: {
+              options: configuredSeedSettings(config, plainObject(ctx.options))
+            }
+          }
+        });
+      } catch (err) {
+        log.warn("failed to build the agent registry for opencode 2", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    const planned = /* @__PURE__ */ new Map();
+    const registrations = [];
+    registrations.push(
+      await ctx.provider.transform((editor) => {
+        const seed = editor.get(BASE_PROVIDER_ID);
+        const seedSettings = {
+          ...seed?.provider.settings ?? {},
+          ...configuredSeedSettings(
+            deps.loadConfig(directory ?? process.cwd()),
+            plainObject(ctx.options)
+          )
+        };
+        const plans = planV2Providers(seedSettings, deps.defaultProxyTools);
+        planned.clear();
+        for (const plan of plans) {
+          planned.set(plan.info.id, plan.info.settings ?? {});
+          if (editor.get(plan.info.id)) {
+            editor.update(plan.info.id, (provider) => {
+              provider.name = plan.info.name;
+              provider.activation = plan.info.activation;
+              provider.package = plan.info.package;
+              provider.settings = plan.info.settings;
+            });
+            editor.models.set(plan.info.id, plan.models);
+          } else {
+            editor.add({ info: plan.info, models: plan.models });
+          }
+        }
+        if (seed && !plans.some((plan) => plan.info.id === BASE_PROVIDER_ID)) {
+          editor.remove(BASE_PROVIDER_ID);
+        }
+        logStartupDiagnostics(
+          Object.fromEntries(
+            plans.map((plan) => [plan.info.id, { name: plan.info.name, options: plan.info.settings }])
+          ),
+          ctx.app?.version
+        );
+      })
+    );
+    registrations.push(
+      await ctx.aisdk.hook("sdk", async (event) => {
+        const providerID = event.model.providerID;
+        if (!isClaudeCodeProviderId(providerID)) return;
+        const settings = await resolveSdkSettings(providerID, planned.get(providerID), event.options);
+        event.sdk = deps.createProvider(settings);
+        log.debug("v2 sdk created", { providerID, cliPath: settings.cliPath });
+      })
+    );
+    registrations.push(
+      await ctx.session.hook("model.request", (event) => {
+        if (!isClaudeCodeProviderId(event.model.providerID)) return;
+        event.headers[SESSION_AFFINITY_HEADER] = event.sessionID;
+        event.headers[OPENCODE_AGENT_HEADER] = agentForRequest(event.kind, event.agent);
+      })
+    );
+    const prompt = ctx.session.prompt;
+    if (ctx.command?.transform && typeof prompt === "function") {
+      const send = (input, command, delivery) => prompt.call(ctx.session, {
+        ...input.prompt,
+        sessionID: input.sessionID,
+        text: commandPromptText(command, input.prompt.text),
+        delivery
+      }).then(() => void 0);
+      registrations.push(
+        await ctx.command.transform((editor) => {
+          editor.add({
+            name: DOCTOR_COMMAND,
+            description: DOCTOR_COMMAND_DESCRIPTION,
+            execute: (input) => send(input, DOCTOR_COMMAND, input.delivery)
+          });
+          editor.add({
+            name: "btw",
+            description: BTW_COMMAND_DESCRIPTION,
+            execute: (input) => send(input, "btw", "queue")
+          });
+        })
+      );
+    }
+    const bundledSkills = readBundledSkillInfos();
+    if (typeof ctx.skill?.transform === "function" && bundledSkills.length > 0) {
+      registrations.push(
+        await ctx.skill.transform((editor) => {
+          const added = [];
+          for (const skill of bundledSkills) {
+            if (editor.get(skill.id)) continue;
+            editor.add(skill);
+            added.push(skill.id);
+          }
+          log.debug("v2 bundled skills registered", { added });
+        })
+      );
+    }
+    const events = new AbortController();
+    if (typeof ctx.event?.subscribe === "function") {
+      void releaseDeletedSessions(ctx.event.subscribe.bind(ctx.event), events.signal);
+    }
+    log.info("claude-code plugin set up for opencode 2", {
+      opencode: ctx.app?.version,
+      directory
+    });
+    return async () => {
+      events.abort();
+      for (const registration of registrations.splice(0)) {
+        await registration.dispose().catch(() => void 0);
+      }
+    };
+  };
+}
+
 // src/index.ts
 function pickOpencodeDirectory(input) {
   if (!input || typeof input !== "object") return void 0;
@@ -9617,7 +10306,7 @@ function registerSideQuestionCommand(config) {
   if (config.command.btw) return false;
   config.command.btw = {
     template: "/btw $ARGUMENTS",
-    description: "Ask a side question in the live Claude Code session without changing its context"
+    description: BTW_COMMAND_DESCRIPTION
   };
   return true;
 }
@@ -9626,7 +10315,7 @@ function registerDoctorCommand(config) {
   if (config.command[DOCTOR_COMMAND]) return false;
   config.command[DOCTOR_COMMAND] = {
     template: `/${DOCTOR_COMMAND} $ARGUMENTS`,
-    description: "Report what the Claude Code plugin sees: versions, cwd, live processes, pending proxy calls"
+    description: DOCTOR_COMMAND_DESCRIPTION
   };
   return true;
 }
@@ -9675,6 +10364,7 @@ function createClaudeCode(settings = {}) {
     return new ClaudeCodeLanguageModel(modelId, {
       provider: providerName,
       cliPath,
+      hostApi: settings.hostApi,
       cwd: settings.cwd,
       account: settings.account,
       configDir: settings.configDir,
@@ -10004,13 +10694,20 @@ var server = async (input) => {
 };
 var index_default = {
   id: "@khalilgharbaoui/opencode-claude-code-plugin",
-  server
+  server,
+  setup: createV2Setup({
+    createProvider: createClaudeCode,
+    defaultProxyTools: DEFAULT_PROXY_TOOL_NAMES,
+    loadConfig: loadMergedOpencodeConfig,
+    buildAgentRegistry: (config) => buildAgentRegistry(config)
+  })
 };
 export {
   ClaudeCodeLanguageModel,
   DEFAULT_PROXY_TOOL_NAMES,
   _resetPlanModeWarningForTests,
   bridgeOpencodeMcp,
+  buildAgentRegistry,
   claudeCodeProviders,
   configModelsForProvider,
   createClaudeCode,