factory-factory 0.3.21 → 0.4.1

package/dist/src/backend/services/session/service/acp/acp-runtime-manager.test.js

@@ -53,6 +53,7 @@ function createMockChildProcess() {
     const child = new EventEmitter();
     child.pid = 12_345;
     child.exitCode = null;
+    child.signalCode = null;
     child.killed = false;
     child.kill = vi.fn((signal) => {
         if (signal) {
@@ -69,6 +70,17 @@ function createMockChildProcess() {
     child.stdin = new PassThrough();
     return child;
 }
+function exitChildAfterSigterm(child) {
+    child.kill = vi.fn((signal) => {
+        if (signal === 'SIGTERM') {
+            queueMicrotask(() => {
+                child.signalCode = 'SIGTERM';
+                child.emit('exit', null, 'SIGTERM');
+            });
+        }
+        return true;
+    });
+}
 function defaultOptions() {
     return {
         provider: 'CLAUDE',
@@ -139,6 +151,15 @@ function setupSuccessfulSpawn() {
     mockSetSessionModel.mockResolvedValue({});
     return child;
 }
+function createDeferred() {
+    let resolvePromise;
+    let rejectPromise;
+    const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+    });
+    return { promise, resolve: resolvePromise, reject: rejectPromise };
+}
 describe('AcpRuntimeManager', () => {
     let manager;
     beforeEach(() => {
@@ -233,40 +254,104 @@ describe('AcpRuntimeManager', () => {
             mockSpawn.mockReturnValue(child);
             mockInitialize.mockImplementation(() => new Promise(() => {
             }));
-            const handlers = defaultHandlers();
-            const createPromise = manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext());
-            await vi.waitFor(() => {
+            vi.useFakeTimers();
+            try {
+                const handlers = defaultHandlers();
+                const createResult = manager
+                    .getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext())
+                    .then((handle) => ({ handle }), (error) => ({ error }));
+                let creationSettled = false;
+                void createResult.then(() => {
+                    creationSettled = true;
+                });
+                await vi.advanceTimersByTimeAsync(0);
                 expect(mockSpawn).toHaveBeenCalledTimes(1);
-            });
-            const spawnError = Object.assign(new Error('spawn claude-agent-acp ENOENT'), {
-                code: 'ENOENT',
-            });
-            child.emit('error', spawnError);
-            await expect(createPromise).rejects.toThrow(/Failed to spawn ACP adapter ".*": spawn claude-agent-acp ENOENT/);
-            expect(handlers.onError).toHaveBeenCalledWith('session-1', expect.any(Error));
+                const spawnError = Object.assign(new Error('spawn claude-agent-acp ENOENT'), {
+                    code: 'ENOENT',
+                });
+                child.emit('error', spawnError);
+                await vi.advanceTimersByTimeAsync(0);
+                expect(child.kill).toHaveBeenCalledWith('SIGTERM');
+                child.emit('close', -2, null);
+                await vi.advanceTimersByTimeAsync(0);
+                expect(creationSettled).toBe(true);
+                await expect(createResult).resolves.toMatchObject({
+                    error: {
+                        message: expect.stringMatching(/Failed to spawn ACP adapter ".*": spawn claude-agent-acp ENOENT/),
+                    },
+                });
+                expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
+                expect(handlers.onError).toHaveBeenCalledWith('session-1', expect.any(Error));
+            }
+            finally {
+                await vi.advanceTimersByTimeAsync(5000);
+                vi.useRealTimers();
+            }
         });
-        it('kills subprocess when initialization fails after spawn', async () => {
+        it('allows the subprocess to exit during the SIGTERM grace period after initialization fails', async () => {
             const child = createMockChildProcess();
+            exitChildAfterSigterm(child);
             mockSpawn.mockReturnValue(child);
             mockInitialize.mockRejectedValue(new Error('handshake failed'));
             await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('handshake failed');
+            expect(child.kill).toHaveBeenCalledTimes(1);
             expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).toHaveBeenCalledWith('SIGKILL');
+            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
             expect(mockNewSession).not.toHaveBeenCalled();
         });
+        it('does not signal a subprocess that already terminated from a signal', async () => {
+            const child = createMockChildProcess();
+            child.signalCode = 'SIGTERM';
+            mockSpawn.mockReturnValue(child);
+            mockInitialize.mockRejectedValue(new Error('handshake failed'));
+            vi.useFakeTimers();
+            try {
+                const creationPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+                const creationRejection = creationPromise.catch((error) => error);
+                await vi.advanceTimersByTimeAsync(5000);
+                await expect(creationRejection).resolves.toMatchObject({ message: 'handshake failed' });
+                expect(child.kill).not.toHaveBeenCalled();
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('escalates failed initialization cleanup to SIGKILL after the grace period', async () => {
+            const child = createMockChildProcess();
+            mockSpawn.mockReturnValue(child);
+            mockInitialize.mockRejectedValue(new Error('handshake failed'));
+            vi.useFakeTimers();
+            try {
+                const creationPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+                const creationRejection = creationPromise.catch((error) => error);
+                await vi.advanceTimersByTimeAsync(0);
+                expect(child.kill).toHaveBeenCalledWith('SIGTERM');
+                expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
+                await vi.advanceTimersByTimeAsync(4999);
+                expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
+                await vi.advanceTimersByTimeAsync(1);
+                await expect(creationRejection).resolves.toMatchObject({ message: 'handshake failed' });
+                expect(child.kill).toHaveBeenCalledWith('SIGKILL');
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
         it('times out when ACP initialize handshake never resolves', async () => {
             manager.setAcpStartupTimeoutMs(20);
             const child = createMockChildProcess();
+            exitChildAfterSigterm(child);
             mockSpawn.mockReturnValue(child);
             mockInitialize.mockImplementation(() => new Promise(() => {
             }));
             await expect(manager.getOrCreateClient('session-timeout-init', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP initialize handshake timed out');
             expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).toHaveBeenCalledWith('SIGKILL');
+            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
         });
         it('times out when ACP session creation never resolves', async () => {
             manager.setAcpStartupTimeoutMs(20);
             const child = createMockChildProcess();
+            exitChildAfterSigterm(child);
             mockSpawn.mockReturnValue(child);
             mockInitialize.mockResolvedValue({
                 protocolVersion: 1,
@@ -277,7 +362,7 @@ describe('AcpRuntimeManager', () => {
             }));
             await expect(manager.getOrCreateClient('session-timeout-new-session', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP session creation timed out');
             expect(child.kill).toHaveBeenCalledWith('SIGTERM');
-            expect(child.kill).toHaveBeenCalledWith('SIGKILL');
+            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
         });
         it('returns existing handle if session already exists and is running', async () => {
             setupSuccessfulSpawn();
@@ -356,7 +441,8 @@ describe('AcpRuntimeManager', () => {
             expect(handle.configOptions).toEqual(expectedConfigOptions);
         });
         it('fails fast when ACP newSession omits configOptions', async () => {
-            setupSuccessfulSpawn();
+            const child = setupSuccessfulSpawn();
+            exitChildAfterSigterm(child);
             mockNewSession.mockResolvedValueOnce({
                 sessionId: 'provider-session-123',
             });
@@ -402,7 +488,8 @@ describe('AcpRuntimeManager', () => {
             ]));
         });
         it('fails fast when ACP newSession omits required model/mode categories', async () => {
-            setupSuccessfulSpawn();
+            const child = setupSuccessfulSpawn();
+            exitChildAfterSigterm(child);
             mockNewSession.mockResolvedValueOnce({
                 sessionId: 'provider-session-123',
                 configOptions: [
@@ -492,6 +579,24 @@ describe('AcpRuntimeManager', () => {
             expect(child.kill).toHaveBeenCalledWith('SIGTERM');
             expect(manager.getClient('session-1')).toBeUndefined();
         });
+        it('clears the SIGTERM grace-period timeout when the child exits quickly', async () => {
+            const child = setupSuccessfulSpawn();
+            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            child.kill = vi.fn(() => {
+                child.exitCode = 0;
+                child.emit('exit', 0, null);
+                return true;
+            });
+            vi.useFakeTimers();
+            try {
+                await manager.stopClient('session-1');
+                expect(child.kill).toHaveBeenCalledWith('SIGTERM');
+                expect(vi.getTimerCount()).toBe(0);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
         it('escalates to SIGKILL after timeout', async () => {
             const child = setupSuccessfulSpawn();
             await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
@@ -546,6 +651,28 @@ describe('AcpRuntimeManager', () => {
             ]);
             expect(result2).toBeUndefined();
         });
+        it('aborts in-flight client creation and cleans up the spawned subprocess', async () => {
+            const child = createMockChildProcess();
+            exitChildAfterSigterm(child);
+            mockSpawn.mockReturnValue(child);
+            mockInitialize.mockImplementation(() => new Promise(() => {
+            }));
+            const createPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            const createRejection = createPromise.catch((error) => error);
+            await vi.waitFor(() => {
+                expect(mockSpawn).toHaveBeenCalledTimes(1);
+                expect(manager.getPendingClient('session-1')).toBeDefined();
+            });
+            await manager.stopClient('session-1');
+            await expect(createRejection).resolves.toMatchObject({
+                message: expect.stringContaining('ACP session stop requested'),
+            });
+            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
+            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
+            expect(manager.isStopInProgress('session-1')).toBe(false);
+            expect(manager.getClient('session-1')).toBeUndefined();
+            expect(manager.getPendingClient('session-1')).toBeUndefined();
+        });
         it('skips exit handler when stop is in progress', async () => {
             const child = setupSuccessfulSpawn();
             const handlers = defaultHandlers();
@@ -637,7 +764,7 @@ describe('AcpRuntimeManager', () => {
             expect(handlers.onExit).not.toHaveBeenCalled();
             expect(manager.getClient('session-1')).toBe(newHandle);
         });
-        it('keeps newer client tracked when old stop exits later', async () => {
+        it('rejects client creation while a stop is in progress', async () => {
             const firstChild = setupSuccessfulSpawn();
             await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
             firstChild.kill = vi.fn((signal) => {
@@ -651,15 +778,17 @@ describe('AcpRuntimeManager', () => {
                 expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
             });
             const secondChild = createMockChildProcess();
+            exitChildAfterSigterm(secondChild);
             mockSpawn.mockReturnValueOnce(secondChild);
-            const restartedHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
-            expect(restartedHandle.child).toBe(secondChild);
+            await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP session stop requested');
+            expect(secondChild.kill).toHaveBeenCalledWith('SIGTERM');
+            expect(secondChild.kill).not.toHaveBeenCalledWith('SIGKILL');
             firstChild.exitCode = 0;
             firstChild.emit('exit', 0, null);
             await stopPromise;
-            expect(manager.getClient('session-1')).toBe(restartedHandle);
+            expect(manager.getClient('session-1')).toBeUndefined();
         });
-        it('preserves in-flight pending creation when stale stop exit fires', async () => {
+        it('wires child error handlers before aborting creation during stop', async () => {
             const firstChild = setupSuccessfulSpawn();
             await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
             firstChild.kill = vi.fn((signal) => {
@@ -673,34 +802,131 @@ describe('AcpRuntimeManager', () => {
                 expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
             });
             const secondChild = createMockChildProcess();
+            secondChild.kill = vi.fn((signal) => {
+                if (signal === 'SIGTERM') {
+                    secondChild.emit('error', new Error('cleanup child error'));
+                    queueMicrotask(() => {
+                        secondChild.exitCode = 0;
+                        secondChild.emit('exit', 0, null);
+                    });
+                }
+                return true;
+            });
             mockSpawn.mockReturnValueOnce(secondChild);
-            let resolveSecondInit;
-            mockInitialize.mockImplementationOnce(() => new Promise((resolve) => {
-                resolveSecondInit = resolve;
-            }));
-            const pendingRestart = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            const handlers = defaultHandlers();
+            await expect(manager.getOrCreateClient('session-1', defaultOptions(), handlers, defaultContext())).rejects.toThrow('ACP session stop requested');
+            expect(secondChild.kill).toHaveBeenCalledWith('SIGTERM');
+            expect(secondChild.kill).not.toHaveBeenCalledWith('SIGKILL');
             await vi.waitFor(() => {
-                expect(mockSpawn).toHaveBeenCalledTimes(2);
+                expect(handlers.onError).toHaveBeenCalledWith('session-1', expect.any(Error));
             });
-            const pendingBeforeStaleExit = manager.getPendingClient('session-1');
-            expect(pendingBeforeStaleExit).toBeDefined();
             firstChild.exitCode = 0;
             firstChild.emit('exit', 0, null);
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            expect(manager.getPendingClient('session-1')).toBe(pendingBeforeStaleExit);
-            const internalManager = manager;
-            expect(internalManager.creationLocks.has('session-1')).toBe(true);
-            expect(internalManager.lockRefCounts.get('session-1')).toBeGreaterThan(0);
-            resolveSecondInit({
-                protocolVersion: 1,
-                agentCapabilities: {},
-                agentInfo: { name: 'test' },
+            await stopPromise;
+        });
+        it('clears creation lock bookkeeping when stop rejects a concurrent create', async () => {
+            const firstChild = setupSuccessfulSpawn();
+            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            firstChild.kill = vi.fn((signal) => {
+                if (signal) {
+                    firstChild.killed = true;
+                }
+                return true;
             });
-            const restartedHandle = await pendingRestart;
-            expect(restartedHandle.child).toBe(secondChild);
+            const stopPromise = manager.stopClient('session-1');
+            await vi.waitFor(() => {
+                expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
+            });
+            const secondChild = createMockChildProcess();
+            exitChildAfterSigterm(secondChild);
+            mockSpawn.mockReturnValueOnce(secondChild);
+            await expect(manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP session stop requested');
+            const internalManager = manager;
+            expect(internalManager.creationLocks.has('session-1')).toBe(false);
+            expect(internalManager.lockRefCounts.has('session-1')).toBe(false);
+            firstChild.exitCode = 0;
+            firstChild.emit('exit', 0, null);
             await stopPromise;
         });
     });
+    describe('stopAllClients', () => {
+        it('clears per-client shutdown timeouts when clients stop quickly', async () => {
+            const firstChild = setupSuccessfulSpawn();
+            await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            const secondChild = createMockChildProcess();
+            mockSpawn.mockReturnValueOnce(secondChild);
+            await manager.getOrCreateClient('session-2', { ...defaultOptions(), sessionId: 'session-2' }, defaultHandlers(), defaultContext());
+            firstChild.kill = vi.fn(() => {
+                firstChild.exitCode = 0;
+                firstChild.emit('exit', 0, null);
+                return true;
+            });
+            secondChild.kill = vi.fn(() => {
+                secondChild.exitCode = 0;
+                secondChild.emit('exit', 0, null);
+                return true;
+            });
+            vi.useFakeTimers();
+            try {
+                await manager.stopAllClients(10_000);
+                expect(firstChild.kill).toHaveBeenCalledWith('SIGTERM');
+                expect(secondChild.kill).toHaveBeenCalledWith('SIGTERM');
+                expect(vi.getTimerCount()).toBe(0);
+                expect([...manager.getAllClients()]).toEqual([]);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('rejects new client creation after shutdown begins', async () => {
+            await manager.stopAllClients();
+            await expect(manager.getOrCreateClient('session-after-shutdown', defaultOptions(), defaultHandlers(), defaultContext())).rejects.toThrow('ACP runtime manager is shutting down');
+            expect(mockSpawn).not.toHaveBeenCalled();
+        });
+        it('aborts in-flight client creation and cleans up the spawned subprocess', async () => {
+            const child = createMockChildProcess();
+            exitChildAfterSigterm(child);
+            mockSpawn.mockReturnValue(child);
+            mockInitialize.mockImplementation(() => new Promise(() => {
+            }));
+            const createPromise = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            const createRejection = createPromise.catch((error) => error);
+            await vi.waitFor(() => {
+                expect(mockSpawn).toHaveBeenCalledTimes(1);
+            });
+            await manager.stopAllClients(50);
+            await expect(createRejection).resolves.toMatchObject({
+                message: expect.stringContaining('ACP runtime manager is shutting down'),
+            });
+            expect(child.kill).toHaveBeenCalledWith('SIGTERM');
+            expect(child.kill).not.toHaveBeenCalledWith('SIGKILL');
+            expect(manager.getClient('session-1')).toBeUndefined();
+            expect(manager.getPendingClient('session-1')).toBeUndefined();
+        });
+        it('rejects queued creation requests after an in-flight creation is aborted', async () => {
+            const child = createMockChildProcess();
+            exitChildAfterSigterm(child);
+            mockSpawn.mockReturnValue(child);
+            mockInitialize.mockImplementation(() => new Promise(() => {
+            }));
+            const firstCreate = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            const firstRejection = firstCreate.catch((error) => error);
+            await vi.waitFor(() => {
+                expect(mockSpawn).toHaveBeenCalledTimes(1);
+            });
+            const secondCreate = manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            const secondRejection = secondCreate.catch((error) => error);
+            await manager.stopAllClients(50);
+            await expect(firstRejection).resolves.toMatchObject({
+                message: expect.stringContaining('ACP runtime manager is shutting down'),
+            });
+            await expect(secondRejection).resolves.toMatchObject({
+                message: expect.stringContaining('ACP runtime manager is shutting down'),
+            });
+            expect(mockSpawn).toHaveBeenCalledTimes(1);
+            expect(manager.getClient('session-1')).toBeUndefined();
+        });
+    });
     describe('sendPrompt', () => {
         it('sets isPromptInFlight, calls connection.prompt, clears flag on resolve', async () => {
             setupSuccessfulSpawn();
@@ -771,6 +997,75 @@ describe('AcpRuntimeManager', () => {
                 vi.useRealTimers();
             }
         });
+        it('does not clear or stop a replacement session when timeout cancel hangs', async () => {
+            setupSuccessfulSpawn();
+            mockPrompt.mockReturnValue(new Promise(() => undefined));
+            mockCancel.mockReturnValue(new Promise(() => undefined));
+            const firstHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            vi.useFakeTimers();
+            try {
+                const stalePrompt = manager.sendPrompt('session-1', [{ type: 'text', text: 'old prompt' }], 100);
+                const staleRejection = stalePrompt.catch((error) => error);
+                await vi.advanceTimersByTimeAsync(100);
+                expect(mockCancel).toHaveBeenCalledTimes(1);
+                const internalManager = manager;
+                internalManager.sessions.delete('session-1');
+                const replacementChild = setupSuccessfulSpawn();
+                const replacementHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+                replacementHandle.isPromptInFlight = true;
+                await vi.advanceTimersByTimeAsync(5000);
+                await expect(staleRejection).resolves.toBeInstanceOf(PromptTimeoutError);
+                expect(replacementHandle.isPromptInFlight).toBe(true);
+                expect(replacementChild.kill).not.toHaveBeenCalled();
+                expect(manager.getClient('session-1')).toBe(replacementHandle);
+                expect(firstHandle.isPromptInFlight).toBe(false);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
+        it('does not cancel a replacement session when an old prompt timeout fires', async () => {
+            const firstChild = setupSuccessfulSpawn();
+            mockPrompt.mockReturnValueOnce(new Promise(() => undefined));
+            mockCancel.mockResolvedValue(undefined);
+            const firstHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+            firstChild.kill = vi.fn((signal) => {
+                if (signal === 'SIGTERM') {
+                    firstChild.killed = true;
+                    firstChild.exitCode = 0;
+                    firstChild.emit('exit', 0, null);
+                }
+                return true;
+            });
+            vi.useFakeTimers();
+            try {
+                const stalePrompt = manager.sendPrompt('session-1', [{ type: 'text', text: 'old prompt' }], 100);
+                const staleRejection = stalePrompt.catch((error) => error);
+                await manager.stopClient('session-1');
+                expect(manager.getClient('session-1')).toBeUndefined();
+                const replacementPrompt = createDeferred();
+                setupSuccessfulSpawn();
+                mockPrompt.mockReturnValueOnce(replacementPrompt.promise);
+                const replacementHandle = await manager.getOrCreateClient('session-1', defaultOptions(), defaultHandlers(), defaultContext());
+                const replacementSend = manager.sendPrompt('session-1', [
+                    { type: 'text', text: 'new prompt' },
+                ]);
+                await Promise.resolve();
+                expect(replacementHandle.isPromptInFlight).toBe(true);
+                const cancelCallsBeforeStaleTimeout = mockCancel.mock.calls.length;
+                await vi.advanceTimersByTimeAsync(100);
+                await expect(staleRejection).resolves.toBeInstanceOf(PromptTimeoutError);
+                expect(mockCancel).toHaveBeenCalledTimes(cancelCallsBeforeStaleTimeout);
+                expect(replacementHandle.isPromptInFlight).toBe(true);
+                expect(firstHandle.isPromptInFlight).toBe(false);
+                replacementPrompt.resolve({ stopReason: 'end_turn' });
+                await expect(replacementSend).resolves.toEqual({ stopReason: 'end_turn' });
+                expect(replacementHandle.isPromptInFlight).toBe(false);
+            }
+            finally {
+                vi.useRealTimers();
+            }
+        });
         it('throws if no session found', async () => {
             await expect(manager.sendPrompt('nonexistent', [{ type: 'text', text: 'Hello' }])).rejects.toThrow('No ACP session found');
         });