agentp 1.13.0 → 1.14.0

package/README.md

@@ -47,7 +47,7 @@ Notes:
 
 - `agentp` connects to the OpenCode event endpoint over HTTP.
 - In practice this means running `opencode serve` (or equivalent serve mode) so the port is open.
-- `opencode attach` is optional but useful to monitor the full conversation in another terminal/tmux pane.
+- `opencode attach` (older OpenCode) / `opencode --server <url>` (OpenCode v2) is optional but useful to monitor the full conversation in another terminal/tmux pane. `ocmux` picks the right form automatically.
 - If the OpenCode server is password-protected (`OPENCODE_SERVER_PASSWORD`), both `agentp` and `ocmux` automatically send the required HTTP Basic Auth credentials.
 
 ## Usage
@@ -281,6 +281,7 @@ Subcommands:
   - `--print-logs` passes `--print-logs` to `opencode serve`, which prints server logs to stderr in the server tmux pane.
 - **`kill [dir]`** — Kill the server found upward from `dir`. Removes its tmux window and state file.
 - **`resurrect [--print-logs] [dir]`** — Recover a dead/crashed server: reads `.ocmux.json`, kills old tmux window, removes state file, then creates a fresh server + TUI in the same directory. Works even if no tmux window exists (stale state file).
+- **`model [ref]`** — Switch the model of the newest session on the current project's server. With no `ref`, shows an interactive model picker (TTY required). With `ref`, switches directly and prints the server URL on stdout so `agentp $(ocmux model <ref>)` composes: the switch (a side effect) takes effect before agentp sends the next prompt. `ref` supports partial matches when unique (`ocmux model deepseek`, `opencode-go/deepseek`, `...#high`); multiple matches open the picker (or error when not a TTY).
 - **`switch`** — Interactive session picker: an interactive menu of all running servers (columns: dirname, status, url, full path). Arrow keys or `j`/`k` move the selection; `Enter`/`Space` switches to the selected server's tmux window (the menu stays open, so you can hop between servers); `q` or `Ctrl+C` exits. The currently active server (queried live from tmux on every redraw) is highlighted across the full line width. Prints the URL of the last selected server on exit. Requires a TTY.
 - **`list`** — List all running servers with their directories, URLs, and status.
 
@@ -325,7 +326,7 @@ The session API ensures the request is processed even when no TUI is attached, a
 
 Operational hint:
 
-- You can keep a separate `opencode attach` view open to see the full run context while `agentp` is used from shell scripts or editor buffers.
+- You can keep a separate TUI view open to see the full run context while `agentp` is used from shell scripts or editor buffers: `opencode --server '<url>' --continue` on OpenCode v2, or `opencode attach --continue '<url>'` on older versions (`ocmux` uses the right one automatically).
 
 ## tgagentp
 

package/bin/ocmux

@@ -25,7 +25,9 @@ const {
   startServer,
   getActiveServer,
   activateServer,
+  tuiAttachCommand,
 } = require('../lib/ocmux');
+const { listSessions, listModels, switchModel, resolveModelRef } = require('../lib/opencode');
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -186,6 +188,12 @@ function printHelp() {
   console.error('  switch    Interactively select a server to switch to.');
   console.error('            j/k or arrows to move, Enter/Space selects (menu stays open),');
   console.error('            q or Ctrl+C quits. Prints the URL of the last selected server on exit.');
+  console.error('  model     Switch the model of the newest session on the current server.');
+  console.error('            With no argument: interactive model picker (requires a TTY).');
+  console.error('            With <ref>: switch directly and print the server URL on stdout,');
+  console.error('            so `agentp $(ocmux model <ref>)` switches before the next prompt.');
+  console.error('            Partial names work when unique (e.g. "ocmux model deepseek",');
+  console.error('            "opencode-go/deepseek", "...#high"). Multiple matches open the picker.');
   console.error('');
   console.error('  --         Treat the next argument as a directory even if it matches');
   console.error('            a subcommand name (e.g. "ocmux -- kill").');
@@ -238,13 +246,13 @@ function cmdSwitch(statefile, longMode) {
       const panesR = tmux(['list-panes', '-t', `${SESSION}:${winIdx}`, '-F', '#{pane_id}']);
       const panes = panesR.stdout.trim().split('\n').filter(Boolean);
       const lastPane = panes[panes.length - 1];
-      const respawnR = tmux(['respawn-pane', '-k', '-t', lastPane, `opencode attach --continue '${url}'`]);
+      const respawnR = tmux(['respawn-pane', '-k', '-t', lastPane, tuiAttachCommand(url)]);
       if (respawnR.status !== 0) {
-        tmux(['send-keys', '-t', lastPane, `opencode attach --continue '${url}'`, 'Enter']);
+        tmux(['send-keys', '-t', lastPane, tuiAttachCommand(url), 'Enter']);
       }
     } else {
       tmux(['split-window', '-v', '-t', `${SESSION}:${winIdx}`, '-c', serverDir,
-        `opencode attach --continue '${url}'`]);
+        tuiAttachCommand(url)]);
     }
   }
 
@@ -367,6 +375,168 @@ function cmdSwitchMenu(longMode) {
   draw();
 }
 
