agentgui 1.0.422 → 1.0.424

package/lib/ws-handlers-session.js

@@ -60,6 +60,14 @@ function checkAgentAuth(agent) {
   return s;
 }
 
+async function acpFetch(port, path, body = null) {
+  const opts = { headers: { 'Content-Type': 'application/json' }, signal: AbortSignal.timeout(3000) };
+  if (body !== null) { opts.method = 'POST'; opts.body = JSON.stringify(body); }
+  const res = await fetch(`http://localhost:${port}${path}`, opts);
+  if (!res.ok) return null;
+  return res.json();
+}
+
 export function register(router, deps) {
   const { db, discoveredAgents, getModelsForAgent, modelCache,
     getAgentDescriptor, activeScripts, broadcastSync, startGeminiOAuth,
@@ -88,51 +96,24 @@ export function register(router, deps) {
   router.handle('sess.exec', (p) => {
     const limit = Math.min(parseInt(p.limit || '1000'), 5000);
     const offset = Math.max(parseInt(p.offset || '0'), 0);
-    const filterType = p.filterType || null;
-    const data = {
-      sessionId: p.id, events: [], total: 0, limit, offset, hasMore: false,
-      metadata: { status: 'pending', startTime: Date.now(), duration: 0, eventCount: 0 }
-    };
-    if (filterType) data.events = data.events.filter(e => e.type === filterType);
-    return data;
+    return { sessionId: p.id, events: [], total: 0, limit, offset, hasMore: false, metadata: { status: 'pending', startTime: Date.now(), duration: 0, eventCount: 0 } };
   });
 
-  router.handle('agent.ls', () => {
-    // Get local agents only (avoid external HTTP calls in WebSocket to prevent recursion)
-    const localAgents = discoveredAgents.map(agent => ({
-      id: agent.id,
-      name: agent.name,
-      icon: agent.icon,
-      path: agent.path,
-      protocol: agent.protocol || 'unknown',
-      description: agent.description || '',
-      status: 'available'
-    }));
-    
-    return { agents: localAgents };
-  });
+  router.handle('agent.ls', () => ({
+    agents: discoveredAgents.map(a => ({
+      id: a.id, name: a.name, icon: a.icon, path: a.path,
+      protocol: a.protocol || 'unknown', description: a.description || '', status: 'available'
+    }))
+  }));
 
   router.handle('agent.subagents', async (p) => {
     const agent = discoveredAgents.find(x => x.id === p.id);
-    if (!agent) return { subAgents: [] };
+    if (!agent || agent.protocol !== 'acp') return { subAgents: [] };
     try {
-      const port = agent.acpPort || 8080;
-      const res = await fetch(`http://localhost:${port}/agents/search`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({}),
-        signal: AbortSignal.timeout(3000)
-      });
-      if (!res.ok) return { subAgents: [] };
-      const data = await res.json();
-      const subAgents = (data.agents || []).map(a => ({
-        id: a.agent_id || a.id,
-        name: a.metadata?.ref?.name || a.name || a.agent_id || a.id
-      }));
-      return { subAgents };
-    } catch (_) {
-      return { subAgents: [] };
-    }
+      const data = await acpFetch(agent.acpPort || 8080, '/agents/search', {});
+      const list = Array.isArray(data) ? data : (data?.agents || []);
+      return { subAgents: list.map(a => ({ id: a.agent_id || a.id, name: a.metadata?.ref?.name || a.name || a.agent_id || a.id })) };
+    } catch (_) { return { subAgents: [] }; }
   });
 
   router.handle('agent.get', (p) => {
@@ -150,6 +131,59 @@ export function register(router, deps) {
   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') {
+      const port = agent.acpPort || 8080;
+      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');
+    for (const acpAgent of acpAgents) {
+      const port = acpAgent.acpPort || 8080;
+      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 (_) {}
+    }
     try {
       const models = await getModelsForAgent(p.id);
       modelCache.set(p.id, { models, ts: Date.now() });

package/package.json

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

package/static/js/client.js

@@ -363,6 +363,7 @@ class AgentGUIClient {
       this.ui.cliSelector.addEventListener('change', () => {
         if (!this._agentLocked) {
           this.loadSubAgentsForCli(this.ui.cliSelector.value);
+          this.loadModelsForAgent(this.ui.cliSelector.value);
           this.saveAgentAndModelToConversation();
         }
       });
@@ -1874,6 +1875,7 @@ class AgentGUIClient {
           .map(a => `<option value="${a.id}">${a.name}</option>`)
           .join('');
         this.ui.agentSelector.style.display = 'inline-block';
+        this.loadModelsForAgent(this.getEffectiveAgentId());
       }
     } catch (_) {
       // No sub-agents available for this CLI tool — keep hidden