onbuzz 4.9.13 → 4.10.0

package/src/core/__tests__/agentScheduler.emptyResponseChatStall.test.js

@@ -1,213 +1,213 @@
-/**
- * Tests for the empty-response stall path in _trackEmptyResponse +
- * _handleEmptyResponseStall.
- *
- * Two contracts here:
- *
- *   1. EARLY ESCALATION FOR CHAT MODE WITH NO QUEUED MESSAGES.
- *      The classic AND-condition (count >= 5 AND elapsed >= 60s) was
- *      designed for autonomous agents that re-cycle. In chat mode without
- *      further messages there IS no next cycle — count gets stuck at 1
- *      and the agent silently hangs forever. Fix: a single empty response
- *      in that state must escalate immediately.
- *
- *   2. THE STALL HANDLER PUSHES A VISIBLE ERROR TURN.
- *      Pre-fix, _handleEmptyResponseStall flipped mode to CHAT and
- *      broadcast a notification, but wrote NOTHING to the conversation
- *      log. REST polling consumers (dashboard, shooting-range,
- *      headless probes) saw an agent that just stopped. Fix: route
- *      through _recordAgentFailure so the same { role:'assistant',
- *      isError:true, classification, error } shape lands in
- *      conversations.full.messages — same diagnostic-gap surface as
- *      the classified-failure branches.
- */
-
-import { jest, describe, test, expect, beforeEach } from '@jest/globals';
-import { createMockLogger } from '../../__test-utils__/mockFactories.js';
-
-jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
-  shouldAgentBeActive: jest.fn(() => ({ active: false, reason: 'idle' })),
-  getActiveAgents: jest.fn(() => []),
-  shouldSkipIteration: jest.fn(() => false),
-}));
-
-const { default: AgentScheduler } = await import('../agentScheduler.js');
-const { AGENT_MODES } = await import('../../utilities/constants.js');
-
-function makeAgent(overrides = {}) {
-  return {
-    id: 'a1',
-    name: 'TestAgent',
-    sessionId: 'sess-1',
-    currentModel: 'gpt-5.3-codex',
-    preferredModel: 'gpt-5.3-codex',
-    mode: AGENT_MODES.CHAT,
-    messageQueues: { toolResults: [], interAgentMessages: [], userMessages: [] },
-    conversations: {
-      full: { messages: [{ role: 'user', content: 'Say HI.' }], lastUpdated: null },
-      'gpt-5.3-codex': { messages: [{ role: 'user', content: 'Say HI.' }], lastUpdated: null },
-    },
-    ...overrides,
-  };
-}
-
-function makeScheduler(agent) {
-  const logger = createMockLogger();
-  const agentPool = {
-    getAgent: jest.fn().mockResolvedValue(agent),
-    persistAgentState: jest.fn().mockResolvedValue(undefined),
-    addToolResult: jest.fn().mockResolvedValue(undefined),
-  };
-  const aiService = { abortRequest: jest.fn() };
-  const scheduler = new AgentScheduler(agentPool, {}, aiService, logger);
-  scheduler.webSocketManager = { broadcastToSession: jest.fn() };
-  scheduler.broadcastAgentStateUpdate = jest.fn().mockResolvedValue(undefined);
-  scheduler.getAgentSession = jest.fn(() => 'sess-1');
-  // Mode-transition history requires this to be initialised on AgentScheduler
-  scheduler._transitionMode = jest.fn().mockResolvedValue(undefined);
-  return { scheduler, agentPool, agent };
-}
-
-// The empty-response detector calls _snapshotResponseShape on the AI
-// response. Mirror the production shape so the conversation-pushed error
-// carries the hint string verifiers can match against.
-function emptyAiResponse() {
-  return {
-    content: '',
-    finishReason: 'stop',
-    model: 'gpt-5.3-codex',
-  };
-}
-
-describe('_trackEmptyResponse — chat-mode early escalation', () => {
-
-  test('chat mode + no queued messages → escalates after ONE empty (not 5)', async () => {
-    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
-    const { scheduler, agentPool } = makeScheduler(agent);
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    // Tracker should have been cleared after the stall handler ran.
-    expect(scheduler._emptyResponseTracker.has('a1')).toBe(false);
-    // Stall handler did its thing: lastError set + conversation push happened.
-    expect(agent.lastError).toBeDefined();
-    expect(agent.lastError.classification).toBe('empty-response-chat-stall');
-    expect(agentPool.persistAgentState).toHaveBeenCalledWith('a1');
-  });
-
-  test('autonomous mode → does NOT early-escalate (waits for normal 5/60s)', async () => {
-    const agent = makeAgent({ mode: AGENT_MODES.AGENT });
-    const { scheduler } = makeScheduler(agent);
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    // Tracker still has count: 1 — normal stall logic in effect.
-    const entry = scheduler._emptyResponseTracker.get('a1');
-    expect(entry).toBeDefined();
-    expect(entry.count).toBe(1);
-    // No conversation error yet.
-    expect(agent.lastError).toBeUndefined();
-  });
-
-  test('chat mode WITH a queued tool result → does NOT early-escalate', async () => {
-    // A pending tool result means the next cycle will produce work — the
-    // empty turn might just be the model awaiting its tool reply.
-    const agent = makeAgent({
-      mode: AGENT_MODES.CHAT,
-      messageQueues: {
-        toolResults: [{ id: 't1', result: 'ok' }],
-        interAgentMessages: [],
-        userMessages: [],
-      },
-    });
-    const { scheduler } = makeScheduler(agent);
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    expect(scheduler._emptyResponseTracker.get('a1')?.count).toBe(1);
-    expect(agent.lastError).toBeUndefined();
-  });
-
-  test('chat mode WITH a queued user message → does NOT early-escalate', async () => {
-    const agent = makeAgent({
-      mode: AGENT_MODES.CHAT,
-      messageQueues: {
-        toolResults: [],
-        interAgentMessages: [],
-        userMessages: [{ content: 'follow-up' }],
-      },
-    });
-    const { scheduler } = makeScheduler(agent);
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    expect(scheduler._emptyResponseTracker.get('a1')?.count).toBe(1);
-    expect(agent.lastError).toBeUndefined();
-  });
-});
-
-describe('_handleEmptyResponseStall — diagnostic-gap fix', () => {
-
-  test('pushes error turn into conversations.full so REST polling sees it', async () => {
-    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
-    const { scheduler } = makeScheduler(agent);
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    const turn = agent.conversations.full.messages
-      .find(m => m.isError === true);
-    expect(turn).toBeDefined();
-    expect(turn.role).toBe('assistant');
-    expect(turn.classification).toBe('empty-response-chat-stall');
-    expect(turn.error).toContain('empty response');
-    expect(turn.model).toBe('gpt-5.3-codex');
-    // Content body for clients that just render `message.content`.
-    expect(turn.content).toContain('[empty-response-chat-stall]');
-  });
-
-  test('also pushes into the per-model conversation bucket', async () => {
-    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
-    const { scheduler } = makeScheduler(agent);
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    const turn = agent.conversations['gpt-5.3-codex'].messages
-      .find(m => m.isError === true);
-    expect(turn).toBeDefined();
-  });
-
-  test('still flips mode to CHAT (preserves existing behaviour)', async () => {
-    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
-    const { scheduler } = makeScheduler(agent);
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    expect(scheduler._transitionMode).toHaveBeenCalledWith(
-      'a1',
-      AGENT_MODES.CHAT,
-      'empty-response-chat-stall',
-      expect.objectContaining({ count: 1 })
-    );
-  });
-
-  test('classic 5-in-60s path still fires when count hits threshold', async () => {
-    // Drive the agent through 5 empty responses, each timestamped >12s
-    // apart so elapsed > 60s by the 5th. Autonomous mode so the early-
-    // escalation branch doesn't short-circuit.
-    const agent = makeAgent({ mode: AGENT_MODES.AGENT });
-    const { scheduler } = makeScheduler(agent);
-
-    // Seed the tracker manually so we don't have to await 60s of real time.
-    scheduler._emptyResponseTracker.set('a1', {
-      count: 4,
-      firstAt: Date.now() - 61_000,   // 61s ago
-      lastAt: Date.now() - 1000,
-      samples: [],
-    });
-
-    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
-
-    expect(scheduler._emptyResponseTracker.has('a1')).toBe(false);   // cleared
-    expect(agent.lastError?.classification).toBe('empty-response-stall');
-  });
-});
+/**
+ * Tests for the empty-response stall path in _trackEmptyResponse +
+ * _handleEmptyResponseStall.
+ *
+ * Two contracts here:
+ *
+ *   1. EARLY ESCALATION FOR CHAT MODE WITH NO QUEUED MESSAGES.
+ *      The classic AND-condition (count >= 5 AND elapsed >= 60s) was
+ *      designed for autonomous agents that re-cycle. In chat mode without
+ *      further messages there IS no next cycle — count gets stuck at 1
+ *      and the agent silently hangs forever. Fix: a single empty response
+ *      in that state must escalate immediately.
+ *
+ *   2. THE STALL HANDLER PUSHES A VISIBLE ERROR TURN.
+ *      Pre-fix, _handleEmptyResponseStall flipped mode to CHAT and
+ *      broadcast a notification, but wrote NOTHING to the conversation
+ *      log. REST polling consumers (dashboard, shooting-range,
+ *      headless probes) saw an agent that just stopped. Fix: route
+ *      through _recordAgentFailure so the same { role:'assistant',
+ *      isError:true, classification, error } shape lands in
+ *      conversations.full.messages — same diagnostic-gap surface as
+ *      the classified-failure branches.
+ */
+
+import { jest, describe, test, expect } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: jest.fn(() => ({ active: false, reason: 'idle' })),
+  getActiveAgents: jest.fn(() => []),
+  shouldSkipIteration: jest.fn(() => false),
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+const { AGENT_MODES } = await import('../../utilities/constants.js');
+
+function makeAgent(overrides = {}) {
+  return {
+    id: 'a1',
+    name: 'TestAgent',
+    sessionId: 'sess-1',
+    currentModel: 'gpt-5.3-codex',
+    preferredModel: 'gpt-5.3-codex',
+    mode: AGENT_MODES.CHAT,
+    messageQueues: { toolResults: [], interAgentMessages: [], userMessages: [] },
+    conversations: {
+      full: { messages: [{ role: 'user', content: 'Say HI.' }], lastUpdated: null },
+      'gpt-5.3-codex': { messages: [{ role: 'user', content: 'Say HI.' }], lastUpdated: null },
+    },
+    ...overrides,
+  };
+}
+
+function makeScheduler(agent) {
+  const logger = createMockLogger();
+  const agentPool = {
+    getAgent: jest.fn().mockResolvedValue(agent),
+    persistAgentState: jest.fn().mockResolvedValue(undefined),
+    addToolResult: jest.fn().mockResolvedValue(undefined),
+  };
+  const aiService = { abortRequest: jest.fn() };
+  const scheduler = new AgentScheduler(agentPool, {}, aiService, logger);
+  scheduler.webSocketManager = { broadcastToSession: jest.fn() };
+  scheduler.broadcastAgentStateUpdate = jest.fn().mockResolvedValue(undefined);
+  scheduler.getAgentSession = jest.fn(() => 'sess-1');
+  // Mode-transition history requires this to be initialised on AgentScheduler
+  scheduler._transitionMode = jest.fn().mockResolvedValue(undefined);
+  return { scheduler, agentPool, agent };
+}
+
+// The empty-response detector calls _snapshotResponseShape on the AI
+// response. Mirror the production shape so the conversation-pushed error
+// carries the hint string verifiers can match against.
+function emptyAiResponse() {
+  return {
+    content: '',
+    finishReason: 'stop',
+    model: 'gpt-5.3-codex',
+  };
+}
+
+describe('_trackEmptyResponse — chat-mode early escalation', () => {
+
+  test('chat mode + no queued messages → escalates after ONE empty (not 5)', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler, agentPool } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    // Tracker should have been cleared after the stall handler ran.
+    expect(scheduler._emptyResponseTracker.has('a1')).toBe(false);
+    // Stall handler did its thing: lastError set + conversation push happened.
+    expect(agent.lastError).toBeDefined();
+    expect(agent.lastError.classification).toBe('empty-response-chat-stall');
+    expect(agentPool.persistAgentState).toHaveBeenCalledWith('a1');
+  });
+
+  test('autonomous mode → does NOT early-escalate (waits for normal 5/60s)', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.AGENT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    // Tracker still has count: 1 — normal stall logic in effect.
+    const entry = scheduler._emptyResponseTracker.get('a1');
+    expect(entry).toBeDefined();
+    expect(entry.count).toBe(1);
+    // No conversation error yet.
+    expect(agent.lastError).toBeUndefined();
+  });
+
+  test('chat mode WITH a queued tool result → does NOT early-escalate', async () => {
+    // A pending tool result means the next cycle will produce work — the
+    // empty turn might just be the model awaiting its tool reply.
+    const agent = makeAgent({
+      mode: AGENT_MODES.CHAT,
+      messageQueues: {
+        toolResults: [{ id: 't1', result: 'ok' }],
+        interAgentMessages: [],
+        userMessages: [],
+      },
+    });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._emptyResponseTracker.get('a1')?.count).toBe(1);
+    expect(agent.lastError).toBeUndefined();
+  });
+
+  test('chat mode WITH a queued user message → does NOT early-escalate', async () => {
+    const agent = makeAgent({
+      mode: AGENT_MODES.CHAT,
+      messageQueues: {
+        toolResults: [],
+        interAgentMessages: [],
+        userMessages: [{ content: 'follow-up' }],
+      },
+    });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._emptyResponseTracker.get('a1')?.count).toBe(1);
+    expect(agent.lastError).toBeUndefined();
+  });
+});
+
+describe('_handleEmptyResponseStall — diagnostic-gap fix', () => {
+
+  test('pushes error turn into conversations.full so REST polling sees it', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    const turn = agent.conversations.full.messages
+      .find(m => m.isError === true);
+    expect(turn).toBeDefined();
+    expect(turn.role).toBe('assistant');
+    expect(turn.classification).toBe('empty-response-chat-stall');
+    expect(turn.error).toContain('empty response');
+    expect(turn.model).toBe('gpt-5.3-codex');
+    // Content body for clients that just render `message.content`.
+    expect(turn.content).toContain('[empty-response-chat-stall]');
+  });
+
+  test('also pushes into the per-model conversation bucket', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    const turn = agent.conversations['gpt-5.3-codex'].messages
+      .find(m => m.isError === true);
+    expect(turn).toBeDefined();
+  });
+
+  test('still flips mode to CHAT (preserves existing behaviour)', async () => {
+    const agent = makeAgent({ mode: AGENT_MODES.CHAT });
+    const { scheduler } = makeScheduler(agent);
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._transitionMode).toHaveBeenCalledWith(
+      'a1',
+      AGENT_MODES.CHAT,
+      'empty-response-chat-stall',
+      expect.objectContaining({ count: 1 })
+    );
+  });
+
+  test('classic 5-in-60s path still fires when count hits threshold', async () => {
+    // Drive the agent through 5 empty responses, each timestamped >12s
+    // apart so elapsed > 60s by the 5th. Autonomous mode so the early-
+    // escalation branch doesn't short-circuit.
+    const agent = makeAgent({ mode: AGENT_MODES.AGENT });
+    const { scheduler } = makeScheduler(agent);
+
+    // Seed the tracker manually so we don't have to await 60s of real time.
+    scheduler._emptyResponseTracker.set('a1', {
+      count: 4,
+      firstAt: Date.now() - 61_000,   // 61s ago
+      lastAt: Date.now() - 1000,
+      samples: [],
+    });
+
+    await scheduler._trackEmptyResponse('a1', emptyAiResponse());
+
+    expect(scheduler._emptyResponseTracker.has('a1')).toBe(false);   // cleared
+    expect(agent.lastError?.classification).toBe('empty-response-stall');
+  });
+});