agenticreplay 0.1.0 → 0.1.2

package/packages/cli/test/exchange-events.test.ts

@@ -1,345 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { RecordedExchange } from '@agenticreplay/proxy';
-import { ExchangeEventDeriver } from '../src/exchange-events.js';
-
-function exchange(over: Partial<RecordedExchange> = {}): RecordedExchange {
-  return {
-    seq: 0,
-    dialect: 'anthropic',
-    path: '/v1/messages',
-    rawRequest: '{}',
-    rawResponse: '{}',
-    status: 200,
-    streamed: false,
-    canonicalRequest: {
-      model: 'claude-opus-5',
-      messages: [{ role: 'user', content: [{ type: 'text', text: 'fix it' }] }],
-    },
-    canonicalResponse: {
-      id: 'msg_0',
-      model: 'claude-opus-5',
-      stop_reason: 'end_turn',
-      content: [{ type: 'text', text: 'ok' }],
-      usage: { input_tokens: 10, output_tokens: 3 },
-    },
-    ...over,
-  };
-}
-
-describe('ExchangeEventDeriver', () => {
-  it('derives a request and a response for a plain exchange', () => {
-    const events = new ExchangeEventDeriver().derive(exchange(), 1);
-    expect(events.map((e) => e.type)).toEqual(['model.request', 'model.response']);
-    expect(events[1]!.attrs.input_tokens).toBe(10);
-  });
-
-  it('links the response back to the request it answered', () => {
-    const events = new ExchangeEventDeriver().derive(exchange(), 0);
-    const requestAt = events.findIndex((e) => e.type === 'model.request');
-    const response = events.find((e) => e.type === 'model.response')!;
-    // Without this edge `agenticreplay graph --to <a model.response>` finds nothing to walk and reports
-    // that the run has no causal edges, however many tool calls it has.
-    expect(response.causesIndex).toEqual([requestAt]);
-  });
-
-  it('derives a tool.call from a tool_use in the response', () => {
-    const events = new ExchangeEventDeriver().derive(
-      exchange({
-        canonicalResponse: {
-          id: 'msg_0',
-          model: 'claude-opus-5',
-          stop_reason: 'tool_use',
-          content: [{ type: 'tool_use', id: 'tu_1', name: 'bash', input: { cmd: 'npm test' } }],
-          usage: { input_tokens: 10, output_tokens: 3 },
-        },
-      }),
-      1,
-    );
-    expect(events.map((e) => e.type)).toContain('tool.call');
-    expect(events.at(-1)!.attrs.name).toBe('bash');
-  });
-
-  it('closes a tool call using the result carried by the NEXT request', () => {
-    const d = new ExchangeEventDeriver();
-    d.derive(
-      exchange({
-        canonicalResponse: {
-          id: 'msg_0',
-          model: 'claude-opus-5',
-          stop_reason: 'tool_use',
-          content: [{ type: 'tool_use', id: 'tu_1', name: 'bash', input: {} }],
-          usage: { input_tokens: 10, output_tokens: 3 },
-        },
-      }),
-      1,
-    );
-    expect(d.unresolved().map((p) => p.id)).toEqual(['tu_1']);
-
-    const next = d.derive(
-      exchange({
-        canonicalRequest: {
-          model: 'claude-opus-5',
-          messages: [
-            { role: 'user', content: [{ type: 'text', text: 'fix it' }] },
-            {
-              role: 'assistant',
-              content: [{ type: 'tool_use', id: 'tu_1', name: 'bash', input: {} }],
-            },
-            {
-              role: 'user',
-              content: [
-                { type: 'tool_result', tool_use_id: 'tu_1', content: 'FAIL', is_error: true },
-              ],
-            },
-          ],
-        },
-      }),
-      2,
-    );
-
-    expect(next[0]!.type).toBe('tool.result');
-    expect(next[0]!.attrs.name).toBe('bash');
-    expect(next[0]!.attrs.is_error).toBe(true);
-    expect(next[0]!.payload).toBe('FAIL');
-    expect(d.unresolved()).toHaveLength(0);
-  });
-
-  it('links a tool result back to the call that produced it', () => {
-    // `causes` is the only thing that turns a flat event list into a chain you can walk, and it was
-    // never set on a `tool.result`: `derive()` dropped the pending entry in the same loop that
-    // built the event, so by the time the recorder asked for the call's seq there was nothing left
-    // to answer with. The recorder does that lookup *after* derive returns, which is why deleting
-    // early broke it silently — no error, just an empty field on every tool result ever recorded.
-    const d = new ExchangeEventDeriver();
-    d.derive(
-      exchange({
-        canonicalResponse: {
-          id: 'msg_0',
-          model: 'claude-opus-5',
-          stop_reason: 'tool_use',
-          content: [{ type: 'tool_use', id: 'tu_1', name: 'bash', input: {} }],
-          usage: { input_tokens: 10, output_tokens: 3 },
-        },
-      }),
-      1,
-    );
-    // The writer assigns the seq and hands it back, exactly as `record` does.
-    d.markPending('tu_1', 7);
-
-    const next = d.derive(
-      exchange({
-        canonicalRequest: {
-          model: 'claude-opus-5',
-          messages: [
-            {
-              role: 'user',
-              content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'ok' }],
-            },
-          ],
-        },
-      }),
-      2,
-    );
-
-    const result = next.find((e) => e.type === 'tool.result');
-    expect(result).toBeDefined();
-    expect(d.seqOf('tu_1'), 'the call seq must still be resolvable after derive returns').toBe(7);
-  });
-
-  it('emits tool.result before the request that carried it, since the work came first', () => {
-    const d = new ExchangeEventDeriver();
-    d.derive(
-      exchange({
-        canonicalResponse: {
-          id: 'm',
-          model: 'm',
-          stop_reason: 'tool_use',
-          content: [{ type: 'tool_use', id: 'tu_1', name: 'bash', input: {} }],
-          usage: { input_tokens: 1, output_tokens: 1 },
-        },
-      }),
-      1,
-    );
-    const next = d.derive(
-      exchange({
-        canonicalRequest: {
-          model: 'm',
-          messages: [
-            {
-              role: 'user',
-              content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'ok' }],
-            },
-          ],
-        },
-      }),
-      2,
-    );
-    expect(next.map((e) => e.type)).toEqual(['tool.result', 'model.request', 'model.response']);
-  });
-
-  it('does not re-emit results for calls already closed on an earlier turn', () => {
-    const d = new ExchangeEventDeriver();
-    d.derive(
-      exchange({
-        canonicalResponse: {
-          id: 'm',
-          model: 'm',
-          stop_reason: 'tool_use',
-          content: [{ type: 'tool_use', id: 'tu_1', name: 'bash', input: {} }],
-          usage: { input_tokens: 1, output_tokens: 1 },
-        },
-      }),
-      1,
-    );
-    const withResult = {
-      model: 'm',
-      messages: [
-        {
-          role: 'user' as const,
-          content: [{ type: 'tool_result' as const, tool_use_id: 'tu_1', content: 'ok' }],
-        },
-      ],
-    };
-    d.derive(exchange({ canonicalRequest: withResult }), 2);
-    const third = d.derive(exchange({ canonicalRequest: withResult }), 3);
-    expect(third.filter((e) => e.type === 'tool.result')).toHaveLength(0);
-  });
-
-  it('reports a tool call whose result never arrived rather than dropping it', () => {
-    const d = new ExchangeEventDeriver();
-    d.derive(
-      exchange({
-        canonicalResponse: {
-          id: 'm',
-          model: 'm',
-          stop_reason: 'tool_use',
-          content: [{ type: 'tool_use', id: 'tu_orphan', name: 'bash', input: {} }],
-          usage: { input_tokens: 1, output_tokens: 1 },
-        },
-      }),
-      1,
-    );
-    expect(d.unresolved().map((p) => p.id)).toEqual(['tu_orphan']);
-  });
-
-  it('survives an exchange whose response could not be canonicalized', () => {
-    const events = new ExchangeEventDeriver().derive(
-      exchange({ canonicalResponse: undefined, rawResponse: 'not json' }),
-      1,
-    );
-    expect(events.map((e) => e.type)).toEqual(['model.request', 'model.response']);
-    expect(events[1]!.attrs.stop_reason).toBe('unknown');
-  });
-});
-
-/**
- * A `tool_use` block is physically inside the response that emitted it, and a `tool_result` block
- * is physically inside the request that carried it back. Neither is an inference, so both belong
- * in `causes` — but the deriver has no seqs, which only exist once the writer has appended. It
- * names positions in its own batch instead, and the recorder resolves them.
- */
-describe('ExchangeEventDeriver causal references', () => {
-  const withToolUse = exchange({
-    canonicalResponse: {
-      id: 'msg_0',
-      model: 'claude-opus-5',
-      stop_reason: 'tool_use',
-      content: [{ type: 'tool_use', id: 'tu_1', name: 'bash', input: { cmd: 'npm test' } }],
-      usage: { input_tokens: 10, output_tokens: 3 },
-    },
-  });
-
-  it('points a tool.call at the model.response that emitted it', () => {
-    const events = new ExchangeEventDeriver().derive(withToolUse, 1);
-    const responseAt = events.findIndex((e) => e.type === 'model.response');
-    const call = events.find((e) => e.type === 'tool.call');
-    expect(call?.causesIndex).toEqual([responseAt]);
-  });
-
-  it('points a model.request at the tool.result it carried back', () => {
-    const d = new ExchangeEventDeriver();
-    d.derive(withToolUse, 1);
-    const next = d.derive(
-      exchange({
-        canonicalRequest: {
-          model: 'claude-opus-5',
-          messages: [
-            {
-              role: 'user',
-              content: [{ type: 'tool_result', tool_use_id: 'tu_1', content: 'ok' }],
-            },
-          ],
-        },
-      }),
-      2,
-    );
-    const resultAt = next.findIndex((e) => e.type === 'tool.result');
-    const request = next.find((e) => e.type === 'model.request');
-    expect(resultAt).toBeGreaterThanOrEqual(0);
-    expect(request?.causesIndex).toEqual([resultAt]);
-  });
-
-  it('leaves the reference off a request that carried no result, rather than naming nothing', () => {
-    const events = new ExchangeEventDeriver().derive(exchange(), 1);
-    expect(events.find((e) => e.type === 'model.request')?.causesIndex).toBeUndefined();
-  });
-
-  it('names every result when one request carries several', () => {
-    const d = new ExchangeEventDeriver();
-    d.derive(
-      exchange({
-        canonicalResponse: {
-          id: 'msg_0',
-          model: 'claude-opus-5',
-          stop_reason: 'tool_use',
-          content: [
-            { type: 'tool_use', id: 'tu_1', name: 'bash', input: {} },
-            { type: 'tool_use', id: 'tu_2', name: 'edit', input: {} },
-          ],
-          usage: { input_tokens: 10, output_tokens: 3 },
-        },
-      }),
-      1,
-    );
-    const next = d.derive(
-      exchange({
-        canonicalRequest: {
-          model: 'claude-opus-5',
-          messages: [
-            {
-              role: 'user',
-              content: [
-                { type: 'tool_result', tool_use_id: 'tu_1', content: 'a' },
-                { type: 'tool_result', tool_use_id: 'tu_2', content: 'b' },
-              ],
-            },
-          ],
-        },
-      }),
-      2,
-    );
-    expect(next.find((e) => e.type === 'model.request')?.causesIndex).toEqual([0, 1]);
-  });
-
-  it('points both tool.calls of one response at that same response', () => {
-    const events = new ExchangeEventDeriver().derive(
-      exchange({
-        canonicalResponse: {
-          id: 'msg_0',
-          model: 'claude-opus-5',
-          stop_reason: 'tool_use',
-          content: [
-            { type: 'tool_use', id: 'tu_1', name: 'bash', input: {} },
-            { type: 'tool_use', id: 'tu_2', name: 'edit', input: {} },
-          ],
-          usage: { input_tokens: 10, output_tokens: 3 },
-        },
-      }),
-      1,
-    );
-    const responseAt = events.findIndex((e) => e.type === 'model.response');
-    const calls = events.filter((e) => e.type === 'tool.call');
-    expect(calls).toHaveLength(2);
-    for (const call of calls) expect(call.causesIndex).toEqual([responseAt]);
-  });
-});

