factory-factory 0.4.5 → 0.4.7

package/dist/src/backend/services/session/service/acp/codex-app-server-adapter/codex-app-server-acp-adapter.test.js

@@ -1,4 +1,5 @@
 import { describe, expect, it, vi } from 'vitest';
+import { SUBAGENT_TOOL_META_KEY, SUBAGENTS_CAPABILITY_META_KEY, SUBAGENTS_CHANGED_METHOD, SUBAGENTS_LIST_METHOD, SUBAGENTS_READ_METHOD, } from '../../../../../../shared/acp-protocol/subagents.js';
 import { CodexAppServerAcpAdapter } from './codex-app-server-acp-adapter.js';
 import { CodexRequestError } from './codex-rpc-client.js';
 function createMockConnection() {
@@ -10,6 +11,7 @@ function createMockConnection() {
         connection: {
             closed,
             sessionUpdate: vi.fn(async () => undefined),
+            extNotification: vi.fn(async () => undefined),
             requestPermission: vi.fn(() => {
                 return Promise.resolve({
                     outcome: { outcome: 'selected', optionId: 'allow_once' },
@@ -25,7 +27,7 @@ function createMockCodexClient() {
     const mocks = {
         start: vi.fn(),
         stop: vi.fn(async () => undefined),
-        request: vi.fn(),
+        request: vi.fn((method) => Promise.resolve(method === 'thread/goal/get' ? { goal: null } : undefined)),
         notify: vi.fn(),
         respondSuccess: vi.fn(),
         respondError: vi.fn(),
@@ -38,6 +40,9 @@ function createMockCodexClient() {
 function getCodexRequestCalls(codex, method) {
     return codex.request.mock.calls.filter((call) => call[0] === method);
 }
+function sendCodexNotification(adapter, method, params) {
+    return adapter.handleCodexNotification(method, params);
+}
 const DEFAULT_APPROVAL_POLICY = 'on-failure';
 const DEFAULT_ALLOWED_APPROVAL_POLICIES = [DEFAULT_APPROVAL_POLICY, 'on-request', 'never'];
 const DEFAULT_ALLOWED_SANDBOX_MODES = ['read-only', 'workspace-write', 'danger-full-access'];
@@ -78,6 +83,197 @@ async function initializeAdapterWithDefaultModel(adapter, codex, options) {
     });
 }
 describe('CodexAppServerAcpAdapter', () => {
+    it('advertises the versioned sub-agent browse capability', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        codex.request.mockResolvedValueOnce({});
+        codex.request.mockResolvedValueOnce({ requirements: {} });
+        codex.request.mockResolvedValueOnce({ data: DEFAULT_COLLABORATION_MODES, nextCursor: null });
+        codex.request.mockResolvedValueOnce({
+            data: [
+                {
+                    id: 'gpt-5',
+                    displayName: 'GPT-5',
+                    description: 'Default model',
+                    isDefault: true,
+                },
+            ],
+            nextCursor: null,
+        });
+        const result = await adapter.initialize({
+            protocolVersion: 1,
+            clientCapabilities: {},
+            clientInfo: { name: 'test-client', version: '0.0.1' },
+        });
+        expect(result.agentCapabilities?._meta).toEqual({
+            [SUBAGENTS_CAPABILITY_META_KEY]: {
+                version: 1,
+                list: true,
+                read: true,
+                notifications: true,
+            },
+        });
+    });
+    it('routes validated sub-agent extension methods and rejects unknown methods', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'parent-thread-1', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({ cwd: '/tmp/workspace', mcpServers: [] });
+        codex.request.mockResolvedValueOnce({
+            data: [
+                {
+                    id: 'child-thread-1',
+                    parentThreadId: 'parent-thread-1',
+                    name: 'reviewer',
+                    preview: 'Review the change',
+                    createdAt: 1_786_089_600,
+                    updatedAt: 1_786_093_200,
+                    status: { type: 'active', activeFlags: [] },
+                    turns: [],
+                },
+            ],
+            nextCursor: null,
+        });
+        await expect(adapter.extMethod(SUBAGENTS_LIST_METHOD, {
+            sessionId: 'sess_parent-thread-1',
+            cursor: null,
+            limit: 50,
+        })).resolves.toMatchObject({
+            subagents: [{ id: 'child-thread-1', status: 'running' }],
+            nextCursor: null,
+        });
+        await expect(adapter.extMethod('example.invalid/method', {})).rejects.toMatchObject({
+            code: -32_601,
+        });
+        await expect(adapter.extMethod(SUBAGENTS_READ_METHOD, {
+            sessionId: 'sess_parent-thread-1',
+            subagentId: '',
+        })).rejects.toMatchObject({ code: -32_602 });
+    });
+    it('invalidates one correlated child for terminal status changes and ignores unrelated threads', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'parent-thread-1', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        await adapter.newSession({ cwd: '/tmp/workspace', mcpServers: [] });
+        codex.request.mockResolvedValueOnce({
+            data: [
+                {
+                    id: 'child-thread-1',
+                    parentThreadId: 'parent-thread-1',
+                    name: 'reviewer',
+                    preview: 'Review the change',
+                    createdAt: 1_786_089_600,
+                    updatedAt: 1_786_093_200,
+                    status: { type: 'active', activeFlags: [] },
+                    turns: [],
+                },
+            ],
+            nextCursor: null,
+        });
+        await adapter.extMethod(SUBAGENTS_LIST_METHOD, {
+            sessionId: 'sess_parent-thread-1',
+            cursor: null,
+            limit: 50,
+        });
+        const handleCodexNotification = adapter.handleCodexNotification.bind(adapter);
+        await handleCodexNotification('thread/status/changed', {
+            threadId: 'child-thread-1',
+            status: { type: 'idle' },
+        });
+        await handleCodexNotification('thread/status/changed', {
+            threadId: 'unrelated-thread-1',
+            status: { type: 'systemError' },
+        });
+        expect(connection.extNotification).toHaveBeenCalledTimes(1);
+        expect(connection.extNotification).toHaveBeenCalledWith(SUBAGENTS_CHANGED_METHOD, {
+            sessionId: 'sess_parent-thread-1',
+            subagentId: 'child-thread-1',
+            change: 'completed',
+        });
+    });
+    it('throttles live transcript invalidations per remembered direct child', async () => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date('2026-08-08T12:00:00.000Z'));
+        try {
+            const { connection } = createMockConnection();
+            const { client: codexClient, mocks: codex } = createMockCodexClient();
+            const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+            await initializeAdapterWithDefaultModel(adapter, codex);
+            codex.request.mockResolvedValueOnce({
+                thread: { id: 'parent-thread-1', cwd: '/tmp/workspace' },
+                approvalPolicy: DEFAULT_APPROVAL_POLICY,
+                reasoningEffort: 'medium',
+            });
+            await adapter.newSession({ cwd: '/tmp/workspace', mcpServers: [] });
+            codex.request.mockResolvedValueOnce({
+                data: [
+                    {
+                        id: 'child-thread-1',
+                        parentThreadId: 'parent-thread-1',
+                        name: 'reviewer',
+                        preview: 'Review the change',
+                        status: { type: 'active', activeFlags: [] },
+                        turns: [],
+                    },
+                ],
+                nextCursor: null,
+            });
+            await adapter.extMethod(SUBAGENTS_LIST_METHOD, {
+                sessionId: 'sess_parent-thread-1',
+                cursor: null,
+                limit: 50,
+            });
+            const handleCodexNotification = adapter.handleCodexNotification.bind(adapter);
+            await handleCodexNotification('item/agentMessage/delta', {
+                threadId: 'child-thread-1',
+                turnId: 'child-turn-1',
+                itemId: 'child-item-1',
+                delta: 'first',
+            });
+            await handleCodexNotification('item/reasoning/summaryTextDelta', {
+                threadId: 'child-thread-1',
+                turnId: 'child-turn-1',
+                itemId: 'child-item-2',
+                delta: 'second',
+            });
+            await handleCodexNotification('item/agentMessage/delta', {
+                threadId: 'unrelated-thread-1',
+                turnId: 'foreign-turn-1',
+                itemId: 'foreign-item-1',
+                delta: 'ignore',
+            });
+            expect(connection.extNotification).toHaveBeenCalledTimes(1);
+            expect(connection.extNotification).toHaveBeenLastCalledWith(SUBAGENTS_CHANGED_METHOD, {
+                sessionId: 'sess_parent-thread-1',
+                subagentId: 'child-thread-1',
+                change: 'updated',
+            });
+            vi.advanceTimersByTime(1000);
+            await handleCodexNotification('item/commandExecution/outputDelta', {
+                threadId: 'child-thread-1',
+                turnId: 'child-turn-1',
+                itemId: 'child-item-3',
+                delta: 'later',
+            });
+            expect(connection.extNotification).toHaveBeenCalledTimes(2);
+        }
+        finally {
+            vi.useRealTimers();
+        }
+    });
     it('paginates model/list during initialize', async () => {
         const { connection } = createMockConnection();
         const { client: codexClient, mocks: codex } = createMockCodexClient();
@@ -431,7 +627,7 @@ describe('CodexAppServerAcpAdapter', () => {
             mcpServers: [],
         });
         connection.sessionUpdate.mockClear();
-        await adapter.handleCodexNotification('item/started', {
+        await sendCodexNotification(adapter, 'item/started', {
             threadId: 'thread_replay_dedupe',
             turnId: 'turn_replay_dedupe',
             item: {
@@ -451,13 +647,13 @@ describe('CodexAppServerAcpAdapter', () => {
                 command: 'cat README.md',
             },
         });
-        await adapter.handleCodexNotification('item/reasoning/summaryTextDelta', {
+        await sendCodexNotification(adapter, 'item/reasoning/summaryTextDelta', {
             threadId: 'thread_replay_dedupe',
             turnId: 'turn_replay_dedupe',
             itemId: 'item_replayed_reasoning',
             delta: '**From live**',
         });
-        await adapter.handleCodexNotification('item/completed', {
+        await sendCodexNotification(adapter, 'item/completed', {
             threadId: 'thread_replay_dedupe',
             turnId: 'turn_replay_dedupe',
             item: {
@@ -543,7 +739,7 @@ describe('CodexAppServerAcpAdapter', () => {
             cwd: '/tmp/workspace',
             mcpServers: [],
         });
-        await adapter.handleCodexNotification('item/started', {
+        await sendCodexNotification(adapter, 'item/started', {
             threadId: 'thread_command_handoff',
             turnId: 'turn_command_handoff',
             item: {
@@ -554,31 +750,46 @@ describe('CodexAppServerAcpAdapter', () => {
                 command: 'git commit -m "test"',
             },
         });
-        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+        await sendCodexNotification(adapter, 'item/commandExecution/outputDelta', {
             threadId: 'thread_command_handoff',
             turnId: 'turn_command_handoff',
             itemId: 'item_command_handoff',
             delta: 'Process running with session ID 96081',
         });
-        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+        await sendCodexNotification(adapter, 'item/commandExecution/outputDelta', {
             threadId: 'thread_command_handoff',
             turnId: 'turn_command_handoff',
             itemId: 'item_command_handoff',
             delta: 'still running',
         });
+        const completedItem = {
+            type: 'commandExecution',
+            id: 'item_command_handoff',
+            status: 'completed',
+            aggregatedOutput: 'Process exited with code 0',
+            exitCode: 0,
+        };
+        for (let count = 0; count < 2; count += 1) {
+            await sendCodexNotification(adapter, 'item/completed', {
+                threadId: 'thread_command_handoff',
+                turnId: 'turn_command_handoff',
+                item: completedItem,
+            });
+        }
         const updates = connection.sessionUpdate.mock.calls.map((call) => call[0].update);
         const inProgressUpdates = updates.filter((update) => update.sessionUpdate === 'tool_call_update' &&
             update.toolCallId === 'call_command_handoff' &&
             update.status === 'in_progress');
         expect(inProgressUpdates).toHaveLength(1);
-        expect(updates).toEqual(expect.arrayContaining([
+        const completedUpdates = updates.filter((update) => (update.sessionUpdate === 'tool_call' || update.sessionUpdate === 'tool_call_update') &&
+            update.toolCallId === 'call_command_handoff' &&
+            update.status === 'completed');
+        expect(completedUpdates).toEqual([
             expect.objectContaining({
                 sessionUpdate: 'tool_call_update',
-                toolCallId: 'call_command_handoff',
-                status: 'completed',
                 rawOutput: 'Process running with session ID 96081',
             }),
-        ]));
+        ]);
     });
     it('does not synthesize completion for normal output that mentions session handoff text', async () => {
         const { connection } = createMockConnection();
@@ -594,7 +805,7 @@ describe('CodexAppServerAcpAdapter', () => {
             cwd: '/tmp/workspace',
             mcpServers: [],
         });
-        await adapter.handleCodexNotification('item/started', {
+        await sendCodexNotification(adapter, 'item/started', {
             threadId: 'thread_command_log_output',
             turnId: 'turn_command_log_output',
             item: {
@@ -605,13 +816,13 @@ describe('CodexAppServerAcpAdapter', () => {
                 command: 'bash script.sh',
             },
         });
-        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+        await sendCodexNotification(adapter, 'item/commandExecution/outputDelta', {
             threadId: 'thread_command_log_output',
             turnId: 'turn_command_log_output',
             itemId: 'item_command_log_output',
             delta: 'worker log: process running with session ID 96081 and waiting',
         });
-        await adapter.handleCodexNotification('item/commandExecution/outputDelta', {
+        await sendCodexNotification(adapter, 'item/commandExecution/outputDelta', {
             threadId: 'thread_command_log_output',
             turnId: 'turn_command_log_output',
             itemId: 'item_command_log_output',
@@ -1663,6 +1874,39 @@ describe('CodexAppServerAcpAdapter', () => {
             ],
         ]));
     });
+    it('keeps an additive turn/start status live and reports shape drift', async () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient, mocks: codex } = createMockCodexClient();
+        const shapeDriftWarn = vi.fn();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient, {
+            shapeDriftWarn,
+        });
+        await initializeAdapterWithDefaultModel(adapter, codex);
+        codex.request.mockResolvedValueOnce({
+            thread: { id: 'thread_future_status', cwd: '/tmp/workspace' },
+            approvalPolicy: DEFAULT_APPROVAL_POLICY,
+            reasoningEffort: 'medium',
+        });
+        const session = await adapter.newSession({ cwd: '/tmp/workspace', mcpServers: [] });
+        codex.request.mockResolvedValueOnce({
+            turn: { id: 'turn_future_status', status: 'queuedByProvider' },
+        });
+        const promptPromise = adapter.prompt({
+            sessionId: session.sessionId,
+            prompt: [{ type: 'text', text: 'hello' }],
+        });
+        await vi.waitFor(() => {
+            expect(shapeDriftWarn).toHaveBeenCalledWith('Codex app-server shape drift detected', expect.objectContaining({
+                event: 'unknown_turn_status',
+                details: expect.stringContaining('queuedByProvider'),
+            }));
+        });
+        await adapter.handleCodexNotification('turn/completed', {
+            threadId: 'thread_future_status',
+            turn: { id: 'turn_future_status', status: 'completed', items: [] },
+        });
+        await expect(promptPromise).resolves.toEqual({ stopReason: 'end_turn' });
+    });
     it('queues early cancel until turn id is known, then interrupts the turn', async () => {
         const { connection } = createMockConnection();
         const { client: codexClient, mocks: codex } = createMockCodexClient();
@@ -2260,5 +2504,30 @@ describe('CodexAppServerAcpAdapter', () => {
         expect(customToolCallOutput).toBeNull();
         expect(unknown).toBeNull();
     });
+    it('builds provider-neutral tool state for Codex sub-agent items', () => {
+        const { connection } = createMockConnection();
+        const { client: codexClient } = createMockCodexClient();
+        const adapter = new CodexAppServerAcpAdapter(connection, codexClient);
+        const toolState = adapter.buildToolCallState({ sessionId: 'parent-session', cwd: '/tmp/workspace' }, {
+            type: 'subAgentActivity',
+            id: 'item_subagent_1',
+            agentThreadId: 'child_1',
+            agentPath: 'review/security',
+            kind: 'started',
+        }, 'turn_1');
+        expect(toolState).toMatchObject({
+            toolCallId: 'item_subagent_1',
+            title: 'Start subagent security',
+            kind: 'other',
+            locations: [],
+            affectedSubagentIds: ['child_1'],
+            meta: {
+                [SUBAGENT_TOOL_META_KEY]: {
+                    id: 'child_1',
+                    parentSessionId: 'parent-session',
+                },
+            },
+        });
+    });
 });
 //# sourceMappingURL=codex-app-server-acp-adapter.test.js.map