agenticreplay 0.1.0 → 0.1.2

package/packages/adapters/test/mcp-config.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { rewriteMcpConfig } from '../src/index.js';
-
-const SHIM = 'agenticreplay-mcp-shim';
-const SHIM_ARGS = ['--out', '/tmp/run/mcp.jsonl'];
-
-function fixture() {
-  return {
-    mcpServers: {
-      fs: {
-        command: 'npx',
-        args: ['-y', '@modelcontextprotocol/server-filesystem', '/work'],
-        env: { FOO: 'bar' },
-      },
-      remote: { url: 'https://mcp.example.com/sse' },
-    },
-  };
-}
-
-describe('rewriteMcpConfig', () => {
-  it('wraps a stdio server so it launches through the shim', () => {
-    const { config, rewritten } = rewriteMcpConfig(fixture(), SHIM, SHIM_ARGS);
-    const fs = (config as any).mcpServers.fs;
-    expect(fs.command).toBe(SHIM);
-    expect(fs.args).toEqual([
-      '--out',
-      '/tmp/run/mcp.jsonl',
-      '--name',
-      'fs',
-      '--',
-      'npx',
-      '-y',
-      '@modelcontextprotocol/server-filesystem',
-      '/work',
-    ]);
-    expect(rewritten).toEqual(['fs']);
-  });
-
-  it('keeps the server environment on the wrapper', () => {
-    const { config } = rewriteMcpConfig(fixture(), SHIM, SHIM_ARGS);
-    expect((config as any).mcpServers.fs.env).toEqual({ FOO: 'bar' });
-  });
-
-  it('handles a stdio server with no args of its own', () => {
-    const { config } = rewriteMcpConfig({ mcpServers: { t: { command: 'srv' } } }, SHIM, []);
-    expect((config as any).mcpServers.t.args).toEqual(['--name', 't', '--', 'srv']);
-  });
-
-  it('preserves fields it does not understand rather than dropping them', () => {
-    const { config } = rewriteMcpConfig(
-      { mcpServers: { t: { command: 'srv', args: [], disabled: true, timeout: 5 } } },
-      SHIM,
-      [],
-    );
-    expect((config as any).mcpServers.t.disabled).toBe(true);
-    expect((config as any).mcpServers.t.timeout).toBe(5);
-  });
-
-  it('leaves url servers alone and reports them instead of dropping them', () => {
-    const { config, rewritten, skipped } = rewriteMcpConfig(fixture(), SHIM, SHIM_ARGS);
-    expect((config as any).mcpServers.remote).toEqual({ url: 'https://mcp.example.com/sse' });
-    expect(rewritten).not.toContain('remote');
-    expect(skipped).toEqual(['remote']);
-  });
-
-  it('reports a server that is neither stdio nor url instead of dropping it', () => {
-    const { config, skipped } = rewriteMcpConfig({ mcpServers: { odd: { note: 1 } } }, SHIM, []);
-    expect((config as any).mcpServers.odd).toEqual({ note: 1 });
-    expect(skipped).toEqual(['odd']);
-  });
-
-  it('is idempotent: a second rewrite does not double-wrap', () => {
-    const once = rewriteMcpConfig(fixture(), SHIM, SHIM_ARGS);
-    const twice = rewriteMcpConfig(once.config, SHIM, SHIM_ARGS);
-    expect(twice.config).toEqual(once.config);
-    expect(twice.rewritten).toEqual(once.rewritten);
-    expect(twice.skipped).toEqual(once.skipped);
-  });
-
-  it('does not mutate the input config', () => {
-    const input = fixture();
-    const before = JSON.parse(JSON.stringify(input));
-    const { config } = rewriteMcpConfig(input, SHIM, SHIM_ARGS);
-    expect(input).toEqual(before);
-    expect(config).not.toBe(input);
-    expect((config as any).mcpServers.fs).not.toBe(input.mcpServers.fs);
-  });
-
-  it('rewrites every stdio server, in order', () => {
-    const { rewritten, skipped } = rewriteMcpConfig(
-      {
-        mcpServers: {
-          a: { command: 'a' },
-          b: { url: 'https://b.example' },
-          c: { command: 'c', args: ['--x'] },
-        },
-      },
-      SHIM,
-      [],
-    );
-    expect(rewritten).toEqual(['a', 'c']);
-    expect(skipped).toEqual(['b']);
-  });
-
-  it('passes through a config with no mcpServers untouched', () => {
-    const input = { other: true };
-    const out = rewriteMcpConfig(input, SHIM, []);
-    expect(out.config).toEqual(input);
-    expect(out.rewritten).toEqual([]);
-    expect(out.skipped).toEqual([]);
-  });
-
-  it('does not throw on a config that is not an object', () => {
-    expect(rewriteMcpConfig(null, SHIM, []).config).toBeNull();
-    expect(rewriteMcpConfig('nope', SHIM, []).config).toBe('nope');
-    expect(rewriteMcpConfig({ mcpServers: 'nope' }, SHIM, []).rewritten).toEqual([]);
-  });
-});