package/packages/cli/test/failure-lines.test.ts

@@ -1,47 +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 { main } from '../src/main.js';
-
-/**
- * Through `main()`, because that is where a thrown message is cut into `what` and `why` — and where
- * the line breaks a message was composed with came out spelled `\x0a`, one line with the choices of
- * a flag, the install command or the order settings are read in run together inside it.
- */
-describe('a failure prints as the lines it was written in', () => {
-  let cwd: string;
-  let printed: string[];
-  const real = { out: process.stdout.write, err: process.stderr.write };
-
-  beforeEach(async () => {
-    cwd = await mkdtemp(join(tmpdir(), 'agenticreplay-failure-lines-'));
-    printed = [];
-    const capture = ((s: string | Uint8Array) => (
-      printed.push(String(s)),
-      true
-    )) as typeof process.stdout.write;
-    process.stdout.write = capture;
-    process.stderr.write = capture;
-  });
-
-  afterEach(async () => {
-    process.stdout.write = real.out;
-    process.stderr.write = real.err;
-    await rm(cwd, { recursive: true, force: true });
-  });
-
-  it('lists the choices of a flag one per line', async () => {
-    const code = await main(
-      ['record', 'generic-openai', '--retrieval-store', 'bogus', '--', 'node', '-e', '1'],
-      cwd,
-    );
-    const lines = printed.join('').split('\n');
-    expect(code).toBe(1);
-    expect(lines).toContain('  full   keep the response, so the run can be replayed offline');
-    expect(lines).toContain(
-      '  digest keep only its sha256, which proves a later run agreed but cannot serve it',
-    );
-    expect(lines.join('\n')).not.toContain('\\x0a');
-  });
-});

