agentp 1.12.1 → 1.14.0

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.12.1",
+  "version": "1.14.0",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",