agentgui 1.0.1119 → 1.0.1120

package/lib/acp-http-protocol.js

@@ -14,7 +14,11 @@
 
 function normalizePart(part, sessionId) {
   if (!part || typeof part !== 'object') return null;
-  if (part.type === 'text' && typeof part.text === 'string') {
+  // A text part streams in incrementally - the first frame for it can arrive
+  // with an empty string before content lands (live-observed). An empty
+  // chunk carries nothing a caller can render; drop it rather than emitting
+  // a blank assistant bubble.
+  if (part.type === 'text' && typeof part.text === 'string' && part.text.length > 0) {
     return { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: part.text }] }, session_id: sessionId };
   }
   if (part.type === 'tool' || part.type === 'tool-invocation') {

package/lib/acp-sdk-manager.js

@@ -17,9 +17,15 @@ const isWindows = os.platform() === 'win32';
 // ACP_TOOLS rather than spawning a command that can never succeed. Re-add it
 // once a WebSocket app-server client exists (see PRD row
 // aaa-codex-app-server-client).
+// `args` MUST pass --port explicitly - `acp` alone defaults --port to 0 (an
+// OS-assigned ephemeral port), so the spawned server never actually listens
+// on `tool.port` and every health-check/getPort() call targets the wrong
+// port forever (live-confirmed: opencode process alive, listening on SOME
+// port, but 127.0.0.1:18100/provider connection-refused). Fixed by pinning
+// --port to the same value this manager already tracks per tool.
 const ACP_TOOLS = [
-  { id: 'opencode', cmd: 'opencode', args: ['acp'], port: 18100, npxPkg: 'opencode-ai' },
-  { id: 'kilo', cmd: 'kilo', args: ['acp'], port: 18101, npxPkg: '@kilocode/cli' },
+  { id: 'opencode', cmd: 'opencode', args: ['acp', '--port', '18100'], port: 18100, npxPkg: 'opencode-ai' },
+  { id: 'kilo', cmd: 'kilo', args: ['acp', '--port', '18101'], port: 18101, npxPkg: '@kilocode/cli' },
 ];
 const HEALTH_INTERVAL_MS = 30000, STARTUP_GRACE_MS = 5000, IDLE_TIMEOUT_MS = 120000;
 const processes = new Map(), idleTimers = new Map();
@@ -120,7 +126,14 @@ function scheduleRestart(tool) {
   }, delay);
 }
 
