@anteros/core 0.0.44 → 0.0.47

package/tests/agent-checkpoint.test.ts

@@ -0,0 +1,195 @@
+/**
+ * The durable checkpoint — a run that dies mid-loop (provider crash, process
+ * restart) continues from its last completed step instead of paying for the whole
+ * conversation again:
+ *
+ *  - the state is saved at a step boundary, never half a step;
+ *  - `resumeRun()` asks the model for the **next** step only;
+ *  - a run that comes back clears its state, a failed one keeps it;
+ *  - a store that misbehaves never fails the run.
+ */
+import { describe, it, expect, afterAll, spyOn } from "bun:test";
+import { Agent, define, v } from "../index";
+import type { AgentRunState, AgentRunStore } from "../index";
+import { at, fakeProvider, openaiText, openaiTool, request, type Fake } from "./fixtures/fake-provider";
+
+const servers: Fake[] = [];
+function track(fake: Fake): Fake {
+    servers.push(fake);
+    return fake;
+}
+
+afterAll(() => {
+    for (const server of servers) server.stop();
+});
+
+/** A store backed by a `Map`, counting what it is asked to do. */
+function memoryStore() {
+    const states = new Map<string, AgentRunState>();
+    const calls = { loads: 0, saves: 0, clears: 0 };
+
+    const store = {
+        states,
+        calls,
+        load(runId: string) {
+            calls.loads += 1;
+            return states.get(runId);
+        },
+        save(runId: string, state: AgentRunState) {
+            calls.saves += 1;
+            states.set(runId, state);
+        },
+        clear(runId: string) {
+            calls.clears += 1;
+            states.delete(runId);
+        },
+    };
+
+    return store satisfies AgentRunStore;
+}
+
+function makeAgent(provider: Fake, overrides: Record<string, any> = {}) {
+    return new Agent({
+        id: "resumable",
+        description: "An agent whose runs can be resumed.",
+        instructions: "You are a test agent.",
+        provider: {
+            model: "test-model",
+            apiKey: "test-key",
+            protocol: "openai",
+            baseUrl: provider.url,
+            options: { retries: 0 },
+        },
+        tools: {
+            echo: define.Tool({
+                id: "echo",
+                description: "Echoes the text back.",
+                inputSchema: v.object({ text: v.string().required() }),
+                execute: async ({ text }: any) => ({ echoed: text }),
+            }),
+        },
+        ...overrides,
+    } as any);
+}
+
+/** A run that calls a tool on its first model call, then dies on the second. */
+function dyingProvider(): Fake {
+    return track(fakeProvider((_body, _req, hits) => hits === 1
+        ? openaiTool("echo", { text: "hello" }, "call_echo")
+        : hits === 2
+            ? Response.json({ error: { message: "provider blew up" } }, { status: 400 })
+            : openaiText("done")));
+}
+
+describe("durable checkpoint", () => {
+    it("saves the last completed step, and a resume continues from it", async () => {
+        const provider = dyingProvider();
+        const store = memoryStore();
+        const agent = makeAgent(provider, { checkpoint: store });
+
+        await expect(agent.generate("say hello", { runId: "run-1" })).rejects.toThrow(/provider blew up/);
+
+        const saved = store.states.get("run-1");
+        expect(saved).toBeDefined();
+        expect(saved!.runId).toBe("run-1");
+        expect(saved!.agentId).toBe("resumable");
+        expect(saved!.step).toBe(1);
+        // The step finished with its tool result — the conversation is valid to replay
+        expect(at(saved!.messages, saved!.messages.length - 1).role).toBe("tool");
+        expect(saved!.usage.requests).toBe(1);
+        expect(saved!.toolStats.calls).toBe(1);
+        expect(typeof saved!.at).toBe("string");
+        // A failed run keeps its state
+        expect(store.calls.clears).toBe(0);
+
+        // A fresh agent — the store is the only thing carrying the run over
+        const fresh = makeAgent(provider, { checkpoint: store });
+        const before = provider.hits();
+        const resumed = await fresh.resumeRun("run-1");
+
+        // The completed step is not replayed through the model: one call, the next step
+        expect(provider.hits() - before).toBe(1);
+        expect(resumed.text).toBe("done");
+        expect(resumed.steps).toHaveLength(1);
+        expect(at(resumed.steps, 0).step).toBe(1);
+        // The whole conversation, not just the resumed segment; the counters are carried
+        expect(resumed.messages.slice(0, saved!.messages.length)).toEqual(saved!.messages);
+        expect(at(resumed.messages, resumed.messages.length - 1).role).toBe("assistant");
+        expect(resumed.usage.requests).toBe(2);
+        expect(resumed.toolStats.calls).toBe(1);
+        expect(request(provider, 2).body.messages.map((message: any) => message.role))
+            .toEqual(["system", "user", "assistant", "tool"]);
+        // A run that came back has nothing left to resume
+        expect(store.states.get("run-1")).toBeUndefined();
+        expect(store.calls.clears).toBe(1);
+    });
+
+    it("refuses an unknown run — and a resume without a store", async () => {
+        const provider = track(fakeProvider(() => openaiText("done")));
+        const store = memoryStore();
+
+        await expect(makeAgent(provider, { checkpoint: store }).resumeRun("never-started"))
+            .rejects.toMatchObject({ code: "AGENT_CHECKPOINT_NOT_FOUND" });
+
+        await expect(makeAgent(provider).resumeRun("run-1"))
+            .rejects.toMatchObject({ code: "AGENT_CHECKPOINT_REQUIRED" });
+        expect(provider.hits()).toBe(0);
+    });
+
+    it("clears the state of a successful run", async () => {
+        const provider = track(fakeProvider(() => openaiText("done")));
+        const store = memoryStore();
+
+        const result = await makeAgent(provider, { checkpoint: store }).generate("hi", { runId: "run-clear" });
+
+        expect(result.text).toBe("done");
+        expect(store.calls.saves).toBeGreaterThan(0);
+        expect(store.calls.clears).toBe(1);
+        expect(store.states.has("run-clear")).toBe(false);
+    });
+
+    it("takes the store from the call over the declaration", async () => {
+        const provider = track(fakeProvider(() => openaiText("done")));
+        const declared = memoryStore();
+        const callLevel = memoryStore();
+
+        await makeAgent(provider, { checkpoint: declared })
+            .generate("hi", { runId: "run-override", checkpoint: callLevel });
+
+        expect(callLevel.calls.saves).toBeGreaterThan(0);
+        expect(declared.calls.saves).toBe(0);
+    });
+
+    it("saves nothing without a run id", async () => {
+        const provider = track(fakeProvider(() => openaiText("done")));
+        const store = memoryStore();
+
+        await makeAgent(provider, { checkpoint: store }).generate("hi");
+
+        expect(store.calls.saves).toBe(0);
+        expect(store.calls.clears).toBe(0);
+    });
+
+    it("does not fail the run when the store cannot save", async () => {
+        const provider = track(fakeProvider(() => openaiText("done")));
+        const spy = spyOn(console, "error").mockImplementation(() => {});
+        const store: AgentRunStore = {
+            load: () => undefined,
+            save: () => {
+                throw new Error("disk full");
+            },
+            clear: () => {},
+        };
+
+        try {
+            const result = await makeAgent(provider, { checkpoint: store }).generate("hi", { runId: "run-broken-store" });
+
+            expect(result.text).toBe("done");
+            expect(result.finishReason).toBe("stop");
+            const logged = spy.mock.calls.map((call) => String(call[0])).join("\n");
+            expect(logged).toContain("run-broken-store");
+        } finally {
+            spy.mockRestore();
+        }
+    });
+});

