@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/packages/adapters/codex/__tests__/incoming.spec.js

@@ -0,0 +1,312 @@
+import { describe, expect, it, vi } from 'vitest';
+import { AgentMessageAccumulator, CommandOutputAccumulator, handleIncomingNotification } from '#~/protocol/incoming.js';
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function makeMockRpc() {
+    return { respond: vi.fn() };
+}
+function makeCollector() {
+    const events = [];
+    const onEvent = (e) => events.push(e);
+    return { events, onEvent };
+}
+function dispatch(method, params, { approvalPolicy = 'unlessTrusted', msgAcc = new AgentMessageAccumulator(), cmdAcc = new CommandOutputAccumulator(), rpc = makeMockRpc() } = {}) {
+    const { events, onEvent } = makeCollector();
+    handleIncomingNotification(method, params, rpc, onEvent, msgAcc, cmdAcc, approvalPolicy);
+    return { events, rpc, msgAcc, cmdAcc };
+}
+// ─── Tests ────────────────────────────────────────────────────────────────────
+describe('handleIncomingNotification', () => {
+    // ── Text delta accumulation ────────────────────────────────────────────────
+    describe('item/agentMessage/delta', () => {
+        it('accumulates text without emitting events', () => {
+            const msgAcc = new AgentMessageAccumulator();
+            const { events } = dispatch('item/agentMessage/delta', { itemId: 'i1', delta: 'Hello ' }, { msgAcc });
+            dispatch('item/agentMessage/delta', { itemId: 'i1', delta: 'world' }, { msgAcc });
+            expect(events).toHaveLength(0);
+            expect(msgAcc.get('i1')).toBe('Hello world');
+        });
+        it('tracks separate items independently', () => {
+            const msgAcc = new AgentMessageAccumulator();
+            dispatch('item/agentMessage/delta', { itemId: 'i1', delta: 'foo' }, { msgAcc });
+            dispatch('item/agentMessage/delta', { itemId: 'i2', delta: 'bar' }, { msgAcc });
+            expect(msgAcc.get('i1')).toBe('foo');
+            expect(msgAcc.get('i2')).toBe('bar');
+        });
+    });
+    // ── item/completed — agentMessage ──────────────────────────────────────────
+    describe('item/completed – agentMessage', () => {
+        it('emits a message event with accumulated text', () => {
+            const msgAcc = new AgentMessageAccumulator();
+            msgAcc.append('i1', 'Hello ');
+            msgAcc.append('i1', 'world');
+            const { events } = dispatch('item/completed', { item: { type: 'agentMessage', id: 'i1', text: '' } }, { msgAcc });
+            expect(events).toHaveLength(1);
+            const ev = events[0];
+            expect(ev.type).toBe('message');
+            expect(ev.type === 'message' && ev.data.content).toBe('Hello world');
+        });
+        it('falls back to item.text when accumulator is empty', () => {
+            const { events } = dispatch('item/completed', { item: { type: 'agentMessage', id: 'i2', text: 'Fallback text' } });
+            expect(events).toHaveLength(1);
+            const ev = events[0];
+            expect(ev.type === 'message' && ev.data.content).toBe('Fallback text');
+        });
+        it('does not emit when text is empty', () => {
+            const { events } = dispatch('item/completed', { item: { type: 'agentMessage', id: 'i3', text: '' } });
+            expect(events).toHaveLength(0);
+        });
+        it('cleans up accumulator entry after emitting', () => {
+            const msgAcc = new AgentMessageAccumulator();
+            msgAcc.append('i4', 'some text');
+            dispatch('item/completed', { item: { type: 'agentMessage', id: 'i4', text: '' } }, { msgAcc });
+            expect(msgAcc.get('i4')).toBe('');
+        });
+    });
+    // ── item/started — commandExecution ───────────────────────────────────────
+    describe('item/started – commandExecution', () => {
+        it('emits a tool_use event for Bash', () => {
+            const { events } = dispatch('item/started', {
+                item: {
+                    type: 'commandExecution',
+                    id: 'cmd1',
+                    command: ['ls', '-la'],
+                    cwd: '/tmp',
+                    status: 'inProgress'
+                }
+            });
+            expect(events).toHaveLength(1);
+            const ev = events[0];
+            expect(ev.type).toBe('message');
+            if (ev.type === 'message') {
+                const content = ev.data.content;
+                expect(content[0].type).toBe('tool_use');
+                expect(content[0].name).toBe('adapter:codex:Bash');
+                expect(content[0].input.command).toBe('ls -la');
+                expect(content[0].input.cwd).toBe('/tmp');
+            }
+        });
+        it('emits a tool_use event for WebSearch', () => {
+            const { events } = dispatch('item/started', {
+                item: { type: 'webSearch', id: 'ws1', query: 'openai codex' }
+            });
+            expect(events).toHaveLength(1);
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].name).toBe('adapter:codex:WebSearch');
+                expect(content[0].input.query).toBe('openai codex');
+            }
+        });
+        it('emits nothing for unknown item types', () => {
+            const { events } = dispatch('item/started', {
+                item: { type: 'contextCompaction', id: 'cc1' }
+            });
+            expect(events).toHaveLength(0);
+        });
+    });
+    // ── item/completed — commandExecution ─────────────────────────────────────
+    describe('item/completed – commandExecution', () => {
+        it('emits a tool_result event with aggregated output', () => {
+            const { events } = dispatch('item/completed', {
+                item: {
+                    type: 'commandExecution',
+                    id: 'cmd1',
+                    command: ['ls'],
+                    status: 'completed',
+                    aggregatedOutput: 'file.txt\n',
+                    exitCode: 0
+                }
+            });
+            expect(events).toHaveLength(1);
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].type).toBe('tool_result');
+                expect(content[0].tool_use_id).toBe('cmd1');
+                expect(content[0].content).toBe('file.txt\n');
+                expect(content[0].is_error).toBe(false);
+            }
+        });
+        it('uses accumulated output deltas when aggregatedOutput is absent', () => {
+            const cmdAcc = new CommandOutputAccumulator();
+            cmdAcc.append('cmd2', 'line1\n');
+            cmdAcc.append('cmd2', 'line2\n');
+            const { events } = dispatch('item/completed', { item: { type: 'commandExecution', id: 'cmd2', command: ['cat'], status: 'completed' } }, { cmdAcc });
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].content).toBe('line1\nline2\n');
+            }
+        });
+        it('marks is_error true when exitCode is non-zero', () => {
+            const { events } = dispatch('item/completed', {
+                item: {
+                    type: 'commandExecution',
+                    id: 'cmd3',
+                    command: ['false'],
+                    status: 'completed',
+                    exitCode: 1
+                }
+            });
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].is_error).toBe(true);
+            }
+        });
+    });
+    // ── item/completed — fileChange ────────────────────────────────────────────
+    describe('item/completed – fileChange', () => {
+        it('emits a tool_result summarising file changes', () => {
+            const { events } = dispatch('item/completed', {
+                item: {
+                    type: 'fileChange',
+                    id: 'fc1',
+                    status: 'completed',
+                    changes: [
+                        { path: 'src/index.ts', kind: 'edit' },
+                        { path: 'README.md', kind: 'add' }
+                    ]
+                }
+            });
+            expect(events).toHaveLength(1);
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].type).toBe('tool_result');
+                expect(content[0].content).toContain('edit src/index.ts');
+                expect(content[0].content).toContain('add README.md');
+                expect(content[0].is_error).toBe(false);
+            }
+        });
+        it('marks is_error true when status is declined', () => {
+            const { events } = dispatch('item/completed', {
+                item: { type: 'fileChange', id: 'fc2', status: 'declined', changes: [] }
+            });
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].is_error).toBe(true);
+            }
+        });
+    });
+    // ── turn/completed ─────────────────────────────────────────────────────────
+    describe('turn/completed', () => {
+        it('emits stop when status is completed', () => {
+            const { events } = dispatch('turn/completed', {
+                turn: { id: 'turn_1', status: 'completed', items: [] }
+            });
+            expect(events).toHaveLength(1);
+            expect(events[0].type).toBe('stop');
+        });
+        it('emits stop when status is interrupted', () => {
+            const { events } = dispatch('turn/completed', {
+                turn: { id: 'turn_2', status: 'interrupted', items: [] }
+            });
+            expect(events).toHaveLength(1);
+            expect(events[0].type).toBe('stop');
+        });
+        it('emits stop with error message when status is failed', () => {
+            const { events } = dispatch('turn/completed', {
+                turn: {
+                    id: 'turn_3',
+                    status: 'failed',
+                    items: [],
+                    error: { message: 'Context window exceeded' }
+                }
+            });
+            expect(events).toHaveLength(2);
+            expect(events[0]).toMatchObject({
+                type: 'error',
+                data: {
+                    message: 'Context window exceeded',
+                    fatal: true
+                }
+            });
+            const ev = events[1];
+            expect(ev.type).toBe('stop');
+            if (ev.type === 'stop') {
+                expect(ev.data?.content).toBe('Context window exceeded');
+            }
+        });
+        it('includes codex turn details in the surfaced failure message', () => {
+            const { events } = dispatch('turn/completed', {
+                turn: {
+                    id: 'turn_4',
+                    status: 'failed',
+                    items: [],
+                    error: {
+                        message: 'Incomplete response returned',
+                        codexErrorInfo: 'status=incomplete',
+                        additionalDetails: 'reason=max_output_tokens'
+                    }
+                }
+            });
+            expect(events[0]).toMatchObject({
+                type: 'error',
+                data: {
+                    fatal: true
+                }
+            });
+            const ev = events[1];
+            expect(ev.type).toBe('stop');
+            if (ev.type === 'stop') {
+                expect(ev.data?.content).toContain('Incomplete response returned');
+                expect(ev.data?.content).toContain('status=incomplete');
+                expect(ev.data?.content).toContain('reason=max_output_tokens');
+            }
+        });
+        it('clears accumulators on completion', () => {
+            const msgAcc = new AgentMessageAccumulator();
+            const cmdAcc = new CommandOutputAccumulator();
+            msgAcc.append('i1', 'text');
+            cmdAcc.append('c1', 'output');
+            dispatch('turn/completed', { turn: { id: 'turn_4', status: 'completed', items: [] } }, { msgAcc, cmdAcc });
+            expect(msgAcc.get('i1')).toBe('');
+            expect(cmdAcc.get('c1')).toBe('');
+        });
+    });
+    // ── Approvals ──────────────────────────────────────────────────────────────
+    describe('item/commandExecution/requestApproval', () => {
+        it('auto-accepts when approvalPolicy is "never"', () => {
+            const rpc = makeMockRpc();
+            dispatch('item/commandExecution/requestApproval', { id: 99, itemId: 'cmd1', threadId: 'thr_1', turnId: 'turn_1', command: ['rm', '-rf', '/'] }, { approvalPolicy: 'never', rpc });
+            expect(rpc.respond).toHaveBeenCalledWith(99, 'accept');
+        });
+        it('emits ask_user_question when policy is "unlessTrusted"', () => {
+            const { events } = dispatch('item/commandExecution/requestApproval', {
+                itemId: 'cmd2',
+                threadId: 'thr_1',
+                turnId: 'turn_1',
+                command: ['npm', 'test'],
+                reason: 'Run test suite'
+            }, { approvalPolicy: 'unlessTrusted' });
+            expect(events).toHaveLength(1);
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].name).toBe('ask_user_question');
+                expect(content[0].input.question).toContain('npm test');
+                expect(content[0].input.question).toContain('Run test suite');
+                expect(content[0].input.options).toHaveLength(3);
+            }
+        });
+    });
+    describe('item/fileChange/requestApproval', () => {
+        it('auto-accepts when approvalPolicy is "never"', () => {
+            const rpc = makeMockRpc();
+            dispatch('item/fileChange/requestApproval', { id: 7, itemId: 'fc1', threadId: 'thr_1', turnId: 'turn_1' }, { approvalPolicy: 'never', rpc });
+            expect(rpc.respond).toHaveBeenCalledWith(7, 'accept');
+        });
+        it('emits ask_user_question with file-change message when policy is "onRequest"', () => {
+            const { events } = dispatch('item/fileChange/requestApproval', { itemId: 'fc2', threadId: 'thr_1', turnId: 'turn_1', reason: 'Update config' }, { approvalPolicy: 'onRequest' });
+            expect(events).toHaveLength(1);
+            if (events[0].type === 'message') {
+                const content = events[0].data.content;
+                expect(content[0].name).toBe('ask_user_question');
+                expect(content[0].input.question).toContain('file changes');
+                expect(content[0].input.question).toContain('Update config');
+            }
+        });
+    });
+    // ── Unrecognised notifications ─────────────────────────────────────────────
+    describe('unrecognised methods', () => {
+        it('emits no events for unknown methods', () => {
+            const { events } = dispatch('codex/event/session_configured', { foo: 'bar' });
+            expect(events).toHaveLength(0);
+        });
+    });
+});