+// ---------------------------------------------------------------------------
+// Subcommand: model — switch the model of the server's most recent session
+// ---------------------------------------------------------------------------
+
+// Newest session id for a server (same heuristic as agentp's default).
+function newestSessionId(sessions) {
+  if (!sessions || sessions.length === 0) return null;
+  const sorted = sessions
+    .filter(s => s && s.id && s.time && (s.time.updated || s.time.created))
+    .sort((a, b) => {
+      const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
+      const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
+      return bTime - aTime;
+    });
+  return sorted.length > 0 ? sorted[0].id : (sessions[0] && sessions[0].id) || null;
+}
+
+// Interactive model picker (mirrors the ocmux switch menu; single selection).
+// Resolves with the chosen model or null on quit.
+function modelMenu(rows) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY || rows.length === 0) return resolve(null);
+
+    // Display name when it differs from the canonical label (e.g. "Kimi K2 (opencode/kimi-k2)").
+    const display = (r) => (r.name && r.name !== r.label ? `${r.name} (${r.label})` : r.label);
+    const maxLen = Math.max(
+      ...rows.map(r => display(r).length),
+      ...rows.map(r => (r.variants || []).join(',').length),
+      8,
+    );
+    const pad = (s, w) => s + ' '.repeat(Math.max(0, w - s.length));
+    let cursor = 0;
+    let done = false;
+
+    const cleanup = () => {
+      process.stderr.write('\x1b[?25h');
+      process.stderr.write('\x1b[?1049l');
+      try { process.stdin.setRawMode(false); } catch {}
+      process.stdin.pause();
+    };
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      process.stdin.removeAllListeners('keypress');
+      process.removeListener('SIGINT', onSig);
+      resolve(value);
+    };
+    const onSig = () => finish(null);
+    process.on('SIGINT', onSig);
+
+    const draw = () => {
+      let out = '\x1b[2J\x1b[H';
+      out += 'ocmux model — j/k or arrows: move, Enter: switch, q/Ctrl+C: quit\n\n';
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const marker = i === cursor ? '▶ ' : '  ';
+        const variants = (row.variants || []).join(',') || '—';
+        out += `${marker}${pad(display(row), maxLen)}  ${variants}\n`;
+      }
+      process.stderr.write(out);
+    };
+
+    process.stdin.on('keypress', (str, key) => {
+      if (key.ctrl && key.name === 'c') return finish(null);
+      if (key.name === 'q') return finish(null);
+      if (key.name === 'up' || str === 'k') {
+        cursor = (cursor + rows.length - 1) % rows.length;
+        draw();
+      } else if (key.name === 'down' || str === 'j') {
+        cursor = (cursor + 1) % rows.length;
+        draw();
+      } else if (key.name === 'return' || key.name === 'enter' || key.name === 'space') {
+        finish(rows[cursor]);
+      }
+    });
+
+    readline.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stderr.write('\x1b[?1049h\x1b[?25l');
+    draw();
+  });
+}
+
+async function cmdModel(modelRef, longMode) {
+  const sf = findParentStatefile(process.cwd());
+  if (!sf) {
+    console.error(`Error: no opencode server found in ${process.cwd()} or any of its parents.`);
+    console.error("Run 'ocmux serve' to create a new server.");
+    process.exit(1);
+  }
+  const state = readState(sf);
+  if (!state || !state.url) {
+    console.error(`Error: invalid state file ${sf}`);
+    process.exit(1);
+  }
+
+  // Fail fast before any HTTP: interactive picker requires a TTY.
+  if (!modelRef && !process.stdin.isTTY) {
+    console.error('Error: "model" with no argument is interactive and requires a TTY.');
+    console.error('Use "ocmux model <ref>" (partial matches allowed when unique) to switch directly.');
+    process.exit(1);
+  }
+
+  const sessions = await listSessions(state.url).catch((err) => {
+    console.error(`Error connecting to ${state.url}: ${err.message}`);
+    process.exit(1);
+  });
+  const sessionId = newestSessionId(sessions);
+  if (!sessionId) {
+    console.error(`Error: no sessions found on ${state.url} (${path.dirname(sf)}).`);
+    console.error('Open a session in the TUI first, or send a prompt with agentp.');
+    process.exit(1);
+  }
+
+  const models = await listModels(state.url).catch((err) => {
+    console.error(`Error listing models: ${err.message}`);
+    process.exit(1);
+  });
+  if (models.length === 0) {
+    console.error('Error: no models available from this server.');
+    process.exit(1);
+  }
+
+  let pick = null;
+  if (modelRef) {
+    const { model, matches, error } = resolveModelRef(models, modelRef);
+    if (model) {
+      pick = model;
+    } else if (matches.length > 1 && process.stdin.isTTY) {
+      console.error(`Multiple models match "${modelRef}", select one:`);
+      pick = await modelMenu(matches);
+    } else {
+      console.error(`Error: ${error}`);
+      process.exit(1);
+    }
+  } else if (process.stdin.isTTY) {
+    pick = await modelMenu(models);
+  } else {
+    // Unreachable (guarded above) — kept for safety.
+    console.error('Error: "model" with no argument is interactive and requires a TTY.');
+    console.error('Use "ocmux model <ref>" (partial matches allowed when unique) to switch directly.');
+    process.exit(1);
+  }
+
+  if (!pick) {
+    console.error('Cancelled.');
+    return;
+  }
+
+  await switchModel(state.url, sessionId, pick).catch((err) => {
+    console.error(`Error switching model: ${err.message}`);
+    process.exit(1);
+  });
+  const label = pick.label + (pick.variant ? `#${pick.variant}` : '');
+  console.error(`Switched session ${sessionId} to ${label}.`);
+  // Print the URL on stdout so `agentp $(ocmux model <ref>)` composes: the
+  // switch (side effect) takes effect before agentp proceeds with the prompt.
+  outputUrl(state.url, path.dirname(sf), longMode);
+}
+
 // ---------------------------------------------------------------------------
 // Subcommand: list
 // ---------------------------------------------------------------------------
@@ -478,7 +648,7 @@ function doNew(targetDir, longMode, printLogs) {
   const tuiPane = splitResult.stdout.trim();
   sleep(0.2);
   tmux(['send-keys', '-t', tuiPane,
-    `opencode attach --continue '${url}'`, 'Enter']);
+    tuiAttachCommand(url), 'Enter']);
   sleep(0.5);
   if (tuiPane) tmux(['resize-pane', '-Z', '-t', tuiPane]);
 