package/tests/agent-hardening.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, afterAll } from "bun:test";
+import { Agent, define, v } from "../index";
+import { InMemoryAgentMemory } from "../lib/agent";
+import {
+    USAGE,
+    at,
+    fakeProvider,
+    openaiText,
+    openaiTool,
+    request,
+    type Fake,
+} from "./fixtures/fake-provider";
+
+/**
+ * The P1 hardening of `define.Agent`: delegation, fallbacks, budgets, cost,
+ * guardrails and the token-aware prompt window.
+ */
+
+const servers: Fake[] = [];
+function track(fake: Fake): Fake {
+    servers.push(fake);
+    return fake;
+}
+
+afterAll(() => {
+    for (const server of servers) server.stop();
+});
+
+function makeAgent(overrides: Record<string, any> = {}, provider: Record<string, any> = {}) {
+    return new Agent({
+        id: "hardened",
+        description: "A hardened test agent.",
+        instructions: "Answer.",
+        provider: {
+            model: "primary-model",
+            apiKey: "test-key",
+            protocol: "openai",
+            options: { retries: 0 },
+            ...provider,
+        },
+        ...overrides,
+    } as any);
+}
+
+/** A 500 the fallback chain must treat as retryable. */
+const serverError = () => Response.json({ error: { message: "boom" } }, { status: 500 });
+
+describe("model fallbacks", () => {
+    it("hands over to the next endpoint on a 5xx, and reports the model that answered", async () => {
+        const primary = track(fakeProvider(() => serverError()));
+        const secondary = track(fakeProvider(() => openaiText("from the fallback")));
+
+        const agent = makeAgent({}, {
+            baseUrl: primary.url,
+            fallbacks: [{ model: "fallback-model", baseUrl: secondary.url, apiKey: "fallback-key" }],
+        });
+
+        const result = await agent.generate("hi");
+
+        expect(result.text).toBe("from the fallback");
+        expect(result.model).toBe("fallback-model");
+        expect(primary.hits()).toBe(1);
+        expect(secondary.hits()).toBe(1);
+    });
+
+    it("does not fall back on a client error", async () => {
+        const primary = track(fakeProvider(() => Response.json({ error: { message: "bad schema" } }, { status: 400 })));
+        const secondary = track(fakeProvider(() => openaiText("should not happen")));
+
+        const agent = makeAgent({}, {
+            baseUrl: primary.url,
+            fallbacks: [{ model: "fallback-model", baseUrl: secondary.url }],
+        });
+
+        await expect(agent.generate("hi")).rejects.toBeDefined();
+        expect(secondary.hits()).toBe(0);
+    });
+});
+
+describe("run budget", () => {
+    it("stops on the token budget and answers the unanswered calls", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("act", {}) : openaiText("never asked")));
+
+        const agent = makeAgent({
+            tools: {
+                act: define.Tool({ id: "act", description: "Does something", inputSchema: v.object({}), execute: () => ({ ok: true }) }),
+            },
+        }, { baseUrl: provider.url });
+
+        // One call already exceeds it (USAGE totals 15 tokens)
+        const result = await agent.generate("go", { maxTokens: 5 });
+
+        expect(result.finishReason).toBe("budget");
+        expect(result.budget).toEqual({ limit: "tokens", value: 5 });
+        expect(at(result.toolResults, 0).errorCode).toBe("AGENT_BUDGET_EXHAUSTED");
+        // The assistant turn asked for a call: the conversation still answers it
+        expect(result.messages.at(-1)!.role).toBe("tool");
+    });
+
+    it("stops on the wall-clock budget between steps", async () => {
+        const provider = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("slow", {}) : openaiText("never asked")));
+
+        const agent = makeAgent({
+            tools: {
+                slow: define.Tool({
+                    id: "slow",
+                    description: "Takes its time",
+                    inputSchema: v.object({}),
+                    execute: () => new Promise((resolve) => setTimeout(() => resolve({ ok: true }), 40)),
+                }),
+            },
+        }, { baseUrl: provider.url });
+
+        const result = await agent.generate("go", { maxDurationMs: 5 });
+
+        expect(result.finishReason).toBe("budget");
+        expect(result.budget).toEqual({ limit: "duration", value: 5 });
+    });
+
+    it("turns pricing into a cost, and stops on the cost budget", async () => {
+        const provider = track(fakeProvider(() => openaiText("ok")));
+        const pricing = { input: 1_000, output: 0 }; // per million tokens
+
+        const cheap = makeAgent({}, { baseUrl: provider.url, pricing });
+        const first = await cheap.generate("hi");
+        // USAGE: 11 input tokens → 11 / 1e6 * 1000
+        expect(first.usage.cost).toBeCloseTo(0.011, 6);
+
+        const capped = makeAgent({}, { baseUrl: provider.url, pricing });
+        const second = await capped.generate("hi", { maxCost: 0.001 });
+        expect(second.finishReason).toBe("budget");
+        expect(second.budget).toEqual({ limit: "cost", value: 0.001 });
+    });
+});
+
+describe("guardrails", () => {
+    it("blocks the prompt before any model call", async () => {
+        const provider = track(fakeProvider(() => openaiText("should not happen")));
+        const agent = makeAgent({
+            guardrails: {
+                input: [{ name: "no-secrets", check: (value: string) => { if (value.includes("secret")) throw new Error("secret detected"); } }],
+            },
+        }, { baseUrl: provider.url });
+
+        await expect(agent.generate("my secret is 42")).rejects.toMatchObject({ code: "AGENT_GUARDRAIL_BLOCKED" });
+        expect(provider.hits()).toBe(0);
+    });
+
+    it("blocks the answer after the model produced it", async () => {
+        const provider = track(fakeProvider(() => openaiText("forbidden answer")));
+        const agent = makeAgent({
+            guardrails: {
+                output: [{ name: "no-forbidden", check: (value: string) => { if (value.includes("forbidden")) throw new Error("not allowed"); } }],
+            },
+        }, { baseUrl: provider.url });
+
+        await expect(agent.generate("hi")).rejects.toMatchObject({ code: "AGENT_GUARDRAIL_BLOCKED" });
+        expect(provider.hits()).toBe(1);
+    });
+});
+
+describe("prompt window in tokens", () => {
+    it("drops the oldest turns to respect `contextTokens`", async () => {
+        const provider = track(fakeProvider(() => openaiText("ok")));
+        const memory = new InMemoryAgentMemory();
+        const long = "a".repeat(2_400); // ~600 tokens each
+        await memory.save("t", [
+            { role: "user", content: long },
+            { role: "assistant", content: long },
+            { role: "user", content: long },
+            { role: "assistant", content: long },
+        ]);
+
+        const agent = makeAgent({ memory }, { baseUrl: provider.url });
+        await agent.generate("now", { thread: "t", contextTokens: 100 });
+
+        // The system prompt is part of `messages` on the OpenAI wire: only the
+        // current question survives the window, the four long turns are dropped.
+        const sent = request(provider, 0).body.messages;
+        expect(sent).toHaveLength(2);
+        expect(sent[0].role).toBe("system");
+        expect(sent[1].content).toBe("now");
+    });
+});
+
+describe("delegated runs", () => {
+    it("folds the sub-agent's usage into the parent's", async () => {
+        const child = track(fakeProvider(() => openaiText("child answer")));
+        const parent = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("helper", { input: "do it" }) : openaiText("parent answer")));
+
+        const helper = define.Agent({
+            id: "helper",
+            description: "A delegated agent",
+            instructions: "Help.",
+            provider: { model: "child-model", apiKey: "k", protocol: "openai", baseUrl: child.url, options: { retries: 0 } },
+        });
+
+        const agent = makeAgent({ agents: [helper] }, { baseUrl: parent.url });
+        const result = await agent.generate("go", { maxSteps: 3 });
+
+        expect(result.text).toBe("parent answer");
+        // Parent: 2 calls (tool round + answer). Child: 1 call.
+        expect(result.usage.requests).toBe(3);
+        expect(result.usage.totalTokens).toBe(USAGE.total_tokens * 3);
+    });
+
+    it("refuses a delegated approval instead of losing it", async () => {
+        const child = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("refund", {}) : openaiText("refunded")));
+        const parent = track(fakeProvider((_body, _req, hits) =>
+            hits === 1 ? openaiTool("helper", { input: "refund it" }) : openaiText("done")));
+
+        const helper = define.Agent({
+            id: "helper",
+            description: "A delegated agent",
+            instructions: "Help.",
+            provider: { model: "child-model", apiKey: "k", protocol: "openai", baseUrl: child.url, options: { retries: 0 } },
+            tools: {
+                refund: define.Tool({
+                    id: "refund",
+                    description: "Refunds an order",
+                    approval: true,
+                    inputSchema: v.object({}),
+                    execute: () => ({ ok: true }),
+                }),
+            },
+        });
+
+        const agent = makeAgent({ agents: [helper] }, { baseUrl: parent.url });
+        const result = await agent.generate("go", { maxSteps: 3 });
+
+        expect(at(result.toolResults, 0).errorCode).toBe("AGENT_APPROVAL_IN_DELEGATION");
+        expect(result.toolStats.byCode.AGENT_APPROVAL_IN_DELEGATION).toBe(1);
+    });
+});

