agenticreplay 0.1.0 → 0.1.2

package/test/integrations/stub-origin.mjs

@@ -1,229 +0,0 @@
-/**
- * A deterministic OpenAI- and Anthropic-shaped origin.
- *
- * Deterministic on purpose: a replay is judged on matching the bytes it recorded, so an origin that
- * varied its answer would make an exact match indistinguishable from a lucky one.
- *
- * It answers the shapes frameworks actually use rather than the simplest one — streaming SSE, tool
- * calls, and `/v1/messages` — because those are where a recording proxy is most likely to break and
- * a stub that only served a plain completion would have proved nothing about either.
- */
-import { createServer } from 'node:http';
-
-const REPLY = 'the stub answered';
-
-function completion(seen) {
-  const wantsTool = Array.isArray(seen.tools) && seen.tools.length > 0;
-  const message = wantsTool
-    ? {
-        role: 'assistant',
-        content: null,
-        tool_calls: [
-          {
-            id: 'call_stub_1',
-            type: 'function',
-            function: {
-              name: seen.tools[0]?.function?.name ?? 'unknown',
-              arguments: '{"city":"Paris"}',
-            },
-          },
-        ],
-      }
-    : { role: 'assistant', content: REPLY };
-
-  return {
-    id: 'chatcmpl-stub-1',
-    object: 'chat.completion',
-    created: 1756000000,
-    model: seen.model ?? 'stub-1',
-    choices: [{ index: 0, message, finish_reason: wantsTool ? 'tool_calls' : 'stop' }],
-    usage: { prompt_tokens: 9, completion_tokens: 4, total_tokens: 13 },
-  };
-}
-
-/** The same answer as the delta frames a streaming client expects. */
-function stream(seen) {
-  const base = {
-    id: 'chatcmpl-stub-1',
-    object: 'chat.completion.chunk',
-    created: 1756000000,
-    model: seen.model ?? 'stub-1',
-  };
-  const frames = [
-    { ...base, choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }] },
-    { ...base, choices: [{ index: 0, delta: { content: 'the stub ' }, finish_reason: null }] },
-    { ...base, choices: [{ index: 0, delta: { content: 'answered' }, finish_reason: null }] },
-    { ...base, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] },
-  ];
-  return `${frames.map((f) => `data: ${JSON.stringify(f)}\n\n`).join('')}data: [DONE]\n\n`;
-}
-
-/**
- * The Responses API shape.
- *
- * Here because it is the OpenAI Agents SDK's *default* — not an option it offers — so a check that
- * quietly switched the SDK to chat completions would prove the wrong path works. agenticreplay has carried a
- * `responses` dialect since early on; until this, nothing end to end exercised it.
- */
-/** How many Responses calls this instance has answered, so a handoff can happen on the first. */
-let responseCalls = 0;
-
-function responses(seen) {
-  responseCalls += 1;
-  // Only when a handoff is actually on offer. The Agents SDK implements a handoff as a function
-  // tool named `transfer_to_<agent>`, so driving one means answering with that call — and a check
-  // whose agent has no handoffs sees none of this.
-  const transfer = (Array.isArray(seen.tools) ? seen.tools : []).find((t) =>
-    String(t?.name ?? '').startsWith('transfer_to_'),
-  );
-  if (responseCalls === 1 && transfer !== undefined) {
-    return {
-      id: 'resp_stub_handoff',
-      object: 'response',
-      created_at: 1756000000,
-      status: 'completed',
-      model: seen.model ?? 'stub-1',
-      output: [
-        {
-          id: 'fc_stub_1',
-          type: 'function_call',
-          status: 'completed',
-          call_id: 'call_stub_1',
-          name: transfer.name,
-          arguments: '{}',
-        },
-      ],
-      usage: { input_tokens: 9, output_tokens: 4, total_tokens: 13 },
-      parallel_tool_calls: false,
-      tool_choice: 'auto',
-      tools: [],
-    };
-  }
-  return {
-    id: 'resp_stub_1',
-    object: 'response',
-    created_at: 1756000000,
-    status: 'completed',
-    model: seen.model ?? 'stub-1',
-    output: [
-      {
-        id: 'msg_stub_1',
-        type: 'message',
-        role: 'assistant',
-        status: 'completed',
-        content: [{ type: 'output_text', text: REPLY, annotations: [] }],
-      },
-    ],
-    usage: { input_tokens: 9, output_tokens: 4, total_tokens: 13 },
-    parallel_tool_calls: false,
-    tool_choice: 'auto',
-    tools: [],
-  };
-}
-
-/**
- * Embeddings, deterministic per input text.
- *
- * A function of the text and nothing else, which is the property the whole retrieval-replay
- * mechanism rests on — and the reason a check can assert that a replayed index is the recorded
- * one rather than a similar one. A stub that returned random vectors would make a correct replay
- * indistinguishable from a lucky one, exactly as a varying completion would.
- *
- * `encoding_format: "base64"` is answered in base64, because that is what the OpenAI SDK asks for
- * by default and a stub that always returned floats would exercise a path real clients do not
- * take.
- */
-function embeddings(seen) {
-  const inputs = Array.isArray(seen.input) ? seen.input : [seen.input ?? ''];
-  const base64 = seen.encoding_format === 'base64';
-  return {
-    object: 'list',
-    data: inputs.map((text, index) => {
-      const vector = vectorFor(String(text));
-      return {
-        object: 'embedding',
-        index,
-        embedding: base64 ? encodeFloats(vector) : vector,
-      };
-    }),
-    model: seen.model ?? 'stub-embedding',
-    usage: { prompt_tokens: inputs.length * 4, total_tokens: inputs.length * 4 },
-  };
-}
-
-/** Eight dimensions, derived from the text so the same text always embeds the same way. */
-function vectorFor(text) {
-  let hash = 2166136261;
-  for (const ch of text) {
-    hash ^= ch.codePointAt(0);
-    hash = Math.imul(hash, 16777619) >>> 0;
-  }
-  return Array.from({ length: 8 }, (_, i) => {
-    hash = Math.imul(hash ^ (i + 1), 16777619) >>> 0;
-    return Number((hash / 2 ** 32 - 0.5).toFixed(6));
-  });
-}
-
-/** Little-endian float32, base64 — the encoding the OpenAI SDK decodes. */
-function encodeFloats(vector) {
-  const buf = Buffer.alloc(vector.length * 4);
-  vector.forEach((v, i) => buf.writeFloatLE(v, i * 4));
-  return buf.toString('base64');
-}
-
-function anthropic(seen) {
-  return {
-    id: 'msg_stub_1',
-    type: 'message',
-    role: 'assistant',
-    model: seen.model ?? 'claude-stub',
-    content: [{ type: 'text', text: REPLY }],
-    stop_reason: 'end_turn',
-    usage: { input_tokens: 9, output_tokens: 4 },
-  };
-}
-
-const server = createServer((req, res) => {
-  let body = '';
-  req.on('data', (chunk) => (body += chunk));
-  req.on('end', () => {
-    let seen = {};
-    try {
-      seen = JSON.parse(body || '{}');
-    } catch {
-      // A body this stub cannot parse is still a request worth answering; the shape under test is
-      // whether agenticreplay captured it, not whether the client sent valid JSON.
-    }
-
-    // Before `/completions`, which it does not end in, but ahead of the generic branch for the
-    // same reason the others are: an embeddings client cannot parse a chat completion.
-    if (req.url?.endsWith('/embeddings')) {
-      res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify(embeddings(seen)));
-      return;
-    }
-    // Before the generic branch: a Responses request wants Responses output back, not a
-    // chat.completion the SDK cannot parse.
-    if (req.url?.includes('/responses')) {
-      res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify(responses(seen)));
-      return;
-    }
-    if (req.url?.includes('/messages')) {
-      res.writeHead(200, { 'content-type': 'application/json' });
-      res.end(JSON.stringify(anthropic(seen)));
-      return;
-    }
-    if (seen.stream === true) {
-      res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache' });
-      res.end(stream(seen));
-      return;
-    }
-    res.writeHead(200, { 'content-type': 'application/json' });
-    res.end(JSON.stringify(completion(seen)));
-  });
-});
-
-server.listen(Number(process.argv[2] ?? 0), '127.0.0.1', () => {
-  process.stdout.write(`${server.address().port}\n`);
-});

