agentgui 1.0.380 → 1.0.381

package/acp-queries.js

@@ -0,0 +1,550 @@
+// ACP-Compatible Data Layer
+// Provides query functions that return ACP v0.2.3 compatible data structures
+
+import { randomUUID } from 'crypto';
+
+// Helper to generate IDs
+function generateId(prefix) {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+
+// Helper to generate UUID
+function generateUUID() {
+  return randomUUID();
+}
+
+// Helper to convert timestamp to ISO date string
+function toISOString(timestamp) {
+  return new Date(timestamp).toISOString();
+}
+
+export function createACPQueries(db, prep) {
+  return {
+    // ============ THREAD CRUD ============
+
+    createThread(metadata = {}) {
+      const threadId = generateUUID();
+      const now = Date.now();
+
+      const stmt = prep(
+        `INSERT INTO conversations (id, agentId, title, created_at, updated_at, status, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      );
+      stmt.run(threadId, 'unknown', null, now, now, 'idle', JSON.stringify(metadata));
+
+      return {
+        thread_id: threadId,
+        created_at: toISOString(now),
+        updated_at: toISOString(now),
+        metadata,
+        status: 'idle'
+      };
+    },
+
+    getThread(threadId) {
+      const stmt = prep('SELECT * FROM conversations WHERE id = ?');
+      const row = stmt.get(threadId);
+
+      if (!row) return null;
+
+      let metadata = {};
+      if (row.metadata) {
+        try {
+          metadata = JSON.parse(row.metadata);
+        } catch (e) {}
+      }
+
+      return {
+        thread_id: row.id,
+        created_at: toISOString(row.created_at),
+        updated_at: toISOString(row.updated_at),
+        metadata,
+        status: row.status || 'idle'
+      };
+    },
+
+    patchThread(threadId, updates) {
+      const thread = this.getThread(threadId);
+      if (!thread) {
+        throw new Error('Thread not found');
+      }
+
+      const now = Date.now();
+      const newMetadata = updates.metadata !== undefined ? updates.metadata : thread.metadata;
+      const newStatus = updates.status !== undefined ? updates.status : thread.status;
+
+      const stmt = prep(
+        `UPDATE conversations SET metadata = ?, status = ?, updated_at = ? WHERE id = ?`
+      );
+      stmt.run(JSON.stringify(newMetadata), newStatus, now, threadId);
+
+      return {
+        thread_id: threadId,
+        created_at: thread.created_at,
+        updated_at: toISOString(now),
+        metadata: newMetadata,
+        status: newStatus
+      };
+    },
+
+    deleteThread(threadId) {
+      // Check for pending runs
+      const pendingRuns = prep(
+        `SELECT COUNT(*) as count FROM run_metadata WHERE thread_id = ? AND status = 'pending'`
+      ).get(threadId);
+
+      if (pendingRuns && pendingRuns.count > 0) {
+        throw new Error('Cannot delete thread with pending runs');
+      }
+
+      const deleteStmt = db.transaction(() => {
+        prep('DELETE FROM thread_states WHERE thread_id = ?').run(threadId);
+        prep('DELETE FROM checkpoints WHERE thread_id = ?').run(threadId);
+        prep('DELETE FROM run_metadata WHERE thread_id = ?').run(threadId);
+        prep('DELETE FROM sessions WHERE conversationId = ?').run(threadId);
+        prep('DELETE FROM messages WHERE conversationId = ?').run(threadId);
+        prep('DELETE FROM chunks WHERE conversationId = ?').run(threadId);
+        prep('DELETE FROM events WHERE conversationId = ?').run(threadId);
+        prep('DELETE FROM conversations WHERE id = ?').run(threadId);
+      });
+
+      deleteStmt();
+      return true;
+    },
+
+    // ============ THREAD STATE MANAGEMENT ============
+
+    saveThreadState(threadId, checkpointId, stateData) {
+      const id = generateId('state');
+      const now = Date.now();
+
+      const stmt = prep(
+        `INSERT INTO thread_states (id, thread_id, checkpoint_id, state_data, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+      );
+      stmt.run(id, threadId, checkpointId, JSON.stringify(stateData), now);
+
+      return {
+        id,
+        thread_id: threadId,
+        checkpoint_id: checkpointId,
+        created_at: toISOString(now)
+      };
+    },
+
+    getThreadState(threadId, checkpointId = null) {
+      let stmt, row;
+
+      if (checkpointId) {
+        stmt = prep(
+          `SELECT * FROM thread_states WHERE thread_id = ? AND checkpoint_id = ? ORDER BY created_at DESC LIMIT 1`
+        );
+        row = stmt.get(threadId, checkpointId);
+      } else {
+        stmt = prep(
+          `SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at DESC LIMIT 1`
+        );
+        row = stmt.get(threadId);
+      }
+
+      if (!row) return null;
+
+      let stateData = {};
+      try {
+        stateData = JSON.parse(row.state_data);
+      } catch (e) {}
+
+      return {
+        checkpoint: { checkpoint_id: row.checkpoint_id },
+        values: stateData.values || {},
+        messages: stateData.messages || [],
+        metadata: stateData.metadata || {}
+      };
+    },
+
+    getThreadHistory(threadId, limit = 50, offset = 0) {
+      const countStmt = prep('SELECT COUNT(*) as count FROM thread_states WHERE thread_id = ?');
+      const total = countStmt.get(threadId).count;
+
+      const stmt = prep(
+        `SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`
+      );
+      const rows = stmt.all(threadId, limit, offset);
+
+      const states = rows.map(row => {
+        let stateData = {};
+        try {
+          stateData = JSON.parse(row.state_data);
+        } catch (e) {}
+
+        return {
+          checkpoint: { checkpoint_id: row.checkpoint_id },
+          values: stateData.values || {},
+          messages: stateData.messages || [],
+          metadata: stateData.metadata || {}
+        };
+      });
+
+      return {
+        states,
+        total,
+        limit,
+        offset,
+        hasMore: offset + limit < total
+      };
+    },
+
+    copyThread(sourceThreadId) {
+      const sourceThread = this.getThread(sourceThreadId);
+      if (!sourceThread) {
+        throw new Error('Source thread not found');
+      }
+
+      const newThreadId = generateUUID();
+      const now = Date.now();
+
+      const copyStmt = db.transaction(() => {
+        // Copy thread
+        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(newThreadId, now, now, sourceThreadId);
+
+        // Copy checkpoints
+        const checkpoints = prep('SELECT * FROM checkpoints WHERE thread_id = ? ORDER BY sequence ASC').all(sourceThreadId);
+        for (const checkpoint of checkpoints) {
+          const newCheckpointId = generateUUID();
+          prep(
+            `INSERT INTO checkpoints (id, thread_id, checkpoint_name, sequence, created_at)
+             VALUES (?, ?, ?, ?, ?)`
+          ).run(newCheckpointId, newThreadId, checkpoint.checkpoint_name, checkpoint.sequence, now);
+        }
+
+        // Copy thread states
+        const states = prep('SELECT * FROM thread_states WHERE thread_id = ? ORDER BY created_at ASC').all(sourceThreadId);
+        for (const state of states) {
+          prep(
+            `INSERT INTO thread_states (id, thread_id, checkpoint_id, state_data, created_at)
+             VALUES (?, ?, ?, ?, ?)`
+          ).run(generateId('state'), newThreadId, state.checkpoint_id, state.state_data, now);
+        }
+
+        // Copy messages
+        const messages = prep('SELECT * FROM messages WHERE conversationId = ? ORDER BY created_at ASC').all(sourceThreadId);
+        for (const msg of messages) {
+          prep(
+            `INSERT INTO messages (id, conversationId, role, content, created_at)
+             VALUES (?, ?, ?, ?, ?)`
+          ).run(generateId('msg'), newThreadId, msg.role, msg.content, now);
+        }
+      });
+
+      copyStmt();
+      return this.getThread(newThreadId);
+    },
+
+    // ============ CHECKPOINT FUNCTIONS ============
+
+    createCheckpoint(threadId, checkpointName = null) {
+      const id = generateUUID();
+      const now = Date.now();
+
+      // Get next sequence number
+      const maxSeq = prep('SELECT MAX(sequence) as max FROM checkpoints WHERE thread_id = ?').get(threadId);
+      const sequence = (maxSeq?.max ?? -1) + 1;
+
+      const stmt = prep(
+        `INSERT INTO checkpoints (id, thread_id, checkpoint_name, sequence, created_at)
+         VALUES (?, ?, ?, ?, ?)`
+      );
+      stmt.run(id, threadId, checkpointName, sequence, now);
+
+      return {
+        checkpoint_id: id,
+        thread_id: threadId,
+        checkpoint_name: checkpointName,
+        sequence,
+        created_at: toISOString(now)
+      };
+    },
+
+    getCheckpoint(checkpointId) {
+      const stmt = prep('SELECT * FROM checkpoints WHERE id = ?');
+      const row = stmt.get(checkpointId);
+
+      if (!row) return null;
+
+      return {
+        checkpoint_id: row.id,
+        thread_id: row.thread_id,
+        checkpoint_name: row.checkpoint_name,
+        sequence: row.sequence,
+        created_at: toISOString(row.created_at)
+      };
+    },
+
+    listCheckpoints(threadId, limit = 50, offset = 0) {
+      const countStmt = prep('SELECT COUNT(*) as count FROM checkpoints WHERE thread_id = ?');
+      const total = countStmt.get(threadId).count;
+
+      const stmt = prep(
+        `SELECT * FROM checkpoints WHERE thread_id = ? ORDER BY sequence DESC LIMIT ? OFFSET ?`
+      );
+      const rows = stmt.all(threadId, limit, offset);
+
+      const checkpoints = rows.map(row => ({
+        checkpoint_id: row.id,
+        thread_id: row.thread_id,
+        checkpoint_name: row.checkpoint_name,
+        sequence: row.sequence,
+        created_at: toISOString(row.created_at)
+      }));
+
+      return {
+        checkpoints,
+        total,
+        limit,
+        offset,
+        hasMore: offset + limit < total
+      };
+    },
+
+    // ============ RUN MANAGEMENT ============
+
+    createRun(agentId, threadId = null, input = null, config = null, webhookUrl = null) {
+      const runId = generateUUID();
+      const now = Date.now();
+
+      // Create session first
+      const sessionStmt = prep(
+        `INSERT INTO sessions (id, conversationId, status, started_at, completed_at, response, error)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`
+      );
+      sessionStmt.run(runId, threadId || 'stateless', 'pending', now, null, null, null);
+
+      // Create run metadata
+      const runStmt = prep(
+        `INSERT INTO run_metadata (run_id, thread_id, agent_id, status, input, config, webhook_url, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      runStmt.run(
+        runId,
+        threadId,
+        agentId,
+        'pending',
+        input ? JSON.stringify(input) : null,
+        config ? JSON.stringify(config) : null,
+        webhookUrl,
+        now,
+        now
+      );
+
+      return {
+        run_id: runId,
+        thread_id: threadId,
+        agent_id: agentId,
+        status: 'pending',
+        created_at: toISOString(now),
+        updated_at: toISOString(now)
+      };
+    },
+
+    getRun(runId) {
+      const stmt = prep('SELECT * FROM run_metadata WHERE run_id = ?');
+      const row = stmt.get(runId);
+
+      if (!row) return null;
+
+      return {
+        run_id: row.run_id,
+        thread_id: row.thread_id,
+        agent_id: row.agent_id,
+        status: row.status,
+        created_at: toISOString(row.created_at),
+        updated_at: toISOString(row.updated_at)
+      };
+    },
+
+    updateRunStatus(runId, status) {
+      const now = Date.now();
+
+      const stmt = prep(
+        `UPDATE run_metadata SET status = ?, updated_at = ? WHERE run_id = ?`
+      );
+      stmt.run(status, now, runId);
+
+      // Also update session
+      prep('UPDATE sessions SET status = ? WHERE id = ?').run(status, runId);
+
+      return this.getRun(runId);
+    },
+
+    cancelRun(runId) {
+      const run = this.getRun(runId);
+      if (!run) {
+        throw new Error('Run not found');
+      }
+
+      if (['success', 'error', 'cancelled'].includes(run.status)) {
+        throw new Error('Run already completed or cancelled');
+      }
+
+      return this.updateRunStatus(runId, 'cancelled');
+    },
+
+    deleteRun(runId) {
+      const deleteStmt = db.transaction(() => {
+        prep('DELETE FROM chunks WHERE sessionId = ?').run(runId);
+        prep('DELETE FROM events WHERE sessionId = ?').run(runId);
+        prep('DELETE FROM run_metadata WHERE run_id = ?').run(runId);
+        prep('DELETE FROM sessions WHERE id = ?').run(runId);
+      });
+
+      deleteStmt();
+      return true;
+    },
+
+    getThreadRuns(threadId, limit = 50, offset = 0) {
+      const countStmt = prep('SELECT COUNT(*) as count FROM run_metadata WHERE thread_id = ?');
+      const total = countStmt.get(threadId).count;
+
+      const stmt = prep(
+        `SELECT * FROM run_metadata WHERE thread_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`
+      );
+      const rows = stmt.all(threadId, limit, offset);
+
+      const runs = rows.map(row => ({
+        run_id: row.run_id,
+        thread_id: row.thread_id,
+        agent_id: row.agent_id,
+        status: row.status,
+        created_at: toISOString(row.created_at),
+        updated_at: toISOString(row.updated_at)
+      }));
+
+      return {
+        runs,
+        total,
+        limit,
+        offset,
+        hasMore: offset + limit < total
+      };
+    },
+
+    // ============ SEARCH FUNCTIONS ============
+
+    searchThreads(filters = {}) {
+      const { metadata, status, dateRange, limit = 50, offset = 0 } = filters;
+
+      let whereClause = "status != 'deleted'";
+      const params = [];
+
+      if (status) {
+        whereClause += ' AND status = ?';
+        params.push(status);
+      }
+
+      if (dateRange?.start) {
+        whereClause += ' AND created_at >= ?';
+        params.push(new Date(dateRange.start).getTime());
+      }
+
+      if (dateRange?.end) {
+        whereClause += ' AND created_at <= ?';
+        params.push(new Date(dateRange.end).getTime());
+      }
+
+      if (metadata) {
+        // Simple metadata filter - check if JSON contains key-value pairs
+        for (const [key, value] of Object.entries(metadata)) {
+          whereClause += ` AND metadata LIKE ?`;
+          params.push(`%"${key}":"${value}"%`);
+        }
+      }
+
+      const countStmt = prep(`SELECT COUNT(*) as count FROM conversations WHERE ${whereClause}`);
+      const total = countStmt.get(...params).count;
+
+      const stmt = prep(
+        `SELECT * FROM conversations WHERE ${whereClause} ORDER BY updated_at DESC LIMIT ? OFFSET ?`
+      );
+      const rows = stmt.all(...params, limit, offset);
+
+      const threads = rows.map(row => {
+        let metadata = {};
+        if (row.metadata) {
+          try { metadata = JSON.parse(row.metadata); } catch (e) {}
+        }
+        return {
+          thread_id: row.id,
+          created_at: toISOString(row.created_at),
+          updated_at: toISOString(row.updated_at),
+          metadata,
+          status: row.status || 'idle'
+        };
+      });
+
+      return {
+        threads,
+        total,
+        limit,
+        offset,
+        hasMore: offset + limit < total
+      };
+    },
+
+    searchAgents(filters = {}) {
+      // This would integrate with the agent discovery system
+      // For now, return empty array as agents are discovered dynamically
+      return [];
+    },
+
+    searchRuns(filters = {}) {
+      const { agent_id, thread_id, status, limit = 50, offset = 0 } = filters;
+
+      let whereClause = '1=1';
+      const params = [];
+
+      if (agent_id) {
+        whereClause += ' AND agent_id = ?';
+        params.push(agent_id);
+      }
+
+      if (thread_id) {
+        whereClause += ' AND thread_id = ?';
+        params.push(thread_id);
+      }
+
+      if (status) {
+        whereClause += ' AND status = ?';
+        params.push(status);
+      }
+
+      const countStmt = prep(`SELECT COUNT(*) as count FROM run_metadata WHERE ${whereClause}`);
+      const total = countStmt.get(...params).count;
+
+      const stmt = prep(
+        `SELECT * FROM run_metadata WHERE ${whereClause} ORDER BY created_at DESC LIMIT ? OFFSET ?`
+      );
+      const rows = stmt.all(...params, limit, offset);
+
+      const runs = rows.map(row => ({
+        run_id: row.run_id,
+        thread_id: row.thread_id,
+        agent_id: row.agent_id,
+        status: row.status,
+        created_at: toISOString(row.created_at),
+        updated_at: toISOString(row.updated_at)
+      }));
+
+      return {
+        runs,
+        total,
+        limit,
+        offset,
+        hasMore: offset + limit < total
+      };
+    }
+  };
+}

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.381",
   "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;
     }