agentgui 1.0.382 → 1.0.384

package/acp-queries.js

@@ -144,8 +144,28 @@ export function createACPQueries(db, prep) {
       const ths = rows.map(r => ({ thread_id: r.id, created_at: iso(r.created_at), updated_at: iso(r.updated_at), metadata: jp(r.metadata), status: r.status || 'idle' }));
       return { threads: ths, total: tot, limit, offset, hasMore: offset + limit < tot };
     },
-    searchAgents(flt = {}) {
-      return [];
+    searchAgents(agents, flt = {}) {
+      const { name, version, capabilities, limit = 50, offset = 0 } = flt;
+      let results = agents;
+      if (name) {
+        const n = name.toLowerCase();
+        results = results.filter(a => a.name.toLowerCase().includes(n) || a.id.toLowerCase().includes(n));
+      }
+      if (capabilities) {
+        results = results.filter(a => {
+          const desc = this.getAgentDescriptor ? this.getAgentDescriptor(a.id) : null;
+          if (!desc) return false;
+          const caps = desc.specs?.capabilities || {};
+          if (capabilities.streaming !== undefined && !caps.streaming) return false;
+          if (capabilities.threads !== undefined && caps.threads !== capabilities.threads) return false;
+          if (capabilities.interrupts !== undefined && caps.interrupts !== capabilities.interrupts) return false;
+          return true;
+        });
+      }
+      const total = results.length;
+      const paginated = results.slice(offset, offset + limit);
+      const agents_list = paginated.map(a => ({ agent_id: a.id, name: a.name, version: version || '1.0.0', path: a.path }));
+      return { agents: agents_list, total, limit, offset, hasMore: offset + limit < total };
     },
     searchRuns(flt = {}) {
       const { agent_id, thread_id, status, limit = 50, offset = 0 } = flt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentgui",
-  "version": "1.0.382",
+  "version": "1.0.384",
   "description": "Multi-agent ACP client with real-time communication",
   "type": "module",
   "main": "server.js",

package/server.js

@@ -340,6 +340,8 @@ function discoverAgents() {
 
 const discoveredAgents = discoverAgents();
 initializeDescriptors(discoveredAgents);
+const acpQueries = createACPQueries(db, prepare);
+acpQueries.getAgentDescriptor = getAgentDescriptor;
 
 const modelCache = new Map();
 
@@ -1444,9 +1446,9 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    const runByIdMatch = pathOnly.match(/^\/api\/runs\/([^/]+)$/);
-    if (runByIdMatch) {
-      const runId = runByIdMatch[1];
+    const oldRunByIdMatch = pathOnly.match(/^\/api\/runs\/([^/]+)$/);
+    if (oldRunByIdMatch) {
+    const runId = oldRunByIdMatch[1];
       const session = queries.getSession(runId);
       
       if (!session) {
@@ -1511,9 +1513,9 @@ const server = http.createServer(async (req, res) => {
       }
     }
 
-    const runCancelMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
-    if (runCancelMatch && req.method === 'POST') {
-      const runId = runCancelMatch[1];
+    const oldRunCancelMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
+    if (oldRunCancelMatch && req.method === 'POST') {
+      const runId = oldRunCancelMatch[1];
       const session = queries.getSession(runId);
       
       if (!session) {
@@ -1767,34 +1769,10 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    const agentsSearchMatch = pathOnly.match(/^\/api\/agents\/search$/);
-    if (agentsSearchMatch && req.method === 'POST') {
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const { query } = parsed;
-      let results = discoveredAgents;
-
-      if (query) {
-        const q = query.toLowerCase();
-        results = discoveredAgents.filter(a => 
-          a.name.toLowerCase().includes(q) || 
-          a.id.toLowerCase().includes(q) ||
-          (a.description && a.description.toLowerCase().includes(q))
-        );
-      }
-
-      const agents = results.map(a => ({
-        id: a.id,
-        name: a.name,
-        description: a.description || '',
-        icon: a.icon || null,
-        status: 'available'
-      }));
-
-      sendJSON(req, res, 200, agents);
+    if (pathOnly === '/api/agents/search' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const result = acpQueries.searchAgents(discoveredAgents, body);
+      sendJSON(req, res, 200, result);
       return;
     }
 
@@ -1915,6 +1893,214 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    if (pathOnly === '/api/runs' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const { agent_id, input, config, webhook_url } = body;
+      if (!agent_id) {
+        sendJSON(req, res, 422, { error: 'agent_id is required' });
+        return;
+      }
+      const agent = discoveredAgents.find(a => a.id === agent_id);
+      if (!agent) {
+        sendJSON(req, res, 404, { error: 'Agent not found' });
+        return;
+      }
+      const run = acpQueries.createRun(agent_id, null, input, config, webhook_url);
+      sendJSON(req, res, 201, run);
+      return;
+    }
+
+    if (pathOnly === '/api/runs/search' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const result = acpQueries.searchRuns(body);
+      sendJSON(req, res, 200, result);
+      return;
+    }
+
+    if (pathOnly === '/api/runs/stream' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const { agent_id, input, config } = body;
+      if (!agent_id) {
+        sendJSON(req, res, 422, { error: 'agent_id is required' });
+        return;
+      }
+      const agent = discoveredAgents.find(a => a.id === agent_id);
+      if (!agent) {
+        sendJSON(req, res, 404, { error: 'Agent not found' });
+        return;
+      }
+      const run = acpQueries.createRun(agent_id, null, input, config);
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive'
+      });
+      res.write('data: ' + JSON.stringify({ type: 'run_created', run_id: run.run_id }) + '\n\n');
+      const eventHandler = (eventData) => {
+        if (eventData.sessionId === run.run_id || eventData.conversationId === run.thread_id) {
+          res.write('data: ' + JSON.stringify(eventData) + '\n\n');
+        }
+      };
+      const cleanup = () => {
+        res.end();
+      };
+      req.on('close', cleanup);
+      const statelessThreadId = acpQueries.getRun(run.run_id)?.thread_id;
+      if (statelessThreadId) {
+        const conv = queries.getConversation(statelessThreadId);
+        if (conv && input?.content) {
+          runClaudeWithStreaming(agent_id, statelessThreadId, input.content, config?.model || null).catch(() => {});
+        }
+      }
+      return;
+    }
+
+    if (pathOnly === '/api/runs/wait' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const { agent_id, input, config } = body;
+      if (!agent_id) {
+        sendJSON(req, res, 422, { error: 'agent_id is required' });
+        return;
+      }
+      const agent = discoveredAgents.find(a => a.id === agent_id);
+      if (!agent) {
+        sendJSON(req, res, 404, { error: 'Agent not found' });
+        return;
+      }
+      const run = acpQueries.createRun(agent_id, null, input, config);
+      const statelessThreadId = acpQueries.getRun(run.run_id)?.thread_id;
+      if (statelessThreadId && input?.content) {
+        try {
+          await runClaudeWithStreaming(agent_id, statelessThreadId, input.content, config?.model || null);
+          const finalRun = acpQueries.getRun(run.run_id);
+          sendJSON(req, res, 200, finalRun);
+        } catch (err) {
+          acpQueries.updateRunStatus(run.run_id, 'error');
+          sendJSON(req, res, 500, { error: err.message });
+        }
+      } else {
+        sendJSON(req, res, 200, run);
+      }
+      return;
+    }
+
+    const oldRunByIdMatch1 = pathOnly.match(/^\/api\/runs\/([^/]+)$/);
+    if (oldRunByIdMatch1) {
+      const runId = oldRunByIdMatch1[1];
+
+      if (req.method === 'GET') {
+        const run = acpQueries.getRun(runId);
+        if (!run) {
+          sendJSON(req, res, 404, { error: 'Run not found' });
+          return;
+        }
+        sendJSON(req, res, 200, run);
+        return;
+      }
+
+      if (req.method === 'POST') {
+        const body = await parseBody(req);
+        const run = acpQueries.getRun(runId);
+        if (!run) {
+          sendJSON(req, res, 404, { error: 'Run not found' });
+          return;
+        }
+        if (run.status !== 'pending') {
+          sendJSON(req, res, 409, { error: 'Run is not resumable' });
+          return;
+        }
+        if (body.input?.content && run.thread_id) {
+          runClaudeWithStreaming(run.agent_id, run.thread_id, body.input.content, null).catch(() => {});
+        }
+        sendJSON(req, res, 200, run);
+        return;
+      }
+
+      if (req.method === 'DELETE') {
+        try {
+          acpQueries.deleteRun(runId);
+          res.writeHead(204);
+          res.end();
+        } catch (err) {
+          sendJSON(req, res, 404, { error: 'Run not found' });
+        }
+        return;
+      }
+    }
+
+    const runWaitMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/wait$/);
+    if (runWaitMatch && req.method === 'GET') {
+      const runId = runWaitMatch[1];
+      const run = acpQueries.getRun(runId);
+      if (!run) {
+        sendJSON(req, res, 404, { error: 'Run not found' });
+        return;
+      }
+      const startTime = Date.now();
+      const pollInterval = setInterval(() => {
+        const currentRun = acpQueries.getRun(runId);
+        if (!currentRun || ['success', 'error', 'cancelled'].includes(currentRun.status) || (Date.now() - startTime) > 30000) {
+          clearInterval(pollInterval);
+          sendJSON(req, res, 200, currentRun || run);
+        }
+      }, 500);
+      req.on('close', () => clearInterval(pollInterval));
+      return;
+    }
+
+    const runStreamMatch = pathOnly.match(/^\/api\/runs\/([^/]+)\/stream$/);
+    if (runStreamMatch && req.method === 'GET') {
+      const runId = runStreamMatch[1];
+      const run = acpQueries.getRun(runId);
+      if (!run) {
+        sendJSON(req, res, 404, { error: 'Run not found' });
+        return;
+      }
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive'
+      });
+      res.write('data: ' + JSON.stringify({ type: 'joined', run_id: runId }) + '\n\n');
+      const eventHandler = (eventData) => {
+        if (eventData.sessionId === runId || eventData.conversationId === run.thread_id) {
+          res.write('data: ' + JSON.stringify(eventData) + '\n\n');
+        }
+      };
+      const cleanup = () => {
+        res.end();
+      };
+      req.on('close', cleanup);
+      return;
+    }
+
+    const oldRunCancelMatch1 = pathOnly.match(/^\/api\/runs\/([^/]+)\/cancel$/);
+    if (oldRunCancelMatch1 && req.method === 'POST') {
+      const runId = oldRunCancelMatch1[1];
+      try {
+        const run = acpQueries.cancelRun(runId);
+        const execution = activeExecutions.get(run.thread_id);
+        if (execution?.process) {
+          execution.process.kill('SIGTERM');
+          setTimeout(() => {
+            if (execution.process && !execution.process.killed) {
+              execution.process.kill('SIGKILL');
+            }
+          }, 5000);
+        }
+        sendJSON(req, res, 200, run);
+      } catch (err) {
+        if (err.message === 'Run not found') {
+          sendJSON(req, res, 404, { error: err.message });
+        } else if (err.message.includes('already completed')) {
+          sendJSON(req, res, 409, { error: err.message });
+        } else {
+          sendJSON(req, res, 500, { error: err.message });
+        }
+      }
+      return;
+    }
+
     if (pathOnly === '/api/gemini-oauth/start' && req.method === 'POST') {
       try {
         const result = await startGeminiOAuth(req);
@@ -2139,336 +2325,6 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
-    const threadsMatch = pathOnly.match(/^\/api\/threads$/);
-    if (threadsMatch && req.method === 'POST') {
-      let body = '';
-      for await (const chunk of req) { body += chunk; }
-      let parsed = {};
-      try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-      const thread = queries.createConversation(parsed.agentId || 'claude-code', parsed.title || 'New Thread', parsed.workingDirectory || STARTUP_CWD);
-      sendJSON(req, res, 200, { 
-        id: thread.id, 
-        agentId: thread.agentId, 
-        title: thread.title,
-        created_at: thread.created_at,
-        status: thread.status,
-        state: null
-      });
-      return;
-    }
-
-    const threadsSearchMatch = pathOnly.match(/^\/api\/threads\/search$/);
-    if (threadsSearchMatch && req.method === 'POST') {
-      const conversations = queries.getConversations();
-      const threads = conversations.map(c => ({
-        id: c.id,
-        agentId: c.agentId,
-        title: c.title,
-        created_at: c.created_at,
-        updated_at: c.updated_at,
-        status: c.status,
-        state: null
-      }));
-      sendJSON(req, res, 200, threads);
-      return;
-    }
-
-    const threadByIdMatch = pathOnly.match(/^\/api\/threads\/([^/]+)$/);
-    if (threadByIdMatch) {
-      const threadId = threadByIdMatch[1];
-      const conv = queries.getConversation(threadId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      if (req.method === 'GET') {
-        sendJSON(req, res, 200, {
-          id: conv.id,
-          agentId: conv.agentId,
-          title: conv.title,
-          created_at: conv.created_at,
-          updated_at: conv.updated_at,
-          status: conv.status,
-          state: null
-        });
-        return;
-      }
-
-      if (req.method === 'DELETE') {
-        const activeEntry = activeExecutions.get(threadId);
-        if (activeEntry) {
-          sendJSON(req, res, 409, { error: 'Thread has an active run, cannot delete' });
-          return;
-        }
-        queries.deleteConversation(threadId);
-        sendJSON(req, res, 204, {});
-        return;
-      }
-
-      if (req.method === 'PATCH') {
-        let body = '';
-        for await (const chunk of req) { body += chunk; }
-        let parsed = {};
-        try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-        const updates = {};
-        if (parsed.title !== undefined) updates.title = parsed.title;
-        if (parsed.state !== undefined) updates.state = parsed.state;
-        
-        if (Object.keys(updates).length > 0) {
-          queries.updateConversation(threadId, updates);
-        }
-        
-        const updated = queries.getConversation(threadId);
-        sendJSON(req, res, 200, {
-          id: updated.id,
-          agentId: updated.agentId,
-          title: updated.title,
-          created_at: updated.created_at,
-          updated_at: updated.updated_at,
-          status: updated.status,
-          state: updated.state
-        });
-        return;
-      }
-    }
-
-    const threadHistoryMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/history$/);
-    if (threadHistoryMatch && req.method === 'GET') {
-      const threadId = threadHistoryMatch[1];
-      const conv = queries.getConversation(threadId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      const limit = parseInt(new URL(req.url, 'http://localhost').searchParams.get('limit') || '10', 10);
-      const sessions = queries.getSessionsByConversation(threadId, limit);
-      
-      const history = sessions.map(s => ({
-        checkpoint: s.id,
-        state: null,
-        created_at: s.started_at,
-        runId: s.id,
-        status: s.status
-      })).reverse();
-
-      sendJSON(req, res, 200, history);
-      return;
-    }
-
-    const threadCopyMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/copy$/);
-    if (threadCopyMatch && req.method === 'POST') {
-      const threadId = threadCopyMatch[1];
-      const original = queries.getConversation(threadId);
-      
-      if (!original) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      const newThread = queries.createConversation(original.agentId, original.title + ' (copy)', original.workingDirectory);
-
-      const messages = queries.getMessages(threadId, 1000, 0);
-      for (const msg of messages) {
-        queries.createMessage(newThread.id, msg.role, msg.content);
-      }
-
-      sendJSON(req, res, 200, {
-        id: newThread.id,
-        agentId: newThread.agentId,
-        title: newThread.title,
-        created_at: newThread.created_at,
-        status: newThread.status,
-        state: null
-      });
-      return;
-    }
-
-    const threadRunsMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs$/);
-    if (threadRunsMatch) {
-      const threadId = threadRunsMatch[1];
-      const conv = queries.getConversation(threadId);
-      
-      if (!conv) {
-        sendJSON(req, res, 404, { error: 'Thread not found' });
-        return;
-      }
-
-      if (req.method === 'GET') {
-        const limit = parseInt(new URL(req.url, 'http://localhost').searchParams.get('limit') || '10', 10);
-        const offset = parseInt(new URL(req.url, 'http://localhost').searchParams.get('offset') || '0', 10);
-        const sessions = queries.getSessionsByConversation(threadId, limit, offset);
-        
-        const runs = sessions.map(s => ({
-          id: s.id,
-          threadId: s.conversationId,
-          status: s.status,
-          started_at: s.started_at,
-          completed_at: s.completed_at,
-          agentId: s.agentId,
-          input: null,
-          output: null
-        }));
-
-        sendJSON(req, res, 200, runs);
-        return;
-      }
-
-      if (req.method === 'POST') {
-        const activeEntry = activeExecutions.get(threadId);
-        if (activeEntry) {
-          sendJSON(req, res, 409, { error: 'Thread already has an active run' });
-          return;
-        }
-
-        let body = '';
-        for await (const chunk of req) { body += chunk; }
-        let parsed = {};
-        try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-        const { input, agentId, webhook } = parsed;
-        if (!input) {
-          sendJSON(req, res, 400, { error: 'Missing input in request body' });
-          return;
-        }
-
-        const resolvedAgentId = agentId || conv.agentId || 'claude-code';
-        const resolvedModel = parsed.model || conv.model || null;
-        const cwd = conv.workingDirectory || STARTUP_CWD;
-
-        const session = queries.createSession(threadId, resolvedAgentId, 'pending');
-        const message = queries.createMessage(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-        processMessageWithStreaming(threadId, message.id, session.id, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-
-        sendJSON(req, res, 200, {
-          id: session.id,
-          threadId: threadId,
-          status: 'pending',
-          started_at: session.started_at,
-          agentId: resolvedAgentId
-        });
-        return;
-      }
-    }
-
-    const threadRunByIdMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)$/);
-    if (threadRunByIdMatch) {
-      const threadId = threadRunByIdMatch[1];
-      const runId = threadRunByIdMatch[2];
-      const session = queries.getSession(runId);
-      
-      if (!session || session.conversationId !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      if (req.method === 'GET') {
-        sendJSON(req, res, 200, {
-          id: session.id,
-          threadId: session.conversationId,
-          status: session.status,
-          started_at: session.started_at,
-          completed_at: session.completed_at,
-          agentId: session.agentId,
-          input: null,
-          output: null
-        });
-        return;
-      }
-
-      if (req.method === 'DELETE') {
-        queries.deleteSession(runId);
-        sendJSON(req, res, 204, {});
-        return;
-      }
-
-      if (req.method === 'POST') {
-        if (session.status !== 'interrupted') {
-          sendJSON(req, res, 409, { error: 'Can only resume interrupted runs' });
-          return;
-        }
-
-        let body = '';
-        for await (const chunk of req) { body += chunk; }
-        let parsed = {};
-        try { parsed = body ? JSON.parse(body) : {}; } catch {}
-
-        const { input } = parsed;
-        if (!input) {
-          sendJSON(req, res, 400, { error: 'Missing input in request body' });
-          return;
-        }
-
-        const conv = queries.getConversation(threadId);
-        const resolvedAgentId = session.agentId || conv.agentId || 'claude-code';
-        const resolvedModel = conv?.model || null;
-        const cwd = conv?.workingDirectory || STARTUP_CWD;
-
-        queries.updateSession(runId, { status: 'pending' });
-        
-        const message = queries.createMessage(threadId, 'user', typeof input === 'string' ? input : JSON.stringify(input));
-
-        processMessageWithStreaming(threadId, message.id, runId, typeof input === 'string' ? input : JSON.stringify(input), resolvedAgentId, resolvedModel);
-
-        sendJSON(req, res, 200, {
-          id: session.id,
-          threadId: threadId,
-          status: 'pending',
-          started_at: session.started_at,
-          agentId: resolvedAgentId
-        });
-        return;
-      }
-    }
-
-    const threadRunCancelMatch = pathOnly.match(/^\/api\/threads\/([^/]+)\/runs\/([^/]+)\/cancel$/);
-    if (threadRunCancelMatch && req.method === 'POST') {
-      const threadId = threadRunCancelMatch[1];
-      const runId = threadRunCancelMatch[2];
-      const session = queries.getSession(runId);
-      
-      if (!session || session.conversationId !== threadId) {
-        sendJSON(req, res, 404, { error: 'Run not found' });
-        return;
-      }
-
-      const entry = activeExecutions.get(threadId);
-      
-      if (entry && entry.sessionId === runId) {
-        const { pid } = entry;
-        if (pid) {
-          try {
-            process.kill(-pid, 'SIGKILL');
-          } catch {
-            try {
-              process.kill(pid, 'SIGKILL');
-            } catch (e) {}
-          }
-        }
-      }
-
-      queries.updateSession(runId, { status: 'interrupted', completed_at: Date.now() });
-      queries.setIsStreaming(threadId, false);
-      activeExecutions.delete(threadId);
-
-      broadcastSync({
-        type: 'streaming_complete',
-        sessionId: runId,
-        conversationId: threadId,
-        interrupted: true,
-        timestamp: Date.now()
-      });
-
-      sendJSON(req, res, 204, {});
-      return;
-    }
-
     if (pathOnly === '/api/stt' && req.method === 'POST') {
       try {
         const chunks = [];
@@ -2734,7 +2590,7 @@ const server = http.createServer(async (req, res) => {
     if (pathOnly === '/api/git/push' && req.method === 'POST') {
       try {
         const isWindows = os.platform() === 'win32';
-        const gitCommand = isWindows 
+        const gitCommand = isWindows
           ? 'git add -A & git commit -m "Auto-commit" & git push'
           : 'git add -A && git commit -m "Auto-commit" && git push';
         execSync(gitCommand, { encoding: 'utf-8', cwd: STARTUP_CWD, shell: isWindows });
@@ -2745,6 +2601,148 @@ const server = http.createServer(async (req, res) => {
       return;
     }
 
+    // ============================================================
+    // THREAD API ENDPOINTS (ACP v0.2.3)
+    // ============================================================
+
+    // POST /threads - Create empty thread
+    if (pathOnly === '/api/threads' && req.method === 'POST') {
+      try {
+        const body = await parseBody(req);
+        const metadata = body.metadata || {};
+        const thread = queries.createThread(metadata);
+        sendJSON(req, res, 201, thread);
+      } catch (err) {
+        sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
+      }
+      return;
+    }
+
+    // POST /threads/search - Search threads
+    if (pathOnly === '/api/threads/search' && req.method === 'POST') {
+      try {
+        const body = await parseBody(req);
+        const result = queries.searchThreads(body);
+        sendJSON(req, res, 200, result);
+      } catch (err) {
+        sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
+      }
+      return;
+    }
+
+    // GET /threads/{thread_id} - Get thread by ID
+    const acpThreadMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})$/);
+    if (acpThreadMatch && req.method === 'GET') {
+      const threadId = threadByIdMatch[1];
+      try {
+        const thread = queries.getThread(threadId);
+        if (!thread) {
+          sendJSON(req, res, 404, { error: 'Thread not found', type: 'not_found' });
+        } else {
+          sendJSON(req, res, 200, thread);
+        }
+      } catch (err) {
+        sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
+      }
+      return;
+    }
+
+    // PATCH /threads/{thread_id} - Update thread metadata
+    if (acpThreadMatch && req.method === 'PATCH') {
+      const threadId = threadByIdMatch[1];
+      try {
+        const body = await parseBody(req);
+        const thread = queries.patchThread(threadId, body);
+        sendJSON(req, res, 200, thread);
+      } catch (err) {
+        if (err.message.includes('not found')) {
+          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
+        } else {
+          sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
+        }
+      }
+      return;
+    }
+
+    // DELETE /threads/{thread_id} - Delete thread (fail if pending runs exist)
+    if (acpThreadMatch && req.method === 'DELETE') {
+      const threadId = threadByIdMatch[1];
+      try {
+        queries.deleteThread(threadId);
+        res.writeHead(204);
+        res.end();
+      } catch (err) {
+        if (err.message.includes('not found')) {
+          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
+        } else if (err.message.includes('pending runs')) {
+          sendJSON(req, res, 409, { error: err.message, type: 'conflict' });
+        } else {
+          sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
+        }
+      }
+      return;
+    }
+
+    // GET /threads/{thread_id}/history - Get thread state history with pagination
+    const threadHistoryMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/history$/);
+    if (threadHistoryMatch && req.method === 'GET') {
+      const threadId = threadHistoryMatch[1];
+      try {
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const limit = parseInt(url.searchParams.get('limit') || '50', 10);
+        const before = url.searchParams.get('before') || null;
+
+        // Convert 'before' cursor to offset if needed
+        let offset = 0;
+        if (before) {
+          // Simple cursor-based pagination: before is an offset value
+          offset = parseInt(before, 10);
+        }
+
+        const result = queries.getThreadHistory(threadId, limit, offset);
+
+        // Generate next_cursor if there are more results
+        const response = {
+          states: result.states,
+          next_cursor: result.hasMore ? String(offset + limit) : null
+        };
+
+        sendJSON(req, res, 200, response);
+      } catch (err) {
+        if (err.message.includes('not found')) {
+          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
+        } else {
+          sendJSON(req, res, 422, { error: err.message, type: 'validation_error' });
+        }
+      }
+      return;
+    }
+
+    // POST /threads/{thread_id}/copy - Copy thread with all states/checkpoints
+    const threadCopyMatch = pathOnly.match(/^\/api\/threads\/([a-f0-9-]{36})\/copy$/);
+    if (threadCopyMatch && req.method === 'POST') {
+      const sourceThreadId = threadCopyMatch[1];
+      try {
+        const body = await parseBody(req);
+        const newThread = queries.copyThread(sourceThreadId);
+
+        // Update metadata if provided
+        if (body.metadata) {
+          const updated = queries.patchThread(newThread.thread_id, { metadata: body.metadata });
+          sendJSON(req, res, 201, updated);
+        } else {
+          sendJSON(req, res, 201, newThread);
+        }
+      } catch (err) {
+        if (err.message.includes('not found')) {
+          sendJSON(req, res, 404, { error: err.message, type: 'not_found' });
+        } else {
+          sendJSON(req, res, 500, { error: err.message, type: 'internal_error' });
+        }
+      }
+      return;
+    }
+
     if (routePath.startsWith('/api/image/')) {
       const imagePath = routePath.slice('/api/image/'.length);
       const decodedPath = decodeURIComponent(imagePath);