package/packages/cli/test/fixtures/deaf-agent.mjs

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-/**
- * An agent that ignores every base-URL variable, for the capture-warning tests.
- *
- * This is not a contrived failure. An agent that never consults a base-URL variable does
- * exactly this under `agenticreplay record`: works perfectly, exits 0, and never once touches the
- * proxy. The run looks like a success from every angle except the one that matters, and the
- * trace is empty.
- */
-console.log('deaf-agent: did some work without asking any model');
-process.exit(0);

package/packages/cli/test/fixtures/embedding-agent.mjs

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-/**
- * An agent that only embeds — the shape of an index build, for the capture-warning tests.
- *
- * Not contrived either. `scripts/build_kb.py` in IndexRAG makes exactly one kind of call, and it
- * is this one: a batch of texts to `/v1/embeddings`, no conversation anywhere. Before retrieval
- * had an answer, recording that printed `capture.empty exchanges=0 cause="the agent never called
- * the proxy — it may not read a base-URL variable"` over a run whose variable was set correctly
- * and whose every call agenticreplay had captured.
- */
-const base = process.env.OPENAI_BASE_URL;
-if (!base) {
-  console.error('embedding-agent: OPENAI_BASE_URL is not set');
-  process.exit(2);
-}
-
-const res = await fetch(`${base}/embeddings`, {
-  method: 'POST',
-  headers: {
-    'content-type': 'application/json',
-    authorization: `Bearer ${process.env.OPENAI_API_KEY ?? 'test-key'}`,
-  },
-  body: JSON.stringify({ model: 'stub-embedding', input: ['one', 'two'] }),
-});
-
-if (!res.ok) {
-  console.error(`embedding-agent: upstream ${res.status}: ${await res.text()}`);
-  process.exit(3);
-}
-
-const body = await res.json();
-console.log(`embedding-agent: embedded ${body.data?.length ?? 0} inputs`);