package/packages/adapters/test/named-agents.test.ts

@@ -1,262 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import type { RecordContext } from '@agenticreplay/plugin-api';
-import { HOOK_FILENAME } from '@agenticreplay/node-instrument';
-import { decodeForwardPath } from '@agenticreplay/proxy';
-import { checkAdapterContract, formatContractResult } from '../src/contract.js';
-import { defaultAdapters } from '../src/registry.js';
-import { grokAdapter } from '../src/grok.js';
-import { openClawAdapter } from '../src/openclaw.js';
-
-/**
- * Adapters for the agents people keep asking about.
- *
- * Each one is written from that project's own documentation rather than from a guess, because an
- * adapter that sets a variable the harness does not read produces the exact failure this codebase
- * fears most: a run that looks fine and a trace that is empty.
- */
-describe('the grok adapter', () => {
-  let root: string;
-  let ctx: RecordContext;
-
-  beforeEach(async () => {
-    root = await mkdtemp(join(tmpdir(), 'agenticreplay-grok-'));
-    ctx = {
-      runId: 'run_test',
-      cwd: join(root, 'work'),
-      runDir: join(root, 'run'),
-      proxyUrl: 'http://127.0.0.1:44100',
-      userArgs: [],
-      env: {},
-    };
-  });
-  afterEach(async () => {
-    await rm(root, { recursive: true, force: true });
-  });
-
-  it('passes the adapter contract', async () => {
-    const result = await checkAdapterContract(grokAdapter, { ctx: { userArgs: [] } });
-    expect(result.ok, formatContractResult(result)).toBe(true);
-  });
-
-  it('answers to the names people type', () => {
-    const registry = defaultAdapters();
-    expect(registry.get('grok').id).toBe('grok');
-    expect(registry.get('grok-cli').id).toBe('grok');
-  });
-
-  it('redirects GROK_BASE_URL, which is the variable grok-cli documents', async () => {
-    // `GROK_BASE_URL` (default https://api.x.ai/v1) — from grok-cli's own README. The `/v1` is
-    // part of the default, so the replacement carries it too or every path is off by a segment.
-    const launch = await grokAdapter.prepare(ctx);
-    expect(launch.env.GROK_BASE_URL).toBe('http://127.0.0.1:44100/v1');
-  });
-
-  it('launches grok and forwards the user args', async () => {
-    const launch = await grokAdapter.prepare({ ...ctx, userArgs: ['--prompt', 'fix it'] });
-    expect(launch.command).toBe('grok');
-    expect(launch.args).toEqual(['--prompt', 'fix it']);
-  });
-
-  it('passes the key through without inventing one', async () => {
-    expect((await grokAdapter.prepare(ctx)).env.GROK_API_KEY).toBeUndefined();
-    const carried = await grokAdapter.prepare({ ...ctx, env: { GROK_API_KEY: 'xai-real' } });
-    expect(carried.env.GROK_API_KEY).toBe('xai-real');
-  });
-
-  it('installs the fetch hook with xAI on the allowlist', async () => {
-    // grok-cli runs on Bun and turns sub-agents on by default; a sub-agent that builds its own
-    // client would slip past a variable the parent read. `api.x.ai` is not in the hook's default
-    // host list, so the adapter has to add it or the hook would be inert here.
-    const launch = await grokAdapter.prepare(ctx);
-    expect(launch.env.AGENTICREPLAY_INSTRUMENT_HOSTS).toContain('api.x.ai');
-    expect(launch.env.NODE_OPTIONS).toContain(HOOK_FILENAME);
-    // Bun ignores `--require` inside NODE_OPTIONS, and grok-cli is a Bun program.
-    expect(launch.env.BUN_OPTIONS).toContain('--preload');
-  });
-});
-
-describe('the openclaw adapter', () => {
-  let root: string;
-  let ctx: RecordContext;
-
-  beforeEach(async () => {
-    root = await mkdtemp(join(tmpdir(), 'agenticreplay-openclaw-'));
-    ctx = {
-      runId: 'run_test',
-      cwd: join(root, 'work'),
-      runDir: join(root, 'run'),
-      proxyUrl: 'http://127.0.0.1:44100',
-      userArgs: [],
-      env: {},
-    };
-  });
-  afterEach(async () => {
-    await rm(root, { recursive: true, force: true });
-  });
-
-  it('passes the adapter contract', async () => {
-    const result = await checkAdapterContract(openClawAdapter, { ctx: { userArgs: [] } });
-    expect(result.ok, formatContractResult(result)).toBe(true);
-  });
-
-  it('is registered', () => {
-    expect(defaultAdapters().get('openclaw').id).toBe('openclaw');
-  });
-
-  it('installs the fetch hook, because it reads no base-URL variable of its own', async () => {
-    const launch = await openClawAdapter.prepare(ctx);
-    expect(launch.env.NODE_OPTIONS).toContain(HOOK_FILENAME);
-  });
-
-  it('still sets the base-URL variables the agents it launches will read', async () => {
-    // This is the point of the adapter: OpenClaw is a gateway that spawns Claude Code, Codex or
-    // opencode as child processes, and a child inherits its parent's environment. Redirecting
-    // here reaches the coding agent even though OpenClaw itself never reads these.
-    const launch = await openClawAdapter.prepare(ctx);
-    expect(launch.env.ANTHROPIC_BASE_URL).toBe('http://127.0.0.1:44100');
-    expect(launch.env.OPENAI_BASE_URL).toBe('http://127.0.0.1:44100/v1');
-  });
-});
-
-describe('AGENTICREPLAY_BASE_URL_VARS — naming a base-URL variable agenticreplay does not know', () => {
-  let root: string;
-  let ctx: RecordContext;
-
-  beforeEach(async () => {
-    root = await mkdtemp(join(tmpdir(), 'agenticreplay-named-'));
-    ctx = {
-      runId: 'run_test',
-      cwd: join(root, 'work'),
-      runDir: join(root, 'run'),
-      proxyUrl: 'http://127.0.0.1:44100',
-      userArgs: ['my-agent'],
-      env: {},
-    };
-  });
-  afterEach(async () => {
-    await rm(root, { recursive: true, force: true });
-  });
-
-  const generic = () => defaultAdapters().get('generic-openai');
-
-  it('points a named variable at the proxy', async () => {
-    // Hermes is the case this exists for: it overrides per provider with `<NAME>_BASE_URL`, a
-    // family too large and too fast-moving to enumerate here — NOVITA, GLM, KIMI, MINIMAX, HF,
-    // NEBIUS and a dozen more in its own .env.example.
-    const launch = await generic().prepare({
-      ...ctx,
-      env: { AGENTICREPLAY_BASE_URL_VARS: 'OPENROUTER_BASE_URL' },
-    });
-    expect(launch.env.OPENROUTER_BASE_URL).toBe('http://127.0.0.1:44100/v1');
-  });
-
-  it('takes several, comma separated', async () => {
-    const launch = await generic().prepare({
-      ...ctx,
-      env: { AGENTICREPLAY_BASE_URL_VARS: 'GLM_BASE_URL, KIMI_BASE_URL' },
-    });
-    expect(launch.env.GLM_BASE_URL).toBe('http://127.0.0.1:44100/v1');
-    expect(launch.env.KIMI_BASE_URL).toBe('http://127.0.0.1:44100/v1');
-  });
-
-  it('lets a path be given, for an origin that is not OpenAI-shaped', async () => {
-    const launch = await generic().prepare({
-      ...ctx,
-      env: { AGENTICREPLAY_BASE_URL_VARS: 'TOKENPLAN_BASE_URL=/' },
-    });
-    expect(launch.env.TOKENPLAN_BASE_URL).toBe('http://127.0.0.1:44100');
-  });
-
-  it('is consumed, not forwarded — the child has no use for it', async () => {
-    const launch = await generic().prepare({
-      ...ctx,
-      env: { AGENTICREPLAY_BASE_URL_VARS: 'OPENROUTER_BASE_URL' },
-    });
-    expect(launch.env.AGENTICREPLAY_BASE_URL_VARS).toBeUndefined();
-  });
-
-  it('ignores blanks and empty entries rather than setting a variable named ""', async () => {
-    const launch = await generic().prepare({
-      ...ctx,
-      env: { AGENTICREPLAY_BASE_URL_VARS: ' , ,' },
-    });
-    expect(Object.keys(launch.env)).not.toContain('');
-  });
-
-  it('works on the node adapter too, where a hooked agent may still read a variable', async () => {
-    const launch = await defaultAdapters()
-      .get('node')
-      .prepare({ ...ctx, env: { AGENTICREPLAY_BASE_URL_VARS: 'LLM_BASE_URL' } });
-    expect(launch.env.LLM_BASE_URL).toBe('http://127.0.0.1:44100/v1');
-  });
-
-  /**
-   * The variable that already pointed somewhere keeps pointing there, through `/forward/`.
-   *
-   * A retrieval run is the case: chat goes to a gateway and embeddings to a dedicated provider,
-   * and agenticreplay's upstream map is keyed by wire dialect — so two origins of the same dialect cannot
-   * be named by any `--upstream-*`. Rewritten to a bare `/v1`, the embedding calls arrived with
-   * nothing saying where they had been headed, and `passthroughOrigin` sent them to the chat
-   * origin, or to `api.openai.com` with the embedding provider's key on them.
-   */
-  it('keeps the origin a set variable already named, as a forward path', async () => {
-    const launch = await generic().prepare({
-      ...ctx,
-      env: {
-        AGENTICREPLAY_BASE_URL_VARS: 'MY_URL',
-        MY_URL: 'https://embeddings.example/v1',
-      },
-    });
-    expect(launch.env.MY_URL).toBe(
-      `http://127.0.0.1:44100/forward/${encodeURIComponent('https://embeddings.example/v1')}`,
-    );
-    // And it decodes back to what the client was originally given, path included.
-    const decoded = decodeForwardPath(new URL(launch.env.MY_URL!).pathname);
-    expect(decoded?.base).toBe('https://embeddings.example/v1');
-  });
-
-  /**
-   * A base URL the `/forward/` decoder will not accept must not become a `/forward/` path.
-   *
-   * `forwardBasePath` encodes anything; `decodeForwardPath` refuses credentials, a query, a
-   * fragment or a non-http(s) scheme. Encoding without asking produced a segment nothing could
-   * read, and the proxy then forwarded the call to the configured upstream — the very
-   * readdressing this rewrite exists to stop — with the harness's credential for another gateway
-   * on it. The segment is also the request *path*, so `https://tenant:pw@gw.example/v1` wrote the
-   * gateway password into the trace, where `agenticreplay show` and `agenticreplay export` carry it.
-   *
-   * The fallback is what this did before origins could be carried: a bare `/v1` on the proxy. The
-   * call is still recorded, and it fails against the wrong origin loudly rather than leaking
-   * quietly. Carrying the origin without its credential is not on offer — the client reads this
-   * value to build its request, so dropping the userinfo would stop it authenticating at all.
-   */
-  it.each([
-    ['credentials', 'https://tenant:s3cr3t@gw.example/v1'],
-    ['a query string', 'https://gw.example/v1?key=s3cr3t'],
-    ['a fragment', 'https://gw.example/v1#frag'],
-    ['a scheme the decoder refuses', 'ftp://gw.example/v1'],
-  ])('does not encode a base URL carrying %s', async (_what, value) => {
-    const launch = await generic().prepare({
-      ...ctx,
-      env: { AGENTICREPLAY_BASE_URL_VARS: 'MY_URL', MY_URL: value },
-    });
-    expect(launch.env.MY_URL).toBe('http://127.0.0.1:44100/v1');
-    expect(launch.env.MY_URL).not.toContain('forward');
-    expect(launch.env.MY_URL).not.toContain('s3cr3t');
-    expect(launch.env.MY_URL).not.toContain(encodeURIComponent('s3cr3t'));
-  });
-
-  it('still honours an explicit path, which is the user saying where to point it', async () => {
-    const launch = await generic().prepare({
-      ...ctx,
-      env: {
-        AGENTICREPLAY_BASE_URL_VARS: 'MY_URL=v2',
-        MY_URL: 'https://embeddings.example/v1',
-      },
-    });
-    expect(launch.env.MY_URL).toBe('http://127.0.0.1:44100/v2');
-  });
-});

