agentgui 1.0.436 → 1.0.437

package/lib/ws-handlers-session.js

@@ -68,71 +68,6 @@ async function acpFetch(port, pth, body = null) {
   return res.json();
 }
 
-function getApiKey(name) {
-  const envMap = {
-    anthropic: 'ANTHROPIC_API_KEY',
-    google: 'GOOGLE_GENAI_API_KEY',
-    openai: 'OPENAI_API_KEY'
-  };
-  if (process.env[envMap[name]]) return process.env[envMap[name]];
-  const configPaths = {
-    anthropic: [
-      path.join(os.homedir(), '.claude.json'),
-      path.join(os.homedir(), '.anthropic.json')
-    ],
-    google: [
-      path.join(os.homedir(), '.gemini.json'),
-      path.join(os.homedir(), '.config', 'gemini', 'credentials.json')
-    ],
-    openai: [
-      path.join(os.homedir(), '.openai.json')
-    ]
-  };
-  for (const p of (configPaths[name] || [])) {
-    const data = readJson(p);
-    if (data) {
-      const key = data.api_key || data.apiKey || data.github_token;
-      if (key) return key;
-    }
-  }
-  return null;
-}
-
-async function fetchModelsFromAPI(agentId) {
-  if (agentId === 'claude-code') {
-    const apiKey = getApiKey('anthropic');
-    if (!apiKey) return null;
-    try {
-      const res = await fetch('https://api.anthropic.com/v1/models', {
-        headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
-        signal: AbortSignal.timeout(8000)
-      });
-      if (!res.ok) return null;
-      const data = await res.json();
-      const items = (data.data || []).filter(m => m.id && m.id.startsWith('claude-'));
-      if (items.length === 0) return null;
-      return items.map(m => ({ id: m.id, label: m.display_name || m.id.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()) }));
-    } catch { return null; }
-  }
-  if (agentId === 'gemini') {
-    const apiKey = getApiKey('google');
-    if (!apiKey) return null;
-    try {
-      const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`, {
-        signal: AbortSignal.timeout(8000)
-      });
-      if (!res.ok) return null;
-      const data = await res.json();
-      const items = (data.models || []).filter(m => m.name && m.name.includes('gemini'));
-      if (items.length === 0) return null;
-      return items.map(m => {
-        const id = m.name.replace(/^models\//, '');
-        return { id, label: id.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()) };
-      });
-    } catch { return null; }
-  }
-  return null;
-}
 
 export function register(router, deps) {
   const { db, discoveredAgents, modelCache,
@@ -194,69 +129,29 @@ export function register(router, deps) {
     return d;
   });
 
-  router.handle('agent.models', async (p) => {
-    const cached = modelCache.get(p.id);
-    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
-    const agent = discoveredAgents.find(x => x.id === p.id);
-    if (agent?.protocol === 'acp' && agent.acpPort) {
-      const port = agent.acpPort;
-      try {
-        const data = await acpFetch(port, '/v1/models');
-        const models = (data?.data || data?.models || []).map(m => ({
-          id: m.id || m.model_id,
-          label: m.name || m.display_name || m.id || m.model_id
-        })).filter(m => m.id);
-        if (models.length > 0) { modelCache.set(p.id, { models, ts: Date.now() }); return { models }; }
-      } catch (_) {}
-      try {
-        const data = await acpFetch(port, '/agents/search', {});
-        const list = Array.isArray(data) ? data : (data?.agents || []);
-        const allModels = new Map();
-        for (const a of list) {
-          const agentId = a.agent_id || a.id;
-          const name = a.metadata?.ref?.name || a.name || agentId;
-          if (agentId && name) allModels.set(agentId, name);
-          for (const m of (a.metadata?.models || a.specs?.models || [])) {
-            const id = m.id || m;
-            if (id) allModels.set(id, m.name || m.label || id);
-          }
-          try {
-            const desc = await acpFetch(port, `/agents/${agentId}/descriptor`);
-            const enumVals = desc?.specs?.config?.properties?.model?.enum || desc?.specs?.input?.properties?.model?.enum || [];
-            for (const v of enumVals) allModels.set(v, v);
-          } catch (_) {}
-        }
-        if (allModels.size > 0) {
-          const models = Array.from(allModels.entries()).map(([id, label]) => ({ id, label }));
-          modelCache.set(p.id, { models, ts: Date.now() });
-          return { models };
-        }
-      } catch (_) {}
-    }
-    const acpAgents = discoveredAgents.filter(x => x.protocol === 'acp' && x.acpPort);
-    for (const acpAgent of acpAgents) {
-      const port = acpAgent.acpPort;
-      try {
-        const desc = await acpFetch(port, `/agents/${p.id}/descriptor`);
-        if (desc) {
-          const enumVals = desc?.specs?.config?.properties?.model?.enum || desc?.specs?.input?.properties?.model?.enum || [];
-          if (enumVals.length > 0) {
-            const models = enumVals.map(v => ({ id: v, label: v }));
-            modelCache.set(p.id, { models, ts: Date.now() });
-            return { models };
-          }
-          const name = desc?.metadata?.ref?.name;
-          if (name) { const models = [{ id: p.id, label: name }]; modelCache.set(p.id, { models, ts: Date.now() }); return { models }; }
-        }
-      } catch (_) {}
-    }
-    const apiModels = await fetchModelsFromAPI(p.id);
-    if (apiModels && apiModels.length > 0) {
-      modelCache.set(p.id, { models: apiModels, ts: Date.now() });
-      return { models: apiModels };
-    }
-    return { models: [] };
-  });
+  router.handle('agent.models', async (p) => {
+    const cached = modelCache.get(p.id);
+    if (cached && (Date.now() - cached.ts) < 300000) return { models: cached.models };
+    let models = [];
+    if (p.id === 'claude-code') {
+      models = [
+        { id: 'claude-haiku', label: 'Haiku' },
+        { id: 'claude-sonnet', label: 'Sonnet' },
+        { id: 'claude-opus', label: 'Opus' }
+      ];
+    } else {
+      const agent = discoveredAgents.find(x => x.id === p.id);
+      if (agent?.protocol === 'acp' && agent.acpPort) {
+        try {
+          const data = await acpFetch(agent.acpPort, '/models');
+          const list = data?.data || data?.models || (Array.isArray(data) ? data : []);
+          models = list.map(m => ({ id: m.id || m.model_id, label: m.name || m.display_name || m.id || m.model_id })).filter(m => m.id);
+        } catch (_) {}
+      }
+    }
+    if (models.length > 0) modelCache.set(p.id, { models, ts: Date.now() });
+    return { models };
+  });
 
   router.handle('agent.search', (p) => db.searchAgents(discoveredAgents, p.query || p));
 

package/package.json

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

package/server.js

@@ -411,22 +411,13 @@ function discoverAgents() {
 
 // Function to discover agents from external ACP servers
 async function discoverExternalACPServers() {
-  // Default ACP servers to query (excluding local server to prevent recursion)
-  const acpServers = [
-    'http://localhost:8080',         // Common default ACP port
-  ];
-  
   const externalAgents = [];
-  for (const serverUrl of acpServers) {
+  for (const agent of discoveredAgents.filter(a => a.protocol === 'acp' && a.acpPort)) {
     try {
-      console.log(`Querying ACP agents from: ${serverUrl}`);
-      const agents = await queryACPServerAgents(serverUrl);
+      const agents = await queryACPServerAgents(`http://localhost:${agent.acpPort}`);
       externalAgents.push(...agents);
-    } catch (error) {
-      console.error(`Failed to query ${serverUrl}:`, error.message);
-    }
+    } catch (_) {}
   }
