agentp 1.14.0 → 2.0.1

package/lib/opencode.js

@@ -1,5 +1,13 @@
 'use strict';
 
+// OpenCode v2 HTTP/SSE session API client.
+//
+// v2-only: endpoints live under `/api`, responses are wrapped in a `{data}`
+// envelope, and the SSE event schema is `{id, type, data}` (text streams via
+// `session.text.delta`, completion via `session.execution.succeeded|failed`,
+// interruption via `session.execution.interrupted`). Legacy (v1) support has
+// been removed.
+
 const http = require('http');
 const https = require('https');
 const { URL } = require('url');
@@ -12,84 +20,27 @@ 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;
+// v2 is the only supported protocol now; kept for API compatibility.
+function v2Mode() {
+  return true;
 }
 
-// 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;
+function detectV2() {
+  return Promise.resolve(true);
 }
 
-// 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;
-    });
-}
+function _setApiVersion() { /* v2 only — kept as a no-op for compatibility */ }
+function _resetApiCache() { /* v2 only — kept as a no-op for compatibility */ }
 
-// 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;
-  });
+// Base URL for API requests (v2: `server/api`).
+async function apiBase(server) {
+  const key = String(server).replace(/\/+$/, '');
+  return `${key}/api`;
 }
 
-// v2 wraps responses in `{ data: ... }`; legacy returns raw JSON.
-function parseBody(body, isV2) {
+// v2 wraps responses in `{ data: ... }`; unwrap it when present.
+function parseBody(body) {
   const parsed = JSON.parse(body);
-  if (!isV2) return parsed;
   return parsed && typeof parsed === 'object' && 'data' in parsed ? parsed.data : parsed;
 }
 
@@ -135,155 +86,50 @@ function buildJsonRequest(url, method, body) {
   return opts;
 }
 
-async function clearPrompt(server) {
-  const url = `${server}/tui/clear-prompt`;
-  await makeRequest(buildJsonRequest(url, 'POST', '{}'), '{}');
-}
-
-async function appendPrompt(server, text) {
-  const url = `${server}/tui/append-prompt`;
-  const body = JSON.stringify({ text });
-  await makeRequest(buildJsonRequest(url, 'POST', body), body);
-}
-
-async function submitPrompt(server) {
-  const url = `${server}/tui/submit-prompt`;
-  await makeRequest(buildJsonRequest(url, 'POST', '{}'), '{}');
-}
-
-// Send a complete text string as a prompt (clear + append + submit).
-// v2 has no TUI prompt endpoints; deliver to the active session instead.
+// Send a complete text string to the server's ACTIVE session (no TUI prompt
+// endpoints exist in v2).
 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);
-}
-
-// Listen for the final answer from the OpenCode event stream.
-// onText(chunk) is called for each text part received (optional; defaults to no-op).
-// 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.
+  const base = await apiBase(server);
+  const { status, body } = await makeRequest(buildJsonRequest(`${base}/session/active`, 'GET'));
+  if (status !== 200) return;
+  let active = null;
+  try {
+    // GET /session/active → { data: { <sessionID>: {...running} } }
+    const data = parseBody(body);
+    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);
+}
+
+// Listen for the assistant's answer from the v2 SSE stream.
+// onText(chunk) is called for each text part received.
+// cancelRef — if provided, { current: null } is populated with the request so
+// it can be aborted. Returns a Promise resolving with the full collected text.
 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));