-async function checkHealth(toolId, port) {
+// A single check at STARTUP_GRACE_MS can race a genuinely-still-starting
+// server (opencode's HTTP endpoint was live-observed taking ~8s to come up,
+// past the 5s grace) and mark it UNHEALTHY with no second chance before the
+// next scheduled HEALTH_INTERVAL_MS tick (30s) - starving any caller polling
+// isHealthy() over a shorter window (ensureRunning's own 10s loop). Retry a
+// few times with backoff before sending UNHEALTHY, so a slow-but-genuinely-
+// starting server gets caught instead of permanently mis-marked for 30s.
+async function checkHealth(toolId, port, _retries = 3) {
   if (shuttingDown) return;
   const snap = acpMachine.snapshot(toolId);
   if (!snap || snap.value === 'stopped' || snap.value === 'idle_stopping') return;
@@ -128,9 +141,13 @@ async function checkHealth(toolId, port) {
   if (!p) return;
   try {
     const res = await fetch('http://127.0.0.1:' + p + '/provider', { signal: AbortSignal.timeout(3000) });
-    if (res.ok) acpMachine.send(toolId, { type: 'HEALTHY', providerInfo: await res.json() });
-    else acpMachine.send(toolId, { type: 'UNHEALTHY' });
-  } catch (_) { acpMachine.send(toolId, { type: 'UNHEALTHY' }); }
+    if (res.ok) { acpMachine.send(toolId, { type: 'HEALTHY', providerInfo: await res.json() }); return; }
+    if (_retries > 0) { setTimeout(() => checkHealth(toolId, p, _retries - 1), 1500); return; }
+    acpMachine.send(toolId, { type: 'UNHEALTHY' });
+  } catch (_) {
+    if (_retries > 0) { setTimeout(() => checkHealth(toolId, p, _retries - 1), 1500); return; }
+    acpMachine.send(toolId, { type: 'UNHEALTHY' });
+  }
 }
 
 export async function ensureRunning(agentId) {
@@ -141,7 +158,10 @@ export async function ensureRunning(agentId) {
   if (!snap || snap.value === 'stopped' || snap.value === 'crashed') {
     startProcess(tool);
   }
-  for (let i = 0; i < 20; i++) {
+  // 30 x 500ms = 15s - wide enough to cover STARTUP_GRACE_MS (5s) plus
+  // checkHealth's own retry backoff (up to ~4.5s more) with real margin, per
+  // opencode's live-observed ~8s cold-start time for its HTTP endpoint.
+  for (let i = 0; i < 30; i++) {
     await new Promise(r => setTimeout(r, 500));
     if (shuttingDown) return null;
     if (acpMachine.isHealthy(agentId)) { resetIdleTimer(agentId); return tool.port; }

package/lib/claude-runner-acp.js

@@ -1,5 +1,7 @@
 import { spawn } from 'child_process';
 import { AgentRunner, getSpawnOptions, resolveCommand } from './claude-runner.js';
+import { ensureRunning as ensureAcpHttpRunning } from './acp-sdk-manager.js';
+import { createACPHttpProtocolHandler, parseSSEChunk } from './acp-http-protocol.js';
 
 function buildEnhancedHandler({ proc, outputs, sessionRef, promptIdRef, completedRef, drainingRef, requestIdRef, originalHandler, resolve, reject, clearTimeoutHandle, promptText }) {
   return function(message) {
@@ -26,8 +28,64 @@ function buildEnhancedHandler({ proc, outputs, sessionRef, promptIdRef, complete
   };
 }
 
+// opencode/kilo (registry entries with transport:'http') are live-verified
+// (lib/acp-http-protocol.js) to serve their normal REST+SSE API under `acp
+// --port`, already spawned as a long-lived server by acp-sdk-manager.js for
+// health/model discovery. This path reuses that same running server for the
+// actual prompt instead of spawning a fresh stdio subprocess per turn -
+// consolidating the two ACP process managers for these two agents only. The
+// other stdio-based ACP agents (gemini, goose, openhands, etc) are untouched.
+AgentRunner.prototype._runACPHttp = async function(prompt, cwd, config = {}) {
+  const { timeout = 300000, onEvent = null } = config;
+  const port = await ensureAcpHttpRunning(this.id);
+  if (!port) { const e = new Error(`${this.name} ACP HTTP server not reachable`); e.isPrematureEnd = true; throw e; }
+  const base = `http://127.0.0.1:${port}`;
+  const sessionRes = await fetch(`${base}/session`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({}), signal: AbortSignal.timeout(10000) });
+  if (!sessionRes.ok) throw new Error(`${this.name} ACP HTTP session create failed: ${sessionRes.status}`);
+  const session = await sessionRes.json();
+  const sessionId = session.id || session.sessionID;
+  if (!sessionId) throw new Error(`${this.name} ACP HTTP session response missing id`);
+
+  const handler = createACPHttpProtocolHandler();
+  const outputs = [];
+  const evController = new AbortController();
+  const timeoutHandle = setTimeout(() => evController.abort(), timeout);
+
+  const evPromise = fetch(`${base}/global/event`, { signal: evController.signal }).then(async (res) => {
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const frames = parseSSEChunk(buffer);
+      buffer = '';
+      for (const frame of frames) {
+        const normalized = handler(frame, { sessionId });
+        if (!normalized) continue;
+        outputs.push(normalized);
+        if (onEvent) { try { onEvent(normalized); } catch (e) { console.error(`[${this.id}] onEvent error: ${e.message}`); } }
+        if (normalized.type === 'result') { clearTimeout(timeoutHandle); return; }
+      }
+    }
+  }).catch(() => {});
+
+  const messageRes = await fetch(`${base}/session/${sessionId}/message`, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ parts: [{ type: 'text', text: prompt }] }),
+    signal: AbortSignal.timeout(timeout),
+  });
+  if (!messageRes.ok) { evController.abort(); throw new Error(`${this.name} ACP HTTP message failed: ${messageRes.status}`); }
+
+  await evPromise;
+  evController.abort();
+  return { outputs, sessionId };
+};
+
 AgentRunner.prototype.runACP = async function(prompt, cwd, config = {}, _retryCount = 0) {
   const maxRetries = config.maxRetries ?? 1;
+  if (this.transport === 'http') return this._runACPHttp(prompt, cwd, config);
   try {
     return await this._runACPOnce(prompt, cwd, config);
   } catch (err) {

package/lib/ws-handlers/agents.js

@@ -60,6 +60,30 @@ export function register(router, deps) {
     return { ok: !!ok };
   });
 
+  // TEMPORARY diagnostic route (aaa-consolidate-acp-http-routing): exercises
+  // AgentRunner.runACP's new transport:'http' branch through the server's own
+  // long-lived process (a one-shot exec_js dispatch's process dies with the
+  // dispatch, killing acp-sdk-manager's non-detached child opencode with it -
+  // this route proves the real production caller shape instead). Remove once
+  // the side-by-side stdio-vs-http witness passes and this row resolves.
+  router.handle('_diag.runAcpHttp', async (p) => {
+    const agent = registry.get(p?.id || 'opencode');
+    if (!agent) err(404, 'unknown agent');
+    const prevTransport = agent.transport;
+    agent.transport = p?.transport === 'stdio' ? undefined : 'http';
+    const events = [];
+    try {
+      const result = await agent.runACP(p?.prompt || 'reply with exactly the word PONG', process.cwd(), {
+        timeout: 40000, onEvent: (e) => events.push(e),
+      });
+      return { ok: true, result, events };
+    } catch (e) {
+      return { ok: false, error: e.message, events };
+    } finally {
+      agent.transport = prevTransport;
+    }
+  });
+
   router.handle('agent.subagents', async (p) => {
     if (!p.id) err(400, 'Missing agent id');
     if (p.id === 'claude-code' || p.id === 'cli-claude') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.1119",
+  "version": "1.0.1120",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "electron/main.js",