-  
   return externalAgents;
 }
 
@@ -435,53 +426,34 @@ initializeDescriptors(discoveredAgents);
 
 const modelCache = new Map();
 
-function modelIdToLabel(id) {
-  const base = id.replace(/^claude-/, '').replace(/-\d{8}$/, '');
-  const m = base.match(/^(\w+)-(\d+)(?:-(\d+))?$/);
-  if (m) return `${m[1].charAt(0).toUpperCase() + m[1].slice(1)} ${m[3] ? m[2] + '.' + m[3] : m[2]}`;
-  return base.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
-}
-
 async function getModelsForAgent(agentId) {
   const cached = modelCache.get(agentId);
-  if (cached && Date.now() - cached.timestamp < 3600000) return cached.models;
-  let models = null;
+  if (cached && Date.now() - cached.timestamp < 300000) return cached.models;
+  let models = [];
   if (agentId === 'claude-code') {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (apiKey) {
-      try {
-        const res = await fetch('https://api.anthropic.com/v1/models', {
-          headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01' },
-          signal: AbortSignal.timeout(8000)
-        });
-        if (res.ok) {
-          const data = await res.json();
-          const items = (data.data || []).filter(m => m.id && m.id.startsWith('claude-'));
-          if (items.length > 0) models = items.map(m => ({ id: m.id, label: m.display_name || modelIdToLabel(m.id) }));
-        }
-      } catch (_) {}
-    }
-  } else if (agentId === 'gemini') {
-    const apiKey = process.env.GOOGLE_GENAI_API_KEY;
-    if (apiKey) {
+    models = [
+      { id: 'claude-haiku', label: 'Haiku' },
+      { id: 'claude-sonnet', label: 'Sonnet' },
+      { id: 'claude-opus', label: 'Opus' }
+    ];
+  } else {
+    const agent = discoveredAgents.find(a => a.id === agentId);
+    if (agent?.protocol === 'acp' && agent.acpPort) {
       try {
-        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`, {
-          signal: AbortSignal.timeout(8000)
+        const res = await fetch(`http://localhost:${agent.acpPort}/models`, {
+          headers: { 'Content-Type': 'application/json' },
+          signal: AbortSignal.timeout(3000)
         });
         if (res.ok) {
           const data = await res.json();
-          const items = (data.models || []).filter(m => m.name && m.name.includes('gemini'));
-          if (items.length > 0) models = items.map(m => {
-            const id = m.name.replace(/^models\//, '');
-            return { id, label: id.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase()) };
-          });
+          const list = data?.data || data?.models || (Array.isArray(data) ? data : []);
+          models = list.map(m => ({ id: m.id || m.model_id, label: m.name || m.display_name || m.id || m.model_id })).filter(m => m.id);
         }
       } catch (_) {}
     }
   }
-  const result = models || [];
-  modelCache.set(agentId, { models: result, timestamp: Date.now() });
-  return result;
+  modelCache.set(agentId, { models, timestamp: Date.now() });
+  return models;
 }
 
 const GEMINI_SCOPES = [
@@ -3851,7 +3823,7 @@ registerConvHandlers(wsRouter, {
 });
 
 registerSessionHandlers(wsRouter, {
-  db: queries, discoveredAgents, getModelsForAgent, modelCache,
+  db: queries, discoveredAgents, modelCache,
   getAgentDescriptor, activeScripts, broadcastSync,
   startGeminiOAuth, geminiOAuthState: () => geminiOAuthState
 });