+  return listenV2(server, null, { 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);
-    const write = typeof onText === 'function' ? onText : null;
-
-    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;
-      }
-      let buffer = '';
-      const userMessageIDs = new Set();
-      let collected = '';
-
-      res.on('data', (chunk) => {
-        buffer += chunk.toString();
-
-        // Split by double newline (SSE event separator)
-        while (buffer.includes('\n\n')) {
-          const eventEnd = buffer.indexOf('\n\n');
-          const eventData = buffer.slice(0, eventEnd);
-          buffer = buffer.slice(eventEnd + 2);
-
-          // Extract data lines
-          const lines = eventData.split('\n');
-          let jsonStr = '';
-
-          for (const line of lines) {
-            if (line.startsWith('data: ')) {
-              jsonStr += line.slice(6);
-            }
-          }
-
-          if (!jsonStr.trim()) continue;
-
-          try {
-            const event = JSON.parse(jsonStr);
-
-            // Track user message IDs
-            if (event.type === 'message.updated' && event.properties?.info?.role === 'user') {
-              userMessageIDs.add(event.properties.info.id);
-            }
-
-            // Check for session.idle to detect completion
-            if (event.type === 'session.idle') {
-              cleanup();
-              req.destroy();
-              res.destroy();
-              resolve(collected);
-              return;
-            }
-
-            const part = event.properties?.part;
-            if (!part) continue;
-
-            // Filter out user input by checking messageID
-            if (part.messageID && userMessageIDs.has(part.messageID)) {
-              continue;
-            }
-
-            if (part.type === 'text' && part.text != null && part.text !== '') {
-              if (write) write(part.text);
-              collected += part.text;
-            }
-          } catch (e) {
-            // Malformed SSE event — skip and continue processing
-          }
-        }
-      });
-
-      res.on('end', () => {
-        cleanup();
-        resolve(collected);
-      });
-    });
-
-    const cleanup = () => {
-      if (cancelRef) cancelRef.current = null;
-    };
-
-    req.on('error', (err) => {
-      cleanup();
-      reject(err);
-    });
-
-    if (cancelRef) cancelRef.current = req;
-    req.end();
-  });
-}
+// Quiescence window after a terminal `session.execution.*` event. OpenCode v2
+// can signal completion before the agent is truly done (a retry may schedule a
+// new execution, or a sub-agent may resume later). We resolve only after this
+// window elapses with no further activity — and ANY event on the stream
+// (including child-session/sub-agent events) resets it. `interrupted` resolves
+// immediately.
+//
+// The window must comfortably exceed the longest SILENT gap of a turn (e.g. a
+// long `bash`/tool call, or a sub-agent that emits nothing for a while);
+// otherwise the answer gets truncated. Tunable via AGENTP_COMPLETION_GRACE_MS.
+const DEFAULT_COMPLETION_GRACE_MS = 15000;
+let completionGraceMs = (() => {
+  const env = parseInt(process.env.AGENTP_COMPLETION_GRACE_MS, 10);
+  return Number.isFinite(env) && env > 0 ? env : DEFAULT_COMPLETION_GRACE_MS;
+})();
+
+// Test hook: override the quiescence window (e.g. to speed up tests).
+function _setCompletionGraceMs(ms) { completionGraceMs = ms; }
 
 // OpenCode v2 SSE processor. Events arrive as `data: {id, type, data}` where
 // `data` carries the payload keyed by sessionID. Text streams via
@@ -314,12 +160,19 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
       let buffer = '';
       let collected = '';
       let resolved = false;
+      let completionTimer = null;
 
       const cleanup = () => { if (cancelRef) cancelRef.current = null; };
+
+      const clearCompletionTimer = () => {
+        if (completionTimer) { clearTimeout(completionTimer); completionTimer = null; }
+      };
+
       const finishResolve = (val) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(safetyTimer);
+        clearCompletionTimer();
         cleanup();
         req.destroy();
         res.destroy();
@@ -329,6 +182,7 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
         if (resolved) return;
         resolved = true;
         clearTimeout(safetyTimer);
+        clearCompletionTimer();
         cleanup();
         req.destroy();
         res.destroy();
@@ -340,6 +194,30 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
         finishResolve(collected);
       }, 90000);
 
+      const scheduleCompletion = () => {
+        if (resolved || completionTimer) return;
+        completionTimer = setTimeout(async () => {
+          completionTimer = null;
+          // Optional second opinion: if the caller can verify the session is
+          // truly idle (its idle marker newer than the send time), keep waiting
+          // — otherwise a terminal signal from an OLDER queued execution would
+          // resolve with an empty/partial answer.
+          if (opts && typeof opts.verify === 'function' && !(await opts.verify())) {
+            sseLog('  [SSE] session not yet idle after quiescence — waiting more\n');
+            scheduleCompletion();
+            return;
+          }
+          sseLog(`  [SSE] terminal signal confirmed after quiescence (${collected.length} chars)\n`);
+          finishResolve(collected);
+        }, completionGraceMs);
+      };
+      const cancelCompletion = () => {
+        if (completionTimer) {
+          clearCompletionTimer();
+          sseLog(`  [SSE] activity after terminal signal — continuing\n`);
+        }
+      };
+
       if (opts && opts.start) {
         opts.start().catch(finishReject);
       }