@@ -611,6 +781,7 @@ function main() {
 
   let subcommand = null;
   let targetDir = null;
+  let modelRef = null;
 
   for (const arg of positional) {
     if (dirIsForced) {
@@ -620,12 +791,15 @@ function main() {
         process.exit(1);
       }
       targetDir = resolveDir(arg);
-    } else if (arg === 'serve' || arg === 'new' || arg === 'kill' || arg === 'list' || arg === 'resurrect' || arg === 'switch') {
+    } else if (arg === 'serve' || arg === 'new' || arg === 'kill' || arg === 'list' || arg === 'resurrect' || arg === 'switch' || arg === 'model') {
       if (subcommand) {
         console.error(`Error: multiple subcommands specified: '${subcommand}' and '${arg}'`);
         process.exit(1);
       }
       subcommand = arg;
+    } else if (subcommand === 'model' && modelRef === null) {
+      // model reference (supports partial matches) — not a directory
+      modelRef = arg;
     } else {
       if (targetDir) {
         console.error(`Error: unexpected argument '${arg}'`);
@@ -695,6 +869,26 @@ function main() {
     }
     ensureSession();
     cmdSwitchMenu(longMode);
+  } else if (subcommand === 'model') {
+    if (gitMode) {
+      console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");
+      process.exit(1);
+    }
+    if (printLogs) {
+      console.error("Error: '--print-logs' is only valid with 'serve'.");
+      process.exit(1);
+    }
+    if (targetDir !== process.cwd()) {
+      console.error("Error: 'model' does not accept a directory path.");
+      process.exit(1);
+    }
+    // cmdModel is async; swallow the (test-mocked) process.exit throw.
+    cmdModel(modelRef, longMode).catch((err) => {
+      if (!err || !err.message || !err.message.startsWith('EXIT:')) {
+        console.error(err ? err.message : String(err));
+        process.exit(1);
+      }
+    });
   } else if (subcommand === 'kill') {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");

package/docs/specification.md

@@ -75,10 +75,13 @@ Manages per-project OpenCode servers in a persistent `Opencode` tmux session.
 | `new [dir]` | Alias for `serve` (deprecated) |
 | `kill [dir]` | Kill server, remove tmux window + `.ocmux.json` |
 | `resurrect [dir]` | Recover dead server: kill old window, remove state file, create fresh server + TUI |
+| `model [ref]` | Switch the model of the newest session (interactive picker without `ref`; prints the server URL on success so `agentp $(ocmux model <ref>)` composes) |
 | `switch` | Interactive session picker (TTY required) |
 | `list [-l]` | List all running servers |
 | _(no arg)_ | Switch to existing server (searches upward for `.ocmux.json`) |
 
+**`model` behavior:** Targets the newest session on the server found upward from `$PWD`. With no argument it opens an interactive model picker (all models, arrow/`j`/`k`, Enter to switch, `q`/`Ctrl+C` to quit; requires a TTY). With a reference it switches directly; references may be full (`providerID/modelID`), partial (matched uniquely against label or bare id), and carry a variant suffix (`#variant`). On success it writes the server URL to stdout (plus a confirmation to stderr), so `agentp $(ocmux model <ref>)` switches the model before the next prompt is sent. Multiple matches open the picker on a TTY, otherwise error listing the candidates. Rejects `--git`, `--GIT`, `--print-logs`, and directory arguments.
+
 **`switch` behavior:** Renders an interactive menu of all running servers on an alt screen with columns `dirname | status | url | full path`. `j`/`k` or arrow keys move the cursor; `Enter`/`Space` activates the selected server (switches its tmux window) and keeps the menu open; `q`/`Ctrl+C` exits and prints the URL of the last selected server (if any). The row matching the tmux-active window (queried live from tmux via `activeWindowIndex()` on every redraw) is highlighted across the full line width, so the highlight tracks both local activations and external tmux window switches. Errors (exit 1) when no TTY or no servers. Rejects `--git`, `--GIT`, `--print-logs`, and directory arguments.
 
 **Default no-server behavior:** When no `.ocmux.json` is found for the current/target directory or any parent, default mode prints the primary `Error: no opencode server found...` line to stdout and the `Run 'ocmux serve'...` hint to stderr. This makes command substitution (`agentp $(ocmux)`) fail safely instead of passing no argument and falling back to `agentp`'s default server.
@@ -88,7 +91,7 @@ Manages per-project OpenCode servers in a persistent `Opencode` tmux session.
 **Window layout:**
 
 - Pane 0: server (`opencode serve --port 0 2>&1 | tee <logfile>`)
-- Pane 1+: TUI (`opencode attach --continue '<url>'`)
+- Pane 1+: TUI (`opencode --server '<url>' --continue` on OpenCode v2; `opencode attach --continue '<url>'` on older versions — chosen automatically via `opencode --version`)
 - Log: `/tmp/opencode-serve-<hashDir(dir)>.log`
 - State: `<dir>/.ocmux.json` (contains `url`, `logfile`, `window_index`)
 
@@ -235,6 +238,8 @@ Server log file. Continuously written by `tee` in the server pane. Polled by `do
 opencode server listening on http://localhost:40999
 ```
 
+OpenCode v2 prints `server listening on http://...` (without the `opencode ` prefix); both formats are matched for URL extraction.
+
 ---
 
 ## Inter-Process Communication
@@ -281,10 +286,10 @@ All servers live in a single tmux session named `Opencode`. Each project gets on
 Session: Opencode
 ├── Window 3: /home/user/project-a
 │   ├── Pane 0: opencode serve --port 0 ...   (server)
-│   └── Pane 1: opencode attach --continue ...  (TUI, zoomed)
+│   └── Pane 1: TUI (opencode --server <url> --continue / attach, zoomed)
 ├── Window 4: /home/user/project-b
 │   ├── Pane 0: opencode serve --port 0 ...
-│   └── Pane 1: opencode attach --continue ...
+│   └── Pane 1: TUI (opencode --server <url> --continue / attach)
 ```
 
 Window names are the full project directory path. Pane 0 is always the server; pane 1+ is the TUI. The TUI pane is zoomed on switch/create. Dead TUI panes are auto-restarted on switch.

package/lib/ocmux.js

@@ -6,7 +6,30 @@ const crypto = require('crypto');
 const child_process = require('child_process');
 
 const SESSION = 'Opencode';
-const URL_RE = /opencode server listening on (http:\/\/[^\s]*)/;
+// OpenCode v2 prints `server listening on http://...`; older versions printed
+// `opencode server listening on http://...`. Accept both.
+const URL_RE = /(?:opencode )?server listening on (http:\/\/[^\s]*)/;
+
+// Detect the OpenCode major version: v2 runs the TUI with `opencode --server`,
+// older versions used the `attach` subcommand. Returns null when undetectable.
+function detectOcMajor() {
+  const r = child_process.spawnSync('opencode', ['--version'], { encoding: 'utf8' });
+  const out = (r.stdout || '') + (r.stderr || '');
+  const m = out.match(/v?(\d+)\.(\d+)\./);
+  return m ? parseInt(m[1], 10) : null;
+}
+
+// Command to attach the TUI to a running server. OpenCode v2 dropped the
+// `attach` subcommand in favor of `opencode --server <url>`; older versions
+// still use `opencode attach --continue <url>`. Falls back to the legacy form
+// when the version cannot be detected (keeps old installations working).
+function tuiAttachCommand(url) {
+  const major = detectOcMajor();
+  if (major !== null && major >= 2) {
+    return `opencode --server '${url}' --continue`;
+  }
+  return `opencode attach --continue '${url}'`;
+}
 
 function _tmux(args) {
   const result = child_process.spawnSync('tmux', args, { encoding: 'utf8', maxBuffer: 1024 * 1024 });
@@ -182,14 +205,14 @@ function activateServer(dir, index, url) {
       if (panesR.status === 0) {
         const panes = panesR.stdout.trim().split('\n').filter(Boolean);
         const lastPane = panes[panes.length - 1];
-        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, `opencode attach --continue '${url}'`]);
+        const respawnR = _tmux(['respawn-pane', '-k', '-t', lastPane, tuiAttachCommand(url)]);
         if (respawnR.status !== 0) {
-          _tmux(['send-keys', '-t', lastPane, `opencode attach --continue '${url}'`, 'Enter']);
+          _tmux(['send-keys', '-t', lastPane, tuiAttachCommand(url), 'Enter']);
         }
       }
     } else {
       _tmux(['split-window', '-v', '-t', `${SESSION}:${winIdx}`, '-c', dir,
-        `opencode attach --continue '${url}'`]);
+        tuiAttachCommand(url)]);
     }
   }
 