package/packages/cli/test/fixtures/fake-agent.mjs

@@ -1,114 +0,0 @@
-#!/usr/bin/env node
-/**
- * A stand-in coding agent, for end-to-end tests.
- *
- * It behaves the way the real targets do in the only respects AgenticReplay depends on: it reads
- * ANTHROPIC_BASE_URL from the environment, drives a multi-turn tool loop over the Messages API,
- * resends the whole conversation every turn (which is what lets the proxy see tool results), and
- * edits a file on disk. If AgenticReplay can record and replay this, the mechanism is sound.
- */
-import { readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-const base = process.env.ANTHROPIC_BASE_URL;
-if (!base) {
-  console.error('fake-agent: ANTHROPIC_BASE_URL is not set');
-  process.exit(2);
-}
-
-const turns = Number(process.env.FAKE_AGENT_TURNS ?? '3');
-// Its own working directory, like a real agent. Overridable only because a couple of tests pin
-// it; anything that pins it stops exercising the directory the harness was actually launched in,
-// which is the whole point of restoring a worktree before a replay or a fork.
-const cwd = process.env.FAKE_AGENT_CWD ?? process.cwd();
-const prompt = process.env.FAKE_AGENT_PROMPT ?? 'fix the auth test';
-// Real harnesses open with a system prompt and a tool catalogue that put the very first request
-// well past the trace's inline payload limit, so the recorded body spills to a blob. Padding lets a
-// test cross that boundary on purpose, because the code either side of it is not the same code.
-const pad = Number(process.env.FAKE_AGENT_PAD ?? '0');
-const system =
-  pad > 0 ? `You are a coding agent. ${'Follow the conventions. '.repeat(pad)}` : undefined;
-
-const tools = [
-  {
-    name: 'edit_file',
-    description: 'Write content to a file',
-    input_schema: {
-      type: 'object',
-      properties: { path: { type: 'string' }, content: { type: 'string' } },
-      required: ['path', 'content'],
-    },
-  },
-];
-
-// Reading a file into the conversation is what makes a run depend on the filesystem it started
-// from: the bytes end up inside the request, so replaying against a directory the recording itself
-// mutated produces a different request. Real harnesses do this on almost every turn.
-const readPath = process.env.FAKE_AGENT_READ;
-const opening = readPath
-  ? `${prompt}\n\n<file path="${readPath}">\n${readFileSync(join(cwd, readPath), 'utf8')}</file>`
-  : prompt;
-
-const messages = [{ role: 'user', content: [{ type: 'text', text: opening }] }];
-
-for (let turn = 0; turn < turns; turn += 1) {
-  const res = await fetch(`${base}/v1/messages`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      'x-api-key': process.env.ANTHROPIC_API_KEY ?? 'test-key',
-      'anthropic-version': '2023-06-01',
-    },
-    body: JSON.stringify({
-      model: 'claude-opus-5',
-      max_tokens: 1024,
-      tools,
-      messages,
-      ...(system === undefined ? {} : { system }),
-    }),
-  });
-
-  if (!res.ok) {
-    console.error(`fake-agent: upstream ${res.status}: ${await res.text()}`);
-    process.exit(3);
-  }
-
-  const body = await res.json();
-  messages.push({ role: 'assistant', content: body.content });
-
-  const toolUse = (body.content ?? []).find((b) => b.type === 'tool_use');
-  if (!toolUse) break;
-
-  // Perform the tool call, then hand the result back on the NEXT request — which is precisely
-  // how the proxy gets to see it without hooking the harness.
-  let result = 'ok';
-  try {
-    if (toolUse.name === 'edit_file') {
-      writeFileSync(join(cwd, toolUse.input.path), toolUse.input.content);
-      result = `wrote ${toolUse.input.path}`;
-    }
-  } catch (err) {
-    result = `error: ${String(err)}`;
-  }
-
-  messages.push({
-    role: 'user',
-    content: [{ type: 'tool_result', tool_use_id: toolUse.id, content: result }],
-  });
-}
-
-// One HTTPS side-call, only when a test asks for it. This is what a harness that talks to its own
-// backend does, and it is the only way a *fork* — which launches this same agent from the parent's
-// argv — can be checked for interception at all.
-if (process.env.AGENTICREPLAY_TEST_TARGETS) {
-  const { callConfiguredTargets } = await import('./proxy-call.mjs');
-  const results = await callConfiguredTargets();
-  if (process.env.AGENTICREPLAY_TEST_RESULT_OUT) {
-    writeFileSync(process.env.AGENTICREPLAY_TEST_RESULT_OUT, JSON.stringify(results, null, 2));
-  }
-}
-if (process.env.AGENTICREPLAY_TEST_ENV_OUT) {
-  writeFileSync(process.env.AGENTICREPLAY_TEST_ENV_OUT, JSON.stringify(process.env, null, 2));
-}
-
-console.log(`fake-agent: completed ${messages.length} messages`);