@@ -370,9 +248,30 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
           }
           if (!data || typeof data !== 'object') continue;
 
+          // Interrupted → resolve immediately with what we have. Every other
+          // event counts as activity — including sub-agent events from child
+          // sessions flowing on the same stream — and defers completion: we
+          // only finish after a silent grace window following the last
+          // terminal signal (a long-running tool or sub-agent would otherwise
+          // truncate the answer).
+          if (ev.type === 'session.execution.interrupted') {
+            sseLog(`  [SSE] session.execution.interrupted for session ${sessionId || 'any'}\n`);
+            finishResolve(collected);
+            return;
+          }
+          cancelCompletion();
+
           if (sessionId && data.sessionID && String(data.sessionID) !== String(sessionId)) continue;
 
-          if (ev.type === 'session.text.delta') {
+          if (ev.type === 'session.text.started') {
+            // v2 emits one text segment per step; separate them so the answer
+            // doesn't run adjacent segments together (as the TUI shows them).
+            if (collected !== '' && !collected.endsWith('\n\n')) {
+              const sep = '\n\n';
+              if (callbacks.onText) callbacks.onText(sep);
+              collected += sep;
+            }
+          } else if (ev.type === 'session.text.delta') {
             if (data.delta != null && data.delta !== '') {
               if (callbacks.onText) callbacks.onText(data.delta);
               collected += data.delta;
@@ -381,6 +280,8 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
             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 === 'session.execution.started' || ev.type === 'session.retry.scheduled') {
+            // activity → completion already cancelled above
           } else if (ev.type === 'permission.asked') {
             if (callbacks.onPermission) callbacks.onPermission(data);
           } else if (ev.type === 'permission.replied') {
@@ -388,11 +289,9 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
           } 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;
+            || ev.type === 'session.execution.failed') {
+            sseLog(`  [SSE] ${ev.type} for session ${sessionId || 'any'} — awaiting quiescence\n`);
+            scheduleCompletion();
           }
         }
       });
@@ -407,184 +306,137 @@ function listenV2(server, sessionId, callbacks, cancelRef, logFn, opts) {
   });
 }
 
-// List all sessions from the OpenCode server.
-// Optionally filter by project directory.
+// List sessions with a running (foreground) drain, as a Set of session IDs.
+async function getActiveSessions(server) {
+  try {
+    const base = await apiBase(server);
+    const { status, body } = await makeRequest(buildJsonRequest(`${base}/session/active`, 'GET'));
+    if (status !== 200) return new Set();
+    const data = parseBody(body);
+    return new Set(data && typeof data === 'object' ? Object.keys(data) : []);
+  } catch {
+    return new Set();
+  }
+}
+
+// List all sessions from the OpenCode server, optionally filtered by project
+// directory (exact match on the session's location.directory).
 async function listSessions(server, directory) {
-  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 parseBody(body, isV2);
+  return parseBody(body);
 }
 
-// Send a message directly to a specific session via the synchronous session API.
-// Returns the collected text from all text parts in the response.
-// Optionally specify an agent to handle the message.
-// Optional cancelRef allows aborting the HTTP request (for /cancel support).
+// Send a message directly to a specific session. Attaches to the event stream
+// FIRST (so no events are missed), then posts a steered prompt, and resolves
+// with the collected text when execution completes.
 async function sendToSession(server, sessionId, text, agent, cancelRef) {
   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 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}`);
   }
-
-  const url = `${server}/session/${encoded}/message`;
-  const bodyObj = { parts: [{ type: 'text', text }] };
-  if (agent) bodyObj.agent = agent;
-  const body = JSON.stringify(bodyObj);
-  const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'POST', body), body, cancelRef);
-  if (status !== 200) throw new Error(`Failed to send to session: ${status}`);
-  const result = JSON.parse(responseBody);
-  const texts = (result.parts || [])
-    .filter(p => p.type === 'text')
-    .map(p => p.text)
-    .join('');
-  return texts;
+  let sendAt = Date.now();
+  let verifyTries = 0;
+  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}`);
+      sendAt = Date.now();
+    },
+    // After a quiescence candidate, only treat the turn as done when the
+    // session's idle marker is newer than our send — otherwise the terminal
+    // signal probably belonged to an older queued execution (which would
+    // produce an empty/partial answer). Give up after a few tryouts so a
+    // stalled session can't hang the caller forever.
+    verify: async () => {
+      verifyTries++;
+      if (verifyTries > 5) return true;
+      try {
+        const s = await getSession(server, sessionId);
+        const idle = s && s.time && s.time.idle;
+        return !!(idle && idle >= sendAt - 1000);
+      } catch {
+        return true; // cannot verify → trust the quiescence window
+      }
+    },
+  });
 }
 