package/tsconfig.base.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2023",
-    "lib": ["ES2023"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "exactOptionalPropertyTypes": false,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "composite": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": true
-  }
-}

package/tsconfig.json

@@ -1,41 +0,0 @@
-{
-  "files": [],
-  "references": [
-    {
-      "path": "packages/schema"
-    },
-    {
-      "path": "packages/plugin-api"
-    },
-    {
-      "path": "packages/core"
-    },
-    {
-      "path": "packages/fs-capture"
-    },
-    {
-      "path": "packages/providers"
-    },
-    {
-      "path": "packages/proxy"
-    },
-    {
-      "path": "packages/mcp-shim"
-    },
-    {
-      "path": "packages/shell-shim"
-    },
-    {
-      "path": "packages/node-instrument"
-    },
-    {
-      "path": "packages/adapters"
-    },
-    {
-      "path": "packages/viewer"
-    },
-    {
-      "path": "packages/cli"
-    }
-  ]
-}

package/vitest.config.ts

@@ -1,39 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { defineConfig } from 'vitest/config';
-
-const pkg = (name: string) =>
-  fileURLToPath(new URL(`./packages/${name}/src/index.ts`, import.meta.url));
-
-export default defineConfig({
-  resolve: {
-    // Tests run against source, not built output, so `npx vitest` needs no prior `tsc --build`.
-    // CONTRIBUTING promises a five-minute dev loop; a mandatory build step is how that promise
-    // quietly becomes twenty.
-    alias: {
-      '@agenticreplay/schema': pkg('schema'),
-      '@agenticreplay/plugin-api': pkg('plugin-api'),
-      '@agenticreplay/core': pkg('core'),
-      '@agenticreplay/fs-capture': pkg('fs-capture'),
-      '@agenticreplay/providers': pkg('providers'),
-      '@agenticreplay/proxy': pkg('proxy'),
-      '@agenticreplay/adapters': pkg('adapters'),
-      '@agenticreplay/node-instrument': pkg('node-instrument'),
-      '@agenticreplay/mcp-shim': pkg('mcp-shim'),
-      '@agenticreplay/shell-shim': pkg('shell-shim'),
-      '@agenticreplay/viewer': pkg('viewer'),
-    },
-  },
-  test: {
-    // `scripts/` too, because the release scripts are code with no package to live in, and a test
-    // that is never collected is worse than no test: `set-version.test.ts` guards an edit that is
-    // permanent on npm if it goes wrong, and would have sat here green and unrun.
-    include: ['packages/*/test/**/*.test.ts', 'scripts/**/*.test.ts'],
-    environment: 'node',
-    // Every worker starts with an empty XDG_CONFIG_HOME — see the file for why that is not a
-    // convenience but the difference between a hermetic suite and one that calls a real gateway.
-    setupFiles: ['./vitest.setup.ts'],
-    testTimeout: 30_000,
-    hookTimeout: 30_000,
-    pool: 'forks',
-  },
-});

package/vitest.setup.ts

@@ -1,25 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-/**
- * No test reads the config of whoever is running it.
- *
- * `record`, `replay`, `attach` and `compare` all resolve their upstream through `upstreamPlan()`
- * and `readConfig()` with no environment argument, so they read the real `~/.config/agenticreplay`. On a
- * machine where anyone has run `agenticreplay setup`, that file names a gateway — and any dialect a test
- * did not override with `--upstream-*` resolves to it. The test then sends a live request to a
- * third party's host, and if every origin happens to be that gateway, `upstreamPlan` attaches the
- * key too.
- *
- * `compare.test.ts` had already found this and worked around it inside one `describe`, noting that
- * "CI passes only because CI has no config". That is the whole diagnosis: nothing platform-
- * specific, nothing wrong with the code under test, and invisible to CI by construction. Doing it
- * once here means no future test has to remember.
- *
- * A directory that exists and is empty, not a missing one: `readConfig` tolerates both, but a real
- * path keeps a test that *writes* a config out of the developer's own.
- */
-const isolated = mkdtempSync(join(tmpdir(), 'agenticreplay-test-config-'));
-process.env['XDG_CONFIG_HOME'] = isolated;
-process.on('exit', () => rmSync(isolated, { recursive: true, force: true }));