agentgui 1.0.380 → 1.0.382

package/acp-queries.js

@@ -0,0 +1,162 @@
+import { randomUUID } from 'crypto';
+const gid = (p) => `${p}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+const uuid = () => randomUUID();
+const iso = (t) => new Date(t).toISOString();
+const j = (o) => JSON.stringify(o);
+const jp = (s) => { try { return JSON.parse(s); } catch { return {}; } };
+
+export function createACPQueries(db, prep) {
+  return {
+    createThread(metadata = {}) {
+      const id = uuid(), now = Date.now();
+      prep('INSERT INTO conversations (id, agentId, title, created_at, updated_at, status, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)').run(id, 'unknown', null, now, now, 'idle', j(metadata));
+      return { thread_id: id, created_at: iso(now), updated_at: iso(now), metadata, status: 'idle' };
+    },
+    getThread(tid) {
+      const r = prep('SELECT * FROM conversations WHERE id = ?').get(tid);
+      if (!r) return null;
+      return { thread_id: r.id, created_at: iso(r.created_at), updated_at: iso(r.updated_at), metadata: jp(r.metadata), status: r.status || 'idle' };
+    },
+    patchThread(tid, upd) {
+      const t = this.getThread(tid);
+      if (!t) throw new Error('Thread not found');
+      const now = Date.now(), meta = upd.metadata !== undefined ? upd.metadata : t.metadata, stat = upd.status !== undefined ? upd.status : t.status;
+      prep('UPDATE conversations SET metadata = ?, status = ?, updated_at = ? WHERE id = ?').run(j(meta), stat, now, tid);
+      return { thread_id: tid, created_at: t.created_at, updated_at: iso(now), metadata: meta, status: stat };
+    },
+    deleteThread(tid) {
+      const pr = prep('SELECT COUNT(*) as count FROM run_metadata WHERE thread_id = ? AND status = ?').get(tid, 'pending');
+      if (pr && pr.count > 0) throw new Error('Cannot delete thread with pending runs');
+      db.transaction(() => {
+        prep('DELETE FROM thread_states WHERE thread_id = ?').run(tid);
+        prep('DELETE FROM checkpoints WHERE thread_id = ?').run(tid);
+        prep('DELETE FROM run_metadata WHERE thread_id = ?').run(tid);
+        prep('DELETE FROM sessions WHERE conversationId = ?').run(tid);
+        prep('DELETE FROM messages WHERE conversationId = ?').run(tid);
+        prep('DELETE FROM chunks WHERE conversationId = ?').run(tid);
+        prep('DELETE FROM events WHERE conversationId = ?').run(tid);
+        prep('DELETE FROM conversations WHERE id = ?').run(tid);
+      })();
+      return true;
+    },
+    saveThreadState(tid, cid, sd) {
+      const id = gid('state'), now = Date.now();
+      prep('INSERT INTO thread_states (id, thread_id, checkpoint_id, state_data, created_at) VALUES (?, ?, ?, ?, ?)').run(id, tid, cid, j(sd), now);
+      return { id, thread_id: tid, checkpoint_id: cid, created_at: iso(now) };
+    },
+    getThreadState(tid, cid = null) {
+      const r = cid ? prep('SELECT * FROM thread_states WHERE thread_id = ? AND checkpoint_id = ? ORDER BY created_at DESC LIMIT 1').get(tid, cid) : prep('SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at DESC LIMIT 1').get(tid);
+      if (!r) return null;
+      const sd = jp(r.state_data);
+      return { checkpoint: { checkpoint_id: r.checkpoint_id }, values: sd.values || {}, messages: sd.messages || [], metadata: sd.metadata || {} };
+    },
+    getThreadHistory(tid, lim = 50, off = 0) {
+      const tot = prep('SELECT COUNT(*) as count FROM thread_states WHERE thread_id = ?').get(tid).count;
+      const rows = prep('SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?').all(tid, lim, off);
+      const states = rows.map(r => { const sd = jp(r.state_data); return { checkpoint: { checkpoint_id: r.checkpoint_id }, values: sd.values || {}, messages: sd.messages || [], metadata: sd.metadata || {} }; });
+      return { states, total: tot, limit: lim, offset: off, hasMore: off + lim < tot };
+    },
+    copyThread(stid) {
+      const st = this.getThread(stid);
+      if (!st) throw new Error('Source thread not found');
+      const ntid = uuid(), now = Date.now();
+      db.transaction(() => {
+        prep('INSERT INTO conversations (id, agentId, title, created_at, updated_at, status, metadata, workingDirectory) SELECT ?, agentId, title || \' (copy)\', ?, ?, status, metadata, workingDirectory FROM conversations WHERE id = ?').run(ntid, now, now, stid);
+        const cps = prep('SELECT * FROM checkpoints WHERE thread_id = ? ORDER BY sequence ASC').all(stid);
+        cps.forEach(cp => prep('INSERT INTO checkpoints (id, thread_id, checkpoint_name, sequence, created_at) VALUES (?, ?, ?, ?, ?)').run(uuid(), ntid, cp.checkpoint_name, cp.sequence, now));
+        const sts = prep('SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at ASC').all(stid);
+        sts.forEach(s => prep('INSERT INTO thread_states (id, thread_id, checkpoint_id, state_data, created_at) VALUES (?, ?, ?, ?, ?)').run(gid('state'), ntid, s.checkpoint_id, s.state_data, now));
+        const msgs = prep('SELECT * FROM messages WHERE conversationId = ? ORDER BY created_at ASC').all(stid);
+        msgs.forEach(m => prep('INSERT INTO messages (id, conversationId, role, content, created_at) VALUES (?, ?, ?, ?, ?)').run(gid('msg'), ntid, m.role, m.content, now));
+      })();
+      return this.getThread(ntid);
+    },
+    createCheckpoint(tid, name = null) {
+      const id = uuid(), now = Date.now();
+      const ms = prep('SELECT MAX(sequence) as max FROM checkpoints WHERE thread_id = ?').get(tid);
+      const seq = (ms?.max ?? -1) + 1;
+      prep('INSERT INTO checkpoints (id, thread_id, checkpoint_name, sequence, created_at) VALUES (?, ?, ?, ?, ?)').run(id, tid, name, seq, now);
+      return { checkpoint_id: id, thread_id: tid, checkpoint_name: name, sequence: seq, created_at: iso(now) };
+    },
+    getCheckpoint(cid) {
+      const r = prep('SELECT * FROM checkpoints WHERE id = ?').get(cid);
+      if (!r) return null;
+      return { checkpoint_id: r.id, thread_id: r.thread_id, checkpoint_name: r.checkpoint_name, sequence: r.sequence, created_at: iso(r.created_at) };
+    },
+    listCheckpoints(tid, lim = 50, off = 0) {
+      const tot = prep('SELECT COUNT(*) as count FROM checkpoints WHERE thread_id = ?').get(tid).count;
+      const rows = prep('SELECT * FROM checkpoints WHERE thread_id = ? ORDER BY sequence DESC LIMIT ? OFFSET ?').all(tid, lim, off);
+      const cps = rows.map(r => ({ checkpoint_id: r.id, thread_id: r.thread_id, checkpoint_name: r.checkpoint_name, sequence: r.sequence, created_at: iso(r.created_at) }));
+      return { checkpoints: cps, total: tot, limit: lim, offset: off, hasMore: off + lim < tot };
+    },
+    createRun(aid, tid = null, inp = null, cfg = null, wh = null) {
+      const rid = uuid(), now = Date.now(), mid = gid('runmeta');
+      let atid = tid;
+      if (!tid) {
+        atid = uuid();
+        prep('INSERT INTO conversations (id, agentId, title, created_at, updated_at, status, metadata) VALUES (?, ?, ?, ?, ?, ?, ?)').run(atid, aid, 'Stateless Run', now, now, 'idle', '{"stateless":true}');
+      }
+      prep('INSERT INTO sessions (id, conversationId, status, started_at, completed_at, response, error) VALUES (?, ?, ?, ?, ?, ?, ?)').run(rid, atid, 'pending', now, null, null, null);
+      prep('INSERT INTO run_metadata (id, run_id, thread_id, agent_id, status, input, config, webhook_url, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)').run(mid, rid, tid, aid, 'pending', inp ? j(inp) : null, cfg ? j(cfg) : null, wh, now, now);
+      return { run_id: rid, thread_id: tid, agent_id: aid, status: 'pending', created_at: iso(now), updated_at: iso(now) };
+    },
+    getRun(rid) {
+      const r = prep('SELECT * FROM run_metadata WHERE run_id = ?').get(rid);
+      if (!r) return null;
+      return { run_id: r.run_id, thread_id: r.thread_id, agent_id: r.agent_id, status: r.status, created_at: iso(r.created_at), updated_at: iso(r.updated_at) };
+    },
+    updateRunStatus(rid, stat) {
+      const now = Date.now();
+      prep('UPDATE run_metadata SET status = ?, updated_at = ? WHERE run_id = ?').run(stat, now, rid);
+      prep('UPDATE sessions SET status = ? WHERE id = ?').run(stat, rid);
+      return this.getRun(rid);
+    },
+    cancelRun(rid) {
+      const r = this.getRun(rid);
+      if (!r) throw new Error('Run not found');
+      if (['success', 'error', 'cancelled'].includes(r.status)) throw new Error('Run already completed or cancelled');
+      return this.updateRunStatus(rid, 'cancelled');
+    },
+    deleteRun(rid) {
+      db.transaction(() => {
+        prep('DELETE FROM chunks WHERE sessionId = ?').run(rid);
+        prep('DELETE FROM events WHERE sessionId = ?').run(rid);
+        prep('DELETE FROM run_metadata WHERE run_id = ?').run(rid);
+        prep('DELETE FROM sessions WHERE id = ?').run(rid);
+      })();
+      return true;
+    },
+    getThreadRuns(tid, lim = 50, off = 0) {
+      const tot = prep('SELECT COUNT(*) as count FROM run_metadata WHERE thread_id = ?').get(tid).count;
+      const rows = prep('SELECT * FROM run_metadata WHERE thread_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?').all(tid, lim, off);
+      const runs = rows.map(r => ({ run_id: r.run_id, thread_id: r.thread_id, agent_id: r.agent_id, status: r.status, created_at: iso(r.created_at), updated_at: iso(r.updated_at) }));
+      return { runs, total: tot, limit: lim, offset: off, hasMore: off + lim < tot };
+    },
+    searchThreads(flt = {}) {
+      const { metadata, status, dateRange, limit = 50, offset = 0 } = flt;
+      let wh = "status != 'deleted'", prm = [];
+      if (status) { wh += ' AND status = ?'; prm.push(status); }
+      if (dateRange?.start) { wh += ' AND created_at >= ?'; prm.push(new Date(dateRange.start).getTime()); }
+      if (dateRange?.end) { wh += ' AND created_at <= ?'; prm.push(new Date(dateRange.end).getTime()); }
+      if (metadata) { for (const [k, v] of Object.entries(metadata)) { wh += ' AND metadata LIKE ?'; prm.push(`%"${k}":"${v}"%`); } }
+      const tot = prep(`SELECT COUNT(*) as count FROM conversations WHERE ${wh}`).get(...prm).count;
+      const rows = prep(`SELECT * FROM conversations WHERE ${wh} ORDER BY updated_at DESC LIMIT ? OFFSET ?`).all(...prm, limit, offset);
+      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 [];
+    },
+    searchRuns(flt = {}) {
+      const { agent_id, thread_id, status, limit = 50, offset = 0 } = flt;
+      let wh = '1=1', prm = [];
+      if (agent_id) { wh += ' AND agent_id = ?'; prm.push(agent_id); }
+      if (thread_id) { wh += ' AND thread_id = ?'; prm.push(thread_id); }
+      if (status) { wh += ' AND status = ?'; prm.push(status); }
+      const tot = prep(`SELECT COUNT(*) as count FROM run_metadata WHERE ${wh}`).get(...prm).count;
+      const rows = prep(`SELECT * FROM run_metadata WHERE ${wh} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...prm, limit, offset);
+      const runs = rows.map(r => ({ run_id: r.run_id, thread_id: r.thread_id, agent_id: r.agent_id, status: r.status, created_at: iso(r.created_at), updated_at: iso(r.updated_at) }));
+      return { runs, total: tot, limit, offset, hasMore: offset + limit < tot };
+    }
+  };
+}