package/dist/packages/adapters/codex/__tests__/native-hooks.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/adapters/codex/__tests__/native-hooks.spec.js

@@ -0,0 +1,132 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ensureCodexNativeHooksInstalled } from '../src/runtime/native-hooks';
+const tempDirs = [];
+const createWorkspace = async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'codex-hooks-'));
+    tempDirs.push(dir);
+    return dir;
+};
+afterEach(async () => {
+    await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});
+describe('ensureCodexNativeHooksInstalled', () => {
+    it('writes managed hooks through the shared call-hook bridge', async () => {
+        const workspace = await createWorkspace();
+        const mockHome = join(workspace, '.ai', '.mock');
+        const ctx = {
+            cwd: workspace,
+            env: {
+                HOME: mockHome
+            },
+            logger: {
+                info: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+                debug: vi.fn()
+            },
+            assets: {
+                hookPlugins: [
+                    {
+                        id: 'hookPlugin:project:logger'
+                    }
+                ]
+            }
+        };
+        const installed = await ensureCodexNativeHooksInstalled(ctx);
+        const hooks = JSON.parse(await readFile(join(mockHome, '.codex', 'hooks.json'), 'utf8'));
+        expect(installed).toBe(true);
+        expect(ctx.env.__VF_PROJECT_AI_CODEX_NATIVE_HOOKS_AVAILABLE__).toBe('1');
+        expect(hooks.hooks?.SessionStart).toHaveLength(1);
+        expect(hooks.hooks?.PreToolUse?.[0]?.matcher).toBe('^Bash$');
+        expect(hooks.hooks?.PostToolUse?.[0]?.matcher).toBe('^Bash$');
+        expect(JSON.stringify(hooks)).toContain('call-hook.js');
+        expect(JSON.stringify(hooks)).not.toContain('codex-hook.js');
+    });
+    it('replaces previously managed codex-hook entries instead of duplicating them', async () => {
+        const workspace = await createWorkspace();
+        const mockHome = join(workspace, '.ai', '.mock');
+        await mkdir(join(mockHome, '.codex'), { recursive: true });
+        await writeFile(join(mockHome, '.codex', 'hooks.json'), JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        hooks: [{ type: 'command', command: '/tmp/codex-hook.js' }]
+                    }],
+                PreToolUse: [{
+                        matcher: '^Bash$',
+                        hooks: [{ type: 'command', command: '/tmp/codex-hook.js' }]
+                    }]
+            }
+        }, null, 2));
+        const ctx = {
+            cwd: workspace,
+            env: {
+                HOME: mockHome
+            },
+            logger: {
+                info: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+                debug: vi.fn()
+            },
+            assets: {
+                hookPlugins: [
+                    {
+                        id: 'hookPlugin:project:logger'
+                    }
+                ]
+            }
+        };
+        const installed = await ensureCodexNativeHooksInstalled(ctx);
+        const hooks = JSON.parse(await readFile(join(mockHome, '.codex', 'hooks.json'), 'utf8'));
+        expect(installed).toBe(true);
+        expect(hooks.hooks?.SessionStart).toHaveLength(1);
+        expect(hooks.hooks?.PreToolUse).toHaveLength(1);
+        expect(JSON.stringify(hooks)).toContain('call-hook.js');
+        expect(JSON.stringify(hooks)).not.toContain('codex-hook.js');
+    });
+    it('does not duplicate managed events already configured in project-level .codex/hooks.json', async () => {
+        const workspace = await createWorkspace();
+        const mockHome = join(workspace, '.ai', '.mock');
+        await mkdir(join(workspace, '.codex'), { recursive: true });
+        await writeFile(join(workspace, '.codex', 'hooks.json'), JSON.stringify({
+            hooks: {
+                SessionStart: [{
+                        hooks: [{ type: 'command', command: '$PROJECT/node_modules/.bin/vf-call-hook' }]
+                    }],
+                UserPromptSubmit: [{
+                        hooks: [{ type: 'command', command: '$PROJECT/node_modules/.bin/vf-call-hook' }]
+                    }]
+            }
+        }, null, 2));
+        const ctx = {
+            cwd: workspace,
+            env: {
+                HOME: mockHome
+            },
+            logger: {
+                info: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+                debug: vi.fn()
+            },
+            assets: {
+                hookPlugins: [
+                    {
+                        id: 'hookPlugin:project:logger'
+                    }
+                ]
+            }
+        };
+        const installed = await ensureCodexNativeHooksInstalled(ctx);
+        const hooks = JSON.parse(await readFile(join(mockHome, '.codex', 'hooks.json'), 'utf8'));
+        expect(installed).toBe(true);
+        expect(hooks.hooks?.SessionStart ?? []).toEqual([]);
+        expect(hooks.hooks?.UserPromptSubmit ?? []).toEqual([]);
+        expect(hooks.hooks?.PreToolUse).toHaveLength(1);
+        expect(hooks.hooks?.PostToolUse).toHaveLength(1);
+        expect(hooks.hooks?.Stop).toHaveLength(1);
+    });
+});

