onbuzz 4.10.0 → 5.0.0

package/src/core/orchestrator.js

@@ -247,7 +247,7 @@ class Orchestrator {
    * @private
    */
   async _handleCreateAgent(request) {
-    const { name, systemPrompt, model, capabilities, dynamicModelRouting, platformProvided, directoryAccess } = request.payload;
+    const { name, systemPrompt, model, capabilities, dynamicModelRouting, platformProvided, directoryAccess, toolConfig, skills } = request.payload;
     
     this.logger.info('Creating agent with payload', {
       name,
@@ -269,6 +269,20 @@ class Orchestrator {
       dynamicModelRouting,
       platformProvided,
       directoryAccess,
+      // Per-tool config from the creation UI (e.g. Overlord's most-permissive
+      // platformcontrol). Forwarded only when present so we don't clobber the
+      // agentPool default with `undefined`. agentPool.createAgent reads
+      // config.toolConfig and stores it keyed by tool id.
+      ...(toolConfig !== undefined ? { toolConfig } : {}),
+      // Skill NAMES the agent references. agentPool.createAgent reads
+      // config.skills to inject the skill index into the system prompt
+      // (agentPool.js:119) and persists them (agentPool.js:193). The
+      // marketplace install path bundles the skill CONTENT separately and
+      // installs it BEFORE this create call, so the skill definitions
+      // already exist on disk by the time we wire these names. Normalize
+      // to an array — a malformed/omitted value becomes [] rather than
+      // poisoning the persisted agent with a non-array.
+      skills: Array.isArray(skills) ? skills : [],
       sessionId: request.sessionId,
       projectDir: request.projectDir
     });

package/src/core/stateManager.js

@@ -16,6 +16,58 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { getUserDataPaths, ensureUserDataDirs } from '../utilities/userDataDir.js';
 
+/**
+ * Extract the agent-list "first user message" snippet from a messages array.
+ * Pure + side-effect-free so it can run both at index-write time (over the
+ * agent's in-memory conversation) and at list-backfill time (over a parsed
+ * conversations file). Returns a ≤120-char, ≤2-line snippet, or null when
+ * there is no usable first user message.
+ *
+ * @param {Array<object>} messages
+ * @returns {string|null}
+ */
+export function extractFirstUserMessageSnippet(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return null;
+  const firstUser = messages.find(m =>
+    m && m.role === 'user' && m.content && m.type !== 'task-boundary'
+  );
+  if (!firstUser) return null;
+  const text = typeof firstUser.content === 'string'
+    ? firstUser.content
+    : Array.isArray(firstUser.content)
+      ? firstUser.content.filter(b => b && b.type === 'text').map(b => b.text).join('\n')
+      : null;
+  if (!text) return null;
+  const lines = text.split('\n').filter(l => l.trim());
+  const snippet = lines.slice(0, 2).join('\n');
+  return snippet.length > 120 ? snippet.slice(0, 117) + '...' : snippet;
+}
+
+/**
+ * Run async task-thunks with a bounded concurrency so a list of slow I/O
+ * tasks (e.g. reading conversations files) executes in parallel batches
+ * instead of strictly one-at-a-time. Preserves result order. Never rejects
+ * for an individual task — that's the caller's responsibility inside the
+ * thunk; this just bounds fan-out.
+ *
+ * @param {Array<() => Promise<any>>} taskFns
+ * @param {number} limit
+ * @returns {Promise<any[]>}
+ */
+export async function runWithConcurrency(taskFns, limit) {
+  const results = new Array(taskFns.length);
+  let next = 0;
+  const width = Math.max(1, Math.min(limit || 1, taskFns.length));
+  const worker = async () => {
+    while (next < taskFns.length) {
+      const idx = next++;
+      results[idx] = await taskFns[idx]();
+    }
+  };
+  await Promise.all(Array.from({ length: width }, worker));
+  return results;
+}
+
 class StateManager {
   constructor(config, logger) {
     this.config = config;
@@ -306,7 +358,7 @@ class StateManager {
       agentIndex = {};
     }
     
-    agentIndex[agent.id] = {
+    const entry = {
       name: agent.name,
       type: agent.type,
       stateFile: `agents/agent-${agent.id}-state.json`,
@@ -316,7 +368,21 @@ class StateManager {
       status: agent.status,
       capabilities: agent.capabilities || []
     };
-    
+
+    // Cache the agent-list snippet here, while the conversation is already in
+    // memory — this is what lets the load modal render WITHOUT re-parsing
+    // (potentially MB-sized) conversations files per agent on every open.
+    // Compute from the live conversation; if it isn't available on this agent
+    // object, preserve any previously cached snippet. We only persist a REAL
+    // (string) value — a transient null (conversation not loaded here) must
+    // not clobber the cache or mask the on-disk source of truth; the list
+    // path will backfill a genuine "no message" as null on a cache miss.
+    const computed = extractFirstUserMessageSnippet(agent.conversations?.full?.messages);
+    const snippet = computed ?? agentIndex[agent.id]?.firstUserMessage;
+    if (snippet !== undefined && snippet !== null) entry.firstUserMessage = snippet;
+
+    agentIndex[agent.id] = entry;
+
     await this.saveJSON(indexFile, agentIndex);
   }
 
@@ -1491,7 +1557,12 @@ class StateManager {
           conversationsFile: info.conversationsFile,
           capabilities: info.capabilities || [],
           isLoaded: activeAgentIds.includes(agentId),
-          canImport: !activeAgentIds.includes(agentId)
+          canImport: !activeAgentIds.includes(agentId),
+          // Cached snippet from the index. `undefined` here (key absent on
+          // legacy/orphan entries) signals a cache MISS so enrichment reads
+          // the conversations file once and backfills it; a defined value
+          // (string OR null) is a cache HIT and skips all disk I/O.
+          firstUserMessage: info.firstUserMessage
         });
       }
 
@@ -1570,8 +1641,9 @@ class StateManager {
         return dateB - dateA;
       });
 
-      // Enrich agents with firstUserMessage snippet
-      await this._enrichAgentsWithSnippets(agents, agentPool);
+      // Enrich agents with firstUserMessage snippet (cache-first; only
+      // cache-miss agents touch disk, and they get backfilled into the index).
+      await this._enrichAgentsWithSnippets(agents, agentPool, projectDir);
 
       this.logger.info(`Found ${agents.length} available agents (${agents.filter(a => a.isLoaded).length} active, ${agents.filter(a => !a.isLoaded).length} archived)`);
 
@@ -1583,51 +1655,93 @@ class StateManager {
   }
 
   /**
-   * Enrich agent list with firstUserMessage snippets.
-   * For loaded agents, reads from agentPool. For archived agents, peeks into conversations file.
+   * Enrich the agent list with firstUserMessage snippets — CACHE-FIRST.
+   *
+   *   - Loaded agents: read from the in-memory agentPool (free, always live).
+   *   - Archived agents with a cached snippet (defined value carried from the
+   *     index — string OR null): use it as-is, zero disk I/O.
+   *   - Archived agents on a cache MISS (snippet === undefined — legacy index
+   *     entry or a just-recovered orphan): read the conversations file ONCE,
+   *     extract the snippet, and queue it to be backfilled into the index so
+   *     every subsequent open is a cache hit.
+   *
+   * Cache-miss reads run with bounded concurrency rather than strictly
+   * sequentially. After the first warm-up, this method performs NO
+   * conversations-file reads for archived agents — the whole point of the fix.
+   *
+   * @param {Array<object>} agents
+   * @param {object} agentPool
+   * @param {string} [projectDir]
    */
-  async _enrichAgentsWithSnippets(agents, agentPool) {
-    const extractSnippet = (messages) => {
-      if (!messages || messages.length === 0) return null;
-      const firstUser = messages.find(m =>
-        m.role === 'user' && m.content && m.type !== 'task-boundary'
-      );
-      if (!firstUser) return null;
-      const text = typeof firstUser.content === 'string'
-        ? firstUser.content
-        : Array.isArray(firstUser.content)
-          ? firstUser.content.filter(b => b.type === 'text').map(b => b.text).join('\n')
-          : null;
-      if (!text) return null;
-      const lines = text.split('\n').filter(l => l.trim());
-      const snippet = lines.slice(0, 2).join('\n');
-      return snippet.length > 120 ? snippet.slice(0, 117) + '...' : snippet;
-    };
+  async _enrichAgentsWithSnippets(agents, agentPool, projectDir) {
+    const backfilled = [];
 
-    for (const agent of agents) {
+    const tasks = agents.map((agent) => async () => {
       try {
         if (agent.isLoaded && agentPool) {
-          // For loaded agents, get from the in-memory agent
+          // Loaded → always reflect live in-memory conversation.
           const liveAgent = await agentPool.getAgent(agent.agentId);
           if (liveAgent) {
-            agent.firstUserMessage = extractSnippet(liveAgent.conversations?.full?.messages);
-            continue;
+            agent.firstUserMessage = extractFirstUserMessageSnippet(liveAgent.conversations?.full?.messages);
+            return;
           }
         }
-        // For archived agents, peek into the conversations file on disk
+        // Archived cache HIT — a defined snippet (string or null) already
+        // travelled from the index. Skip disk entirely.
+        if (agent.firstUserMessage !== undefined) return;
+
+        // Archived cache MISS — read the conversations file ONCE, then queue
+        // the result (string or null) for backfill into the index.
         if (agent.conversationsFile) {
           const convPath = path.join(this.stateDirectory, agent.conversationsFile);
           try {
             const convData = await this.loadJSON(convPath);
             const messages = convData?.conversations?.full?.messages || convData?.full?.messages;
-            agent.firstUserMessage = extractSnippet(messages);
+            agent.firstUserMessage = extractFirstUserMessageSnippet(messages);
+            backfilled.push(agent);
           } catch {
-            // File may not exist — that's fine
+            // File may not exist — leave snippet undefined, don't cache.
           }
         }
       } catch {
-        // Non-critical — just skip this agent's snippet
+        // Non-critical — just skip this agent's snippet.
       }
+    });
+
+    await runWithConcurrency(tasks, 8);
+
+    // Persist freshly-computed snippets so the next list is a pure cache hit.
+    if (backfilled.length) {
+      await this._persistAgentSnippets(backfilled, projectDir);
+    }
+  }
+
+  /**
+   * Write computed firstUserMessage snippets back into the agent index so
+   * they're served from cache on subsequent list calls. Writes the key even
+   * when the value is null (a genuine "no first user message") so that case
+   * is cached too and never re-read. One index write for the whole batch;
+   * best-effort (a failure here only costs a future cache miss).
+   *
+   * @param {Array<{agentId: string, firstUserMessage: string|null}>} agents
+   * @param {string} [projectDir]
+   * @private
+   */
+  async _persistAgentSnippets(agents, projectDir) {
+    try {
+      const indexFile = path.join(this.stateDirectory, this.stateFiles.agentIndex);
+      const agentIndex = await this.loadAgentIndex(projectDir);
+      let changed = false;
+      for (const agent of agents) {
+        const entry = agentIndex[agent.agentId];
+        if (entry) {
+          entry.firstUserMessage = agent.firstUserMessage ?? null;
+          changed = true;
+        }
+      }
+      if (changed) await this.saveJSON(indexFile, agentIndex);
+    } catch (err) {
+      this.logger.warn(`Failed to persist agent snippets to index: ${err.message}`);
     }
   }
 

package/src/interfaces/webServer.js

@@ -4438,6 +4438,88 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       }
     });
 
+    // Get full agent config by id. Required by the marketplace publish
+    // flow (PublishItemModal): the in-memory `agents` cache in the UI
+    // is a list-summary populated by listActiveAgents, but archived /
+    // unloaded agents are missing from it, and even active-agent entries
+    // can drift from the canonical persisted shape. The publisher
+    // round-trips through this endpoint so the payload it ships matches
+    // exactly what install would need to reconstruct the agent.
+    //
+    // Resolution order:
+    //   1. agentPool — live agent (best, includes runtime fields)
+    //   2. state file on disk — archived agent
+    //
+    // Returns: { success, agent: { id, name, type, systemPrompt,
+    //                              originalSystemPrompt, skills,
+    //                              capabilities, preferredModel,
+    //                              currentModel, dynamicModelRouting,
+    //                              routingStrategy } }
+    // 404 when neither source has the id.
+    this.app.get('/api/agents/:agentId', async (req, res) => {
+      try {
+        const { agentId } = req.params;
+        if (!agentId) {
+          return res.status(400).json({ success: false, error: 'agentId is required' });
+        }
+        const projectDir = this.orchestrator.config.project?.directory || process.cwd();
+
+        // 1. Live agent in the pool
+        const live = await this.orchestrator.agentPool.getAgent(agentId);
+        if (live) {
+          return res.json({
+            success: true,
+            agent: {
+              id: live.id,
+              name: live.name,
+              type: live.type || 'user-created',
+              systemPrompt: live.systemPrompt || live.originalSystemPrompt || '',
+              originalSystemPrompt: live.originalSystemPrompt || live.systemPrompt || '',
+              skills: live.skills || [],
+              capabilities: live.capabilities || [],
+              preferredModel: live.preferredModel || live.currentModel || null,
+              currentModel: live.currentModel || live.preferredModel || null,
+              dynamicModelRouting: live.dynamicModelRouting || false,
+              routingStrategy: live.routingStrategy || '',
+              toolConfig: live.toolConfig || {},
+            },
+          });
+        }
+
+        // 2. Archived agent — load from state file
+        try {
+          const agentsDir = this.orchestrator.stateManager.getAgentsDir();
+          const stateFile = path.join(agentsDir, `agent-${agentId}-state.json`);
+          const stateData = await this.orchestrator.stateManager.loadJSON(stateFile);
+          const state = stateData.state || stateData;
+          return res.json({
+            success: true,
+            agent: {
+              id: agentId,
+              name: state.name || agentId,
+              type: state.type || 'user-created',
+              systemPrompt: state.systemPrompt || state.originalSystemPrompt || '',
+              originalSystemPrompt: state.originalSystemPrompt || state.systemPrompt || '',
+              skills: state.skills || [],
+              capabilities: state.capabilities || [],
+              preferredModel: state.preferredModel || state.currentModel || null,
+              currentModel: state.currentModel || state.preferredModel || null,
+              dynamicModelRouting: state.dynamicModelRouting || false,
+              routingStrategy: state.routingStrategy || '',
+              toolConfig: state.toolConfig || {},
+            },
+          });
+        } catch {
+          /* fall through to 404 */
+        }
+
+        return res.status(404).json({ success: false, error: `Agent ${agentId} not found` });
+      } catch (error) {
+        this.logger.error('Failed to get agent', { error: error.message });
+        return res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
     // Get agent metadata for preview
     this.app.get('/api/agents/:agentId/metadata', async (req, res) => {
       try {

package/src/services/__tests__/composioService.test.js

@@ -621,7 +621,7 @@ describe('composioService — listTools', () => {
   // toolkitSlug/displayName. We need the raw catalog shape, so we call
   // REST directly.
 
-  test('forwards toolkit_slugs + user_id to REST', async () => {
+  test('forwards toolkit_slug (singular) + user_id to REST', async () => {
     const stub = stubFetch({
       '/api/v3.1/tools': [[
         { slug: 'GITHUB_CREATE_AN_ISSUE', display_name: 'Create Issue',
@@ -641,7 +641,10 @@ describe('composioService — listTools', () => {
       expect(r.tools[0].input).toEqual({ type: 'object' });
       expect(r.tools[0].parameters).toEqual({ type: 'object' });
       const call = stub.calls.find(c => c.path === '/api/v3.1/tools');
-      expect(call.query.toolkit_slugs).toBe('github');
+      // Composio filters on `toolkit_slug` (singular). The plural form is
+      // silently ignored and returns the entire catalog — see listTools.
+      expect(call.query.toolkit_slug).toBe('github');
+      expect(call.query.toolkit_slugs).toBeUndefined();
       expect(call.query.user_id).toBe('operator');
     } finally { stub.restore(); }
   });
@@ -655,7 +658,7 @@ describe('composioService — listTools', () => {
     try {
       await composioService.listTools('github');
       const call = stub.calls.find(c => c.path === '/api/v3.1/tools');
-      expect(call.query.toolkit_slugs).toBe('github');
+      expect(call.query.toolkit_slug).toBe('github');
       expect(call.query.user_id).toBeUndefined();
     } finally { stub.restore(); }
   });
@@ -679,6 +682,8 @@ describe('composioService — execute', () => {
     expect(client.tools.execute).toHaveBeenCalledWith('GITHUB_CREATE_AN_ISSUE', {
       userId: 'operator',
       arguments: { owner: 'acme', repo: 'api', title: 'Bug', body: '…' },
+      version: 'latest',
+      dangerouslySkipVersionCheck: true,
     });
   });
 

package/src/services/composioService.js

@@ -687,8 +687,18 @@ export async function listTools(toolkitSlug, userId) {
   if (!apiKey) return { success: false, error: 'No Composio API key configured.' };
   if (!toolkitSlug) return { success: false, error: 'listTools: toolkitSlug is required.' };
   try {
+    // Composio's /api/v3.1/tools filter param is `toolkit_slug` (SINGULAR).
+    // We previously sent `toolkit_slugs` (plural), which the API silently
+    // ignores — so every list-tools / get-action-schema / find-action
+    // substring-fallback call paginated the ENTIRE ~5000-tool catalog
+    // (~90s, all toolkits) instead of just the requested one. That ~90s
+    // call never returned within an agent iteration, so the agent kept
+    // re-issuing list-tools/find-action and never reached execute — the
+    // observed Gmail death-loop. Verified live: `toolkit_slug=gmail`
+    // returns only GMAIL_* tools in <1s; `toolkit_slugs=gmail` returns
+    // 1Password et al. unfiltered.
     const items = await _restListPaginated(apiKey, '/api/v3.1/tools', {
-      toolkit_slugs: toolkitSlug,
+      toolkit_slug: toolkitSlug,
       ...(userId ? { user_id: userId } : {}),
     });
     const tools = items.map(_camelizeTool);
@@ -708,7 +718,15 @@ export async function execute(userId, toolkitSlug, actionSlug, args = {}) {
   const { client, error } = await getClient();
   if (error) return { success: false, error };
   try {
-    const result = await client.tools?.execute?.(actionSlug, { userId, arguments: args });
+    // version:'latest' + dangerouslySkipVersionCheck — composio-core 0.6.x
+    // rejects manual execution with "Toolkit version not specified" unless a
+    // version is given. Run the toolkit's current version.
+    const result = await client.tools?.execute?.(actionSlug, {
+      userId,
+      arguments: args,
+      version: 'latest',
+      dangerouslySkipVersionCheck: true,
+    });
     return {
       success: result?.successful !== false,
       output: result?.data ?? result?.output ?? result,