package/packages/adapters/test/node-adapter.test.ts

@@ -1,98 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import type { RecordContext } from '@agenticreplay/plugin-api';
-import { HOOK_FILENAME } from '@agenticreplay/node-instrument';
-import { checkAdapterContract, formatContractResult } from '../src/contract.js';
-import { defaultAdapters } from '../src/registry.js';
-import { nodeAdapter } from '../src/node.js';
-
-/**
- * The adapter for a JS agent that reads no base-URL variable.
- *
- * Every other adapter works by pointing an environment variable at the proxy. This one exists
- * because a whole class of agents ignores them — an origin compiled into source, or a gateway
- * pinned in code — so the redirect has to happen inside the runtime.
- */
-describe('the node adapter', () => {
-  let root: string;
-  let ctx: RecordContext;
-
-  beforeEach(async () => {
-    root = await mkdtemp(join(tmpdir(), 'agenticreplay-node-adapter-'));
-    ctx = {
-      runId: 'run_test',
-      cwd: join(root, 'work'),
-      runDir: join(root, 'run'),
-      proxyUrl: 'http://127.0.0.1:44100',
-      userArgs: ['node', 'app.mjs'],
-      env: {},
-    };
-  });
-  afterEach(async () => {
-    await rm(root, { recursive: true, force: true });
-  });
-
-  it('passes the adapter contract', async () => {
-    const result = await checkAdapterContract(nodeAdapter);
-    expect(result.ok, formatContractResult(result)).toBe(true);
-  });
-
-  it('is registered, and answers to the names people will actually type', () => {
-    const registry = defaultAdapters();
-    expect(registry.get('node').id).toBe('node');
-    expect(registry.get('vercel-ai').id).toBe('node');
-    expect(registry.get('ai-sdk').id).toBe('node');
-  });
-
-  it('launches the command the user gave it', async () => {
-    const launch = await nodeAdapter.prepare(ctx);
-    expect(launch.command).toBe('node');
-    expect(launch.args).toEqual(['app.mjs']);
-  });
-
-  it('installs the fetch hook through NODE_OPTIONS', async () => {
-    const launch = await nodeAdapter.prepare(ctx);
-    expect(launch.env.NODE_OPTIONS).toContain('--require');
-    expect(launch.env.NODE_OPTIONS).toContain(HOOK_FILENAME);
-    // Written where the run can find it and clean it up, never into the user's project.
-    expect(launch.env.NODE_OPTIONS).toContain(ctx.runDir);
-  });
-
-  it('writes the hook to disk, ready for the child to load', async () => {
-    await nodeAdapter.prepare(ctx);
-    const source = await readFile(join(ctx.runDir, HOOK_FILENAME), 'utf8');
-    expect(source).toContain('globalThis.fetch');
-  });
-
-  it('tells the hook where the proxy is', async () => {
-    const launch = await nodeAdapter.prepare(ctx);
-    expect(launch.env.AGENTICREPLAY_PROXY_URL).toBe(ctx.proxyUrl);
-  });
-
-  it('still sets the base-URL variables, for an agent that does read them', async () => {
-    // Belt and braces on purpose: one agent may use the SDK's default client for one provider and
-    // a hardcoded origin for another, and agenticreplay has no way to know which.
-    const launch = await nodeAdapter.prepare(ctx);
-    expect(launch.env.OPENAI_BASE_URL).toContain('44100');
-    expect(launch.env.ANTHROPIC_BASE_URL).toContain('44100');
-  });
-
-  it('keeps NODE_OPTIONS the user already set', async () => {
-    const launch = await nodeAdapter.prepare({
-      ...ctx,
-      env: { NODE_OPTIONS: '--max-old-space-size=4096' },
-    });
-    expect(launch.env.NODE_OPTIONS).toContain('--max-old-space-size=4096');
-    expect(launch.env.NODE_OPTIONS).toContain('--require');
-  });
-
-  it('is not chosen automatically, because it cannot know what it would be launching', async () => {
-    expect(await nodeAdapter.detect(ctx.cwd)).toBe(false);
-  });
-
-  it('refuses without a command, rather than launching something arbitrary', async () => {
-    await expect(nodeAdapter.prepare({ ...ctx, userArgs: [] })).rejects.toThrow(/command/i);
-  });
-});