package/dist/packages/adapters/codex/__tests__/proxy.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/adapters/codex/__tests__/proxy.spec.js

@@ -0,0 +1,214 @@
+import { Buffer } from 'node:buffer';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { CODEX_PROXY_META_HEADER_NAME, encodeCodexProxyMeta, ensureCodexProxyServer } from '#~/runtime/proxy.js';
+const upstreamServers = [];
+const tempDirs = [];
+const closeServer = async (server) => {
+    await new Promise((resolve, reject) => {
+        server.close((err) => {
+            if (err)
+                reject(err);
+            else
+                resolve();
+        });
+    });
+};
+const readRequestBody = async (req) => {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+};
+afterEach(async () => {
+    await Promise.all(upstreamServers.splice(0).map(closeServer));
+    await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })));
+});
+describe('codex proxy', () => {
+    it('reuses a single local proxy instance across repeated starts', async () => {
+        const first = await ensureCodexProxyServer();
+        const second = await ensureCodexProxyServer();
+        expect(first.baseUrl).toBe(second.baseUrl);
+    });
+    it('forwards upstream provider metadata and injects max_output_tokens', async () => {
+        let capturedRequest;
+        const upstream = createServer(async (req, res) => {
+            const bodyText = await readRequestBody(req);
+            capturedRequest = {
+                method: req.method,
+                url: req.url,
+                headers: req.headers,
+                body: JSON.parse(bodyText)
+            };
+            await new Promise(resolve => setTimeout(resolve, 25));
+            res.writeHead(200, {
+                'Content-Type': 'application/json'
+            });
+            res.end(JSON.stringify({ ok: true }));
+        });
+        upstreamServers.push(upstream);
+        await new Promise((resolve, reject) => {
+            upstream.once('error', reject);
+            upstream.listen(0, '127.0.0.1', () => {
+                upstream.off('error', reject);
+                resolve();
+            });
+        });
+        const upstreamAddress = upstream.address();
+        if (upstreamAddress == null || typeof upstreamAddress === 'string') {
+            throw new Error('Failed to resolve upstream address');
+        }
+        const proxy = await ensureCodexProxyServer();
+        const response = await fetch(`${proxy.baseUrl}/responses?stream=true`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: 'Bearer test-key',
+                [CODEX_PROXY_META_HEADER_NAME]: encodeCodexProxyMeta({
+                    upstreamBaseUrl: `http://127.0.0.1:${upstreamAddress.port}/v1`,
+                    queryParams: {
+                        'api-version': '2025-04-01-preview'
+                    },
+                    headers: {
+                        'X-Tenant': 'tenant-1'
+                    },
+                    maxOutputTokens: 8192
+                })
+            },
+            body: JSON.stringify({
+                model: 'gpt-5.4',
+                input: 'Reply with pong.'
+            })
+        });
+        expect(response.status).toBe(200);
+        expect(await response.json()).toEqual({ ok: true });
+        expect(capturedRequest).toBeDefined();
+        const upstreamUrl = new URL(capturedRequest.url ?? '/', 'http://127.0.0.1');
+        expect(capturedRequest).toMatchObject({
+            method: 'POST',
+            body: {
+                model: 'gpt-5.4',
+                input: 'Reply with pong.',
+                max_output_tokens: 8192
+            }
+        });
+        expect(upstreamUrl.pathname).toBe('/v1/responses');
+        expect(upstreamUrl.searchParams.get('stream')).toBe('true');
+        expect(upstreamUrl.searchParams.get('api-version')).toBe('2025-04-01-preview');
+        expect(capturedRequest?.headers.authorization).toBe('Bearer test-key');
+        expect(capturedRequest?.headers['x-tenant']).toBe('tenant-1');
+        expect(capturedRequest?.headers['x-vibe-forge-proxy-meta']).toBeUndefined();
+    });
+    it('replays JSON request bodies across upstream 308 redirects', async () => {
+        let capturedBody;
+        const target = createServer(async (req, res) => {
+            capturedBody = await readRequestBody(req);
+            res.writeHead(200, {
+                'Content-Type': 'application/json'
+            });
+            res.end(JSON.stringify({ ok: true }));
+        });
+        upstreamServers.push(target);
+        await new Promise((resolve, reject) => {
+            target.once('error', reject);
+            target.listen(0, '127.0.0.1', () => {
+                target.off('error', reject);
+                resolve();
+            });
+        });
+        const targetAddress = target.address();
+        if (targetAddress == null || typeof targetAddress === 'string') {
+            throw new Error('Failed to resolve redirect target address');
+        }
+        const redirector = createServer((req, res) => {
+            res.writeHead(308, {
+                location: `http://127.0.0.1:${targetAddress.port}${req.url ?? '/responses'}`
+            });
+            res.end();
+        });
+        upstreamServers.push(redirector);
+        await new Promise((resolve, reject) => {
+            redirector.once('error', reject);
+            redirector.listen(0, '127.0.0.1', () => {
+                redirector.off('error', reject);
+                resolve();
+            });
+        });
+        const redirectAddress = redirector.address();
+        if (redirectAddress == null || typeof redirectAddress === 'string') {
+            throw new Error('Failed to resolve redirector address');
+        }
+        const proxy = await ensureCodexProxyServer();
+        const response = await fetch(`${proxy.baseUrl}/responses`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                [CODEX_PROXY_META_HEADER_NAME]: encodeCodexProxyMeta({
+                    upstreamBaseUrl: `http://127.0.0.1:${redirectAddress.port}`,
+                    maxOutputTokens: 8192
+                })
+            },
+            body: JSON.stringify({
+                model: 'gpt-5.4',
+                input: 'Reply with pong.'
+            })
+        });
+        expect(response.status).toBe(200);
+        expect(await response.json()).toEqual({ ok: true });
+        expect(capturedBody).toBe(JSON.stringify({
+            model: 'gpt-5.4',
+            input: 'Reply with pong.',
+            max_output_tokens: 8192
+        }));
+    });
+    it('writes proxy logs to the adapter-codex scoped log file', async () => {
+        const cwd = await mkdtemp(join(tmpdir(), 'vf-codex-proxy-log-'));
+        tempDirs.push(cwd);
+        const upstream = createServer((_req, res) => {
+            res.writeHead(500, {
+                'Content-Type': 'application/json'
+            });
+            res.end(JSON.stringify({ error: 'upstream failed' }));
+        });
+        upstreamServers.push(upstream);
+        await new Promise((resolve, reject) => {
+            upstream.once('error', reject);
+            upstream.listen(0, '127.0.0.1', () => {
+                upstream.off('error', reject);
+                resolve();
+            });
+        });
+        const upstreamAddress = upstream.address();
+        if (upstreamAddress == null || typeof upstreamAddress === 'string') {
+            throw new Error('Failed to resolve upstream address');
+        }
+        const proxy = await ensureCodexProxyServer();
+        const response = await fetch(`${proxy.baseUrl}/responses`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                [CODEX_PROXY_META_HEADER_NAME]: encodeCodexProxyMeta({
+                    upstreamBaseUrl: `http://127.0.0.1:${upstreamAddress.port}`,
+                    logContext: {
+                        cwd,
+                        ctxId: 'ctx-1',
+                        sessionId: 'session-1'
+                    }
+                })
+            },
+            body: JSON.stringify({
+                model: 'gpt-5.4',
+                input: 'Reply with pong.'
+            })
+        });
+        expect(response.status).toBe(500);
+        await new Promise(resolve => setTimeout(resolve, 25));
+        const logPath = join(cwd, '.ai', 'logs', 'ctx-1', 'session-1', 'adapter-codex', 'proxy.log.md');
+        const logContent = await readFile(logPath, 'utf8');
+        expect(logContent).toContain('[codex proxy] upstream returned error status');
+    });
+});

package/dist/packages/adapters/codex/__tests__/rpc.spec.d.ts

@@ -0,0 +1 @@
+export {};