@@ -312,7 +335,7 @@ function startServer(dir, printLogs) {
   const splitResult = _tmux(['split-window', '-v', '-P', '-F', '#{pane_id}', '-t', `${SESSION}:${winIdx}`, '-c', dir]);
   const tuiPane = splitResult.stdout.trim();
   sleep(0.2);
-  _tmux(['send-keys', '-t', tuiPane, `opencode attach --continue '${url}'`, 'Enter']);
+  _tmux(['send-keys', '-t', tuiPane, tuiAttachCommand(url), 'Enter']);
   sleep(0.5);
   if (tuiPane) _tmux(['resize-pane', '-Z', '-t', tuiPane]);
 
@@ -346,4 +369,6 @@ module.exports = {
   startServer,
   serverStatus,
   listDeadServers,
+  detectOcMajor,
+  tuiAttachCommand,
 };

package/lib/opencode.js

@@ -12,6 +12,87 @@ function getAuthHeaders() {
   return { 'Authorization': `Basic ${encoded}` };
 }
 
+// ---------------------------------------------------------------------------
+// OpenCode v2 detection
+//
+// OpenCode v2 moved the HTTP API under the `/api` prefix (besides now serving
+// the web UI as HTML at the root), wraps responses in a `{ data }` envelope,
+// and changed the SSE event schema from `{type, properties}` to
+// `{id, type, data}`. Older versions keep the bare paths and old schemas.
+// We probe once per server URL and cache the result.
+// ---------------------------------------------------------------------------
+
+let apiVersionOverride = null;          // 'v2' | 'legacy' | null (auto-detect)
+const v2Servers = new Set();
+const legacyServers = new Set();
+
+// Test hooks: force a protocol version / clear the detection cache.
+function _setApiVersion(v) { apiVersionOverride = v; }
+function _resetApiCache() {
+  v2Servers.clear();
+  legacyServers.clear();
+  apiVersionOverride = null;
+}
+
+// Synchronous fast-path for forced/cached mode; null means auto-detect needed.
+function v2Mode(server) {
+  if (apiVersionOverride === 'v2') return true;
+  if (apiVersionOverride === 'legacy') return false;
+  const key = String(server).replace(/\/+$/, '');
+  if (v2Servers.has(key)) return true;
+  if (legacyServers.has(key)) return false;
+  return null;
+}
+
+// Returns true when `server` speaks the OpenCode v2 HTTP API.
+function detectV2(server) {
+  const forced = v2Mode(server);
+  if (forced !== null) return Promise.resolve(forced);
+  const key = String(server).replace(/\/+$/, '');
+  return makeRequest(buildJsonRequest(`${key}/api/info`, 'GET'), null, null, 5000)
+    .then(({ status, body }) => {
+      let isV2 = status === 401; // a v2 server requires auth; legacy never 401s on /api/info
+      if (status === 200) {
+        const t = String(body).trim();
+        if (t.startsWith('{')) {
+          try {
+            const info = JSON.parse(t);
+            isV2 = !!(info && typeof info.version === 'string');
+          } catch {
+            isV2 = false;
+          }
+        }
+      }
+      (isV2 ? v2Servers : legacyServers).add(key);
+      return isV2;
+    })
+    .catch((err) => {
+      // makeRequest rejects on 401; a v2 server requires auth (legacy never
+      // 401s on /api/info), so treat an auth failure as v2.
+      if (err && /authentication failed/i.test(err.message)) {
+        v2Servers.add(key);
+        return true;
+      }
+      legacyServers.add(key);
+      return false;
+    });
+}
+
+// Base URL for API requests: `server/api` on v2, `server` on legacy.
+function apiBase(server) {
+  return detectV2(server).then((isV2) => {
+    const key = String(server).replace(/\/+$/, '');
+    return isV2 ? `${key}/api` : key;
+  });
+}
+
+// v2 wraps responses in `{ data: ... }`; legacy returns raw JSON.
+function parseBody(body, isV2) {
+  const parsed = JSON.parse(body);
+  if (!isV2) return parsed;
+  return parsed && typeof parsed === 'object' && 'data' in parsed ? parsed.data : parsed;
+}
+
 function makeRequest(options, data, cancelRef, timeoutMs) {
   return new Promise((resolve, reject) => {
     const req = http.request(options, (res) => {
@@ -71,7 +152,23 @@ async function submitPrompt(server) {
 }
 
 // Send a complete text string as a prompt (clear + append + submit).
+// v2 has no TUI prompt endpoints; deliver to the active session instead.
 async function sendText(server, text) {
+  if (await detectV2(server)) {
+    const base = await apiBase(server);
+    const { status, body } = await makeRequest(buildJsonRequest(`${base}/session/active`, 'GET'));
+    if (status !== 200) return;
+    let active = null;
+    try {
+      const data = parseBody(body, true); // data: { <sessionID>: {...} }
+      const ids = data && typeof data === 'object' ? Object.keys(data) : [];
+      if (ids.length > 0) active = ids[0];
+    } catch {}
+    if (!active) return;
+    const pbody = JSON.stringify({ text, delivery: 'queue' });
+    await makeRequest(buildJsonRequest(`${base}/session/${encodeURIComponent(active)}/prompt`, 'POST', pbody), pbody);
+    return;
+  }
   await clearPrompt(server);
   await appendPrompt(server, text);
   await submitPrompt(server);
@@ -82,6 +179,15 @@ async function sendText(server, text) {
 // cancelRef — if provided, { current: null } is populated with the request so it can be aborted.
 // Returns a Promise that resolves with the full collected response string.
 function listenForFinalAnswer(server, onText, cancelRef) {
+  const mode = v2Mode(server);
+  if (mode === true) return listenV2(server, null, { onText }, cancelRef);
+  if (mode === false) return listenLegacyFinalAnswer(server, onText, cancelRef);
+  return detectV2(server).then((isV2) =>
+    isV2 ? listenV2(server, null, { onText }, cancelRef) : listenLegacyFinalAnswer(server, onText, cancelRef));
+}
+
+// Legacy (pre-v2) SSE final-answer listener: events are `{type, properties}`.
+function listenLegacyFinalAnswer(server, onText, cancelRef) {
   return new Promise((resolve, reject) => {
     const url = `${server}/event`;
     const parsed = new URL(url);
@@ -179,14 +285,137 @@ function listenForFinalAnswer(server, onText, cancelRef) {
   });
 }
 
+// OpenCode v2 SSE processor. Events arrive as `data: {id, type, data}` where
+// `data` carries the payload keyed by sessionID. Text streams via
+// `session.text.delta`, reasoning via `session.reasoning.delta`, completion is
+// signaled by `session.execution.succeeded|failed|interrupted`.
+// callbacks: { onText, onThinking, onPermission, onPermissionReplied, onQuestion, onConnected }
+// opts.start — optional async fn called once the stream is connected (used to
+//   send the prompt AFTER attaching the listener, so no events are missed).
+// Resolves with the collected text on completion, stream end, or 90s safety timeout.
+function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
+  const sseLog = logFn || (() => {});
+  return new Promise((resolve, reject) => {
+    const base = String(server).replace(/\/+$/, '');
+    const parsed = new URL(`${base}/api/event`);
+    const req = http.request({
+      hostname: parsed.hostname,
+      port: parsed.port,
+      path: parsed.pathname,
+      method: 'GET',
+      headers: { 'Accept': 'text/event-stream', ...getAuthHeaders() }
+    }, (res) => {
+      if (res.statusCode === 401) {
+        res.resume();
+        reject(new Error('OpenCode server authentication failed. Set OPENCODE_SERVER_PASSWORD to match the server password.'));
+        return;
+      }
+      if (callbacks.onConnected) callbacks.onConnected();
+      let buffer = '';
+      let collected = '';
+      let resolved = false;
+
+      const cleanup = () => { if (cancelRef) cancelRef.current = null; };
+      const finishResolve = (val) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(safetyTimer);
+        cleanup();
+        req.destroy();
+        res.destroy();
+        resolve(val);
+      };
+      const finishReject = (err) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(safetyTimer);
+        cleanup();
+        req.destroy();
+        res.destroy();
+        reject(err);
+      };
+
+      const safetyTimer = setTimeout(() => {
+        sseLog(`  [SSE] safety timeout (90s), collected ${collected.length} chars\n`);
+        finishResolve(collected);
+      }, 90000);
+
+      if (opts && opts.start) {
+        opts.start().catch(finishReject);
+      }
+
+      res.on('data', (chunk) => {
+        buffer += chunk.toString();
+        while (buffer.includes('\n\n')) {
+          const eventEnd = buffer.indexOf('\n\n');
+          const eventData = buffer.slice(0, eventEnd);
+          buffer = buffer.slice(eventEnd + 2);
+
+          const lines = eventData.split('\n');
+          let jsonStr = '';
+          for (const line of lines) {
+            if (line.startsWith('data: ')) jsonStr += line.slice(6);
+          }
+          if (!jsonStr.trim()) continue;
+
+          let ev;
+          try {
+            ev = JSON.parse(jsonStr);
+          } catch {
+            continue;
+          }
+          let data = ev && ev.data;
+          if (typeof data === 'string') {
+            try { data = JSON.parse(data); } catch { data = null; }
+          }
+          if (!data || typeof data !== 'object') continue;
+
+          if (sessionId && data.sessionID && String(data.sessionID) !== String(sessionId)) continue;
+
+          if (ev.type === 'session.text.delta') {
+            if (data.delta != null && data.delta !== '') {
+              if (callbacks.onText) callbacks.onText(data.delta);
+              collected += data.delta;
+            }
+          } else if (ev.type === 'session.text.ended') {
+            if (collected === '' && data.text != null) collected = data.text;
+          } else if (ev.type === 'session.reasoning.delta') {
+            if (data.delta != null && data.delta !== '' && callbacks.onThinking) callbacks.onThinking(data.delta);
+          } else if (ev.type === 'permission.asked') {
+            if (callbacks.onPermission) callbacks.onPermission(data);
+          } else if (ev.type === 'permission.replied') {
+            if (callbacks.onPermissionReplied) callbacks.onPermissionReplied(data);
+          } else if (ev.type === 'form.created' || ev.type === 'question.asked') {
+            if (callbacks.onQuestion) callbacks.onQuestion(data);
+          } else if (ev.type === 'session.execution.succeeded'
+            || ev.type === 'session.execution.failed'
+            || ev.type === 'session.execution.interrupted') {
+            sseLog(`  [SSE] ${ev.type} for session ${sessionId || 'any'}\n`);
+            finishResolve(collected);
+            return;
+          }
+        }
+      });
+
+      res.on('end', () => finishResolve(collected));
+      res.on('error', () => finishResolve(collected));
+    });
+
+    req.on('error', reject);
+    if (cancelRef) cancelRef.current = req;
+    req.end();
+  });
+}
+
 // List all sessions from the OpenCode server.
 // Optionally filter by project directory.
 async function listSessions(server, directory) {
-  let url = `${server}/session`;
+  const isV2 = await detectV2(server);
+  let url = `${await apiBase(server)}/session`;
   if (directory) url += '?directory=' + encodeURIComponent(directory);
   const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
   if (status !== 200) throw new Error(`Failed to list sessions: ${status}`);
-  return JSON.parse(body);
+  return parseBody(body, isV2);
 }
 
 // Send a message directly to a specific session via the synchronous session API.
@@ -194,7 +423,26 @@ async function listSessions(server, directory) {
 // Optionally specify an agent to handle the message.
 // Optional cancelRef allows aborting the HTTP request (for /cancel support).
 async function sendToSession(server, sessionId, text, agent, cancelRef) {
-  const url = `${server}/session/${encodeURIComponent(sessionId)}/message`;
+  const encoded = encodeURIComponent(sessionId);
+  if (await detectV2(server)) {
+    const base = await apiBase(server);
+    if (agent != null) {
+      const body = JSON.stringify({ agent });
+      const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/agent`, 'POST', body), body);
+      if (status !== 200 && status !== 204) throw new Error(`Failed to set agent: ${status}`);
+    }
+    // Attach to the event stream FIRST (so no events are missed), then send the
+    // prompt, and resolve with the collected text when execution completes.
+    return listenV2(server, sessionId, {}, cancelRef, null, {
+      start: async () => {
+        const body = JSON.stringify({ text, delivery: 'steer' });
+        const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/prompt`, 'POST', body), body, cancelRef);
+        if (status !== 200) throw new Error(`Failed to send to session: ${status}`);
+      },
+    });
+  }
+
+  const url = `${server}/session/${encoded}/message`;
   const bodyObj = { parts: [{ type: 'text', text }] };
   if (agent) bodyObj.agent = agent;
   const body = JSON.stringify(bodyObj);
@@ -210,16 +458,49 @@ async function sendToSession(server, sessionId, text, agent, cancelRef) {
 
 // Create a new session on the OpenCode server. Optionally set a title.
 async function createSession(server, title) {
-  const url = `${server}/session`;
+  const isV2 = await detectV2(server);
+  const url = `${await apiBase(server)}/session`;
   const body = JSON.stringify(title != null ? { title } : {});
   const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
   if (status !== 200) throw new Error(`Failed to create session: ${status}`);
-  return JSON.parse(responseBody);
+  return parseBody(responseBody, isV2);
 }
 
 // Update a session's properties (e.g. title, agent, model).
 // model can be a string "providerID/modelID" or an object { providerID, modelID }.
 async function updateSession(server, sessionId, title, agent, model) {
+  const encoded = encodeURIComponent(sessionId);
+  if (await detectV2(server)) {
+    // v2 PATCH accepts only title/metadata/permissions; agent and model have
+    // dedicated endpoints.
+    const base = await apiBase(server);
+    let session = null;
+    if (title != null) {
+      const body = JSON.stringify({ title });
+      const { status, body: responseBody } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}`, 'PATCH', body), body);
+      if (status !== 200) throw new Error(`Failed to update session: ${status}`);
+      session = parseBody(responseBody, true);
+    }
+    if (agent != null) {
+      const body = JSON.stringify({ agent });
+      const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/agent`, 'POST', body), body);
+      if (status !== 200 && status !== 204) throw new Error(`Failed to set agent: ${status}`);
+    }
+    if (model != null) {
+      const mObj = typeof model === 'string'
+        ? { id: model }
+        : { providerID: model.providerID, id: model.modelID || model.id };
+      const body = JSON.stringify({ model: mObj });
+      const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/model`, 'POST', body), body);
+      if (status !== 200 && status !== 204) throw new Error(`Failed to set model: ${status}`);
+    }
+    if (session) return session;
+    // Nothing to patch: return the current session info.
+    const { status, body: responseBody } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}`, 'GET'));
+    if (status !== 200) throw new Error(`Failed to update session: ${status}`);
+    return parseBody(responseBody, true);
+  }
+
   const bodyObj = {};
   if (title != null) bodyObj.title = title;
   if (agent != null) bodyObj.agent = agent;
@@ -228,7 +509,7 @@ async function updateSession(server, sessionId, title, agent, model) {
       ? model
       : { providerID: model.providerID, id: model.modelID || model.id };
   }
-  const url = `${server}/session/${encodeURIComponent(sessionId)}`;
+  const url = `${server}/session/${encoded}`;
   const body = JSON.stringify(bodyObj);
   const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'PATCH', body), body);
   if (status !== 200) throw new Error(`Failed to update session: ${status}`);
