onbuzz 4.7.2 → 4.8.1

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

@@ -0,0 +1,319 @@
+/**
+ * Unit tests for `_resolveModelApiType` + `_pickSystemPromptForModel`
+ * on AgentScheduler — the runtime-side half of the "trim duplicated
+ * tool docs for Responses-API models" feature.
+ *
+ * Three concerns covered:
+ *   1. Classification (_resolveModelApiType) — every catalog shape the
+ *      backend's _inferRouting recognizes must produce the same answer
+ *      on the CLI side, or the optimization fires on the wrong models.
+ *   2. Selection (_pickSystemPromptForModel) — must fall back to
+ *      `agent.systemPrompt` for every safety-net path:
+ *         • modelsService missing                → fallback
+ *         • model not in catalog                 → fallback
+ *         • apiType resolves to chat_completion → fallback
+ *         • originalSystemPrompt missing         → fallback
+ *         • toolsRegistry missing                → fallback
+ *         • rebuild throws                       → fallback
+ *      Only the happy path (Responses model + everything available)
+ *      returns the trimmed rebuild.
+ *   3. Caching — same (agent, model) twice should rebuild ONCE; the
+ *      invalidator should clear entries for ONE agent only.
+ */
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+// Stub the activity service so importing the scheduler doesn't drag in
+// the full agent dependency graph for these unit tests.
+jest.unstable_mockModule('../../services/agentActivityService.js', () => ({
+  shouldAgentBeActive: () => ({ active: false, reason: 'stub' }),
+  getActiveAgents: () => [],
+  shouldSkipIteration: () => false,
+}));
+
+const { default: AgentScheduler } = await import('../agentScheduler.js');
+
+// ─── Test-only helpers ────────────────────────────────────────────────
+function makeScheduler({ models = [], registry = null, logger = null } = {}) {
+  const modelsService = {
+    getModels: () => models,
+  };
+  const agentPool = {
+    toolsRegistry: registry,
+    getAllAgents: async () => new Map(),
+    getAgent: async () => null,
+  };
+  const aiService = {};
+  const messageProcessor = {};
+  const log = logger || {
+    info() {}, warn() {}, error() {}, debug() {},
+  };
+  return new AgentScheduler(
+    agentPool,
+    messageProcessor,
+    aiService,
+    log,
+    null,           // webSocketManager
+    null,           // modelRouterService
+    modelsService,  // ← what we care about
+  );
+}
+
+// A minimal fake registry that records the apiType it was called with
+// so we can assert the scheduler propagates it correctly.
+function makeRegistry({ shouldThrow = false } = {}) {
+  const calls = [];
+  return {
+    calls,
+    enhanceSystemPrompt(prompt, capabilities, options) {
+      calls.push({ prompt, capabilities, options });
+      if (shouldThrow) throw new Error('boom');
+      const apiTag = options?.apiType === 'responses' ? '[trimmed]' : '[full]';
+      return `${prompt}\n## TOOLS ${apiTag} for caps=${(capabilities || []).join(',')}`;
+    },
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// 1. _resolveModelApiType — parity with backend's _inferRouting
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_resolveModelApiType — catalog → routing decision', () => {
+  test('api_type=["responses"] alone → "responses"', () => {
+    const s = makeScheduler({ models: [{ name: 'codex-mini', api_type: ['responses'] }] });
+    expect(s._resolveModelApiType('codex-mini')).toBe('responses');
+  });
+
+  test('api_type=["chat_completion","responses"] (BOTH present) → "chat_completion"', () => {
+    // Backend rule: only flips to responses when chat_completion is ABSENT.
+    const s = makeScheduler({
+      models: [{ name: 'gpt-5', api_type: ['chat_completion', 'responses'] }],
+    });
+    expect(s._resolveModelApiType('gpt-5')).toBe('chat_completion');
+  });
+
+  test('api_type=["chat_completion"] → "chat_completion"', () => {
+    const s = makeScheduler({ models: [{ name: 'claude', api_type: ['chat_completion'] }] });
+    expect(s._resolveModelApiType('claude')).toBe('chat_completion');
+  });
+
+  test('capabilities.responses=="true" + chatCompletion=="false" → "responses"', () => {
+    const s = makeScheduler({
+      models: [{
+        name: 'o3',
+        api_type: ['responses'],
+        capabilities: { responses: 'true', chatCompletion: 'false' },
+      }],
+    });
+    expect(s._resolveModelApiType('o3')).toBe('responses');
+  });
+
+  test('explicit useResponsesApi flag → "responses"', () => {
+    const s = makeScheduler({
+      models: [{ name: 'foo', api_type: [], useResponsesApi: true }],
+    });
+    expect(s._resolveModelApiType('foo')).toBe('responses');
+  });
+
+  test('name-pattern fallback: "codex" → "responses" even with no catalog data', () => {
+    const s = makeScheduler({ models: [{ name: 'gpt-5-1-codex-mini' }] });
+    expect(s._resolveModelApiType('gpt-5-1-codex-mini')).toBe('responses');
+  });
+
+  test('name-pattern fallback: "gpt-X-pro" → "responses"', () => {
+    const s = makeScheduler({ models: [{ name: 'gpt-5-pro' }] });
+    expect(s._resolveModelApiType('gpt-5-pro')).toBe('responses');
+  });
+
+  test('unknown model returns undefined (caller falls back to old behaviour)', () => {
+    const s = makeScheduler({ models: [{ name: 'claude', api_type: ['chat_completion'] }] });
+    expect(s._resolveModelApiType('mystery-model')).toBeUndefined();
+  });
+
+  test('modelsService missing → undefined (safe — caller falls back)', () => {
+    const s = new AgentScheduler({ toolsRegistry: null }, {}, {}, {
+      info() {}, warn() {}, error() {}, debug() {},
+    });
+    expect(s._resolveModelApiType('codex-mini')).toBeUndefined();
+  });
+
+  test('arbitrary exception in catalog → undefined (defensive)', () => {
+    // getModels() throws — must not propagate.
+    const s = new AgentScheduler(
+      { toolsRegistry: null },
+      {},
+      {},
+      { info() {}, warn() {}, error() {}, debug() {} },
+      null,
+      null,
+      { getModels() { throw new Error('catalog offline'); } },
+    );
+    expect(s._resolveModelApiType('codex-mini')).toBeUndefined();
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 2. _pickSystemPromptForModel — happy path + every safety-net path
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_pickSystemPromptForModel — back-compat fallbacks', () => {
+  const BAKED_PROMPT = 'BAKED: agent persona\n## AVAILABLE TOOLS\n…lots of text…';
+  const ORIGINAL_PROMPT = 'Agent persona';
+
+  const agentFor = (overrides = {}) => ({
+    id: 'agent-1',
+    systemPrompt: BAKED_PROMPT,
+    originalSystemPrompt: ORIGINAL_PROMPT,
+    capabilities: ['memory', 'terminal'],
+    skills: [],
+    ...overrides,
+  });
+
+  test('chat-completion model → returns agent.systemPrompt verbatim', async () => {
+    const s = makeScheduler({
+      models: [{ name: 'claude', api_type: ['chat_completion'] }],
+      registry: makeRegistry(),
+    });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'claude');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('unknown model → returns agent.systemPrompt verbatim', async () => {
+    const s = makeScheduler({ models: [], registry: makeRegistry() });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'never-heard-of');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('Responses model BUT originalSystemPrompt missing → fallback', async () => {
+    // Very old persisted agent (pre-originalSystemPrompt storage).
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: makeRegistry(),
+    });
+    const out = await s._pickSystemPromptForModel(
+      agentFor({ originalSystemPrompt: undefined }),
+      'codex',
+    );
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('Responses model BUT toolsRegistry missing → fallback', async () => {
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: null,
+    });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'codex');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+
+  test('Responses model AND rebuild throws → fallback (no crash)', async () => {
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: makeRegistry({ shouldThrow: true }),
+    });
+    const out = await s._pickSystemPromptForModel(agentFor(), 'codex');
+    expect(out).toBe(BAKED_PROMPT);
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 3. _pickSystemPromptForModel — happy path
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_pickSystemPromptForModel — Responses model rebuild', () => {
+  const agent = {
+    id: 'agent-1',
+    systemPrompt: 'STALE (chat-completion shape)',
+    originalSystemPrompt: 'Agent persona',
+    capabilities: ['memory', 'terminal'],
+    skills: [],
+  };
+
+  test('rebuilds with apiType:"responses" and returns trimmed prompt', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: reg,
+    });
+    const out = await s._pickSystemPromptForModel(agent, 'codex');
+    expect(out).toContain('[trimmed]');
+    expect(out).toContain('Agent persona');
+    // The registry was called with apiType: 'responses' AND the agent's capabilities.
+    expect(reg.calls).toHaveLength(1);
+    expect(reg.calls[0].options.apiType).toBe('responses');
+    expect(reg.calls[0].capabilities).toEqual(['memory', 'terminal']);
+  });
+
+  test('caches per (agentId, modelName) — second call does NOT rebuild', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: reg,
+    });
+    await s._pickSystemPromptForModel(agent, 'codex');
+    await s._pickSystemPromptForModel(agent, 'codex');
+    await s._pickSystemPromptForModel(agent, 'codex');
+    expect(reg.calls).toHaveLength(1);
+  });
+
+  test('different models for same agent → SEPARATE cache entries', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [
+        { name: 'codex', api_type: ['responses'] },
+        { name: 'gpt-5-pro', api_type: ['responses'] },
+      ],
+      registry: reg,
+    });
+    await s._pickSystemPromptForModel(agent, 'codex');
+    await s._pickSystemPromptForModel(agent, 'gpt-5-pro');
+    expect(reg.calls).toHaveLength(2);
+  });
+
+  test('switching back to chat-completion mid-session uses the persisted prompt unchanged', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [
+        { name: 'codex',  api_type: ['responses'] },
+        { name: 'claude', api_type: ['chat_completion'] },
+      ],
+      registry: reg,
+    });
+    const native = await s._pickSystemPromptForModel(agent, 'codex');
+    const inline = await s._pickSystemPromptForModel(agent, 'claude');
+    expect(native).toContain('[trimmed]');
+    expect(inline).toBe('STALE (chat-completion shape)');  // persisted, untouched
+    expect(reg.calls).toHaveLength(1);                     // only the codex rebuild ran
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────
+// 4. Cache invalidation
+// ──────────────────────────────────────────────────────────────────────
+
+describe('_invalidateNativePromptCache — selective per-agent clear', () => {
+  test('clears entries for ONE agent only, leaves others alone', async () => {
+    const reg = makeRegistry();
+    const s = makeScheduler({
+      models: [{ name: 'codex', api_type: ['responses'] }],
+      registry: reg,
+    });
+    const a1 = { id: 'a1', systemPrompt: 'p1', originalSystemPrompt: 'persona-1', capabilities: ['memory'], skills: [] };
+    const a2 = { id: 'a2', systemPrompt: 'p2', originalSystemPrompt: 'persona-2', capabilities: ['terminal'], skills: [] };
+
+    await s._pickSystemPromptForModel(a1, 'codex');
+    await s._pickSystemPromptForModel(a2, 'codex');
+    expect(reg.calls).toHaveLength(2);
+
+    s._invalidateNativePromptCache('a1');
+
+    // Re-fetching a1 → rebuild. a2 → still cached.
+    await s._pickSystemPromptForModel(a1, 'codex');
+    await s._pickSystemPromptForModel(a2, 'codex');
+    expect(reg.calls).toHaveLength(3); // only a1 rebuilt
+  });
+
+  test('invalidating for an agent that never rendered is a no-op (does not throw)', async () => {
+    const s = makeScheduler({ models: [], registry: makeRegistry() });
+    expect(() => s._invalidateNativePromptCache('never-seen')).not.toThrow();
+  });
+});

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

