onbuzz 4.9.0 → 4.9.1

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/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);
 

package/src/interfaces/webServer.js

@@ -1903,6 +1903,96 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     // API Key Management Endpoints
     
     // Set API keys for current session
+    // ─── Embeddings configuration + telemetry ─────────────────────────
+    //
+    // Settings UI surface for the semantic-retrieval layer (Phases 0-5
+    // in the embeddings rollout). All routes 200 even when the
+    // embedding service hasn't been attached yet — they return a
+    // clearly-marked unconfigured payload rather than a 503, so the
+    // Settings UI can render a "not configured yet" state.
+
+    /** GET /api/embeddings/config — current config + provider catalog. */
+    this.app.get('/api/embeddings/config', async (_req, res) => {
+      try {
+        const svc = this.embeddingService;
+        if (!svc) {
+          return res.json({ configured: false, config: null, providers: [], models: {} });
+        }
+        // Lazy-import the model catalog so we don't pull it into the
+        // hot-path bundle of the webServer.
+        const [{ getProviderModelOptions, PROVIDERS, DEFAULT_CONFIG }] = await Promise.all([
+          import('../services/embeddings/embeddingsConfig.js'),
+        ]);
+        const models = {};
+        for (const p of PROVIDERS) models[p] = getProviderModelOptions(p);
+        res.json({
+          configured: true,
+          config: svc.config,
+          providers: PROVIDERS,
+          models,
+          defaults: DEFAULT_CONFIG,
+          enabled: svc.isEnabled,
+        });
+      } catch (error) {
+        this.logger.error('Failed to read embeddings config', { error: error.message });
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    /** POST /api/embeddings/config — update + persist. */
+    this.app.post('/api/embeddings/config', async (req, res) => {
+      try {
+        const svc = this.embeddingService;
+        if (!svc) return res.status(503).json({ error: 'Embedding service not initialised' });
+        const result = await svc.updateConfig(req.body || {}, { persist: true });
+        if (!result.ok) {
+          return res.status(400).json({ error: 'Invalid config', details: result.errors });
+        }
+        res.json({ success: true, config: svc.config, enabled: svc.isEnabled });
+      } catch (error) {
+        this.logger.error('Failed to update embeddings config', { error: error.message });
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    /** GET /api/embeddings/telemetry — cost dashboard data. */
+    this.app.get('/api/embeddings/telemetry', async (_req, res) => {
+      try {
+        const svc = this.embeddingService;
+        if (!svc) return res.json({ configured: false, telemetry: null });
+        res.json({ configured: true, telemetry: svc.getTelemetry(), enabled: svc.isEnabled });
+      } catch (error) {
+        this.logger.error('Failed to read embeddings telemetry', { error: error.message });
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    /** GET /api/embeddings/health — provider readiness pill. */
+    this.app.get('/api/embeddings/health', async (_req, res) => {
+      try {
+        const svc = this.embeddingService;
+        if (!svc) return res.json({ configured: false, health: { ok: false, reason: 'service not initialised' } });
+        const health = await svc.health();
+        res.json({ configured: true, health, enabled: svc.isEnabled, provider: svc.config?.provider });
+      } catch (error) {
+        this.logger.error('Failed to check embeddings health', { error: error.message });
+        res.status(500).json({ error: error.message });
+      }
+    });
+
+    /** POST /api/embeddings/warmup — load the local model now. */
+    this.app.post('/api/embeddings/warmup', async (_req, res) => {
+      try {
+        const svc = this.embeddingService;
+        if (!svc) return res.status(503).json({ error: 'Embedding service not initialised' });
+        await svc.warmup();
+        res.json({ success: true, health: await svc.health() });
+      } catch (error) {
+        this.logger.error('Embeddings warmup failed', { error: error.message });
+        res.status(500).json({ error: error.message });
+      }
+    });
+
     this.app.post('/api/keys', async (req, res) => {
       try {
         const { sessionId, loxiaApiKey, vendorKeys } = req.body;