-// Create a new session on the OpenCode server. Optionally set a title.
-async function createSession(server, title) {
-  const isV2 = await detectV2(server);
+// Create a new session. Optionally set a title and pin it to a project
+// location (directory → Location.PublicRef `{ directory }`).
+async function createSession(server, title, location) {
   const url = `${await apiBase(server)}/session`;
-  const body = JSON.stringify(title != null ? { title } : {});
+  const payload = {};
+  if (title != null) payload.title = title;
+  if (location != null) payload.location = { directory: location };
+  const body = JSON.stringify(payload);
   const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
   if (status !== 200) throw new Error(`Failed to create session: ${status}`);
-  return parseBody(responseBody, isV2);
+  return parseBody(responseBody);
 }
 
-// Update a session's properties (e.g. title, agent, model).
-// model can be a string "providerID/modelID" or an object { providerID, modelID }.
+// Update a session's properties (title via PATCH, agent/model via dedicated
+// endpoints).
 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 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);
+    // v2 returns 204 No Content on success; the updated session comes from the
+    // GET below.
+    if (status !== 200 && status !== 204) throw new Error(`Failed to update session: ${status}`);
+    if (status === 200) session = parseBody(responseBody);
+  }
+  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}`);
   }
-
-  const bodyObj = {};
-  if (title != null) bodyObj.title = title;
-  if (agent != null) bodyObj.agent = agent;
   if (model != null) {
-    bodyObj.model = typeof model === 'string'
-      ? model
+    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}`);
   }
-  const url = `${server}/session/${encoded}`;
-  const body = JSON.stringify(bodyObj);
-  const { status, body: responseBody } = await makeRequest(buildJsonRequest(url, 'PATCH', body), body);
+  if (session) return session;
+  const { status, body: responseBody } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}`, 'GET'));
   if (status !== 200) throw new Error(`Failed to update session: ${status}`);
-  return JSON.parse(responseBody);
+  return parseBody(responseBody);
 }
 
-// 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 }) },
-    { url: `${server}/session/${encoded}/select`, body: '{}' },
-  ];
-  for (const { url, body } of attempts) {
-    try {
-      const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
-      // /session/:id/select returns 200 with HTML even for bad IDs (TUI page),
-      // but doesn't actually navigate. Only consider it a success if the
-      // response looks like JSON (i.e. not HTML).
-      if (status === 200) return;
-    } catch {
-      // try next approach
-    }
-  }
+// Tell the TUI to navigate to a specific session. v2 has no HTTP endpoint to
+// steer the TUI; the TUI keeps itself in sync, and ocmux relaunches the TUI on
+// the chosen session instead.
+async function selectSession() {
+  return;
 }
 
 // Get a single session by ID, including its message history.
-// 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}`,
-    `${server}/session/${encoded}/messages`,
-    `${server}/session/${encoded}/history`,
-    `${server}/session/${encoded}/conversation`,
-    `${server}/conversation/${encoded}`,
-  ];
+  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 = JSON.parse(body);
+          const parsed = parseBody(body);
           if (parsed != null) return parsed;
         } catch {}
       }
     } catch {}
   }
-  // Fallback: get all sessions and find the one we need
   const sessions = await listSessions(server);
   const match = sessions.find(s => String(s.id) === String(sessionId));
   if (match) return match;
