onbuzz 3.7.0 → 3.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/src/core/__tests__/agentPoolAutoResume.test.js

@@ -0,0 +1,209 @@
+/**
+ * AgentPool - Auto-resume on addUserMessage tests
+ * Verifies that sending a user message to a paused agent auto-resumes it.
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig, createMockStateManager } from '../../__test-utils__/mockFactories.js';
+
+// ── Mocks (same pattern as agentPool.test.js) ──────────────────────────────
+const mockValidateAccessConfiguration = jest.fn().mockReturnValue({ valid: true });
+const mockCreateProjectDefaults = jest.fn().mockReturnValue({
+  workingDirectory: '/tmp/project',
+  readOnlyDirectories: [],
+  writeEnabledDirectories: ['/tmp/project']
+});
+
+jest.unstable_mockModule('../../utilities/directoryAccessManager.js', () => {
+  const MockDAM = jest.fn().mockImplementation(() => ({
+    validateAccessConfiguration: mockValidateAccessConfiguration
+  }));
+  MockDAM.createProjectDefaults = mockCreateProjectDefaults;
+  return { default: MockDAM };
+});
+
+jest.unstable_mockModule('../../services/visualEditorBridge.js', () => ({
+  getVisualEditorBridge: jest.fn().mockReturnValue({
+    hasInstance: jest.fn().mockReturnValue(false),
+    stopInstance: jest.fn().mockResolvedValue(undefined)
+  })
+}));
+
+const { default: AgentPool } = await import('../agentPool.js');
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makePool(overrides = {}) {
+  const config = createMockConfig(overrides.config);
+  const logger = createMockLogger();
+  const stateManager = createMockStateManager();
+  const contextManager = { getContext: jest.fn() };
+  const pool = new AgentPool(config, logger, stateManager, contextManager, null);
+  return { pool, config, logger, stateManager, contextManager };
+}
+
+function agentCfg(overrides = {}) {
+  return {
+    name: 'TestAgent',
+    systemPrompt: 'You are a test agent.',
+    preferredModel: 'test-model',
+    capabilities: [],
+    projectDir: '/tmp/project',
+    ...overrides
+  };
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────────
+describe('AgentPool – addUserMessage auto-resume', () => {
+  let pool, logger;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    ({ pool, logger } = makePool());
+  });
+
+  test('addUserMessage on active agent does NOT call resumeAgent', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    expect(agent.status).toBe('active');
+
+    const resumeSpy = jest.spyOn(pool, 'resumeAgent');
+    await pool.addUserMessage(agent.id, { content: 'hello' });
+
+    expect(resumeSpy).not.toHaveBeenCalled();
+    resumeSpy.mockRestore();
+  });
+
+  test('addUserMessage on paused agent calls resumeAgent before queuing', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'manual pause');
+    expect(agent.status).toBe('paused');
+
+    const resumeSpy = jest.spyOn(pool, 'resumeAgent');
+    await pool.addUserMessage(agent.id, { content: 'wake up' });
+
+    expect(resumeSpy).toHaveBeenCalledWith(agent.id);
+    resumeSpy.mockRestore();
+  });
+
+  test('after auto-resume, agent status is active (not paused)', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause reason');
+    expect(agent.status).toBe('paused');
+
+    await pool.addUserMessage(agent.id, { content: 'resume me' });
+
+    expect(agent.status).toBe('active');
+    expect(agent.pausedUntil).toBeNull();
+  });
+
+  test('message is still queued successfully after auto-resume', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause reason');
+
+    await pool.addUserMessage(agent.id, { content: 'queued msg' });
+
+    expect(agent.messageQueues.userMessages).toHaveLength(1);
+    expect(agent.messageQueues.userMessages[0].content).toBe('queued msg');
+    expect(agent.messageQueues.userMessages[0].id).toBeDefined();
+    expect(agent.messageQueues.userMessages[0].queuedAt).toBeDefined();
+  });
+
+  test('addUserMessage on non-existent agent throws error', async () => {
+    await expect(
+      pool.addUserMessage('nonexistent-id', { content: 'hello' })
+    ).rejects.toThrow('Agent not found');
+  });
+
+  // ── Additional coverage ───────────────────────────────────────────────
+
+  test('auto-resume processes queued notifications after resume', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause for notifications');
+
+    // Spy on _processQueuedNotifications to verify it is called during resume
+    const processSpy = jest.spyOn(pool, '_processQueuedNotifications');
+
+    await pool.addUserMessage(agent.id, { content: 'trigger resume' });
+
+    // resumeAgent calls _processQueuedNotifications internally
+    expect(processSpy).toHaveBeenCalledWith(agent.id);
+    processSpy.mockRestore();
+  });
+
+  test('multiple rapid messages to paused agent — only first triggers resume', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause reason');
+    expect(agent.status).toBe('paused');
+
+    const resumeSpy = jest.spyOn(pool, 'resumeAgent');
+
+    // Send first message — triggers auto-resume
+    await pool.addUserMessage(agent.id, { content: 'msg1' });
+    expect(resumeSpy).toHaveBeenCalledTimes(1);
+    expect(agent.status).toBe('active');
+
+    // Send second message — agent is now active, so no resume
+    await pool.addUserMessage(agent.id, { content: 'msg2' });
+    // resumeAgent should still only have been called once
+    expect(resumeSpy).toHaveBeenCalledTimes(1);
+
+    // Both messages should be queued
+    expect(agent.messageQueues.userMessages).toHaveLength(2);
+    resumeSpy.mockRestore();
+  });
+
+  test('addUserMessage after manual resume does NOT call resumeAgent again', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause reason');
+
+    // Manually resume first
+    await pool.resumeAgent(agent.id);
+    expect(agent.status).toBe('active');
+
+    const resumeSpy = jest.spyOn(pool, 'resumeAgent');
+
+    // Now send a message — agent is already active
+    await pool.addUserMessage(agent.id, { content: 'after manual resume' });
+
+    expect(resumeSpy).not.toHaveBeenCalled();
+    expect(agent.messageQueues.userMessages).toHaveLength(1);
+    resumeSpy.mockRestore();
+  });
+
+  test('auto-resume logs info message with agent ID', async () => {
+    const agent = await pool.createAgent(agentCfg());
+    await pool.pauseAgent(agent.id, 300, 'pause for log test');
+
+    // Clear mocks to isolate the log calls from addUserMessage
+    logger.info.mockClear();
+
+    await pool.addUserMessage(agent.id, { content: 'log test' });
+
+    // The auto-resume path logs: `Auto-resuming paused agent ${agentId} due to user message`
+    const autoResumeLog = logger.info.mock.calls.find(
+      call => typeof call[0] === 'string' && call[0].includes('Auto-resuming paused agent')
+    );
+    expect(autoResumeLog).toBeDefined();
+    expect(autoResumeLog[0]).toContain(agent.id);
+  });
+
+  test('auto-resume broadcasts mode change via scheduler if scheduler is set', async () => {
+    const { pool: poolWithScheduler, logger: loggerWS } = makePool();
+
+    // Set up a mock scheduler
+    const mockScheduler = {
+      addAgent: jest.fn().mockResolvedValue(undefined),
+      removeAgent: jest.fn(),
+      isAgentInScheduler: jest.fn().mockReturnValue(false)
+    };
+    poolWithScheduler.setScheduler(mockScheduler);
+
+    const agent = await poolWithScheduler.createAgent(agentCfg());
+    await poolWithScheduler.pauseAgent(agent.id, 300, 'pause for scheduler test');
+
+    await poolWithScheduler.addUserMessage(agent.id, { content: 'scheduler trigger' });
+
+    // Agent should be active after auto-resume
+    expect(agent.status).toBe('active');
+    // The resume flow should have run successfully with the scheduler set
+    expect(agent.pausedUntil).toBeNull();
+  });
+});

package/src/core/agentPool.js

@@ -1300,6 +1300,12 @@ 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);
+    }
+
     const queuedMessage = {
       ...message,
       id: message.id || `user-msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
@@ -1352,10 +1358,20 @@ class AgentPool {
 
     await this.persistAgentState(agentId);
 
+    // CRITICAL: Register recipient with scheduler so it has a sessionId for API key resolution.
+    // Inter-agent messages carry the sender's sessionId — reuse it for the recipient.
+    if (this.scheduler && message.sessionId) {
+      await this.scheduler.addAgent(agentId, {
+        sessionId: message.sessionId,
+        triggeredBy: 'inter-agent-message'
+      });
+    }
+
     this.logger.info(`Inter-agent message queued for agent: ${agentId}`, {
       messageId: queuedMessage.id,
       sender: message.sender || message.senderName,
-      queueSize: agent.messageQueues.interAgentMessages.length
+      queueSize: agent.messageQueues.interAgentMessages.length,
+      sessionRegistered: !!(this.scheduler && message.sessionId)
     });
   }
 

package/src/core/agentScheduler.js

@@ -1182,6 +1182,14 @@ class AgentScheduler {
           targetTokenCount: this.tokenCountingService.calculateTargetTokenCount(contextWindow),
           sessionId,
           compactedConversations,
+          onRetryAttempt: (retryInfo) => {
+            this.broadcastCompactionEvent(agentId, sessionId, {
+              status: 'retrying',
+              message: retryInfo.message,
+              attempt: retryInfo.attempt,
+              totalModels: retryInfo.totalModels
+            });
+          },
           onAllModelsExhausted: (errorInfo) => {
             this.broadcastCompactionEvent(agentId, sessionId, {
               type: 'compaction_models_exhausted',
@@ -1308,14 +1316,30 @@ class AgentScheduler {
 
       const conversationHistory = agent.conversations?.full?.messages || [];
 
-      // Get the session ID from the session map or agent's stored sessionId
-      const sessionId = this.getAgentSession(agentId) || agent.sessionId;
-      
+      // Get the session ID from the session map, agent's stored sessionId, or any active session
+      let sessionId = this.getAgentSession(agentId) || agent.sessionId;
+
+      // Fallback: if this agent has no session (e.g., activated by inter-agent message
+      // from a different session), borrow a session from any other registered agent.
+      // This is safe because sessions are only used for API key resolution.
+      if (!sessionId && this.agentSessionMap.size > 0) {
+        const fallbackSession = this.agentSessionMap.values().next().value;
+        if (fallbackSession) {
+          sessionId = fallbackSession;
+          this.registerAgentSession(agentId, sessionId);
+          this.logger.info(`Agent ${agentId} borrowed session from pool for API key resolution`, {
+            agentName: agent.name,
+            borrowedSessionId: sessionId
+          });
+        }
+      }
+
       if (!sessionId) {
         this.logger.error(`Agent ${agentId} has no session ID - API key resolution will fail`, {
           agentName: agent.name,
           agentSessionId: agent.sessionId,
-          sessionMapHas: this.agentSessionMap.has(agentId)
+          sessionMapHas: this.agentSessionMap.has(agentId),
+          totalSessions: this.agentSessionMap.size
         });
         // Return null to avoid making requests that will fail
         return null;
@@ -2173,6 +2197,14 @@ class AgentScheduler {
           sessionId,
           agentId,
           emergency: true,
+          onRetryAttempt: (retryInfo) => {
+            this.broadcastCompactionEvent(agentId, sessionId, {
+              status: 'retrying',
+              message: retryInfo.message,
+              attempt: retryInfo.attempt,
+              totalModels: retryInfo.totalModels
+            });
+          },
           onAllModelsExhausted: (errorInfo) => {
             this.broadcastCompactionEvent(agentId, sessionId, {
               type: 'compaction_models_exhausted',

package/src/index.js

@@ -298,6 +298,16 @@ class LoxiaApplication {
       this.logger.info('Telegram service unavailable', { error: e.message });
     }
 
+    // Discord Service (optional — requires discord.js)
+    try {
+      const { getDiscordService } = await import('./services/discordService.js');
+      this.discordService = getDiscordService(this.logger);
+      this.logger.info('Discord service initialized');
+    } catch (e) {
+      this.discordService = null;
+      this.logger.info('Discord service unavailable', { error: e.message });
+    }
+
     // Schedule Service
     this.scheduleService = new ScheduleService(this.logger);
     await this.scheduleService.initialize();
@@ -652,6 +662,19 @@ class LoxiaApplication {
         );
       }
 
+      // Set Discord Service references
+      if (this.discordService) {
+        webServer.setDiscordService(this.discordService);
+        this.discordService.setOrchestrator(this.orchestrator);
+        this.discordService.setAgentPool(this.agentPool);
+        this.discordService.setWebSocketManager(webServer);
+        if (this.flowExecutor) this.discordService.setFlowExecutor(this.flowExecutor);
+        // Auto-connect if token exists in config (non-blocking)
+        this.discordService.autoConnect().catch(e =>
+          this.logger.warn('Discord auto-connect failed', { error: e.message })
+        );
+      }
+
       await webServer.initialize();
       this.interfaces.set(INTERFACE_TYPES.WEB, webServer);
       

package/src/interfaces/webServer.js

@@ -891,6 +891,18 @@ class WebServer {
           if (!contentType?.includes('text/event-stream')) {
             // Not a stream, parse as regular JSON (fallback)
             const data = await response.json();
+            if (data.error) {
+              this.logger.warn('Azure backend returned non-streaming error response', {
+                model: req.body.model,
+                error: data.error,
+                details: data.details
+              });
+              return res.status(400).json({
+                error: `Model "${req.body.model}" returned no stream generator. ${data.error}. The model may not support streaming or the deployment may not be configured.`,
+                details: data.details,
+                originalError: data.error
+              });
+            }
             this.logger.info('Received non-streaming response from Azure backend', {
               model: data.model,
               contentLength: data.content?.length || 0
@@ -1526,6 +1538,39 @@ class WebServer {
       }
     });
 
+    // Extend prompt timeout
+    this.app.post('/api/prompts/:requestId/extend', async (req, res) => {
+      try {
+        const { additionalMs } = req.body;
+        const { getPromptService } = await import('../services/promptService.js');
+        const promptService = getPromptService(this.logger);
+        const result = promptService.extendTimeout(req.params.requestId, additionalMs || 120000);
+        if (!result.success) {
+          return res.status(404).json(result);
+        }
+        res.json(result);
+      } catch (error) {
+        this.logger.error('Failed to extend prompt timeout', { error: error.message });
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    // Clear prompt timeout (stop countdown)
+    this.app.post('/api/prompts/:requestId/clear-timeout', async (req, res) => {
+      try {
+        const { getPromptService } = await import('../services/promptService.js');
+        const promptService = getPromptService(this.logger);
+        const result = promptService.stopTimeout(req.params.requestId);
+        if (!result.success) {
+          return res.status(404).json(result);
+        }
+        res.json(result);
+      } catch (error) {
+        this.logger.error('Failed to clear prompt timeout', { error: error.message });
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
     // Get known site configuration
     this.app.get('/api/credentials/known-sites', async (req, res) => {
       try {
@@ -3051,6 +3096,89 @@ class WebServer {
       }
     });
 
+    // Discord Bot Endpoints
+
+    this.app.get('/api/discord/status', (req, res) => {
+      if (!this.discordService) {
+        return res.json({ success: true, status: 'unavailable', connected: false });
+      }
+      res.json({ success: true, ...this.discordService.getStatus() });
+    });
+
+    this.app.post('/api/discord/connect', async (req, res) => {
+      try {
+        if (!this.discordService) {
+          return res.status(400).json({ success: false, error: 'Discord service not available' });
+        }
+        const { botToken } = req.body;
+        if (!botToken) {
+          return res.status(400).json({ success: false, error: 'botToken is required' });
+        }
+        const result = await this.discordService.connect(botToken);
+        res.json({ success: true, ...result });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    this.app.post('/api/discord/disconnect', async (req, res) => {
+      try {
+        if (!this.discordService) {
+          return res.status(400).json({ success: false, error: 'Discord service not available' });
+        }
+        await this.discordService.disconnect();
+        res.json({ success: true });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    this.app.get('/api/discord/channels', (req, res) => {
+      if (!this.discordService) {
+        return res.json({ success: true, channels: [] });
+      }
+      res.json({ success: true, channels: this.discordService.getAvailableChannels() });
+    });
+
+    this.app.get('/api/discord/mappings', (req, res) => {
+      if (!this.discordService) {
+        return res.json({ success: true, mappings: {}, knownGuilds: {}, knownChannels: {} });
+      }
+      res.json({ success: true, ...this.discordService.getChannelMappings() });
+    });
+
+    this.app.post('/api/discord/assign', async (req, res) => {
+      try {
+        if (!this.discordService) {
+          return res.status(400).json({ success: false, error: 'Discord service not available' });
+        }
+        const { channelKey, agentId } = req.body;
+        if (!channelKey || !agentId) {
+          return res.status(400).json({ success: false, error: 'channelKey and agentId are required' });
+        }
+        await this.discordService.assignAgentToChannel(channelKey, agentId);
+        res.json({ success: true, ...this.discordService.getChannelMappings() });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
+    this.app.post('/api/discord/unassign', async (req, res) => {
+      try {
+        if (!this.discordService) {
+          return res.status(400).json({ success: false, error: 'Discord service not available' });
+        }
+        const { channelKey, agentId } = req.body;
+        if (!channelKey || !agentId) {
+          return res.status(400).json({ success: false, error: 'channelKey and agentId are required' });
+        }
+        await this.discordService.removeAgentFromChannel(channelKey, agentId);
+        res.json({ success: true, ...this.discordService.getChannelMappings() });
+      } catch (error) {
+        res.status(500).json({ success: false, error: error.message });
+      }
+    });
+
     // Agent Import/Resume Endpoints
 
     // Get all available agents (active + archived)
@@ -5345,6 +5473,10 @@ class WebServer {
     this.telegramService = telegramService;
   }
 
+  setDiscordService(discordService) {
+    this.discordService = discordService;
+  }
+
   setScheduleService(scheduleService) {
     this.scheduleService = scheduleService;
   }