package/database.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import os from 'os';
 import { createRequire } from 'module';
+import { createACPQueries } from './acp-queries.js';
 
 const require = createRequire(import.meta.url);
 
@@ -226,8 +227,102 @@ function migrateFromJson() {
   }
 }
 
+function migrateToACP() {
+  try {
+    const migrate = db.transaction(() => {
+      // Create new tables for ACP support
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS thread_states (
+          id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          checkpoint_id TEXT,
+          state_data TEXT NOT NULL,
+          created_at INTEGER NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE,
+          FOREIGN KEY (checkpoint_id) REFERENCES checkpoints(id) ON DELETE SET NULL
+        )
+      `);
+
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS checkpoints (
+          id TEXT PRIMARY KEY,
+          thread_id TEXT NOT NULL,
+          checkpoint_name TEXT NOT NULL,
+          sequence INTEGER NOT NULL,
+          created_at INTEGER NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+        )
+      `);
+
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS run_metadata (
+          id TEXT PRIMARY KEY,
+          run_id TEXT NOT NULL UNIQUE,
+          thread_id TEXT,
+          agent_id TEXT NOT NULL,
+          status TEXT NOT NULL DEFAULT 'pending',
+          input TEXT,
+          config TEXT,
+          webhook_url TEXT,
+          created_at INTEGER NOT NULL,
+          updated_at INTEGER NOT NULL,
+          FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+        )
+      `);
+
+      // Add new columns to existing tables
+      const convCols = db.prepare("PRAGMA table_info(conversations)").all();
+      const convColNames = convCols.map(c => c.name);
+
+      if (!convColNames.includes('metadata')) {
+        db.exec('ALTER TABLE conversations ADD COLUMN metadata TEXT');
+      }
+
+      const sessCols = db.prepare("PRAGMA table_info(sessions)").all();
+      const sessColNames = sessCols.map(c => c.name);
+
+      const sessionCols = {
+        run_id: 'TEXT',
+        input: 'TEXT',
+        config: 'TEXT',
+        interrupt: 'TEXT'
+      };
+
+      for (const [colName, colType] of Object.entries(sessionCols)) {
+        if (!sessColNames.includes(colName)) {
+          db.exec(`ALTER TABLE sessions ADD COLUMN ${colName} ${colType}`);
+        }
+      }
+
+      // Create indexes
+      db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_thread_states_thread ON thread_states(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_thread_states_checkpoint ON thread_states(checkpoint_id);
+        CREATE INDEX IF NOT EXISTS idx_thread_states_created ON thread_states(created_at);
+
+        CREATE INDEX IF NOT EXISTS idx_checkpoints_thread ON checkpoints(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_checkpoints_sequence ON checkpoints(thread_id, sequence);
+        CREATE UNIQUE INDEX IF NOT EXISTS idx_checkpoints_unique_seq ON checkpoints(thread_id, sequence);
+
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_run_id ON run_metadata(run_id);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_thread ON run_metadata(thread_id);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_status ON run_metadata(status);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_agent ON run_metadata(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_run_metadata_created ON run_metadata(created_at);
+
+        CREATE INDEX IF NOT EXISTS idx_sessions_run_id ON sessions(run_id);
+      `);
+    });
+
+    migrate();
+  } catch (err) {
+    console.error('[Migration] ACP schema migration error:', err.message);
+  }
+}
+
 initSchema();
 migrateFromJson();
