import { runScenarios } from '../../../scripts/test-scenarios.mjs' import { describe, expect, it, vi } from 'vitest' import { AcpVirtualHarness, discoverAcpVirtualWorkspaces, acpCwdWorkspaceId, type AcpClientLike, } from '../src/acp/virtual-harness.js' import { AcpSessionHistoryCache } from '../src/session-history-cache.js' import type { AcpSessionArchivedData, AgentAcpFrameData } from '@dsh-remote/protocol' type AgentAcpClientLike = AcpClientLike function fakeAcp() { return { createSession: vi.fn(async (cwd: string) => ({ sessionId: 'acp_1', cwd })), listSessions: vi.fn(async () => [{ conversationId: 'remote-history', title: 'Remote history', createdAt: 1, updatedAt: 2 }]), prompt: vi.fn(async () => ({})), cancel: vi.fn(async () => ({})), listDirectory: vi.fn(async (path: string) => ({ path, home: path, crumbs: [{ name: 'repo', path, hidden: false }], entries: [], truncated: false, })), openStream: vi.fn(async () => ({ close: async () => undefined })), respond: vi.fn(async () => ({})), } } describe('AcpVirtualHarness', () => { it('recovers delayed ACP titles without stale catalog reads replacing newer metadata', async () => { await runScenarios(['delayed catalog', 'live rename', 'workspace refresh', 'manual rename', 'closed projection', 'retry exhausted', 'read timeout'].map(name => ({ name, run: async () => { vi.useFakeTimers() const catalog = (title: string) => [{ conversationId: 'remote-history', title, createdAt: 1, updatedAt: 2 }] const placeholder = 'New session - 2026-10-18T14:29:07.000Z' let onFrame!: (frame: AgentAcpFrameData) => void let resolveRead!: (items: ReturnType) => void let readSignal: AbortSignal | undefined const listSessions = vi.fn(async (_path: string, _backend?: string, _limit?: number, _signal?: AbortSignal) => catalog('Native title')) .mockResolvedValueOnce(catalog(placeholder)) .mockImplementationOnce((_path, _backend, _limit, signal) => { readSignal = signal return new Promise(resolve => { resolveRead = resolve }) }) const client = { ...fakeAcp(), listSessions, openStream: vi.fn(async (_id: string, handler: typeof onFrame) => { onFrame = handler; return { close: async () => undefined } }), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') const signal = new AbortController().signal const request = { sessionId: 'opencode:remote-history' } const emit = (update: Record) => onFrame({ frame: { method: 'session/update', params: { sessionId: 'remote-history', update } } } as AgentAcpFrameData) const projection = () => target.dispatch('session/projections', { args: { request } }, signal) try { await target.selectOrCreateWorkspace('/test') await target.dispatch('session/prompt', { args: { request: { ...request, content: [{ type: 'text', text: 'First request' }] } } }, signal) const rediscovery = name === 'workspace refresh' ? target.dispatch('session/list', { args: {} }, signal) : undefined if (!rediscovery) emit({ sessionUpdate: 'prompt_completed' }) expect(await projection()).toMatchObject({ ok: true, value: { values: { title: 'First request' } } }) expect(listSessions).toHaveBeenCalledTimes(2) if (name === 'live rename' || name === 'workspace refresh') emit({ sessionUpdate: 'session_info_update', title: 'Live title' }) if (name === 'manual rename') await target.dispatch('session/rename', { args: { request: { ...request, title: 'Manual title' } } }, signal) if (name === 'closed projection') { await target.close() expect(readSignal?.aborted).toBe(true) } if (name === 'retry exhausted') listSessions.mockResolvedValue(catalog(placeholder)) if (name !== 'read timeout') resolveRead(catalog(name === 'delayed catalog' || name === 'retry exhausted' ? placeholder : 'Stale title')) await rediscovery await vi.advanceTimersByTimeAsync(20_000) if (name === 'read timeout') { expect(readSignal?.aborted).toBe(true) resolveRead(catalog('Late title')) await vi.advanceTimersByTimeAsync(0) } if (name !== 'closed projection') { const title = name === 'live rename' || name === 'workspace refresh' ? 'Live title' : name === 'manual rename' ? 'Manual title' : name === 'retry exhausted' || name === 'read timeout' ? 'First request' : 'Native title' expect(await projection()).toMatchObject({ ok: true, value: { values: { title } } }) } expect(listSessions).toHaveBeenCalledTimes(name === 'delayed catalog' ? 3 : name === 'retry exhausted' ? 6 : 2) expect(vi.getTimerCount()).toBe(0) } finally { await target.close(); vi.useRealTimers() } } }))) }) it('restores OpenCode title metadata from history and accepts only its own live updates', async () => { await runScenarios(['New session - 2026-10-18T14:29:07.000Z', 'Native title'].map(title => ({ name: title, run: async () => { const client = { ...fakeAcp(), listSessions: vi.fn(async () => [{ conversationId: 'remote-history', title, createdAt: 1, updatedAt: 2 }]), loadSessionHistory: vi.fn(async () => ['Original request', 'Later request'].map((text, seq) => ({ type: 'event', event: { type: 'user/message', seq, time: 0, data: { content: [{ type: 'text', text }] }, } }))), openStream: vi.fn(async (_id: string, handler: (frame: AgentAcpFrameData) => void) => { onFrame = handler; return { close: async () => undefined } }), } let onFrame!: (frame: AgentAcpFrameData) => void const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') const controller = new AbortController() const request = { sessionId: 'opencode:remote-history' } const projection = () => target.dispatch('session/projections', { args: { request } }, controller.signal) let iterator: AsyncIterator | undefined try { await target.selectOrCreateWorkspace('/test') const stream = await target.open('session/follow', { args: { request } }, controller.signal) iterator = stream[Symbol.asyncIterator]() const expected = title === 'Native title' ? title : 'Original request' expect((await iterator.next()).value).toMatchObject({ type: 'snapshot', projections: { values: { title: expected } } }) // A stale placeholder catalog cannot overwrite the recovered title. await target.dispatch('session/list', { args: {} }, controller.signal) expect(await projection()).toMatchObject({ ok: true, value: { values: { title: expected } } }) for (const [sessionId, update] of [ ['other', { sessionUpdate: 'session_info_update', title: 'Other session' }], ['remote-history', { sessionUpdate: 'session_info_update', _meta: { retry: true } }], ] as const) onFrame({ frame: { method: 'session/update', params: { sessionId, update } } } as AgentAcpFrameData) expect(await projection()).toMatchObject({ ok: true, value: { values: { title: expected } } }) onFrame({ frame: { method: 'session/update', params: { sessionId: 'remote-history', update: { sessionUpdate: 'session_info_update', title: 'Confirmed title' } } } } as AgentAcpFrameData) expect(await projection()).toMatchObject({ ok: true, value: { values: { title: 'Confirmed title' } } }) } finally { controller.abort(); await iterator?.return?.(); await target.close() } } }))) }) it('requires exact registered session identities for model reads and changes', async () => { await runScenarios([ { id: 'opencode:remote-history', nativeId: 'remote-history' }, { id: 'other-history', nativeId: 'other-history' }, { id: 'history' }, { id: 'opencode:missing' }, { id: 'claude:remote-history' }, ].map(scenario => ({ name: scenario.id, run: async () => { const current = { provider: 'opencode', model: 'host/a' } const selected = { provider: 'opencode', model: 'host/b' } const client = { ...fakeAcp(), listSessions: vi.fn(async () => ['remote-history', 'other-history'].map(conversationId => ({ conversationId, title: conversationId, createdAt: 1, updatedAt: 2 }))), sessionModels: vi.fn(async () => ({ current, routable: true, failures: [], groups: [{ id: 'opencode', name: 'OpenCode', models: [{ id: 'host/a', name: 'A' }, { id: 'host/b', name: 'B' }] }] })), selectModel: vi.fn(async () => selected), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') const signal = new AbortController().signal try { await target.selectOrCreateWorkspace('/test') const request = { sessionId: scenario.id, ...selected } const models = await target.dispatch('session/models', { args: { request } }, signal) const selection = await target.dispatch('session/selectModel', { args: { request } }, signal) if (scenario.nativeId) { expect(models).toMatchObject({ ok: true, value: { current } }) expect(selection).toMatchObject({ ok: true, value: { selected } }) expect(client.sessionModels).toHaveBeenCalledWith(scenario.nativeId, 'opencode') expect(client.selectModel).toHaveBeenCalledTimes(1) expect(client.selectModel).toHaveBeenCalledWith(scenario.nativeId, 'opencode', selected) } else { expect(models).toMatchObject({ ok: false, error: { code: 'session-not-found' } }) expect(selection).toMatchObject({ ok: false, error: { code: 'session-not-found' } }) expect(client.sessionModels).not.toHaveBeenCalled() expect(client.selectModel).not.toHaveBeenCalled() } } finally { await target.close() } } }))) }) it('prefers exact model IDs and rejects ambiguous aliases before upstream mutation', async () => { await runScenarios([ { model: 'openrouter/anthropic/sonnet', expected: 'openrouter/anthropic/sonnet' }, { model: 'anthropic/sonnet', expected: 'anthropic/sonnet' }, { model: 'haiku', expected: 'vendor/haiku' }, { model: 'router/vendor/haiku', expected: 'vendor/haiku' }, { model: 'sonnet' }, { model: 'router/openrouter/anthropic/sonnet' }, { model: 'missing' }, ].map(scenario => ({ name: scenario.model, run: async () => { const client = { ...fakeAcp(), sessionModels: vi.fn(async () => ({ current: { provider: 'opencode', model: 'anthropic/sonnet' }, routable: true, failures: [], groups: [{ id: 'opencode', name: 'OpenCode', models: ['anthropic/sonnet', 'openrouter/anthropic/sonnet', 'vendor/haiku'].map(id => ({ id, name: id })) }] })), selectModel: vi.fn(async (_id: string, _backend: string, selection: { provider: string; model: string }) => selection), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') const signal = new AbortController().signal try { const workspace = await target.selectOrCreateWorkspace('/test') const request = { sessionId: workspace.sessionIds[0]!, provider: 'opencode', model: scenario.model } const result = await target.dispatch('session/selectModel', { args: { request } }, signal) if (scenario.expected) { const selected = { provider: 'opencode', model: scenario.expected } expect(result).toMatchObject({ ok: true, value: { selected } }) expect(client.selectModel).toHaveBeenCalledTimes(1) expect(client.selectModel).toHaveBeenCalledWith('remote-history', 'opencode', selected) expect(await target.dispatch('session/projections', { args: { request } }, signal)).toMatchObject({ ok: true, value: { values: { modelSelection: { next: selected } } } }) } else { expect(result).toMatchObject({ ok: false, error: { code: 'model-unavailable' } }) expect(client.selectModel).not.toHaveBeenCalled() } } finally { await target.close() } } }))) }) it('preserves authoritative history failures and permits recovery after retry', async () => { await runScenarios((['pi', 'claude', 'opencode'] as const).map(backend => ({ name: backend, run: async () => { const client = { ...fakeAcp(), loadSessionHistory: vi.fn(async () => [] as unknown[]) } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend) const signal = new AbortController().signal try { const workspace = await target.selectOrCreateWorkspace('/test') const request = { sessionId: workspace.sessionIds[0]! } for (const endpoint of ['session/history', 'session/page']) { client.loadSessionHistory.mockRejectedValueOnce(Object.assign(new Error('History reader is busy'), { code: 'ACP_HISTORY_BUSY' })) expect(await target.dispatch(endpoint, { args: { request } }, signal)).toMatchObject({ ok: false, error: { code: 'ACP_HISTORY_BUSY' } }) expect(await target.dispatch(endpoint, { args: { request } }, signal)).toMatchObject({ ok: true, value: { records: [] } }) } const events = [{ type: 'event', event: { type: 'user/message', seq: 0, time: 1, data: { content: [{ type: 'text', text: 'Saved prompt' }] } } }] client.loadSessionHistory.mockResolvedValueOnce(events) expect(await target.dispatch('session/history', { args: { request } }, signal)).toMatchObject({ ok: true, value: { records: events } }) } finally { await target.close() } } }))) }) it('deduplicates concurrent ACP history hydration across backends and reuses cached history across workspace switches', async () => { await runScenarios((['claude', 'hermes', 'opencode', 'pi'] as const).map(backend => ({ name: backend, run: async () => { const event = { type: 'event', event: { type: 'user/message', seq: 0, time: 1, data: { content: [{ type: 'text', text: 'Cached project prompt' }] } } } let resolveHistory!: (value: unknown[]) => void const client = { ...fakeAcp(), listSessions: vi.fn(async () => [{ conversationId: 's1', cwd: '/repo-a', title: 'Repo A', createdAt: 10, updatedAt: 20 }]), loadSessionHistory: vi.fn(() => new Promise(resolve => { resolveHistory = resolve })), } const cache = new AcpSessionHistoryCache() const signal = new AbortController().signal const first = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend, undefined, cache) try { const workspace = await first.selectWorkspace(`${backend}:cwd:/repo-a`) const request = { sessionId: workspace.sessionIds[0]!, address: { sessionId: workspace.sessionIds[0]! } } const projections = first.dispatch('session/projections', { args: { request } }, signal) const history = first.dispatch('session/history', { args: { request } }, signal) const page = first.dispatch('session/page', { args: { request } }, signal) expect(client.loadSessionHistory).toHaveBeenCalledTimes(1) resolveHistory([event]) await expect(projections).resolves.toMatchObject({ ok: true }) await expect(history).resolves.toMatchObject({ ok: true, value: { records: [event] } }) await expect(page).resolves.toMatchObject({ ok: true, value: { records: [event] } }) expect(first.openedSessionId).toBe(workspace.sessionIds[0]!) } finally { await first.close() } const second = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend, undefined, cache) try { const workspace = await second.selectWorkspace(`${backend}:cwd:/repo-a`) const request = { sessionId: workspace.sessionIds[0]!, address: { sessionId: workspace.sessionIds[0]! } } await expect(second.dispatch('session/history', { args: { request } }, signal)).resolves.toMatchObject({ ok: true, value: { records: [event] }, }) expect(client.loadSessionHistory).toHaveBeenCalledTimes(1) } finally { await second.close() } } }))) }) it('commits ACP model projections only after Host confirmation and fails closed on discovery errors', async () => { await runScenarios((['cursor', 'claude', 'pi', 'opencode', 'antigravity'] as const).map(backend => ({ name: backend, run: async () => { const current = { provider: backend, model: 'host/a' } const client = { ...fakeAcp(), sessionModels: vi.fn(async () => ({ current, routable: true, failures: [], groups: [{ id: backend, name: backend, models: [{ id: 'host/a', name: 'A' }, { id: 'host/b', name: 'B' }] }] })), selectModel: vi.fn(async () => { throw new Error('upstream rejected') }), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend) const signal = new AbortController().signal try { const workspace = await target.selectOrCreateWorkspace('/test') const sessionId = workspace.sessionIds[0]! const request = { sessionId, provider: backend, model: 'host/b' } expect(await target.dispatch('session/models', { args: { request } }, signal)).toMatchObject({ ok: true, value: { current } }) expect(await target.dispatch('session/selectModel', { args: { request } }, signal)).toMatchObject({ ok: false }) expect(client.selectModel).toHaveBeenCalledWith(backend === 'cursor' ? 'acp_1' : 'remote-history', backend, { provider: backend, model: 'host/b' }) expect(await target.dispatch('session/projections', { args: { request } }, signal)).toMatchObject({ ok: true, value: { values: { modelSelection: { next: current } } } }) client.sessionModels.mockRejectedValueOnce(new Error('catalog failed')) expect(await target.dispatch('session/models', { args: { request } }, signal)).toMatchObject({ ok: false }) } finally { await target.close() } } }))) }) it('requires native archive confirmation, retains history and applies shared catalog events', async () => { let notify!: (data: AcpSessionArchivedData) => void const unsubscribe = vi.fn() const client = { ...fakeAcp(), supportsArchive: () => true, archiveSession: vi.fn(async () => { throw new Error('native rejected') }), onSessionArchived: (handler: typeof notify) => { notify = handler; return unsubscribe }, loadSessionHistory: vi.fn(async () => []), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') const signal = new AbortController().signal try { const workspace = await target.selectOrCreateWorkspace('/test') const sessionId = workspace.sessionIds[0]! const invoke = (endpoint: string) => target.dispatch(endpoint, { args: { request: { sessionId } } }, signal) expect(await invoke('workspace/archiveSession')).toMatchObject({ ok: false }) expect(workspace.sessionIds).toContain(sessionId) client.archiveSession.mockImplementationOnce(async () => undefined as never) expect(await invoke('workspace/archiveSession')).toMatchObject({ ok: true, value: { archivedSessionIds: [sessionId] } }) expect(client.archiveSession).toHaveBeenLastCalledWith('remote-history', 'opencode') expect(await invoke('session/history')).toMatchObject({ ok: true }) notify({ backend: 'opencode', sessionId: 'other', archived: true }) expect(await target.dispatch('workspace/list', { args: {} }, signal)).toMatchObject({ ok: true, value: { archivedSessionIds: [sessionId, 'opencode:other'] } }) } finally { await target.close() } expect(unsubscribe).toHaveBeenCalledOnce() }) it('keeps a new AGY follow empty and reuses only the requested blank session', async () => { const client = { ...fakeAcp(), listSessions: vi.fn(async () => [{ conversationId: 'old', title: 'Old history', createdAt: 1, updatedAt: 2 }]), loadSessionHistory: vi.fn(async () => [{ type: 'event', event: { type: 'user/message', seq: 0, time: 1, data: {} } }]), } client.createSession.mockResolvedValue({ sessionId: 'new', cwd: '/test' }) const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'antigravity') const workspace = await target.selectOrCreateWorkspace('/test') const signal = new AbortController().signal const created = await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal) expect(created).toMatchObject({ ok: true, value: { sessionId: 'acp:new' } }) const stream = await target.open('session/follow', { args: { request: { address: { kind: 'session', sessionId: 'acp:new' } } } }, signal) const iterator = stream[Symbol.asyncIterator]() expect((await iterator.next()).value).toMatchObject({ type: 'snapshot', header: { id: 'acp:new' }, records: [], cursor: -1 }) await expect(target.dispatch('session/projections', { args: { request: { sessionId: 'acp:new' } } }, signal)) .resolves.toMatchObject({ ok: true, value: { kind: 'sequenced', asOfSeq: -1 } }) expect(client.loadSessionHistory).not.toHaveBeenCalled() const calls = client.createSession.mock.calls.length expect(await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId, sessionId: 'acp:new' } } }, signal)) .toMatchObject({ ok: true, value: { sessionId: 'acp:new' } }) expect(client.createSession.mock.calls).toHaveLength(calls) expect(await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal)) .toMatchObject({ ok: false, error: { code: 'session-already-exists' } }) await iterator.return?.() await target.close() }) it('passes AGY images and exposes attachments only in their own Session', async () => { const data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/l9sAAAAASUVORK5CYII=' let onFrame: ((frame: AgentAcpFrameData) => void) | undefined const client = { ...fakeAcp(), listSessions: vi.fn(async () => [{ conversationId: 'old', title: 'Old', createdAt: 1, updatedAt: 2 }]), openStream: vi.fn(async (_id: string, handler: (frame: AgentAcpFrameData) => void) => { onFrame = handler; return { close: async () => undefined } }), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'antigravity') const signal = new AbortController().signal try { const workspace = await target.selectOrCreateWorkspace('/test') await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal) expect(await target.dispatch('session/prompt', { args: { request: { sessionId: 'acp:acp_1', content: [{ type: 'image', mediaType: 'image/png', data }] } } }, signal)).toMatchObject({ ok: true }) expect(client.prompt).toHaveBeenCalledWith('acp_1', '', signal, [{ type: 'image', mimeType: 'image/png', data }], 'antigravity') const history = await target.dispatch('session/history', { args: { request: { sessionId: 'acp:acp_1' } } }, signal) as any const image = history.value.records.find((entry: any) => entry.event.type === 'user/message').event.data.content[0] expect(image).toMatchObject({ type: 'image', attachment: { mediaType: 'image/png', width: 1, height: 1 } }) expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'acp:acp_1', attachmentId: image.attachment.attachmentId } } }, signal)).toMatchObject({ ok: true, value: { data } }) // 0.2.2 clients send the full image reference instead of the bare id. expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'acp:acp_1', attachment: image.attachment } } }, signal)).toMatchObject({ ok: true, value: { data } }) expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'acp:old', attachmentId: image.attachment.attachmentId } } }, signal)).toMatchObject({ ok: false }) onFrame!({ frame: { method: 'session/update', params: { sessionId: 'acp_1', update: { sessionUpdate: 'prompt_completed' } } } } as AgentAcpFrameData) } finally { await target.close() } }) it('passes images and exposes attachments in Hermes sessions', async () => { const data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/l9sAAAAASUVORK5CYII=' let onFrame: ((frame: AgentAcpFrameData) => void) | undefined const client = { ...fakeAcp(), call: vi.fn(async (method: string) => method === 'session/new' ? { sessionId: 'hermes_1' } : {}), prompt: vi.fn(async () => ({})), openStream: vi.fn(async (_id: string, handler: (frame: AgentAcpFrameData) => void) => { onFrame = handler; return { close: async () => undefined } }), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'hermes') const signal = new AbortController().signal try { const workspace = await target.selectOrCreateWorkspace('/test') await target.dispatch('session/create', { args: { request: { workspaceId: workspace.workspaceId } } }, signal) expect(await target.dispatch('session/prompt', { args: { request: { sessionId: 'hermes:hermes_1', content: [{ type: 'image', mediaType: 'image/png', data }] } } }, signal)).toMatchObject({ ok: true }) expect(client.prompt).toHaveBeenCalledWith('hermes_1', '', signal, [{ type: 'image', mimeType: 'image/png', data }], 'hermes') const history = await target.dispatch('session/history', { args: { request: { sessionId: 'hermes:hermes_1' } } }, signal) as any const image = history.value.records.find((entry: any) => entry.event.type === 'user/message').event.data.content[0] expect(image).toMatchObject({ type: 'image', attachment: { mediaType: 'image/png', width: 1, height: 1 } }) expect(await target.dispatch('session/attachment', { args: { request: { sessionId: 'hermes:hermes_1', attachmentId: image.attachment.attachmentId } } }, signal)).toMatchObject({ ok: true, value: { data } }) onFrame!({ frame: { method: 'session/update', params: { sessionId: 'hermes_1', update: { sessionUpdate: 'prompt_completed' } } } } as AgentAcpFrameData) } finally { await target.close() } }) it('delegates unprojected global surfaces to the Host gateway', async () => { const hostCarrier = { invoke: vi.fn(async () => undefined), dispatch: vi.fn(async (endpoint: string) => ({ ok: true as const, value: { endpoint } })), open: vi.fn(async () => (async function* () { yield { type: 'ready' } })()), } const target = new AcpVirtualHarness(fakeAcp(), { deviceId: 'host-1', name: 'Host' }, 'antigravity', hostCarrier) const signal = new AbortController().signal await expect(target.dispatch('settings/describe', { args: {} }, signal)) .resolves.toEqual({ ok: true, value: { endpoint: 'settings/describe' } }) expect(hostCarrier.dispatch).toHaveBeenCalledWith('settings/describe', { args: {} }, signal) const stream = await target.open('account/watch', { args: {} }, signal) await expect(stream[Symbol.asyncIterator]().next()).resolves.toEqual({ done: false, value: { type: 'ready' } }) expect(hostCarrier.open).toHaveBeenCalledWith('account/watch', { args: {} }, signal) await target.close() }) it('provides the required native carrier stream baselines', async () => { await runScenarios([ { name: 'opens the Session control stream with the required baseline', run: async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) const stream = await target.open('session/control', {}, new AbortController().signal) const first = await stream[Symbol.asyncIterator]().next() expect(first.value).toEqual({ type: 'baseline', value: { projections: {} } }) await target.close() }, }, { name: 'opens the Workspace follow stream with the complete 0.2 baseline', run: async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) await target.selectOrCreateWorkspace('/workspace/repo') const stream = await target.open('workspace/follow', {}, new AbortController().signal) const first = await stream[Symbol.asyncIterator]().next() expect(first.value).toMatchObject({ type: 'baseline', value: { archivedSessionIds: [], pinnedSessionIds: [] }, }) await target.close() }, }, { name: 'opens the event stream with the required ready frame', run: async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) await target.selectOrCreateWorkspace('/workspace/repo') const stream = await target.open('$events', {}, new AbortController().signal) const first = await stream[Symbol.asyncIterator]().next() expect(first.value).toMatchObject({ type: 'ready', host: { home: '/workspace/repo' } }) await target.close() }, }, { name: 'answers the background-job roster without a terminal stream failure', run: async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') const rosterController = new AbortController() const roster = await target.open('job/list', { args: { request: { sessionId: 'acp:job' } } }, rosterController.signal) const rosterIterator = roster[Symbol.asyncIterator]() await expect(rosterIterator.next()).resolves.toEqual({ done: false, value: { type: 'rows', jobs: [] } }) rosterController.abort() await expect(rosterIterator.next()).resolves.toMatchObject({ done: true }) const followController = new AbortController() const follow = await target.open('job/follow', { args: { request: { jobId: 'job-1' } } }, followController.signal) followController.abort() await expect(follow[Symbol.asyncIterator]().next()).resolves.toMatchObject({ done: true }) await target.close() }, }, { name: 'emits opening snapshot with assistantStream baseline in session/follow', run: async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') await target.selectOrCreateWorkspace('/workspace/repo') const created = (await target.dispatch( 'session/create', { args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity') } }, }, new AbortController().signal, )) as { ok: true; value: { sessionId: string } } const controller = new AbortController() const source = await target.open( 'session/follow', { args: { request: { address: { kind: 'session', sessionId: created.value.sessionId }, assistantStream: true, }, }, }, controller.signal, ) const iterator = source[Symbol.asyncIterator]() const snapshot = await iterator.next() expect(snapshot.value).toMatchObject({ type: 'snapshot', header: { version: 3, id: created.value.sessionId }, assistantStream: { revision: 0 }, }) controller.abort() await iterator.return?.() await target.close() }, }, ]) }, 20000) it('forwards text prompts to Agent ACP', async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) await target.selectOrCreateWorkspace('/workspace/repo') await target.dispatch('session/create', { args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'cursor') } }, }, new AbortController().signal) const prompted = await target.dispatch('session/prompt', { args: { request: { sessionId: 'cursor:acp_1', content: [{ type: 'text', text: 'List files' }], } }, }, new AbortController().signal) expect(prompted.ok).toBe(true) expect(client.prompt).toHaveBeenCalledWith('acp_1', 'List files', expect.any(AbortSignal), [], 'cursor') expect(client.openStream).toHaveBeenCalled() await target.close() }) it('maps Typert approval outcomes to ACP respond decisions', async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }) await target.selectOrCreateWorkspace('/workspace/repo') await target.dispatch('session/create', { args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'cursor') } }, }, new AbortController().signal) // Seed a pending approval the same way stream frames would. ;(target as unknown as { pendingApprovals: Map }) .pendingApprovals.set('req_1', { requestHandle: 'req_1', sessionId: 'cursor:acp_1' }) await expect(target.dispatch('$events/result', { args: { eventId: 'req_1', outcome: { kind: 'result', value: 'allowed-once' } } }, new AbortController().signal)).resolves.toMatchObject({ ok: true }) expect(client.respond).toHaveBeenCalledWith('req_1', 'allow-once', undefined, expect.any(AbortSignal)) await target.close() }) it('loads and pages history only through the remote ACP authority', async () => { await runScenarios([ { name: 'loads session/page with address object from DSH session controller', run: async () => { const client = fakeAcp() const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') await target.selectOrCreateWorkspace('/workspace/repo') const created = (await target.dispatch( 'session/create', { args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity') } }, }, new AbortController().signal, )) as { ok: true; value: { sessionId: string } } const sessionId = created.value.sessionId // DSH SessionController sends address instead of sessionId: const pageResult = (await target.dispatch( 'session/page', { args: { request: { address: { kind: 'session', sessionId }, throughSeq: 0, }, }, }, new AbortController().signal, )) as { ok: true; value: { records: unknown[]; hasMore: boolean } } expect(pageResult.ok).toBe(true) expect(pageResult.value.records).toEqual([]) expect(pageResult.value.hasMore).toBe(false) // Send a prompt to create history events and verify follow snapshot cursor matches tail record seq await target.dispatch( 'session/prompt', { args: { request: { sessionId, content: [{ type: 'text', text: 'Hello Antigravity' }], }, }, }, new AbortController().signal, ) const followStream = await target.open( 'session/follow', { args: { request: { address: { kind: 'session', sessionId }, assistantStream: true, }, }, }, new AbortController().signal, ) const iterator = followStream[Symbol.asyncIterator]() const snapshotFrame = await iterator.next() expect(snapshotFrame.done).toBe(false) const snapshot = snapshotFrame.value as { type: string cursor: number records: Array<{ event: { seq: number } }> } expect(snapshot.type).toBe('snapshot') expect(snapshot.records.length).toBeGreaterThan(0) // The cursor MUST equal the tail entry's seq (assertPageThrough requirement) expect(snapshot.cursor).toBe(snapshot.records.at(-1)!.event.seq) // And session/page throughSeq returns records up to that seq const pageWithThrough = (await target.dispatch( 'session/page', { args: { request: { address: { kind: 'session', sessionId }, throughSeq: 0, }, }, }, new AbortController().signal, )) as { ok: true; value: { records: Array<{ event: { seq: number } }> } } expect(pageWithThrough.ok).toBe(true) expect(pageWithThrough.value.records.at(-1)!.event.seq).toBe(0) await target.close() }, }, { name: 'uses only the remote ACP history, including empty or unavailable history', run: async () => { const client = { ...fakeAcp(), listSessions: vi.fn(async () => [ { conversationId: 'remote-only', title: 'Remote', createdAt: 1, updatedAt: 2 }, ]), loadSessionHistory: vi.fn(async () => [] as unknown[]), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'antigravity') try { await target.selectOrCreateWorkspace('/workspace/repo') const history = () => target.dispatch( 'session/history', { args: { sessionId: 'acp:remote-only' } }, new AbortController().signal, ) expect(await history()).toMatchObject({ ok: true, value: { records: [] } }) client.loadSessionHistory.mockRejectedValueOnce(new Error('remote unavailable')) expect(await history()).toMatchObject({ ok: true, value: { records: [] } }) expect(client.loadSessionHistory).toHaveBeenCalledWith('acp:remote-only', 'antigravity') } finally { await target.close() } }, }, { name: 'hydrates session history via client.loadSessionHistory RPC when available', run: async () => { const mockEvents = [ { type: 'event', event: { type: 'turn/start', seq: 0, time: 1000, data: { turn: 1 } } }, { type: 'event', event: { type: 'step/start', seq: 1, time: 1000, data: { turn: 1, step: 1 } } }, { type: 'event', event: { type: 'user/message', seq: 2, time: 1000, data: { role: 'user', content: [{ type: 'text', text: 'hello' }] }, surfaceOp: 'append', }, }, { type: 'event', event: { type: 'assistant/message', seq: 3, time: 1001, data: { role: 'assistant', message: { content: [{ type: 'text', text: 'hi' }] } }, surfaceOp: 'append', }, }, { type: 'event', event: { type: 'step/end', seq: 4, time: 1001, data: { turn: 1, step: 1 } } }, { type: 'event', event: { type: 'turn/end', seq: 5, time: 1001, data: { turn: 1 } } }, ] const client: AcpClientLike = { createSession: vi.fn(async () => ({ sessionId: 'new-session' })), prompt: vi.fn(async () => {}), cancel: vi.fn(async () => {}), listDirectory: vi.fn(async () => []), openStream: vi.fn(async () => ({ close: async () => {} })), respond: vi.fn(async () => {}), listSessions: vi.fn(async () => [ { conversationId: 'remote-conv-1', title: 'Remote conversation', createdAt: 1000, updatedAt: 2000, }, ]), loadSessionHistory: vi.fn(async () => mockEvents), } const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') const workspaceId = acpCwdWorkspaceId('/var/lib/dsh/workspace/ds-harness-remote', 'antigravity') const ws = await target.selectWorkspace(workspaceId) expect(client.listSessions).toHaveBeenCalled() expect(ws.sessionIds).toContain('acp:remote-conv-1') const historyRes = await target.dispatch( 'session/history', { args: { sessionId: 'acp:remote-conv-1', maxMessages: 50 }, }, new AbortController().signal, ) expect(client.loadSessionHistory).toHaveBeenCalledWith('acp:remote-conv-1', 'antigravity') expect(historyRes.ok).toBe(true) if (historyRes.ok) { const records = (historyRes.value as any).records expect(records.length).toBe(6) const types = records.map((r: any) => r.event.type) expect(types).toContain('user/message') expect(types).toContain('assistant/message') } await target.close() }, }, ]) }, 15000) it('projects ordered ACP assistant and user turns into native events', async () => { await runScenarios([ { name: 'streams assistant response via assistant-stream frames and commits assistant/message event', run: async () => { let inboundHandler: ((frame: { frame: { method: string; params: unknown } }) => void) | undefined const client = { ...fakeAcp(), openStream: vi.fn(async (_sessionId: string, onFrame: (frame: unknown) => void) => { inboundHandler = onFrame as never return { close: vi.fn(async () => undefined) } }), } const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') await target.selectOrCreateWorkspace('/workspace/repo') const created = (await target.dispatch( 'session/create', { args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity') } }, }, new AbortController().signal, )) as { ok: true; value: { sessionId: string } } const sessionId = created.value.sessionId const followController = new AbortController() const followStream = await target.open( 'session/follow', { args: { request: { address: { kind: 'session', sessionId }, assistantStream: true, }, }, }, followController.signal, ) const iterator = followStream[Symbol.asyncIterator]() const snapshot = await iterator.next() expect(snapshot.value).toMatchObject({ type: 'snapshot' }) // Simulate ACP inbound events: agent_message_chunk -> prompt_completed expect(inboundHandler).toBeDefined() inboundHandler!({ frame: { method: 'session/update', params: { sessionId, update: { sessionUpdate: 'agent_message_chunk', text: 'Hello, World!', }, }, }, }) // Should receive turn/start and step/start events before assistant-stream frames const turnStart = await iterator.next() expect(turnStart.value).toMatchObject({ type: 'event', event: { type: 'turn/start' } }) const stepStart = await iterator.next() expect(stepStart.value).toMatchObject({ type: 'event', event: { type: 'step/start' } }) // Should receive assistant-stream start and chunk frames const startFrame = await iterator.next() expect(startFrame.value).toMatchObject({ type: 'assistant-stream', frame: { type: 'start', turn: 1 }, }) const chunk1 = await iterator.next() expect(chunk1.value).toMatchObject({ type: 'assistant-stream', frame: { type: 'chunk', chunk: { type: 'block-start', blockType: 'text' } }, }) const chunk2 = await iterator.next() expect(chunk2.value).toMatchObject({ type: 'assistant-stream', frame: { type: 'chunk', chunk: { type: 'text-delta', text: 'Hello, World!' } }, }) // Now emit prompt_completed inboundHandler!({ frame: { method: 'session/update', params: { sessionId, update: { sessionUpdate: 'prompt_completed', stopReason: 'end_turn', }, }, }, }) // Should receive block-end, finish, assistant/message event, and end frame const blockEnd = await iterator.next() expect(blockEnd.value).toMatchObject({ type: 'assistant-stream', frame: { type: 'chunk', chunk: { type: 'block-end', block: { text: 'Hello, World!' } } }, }) const finish = await iterator.next() expect(finish.value).toMatchObject({ type: 'assistant-stream', frame: { type: 'chunk', chunk: { type: 'finish', reason: { kind: 'stop' } } }, }) const msgEvent = await iterator.next() expect(msgEvent.value).toMatchObject({ type: 'event', event: { type: 'assistant/message', surfaceOp: 'append', data: { message: { role: 'assistant', content: [{ type: 'text', text: 'Hello, World!' }], }, }, }, }) const endFrame = await iterator.next() expect(endFrame.value).toMatchObject({ type: 'assistant-stream', frame: { type: 'end', outcome: { kind: 'committed', eventType: 'assistant/message', }, }, }) // Verify session/page returns the committed assistant/message in history const pageResult = (await target.dispatch( 'session/page', { args: { request: { address: { kind: 'session', sessionId }, cursor: -1, }, }, }, new AbortController().signal, )) as { ok: true; value: { records: Array<{ event: { type: string; data: unknown } }> } } expect(pageResult.ok).toBe(true) const assistantRecord = pageResult.value.records.find((r) => r.event.type === 'assistant/message') expect(assistantRecord).toBeDefined() expect(assistantRecord?.event.data).toMatchObject({ message: { role: 'assistant', content: [{ type: 'text', text: 'Hello, World!' }], }, stream: [ { type: 'chunk', time: expect.any(Number), chunk: { type: 'block-start', index: 0, blockType: 'text' }, }, { type: 'chunk', time: expect.any(Number), chunk: { type: 'text-delta', index: 0, text: 'Hello, World!' }, }, { type: 'chunk', time: expect.any(Number), chunk: { type: 'block-end', index: 0, block: { type: 'text', text: 'Hello, World!' } }, }, { type: 'chunk', time: expect.any(Number), chunk: { type: 'finish', reason: { kind: 'stop' } } }, ], }) followController.abort() await iterator.return?.() await target.close() }, }, { name: 'encloses user/message in turn/step and associates rpcId across multiple turns', run: async () => { let inboundHandler: ((frame: AgentAcpFrameData) => void) | undefined const client: AgentAcpClientLike = { createSession: vi.fn(async () => ({ sessionId: 'acp_multiturn' })), prompt: vi.fn(async () => {}), cancel: vi.fn(async () => {}), listDirectory: vi.fn(async () => []), openStream: vi.fn(async (_sid, onFrame) => { inboundHandler = onFrame return { close: async () => {} } }), respond: vi.fn(async () => {}), } const target = new AcpVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'antigravity') await target.selectOrCreateWorkspace('/workspace/repo') const created = (await target.dispatch( 'session/create', { args: { request: { workspaceId: acpCwdWorkspaceId('/workspace/repo', 'antigravity'), sessionId: 'acp:acp_multiturn', }, }, }, new AbortController().signal, )) as { ok: true; value: { sessionId: string } } const sessionId = created.value.sessionId const followController = new AbortController() const followStream = await target.open( 'session/follow', { args: { request: { address: { kind: 'session', sessionId }, assistantStream: true, }, }, }, followController.signal, ) const iterator = followStream[Symbol.asyncIterator]() await iterator.next() // snapshot // Turn 1 prompt await target.dispatch( 'session/prompt', { args: { request: { sessionId, requestId: 'req_turn_1', content: [{ type: 'text', text: 'First question' }], }, }, }, new AbortController().signal, ) // Should receive turn/start, step/start, user/message with rpcId const t1TurnStart = await iterator.next() expect(t1TurnStart.value).toMatchObject({ type: 'event', event: { type: 'turn/start', data: { turn: 1 } }, }) const t1StepStart = await iterator.next() expect(t1StepStart.value).toMatchObject({ type: 'event', event: { type: 'step/start', data: { turn: 1, step: 1 } }, }) const t1UserMsg = await iterator.next() expect(t1UserMsg.value).toMatchObject({ type: 'event', event: { type: 'user/message', surfaceOp: 'append', data: { role: 'user', content: [{ type: 'text', text: 'First question' }], source: { kind: 'user', rpcId: 'req_turn_1' }, }, }, }) // Reply turn 1 inboundHandler!({ streamId: 'stream-1', frame: { method: 'session/update', params: { sessionId, update: { sessionUpdate: 'agent_message_chunk', text: 'First answer' }, }, }, }) inboundHandler!({ streamId: 'stream-1', frame: { method: 'session/update', params: { sessionId, update: { sessionUpdate: 'prompt_completed', stopReason: 'end_turn' }, }, }, }) // Consume stream frames for turn 1 let frame = await iterator.next() while ( !frame.done && !(frame.value as { event?: { type: string } }).event?.type?.includes('turn/end') ) { frame = await iterator.next() } // Turn 2 prompt await target.dispatch( 'session/prompt', { args: { request: { sessionId, requestId: 'req_turn_2', content: [{ type: 'text', text: 'Second question' }], }, }, }, new AbortController().signal, ) // Should receive turn/start (turn 2), step/start (turn 2), user/message with rpcId req_turn_2 const t2TurnStart = await iterator.next() expect(t2TurnStart.value).toMatchObject({ type: 'event', event: { type: 'turn/start', data: { turn: 2 } }, }) const t2StepStart = await iterator.next() expect(t2StepStart.value).toMatchObject({ type: 'event', event: { type: 'step/start', data: { turn: 2, step: 1 } }, }) const t2UserMsg = await iterator.next() expect(t2UserMsg.value).toMatchObject({ type: 'event', event: { type: 'user/message', surfaceOp: 'append', data: { role: 'user', content: [{ type: 'text', text: 'Second question' }], source: { kind: 'user', rpcId: 'req_turn_2' }, }, }, }) followController.abort() await iterator.return?.() await target.close() }, }, ]) }, 10000) it('scopes workspace IDs by backend and rejects unscoped or other backend IDs', async () => { const cursorId = acpCwdWorkspaceId('/workspace/repo', 'cursor') const agyId = acpCwdWorkspaceId('/workspace/repo', 'antigravity') expect(cursorId).toBe('cursor:cwd:%2Fworkspace%2Frepo') expect(agyId).toBe('antigravity:cwd:%2Fworkspace%2Frepo') expect(agyId).not.toBe(cursorId) expect(() => acpCwdWorkspaceId('/workspace/repo', undefined as never)).toThrow('explicit ACP workspace backend') const catalog = { ...fakeAcp(), listWorkspaces: vi.fn(async () => [{ path: '/workspace/repo' }]) } expect((await discoverAcpVirtualWorkspaces(catalog, 'cursor'))[0].workspaceId).toBe(cursorId) expect((await discoverAcpVirtualWorkspaces(catalog, 'antigravity'))[0].workspaceId).toBe(agyId) const agy = new AcpVirtualHarness(fakeAcp(), { deviceId: 'host', name: 'Host' }, 'antigravity') const cursor = new AcpVirtualHarness(fakeAcp(), { deviceId: 'host', name: 'Host' }) try { expect((await agy.selectWorkspace(agyId)).workspaceId).toBe(agyId) expect((await cursor.selectWorkspace(cursorId)).workspaceId).toBe(cursorId) await expect(agy.selectWorkspace(cursorId)).rejects.toThrow('no longer available') await expect(agy.selectWorkspace('/workspace/repo')).rejects.toThrow('no longer available') await expect(cursor.selectWorkspace('/workspace/repo')).rejects.toThrow('no longer available') await expect(cursor.selectWorkspace(agyId)).rejects.toThrow('no longer available') } finally { await agy.close(); await cursor.close() } }) it('projects and toggles ACP permission presets and auto-approves requests under danger-full-access', async () => { let onFrame!: (frame: AgentAcpFrameData) => void const client = { ...fakeAcp(), openStream: vi.fn(async (_id: string, handler: typeof onFrame) => { onFrame = handler; return { close: async () => undefined } }), respond: vi.fn(async () => ({})), selectPermission: vi.fn(async () => ({})), } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, 'opencode') const signal = new AbortController().signal try { const workspace = await target.selectOrCreateWorkspace('/test') const sessionId = workspace.sessionIds[0]! const request = { sessionId } const initial = await target.dispatch('session/projections', { args: { request } }, signal) expect(initial).toMatchObject({ ok: true, value: { values: { permissions: { options: [ { value: 'workspace-write' }, { value: 'danger-full-access' }, ], currentValue: 'Host settings (not reported)', }, }, }, }) const commands = await target.dispatch('commands/list', { args: { request } }, signal) expect(commands).toMatchObject({ ok: true, value: [{ name: 'permission' }] }) const switchResult = await target.dispatch('commands/execute', { args: { agentId: sessionId, line: '/permission danger-full-access', images: [] } }, signal) expect(switchResult).toMatchObject({ ok: true, value: { result: { kind: 'success', text: 'preset danger-full-access' } } }) expect(client.selectPermission).toHaveBeenCalledWith('remote-history', 'opencode', 'danger-full-access') const updated = await target.dispatch('session/projections', { args: { request } }, signal) expect(updated).toMatchObject({ ok: true, value: { values: { permissions: { currentValue: 'danger-full-access', }, }, }, }) const followStream = await target.open('session/follow', { args: { request } }, signal) const iterator = followStream[Symbol.asyncIterator]() await iterator.next() onFrame({ frame: { method: 'session/request_permission', params: { requestHandle: 'handle_1', toolName: 'bash', reason: 'execute command', }, }, } as AgentAcpFrameData) expect(client.respond).toHaveBeenCalledWith('handle_1', 'allow-once') await target.dispatch('commands/execute', { args: { agentId: sessionId, line: '/permission workspace-write', images: [] } }, signal) const reverted = await target.dispatch('session/projections', { args: { request } }, signal) expect(reverted).toMatchObject({ ok: true, value: { values: { permissions: { currentValue: 'workspace-write', }, }, }, }) } finally { await target.close() } }) }) it.each(['claude', 'hermes'] as const)('%s routes direct files and terminal streams through ACP tools', async backend => { const client = { ...fakeAcp(), workspaceToolCall: vi.fn(async () => ({ entries: [] })) } const target = new AcpVirtualHarness(client, { deviceId: 'host', name: 'Host' }, backend) const signal = new AbortController().signal const scope = `${backend}:saved` try { const args = { workspaceFileScopeId: scope, path: '.' } expect(await target.dispatch('workspaceFiles/list', { args }, signal)).toMatchObject({ ok: true }) expect(client.workspaceToolCall).toHaveBeenCalledWith('saved', backend, 'workspaceFiles/list', args, signal) await target.open('terminal/follow', { args: { agentId: scope, id: 'term', attachmentId: 'attachment' } }, signal) expect(client.openStream).toHaveBeenLastCalledWith('saved', expect.any(Function), expect.any(Function), signal, { backend, endpoint: 'terminal/follow', args: { agentId: scope, id: 'term', attachmentId: 'attachment' } }) } finally { await target.close() } })