onbuzz 4.0.2 → 4.2.0

package/src/core/agentPool.js

@@ -161,6 +161,16 @@ class AgentPool {
       status: AGENT_STATUS.ACTIVE,
       capabilities: config.capabilities || [],
       directoryAccess: directoryAccess, // Directory access configuration
+      // Per-tool configuration — keyed by tool id (e.g., 'terminal',
+      // 'filesystem'). When a tool is instantiated for this agent, the
+      // object under toolConfig[toolId] is merged into the tool's
+      // constructor config. Previously tools were constructed from global
+      // defaults only, so there was no way to set per-agent knobs like
+      // terminal allowed-commands, filesystem size limits, web stealth
+      // level, etc. See ToolManager integration in step 2.
+      toolConfig: (config.toolConfig && typeof config.toolConfig === 'object' && !Array.isArray(config.toolConfig))
+        ? { ...config.toolConfig }
+        : {},
       conversations: {
         full: {
           messages: [],
@@ -304,6 +314,24 @@ class AgentPool {
       });
     }
 
+    // Validate per-tool config if being updated. Must be a plain object
+    // keyed by tool id; each value is an object of config overrides that
+    // will be merged into the tool's constructor config at instantiation.
+    // We don't validate individual tool schemas here — that happens at
+    // tool construction time where the tool knows its own shape.
+    if (updates.toolConfig !== undefined) {
+      if (updates.toolConfig === null
+          || typeof updates.toolConfig !== 'object'
+          || Array.isArray(updates.toolConfig)) {
+        throw new Error('Invalid toolConfig: must be a plain object keyed by tool id');
+      }
+      for (const [toolId, cfg] of Object.entries(updates.toolConfig)) {
+        if (cfg !== null && (typeof cfg !== 'object' || Array.isArray(cfg))) {
+          throw new Error(`Invalid toolConfig.${toolId}: must be an object or null`);
+        }
+      }
+    }
+
     // If originalSystemPrompt is being updated (user edited the raw prompt), store it
     // and use it as the base for enhancement. Otherwise use the existing originalSystemPrompt.
     if (updates.originalSystemPrompt !== undefined) {
@@ -441,6 +469,15 @@ class AgentPool {
     // Persist the updated agent state
     await this.stateManager.persistAgentState(updatedAgent);
 
+    // Record the mode transition (both directions) into the scheduler's
+    // per-agent history. This is where UI-toggle and programmatic
+    // update_agent flips land — internal scheduler flips go through
+    // scheduler._transitionMode directly. Both feed the same ring buffer
+    // and the same /scheduler visualizer row.
+    if (updates.mode !== undefined && agent.mode !== updates.mode && this.scheduler?.recordModeTransition) {
+      this.scheduler.recordModeTransition(agentId, agent.mode, updates.mode, 'user-toggle');
+    }
+
     // CRITICAL: If agent was switched to AGENT mode, add it to scheduler
     if (updates.mode === AGENT_MODES.AGENT && this.scheduler) {
       // CRITICAL FIX: Use the session ID from updates first, then agent's sessionId
@@ -583,6 +620,7 @@ class AgentPool {
       platformProvided: agent.platformProvided,
       capabilities: agent.capabilities,
       directoryAccess: agent.directoryAccess,
+      toolConfig: agent.toolConfig || {},
       lastActivity: agent.lastActivity,
       isPaused: this._isAgentPaused(agent),
       pausedUntil: agent.pausedUntil,
@@ -1288,6 +1326,69 @@ class AgentPool {
   // Now using the new messageQueues system with AgentScheduler
   // Inter-agent messages are queued via addInterAgentMessage() method
 
+  /**
+   * Wake an agent out of any paused/delayed state because a message has
+   * arrived for it. Shared by addUserMessage / addInterAgentMessage /
+   * addToolResult — every inbound path MUST route through this to avoid
+   * the "silent queue into a delayed agent" bug where the recipient never
+   * wakes up and the message sits until the scheduler back-off naturally
+   * expires.
+   *
+   * Rationale: delays/pauses are "leave this agent alone" signals set by
+   * the scheduler on error back-off or by the agentDelayTool for timed
+   * waits. Any caller going to the trouble of actually addressing the
+   * agent is an explicit "act now" signal that overrides the wait.
+   *
+   * @param {Object} agent - Agent object (already fetched)
+   * @param {string} reason - Source label for logs (e.g. 'user-message',
+   *   'inter-agent-message', 'tool-result')
+   * @returns {Promise<{wasPaused:boolean, hadDelay:boolean, hadPausedUntil:boolean}>}
+   * @private
+   */
+  async _wakeAgentForMessage(agent, reason) {
+    const info = { wasPaused: false, hadDelay: false, hadPausedUntil: false };
+    if (!agent) return info;
+
+    // Auto-resume explicitly paused agent.
+    if (agent.status === AGENT_STATUS.PAUSED) {
+      info.wasPaused = true;
+      this.logger.info(`Auto-resuming paused agent ${agent.id} due to ${reason}`);
+      await this.resumeAgent(agent.id);
+    }
+
+    // Clear scheduler-enforced delay (rate-limit back-off, api-key delay,
+    // builtin webTool delay, etc.). Only clear if actually in the future;
+    // stale past values don't matter but shouldn't trigger a broadcast.
+    if (agent.delayEndTime && new Date(agent.delayEndTime).getTime() > Date.now()) {
+      info.hadDelay = true;
+      agent.delayEndTime = null;
+      this.logger.info(`Cleared scheduler delay for agent ${agent.id} — ${reason} takes precedence`);
+    }
+
+    // Defensive: if pausedUntil is set but status isn't PAUSED (shouldn't
+    // happen but protects against state drift), clear it too.
+    if (agent.pausedUntil && new Date(agent.pausedUntil).getTime() > Date.now()) {
+      info.hadPausedUntil = true;
+      agent.pausedUntil = null;
+    }
+
+    return info;
+  }
+
+  /**
+   * Broadcast a delay-clear to the WS so the UI's delay chip disappears
+   * immediately instead of waiting for the next scheduler tick.
+   * @private
+   */
+  async _broadcastWake(agentId, reason) {
+    if (!this.scheduler?.broadcastAgentStateUpdate) return;
+    try {
+      await this.scheduler.broadcastAgentStateUpdate(agentId, reason);
+    } catch (err) {
+      this.logger.warn(`Failed to broadcast wake for ${agentId}: ${err.message}`);
+    }
+  }
+
   /**
    * Add message to agent's user message queue
    * @param {string} agentId - Agent ID
@@ -1300,25 +1401,10 @@ class AgentPool {
       throw new Error(`Agent not found: ${agentId}`);
     }
 
-    // Auto-resume paused agent when user sends a message
-    if (agent.status === AGENT_STATUS.PAUSED) {
-      this.logger.info(`Auto-resuming paused agent ${agentId} due to user message`);
-      await this.resumeAgent(agentId);
-    }
-
-    // Clear any scheduler-enforced delay when the user explicitly addresses
-    // the agent. Delays are set by the scheduler as a back-off for
-    // rate-limit / network / api-key / builtin-tool-delay situations and
-    // only make sense while the agent is left alone — a new user message is
-    // an explicit signal to act NOW, and waiting out the remaining delay
-    // would feel unresponsive. We clear the field and let the scheduler
-    // pick the agent up on its next tick. Broadcast the state update so
-    // the UI's delay chip disappears immediately.
-    const hadDelay = !!(agent.delayEndTime && new Date(agent.delayEndTime).getTime() > Date.now());
-    if (hadDelay) {
-      agent.delayEndTime = null;
-      this.logger.info(`Cleared scheduler delay for agent ${agentId} — user message takes precedence`);
-    }
+    // Any inbound message — user, inter-agent, or tool-result — takes
+    // precedence over scheduler back-off and manual pauses. See
+    // _wakeAgentForMessage for the rationale.
+    const wakeInfo = await this._wakeAgentForMessage(agent, 'user-message');
 
     const queuedMessage = {
       ...message,
@@ -1339,12 +1425,8 @@ class AgentPool {
 
     // If we cleared a delay, surface it on the WS so the delay chip in the
     // chat header disappears without waiting for the next scheduler cycle.
-    if (hadDelay && this.scheduler?.broadcastAgentStateUpdate) {
-      try {
-        await this.scheduler.broadcastAgentStateUpdate(agentId, 'user-message-clears-delay');
-      } catch (err) {
-        this.logger.warn(`Failed to broadcast delay-clear for ${agentId}: ${err.message}`);
-      }
+    if (wakeInfo.hadDelay) {
+      await this._broadcastWake(agentId, 'user-message-clears-delay');
     }
 
     this.logger.info(`User message queued for agent: ${agentId}`, {
@@ -1365,6 +1447,11 @@ class AgentPool {
       throw new Error(`Agent not found: ${agentId}`);
     }
 
+    // An inter-agent ping from another agent is an explicit "act now"
+    // signal and must override any scheduler back-off or manual pause
+    // on the recipient. See _wakeAgentForMessage.
+    const wakeInfo = await this._wakeAgentForMessage(agent, 'inter-agent-message');
+
     const queuedMessage = {
       ...message,
       id: message.id || message.messageId || `inter-agent-msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -1391,6 +1478,10 @@ class AgentPool {
       });
     }
 
+    if (wakeInfo.hadDelay) {
+      await this._broadcastWake(agentId, 'inter-agent-message-clears-delay');
+    }
+
     this.logger.info(`Inter-agent message queued for agent: ${agentId}`, {
       messageId: queuedMessage.id,
       sender: message.sender || message.senderName,
@@ -1411,6 +1502,13 @@ class AgentPool {
       throw new Error(`Agent not found: ${agentId}`);
     }
 
+    // Tool results are "external async work finished — continue."
+    // If the agent is delayed or paused when a result arrives (e.g. a
+    // long image/video render completes while an unrelated rate-limit
+    // back-off is still in effect) we wake it so the result can be
+    // consumed immediately instead of sitting until the back-off expires.
+    const wakeInfo = await this._wakeAgentForMessage(agent, 'tool-result');
+
     const queuedResult = {
       ...toolResult,
       id: toolResult.id || `tool-result-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -1421,6 +1519,10 @@ class AgentPool {
     agent.messageQueues.toolResults.push(queuedResult);
     await this.persistAgentState(agentId);
 
+    if (wakeInfo.hadDelay) {
+      await this._broadcastWake(agentId, 'tool-result-clears-delay');
+    }
+
     this.logger.debug(`Tool result queued for agent: ${agentId}`, {
       toolId: toolResult.toolId,
       status: toolResult.status,