+migrateToACP();
 
 // Migration: Add imported conversation columns if they don't exist
 try {
@@ -272,25 +367,90 @@ try {
   console.error('[Migration] Error:', err.message);
 }
 
-// Migration: Add resume capability columns to  if needed
+// Migration: Add resume capability columns (disabled - incomplete migration)
+// This migration block was incomplete and has been removed
+
+// ============ ACP SCHEMA MIGRATION ============
 try {
-  const result = db.prepare("PRAGMA table_info()").all();
-  const columnNames = result.map(r => r.name);
-  const resumeColumns = {
-    attempts: 'INTEGER DEFAULT 0',
-    lastAttempt: 'INTEGER',
-    currentSize: 'INTEGER DEFAULT 0',
-    hash: 'TEXT'
-  };
+  console.log('[Migration] Running ACP schema migration...');
 
-  for (const [colName, colDef] of Object.entries(resumeColumns)) {
-    if (!columnNames.includes(colName)) {
-      db.exec(`ALTER TABLE  ADD COLUMN ${colName} ${colDef}`);
-      console.log(`[Migration] Added column ${colName} to  table`);
-    }
+  // Add metadata column to conversations if not exists
+  const convColsACP = db.prepare("PRAGMA table_info(conversations)").all().map(c => c.name);
+  if (!convColsACP.includes('metadata')) {
+    db.exec('ALTER TABLE conversations ADD COLUMN metadata TEXT DEFAULT "{}"');
+    console.log('[Migration] Added metadata column to conversations');
+  }
+
+  // Add run_id, input, config, interrupt to sessions if not exists
+  const sessColsACP = db.prepare("PRAGMA table_info(sessions)").all().map(c => c.name);
+  if (!sessColsACP.includes('run_id')) {
+    db.exec('ALTER TABLE sessions ADD COLUMN run_id TEXT');
+    console.log('[Migration] Added run_id column to sessions');
+  }
+  if (!sessColsACP.includes('input')) {
+    db.exec('ALTER TABLE sessions ADD COLUMN input TEXT');
+    console.log('[Migration] Added input column to sessions');
   }
+  if (!sessColsACP.includes('config')) {
+    db.exec('ALTER TABLE sessions ADD COLUMN config TEXT');
+    console.log('[Migration] Added config column to sessions');
+  }
+  if (!sessColsACP.includes('interrupt')) {
+    db.exec('ALTER TABLE sessions ADD COLUMN interrupt TEXT');
+    console.log('[Migration] Added interrupt column to sessions');
+  }
+
+  // Create ACP tables
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS thread_states (
+      id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      checkpoint_id TEXT NOT NULL,
+      state_data TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_thread_states_thread ON thread_states(thread_id);
+    CREATE INDEX IF NOT EXISTS idx_thread_states_checkpoint ON thread_states(checkpoint_id);
+    CREATE INDEX IF NOT EXISTS idx_thread_states_created ON thread_states(created_at);
+
+    CREATE TABLE IF NOT EXISTS checkpoints (
+      id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL,
+      checkpoint_name TEXT,
+      sequence INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_checkpoints_thread ON checkpoints(thread_id);
+    CREATE INDEX IF NOT EXISTS idx_checkpoints_sequence ON checkpoints(thread_id, sequence);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_checkpoints_unique ON checkpoints(thread_id, sequence);
+
+    CREATE TABLE IF NOT EXISTS run_metadata (
+      run_id TEXT PRIMARY KEY,
+      thread_id TEXT,
+      agent_id TEXT NOT NULL,
+      status TEXT NOT NULL,
+      input TEXT,
+      config TEXT,
+      webhook_url TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (thread_id) REFERENCES conversations(id) ON DELETE CASCADE,
+      FOREIGN KEY (run_id) REFERENCES sessions(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_run_metadata_thread ON run_metadata(thread_id);
+    CREATE INDEX IF NOT EXISTS idx_run_metadata_agent ON run_metadata(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_run_metadata_status ON run_metadata(status);
+    CREATE INDEX IF NOT EXISTS idx_run_metadata_created ON run_metadata(created_at);
+  `);
+
+  console.log('[Migration] ACP schema migration complete');
 } catch (err) {
-  console.error('[Migration] Schema update warning:', err.message);
+  console.error('[Migration] ACP schema migration error:', err.message);
 }
 
 // Migration: Backfill messages for conversations imported without message content
@@ -1300,7 +1460,10 @@ export const queries = {
   markDownloadPaused(downloadId, errorMessage) {
     const stmt = prep('UPDATE  SET status = ?, error_message = ?, lastAttempt = ? WHERE id = ?');
     stmt.run('paused', errorMessage, Date.now(), downloadId);
-  }
+  },
+
+  // ============ ACP-COMPATIBLE QUERIES ============
+  ...createACPQueries(db, prep)
 };
 
 export default { queries };

package/lib/agent-descriptors.js

@@ -0,0 +1,332 @@
+const agentDescriptorCache = new Map();
+
+function generateClaudeCodeDescriptor(agent) {
+  return {
+    metadata: {
+      ref: {
+        name: agent.name,
+        version: '1.0.0',
+        url: agent.path
+      },
+      description: 'Claude Code is an AI coding agent that can read, write, and execute code with streaming output support. It provides comprehensive code editing, file management, and terminal execution capabilities.'
+    },
+    specs: {
+      capabilities: {
+        threads: true,
+        interrupts: false,
+        callbacks: false,
+        streaming: {
+          values: false,
+          custom: true
+        }
+      },
+      input: {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'string',
+            description: 'The user prompt or instruction to send to the agent'
+          },
+          model: {
+            type: 'string',
+            description: 'Optional model identifier to use for this run'
+          }
+        },
+        required: ['content']
+      },
+      output: {
+        type: 'object',
+        properties: {
+          result: {
+            type: 'string',
+            description: 'The final response or result from the agent'
+          },
+          events: {
+            type: 'array',
+            description: 'Stream of execution events (tool calls, outputs, etc.)',
+            items: { type: 'object' }
+          }
+        }
+      },
+      custom_streaming_update: {
+        type: 'object',
+        properties: {
+          type: {
+            type: 'string',
+            enum: ['text', 'tool_use', 'tool_result', 'error']
+          },
+          data: { type: 'object' }
+        }
+      },
+      thread_state: {
+        type: 'object',
+        description: 'Conversation history with messages and session state',
+        properties: {
+          messages: {
+            type: 'array',
+            items: { type: 'object' }
+          },
+          sessionId: { type: 'string' }
+        }
+      },
+      config: {
+        type: 'object',
+        properties: {
+          workingDirectory: {
+            type: 'string',
+            description: 'Working directory for file operations'
+          },
+          model: {
+            type: 'string',
+            description: 'Default model to use'
+          }
+        }
+      }
+    }
+  };
+}
+
+function generateGeminiDescriptor(agent) {
+  return {
+    metadata: {
+      ref: {
+        name: agent.name,
+        version: '1.0.0',
+        url: agent.path
+      },
+      description: 'Gemini CLI is Google AI coding agent with streaming support, code execution, and file management capabilities.'
+    },
+    specs: {
+      capabilities: {
+        threads: true,
+        interrupts: false,
+        callbacks: false,
+        streaming: {
+          values: false,
+          custom: true
+        }
+      },
+      input: {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'string',
+            description: 'The user prompt or instruction to send to the agent'
+          },
+          model: {
+            type: 'string',
+            description: 'Optional model identifier to use for this run'
+          }
+        },
+        required: ['content']
+      },
+      output: {
+        type: 'object',
+        properties: {
+          result: {
+            type: 'string',
+            description: 'The final response or result from the agent'
+          },
+          events: {
+            type: 'array',
+            description: 'Stream of execution events',
+            items: { type: 'object' }
+          }
+        }
+      },
+      custom_streaming_update: {
+        type: 'object',
+        properties: {
+          type: { type: 'string' },
+          data: { type: 'object' }
+        }
+      },
+      thread_state: {
+        type: 'object',
+        description: 'Conversation history and session state',
+        properties: {
+          messages: {
+            type: 'array',
+            items: { type: 'object' }
+          }
+        }
+      },
+      config: {
+        type: 'object',
+        properties: {
+          workingDirectory: {
+            type: 'string',
+            description: 'Working directory for file operations'
+          },
+          model: {
+            type: 'string',
+            description: 'Model identifier'
+          }
+        }
+      }
+    }
+  };
+}
+
+function generateOpenCodeDescriptor(agent) {
+  return {
+    metadata: {
+      ref: {
+        name: agent.name,
+        version: '1.0.0',
+        url: agent.path
+      },
+      description: 'OpenCode is a multi-provider AI coding agent with streaming support and comprehensive code manipulation capabilities.'
+    },
+    specs: {
+      capabilities: {
+        threads: true,
+        interrupts: false,
+        callbacks: false,
+        streaming: {
+          values: false,
+          custom: true
+        }
+      },
+      input: {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'string',
+            description: 'The user prompt or instruction'
+          },
+          model: {
+            type: 'string',
+            description: 'Model identifier'
+          }
+        },
+        required: ['content']
+      },
+      output: {
+        type: 'object',
+        properties: {
+          result: { type: 'string' },
+          events: {
+            type: 'array',
+            items: { type: 'object' }
+          }
+        }
+      },
+      custom_streaming_update: {
+        type: 'object',
+        properties: {
+          type: { type: 'string' },
+          data: { type: 'object' }
+        }
+      },
+      thread_state: {
+        type: 'object',
+        properties: {
+          messages: {
+            type: 'array',
+            items: { type: 'object' }
+          }
+        }
+      },
+      config: {
+        type: 'object',
+        properties: {
+          workingDirectory: { type: 'string' },
+          model: { type: 'string' }
+        }
+      }
+    }
+  };
+}
+
+function generateGenericDescriptor(agent) {
+  return {
+    metadata: {
+      ref: {
+        name: agent.name,
+        version: '1.0.0',
+        url: agent.path
+      },
+      description: `${agent.name} is an AI coding agent with basic streaming and execution capabilities.`
+    },
+    specs: {
+      capabilities: {
+        threads: true,
+        interrupts: false,
+        callbacks: false,
+        streaming: {
+          values: false,
+          custom: true
+        }
+      },
+      input: {
+        type: 'object',
+        properties: {
+          content: {
+            type: 'string',
+            description: 'User prompt or instruction'
+          }
+        },
+        required: ['content']
+      },
+      output: {
+        type: 'object',
+        properties: {
+          result: { type: 'string' }
+        }
+      },
+      custom_streaming_update: {
+        type: 'object',
+        properties: {
+          type: { type: 'string' },
+          data: { type: 'object' }
+        }
+      },
+      thread_state: {
+        type: 'object',
+        properties: {
+          messages: {
+            type: 'array',
+            items: { type: 'object' }
+          }
+        }
+      },
+      config: {
+        type: 'object',
+        properties: {
+          workingDirectory: { type: 'string' }
+        }
+      }
+    }
+  };
+}
+
+function generateAgentDescriptor(agent) {
+  switch (agent.id) {
+    case 'claude-code':
+      return generateClaudeCodeDescriptor(agent);
+    case 'gemini':
+      return generateGeminiDescriptor(agent);
+    case 'opencode':
+      return generateOpenCodeDescriptor(agent);
+    default:
+      return generateGenericDescriptor(agent);
+  }
+}
+
+export function initializeDescriptors(agents) {
+  agentDescriptorCache.clear();
+  for (const agent of agents) {
+    const descriptor = generateAgentDescriptor(agent);
+    agentDescriptorCache.set(agent.id, descriptor);
+  }
+  return agentDescriptorCache.size;
+}
+
+export function getAgentDescriptor(agentId) {
+  return agentDescriptorCache.get(agentId) || null;
+}
+
+export function getAllDescriptors() {
+  return Object.fromEntries(agentDescriptorCache);
+}

package/package.json

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

package/server.js

@@ -14,6 +14,7 @@ import Busboy from 'busboy';
 import fsbrowse from 'fsbrowse';
 import { queries } from './database.js';
 import { runClaudeWithStreaming } from './lib/claude-runner.js';
+import { initializeDescriptors, getAgentDescriptor } from './lib/agent-descriptors.js';
 
 const ttsTextAccumulators = new Map();
 
@@ -338,6 +339,7 @@ function discoverAgents() {
 }
 
 const discoveredAgents = discoverAgents();
+initializeDescriptors(discoveredAgents);
 
 const modelCache = new Map();
 
@@ -1884,32 +1886,14 @@ const server = http.createServer(async (req, res) => {
     const agentDescriptorMatch = pathOnly.match(/^\/api\/agents\/([^/]+)\/descriptor$/);
     if (agentDescriptorMatch && req.method === 'GET') {
       const agentId = agentDescriptorMatch[1];
-      const agent = discoveredAgents.find(a => a.id === agentId);
-      
-      if (!agent) {
+      const descriptor = getAgentDescriptor(agentId);
+
+      if (!descriptor) {
         sendJSON(req, res, 404, { error: 'Agent not found' });
         return;
       }
 
-      sendJSON(req, res, 200, {
-        agentId: agent.id,
-        agentName: agent.name,
-        protocol: agent.protocol || 'direct',
-        capabilities: {
-          streaming: true,
-          cancel: true,
-          resume: agent.protocol === 'direct',
-          stateful: true
-        },
-        inputSchema: {
-          type: 'object',
-          properties: {
-            content: { type: 'string', description: 'The prompt to send to the agent' }
-          },
-          required: ['content']
-        },
-        stateFormat: 'opaque'
-      });
+      sendJSON(req, res, 200, descriptor);
       return;
     }