agentgui 1.0.714 → 1.0.716

package/lib/agent-descriptors.js

@@ -1,332 +1,47 @@
-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);
-}
+const agentDescriptorCache = new Map();
+
+const AGENT_DESCRIPTIONS = {
+  'claude-code': '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.',
+  'gemini': 'Gemini CLI is Google AI coding agent with streaming support, code execution, and file management capabilities.',
+  'opencode': 'OpenCode is a multi-provider AI coding agent with streaming support and comprehensive code manipulation capabilities.',
+};
+
+const BASE_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' } }, 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 buildDescriptor(agent) {
+  const description = AGENT_DESCRIPTIONS[agent.id] || `${agent.name} is an AI coding agent with basic streaming and execution capabilities.`;
+  const specs = JSON.parse(JSON.stringify(BASE_SPECS));
+  if (agent.id === 'claude-code' || agent.id === 'gemini' || agent.id === 'opencode') {
+    specs.input.properties.model = { type: 'string', description: 'Optional model identifier to use for this run' };
+    specs.output.properties.events = { type: 'array', description: 'Stream of execution events', items: { type: 'object' } };
+    specs.config.properties.model = { type: 'string' };
+  }
+  if (agent.id === 'claude-code') {
+    specs.thread_state.description = 'Conversation history with messages and session state';
+    specs.thread_state.properties.sessionId = { type: 'string' };
+    specs.config.properties.model.description = 'Default model to use';
+    specs.config.properties.workingDirectory.description = 'Working directory for file operations';
+  }
+  return { metadata: { ref: { name: agent.name, version: '1.0.0', url: agent.path }, description }, specs };
+}
+
+export function initializeDescriptors(agents) {
+  agentDescriptorCache.clear();
+  for (const agent of agents) agentDescriptorCache.set(agent.id, buildDescriptor(agent));
+  return agentDescriptorCache.size;
+}
+
+export function getAgentDescriptor(agentId) {
+  return agentDescriptorCache.get(agentId) || null;
+}
+
+export function getAllDescriptors() {
+  return Object.fromEntries(agentDescriptorCache);
+}

package/lib/agent-registry-configs.js

@@ -0,0 +1,125 @@
+import { acpProtocolHandler } from './acp-protocol.js';
+
+const SIMPLE_ACP_AGENTS = [
+  { id: 'goose', name: 'Goose', command: 'goose' },
+  { id: 'openhands', name: 'OpenHands', command: 'openhands' },
+  { id: 'augment', name: 'Augment Code', command: 'augment' },
+  { id: 'cline', name: 'Cline', command: 'cline' },
+  { id: 'kimi', name: 'Kimi CLI', command: 'kimi' },
+  { id: 'qwen', name: 'Qwen Code', command: 'qwen-code' },
+  { id: 'codex', name: 'Codex CLI', command: 'codex' },
+  { id: 'mistral', name: 'Mistral Vibe', command: 'mistral-vibe' },
+  { id: 'kiro', name: 'Kiro CLI', command: 'kiro' },
+  { id: 'fast-agent', name: 'fast-agent', command: 'fast-agent' },
+];
+
+function parseClaudeOutput(line) {
+  try {
+    const entry = JSON.parse(line);
+    if (!entry || typeof entry !== 'object') return null;
+    if (entry.type === 'user' && entry.isMeta === true) return null;
+    if (entry.isApiErrorMessage === true && entry.error === 'rate_limit') {
+      entry._rateLimitDetected = true;
+    }
+    if (entry.type === 'assistant' && entry.message) {
+      entry._isFragment = entry.message.stop_reason === null || entry.message.stop_reason === undefined;
+    }
+    if (entry.type === 'system' && entry.subtype === 'turn_duration' && entry.durationMs) {
+      entry._turnDurationMs = entry.durationMs;
+    }
+    if (entry.type === 'system' && entry.subtype === 'compact_boundary' && entry.compactMetadata) {
+      entry._preTokens = entry.compactMetadata.preTokens;
+    }
+    if (entry.message?.usage) {
+      const u = entry.message.usage;
+      entry._cacheUsage = {
+        cache_creation: u.cache_creation_input_tokens || u['cache_creation.ephemeral_1h_input_tokens'] || u['cache_creation.ephemeral_5m_input_tokens'] || 0,
+        cache_read: u.cache_read_input_tokens || 0
+      };
+    }
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+export function registerAllAgents(registry) {
+  registry.register({
+    id: 'claude-code',
+    name: 'Claude Code',
+    command: 'claude',
+    protocol: 'direct',
+    supportsStdin: false,
+    closeStdin: true,
+    useJsonRpcStdin: false,
+    supportedFeatures: ['streaming', 'resume', 'system-prompt', 'permissions-skip', 'steering'],
+    spawnEnv: { MAX_THINKING_TOKENS: '0', AGENTGUI_SUBPROCESS: '1' },
+    buildArgs(prompt, config) {
+      const { verbose = true, outputFormat = 'stream-json', print = true, resumeSessionId = null, systemPrompt = null, model = null } = config;
+      const flags = [];
+      if (print) flags.push('--print');
+      if (verbose) flags.push('--verbose');
+      flags.push(`--output-format=${outputFormat}`);
+      if (model) flags.push('--model', model);
+      if (resumeSessionId) flags.push('--resume', resumeSessionId);
+      if (systemPrompt) flags.push('--append-system-prompt', systemPrompt);
+      flags.push('--dangerously-skip-permissions');
+      flags.push(typeof prompt === 'string' ? prompt : String(prompt));
+      return flags;
+    },
+    parseOutput: parseClaudeOutput,
+  });
+
+  registry.register({
+    id: 'opencode',
+    name: 'OpenCode',
+    command: 'opencode',
+    protocol: 'acp',
+    supportsStdin: false,
+    npxPackage: 'opencode-ai',
+    supportedFeatures: ['streaming', 'resume', 'acp-protocol'],
+    buildArgs: () => ['acp'],
+    protocolHandler: acpProtocolHandler,
+  });
+
+  registry.register({
+    id: 'gemini',
+    name: 'Gemini CLI',
+    command: 'gemini',
+    protocol: 'acp',
+    supportsStdin: false,
+    npxPackage: '@google/gemini-cli',
+    supportedFeatures: ['streaming', 'resume', 'acp-protocol'],
+    buildArgs(prompt, config) {
+      const args = ['--experimental-acp', '--yolo'];
+      if (config?.model) args.push('--model', config.model);
+      return args;
+    },
+    protocolHandler: acpProtocolHandler,
+  });
+
+  registry.register({
+    id: 'kilo',
+    name: 'Kilo CLI',
+    command: 'kilo',
+    protocol: 'acp',
+    supportsStdin: false,
+    npxPackage: '@kilocode/cli',
+    supportedFeatures: ['streaming', 'resume', 'acp-protocol', 'models'],
+    buildArgs: () => ['acp'],
+    protocolHandler: acpProtocolHandler,
+  });
+
+  for (const agent of SIMPLE_ACP_AGENTS) {
+    registry.register({
+      id: agent.id,
+      name: agent.name,
+      command: agent.command,
+      protocol: 'acp',
+      supportsStdin: false,
+      supportedFeatures: ['streaming', 'resume', 'acp-protocol'],
+      buildArgs: () => ['acp'],
+      protocolHandler: acpProtocolHandler,
+    });
+  }
+}