agentp 0.7.0 → 0.9.0

package/lib/opencode.js

@@ -11,7 +11,7 @@ function getAuthHeaders() {
   return { 'Authorization': `Basic ${encoded}` };
 }
 
-function makeRequest(options, data) {
+function makeRequest(options, data, cancelRef) {
   return new Promise((resolve, reject) => {
     const req = http.request(options, (res) => {
       let body = '';
@@ -25,6 +25,7 @@ function makeRequest(options, data) {
       });
     });
     req.on('error', reject);
+    if (cancelRef) cancelRef.current = req;
     if (data) req.write(data);
     req.end();
   });
@@ -181,15 +182,16 @@ async function listSessions(server, directory) {
   return JSON.parse(body);
 }
 
-// Send a message directly to a specific session via the session API.
+// 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.
-async function sendToSession(server, sessionId, text, agent) {
+// 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 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);
+  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 || [])
@@ -209,9 +211,12 @@ async function createSession(server, title) {
 }
 
 // Update a session's properties (e.g. title).
-async function updateSession(server, sessionId, title) {
+async function updateSession(server, sessionId, title, agent) {
+  const bodyObj = {};
+  if (title != null) bodyObj.title = title;
+  if (agent != null) bodyObj.agent = agent;
   const url = `${server}/session/${encodeURIComponent(sessionId)}`;
-  const body = JSON.stringify({ title });
+  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}`);
   return JSON.parse(responseBody);
@@ -222,13 +227,16 @@ async function updateSession(server, sessionId, title) {
 async function selectSession(server, sessionId) {
   const encoded = encodeURIComponent(sessionId);
   const attempts = [
-    { url: `${server}/session/${encoded}/select`, body: '{}' },
     { url: `${server}/tui/select-session`, body: JSON.stringify({ sessionID: sessionId }) },
+    { url: `${server}/session/${encoded}/select`, body: '{}' },
   ];
   for (const { url, body } of attempts) {
     try {
-      await makeRequest(buildJsonRequest(url, 'POST', body), body);
-      return;
+      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
     }
@@ -273,7 +281,7 @@ async function respondToPermission(server, sessionId, permissionId, response, re
 
 // 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) }
+// callbacks: { onText(chunk), onPermission(permission), onThinking(chunk), onConnected() }
 // cancelRef — allows aborting the SSE stream via req.destroy()
 function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
   process.stderr.write(`  [SSE] connecting to ${server}/event for session ${sessionId}\n`);
@@ -294,9 +302,22 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
         return;
       }
       process.stderr.write(`  [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;
+        process.stderr.write(`  [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();
@@ -322,8 +343,8 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
               process.stderr.write(`  [SSE] event type=${event.type} sessionID=${props.sessionID} waitSession=${sessionId}\n`);
             }
 
-            // Filter by sessionID when the event carries one
-            if (props.sessionID && props.sessionID !== sessionId) continue;
+            // 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);
@@ -352,6 +373,9 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
 
             // Completion signals
             if (event.type === 'session.idle') {
+              clearTimeout(safetyTimer);
+              if (resolved) return;
+              resolved = true;
               cleanup();
               req.destroy();
               res.destroy();
@@ -359,6 +383,9 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
               return;
             }
             if (event.type === 'session.status' && props.status?.type === 'idle') {
+              clearTimeout(safetyTimer);
+              if (resolved) return;
+              resolved = true;
               cleanup();
               req.destroy();
               res.destroy();
@@ -376,6 +403,10 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
               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
           }
@@ -383,9 +414,21 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef) {
       });
 
       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();
+        process.stderr.write(`  [SSE] response stream error for session ${sessionId}: ${err.message}\n`);
+        resolve(collected);   // resolve with what we have
+      });
     });
 
     const cleanup = () => {

package/package.json

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