package/tests/agent-memory.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeAll, afterAll } from "bun:test";
 import { Agent } from "../lib/agent";
-import { InMemoryAgentMemory, MongoAgentMemory, RedisAgentMemory } from "../lib/agentMemory";
+import { InMemoryAgentMemory, MongoAgentMemory, RedisAgentMemory, customAgentMemory, semanticRecall } from "../lib/agentMemory";
 import { replicatesCollection, replicatesMetaCollection } from "../database/deleteLog";
 import { formatConfig, cfg } from "../server/config";
 import { syncTenants } from "../database/tenant";
@@ -110,6 +110,180 @@ describe("agents.memory.InMemory", () => {
     });
 });
 
+// ─── Custom store ────────────────────────────────────────────────────────
+
+describe("agents.memory.custom", () => {
+    it("requires get, save and clear", () => {
+        expect(() => customAgentMemory({} as any)).toThrow(/needs `get`/);
+        expect(() => customAgentMemory({ get: () => [], save: () => {} } as any)).toThrow(/needs `clear`/);
+    });
+
+    it("scopes the key and caps the thread on save", async () => {
+        const seen: { key?: string; messages?: AgentMessage[] } = {};
+        const memory = customAgentMemory({
+            maxMessages: 2,
+            get: () => [],
+            save: (key, messages) => { seen.key = key; seen.messages = messages; },
+            clear: () => {},
+        });
+
+        await memory.save("chat", [
+            message("user", "1"),
+            message("assistant", "2"),
+            message("user", "3"),
+        ], { resourceId: "u1" });
+
+        expect(seen.key).toBe("u1:chat");
+        expect(seen.messages!.map((m) => m.content)).toEqual(["2", "3"]);
+        expect(await memory.get("chat", { resourceId: "u1" })).toEqual([]);
+    });
+
+    it("uses the bare thread id when the store is unscoped", async () => {
+        let key: string | undefined;
+        const memory = customAgentMemory({
+            scoped: false,
+            get: () => [],
+            save: (threadKey) => { key = threadKey; },
+            clear: () => {},
+        });
+        await memory.save("chat", [], { resourceId: "u1" });
+        expect(key).toBe("chat");
+    });
+
+    it("exposes the optional handlers only when given", async () => {
+        const plain = customAgentMemory({ get: () => [], save: () => {}, clear: () => {} });
+        expect("list" in plain).toBe(false);
+        expect("getState" in plain).toBe(false);
+        expect("collections" in plain).toBe(false);
+
+        const calls: string[] = [];
+        const full = customAgentMemory({
+            get: () => [],
+            save: () => {},
+            clear: () => {},
+            list: () => [{ threadId: "chat", messages: 2, updatedAt: new Date() }],
+            getState: () => ({ value: "# sheet" }),
+            setState: () => { calls.push("setState"); },
+            clearState: () => { calls.push("clearState"); },
+            collections: () => ["threads", "threads__state"],
+        });
+
+        expect((await full.list!({ resourceId: "u1", limit: 5 }))).toHaveLength(1);
+        expect(await full.getState!("u1", {})).toEqual({ value: "# sheet" });
+        await full.setState!("u1", { value: "x" });
+        await full.clearState!("u1");
+        expect(calls).toEqual(["setState", "clearState"]);
+        expect(full.collections!()).toEqual(["threads", "threads__state"]);
+    });
+
+    it("passes the caller context through to the handlers", async () => {
+        let seen: any;
+        const memory = customAgentMemory({
+            get: (_key, ctx) => { seen = ctx; return []; },
+            save: () => {},
+            clear: () => {},
+        });
+        await memory.get("chat", { resourceId: "u1", agentId: "support", tenant: "t1", thread: "chat" });
+        expect(seen).toMatchObject({ resourceId: "u1", agentId: "support", tenant: "t1", thread: "chat" });
+    });
+});
+
+// ─── Semantic recall ─────────────────────────────────────────────────────
+
+describe("agents.memory.semanticRecall", () => {
+    it("requires embed and search", () => {
+        expect(() => semanticRecall({} as any)).toThrow(/needs `embed` and `search`/);
+    });
+
+    it("recalls by meaning and prepends the hits", async () => {
+        const calls: any[] = [];
+        const processor = semanticRecall({
+            topK: 3,
+            messageRange: 2,
+            scope: "resource",
+            filter: { project: "A" },
+            embed: (batch, kind) => { calls.push(["embed", batch, kind]); return [[0.1, 0.2]]; },
+            search: (vector, query, ctx) => {
+                calls.push(["search", vector, query, ctx]);
+                return [{ id: "m1", text: "Le client a demandé un remboursement.", role: "assistant" }];
+            },
+        });
+
+        const messages = [{ role: "user", content: "Et le remboursement ?" }] as AgentMessage[];
+        const context = { thread: "chat-1", resourceId: "u-1" };
+        const out = await processor.load!(messages, context) as AgentMessage[];
+
+        expect(out).toHaveLength(2);
+        expect(out[0]!.role).toBe("system");
+        expect(String(out[0]!.content)).toContain("remboursement");
+        expect(calls[0]).toEqual(["embed", ["Et le remboursement ?"], "query"]);
+        expect(calls[1]).toEqual(["search", [0.1, 0.2], {
+            topK: 3,
+            messageRange: 2,
+            scope: "resource",
+            filter: { project: "A" },
+            thread: "chat-1",
+            resourceId: "u-1",
+        }, context]);
+    });
+
+    it("leaves the messages alone without a question or without hits", async () => {
+        const processor = semanticRecall({ embed: () => [[1]], search: () => [] });
+
+        const noQuestion = [{ role: "assistant", content: "hello" }] as AgentMessage[];
+        expect(await processor.load!(noQuestion, {})).toBe(noQuestion);
+
+        const noHits = [{ role: "user", content: "q" }] as AgentMessage[];
+        expect(await processor.load!(noHits, {})).toBe(noHits);
+    });
+
+    it("indexes new messages as passages, once", async () => {
+        const embedded: any[] = [];
+        const records: any[] = [];
+        let upsertCtx: any;
+        const processor = semanticRecall({
+            embed: (batch, kind) => { embedded.push([batch, kind]); return batch.map(() => [1, 2]); },
+            search: () => [],
+            upsert: (batch, ctx) => { records.push(...batch); upsertCtx = ctx; },
+        });
+
+        const messages = [
+            { role: "system", content: "prompt" },
+            { role: "user", content: "Bonjour" },
+            { role: "assistant", content: "Salut" },
+        ] as AgentMessage[];
+
+        const context = { thread: "chat-1", resourceId: "u-1" };
+        await processor.save!(messages, context);
+        expect(embedded).toEqual([[["Bonjour", "Salut"], "passage"]]);
+        expect(records.map((record) => record.text)).toEqual(["Bonjour", "Salut"]);
+        expect(records[0]).toMatchObject({ thread: "chat-1", resourceId: "u-1", role: "user", vector: [1, 2] });
+        expect(typeof records[0]!.id).toBe("string");
+        expect(upsertCtx).toBe(context);
+
+        // A second save of the same messages embeds nothing new.
+        await processor.save!(messages, { thread: "chat-1", resourceId: "u-1" });
+        expect(embedded).toHaveLength(1);
+        expect(records).toHaveLength(2);
+    });
+
+    it("recalls only, without upsert", async () => {
+        const processor = semanticRecall({ embed: () => [[1]], search: () => [] });
+        const messages = [{ role: "user", content: "q" }] as AgentMessage[];
+        expect(await processor.save!(messages, {})).toBe(messages);
+    });
+
+    it("accepts a custom formatter", async () => {
+        const processor = semanticRecall({
+            embed: () => [[1]],
+            search: () => [{ text: "A" }, { text: "B" }],
+            format: (hits) => hits.map((hit) => hit.text).join(" | "),
+        });
+        const out = await processor.load!([{ role: "user", content: "q" }] as AgentMessage[], {}) as AgentMessage[];
+        expect(String(out[0]!.content)).toContain("A | B");
+    });
+});
+
 // ─── MongoDB ─────────────────────────────────────────────────────────────
 
 describe("agents.memory.Mongo", () => {