@@ -593,32 +445,32 @@ async function getSession(server, sessionId) {
 
 // List all agents from the OpenCode server.
 async function listAgents(server) {
-  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 parseBody(body, isV2);
+  return parseBody(body);
 }
 
-// List all providers/models from the OpenCode server.
+// List all providers from the OpenCode server.
 async function listProviders(server) {
-  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 parseBody(body, isV2);
+  return parseBody(body);
 }
 
 // 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 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) || [];
   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) => {
+  const push = (providerID, id, name, variants, context) => {
     if (!providerID || !id) return;
     if (out.some(m => m.providerID === providerID && m.id === id)) return;
     out.push({
@@ -627,22 +479,10 @@ async function listModels(server) {
       label: `${providerID}/${id}`,
       name: name && String(name) !== String(id) ? String(name) : null,
       variants: toVariants(variants),
+      context: context || null,
     });
   };
-  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);
-  }
+  for (const m of data) push(m.providerID, m.id, m.name || m.label, m.variants, m.limit && m.limit.context);
   return out;
 }
 
@@ -712,290 +552,81 @@ function resolveModelRef(models, ref) {
   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).
+// Switch the session's model immediately (POST /api/session/:id/model).
 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}`);
+  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}`);
 }
 
-// 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) {
+// Send a message asynchronously (non-blocking enqueue). Optionally set an
+// agent/model first. v2's noReply has no equivalent; the prompt is queued.
+async function sendToSessionAsync(server, sessionId, text, agent, model) {
   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 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}`);
+  }
+  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}`);
   }
-  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 };
-  if (noReply) bodyObj.noReply = true;
-  const body = JSON.stringify(bodyObj);
-  const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
-  if (status !== 204) throw new Error(`Failed to send async message: ${status}`);
 }
 
-// Respond to a permission request.
+// Respond to a permission request (v2 decision enum: once | always | reject).
 async function respondToPermission(server, sessionId, permissionId, response, remember) {
   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);