package/packages/adapters/test/opencode-capture.test.ts

@@ -1,137 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { installOpenCodeCapture } from '../src/opencode-capture.js';
-import { openCodeAdapter } from '../src/opencode.js';
-
-const PROXY = 'http://127.0.0.1:51733';
-const CHATGPT = 'https://chatgpt.com/backend-api/codex/responses';
-afterEach(() => vi.unstubAllGlobals());
-
-describe('OpenCode final fetch capture', () => {
-  it.each([
-    CHATGPT,
-    'https://api.openai.com/v1/responses',
-    'https://api.openai.com/v1/chat/completions',
-  ])('captures %s with its original destination and fetch options', async (url) => {
-    const original = vi.fn(async () => new Response('ok'));
-    vi.stubGlobal('fetch', original);
-    installOpenCodeCapture(PROXY);
-    const init = { method: 'POST', body: '{}', headers: { authorization: 'Bearer fixture' } };
-    await fetch(new URL(url + '?test=1'), init);
-    const target = new URL(url);
-    expect(original).toHaveBeenCalledExactlyOnceWith(
-      `${PROXY}/forward/${encodeURIComponent(target.origin)}${target.pathname}?test=1`,
-      init,
-    );
-  });
-
-  it.each([
-    'https://auth.openai.com/oauth/token',
-    'https://chatgpt.com/backend-api/me',
-    'https://chatgpt.com/backend-api/codex/responses/other',
-    'https://chatgpt.com.attacker.test/backend-api/codex/responses',
-    'https://api.openai.com/v1/files',
-    'https://gateway.example/v1/responses',
-    'http://chatgpt.com/backend-api/codex/responses',
-    'https://chatgpt.com:444/backend-api/codex/responses',
-    'https://user:pass@chatgpt.com/backend-api/codex/responses',
-    `${PROXY}/v1/responses`,
-    '/relative',
-  ])('leaves unrelated or already redirected traffic alone: %s', async (url) => {
-    const original = vi.fn(async () => new Response('ok'));
-    vi.stubGlobal('fetch', original);
-    installOpenCodeCapture(PROXY);
-    await fetch(url);
-    expect(original).toHaveBeenCalledExactlyOnceWith(url, undefined);
-  });
-
-  it('preserves a Request body, auth, abort signal and init overrides', async () => {
-    const original = vi.fn(async () => new Response('ok'));
-    vi.stubGlobal('fetch', original);
-    installOpenCodeCapture(PROXY);
-    const abort = new AbortController();
-    const input = new Request(CHATGPT, {
-      method: 'POST',
-      body: '{"model":"gpt-5"}',
-      headers: { authorization: 'Bearer fixture', 'ChatGPT-Account-Id': 'account-fixture' },
-      signal: abort.signal,
-    });
-    const init = { redirect: 'manual' as const };
-    await fetch(input, init);
-    const [moved, options] = original.mock.calls[0]! as unknown as [Request, RequestInit];
-    expect(moved.method).toBe('POST');
-    expect(await moved.text()).toBe('{"model":"gpt-5"}');
-    expect(moved.headers.get('authorization')).toBe('Bearer fixture');
-    expect(moved.headers.get('ChatGPT-Account-Id')).toBe('account-fixture');
-    expect(options).toBe(init);
-    abort.abort();
-    expect(moved.signal.aborted).toBe(true);
-  });
-
-  it('never retries a failed capture directly', async () => {
-    const original = vi.fn(async () => {
-      throw new Error('proxy unavailable');
-    });
-    vi.stubGlobal('fetch', original);
-    installOpenCodeCapture(PROXY);
-    await expect(fetch(CHATGPT)).rejects.toThrow('proxy unavailable');
-    expect(original).toHaveBeenCalledTimes(1);
-  });
-
-  it('keeps Bun fetch helpers and makes disposed wrappers inactive', async () => {
-    const original = Object.assign(
-      vi.fn(async () => new Response('ok')),
-      { preconnect: vi.fn() },
-    );
-    vi.stubGlobal('fetch', original);
-    const first = installOpenCodeCapture(PROXY);
-    const second = installOpenCodeCapture(PROXY);
-    expect((fetch as unknown as { preconnect: unknown }).preconnect).toBe(original.preconnect);
-    await first.dispose();
-    await second.dispose();
-    await fetch(CHATGPT);
-    expect(original).toHaveBeenCalledExactlyOnceWith(CHATGPT, undefined);
-  });
-});
-
-describe('OpenCode capture plugin configuration', () => {
-  it('appends a loadable local plugin while preserving JSONC config and existing plugins', async () => {
-    const scratch = await mkdtemp(join(tmpdir(), 'agenticreplay opencode-'));
-    try {
-      const theirs = `{
-        // Existing user choices must survive.
-        "model": "openai/gpt-5",
-        "plugin": ["user-plugin", ["configured-plugin", {"enabled": true}]],
-        "provider": {"openai": {"options": {"baseURL": "https://gateway.example/v1"}}},
-      }`;
-      const env = { OPENCODE_CONFIG_CONTENT: theirs, AGENTICREPLAY_OPENCODE_VERSION: '2.0.0' };
-      const launch = await openCodeAdapter.prepare({
-        runId: 'run_abc123',
-        cwd: scratch,
-        runDir: scratch,
-        proxyUrl: PROXY,
-        env,
-        userArgs: [],
-      });
-      const config = JSON.parse(launch.env.OPENCODE_CONFIG_CONTENT!);
-      expect(config.model).toBe('openai/gpt-5');
-      expect(config.provider.openai.options.baseURL).toBe('https://gateway.example/v1');
-      expect(config.plugin.slice(0, 2)).toEqual([
-        'user-plugin',
-        ['configured-plugin', { enabled: true }],
-      ]);
-      expect(env.OPENCODE_CONFIG_CONTENT).toBe(theirs);
-      const source = await readFile(fileURLToPath(config.plugin[2]), 'utf8');
-      expect(source).toContain(installOpenCodeCapture.toString());
-      expect(source).not.toContain('import ');
-      const v2Source = await readFile(join(fileURLToPath(config.plugins[0]), 'index.mjs'), 'utf8');
-      expect(v2Source).toContain("id: 'agenticreplay.capture'");
-      expect(v2Source).toContain("session.hook('http.request'");
-    } finally {
-      await rm(scratch, { recursive: true, force: true });
-    }
-  });
-});