Skip to content

Build your personal knowledge base with Trilium Notes

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.ts
new file mode 100644
index 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.ts
index 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.ts
new file mode 100644
index 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
+ };
+}