onbuzz 4.9.0 → 4.9.5

package/src/core/agentPool.js

@@ -868,74 +868,86 @@ class AgentPool {
    */
 
   /**
-   * Delete an agent and clean up its resources
+   * Delete an agent and clean up its resources.
+   *
+   * Best-effort / idempotent: if the agent isn't currently loaded in
+   * memory we skip the live-state cleanup (attachments, visual editor,
+   * terminal processes — those only exist for loaded agents anyway)
+   * and go straight to clearing persistent state. This is how the
+   * bulk-delete UI can remove agents that were unloaded earlier in
+   * the session or that survived a process restart with no in-memory
+   * footprint. `stateManager.deleteAgentState` is itself ENOENT-safe,
+   * so deleting an already-gone agent is a no-op success.
+   *
    * @param {string} agentId - Agent identifier
    * @returns {Promise<Object>} Deletion result
    */
   async deleteAgent(agentId) {
     const agent = await this.getAgent(agentId);
-    if (!agent) {
-      throw new Error(`Agent not found: ${agentId}`);
-    }
+    const wasLoaded = !!agent;
 
-    // Clean up file attachments with reference counting
-    if (this.fileAttachmentService) {
-      try {
-        await this.fileAttachmentService.deleteAgentAttachments(agentId);
-        this.logger.info(`File attachments cleaned up for agent: ${agentId}`);
-      } catch (error) {
-        this.logger.warn(`Failed to clean up file attachments for agent: ${error.message}`, { agentId });
-        // Continue with agent deletion even if attachment cleanup fails
+    if (wasLoaded) {
+      // Clean up file attachments with reference counting
+      if (this.fileAttachmentService) {
+        try {
+          await this.fileAttachmentService.deleteAgentAttachments(agentId);
+          this.logger.info(`File attachments cleaned up for agent: ${agentId}`);
+        } catch (error) {
+          this.logger.warn(`Failed to clean up file attachments for agent: ${error.message}`, { agentId });
+          // Continue with agent deletion even if attachment cleanup fails
+        }
       }
-    }
 
-    // Clear codebase-knowledge cache for this agent — bytes live in
-    // the service's in-memory map; without this the per-agent entry
-    // would persist until the next process restart.
-    try {
-      const { getCodebaseKnowledgeService } = await import('../services/codebaseKnowledgeService.js');
-      getCodebaseKnowledgeService(this.logger).clear(agentId);
-    } catch (e) {
-      this.logger.debug?.('codebase-knowledge clear failed on agent delete', { agentId, error: e.message });
-    }
+      // Clear codebase-knowledge cache for this agent — bytes live in
+      // the service's in-memory map; without this the per-agent entry
+      // would persist until the next process restart.
+      try {
+        const { getCodebaseKnowledgeService } = await import('../services/codebaseKnowledgeService.js');
+        getCodebaseKnowledgeService(this.logger).clear(agentId);
+      } catch (e) {
+        this.logger.debug?.('codebase-knowledge clear failed on agent delete', { agentId, error: e.message });
+      }
 
-    // Clean up visual editor instance
-    try {
-      const visualEditorBridge = getVisualEditorBridge();
-      if (visualEditorBridge.hasInstance(agentId)) {
-        await visualEditorBridge.stopInstance(agentId);
-        this.logger.info(`Visual editor instance cleaned up for agent: ${agentId}`);
+      // Clean up visual editor instance
+      try {
+        const visualEditorBridge = getVisualEditorBridge();
+        if (visualEditorBridge.hasInstance(agentId)) {
+          await visualEditorBridge.stopInstance(agentId);
+          this.logger.info(`Visual editor instance cleaned up for agent: ${agentId}`);
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to clean up visual editor for agent: ${error.message}`, { agentId });
       }
-    } catch (error) {
-      this.logger.warn(`Failed to clean up visual editor for agent: ${error.message}`, { agentId });
-    }
 
-    // Kill any running terminal processes for this agent
-    try {
-      const terminalTool = this.toolsRegistry?.getTool?.('terminal');
-      if (terminalTool && typeof terminalTool.cleanupAgent === 'function') {
-        await terminalTool.cleanupAgent(agentId);
-        this.logger.info(`Terminal processes cleaned up for agent: ${agentId}`);
+      // Kill any running terminal processes for this agent
+      try {
+        const terminalTool = this.toolsRegistry?.getTool?.('terminal');
+        if (terminalTool && typeof terminalTool.cleanupAgent === 'function') {
+          await terminalTool.cleanupAgent(agentId);
+          this.logger.info(`Terminal processes cleaned up for agent: ${agentId}`);
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to clean up terminal processes for agent: ${error.message}`, { agentId });
       }
-    } catch (error) {
-      this.logger.warn(`Failed to clean up terminal processes for agent: ${error.message}`, { agentId });
+
+      // Clean up agent resources
+      this.agents.delete(agentId);
+      this.agentDirectory.delete(agentId);
+      this.pausedAgents.delete(agentId);
+      this.notificationQueue.delete(agentId);
     }
 
-    // Clean up agent resources
-    this.agents.delete(agentId);
-    this.agentDirectory.delete(agentId);
-    this.pausedAgents.delete(agentId);
-    this.notificationQueue.delete(agentId);
-    
-    // Clean up persistent state
+    // Clean up persistent state — runs whether or not the agent was
+    // loaded. deleteAgentState handles missing files gracefully.
     try {
       await this.stateManager.deleteAgentState(agentId);
     } catch (error) {
       this.logger.warn(`Failed to delete agent persistent state: ${error.message}`, { agentId });
     }
-    
+
     this.logger.info(`Agent deleted: ${agentId}`, {
-      agentName: agent.name,
+      agentName: agent?.name || '(not loaded)',
+      wasLoaded,
       totalAgents: this.agents.size
     });
     

package/src/core/agentScheduler.js

@@ -37,6 +37,34 @@ import {
   shouldSkipIteration
 } from '../services/agentActivityService.js';
 
+/**
+ * True iff `text` contains the digit sequence `code` not flanked by other
+ * digits. Used for HTTP status-code detection inside free-text error
+ * messages (e.g. "HTTP 401 Unauthorized" or "got 503 from upstream")
+ * without matching "1401" or "5039".
+ *
+ * Chosen over the regex `/\b401\b/` because (a) `\b` doesn't actually
+ * mean "non-digit boundary" — it means "transition between \w and \W",
+ * which still treats "_401" as a match — and (b) plain string ops are
+ * easier to read and harder to break under future maintenance.
+ *
+ * @param {string} text   The error message, already lowercased.
+ * @param {string} code   The status code as a digit string, e.g. "401".
+ * @returns {boolean}
+ */
+function containsStatusCode(text, code) {
+  let i = 0;
+  while ((i = text.indexOf(code, i)) !== -1) {
+    const before = i === 0 ? '' : text[i - 1];
+    const after  = (i + code.length >= text.length) ? '' : text[i + code.length];
+    const beforeIsDigit = before >= '0' && before <= '9';
+    const afterIsDigit  = after  >= '0' && after  <= '9';
+    if (!beforeIsDigit && !afterIsDigit) return true;
+    i += code.length;
+  }
+  return false;
+}
+
 class AgentScheduler {
   /**
    * Register the Discord service so the scheduler can ask whether a given
@@ -2247,6 +2275,39 @@ class AgentScheduler {
         ? userStreamingPref !== false
         : agent.streamingEnabled !== false; // Default to true
 
+      // ── Auto-recall: silent retrieval injected per turn (Phase 6d.2) ─
+      // When embeddings + autoRecall.enabled, look up high-similarity
+      // memory + reminisce items against the user's most recent message
+      // and append them under "## RELEVANT CONTEXT (auto-recalled)".
+      // Hybrid call path: voluntary `memory.semantic-search` remains the
+      // explicit primitive; this is the silent supplement. Lit-aligned
+      // with the ChatGPT / Anthropic Memory shape — see Phase 6 design.
+      //
+      // Best-effort: failures NEVER block the turn. Gated by:
+      //   - agent has 'memory' capability (no point recalling for an
+      //     agent that can't read/write memories)
+      //   - aiService.augmentSystemPrompt is present (older builds
+      //     without Phase 6d skip cleanly)
+      //   - the helper itself short-circuits on disabled/empty config
+      if (
+        Array.isArray(agent.capabilities) &&
+        agent.capabilities.includes('memory') &&
+        typeof this.aiService?.augmentSystemPrompt === 'function'
+      ) {
+        try {
+          const recentText = typeof lastUserMsg?.content === 'string' ? lastUserMsg.content : '';
+          if (recentText) {
+            enhancedSystemPrompt = await this.aiService.augmentSystemPrompt(
+              enhancedSystemPrompt, agentId, recentText,
+            );
+          }
+        } catch (err) {
+          this.logger.warn?.(`Auto-recall injection failed for agent ${agentId} (continuing without)`, {
+            error: err?.message,
+          });
+        }
+      }
+
       // Native function-call tools for the agent's enabled capabilities.
       // Passed as `options.tools` to the backend. For Responses-API models
       // (codex/o-series/gpt-5-pro) the backend forwards these to Azure so
@@ -2775,18 +2836,69 @@ class AgentScheduler {
       return; // Don't proceed with other error handling
     }
 
-    // Determine failure type and response
+    // Classification. Two reasons we do this here and not at AI-service call
+    // sites: (1) we already have the canonical error object, (2) the
+    // scheduler is the only place that decides "retry vs pause vs alert".
+    //
+    // Persistent vs transient is the key axis: persistent failures need a
+    // human in the loop (broadcast `agent_error` so it reaches the UI and
+    // Telegram); transient failures self-heal (skip the broadcast — they
+    // were the source of the per-minute Telegram floods historically).
     const errorMessage = error.message?.toLowerCase() || '';
 
-    if (errorMessage.includes('api key') || errorMessage.includes('authentication')) {
-      // API key issues - pause agent to prevent infinite retries
+    // Plain string operations only — no regex. Each classifier reads
+    // top-down as a flat list of substring or status-code probes,
+    // making it obvious what's matched and trivial to extend.
+    const isAuthError =
+         errorMessage.includes('api key')
+      || errorMessage.includes('api-key')
+      || errorMessage.includes('api_key')
+      || errorMessage.includes('apikey')
+      || errorMessage.includes('authentication')
+      || errorMessage.includes('unauthorized')
+      || errorMessage.includes('forbidden')
+      || containsStatusCode(errorMessage, '401')
+      || containsStatusCode(errorMessage, '403');
+
+    const isRateLimit =
+         errorMessage.includes('rate limit')
+      || errorMessage.includes('rate-limit')
+      || errorMessage.includes('ratelimit')
+      || errorMessage.includes('too many requests')
+      || containsStatusCode(errorMessage, '429');
+
+    // The bare "busy" branch is acceptable because the cost of a false
+    // positive is just a 2-min quiet retry (no broadcast, no escalation).
+    const isProviderOverload =
+         errorMessage.includes('overload')
+      || errorMessage.includes('capacity')
+      || errorMessage.includes('busy')
+      || containsStatusCode(errorMessage, '529');
+
+    const isGatewayError =
+         errorMessage.includes('service unavailable')
+      || errorMessage.includes('gateway')
+      || errorMessage.includes('upstream')
+      || containsStatusCode(errorMessage, '503')
+      || containsStatusCode(errorMessage, '504');
+
+    const isNetworkError =
+         errorMessage.includes('network')
+      || errorMessage.includes('connection')
+      || errorMessage.includes('econnrefused')
+      || errorMessage.includes('etimedout')
+      || errorMessage.includes('enotfound')
+      || errorMessage.includes('fetch failed');
+
+    if (isAuthError) {
+      // PERSISTENT — only the user can resolve. Long pause + broadcast so
+      // the Telegram fanout (and UI banner) tell them what's wrong.
       this.logger.warn(`Agent ${agentId} paused due to API key issue`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.API_KEY_ERROR_DELAY_MS).toISOString();
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'api-key-error');
 
-      // Add error message to agent's queue
       await this.agentPool.addToolResult(agentId, {
         toolId: 'system-error',
         status: 'failed',
@@ -2794,16 +2906,39 @@ class AgentScheduler {
         timestamp: new Date().toISOString()
       });
 
-    } else if (errorMessage.includes('rate limit') || errorMessage.includes('too many requests')) {
-      // Rate limit - delay agent
+      this._broadcastAgentError(agent, 'API key issue — check Settings → API Keys.', error);
+
+    } else if (isRateLimit) {
+      // TRANSIENT — provider asked us to back off. No broadcast.
       this.logger.warn(`Agent ${agentId} delayed due to rate limiting`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.RATE_LIMIT_DELAY_MS).toISOString();
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'rate-limit');
 
-    } else if (errorMessage.includes('network') || errorMessage.includes('connection')) {
-      // Network issues (non-timeout) - shorter delay and retry
+    } else if (isProviderOverload) {
+      // TRANSIENT — provider is over capacity (e.g. Anthropic 529). No
+      // broadcast: there's nothing actionable on the user's side. Reuse
+      // rate-limit's 2-min delay since the upstream advice is identical:
+      // "back off and try again."
+      this.logger.warn(`Agent ${agentId} delayed due to provider overload`);
+
+      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.RATE_LIMIT_DELAY_MS).toISOString();
+      await this.agentPool.persistAgentState(agentId);
+      await this.broadcastAgentStateUpdate(agentId, 'provider-overload');
+
+    } else if (isGatewayError) {
+      // TRANSIENT — 5xx / gateway / upstream timeout. Reuse the network
+      // 30-second delay; if it's still failing after a few retries it
+      // will eventually fall through to the unknown branch and broadcast.
+      this.logger.warn(`Agent ${agentId} delayed due to gateway/5xx error`);
+
+      agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.NETWORK_ERROR_DELAY_MS).toISOString();
+      await this.agentPool.persistAgentState(agentId);
+      await this.broadcastAgentStateUpdate(agentId, 'gateway-error');
+
+    } else if (isNetworkError) {
+      // TRANSIENT — connectivity. No broadcast.
       this.logger.warn(`Agent ${agentId} delayed due to network issues`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.NETWORK_ERROR_DELAY_MS).toISOString();
@@ -2811,44 +2946,55 @@ class AgentScheduler {
       await this.broadcastAgentStateUpdate(agentId, 'network-error');
 
     } else if (this.isTokenLimitError(errorMessage)) {
-      // Token/context limit error - trigger emergency compaction and retry
+      // Token/context limit error — trigger emergency compaction and retry.
       await this.handleTokenLimitError(agentId, agent, error);
-      return; // Don't add error message or broadcast - will retry after compaction
+      return; // Don't add error message or broadcast — will retry after compaction.
 
     } else {
-      // Unknown error - pause agent and notify
+      // PERSISTENT (unknown shape) — we don't know what to do, so alert.
+      // The Telegram service's _registerErrorBroadcast dedup keeps this
+      // from flooding if the loop persists.
       this.logger.error(`Agent ${agentId} paused due to unknown AI service error: ${error.message}`);
 
       agent.delayEndTime = new Date(Date.now() + SCHEDULER_CONFIG.UNKNOWN_ERROR_DELAY_MS).toISOString();
       await this.agentPool.persistAgentState(agentId);
       await this.broadcastAgentStateUpdate(agentId, 'server-error');
 
-      // Add error message to agent's queue
       await this.agentPool.addToolResult(agentId, {
         toolId: 'system-error',
         status: 'failed',
         error: `AI service error: ${error.message}. Agent temporarily paused.`,
         timestamp: new Date().toISOString()
       });
-    }
 
-    // Broadcast error to UI
-    if (this.webSocketManager && this.webSocketManager.broadcastToSession) {
-      const sessionId = this.getAgentSession(agentId) || agent.sessionId || 'scheduler-session';
-      
-      // FIX: Wrap payload in 'data' field to match UI expectations
-      this.webSocketManager.broadcastToSession(sessionId, {
-        type: 'agent_error',
-        data: {
-          agentId: agentId,
-          error: error.message,
-          recovery: 'Agent temporarily paused for recovery',
-          timestamp: new Date().toISOString()
-        }
-      });
+      this._broadcastAgentError(agent, 'Agent temporarily paused for recovery', error);
     }
   }
 
+  /**
+   * Emit a `type: 'agent_error'` broadcast. Only called from the persistent
+   * failure branches (auth + unknown). Transient branches (rate-limit,
+   * provider-overload, gateway, network) deliberately do NOT broadcast —
+   * those used to flood Telegram every cycle and added no signal because
+   * the user couldn't act on them anyway.
+   *
+   * @private
+   */
+  _broadcastAgentError(agent, recovery, error) {
+    if (!this.webSocketManager || !this.webSocketManager.broadcastToSession) return;
+    const sessionId = this.getAgentSession(agent.id) || agent.sessionId || 'scheduler-session';
+    this.webSocketManager.broadcastToSession(sessionId, {
+      type: 'agent_error',
+      data: {
+        agentId:   agent.id,
+        agentName: agent.name,
+        error:     error.message,
+        recovery,
+        timestamp: new Date().toISOString(),
+      },
+    });
+  }
+
   /**
    * Check if error message indicates a token/context limit error
    * @param {string} errorMessage - Lowercased error message
@@ -2856,7 +3002,7 @@ class AgentScheduler {
    * @private
    */
   isTokenLimitError(errorMessage) {
-    const tokenLimitPatterns = [
+    const substrings = [
       'prompt is too long',
       'tokens',
       'context length',
@@ -2865,15 +3011,15 @@ class AgentScheduler {
       'token limit',
       'max_tokens',
       'context_length_exceeded',
-      'maximum.*exceeded'
     ];
-
-    return tokenLimitPatterns.some(pattern => {
-      if (pattern.includes('.*')) {
-        return new RegExp(pattern).test(errorMessage);
-      }
-      return errorMessage.includes(pattern);
-    });
+    for (const p of substrings) {
+      if (errorMessage.includes(p)) return true;
+    }
+    // Match the old 'maximum.*exceeded' regex case without the regex:
+    // "maximum" followed somewhere later by "exceeded" in the same string.
+    const maxIdx = errorMessage.indexOf('maximum');
+    if (maxIdx !== -1 && errorMessage.indexOf('exceeded', maxIdx) !== -1) return true;
+    return false;
   }
 
   /**

package/src/core/orchestrator.js

@@ -326,30 +326,31 @@ class Orchestrator {
    */
   async _handleDeleteAgent(request) {
     const { agentId } = request.payload;
-    
+
     if (!agentId) {
       throw new Error('Agent ID is required for deletion');
     }
-    
-    // Get agent before deletion to return info
+
+    // Best-effort lookup for logging + response shape. We do NOT throw
+    // when the agent isn't loaded — that breaks bulk-delete against
+    // agents that were unloaded earlier in the session (the original
+    // implementation made the entire group operation fail with
+    // "Failed to delete N agents"). agentPool.deleteAgent now handles
+    // the unloaded case by cleaning up persistent state only.
     const agent = await this.agentPool.getAgent(agentId);
-    if (!agent) {
-      throw new Error(`Agent not found: ${agentId}`);
-    }
-    
-    // Delete the agent
+
     const result = await this.agentPool.deleteAgent(agentId);
-    
+
     this.logger.info(`Agent deleted: ${agentId}`, {
-      agentName: agent.name,
+      agentName: agent?.name || '(not loaded)',
       sessionId: request.sessionId
     });
-    
+
     return {
       success: true,
       deletedAgent: {
-        id: agent.id,
-        name: agent.name
+        id: agentId,
+        name: agent?.name || null,
       },
       ...result
     };

package/src/index.js

@@ -20,6 +20,8 @@ import AgentScheduler from './core/agentScheduler.js';
 import ContextManager from './core/contextManager.js';
 import StateManager from './core/stateManager.js';
 import AIService from './services/aiService.js';
+import { EmbeddingService } from './services/embeddings/embeddingService.js';
+import { getUserDataPaths } from './utilities/userDataDir.js';
 import BudgetService from './services/budgetService.js';
 import ErrorHandler from './services/errorHandler.js';
 import BenchmarkService from './services/benchmarkService.js';
@@ -329,9 +331,29 @@ class LoxiaApplication {
     
     // Set API Key Manager reference in AI Service
     this.aiService.setApiKeyManager(this.apiKeyManager);
-    
+
     // Set Agent Pool reference in AI Service
     this.aiService.setAgentPool(this.agentPool);
+
+    // Embedding Service — opt-in semantic retrieval layer. Boots in the
+    // disabled state by default; loadPersistedConfig() picks up whatever
+    // the user previously chose in Settings.
+    const stateDir = getUserDataPaths().state;
+    this.embeddingService = new EmbeddingService({
+      // Start with the in-memory default (disabled). The settings file
+      // (if present) will override this on the next line.
+      config: this.config?.embeddings || {},
+      apiKeyManager: this.apiKeyManager,
+      baseUrl: this.config?.backend?.baseUrl || this.aiService.baseUrl,
+      stateDir,
+      logger: this.logger,
+    });
+    await this.embeddingService.loadPersistedConfig();
+    this.aiService.setEmbeddingService(this.embeddingService);
+    this.logger.info('[Loxia] Embedding service ready', {
+      provider: this.embeddingService.config.provider,
+      enabled: this.embeddingService.isEnabled,
+    });
     
     // Initialize Model Routing Services
     this.benchmarkService = new BenchmarkService(this.config, this.logger);
@@ -569,6 +591,14 @@ class LoxiaApplication {
       if (typeof platformControlTool.setStateManager === 'function') {
         platformControlTool.setStateManager(this.stateManager);
       }
+      // Memory tool's team-pool actions (publish/search/unpublish) need
+      // StateManager for the team-membership ACL check. The wiring is
+      // optional: when StateManager isn't attached, team-scoped actions
+      // refuse cleanly rather than defaulting open.
+      const memoryTool = this.toolsRegistry?.getTool?.('memory');
+      if (memoryTool && typeof memoryTool.setStateManager === 'function') {
+        memoryTool.setStateManager(this.stateManager);
+      }
       if (typeof platformControlTool.setMemoryService === 'function') {
         const { getMemoryService } = await import('./services/memoryService.js');
         platformControlTool.setMemoryService(getMemoryService(this.logger));
@@ -663,6 +693,34 @@ class LoxiaApplication {
       this.logger.info('WhatsAppService set for WhatsApp Tool');
     }
 
+    // ─── Catch-all aiService wiring ────────────────────────────────
+    //
+    // Several tools read `this.aiService.getEmbeddingService()` for their
+    // semantic-search / find-action paths (memory, agentcommunication,
+    // taskmanager, skills, composio) but have no `setAIService` method
+    // and were never wired by the explicit calls above. Production silently
+    // returned `this.aiService === undefined` → `_getIndexer()` returned
+    // null → every embedding-backed action surfaced "Embeddings are not
+    // enabled" even when embeddings WERE enabled (the user just hit this
+    // on composio.find-action; auto-recall in agentScheduler uses a
+    // different code path so it kept working, masking the wider gap).
+    //
+    // We sweep every registered tool here, AFTER the explicit per-tool
+    // wiring above. Tools that already have aiService set (image, vision,
+    // video, foundry-web-search, desktop) are skipped; everyone else
+    // gets it now. The assignment is harmless for tools that ignore the
+    // property.
+    {
+      let wired = 0;
+      for (const tool of this.toolsRegistry.tools.values()) {
+        if (!tool.aiService) {
+          tool.aiService = this.aiService;
+          wired++;
+        }
+      }
+      this.logger.info('AIService wired onto remaining tools', { count: wired });
+    }
+
     const toolCapabilities = this.toolsRegistry.getToolCapabilities();
     this.logger.info('Tools initialized', {
       toolCount: Object.keys(toolCapabilities).length,
@@ -737,6 +795,10 @@ class LoxiaApplication {
       // Set API Key Manager reference in Web Server
       webServer.setApiKeyManager(this.apiKeyManager);
 
+      // Embedding service handle so the /api/embeddings/* routes can
+      // read config + telemetry, hot-swap providers, etc.
+      webServer.embeddingService = this.embeddingService;
+
       // Set Credential Vault reference in Web Server
       webServer.setCredentialVault(this.credentialVault);