-  const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
-  if (status !== 200) throw new Error(`Failed to respond to permission: ${status}`);
-}
-
-// Listen for session events via SSE, collecting assistant text parts and detecting
-// permission requests. Resolves with the full collected text when the session goes idle.
-// callbacks: { onText(chunk), onPermission(permission), onThinking(chunk), onConnected(), onQuestion(question) }
+  const base = await apiBase(server);
+  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}`);
+}
+
+// Listen for session events via the v2 SSE stream, collecting assistant text
+// parts and detecting permission requests. Resolves with the collected text.
+// callbacks: { onText, onPermission, onThinking, onConnected, onQuestion }
 // cancelRef — allows aborting the SSE stream via req.destroy()
-// logFn — optional logger; if provided, used instead of process.stderr.write
+// logFn — optional logger
 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));
+  return listenV2(server, sessionId, callbacks, cancelRef, logFn, null);
 }
 
-// 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}`);
-  });
-  sseLog(`  [SSE] connecting to ${server}/event for session ${sessionId}\n`);
-  return new Promise((resolve, reject) => {
-    const url = `${server}/event`;
-    const parsed = new URL(url);
-
-    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;
-      }
-      sseLog(`  [SSE] connected for session ${sessionId}\n`);
-      if (callbacks.onConnected) callbacks.onConnected();
-      let buffer = '';
-      const userMessageIDs = new Set();
-      let collected = '';
-      let resolved = false;
-
-      // Safety timeout: resolve with whatever we have after 90s
-      const safetyTimer = setTimeout(() => {
-        if (resolved) return;
-        resolved = true;
-        sseLog(`  [SSE] safety timeout (90s) for session ${sessionId}, collected ${collected.length} chars\n`);
-        cleanup();
-        req.destroy();
-        res.destroy();
-        resolve(collected);
-      }, 90000);
-
-      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;
-
-          try {
-            const event = JSON.parse(jsonStr);
-            const props = event.properties || {};
-
-            if (event.type === 'session.status') {
-              sseLog(`  [SSE] session.status: type=${props.status?.type} status=${JSON.stringify(props.status)}\n`);
-            } else {
-              sseLog(`  [SSE] event type=${event.type} sessionID=${props.sessionID} waitSession=${sessionId}\n`);
-            }
-
-            // Filter by sessionID when the event carries one (string-compare to handle type mismatches)
-            if (props.sessionID && String(props.sessionID) !== String(sessionId)) continue;
-
-            if (event.type === 'message.updated' && props.info?.role === 'user') {
-              userMessageIDs.add(props.info.id);
-              continue;
-            }
-
-            if (event.type === 'permission.asked') {
-              const permStr = JSON.stringify(props);
-              sseLog(`  [SSE] PERMISSION ASKED: ${permStr}\n`);
-              if (callbacks.onPermission) {
-                sseLog(`  [SSE] calling onPermission callback\n`);
-                callbacks.onPermission(props);
-              } else {
-                sseLog(`  [SSE] WARNING: no onPermission callback registered\n`);
-              }
-              continue;
-            }
-
-            if (event.type === 'permission.replied') {
-              sseLog(`  [SSE] PERMISSION REPLIED: type=${props.type}\n`);
-              if (callbacks.onPermissionReplied) {
-                callbacks.onPermissionReplied(props);
-              }
-              continue;
-            }
-
-            if (event.type === 'question.asked') {
-              const qStr = JSON.stringify(props);
-              sseLog(`  [SSE] QUESTION ASKED: ${qStr}\n`);
-              if (callbacks.onQuestion) {
-                sseLog(`  [SSE] calling onQuestion callback\n`);
-                callbacks.onQuestion(props);
-              } else {
-                sseLog(`  [SSE] WARNING: no onQuestion callback registered\n`);
-              }
-              continue;
-            }
-
-            // Completion signals
-            if (event.type === 'session.idle') {
-              clearTimeout(safetyTimer);
-              if (resolved) return;
-              resolved = true;
-              cleanup();
-              req.destroy();
-              res.destroy();
-              resolve(collected);
-              return;
-            }
-            if (event.type === 'session.status' && props.status?.type === 'idle') {
-              clearTimeout(safetyTimer);
-              if (resolved) return;
-              resolved = true;
-              cleanup();
-              req.destroy();
-              res.destroy();
-              resolve(collected);
-              return;
-            }
-
-            const part = props.part;
-            if (!part) continue;
-
-            // Skip echoed user input
-            if (part.messageID && userMessageIDs.has(part.messageID)) continue;
-
-            if (part.type === 'text' && part.text != null && part.text !== '') {
-              if (callbacks.onText) callbacks.onText(part.text);
-              collected += part.text;
-            }
-
-            if ((part.type === 'reasoning' || part.type === 'thinking') && part.text != null && part.text !== '') {
-              if (callbacks.onThinking) callbacks.onThinking(part.text);
-            }
-          } catch (e) {
-            // Malformed SSE event — skip
-          }
-        }
-      });
-
-      res.on('end', () => {
-        clearTimeout(safetyTimer);
-        if (resolved) return;
-        resolved = true;
-        cleanup();
-        resolve(collected);
-      });
-
-      res.on('error', (err) => {
-        clearTimeout(safetyTimer);
-        if (resolved) return;
-        resolved = true;
-        cleanup();
-        sseLog(`  [SSE] response stream error for session ${sessionId}: ${err.message}\n`);
-        resolve(collected);   // resolve with what we have
-      });
-    });
-
-    const cleanup = () => {
-      if (cancelRef) cancelRef.current = null;
-    };
-
-    req.on('error', (err) => {
-      cleanup();
-      reject(err);
-    });
-
-    if (cancelRef) cancelRef.current = req;
-    req.end();
-  });
-}
-
-// 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).
+// Check if an OpenCode server is reachable (any HTTP response = alive).
+// Returns a Promise resolving to true/false.
 function isServerAlive(url) {
-  return detectV2(url).then((isV2) => new Promise((resolve) => {
+  return new Promise((resolve) => {
     const base = String(url).replace(/\/+$/, '');
     const mod = base.startsWith('https') ? https : http;
-    const parsed = new URL(`${base}${isV2 ? '/api' : ''}/session`);
+    let parsed;
+    try {
+      parsed = new URL(`${base}/api/info`);
+    } catch {
+      resolve(false);
+      return;
+    }
     const opts = {
       hostname: parsed.hostname,
       port: parsed.port,
@@ -1010,37 +641,106 @@ function isServerAlive(url) {
     req.on('error', () => resolve(false));
     req.setTimeout(5000, () => { req.destroy(); resolve(false); });
     req.end();
-  })).catch(() => false);
+  }).catch(() => false);
 }
 
-// Respond to a question (choice) asked by the AI.
+// Respond to a question (choice) asked by the AI (v2 form reply).
 async function respondToQuestion(server, sessionId, questionId, answer) {
   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}`);
+}
+
+// Sort sessions most-recently-viewed first (`time.viewed`), tie-broken by
+// `time.updated`, then `time.created`. Used for target selection so agentp and
+// ocmux line up with what the TUI last showed.
+function sortSessionsByRecency(sessions) {
+  const score = (s) => {
+    const t = (s && s.time) || {};
+    return t.viewed || t.updated || t.created || 0;
+  };
+  return [...(sessions || [])].sort((a, b) => score(b) - score(a));
+}
+
+// Delete a session (DELETE /api/session/:id).
+async function deleteSession(server, sessionId) {
+  const encoded = encodeURIComponent(sessionId);
+  const base = await apiBase(server);
+  const { status } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}`, 'DELETE'));
+  if (status !== 200 && status !== 204) throw new Error(`Failed to delete session: ${status}`);
+}
+
+// Interrupt a session's active execution (like pressing ESC in the TUI).
+// Returns true when an execution was actually interrupted, false otherwise
+// (idle / already finished). Best-effort: never throws.
+async function interruptSession(server, sessionId) {
+  try {
+    const encoded = encodeURIComponent(sessionId);
     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 { status, body } = await makeRequest(buildJsonRequest(`${base}/session/${encoded}/interrupt`, 'POST'));
+    if (status !== 200) return false;
+    try {
+      const d = parseBody(body);
+      return !!(d && d.interrupted);
+    } catch {
+      return true;
+    }
+  } catch {
+    return false;
   }
-  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}`);
+}
+
+// The server's default model as { providerID, id, variant? }, or null.
+async function getDefaultModel(server) {
+  try {
+    const base = await apiBase(server);
+    const { status, body } = await makeRequest(buildJsonRequest(`${base}/model/default`, 'GET'), null, null, 5000);
+    if (status !== 200) return null;
+    const d = parseBody(body);
+    if (!d) return null;
+    const providerID = d.providerID;
+    const id = d.id || d.modelID;
+    if (!providerID || !id) return null;
+    return { providerID, id, variant: d.variant };
+  } catch {
+    return null;
+  }
+}
+
+// Create a session and ensure it has a model. v2 sessions created via the API
+// start with NO model and will not execute prompts until one is set (the prompt
+// just sits in the inbox → an empty answer). Prefer the model of a reference
+// session (e.g. the newest one in the project); fall back to the server default.
+async function createSessionWithModel(server, title, location, referenceSessions) {
+  const created = await createSession(server, title, location);
+  let model = null;
+  const ref = (referenceSessions || []).find(s => s && s.model && s.model.providerID && (s.model.id || s.model.modelID));
+  if (ref) {
+    model = {
+      providerID: ref.model.providerID,
+      id: ref.model.id || ref.model.modelID,
+      variant: ref.model.variant,
+    };
+  }
+  if (!model) model = await getDefaultModel(server);
+  if (model && model.providerID && model.id) {
+    await switchModel(server, created.id, model).catch(() => {});
+  }
+  return created;
 }
 
 module.exports = {
   getAuthHeaders,
   makeRequest,
   buildJsonRequest,
-  clearPrompt,
-  appendPrompt,
-  submitPrompt,
   sendText,
   listenForFinalAnswer,
   respondToQuestion,
   listSessions,
+  getActiveSessions,
   getSession,
   createSession,
   updateSession,
@@ -1060,6 +760,12 @@ module.exports = {
   apiBase,
   parseBody,
   listenV2,
+  sortSessionsByRecency,
+  deleteSession,
+  getDefaultModel,
+  createSessionWithModel,
+  interruptSession,
   _setApiVersion,
   _resetApiCache,
-};
+  _setCompletionGraceMs,
+};