Build your personal knowledge base with Trilium Notes
TypeScript electronelectron-appknowledge-baseknowledge-graphknowledge-managementknowledge-management-graphlocal-firstnote-managmentnote-takernote-takingnotebooknotesnotes-apppersonal-knowledge-basepersonal-wikiscriptableself-hostedself-hostingwiki
test(llm): cover the Claude session pool and the ACP client pool
Elian Doran153434a40c36
diff --git a/apps/server/src/services/llm/providers/acp_client_pool.spec.ts b/apps/server/src/services/llm/providers/acp_client_pool.spec.tsnew file mode 100644index 0000000000..fe9fa05518--- /dev/null+++ b/apps/server/src/services/llm/providers/acp_client_pool.spec.ts@@ -0,0 +1,66 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++import type { AcpClient } from "./acp_client.js";+import type { AcpPoolConnection } from "./acp_client_pool.js";++const infoLogMock = vi.hoisted(() => vi.fn());+vi.mock("@triliumnext/core", () => ({+ getLog: () => ({ info: infoLogMock })+}));++const { AcpClientPool, IDLE_TIMEOUT_MS } = await import("./acp_client_pool.js");++describe("AcpClientPool", () => {+ beforeEach(() => {+ vi.useFakeTimers();+ infoLogMock.mockClear();+ });++ afterEach(() => {+ vi.useRealTimers();+ });++ it("keeps a newer process pooled when an older one reports its exit late", async () => {+ const pool = new AcpClientPool("Test");+ const { connect, connections, clients } = fakeConnector();++ const first = await pool.acquire(connect);+ pool.release();+ pool.dispose();+ const second = await pool.acquire(connect);+ expect(second.generation).toBe(first.generation + 1);++ connections[0].onExit(new Error("killed"));++ expect(pool.warm).toBe(true);+ expect(clients[1].dispose).not.toHaveBeenCalled();+ expect(infoLogMock).toHaveBeenCalledWith(expect.stringContaining("#1 ended (killed)"));+ });++ it("skips the idle reap when the process already exited on its own", async () => {+ const pool = new AcpClientPool("Test");+ const { connect, connections, clients } = fakeConnector();++ await pool.acquire(connect);+ pool.release();+ connections[0].onExit(new Error("crashed"));+ vi.advanceTimersByTime(IDLE_TIMEOUT_MS);++ expect(pool.warm).toBe(false);+ expect(clients[0].dispose).not.toHaveBeenCalled();+ expect(infoLogMock).not.toHaveBeenCalledWith(expect.stringContaining("reaping"));+ });+});++/** A `connect` callback that records each connection and hands out a live stub client. */+function fakeConnector() {+ const connections: AcpPoolConnection[] = [];+ const clients: { alive: boolean; dispose: ReturnType<typeof vi.fn> }[] = [];+ const connect = async (connection: AcpPoolConnection) => {+ connections.push(connection);+ const client = { alive: true, dispose: vi.fn() };+ clients.push(client);+ return client as unknown as AcpClient;+ };+ return { connect, connections, clients };+}diff --git a/apps/server/src/services/llm/providers/claude_agent.spec.ts b/apps/server/src/services/llm/providers/claude_agent.spec.tsindex 28877e1905..e08f475894 100644--- a/apps/server/src/services/llm/providers/claude_agent.spec.ts+++ b/apps/server/src/services/llm/providers/claude_agent.spec.ts@@ -240,8 +240,7 @@ describe("ClaudeAgentProvider.chatChunks", () => {// through to the raw `claude-opus-4-8[1m]`.expect(await usageModel({ model: "claude-opus-4-8[1m]" })).toBe("Claude Opus 4.8 (1M)");// An unrecognized ID passes through unchanged rather than becoming undefined.- expect(await usageModel({ model: "some-unknown-model" })).toBe("some-unknown-model");- });+ expect(await usageModel({ model: "some-unknown-model" })).toBe("some-unknown-model"); });it("ignores subagent traffic (non-null parent_tool_use_id)", async () => {scriptAgent([@@ -998,6 +997,18 @@ describe("ClaudeAgentProvider.chatChunks", () => {expect(retried).toContainEqual({ type: "text", content: "b" });});+ it("starts a new session after the agent's stream ended mid-turn", async () => {+ const provider = new ClaudeAgentProvider();+ const config = { chatNoteId: "note-ended" };+ scriptAgent([textDelta("cut off")]);+ const chunks = await collect(provider.chatChunks([{ role: "user", content: "q" }], config));+ expect(chunks).toContainEqual({ type: "text", content: "cut off" });++ scriptAgent([textDelta("fresh"), successResult()]);+ await collect(provider.chatChunks([{ role: "user", content: "q" }], config));+ expect(queryMock).toHaveBeenCalledTimes(2);+ });+it("keeps to the warm-session cap by closing idle sessions behind a busy oldest one", () => {const fakeSession = (): ClaudeSession => ({query: { close: vi.fn() } as unknown as ClaudeSession["query"],diff --git a/apps/server/src/services/llm/providers/claude_session_pool.spec.ts b/apps/server/src/services/llm/providers/claude_session_pool.spec.tsnew file mode 100644index 0000000000..61ce097f1e--- /dev/null+++ b/apps/server/src/services/llm/providers/claude_session_pool.spec.ts@@ -0,0 +1,157 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";++import type { ClaudeSession } from "./claude_session_pool.js";++const infoLogMock = vi.hoisted(() => vi.fn());+vi.mock("@triliumnext/core", () => ({+ getLog: () => ({ info: infoLogMock })+}));++const {+ closeSession, IDLE_TIMEOUT_MS, Pushable, releaseSession, rememberSession, resetClaudeSessionPoolForTests, takeWarmSession+} = await import("./claude_session_pool.js");++describe("Pushable", () => {+ it("queues pushes until consumed and hands a push straight to a waiting consumer", async () => {+ const pushable = new Pushable<string>();+ const iterator = pushable[Symbol.asyncIterator]();++ pushable.push("queued");+ expect(pushable.pending).toEqual(["queued"]);+ expect(await iterator.next()).toEqual({ value: "queued", done: false });++ const waiting = iterator.next();+ pushable.push("direct");+ expect(await waiting).toEqual({ value: "direct", done: false });+ expect(pushable.pending).toEqual([]);+ });++ it("settles every waiting consumer on end() and ignores later pushes", async () => {+ const pushable = new Pushable<string>();+ const iterator = pushable[Symbol.asyncIterator]();+ const waiters = [iterator.next(), iterator.next()];++ pushable.end();+ expect(await Promise.all(waiters)).toEqual([+ { value: undefined, done: true },+ { value: undefined, done: true }+ ]);++ pushable.push("too late");+ expect(pushable.pending).toEqual([]);+ expect(await iterator.next()).toEqual({ value: undefined, done: true });+ });+});++describe("Claude session pool", () => {+ beforeEach(() => {+ vi.useFakeTimers();+ infoLogMock.mockClear();+ });++ afterEach(() => {+ resetClaudeSessionPoolForTests();+ vi.useRealTimers();+ });++ it("hands a released session back on a matching fingerprint and marks it busy", () => {+ const session = fakeSession("fp");+ rememberSession("chat", session);+ releaseSession("chat", session);++ expect(takeWarmSession("unknown", "fp")).toBeUndefined();+ expect(takeWarmSession("chat", "fp")).toBe(session);+ expect(session.busy).toBe(true);+ expect(session.idleTimer).toBeUndefined();+ });++ it.each([+ [ "busy", (session: ClaudeSession) => { session.busy = true; }, "fp" ],+ [ "closed", (session: ClaudeSession) => { session.closed = true; }, "fp" ],+ [ "built with other options", () => {}, "other-fp" ]+ ])("retires a session that is %s instead of handing it out", (_state, mutate, fingerprint) => {+ const session = fakeSession("fp");+ rememberSession("chat", session);+ releaseSession("chat", session);+ mutate(session);++ expect(takeWarmSession("chat", fingerprint)).toBeUndefined();+ // Retired sessions leave the map, so the next lookup finds nothing.+ session.closed = false;+ session.busy = false;+ expect(takeWarmSession("chat", "fp")).toBeUndefined();+ });++ it("closes the previous session when a chat registers a new one", () => {+ const previous = fakeSession();+ const next = fakeSession();+ rememberSession("chat", previous);+ rememberSession("chat", previous);+ expect(previous.closed).toBe(false);++ rememberSession("chat", next);+ expect(previous.closed).toBe(true);+ expect(previous.query.close).toHaveBeenCalledOnce();+ expect(next.closed).toBe(false);+ });++ it("forgets a session released after its stream closed", () => {+ const session = fakeSession("fp");+ rememberSession("chat", session);+ session.closed = true;+ releaseSession("chat", session);++ expect(session.idleTimer).toBeUndefined();+ session.closed = false;+ expect(takeWarmSession("chat", "fp")).toBeUndefined();+ });++ it("reaps an idle session after the timeout, but spares one a turn picked up again", () => {+ const idle = fakeSession();+ rememberSession("idle", idle);+ releaseSession("idle", idle);++ const reused = fakeSession();+ rememberSession("reused", reused);+ releaseSession("reused", reused);+ // A turn that claims the session without going through the pool.+ reused.busy = true;++ vi.advanceTimersByTime(IDLE_TIMEOUT_MS);++ expect(idle.closed).toBe(true);+ expect(idle.idleTimer).toBeUndefined();+ expect(infoLogMock).toHaveBeenCalledWith(expect.stringContaining("chat idle"));+ expect(reused.closed).toBe(false);+ });++ it("closes a session only once and logs a failing close instead of throwing", () => {+ const session = fakeSession();+ vi.mocked(session.query.close).mockImplementation(() => {+ throw new Error("already dead");+ });++ closeSession("chat", session);+ closeSession("chat", session);++ expect(session.query.close).toHaveBeenCalledOnce();+ expect(infoLogMock).toHaveBeenCalledWith(expect.stringContaining("(already dead)"));++ const other = fakeSession();+ vi.mocked(other.query.close).mockImplementation(() => {+ throw "plain string";+ });+ closeSession("chat", other);+ expect(infoLogMock).toHaveBeenCalledWith(expect.stringContaining("(plain string)"));+ });+});++function fakeSession(fingerprint = ""): ClaudeSession {+ return {+ query: { close: vi.fn() } as unknown as ClaudeSession["query"],+ input: new Pushable(),+ fingerprint,+ closed: false,+ busy: false+ };+}