@@ -657,6 +657,80 @@ describe('AgentScheduler', () => {
       await scheduler.stopAgentExecution('agent-abort');
       expect(scheduler.aiService.abortRequest).toHaveBeenCalledWith('agent-abort');
     });
+
+    // ─── REGRESSION: stop-mid-flight wedge ─────────────────────────────
+    // Background: in production a user's agent was found stuck with
+    //   activity = { active:false, reason:'stop-requested' }
+    //   stopRequested = true (in memory + persisted)
+    //   mode = chat (transition flipped, then…)
+    // …and the scheduler skipping it every cycle forever. Root cause:
+    // stopAgentExecution set stopRequested=true BEFORE awaiting
+    // _transitionMode and only cleared it AFTER. If the await threw or
+    // the process restarted between the two, the flag was never cleared
+    // and persisted state carried the wedge across reboots — a one-way
+    // trap for the agent's schedulability.
+    //
+    // These tests lock the invariant: stopRequested MUST always end at
+    // false after stopAgentExecution returns, whether _transitionMode
+    // succeeded, threw a sync error, or rejected asynchronously. The
+    // cleared state must also be persisted before the function returns.
+
+    test('clears stopRequested even when _transitionMode throws synchronously', async () => {
+      const agent = makeAgent({ id: 'wedge-sync', mode: 'agent' });
+      agentPool.getAgent.mockResolvedValue(agent);
+      // Inject a transition that throws synchronously inside the await.
+      scheduler._transitionMode = jest.fn(() => {
+        throw new Error('boom-sync');
+      });
+
+      // We don't care if stopAgentExecution itself throws — what matters
+      // is that the flag is cleared regardless. Catch and assert state.
+      await scheduler.stopAgentExecution('wedge-sync').catch(() => {});
+
+      expect(agent.stopRequested).toBe(false);
+      // Persisted at least once after the clear so a process crash
+      // immediately after this point can't re-wedge on reload.
+      expect(agentPool.persistAgentState).toHaveBeenCalledWith('wedge-sync');
+    });
+
+    test('clears stopRequested even when _transitionMode rejects asynchronously', async () => {
+      const agent = makeAgent({ id: 'wedge-async', mode: 'agent' });
+      agentPool.getAgent.mockResolvedValue(agent);
+      scheduler._transitionMode = jest.fn().mockRejectedValue(new Error('ws-broadcast-hung'));
+
+      await scheduler.stopAgentExecution('wedge-async').catch(() => {});
+
+      expect(agent.stopRequested).toBe(false);
+      expect(agentPool.persistAgentState).toHaveBeenCalledWith('wedge-async');
+    });
+
+    test('clears stopRequested on the happy path too (no regression)', async () => {
+      const agent = makeAgent({ id: 'happy', mode: 'agent' });
+      agentPool.getAgent.mockResolvedValue(agent);
+      // The default _transitionMode on the real scheduler does I/O we
+      // don't want here; stub a no-op success.
+      scheduler._transitionMode = jest.fn().mockResolvedValue(undefined);
+
+      const result = await scheduler.stopAgentExecution('happy');
+      expect(result.success).toBe(true);
+      expect(agent.stopRequested).toBe(false);
+    });
+
+    test('a persist failure during recovery does NOT re-throw or leave flag set', async () => {
+      // Even when both the transition AND the recovery persist fail, the
+      // in-memory flag MUST end up cleared. The recovery persist failure
+      // is logged but suppressed (the in-memory clear is what the next
+      // scheduler cycle reads, and the next normal persist will save it).
+      const agent = makeAgent({ id: 'wedge-double-fail', mode: 'agent' });
+      agentPool.getAgent.mockResolvedValue(agent);
+      scheduler._transitionMode = jest.fn().mockRejectedValue(new Error('transition-failed'));
+      // Persist fails too.
+      agentPool.persistAgentState.mockRejectedValueOnce(new Error('disk-full'));
+
+      await scheduler.stopAgentExecution('wedge-double-fail').catch(() => {});
+
+      expect(agent.stopRequested).toBe(false);
+    });
   });
 
   // ─── isAgentInScheduler ───────────────────────────────────────────────

package/src/core/agentPool.js

@@ -380,6 +380,18 @@ class AgentPool {
           originalLength: baseSystemPrompt?.length || 0,
           enhancedLength: enhancedSystemPrompt?.length || 0
         });
+
+        // The scheduler caches per-(agent, model) Responses-API prompts
+        // built from this agent's `originalSystemPrompt` + capabilities.
+        // Both inputs just changed, so any cached rebuilds are stale.
+        // No-op when the scheduler isn't attached (tests / very-early
+        // boot) or when it predates this method (old binaries during
+        // a rolling upgrade).
+        try {
+          this.scheduler?._invalidateNativePromptCache?.(agentId);
+        } catch (e) {
+          this.logger.debug?.('Failed to invalidate native prompt cache', { agentId, error: e.message });
+        }
       } catch (error) {
         this.logger.error(`Failed to regenerate system prompt with updated capabilities`, {
           agentId,