onbuzz 5.0.1 → 5.1.0

package/src/services/__tests__/recall.whatsMyName.e2e.test.js

@@ -0,0 +1,151 @@
+/**
+ * End-to-end "what's my name?" recall test.
+ *
+ * Exercises the REAL pipeline — EmbeddingService + the memory/reminisce/document
+ * indexers + InMemoryJsonStore + autoRecall via aiService.augmentSystemPrompt —
+ * with a deterministic stub provider (so we test the plumbing, not embedding
+ * quality). The stub maps text to a topic basis vector by keyword:
+ *   - contains "name"  → [1,0,0,0]
+ *   - contains "sky"/"blue"/"color" → [0,1,0,0]
+ *   - otherwise        → [0,0,1,0]
+ * So "what's my name?" and "My name is Daniel" both embed to [1,0,0,0]
+ * (cosine 1 → clears the 0.78 gate), while unrelated facts stay orthogonal.
+ *
+ * Covers:
+ *   PER-AGENT scope
+ *     - the agent recalls a fact from its OWN reminisce (the "told in chat,
+ *       then cleared" path — the embedding persists) and its OWN memory.
+ *     - a fact in agent X is NOT recalled by agent Y (isolation).
+ *     - an unrelated fact is NOT surfaced for the name query (selectivity).
+ *   GLOBAL / shared scope
+ *     - with sharedUserMemory ON, a fact saved to the SHARED scope is recalled
+ *       by a DIFFERENT agent.
+ *     - with sharedUserMemory OFF, that shared fact is NOT recalled.
+ */
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import os from 'os';
+import fsp from 'fs/promises';
+import path from 'path';
+
+import { EmbeddingService } from '../embeddings/embeddingService.js';
+import { EmbeddingProvider } from '../embeddings/providerInterface.js';
+import { MemoryIndexer } from '../embeddings/indexers/memoryIndexer.js';
+import { ReminisceIndexer } from '../embeddings/indexers/reminisceIndexer.js';
+import { SHARED_MEMORY_SCOPE } from '../memoryService.js';
+import { default as AIService } from '../aiService.js';
+
+class TopicStubProvider extends EmbeddingProvider {
+  getInfo() {
+    return {
+      name: 'azure', modelId: 'stub-recall', dimensions: 4,
+      maxBatchSize: 32, maxTokensPerText: 1000,
+      distinguishesQueryAndDocument: false, isLocal: false,
+    };
+  }
+  getModelFingerprint() { return 'stub-recall:v1'; }
+  async _embed(texts) {
+    return texts.map((t) => {
+      const s = String(t).toLowerCase();
+      if (s.includes('name')) return [1, 0, 0, 0];
+      if (s.includes('sky') || s.includes('blue') || s.includes('color')) return [0, 1, 0, 0];
+      return [0, 0, 1, 0];
+    });
+  }
+}
+
+const NAME_FACT = 'My name is Daniel.';
+const QUESTION = "what's my name?";
+
+describe('recall e2e — "what\'s my name?"', () => {
+  let tmpDir, embeddingService, aiService;
+
+  beforeEach(async () => {
+    tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'loxia-recall-e2e-'));
+    embeddingService = new EmbeddingService({
+      config: {
+        provider: 'azure',
+        autoRecall: {
+          enabled: true, threshold: 0.78, topK: 5, maxTokens: 400,
+          surfaces: ['memory', 'reminisce', 'documents'],
+          sharedUserMemory: false,
+        },
+      },
+      apiKeyManager: { getEmbeddingApiKey: () => 'k' },
+      baseUrl: 'https://stub.example',
+      stateDir: tmpDir,
+      providerOverrides: { azure: () => new TopicStubProvider() },
+    });
+    aiService = new AIService({ backend: { baseUrl: 'https://stub.example' } }, null, null, null);
+    aiService.setEmbeddingService(embeddingService);
+  });
+
+  afterEach(async () => {
+    await fsp.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  // Seed helpers use the SAME embeddingService, so they write into the exact
+  // stores aiService's own indexers read back (getStore caches per scope).
+  const rememberMemory = (scope, content, id = 'mem-name') =>
+    new MemoryIndexer({ embeddingService }).indexOne(scope, { id, title: '', content });
+  const rememberConversation = (agentId, content, id = 'msg-name') =>
+    new ReminisceIndexer({ embeddingService }).indexOne(agentId, { id, role: 'user', content });
+
+  const ask = (agentId, q = QUESTION) => aiService.augmentSystemPrompt('SYSTEM', agentId, q);
+
+  // ── PER-AGENT scope ───────────────────────────────────────────────
+  describe('per-agent scope', () => {
+    test('recalls a fact from its OWN conversation (reminisce) — the post-clear case', async () => {
+      await rememberConversation('agentX', NAME_FACT);
+      const out = await ask('agentX');
+      expect(out).toContain('## RELEVANT CONTEXT (auto-recalled)');
+      expect(out).toContain('Daniel');
+    });
+
+    test('recalls a fact from its OWN saved memory', async () => {
+      await rememberMemory('agentX', NAME_FACT);
+      const out = await ask('agentX');
+      expect(out).toContain('Daniel');
+    });
+
+    test('does NOT recall another agent\'s fact (isolation; shared off)', async () => {
+      await rememberMemory('agentX', NAME_FACT);
+      await rememberConversation('agentX', NAME_FACT);
+      const out = await ask('agentY');           // different agent
+      expect(out).toBe('SYSTEM');                 // unchanged → nothing recalled
+      expect(out).not.toContain('Daniel');
+    });
+
+    test('does NOT surface an unrelated fact for the name question (selectivity)', async () => {
+      await rememberMemory('agentX', 'The sky is blue today.');
+      const out = await ask('agentX');
+      expect(out).toBe('SYSTEM');
+      expect(out).not.toContain('sky');
+    });
+  });
+
+  // ── GLOBAL / shared scope ─────────────────────────────────────────
+  describe('shared (global) scope', () => {
+    test('with sharedUserMemory ON, a DIFFERENT agent recalls a shared fact', async () => {
+      embeddingService.config.autoRecall.sharedUserMemory = true;
+      await rememberMemory(SHARED_MEMORY_SCOPE, NAME_FACT);   // saved to the shared store
+      const out = await ask('agentY');                        // agent that never heard it
+      expect(out).toContain('## RELEVANT CONTEXT (auto-recalled)');
+      expect(out).toContain('Daniel');
+    });
+
+    test('with sharedUserMemory OFF, the shared fact is NOT recalled', async () => {
+      embeddingService.config.autoRecall.sharedUserMemory = false;
+      await rememberMemory(SHARED_MEMORY_SCOPE, NAME_FACT);
+      const out = await ask('agentY');
+      expect(out).toBe('SYSTEM');
+      expect(out).not.toContain('Daniel');
+    });
+
+    test('the writer agent also benefits from shared recall', async () => {
+      embeddingService.config.autoRecall.sharedUserMemory = true;
+      await rememberMemory(SHARED_MEMORY_SCOPE, NAME_FACT);
+      const out = await ask('agentX');
+      expect(out).toContain('Daniel');
+    });
+  });
+});