@@ -238,6 +519,11 @@ async function updateSession(server, sessionId, title, agent, model) {
 // Tell the TUI to navigate to a specific session (if a TUI is attached).
 // Tries multiple approaches since the endpoint varies by opencode version.
 async function selectSession(server, sessionId) {
+  if (await detectV2(server)) {
+    // v2 has no HTTP endpoint to steer the TUI to a session; the TUI keeps
+    // itself in sync. Best effort: no-op.
+    return;
+  }
   const encoded = encodeURIComponent(sessionId);
   const attempts = [
     { url: `${server}/tui/select-session`, body: JSON.stringify({ sessionID: sessionId }) },
@@ -260,6 +546,25 @@ async function selectSession(server, sessionId) {
 // Tries GET /session/:id first; falls back to filtering the sessions list.
 async function getSession(server, sessionId) {
   const encoded = encodeURIComponent(sessionId);
+  if (await detectV2(server)) {
+    const base = await apiBase(server);
+    const urls = [`${base}/session/${encoded}`];
+    for (const url of urls) {
+      try {
+        const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'), null, null, 10000);
+        if (status === 200) {
+          try {
+            const parsed = parseBody(body, true);
+            if (parsed != null) return parsed;
+          } catch {}
+        }
+      } catch {}
+    }
+    const sessions = await listSessions(server);
+    const match = sessions.find(s => String(s.id) === String(sessionId));
+    if (match) return match;
+    throw new Error(`Session ${sessionId} not found`);
+  }
   // Try several endpoint patterns that different opencode versions may expose
   const urls = [
     `${server}/session/${encoded}`,
@@ -288,24 +593,176 @@ async function getSession(server, sessionId) {
 
 // List all agents from the OpenCode server.
 async function listAgents(server) {
-  const url = `${server}/agent`;
+  const isV2 = await detectV2(server);
+  const url = `${await apiBase(server)}/agent`;
   const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
   if (status !== 200) throw new Error(`Failed to list agents: ${status}`);
-  return JSON.parse(body);
+  return parseBody(body, isV2);
 }
 
 // List all providers/models from the OpenCode server.
 async function listProviders(server) {
-  const url = `${server}/provider`;
+  const isV2 = await detectV2(server);
+  const url = `${await apiBase(server)}/provider`;
   const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
   if (status !== 200) throw new Error(`Failed to list providers: ${status}`);
-  return JSON.parse(body);
+  return parseBody(body, isV2);
+}
+
+// List available models as { providerID, id, label: "providerID/id", name, variants: [] }.
+// `name` is the friendly display name (e.g. "Kimi K2") when the server provides it.
+// v2: GET /api/model. Legacy: derive from the provider list.
+async function listModels(server) {
+  const isV2 = await detectV2(server);
+  const out = [];
+  const toVariants = (variants) => (Array.isArray(variants)
+    ? variants.map(v => (typeof v === 'string' ? v : (v && v.id))).filter(Boolean)
+    : []);
+  const push = (providerID, id, name, variants) => {
+    if (!providerID || !id) return;
+    if (out.some(m => m.providerID === providerID && m.id === id)) return;
+    out.push({
+      providerID,
+      id,
+      label: `${providerID}/${id}`,
+      name: name && String(name) !== String(id) ? String(name) : null,
+      variants: toVariants(variants),
+    });
+  };
+  if (isV2) {
+    const url = `${await apiBase(server)}/model`;
+    const { status, body } = await makeRequest(buildJsonRequest(url, 'GET'));
+    if (status !== 200) throw new Error(`Failed to list models: ${status}`);
+    const data = parseBody(body, true) || [];
+    for (const m of data) push(m.providerID, m.id, m.name || m.label, m.variants);
+    return out;
+  }
+  const providers = await listProviders(server);
+  for (const p of providers) {
+    const pid = p.provider || p.id || p.name;
+    const models = p.models || [];
+    for (const m of models) push(pid, m.id || m.model || m.name, m.name, m.variants);
+  }
+  return out;
+}
+
+// Parse a model reference: "providerID/modelID", "modelID", optionally with a
+// "#variant" suffix. Returns { providerID, id, variant } (providerID may be null).
+function parseModelRef(ref) {
+  const s = String(ref || '').trim();
+  if (!s) return null;
+  let variant = null;
+  let base = s;
+  const hashIdx = s.indexOf('#');
+  if (hashIdx !== -1) {
+    variant = s.slice(hashIdx + 1) || null;
+    base = s.slice(0, hashIdx);
+  }
+  const slashIdx = base.indexOf('/');
+  if (slashIdx === -1) return { providerID: null, id: base, variant };
+  return { providerID: base.slice(0, slashIdx) || null, id: base.slice(slashIdx + 1) || null, variant };
+}
+
+// Resolve a (possibly partial) model reference against available models.
+// Returns { model, matches, error }; `model` is set only when exactly one
+// candidate matches. Matching is case-insensitive and, besides the canonical
+// "providerID/modelID" label and bare id, also matches the friendly display
+// name (e.g. "Kimi K2"); separators/quotes are ignored so "deep seek" matches
+// "DeepSeek V4" and "deepseek-v4-flash".
+function resolveModelRef(models, ref) {
+  const q = String(ref || '').trim();
+  if (!q) return { model: null, matches: models, error: null };
+  const parsed = parseModelRef(q);
+  const variant = parsed ? parsed.variant : null;
+  const baseQ = parsed
+    ? (parsed.providerID ? `${parsed.providerID}/${parsed.id}` : parsed.id)
+    : q;
+  const baseQLower = baseQ.toLowerCase();
+  const norm = (s) => String(s || '').toLowerCase().replace(/[\s\-_.'’]/g, '');
+
+  // 1) Exact canonical label ("providerID/modelID").
+  const byLabel = models.filter(m => m.label.toLowerCase() === baseQLower);
+  if (byLabel.length === 1) return { model: { ...byLabel[0], variant }, matches: byLabel, error: null };
+  if (byLabel.length > 1) {
+    return { model: null, matches: byLabel, error: `multiple models match "${q}" (${byLabel.length}): ${byLabel.map(m => m.label).join(', ')}` };
+  }
+
+  // 2) Exact bare id (only when the reference has no provider prefix).
+  if (!parsed || !parsed.providerID) {
+    const byId = models.filter(m => m.id.toLowerCase() === baseQLower);
+    if (byId.length === 1) return { model: { ...byId[0], variant }, matches: byId, error: null };
+    if (byId.length > 1) {
+      return { model: null, matches: byId, error: `multiple models match "${q}" (${byId.length}): ${byId.map(m => m.label).join(', ')}` };
+    }
+  }
+
+  // 3) Substring match on label, bare id, or display name (raw and normalized).
+  const qLower = q.toLowerCase();
+  const qNorm = norm(q);
+  const matches = models.filter(m =>
+    m.label.toLowerCase().includes(qLower)
+    || m.id.toLowerCase().includes(qLower)
+    || (m.name != null && m.name.toLowerCase().includes(qLower))
+    || (qNorm !== '' && (norm(m.label).includes(qNorm) || norm(m.id).includes(qNorm) || (m.name != null && norm(m.name).includes(qNorm))))
+  );
+  if (matches.length === 1) return { model: { ...matches[0], variant }, matches, error: null };
+  const error = matches.length === 0
+    ? `no model matches "${q}"`
+    : `multiple models match "${q}" (${matches.length}): ${matches.map(m => m.label).join(', ')}`;
+  return { model: null, matches, error };
+}
+
+// Switch the session's model immediately. On v2 POSTs /api/session/:id/model;
+// on legacy PATCHes the session's model. `model` may be a string reference or a
+// { providerID, id, variant? } object (as produced by resolveModelRef).
+async function switchModel(server, sessionId, model) {
+  const encoded = encodeURIComponent(sessionId);
+  const mObj = model && typeof model === 'object' ? model : (parseModelRef(model) || {});
+  if (!mObj.id || !mObj.providerID) {
+    throw new Error(`Invalid model reference: ${model}`);
+  }
+  const isV2 = await detectV2(server);
+  if (isV2) {
+    const base = await apiBase(server);
+    const bodyObj = { model: { providerID: mObj.providerID, id: mObj.id } };
+    if (mObj.variant) bodyObj.model.variant = mObj.variant;
+    const body = JSON.stringify(bodyObj);
+    const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/model`, 'POST', body), body);
+    if (status !== 200 && status !== 204) throw new Error(`Failed to switch model: ${status}`);
+    return;
+  }
+  await updateSession(server, sessionId, null, null, `${mObj.providerID}/${mObj.id}`);
 }
 
 // Send a message asynchronously (non-blocking). Returns 204 No Content.
 // Optionally specify a model and/or noReply (injects context without AI response).
 async function sendToSessionAsync(server, sessionId, text, agent, model, noReply) {
-  const url = `${server}/session/${encodeURIComponent(sessionId)}/prompt_async`;
+  const encoded = encodeURIComponent(sessionId);
+  if (await detectV2(server)) {
+    const base = await apiBase(server);
+    if (agent != null) {
+      const body = JSON.stringify({ agent });
+      const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/agent`, 'POST', body), body);
+      if (status !== 200 && status !== 204) throw new Error(`Failed to set agent: ${status}`);
+    }
+    if (model != null) {
+      const mObj = typeof model === 'string'
+        ? { id: model }
+        : { providerID: model.providerID, id: model.modelID || model.id };
+      const body = JSON.stringify({ model: mObj });
+      const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/model`, 'POST', body), body);
+      if (status !== 200 && status !== 204) throw new Error(`Failed to set model: ${status}`);
+    }
+    // Non-blocking enqueue. (legacy noReply has no v2 equivalent; the prompt is
+    // queued and executed when the session processes its inbox.)
+    const body = JSON.stringify({ text, delivery: 'queue' });
+    const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/prompt`, 'POST', body), body);
+    if (status !== 200 && status !== 201 && status !== 202 && status !== 204) {
+      throw new Error(`Failed to send async message: ${status}`);
+    }
+    return;
+  }
+  const url = `${server}/session/${encoded}/prompt_async`;
   const bodyObj = { parts: [{ type: 'text', text }] };
   if (agent) bodyObj.agent = agent;
   if (model) bodyObj.model = typeof model === 'string' ? model : { providerID: model.providerID, modelID: model.modelID };
@@ -317,7 +774,20 @@ async function sendToSessionAsync(server, sessionId, text, agent, model, noReply
 
 // Respond to a permission request.
 async function respondToPermission(server, sessionId, permissionId, response, remember) {
-  const url = `${server}/session/${encodeURIComponent(sessionId)}/permissions/${encodeURIComponent(permissionId)}`;
+  const encodedS = encodeURIComponent(sessionId);
+  const encodedP = encodeURIComponent(permissionId);
+  if (await detectV2(server)) {
+    const base = await apiBase(server);
+    // v2 decision enum: once | always | reject
+    let decision = response === 'allow' ? 'once' : response;
+    if (remember && decision !== 'reject') decision = 'always';
+    if (!['once', 'always', 'reject'].includes(decision)) decision = 'once';
+    const body = JSON.stringify({ decision });
+    const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encodedS}/permission/${encodedP}/reply`, 'POST', body), body);
+    if (status !== 200 && status !== 204) throw new Error(`Failed to respond to permission: ${status}`);
+    return;
+  }
+  const url = `${server}/session/${encodedS}/permissions/${encodedP}`;
   const bodyObj = { response };
   if (remember) bodyObj.remember = true;
   const body = JSON.stringify(bodyObj);
@@ -331,6 +801,17 @@ async function respondToPermission(server, sessionId, permissionId, response, re
 // cancelRef — allows aborting the SSE stream via req.destroy()
 // logFn — optional logger; if provided, used instead of process.stderr.write
 function listenForSessionEvents(server, sessionId, callbacks, cancelRef, logFn) {
+  const mode = v2Mode(server);
+  if (mode === true) return listenV2(server, sessionId, callbacks, cancelRef, logFn, null);
+  if (mode === false) return listenLegacySessionEvents(server, sessionId, callbacks, cancelRef, logFn);
+  return detectV2(server).then((isV2) =>
+    isV2
+      ? listenV2(server, sessionId, callbacks, cancelRef, logFn, null)
+      : listenLegacySessionEvents(server, sessionId, callbacks, cancelRef, logFn));
+}
+
+// Legacy (pre-v2) SSE session-event listener: events are `{type, properties}`.
+function listenLegacySessionEvents(server, sessionId, callbacks, cancelRef, logFn) {
   const sseLog = logFn || ((msg) => {
     const ts = new Date().toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, '');
     process.stderr.write(`${ts} ${msg}`);
@@ -511,9 +992,10 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef, logFn)
 // Check if an OpenCode server is reachable by making a GET /session request.
 // Returns a Promise that resolves to `true` (any response) or `false` (connection error / timeout).
 function isServerAlive(url) {
-  return new Promise((resolve) => {
-    const mod = url.startsWith('https') ? https : http;
-    const parsed = new URL(url + '/session');
+  return detectV2(url).then((isV2) => new Promise((resolve) => {
+    const base = String(url).replace(/\/+$/, '');
+    const mod = base.startsWith('https') ? https : http;
+    const parsed = new URL(`${base}${isV2 ? '/api' : ''}/session`);
     const opts = {
       hostname: parsed.hostname,
       port: parsed.port,
@@ -528,12 +1010,21 @@ function isServerAlive(url) {
     req.on('error', () => resolve(false));
     req.setTimeout(5000, () => { req.destroy(); resolve(false); });
     req.end();
-  });
+  })).catch(() => false);
 }
 
 // Respond to a question (choice) asked by the AI.
 async function respondToQuestion(server, sessionId, questionId, answer) {
-  const url = `${server}/session/${encodeURIComponent(sessionId)}/questions/${encodeURIComponent(questionId)}`;
+  const encodedS = encodeURIComponent(sessionId);
+  const encodedQ = encodeURIComponent(questionId);
+  if (await detectV2(server)) {
+    const base = await apiBase(server);
+    const body = JSON.stringify({ answer });
+    const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encodedS}/form/${encodedQ}/reply`, 'POST', body), body);
+    if (status !== 200 && status !== 204) throw new Error(`Failed to respond to question: ${status}`);
+    return;
+  }
+  const url = `${server}/session/${encodedS}/questions/${encodedQ}`;
   const body = JSON.stringify({ answer });
   const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
   if (status !== 200) throw new Error(`Failed to respond to question: ${status}`);
@@ -560,5 +1051,15 @@ module.exports = {
   listenForSessionEvents,
   listAgents,
   listProviders,
+  listModels,
+  parseModelRef,
+  resolveModelRef,
+  switchModel,
   isServerAlive,
+  detectV2,
+  apiBase,
+  parseBody,
+  listenV2,
+  _setApiVersion,
+  _resetApiCache,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentp",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",