package/packages/cli/test/fixtures/fake-model.mjs

@@ -1,105 +0,0 @@
-/**
- * A deterministic stand-in for a model API, so end-to-end tests never touch the network.
- *
- * Turn 1 asks for a file edit, later turns end the conversation. Deterministic on purpose: an
- * exact-replay test cannot distinguish "replay worked" from "the model happened to agree" unless
- * the recording is reproducible in the first place.
- */
-import { createServer } from 'node:http';
-
-export async function startFakeModel(options = {}) {
-  const calls = [];
-  /**
-   * Answer every call with this HTTP status instead of a completion.
-   *
-   * A provider that refuses -- an expired credential, a model the account cannot reach -- is not
-   * an exotic case, and from the harness's side it looks like a run that merely went badly. The
-   * recording still happens; every answer in it is the refusal.
-   */
-  const failWith = options.failWith;
-  const editContent = options.editContent ?? 'export const fixed = true;\n';
-
-  const server = createServer((req, res) => {
-    const chunks = [];
-    req.on('data', (c) => chunks.push(c));
-    req.on('end', () => {
-      const raw = Buffer.concat(chunks).toString('utf8');
-      let body = {};
-      try {
-        body = JSON.parse(raw);
-      } catch {
-        /* fall through to the default reply */
-      }
-      calls.push({ url: req.url, body });
-
-      const turn = (body.messages ?? []).filter((m) => m.role === 'assistant').length;
-      const wantsEdit = turn === 0;
-
-      const reply = wantsEdit
-        ? {
-            id: `msg_${turn}`,
-            type: 'message',
-            role: 'assistant',
-            model: body.model ?? 'claude-opus-5',
-            content: [
-              { type: 'text', text: 'editing auth.ts' },
-              {
-                type: 'tool_use',
-                id: `tu_${turn}`,
-                name: 'edit_file',
-                input: { path: 'auth.ts', content: editContent },
-              },
-            ],
-            stop_reason: 'tool_use',
-            usage: { input_tokens: 100 + turn, output_tokens: 20 + turn },
-          }
-        : {
-            id: `msg_${turn}`,
-            type: 'message',
-            role: 'assistant',
-            model: body.model ?? 'claude-opus-5',
-            content: [{ type: 'text', text: 'done' }],
-            stop_reason: 'end_turn',
-            usage: { input_tokens: 100 + turn, output_tokens: 5 },
-          };
-
-      if (failWith !== undefined) {
-        res.writeHead(failWith, { 'content-type': 'application/json' });
-        res.end(JSON.stringify({ error: { type: 'error', message: 'no auth available' } }));
-        return;
-      }
-      // Embeddings, for the tests that record a run whose only calls are retrieval. Deterministic
-      // for the same reason every other answer here is: a replay is judged on matching what was
-      // recorded, so a varying answer would make a correct replay indistinguishable from a lucky
-      // one.
-      if (req.url?.endsWith('/embeddings')) {
-        const inputs = Array.isArray(body.input) ? body.input : [body.input ?? ''];
-        res.writeHead(200, { 'content-type': 'application/json' });
-        res.end(
-          JSON.stringify({
-            object: 'list',
-            data: inputs.map((text, index) => ({
-              object: 'embedding',
-              index,
-              embedding: [String(text).length / 10, index / 10],
-            })),
-            model: body.model ?? 'stub-embedding',
-            usage: { prompt_tokens: inputs.length, total_tokens: inputs.length },
-          }),
-        );
-        return;
-      }
-      res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify(reply));
-    });
-  });
-
-  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
-  const { port } = server.address();
-
-  return {
-    url: `http://127.0.0.1:${port}`,
-    calls,
-    close: () => new Promise((resolve) => server.close(resolve)),
-  };
-}

package/packages/cli/test/fixtures/gateway-agent.mjs

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-/**
- * A stand-in for a gateway that launches a coding agent, for the OpenClaw-shaped tests.
- *
- * It makes no model call of its own. It spawns a child that does, and passes on nothing — the
- * child sees the environment only because a process inherits its parent's. That inheritance is the
- * whole mechanism behind recording a gateway, and it is a property of the OS rather than of agenticreplay,
- * which is exactly why it is worth a test rather than a sentence in a README.
- */
-import { spawn } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const here = dirname(fileURLToPath(import.meta.url));
-console.log('gateway: launching the coding agent');
-const child = spawn(process.execPath, [join(here, 'responses-agent.mjs')], { stdio: 'inherit' });
-child.on('exit', (code) => {
-  console.log(`gateway: agent exited ${code}`);
-  process.exit(code ?? 0);
-});