agenticreplay 0.1.4 → 0.1.6

package/node_modules/@agenticreplay/proxy/dist/server.js

@@ -1,12 +1,10 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { createServer } from 'node:http';
 import { AUTH_REQUEST_HEADERS, AUTH_RESPONSE_HEADERS, BINARY_BODY_PREFIX, Redactor, fetchPinned, } from '@agenticreplay/core';
-import { anthropicToCanonicalRequest, anthropicToCanonicalResponse, canonicalToAnthropicRequest, canonicalToAnthropicResponse, canonicalToAnthropicSse, canonicalToOpenaiRequest, canonicalToOpenaiResponse, canonicalToOpenaiSse, canonicalToResponsesRequest, canonicalToResponsesResponse, canonicalToResponsesSse, openaiToCanonicalRequest, openaiToCanonicalResponse, parseAnthropicSse, parseOpenaiSse, parseResponsesSse, responsesToCanonicalRequest, responsesToCanonicalResponse, } from '@agenticreplay/providers';
+import { anthropicToCanonicalRequest, anthropicToCanonicalResponse, openaiToCanonicalRequest, openaiToCanonicalResponse, parseAnthropicSse, parseOpenaiSse, parseResponsesSse, responsesToCanonicalRequest, responsesToCanonicalResponse, } from '@agenticreplay/providers';
 import { anthropicDialect, codexDialect, openaiDialect, responsesDialect, selectDialect, } from './dialects.js';
 import { decodeForwardPath } from './forward.js';
-import { consume, defaultRetrievalRules, indexRetrievals, selectRetrievalRule, } from './retrieval.js';
 import { attachTlsIntercept, decodeBody, DEFAULT_MAX_CAPTURED_BYTES, } from './intercept.js';
-import { RequestMatcher } from './matching.js';
 function scalarHeaders(headers) {
     const out = {};
     for (const [key, value] of Object.entries(headers)) {
@@ -87,24 +85,6 @@ function captureEncodingTransformation(location, encoding) {
         },
     ];
 }
-function protocolTranslationTransformation(from, to, location = 'response.body') {
-    return {
-        kind: 'encoding',
-        location,
-        rule: 'provider-protocol-translation',
-        count: 1,
-        reason: `${from} response translated to ${to} for the client`,
-    };
-}
-function modelOverrideTransformation(from, to) {
-    return {
-        kind: 'encoding',
-        location: 'request.body',
-        rule: 'model-override-and-serialization',
-        count: 1,
-        reason: `${from} request model overridden with ${to} and serialized for the live fork`,
-    };
-}
 function captureUrlTransformations(origin) {
     const scrubbed = recordableOrigin(origin);
     if (scrubbed === undefined || scrubbed === origin)
@@ -132,44 +112,6 @@ function binaryBodyTransformation(location, body) {
         },
     ];
 }
-/**
- * Beta flags that belong to the model that was recorded, not to the request.
- *
- * `anthropic-beta` is a header, so substituting a model in the body leaves it untouched — and a
- * fork of a run made on a 1M-context model onto one without that entitlement comes back
- * `400 The long context beta is not yet available for this subscription`. The failure names the
- * subscription rather than the flag, so it reads as an account problem and not as agenticreplay carrying
- * over something it should have dropped.
- *
- * Only entitlement-gated flags are removed. The rest of the header is what the harness needs to
- * speak its own protocol — tool shapes, output formats — and dropping those would break the fork
- * in a way that is much harder to see than a 400.
- */
-const MODEL_GATED_BETAS = [/^context-\d+m\b/i];
-/** `anthropic-beta` with the recorded model's entitlements taken out, or undefined if empty. */
-export function betasForModelChange(value) {
-    const kept = value
-        .split(',')
-        .map((flag) => flag.trim())
-        .filter((flag) => flag !== '' && !MODEL_GATED_BETAS.some((re) => re.test(flag)));
-    return kept.length > 0 ? kept.join(',') : undefined;
-}
-/** The outbound headers for a live call, reconciled with a model the recording did not use. */
-function headersForModel(headers, forkModel) {
-    if (forkModel === undefined)
-        return headers;
-    const out = {};
-    for (const [key, value] of Object.entries(headers)) {
-        if (key.toLowerCase() !== 'anthropic-beta') {
-            out[key] = value;
-            continue;
-        }
-        const kept = betasForModelChange(value);
-        if (kept !== undefined)
-            out[key] = kept;
-    }
-    return out;
-}
 /**
  * An origin with the parts a credential rides in taken out.
  *
@@ -359,26 +301,17 @@ export function defaultDialects() {
             toCanonicalRequest: anthropicToCanonicalRequest,
             toCanonicalResponse: anthropicToCanonicalResponse,
             parseSse: parseAnthropicSse,
-            fromCanonicalRequest: canonicalToAnthropicRequest,
-            fromCanonicalResponse: canonicalToAnthropicResponse,
-            toSse: canonicalToAnthropicSse,
         }),
         openaiDialect({
             toCanonicalRequest: openaiToCanonicalRequest,
             toCanonicalResponse: openaiToCanonicalResponse,
             parseSse: parseOpenaiSse,
-            fromCanonicalRequest: canonicalToOpenaiRequest,
-            fromCanonicalResponse: canonicalToOpenaiResponse,
-            toSse: canonicalToOpenaiSse,
         }),
         // After the chat dialect deliberately: see the note on `responsesDialect`.
         responsesDialect({
             toCanonicalRequest: responsesToCanonicalRequest,
             toCanonicalResponse: responsesToCanonicalResponse,
             parseSse: parseResponsesSse,
-            fromCanonicalRequest: canonicalToResponsesRequest,
-            fromCanonicalResponse: canonicalToResponsesResponse,
-            toSse: canonicalToResponsesSse,
         }),
     ];
 }
@@ -444,75 +377,16 @@ export async function createProxy(options) {
     //
     // `fetchImpl` stays the seam the tests inject through; only the default moves.
     const doFetch = options.fetchImpl ?? fetchPinned;
-    const recorded = options.exchanges ?? [];
     const captured = [];
     // Plain base-URL traffic needs the same aggregate bound as intercepted traffic. This counter
     // covers bodies retained by concurrent fetch responses while each response still streams to the
     // caller; it is released only after that response has been materialized into evidence.
     let plainBufferedBytes = 0;
     const plainBufferLimit = options.maxBufferedBytes ?? 256 * 1024 * 1024;
-    const stats = {
-        mode: options.mode,
-        recorded: recorded.length,
-        matchedExact: 0,
-        matchedInexact: 0,
-        divergences: 0,
-        liveCalls: 0,
-        unmatched: 0,
-        intercepted: 0,
-        tunnelled: 0,
-        passedThrough: 0,
-        retrievalServed: 0,
-        retrievalTotal: 0,
-        retrievalLive: 0,
-        retrievalReordered: 0,
-        reordered: 0,
-    };
-    // In hybrid mode only the exchanges below the fork point are replayable; everything at or above
-    // it must go live, which is exactly what makes a fork a fork.
-    const replayable = options.mode === 'hybrid' ? recorded.slice(0, options.forkAt ?? recorded.length) : recorded;
-    /**
-     * The most requests this proxy has had open at once, and the count it is derived from.
-     *
-     * Only the proxy can know this, and the matcher needs it: a pipeline that issues ten requests
-     * together is answered in whatever order the origin finished them, so a replay's request can
-     * arrive up to nine positions from the cursor. See {@link LOOKAHEAD}.
-     */
-    let inFlight = 0;
-    let peakInFlight = 0;
-    function opened() {
-        inFlight += 1;
-        if (inFlight > peakInFlight)
-            peakInFlight = inFlight;
-    }
-    function closed() {
-        if (inFlight > 0)
-            inFlight -= 1;
-    }
-    // The recorded requests carry placeholders where secrets were; a live replay request carries the
-    // secrets themselves. Without a redactor on this side the two are never in the same
-    // representation, and a recording of any real harness — whose own system prompt carries a
-    // session id — cannot match itself.
-    // Shared with the passthrough failure path, which writes an upstream's own error message into
-    // the trace: a gateway that quotes the call it refused can quote the credential with it, and §7
-    // says never write it — not "write it and let a later layer catch it".
+    const stats = { liveCalls: 0, intercepted: 0, tunnelled: 0, passedThrough: 0 };
     const redactor = new Redactor();
-    const matcher = new RequestMatcher(replayable.map((e) => e.canonicalRequest), { redactor, concurrency: () => peakInFlight });
-    /**
-     * The recording's retrieval calls, by key, ready to be consumed one at a time.
-     *
-     * Not filtered by the fork point. A fork keeps replaying these past the cursor on purpose: the
-     * vector for a paragraph does not depend on which chat model answers the question afterwards,
-     * so re-embedding it live would spend money to recompute an identical value and leave the
-     * fork's index differing from its parent's for no reason. See `RetrievalRule.forkable`.
-     */
-    const retrievalRules = options.retrievalRules ?? defaultRetrievalRules();
-    const retrievalIndex = indexRetrievals(options.retrievals ?? []);
-    stats.retrievalTotal = (options.retrievals ?? []).length;
     const server = createServer((req, res) => {
-        opened();
-        void handle(req, res)
-            .catch((err) => {
+        void handle(req, res).catch((err) => {
             // Whatever failed, its message may name the origin it was given — and this body reaches
             // the agent, which prints it. See {@link withoutCredentials}.
             if (res.destroyed || res.writableEnded)
@@ -522,8 +396,7 @@ export async function createProxy(options) {
                 return;
             }
             json(res, 500, { error: { message: withoutCredentials(String(err)) } });
-        })
-            .finally(closed);
+        });
     });
     /**
      * A decrypted exchange that turns out to be a model call is recorded as one.
@@ -594,151 +467,6 @@ export async function createProxy(options) {
         }
         options.tls?.onNetExchange?.(exchange);
     }
-    /**
-     * Replay hook for requests inside an intercepted TLS session. The ordinary HTTP proxy reaches
-     * `handle()` below, but the TLS interceptor has already terminated the outer CONNECT and needs
-     * the same matcher before it opens an origin connection.
-     *
-     * Live calls used to return `undefined` here, which forwarded the client's bytes unchanged —
-     * so `agenticreplay replay --from N --model X` on a TLS-intercepted recording echoed `model=X` and then
-     * called the recorded model. `replayed=0 live=0` was the tell: `goLive` never ran, substitution
-     * never had a chance. Same-provider `--model` now rewrites the body and still talks to the
-     * intercepted origin (the only origin that origin's credential can reach). A cross-provider
-     * target would have to leave that host, which this path cannot do; that fails loudly instead of
-     * succeeding with the old model.
-     */
-    function onInterceptedRequest(request) {
-        const path = request.path.split('?')[0] ?? '/';
-        const dialect = selectDialect(dialects, path);
-        if (!dialect || request.method !== 'POST' || request.requestTruncated)
-            return undefined;
-        let rawBody;
-        try {
-            rawBody = decodeBody(request.requestBytes, Array.isArray(request.requestHeaders['content-encoding'])
-                ? request.requestHeaders['content-encoding'].join(', ')
-                : request.requestHeaders['content-encoding'], options.maxCapturedBytes ?? DEFAULT_MAX_CAPTURED_BYTES);
-        }
-        catch (err) {
-            if (options.mode !== 'replay' || !options.loose) {
-                stats.unmatched += 1;
-                return replayError(`cannot decode intercepted request body: ${String(err)}`);
-            }
-            return undefined;
-        }
-        const result = tryReplay(dialect, rawBody);
-        if (result?.exchange) {
-            return {
-                status: result.exchange.status,
-                headers: {
-                    'content-type': result.exchange.streamed ? 'text/event-stream' : 'application/json',
-                },
-                body: result.exchange.rawResponse,
-            };
-        }
-        if (result?.error)
-            return replayError(result.error);
-        return liveIntercepted(dialect, request, rawBody);
-    }
-    /**
-     * A decrypted model call the recording will not serve — past the fork point, or unmatched on a
-     * hybrid / `--loose` run. Counted as live the way `handle()` → `goLive` is, so `fork.done`
-     * `live=N` is the number of exchanges the fork actually owned.
-     */
-    function liveIntercepted(dialect, request, rawBody) {
-        if (options.forkModel === undefined) {
-            stats.liveCalls += 1;
-            return undefined;
-        }
-        const target = dialect.ownsModel(options.forkModel)
-            ? dialect
-            : (dialects.find((d) => d.ownsModel(options.forkModel)) ?? dialect);
-        const crossProvider = target.id !== dialect.id;
-        if (crossProvider) {
-            return replayError(`--model ${options.forkModel} is served by ${target.id}, not the intercepted ` +
-                `${dialect.id} origin ${request.host}:${request.port}. A TLS-intercepted fork cannot ` +
-                `leave the host the recording talked to. Pick a model that origin serves`);
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(rawBody);
-        }
-        catch (err) {
-            return replayError(`unparseable request body: ${String(err)}`);
-        }
-        const outboundBody = Buffer.from(JSON.stringify(dialect.withModel(parsed, options.forkModel)), 'utf8');
-        stats.liveCalls += 1;
-        const origin = `https://${request.host}${request.port === 443 ? '' : `:${request.port}`}`;
-        const recordable = recordableOrigin(origin);
-        options.onRoute?.({
-            model: options.forkModel,
-            target: target.id,
-            recorded: dialect.id,
-            ...(recordable === undefined ? {} : { origin: recordable }),
-            crossProvider: false,
-            reason: `served by the recorded dialect ${dialect.id}`,
-        });
-        return { outboundBody };
-    }
-    function tryReplay(dialect, rawBody) {
-        let canonical;
-        try {
-            canonical = dialect.toCanonicalRequest(JSON.parse(rawBody));
-        }
-        catch (err) {
-            return { error: `unparseable request body: ${String(err)}` };
-        }
-        const beyondFork = options.mode === 'hybrid' && matcher.cursor >= (options.forkAt ?? replayable.length);
-        if (beyondFork)
-            return undefined;
-        const result = matcher.match(canonical);
-        if (result.matched) {
-            const exchange = replayable[result.index];
-            if (result.reordered)
-                stats.reordered += 1;
-            if (result.divergence) {
-                stats.matchedInexact += 1;
-                stats.divergences += 1;
-                options.onDivergence?.({ ...result.divergence, seq: exchange.seq });
-            }
-            else {
-                stats.matchedExact += 1;
-            }
-            return { exchange };
-        }
-        stats.unmatched += 1;
-        if (options.mode === 'hybrid' || options.loose) {
-            stats.divergences += 1;
-            options.onDivergence?.({
-                level: 'major',
-                rung: 4,
-                distance: -1,
-                detail: result.reason ?? 'request does not match the recording; served live instead',
-                seq: replayable[result.index]?.seq ?? -1,
-            });
-            return undefined;
-        }
-        const reason = result.reason ?? 'request does not match the recording';
-        options.onUnmatched?.({
-            seq: replayable[result.index]?.seq ?? -1,
-            index: result.index,
-            reason,
-        });
-        return { error: `agenticreplay: replay halted — ${reason}` };
-    }
-    function replayError(message) {
-        return {
-            status: 400,
-            headers: { 'content-type': 'application/json' },
-            body: JSON.stringify({
-                type: 'error',
-                error: {
-                    type: 'invalid_request_error',
-                    message: `${message}. Re-run with \`agenticreplay replay <run> --loose\` to continue live from this point, ` +
-                        'or `agenticreplay show <run>` to see what was recorded.',
-                },
-            }),
-        };
-    }
     const interception = options.tls
         ? attachTlsIntercept(server, {
             ...options.tls,
@@ -749,7 +477,6 @@ export async function createProxy(options) {
                 ? {}
                 : { maxBufferedBytes: options.maxBufferedBytes }),
             onRequestStart: options.onRequestStart,
-            ...(options.mode === 'record' ? {} : { onRequest: onInterceptedRequest }),
             onNetExchange: onDecrypted,
         }, stats)
         : undefined;
@@ -784,115 +511,23 @@ export async function createProxy(options) {
      */
     forwardBase) {
         stats.liveCalls += 1;
-        // Which dialect actually serves the model we are about to ask for. Without this the origin
-        // came from the *recorded* request, so forking an Anthropic run onto gpt-5.2 posted an
-        // Anthropic body to api.anthropic.com naming a model that does not exist there — the
-        // cross-provider comparison the tool is pitched on could not have worked.
-        // The recorded dialect wins whenever it can serve the model, and only then do we go looking.
-        // Two dialects now share a provider — chat completions and Responses both answer for anything
-        // that is not Claude — so a bare `find` would route every Responses fork to chat completions
-        // and translate a turn that never needed translating.
-        const target = options.forkModel === undefined || dialect.ownsModel(options.forkModel)
-            ? dialect
-            : (dialects.find((d) => d.ownsModel(options.forkModel)) ?? dialect);
-        const crossProvider = target.id !== dialect.id;
-        let parsed = JSON.parse(rawBody);
-        if (crossProvider) {
-            // Through canonical, which is the only representation both dialects agree on.
-            const canonical = dialect.toCanonicalRequest(parsed);
-            parsed = target.fromCanonicalRequest({ ...canonical, model: options.forkModel });
-        }
-        else if (options.forkModel) {
-            parsed = dialect.withModel(parsed, options.forkModel);
-        }
-        // A recording must retain the provider's serialized bytes. Re-serializing an unchanged
-        // request silently loses whitespace, field ordering, and unknown textual fields before the
-        // endpoint oracle can compare it. Only a model/provider fork is allowed to construct a new
-        // request body.
-        const outboundBody = options.forkModel === undefined ? rawBody : JSON.stringify(parsed);
-        const requestTranslation = options.forkModel === undefined
-            ? []
-            : [
-                crossProvider
-                    ? protocolTranslationTransformation(dialect.id, target.id, 'request.body')
-                    : modelOverrideTransformation(dialect.id, options.forkModel),
-            ];
-        // Prefer an override for the provider we are actually calling; fall back to the override for
-        // the recorded provider before the vendor default. That fallback is the gateway case, and it
-        // is the common one: someone who passed --upstream-anthropic pointed *this run* at a specific
-        // origin, and a gateway serves both dialects from it. Going to api.openai.com instead because
-        // the fork changed model would ignore an instruction the user gave explicitly.
-        // Where this call goes, in strict order of who decided it. A `/forward/` path names its own
-        // destination — that is the whole point of the encoding — so on a live call that agenticreplay is
-        // merely relaying (record, or a loose replay continuing past its recording) the request's own
-        // base outranks every configured origin: a gateway picked up from `agenticreplay setup` is a default
-        // for calls agenticreplay would otherwise have to guess at, not a licence to readdress one that
-        // announces where it was headed. A fork is different: substituting the model is the operator
-        // choosing where answers come from, so the fork target's explicit upstream — or the gateway —
-        // decides, and the forwarded base is dropped as incoherent for the substitution.
-        const relaying = options.forkModel === undefined && !crossProvider;
-        const origin = relaying && forwardBase !== undefined
-            ? forwardBase
-            : (options.upstream?.[target.id] ??
-                options.upstream?.[dialect.id] ??
-                (target.id === 'openai-responses' || target.id === 'codex'
-                    ? options.upstream?.openai
-                    : undefined) ??
-                target.defaultUpstream);
-        // A relayed call keeps the path the client appended, because the base it names expects
-        // exactly that. Everything else is answered by an origin agenticreplay chose, which expects the
-        // dialect's own path — and the incoming path cannot be trusted to be it: a bare base url
-        // (no `/v1`) reaches this proxy as `/chat/completions`, and a gateway handed that without the
-        // version segment answers 404.
-        //
-        // The query survives the substitution either way, because it is not part of the endpoint's
-        // shape. A path says which endpoint; a query says how to call it, and the client set it —
-        // `?api-version=` is required on every Azure OpenAI call, and dropping it turns a working
-        // configuration into `404 Resource not found` with nothing in the run explaining why.
-        // Replacing a path is agenticreplay normalising an address it chose; replacing the parameters would
-        // be agenticreplay editing the request.
+        const outboundBody = rawBody;
+        const origin = forwardBase ??
+            options.upstream?.[dialect.id] ??
+            (dialect.id === 'openai-responses' || dialect.id === 'codex'
+                ? options.upstream?.openai
+                : undefined) ??
+            dialect.defaultUpstream;
         const queryAt = path.indexOf('?');
         const query = queryAt === -1 ? '' : path.slice(queryAt);
-        const upstreamPath = relaying && forwardBase !== undefined ? path : `${target.requestPath}${query}`;
-        // Spec §2: "a gateway chose a model". AgenticReplay *is* the gateway on this path — it substitutes the
-        // model, picks the wire format that serves it, and picks the origin — and it was making all
-        // three of those choices silently. Which is the one thing a comparison must not do: reading
-        // `claude-opus-5 vs gpt-5.2` in a verdict table tells you nothing about where either went, and
-        // a fork that quietly fell back to the recorded provider's origin looked identical to one that
-        // did not. Emitted only when a decision was actually taken, so an ordinary recording — where
-        // agenticreplay forwards what it was given — stays free of an event saying "nothing was chosen".
-        if (options.forkModel !== undefined) {
-            // Sanitised here for the reason {@link buildExchange} sanitises the exchange's `upstream`,
-            // and it is the same value: an origin that came from configuration rather than off the wire,
-            // so a gateway that authenticates by URL carries its key in it. This payload is not just
-            // reported — `agenticreplay replay --model` and `agenticreplay compare --models` write it into the fork's
-            // trace as `route.decision.attrs` unchanged, and the trace redactor cannot help, because it
-            // matches key shapes and field names and this is a password inside a URL under `origin`.
-            // Omitted rather than replaced when it will not parse: no consumer reads it — the viewer
-            // renders model, target and reason — and a placeholder in a field others may parse as a URL
-            // is worse than the field being absent.
-            const recordable = recordableOrigin(origin);
-            options.onRoute?.({
-                model: options.forkModel,
-                target: target.id,
-                recorded: dialect.id,
-                ...(recordable === undefined ? {} : { origin: recordable }),
-                crossProvider,
-                // Deliberately does not open with the model name: the viewer already renders that as the
-                // row's label, so a reason that repeats it produces `gpt-5.2  gpt-5.2 is served by…` and
-                // spends the row's width saying the same thing twice.
-                reason: crossProvider
-                    ? `served by ${target.id}, not the recorded ${dialect.id}`
-                    : `served by the recorded dialect ${dialect.id}`,
-            });
-        }
+        const upstreamPath = forwardBase !== undefined ? path : `${dialect.requestPath}${query}`;
         let upstreamRes;
         try {
             upstreamRes = await doFetch(`${origin}${upstreamPath}`, {
                 method: 'POST',
                 headers: {
                     'content-type': 'application/json',
-                    ...headersForModel(headers, options.forkModel),
+                    ...headers,
                     ...headersForOrigin(origin),
                 },
                 body: outboundBody,
@@ -961,104 +596,6 @@ export async function createProxy(options) {
         const upstreamStreamed = upstreamType.includes('event-stream');
         const responseEncoding = upstreamRes.headers.get('content-encoding') ?? undefined;
         const responseDecoded = responseEncoding !== undefined && responseEncoding.trim() !== '';
-        // The agent asked one provider and must be answered in that provider's shape, whatever served
-        // the request. Handing an agent a `chat.completion` body it cannot parse is indistinguishable
-        // from the model having failed.
-        //
-        // A cross-provider reply cannot be teed: translating it means having all of it, so this path
-        // buffers where the same-provider path streams. That is a real cost and it only applies to a
-        // fork that deliberately changed provider — the recording path, which is what an interactive
-        // session runs through, still streams.
-        if (crossProvider) {
-            const received = await readBoundedResponse(upstreamRes, options.maxCapturedBytes ?? DEFAULT_MAX_CAPTURED_BYTES, plainBufferLimit);
-            if (received.truncated) {
-                emitNetExchange({
-                    path: upstreamPath,
-                    responseHeaders: captureResponseHeaders(upstreamRes.headers, responseDecoded),
-                    responseBody: received.text,
-                    responseBytes: received.bytes,
-                    responseTruncated: true,
-                    status: upstreamRes.status,
-                    responseComplete: false,
-                    responseError: 'cross-provider response exceeded capture limit',
-                    streamed: upstreamStreamed,
-                    modelDialect: target.id,
-                    extraTransformations: [protocolTranslationTransformation(target.id, dialect.id)],
-                });
-                res.writeHead(502, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ error: { message: 'cross-provider response exceeded capture limit' } }));
-                return;
-            }
-            const raw = received.text;
-            // Keep the origin bytes even when protocol translation fails. The client receives an error,
-            // but the recorder must still prove that the origin answered and preserve the response that
-            // caused the translation failure.
-            let body;
-            const wantsStream = requestedStream(rawBody);
-            try {
-                const canonical = upstreamStreamed
-                    ? target.parseStream(raw)
-                    : target.toCanonicalResponse(JSON.parse(raw));
-                // Match the shape the agent asked for, not the shape the other provider happened to send.
-                body = dialect.fromCanonicalResponse(canonical, wantsStream);
-            }
-            catch (err) {
-                emitNetExchange({
-                    path: upstreamPath,
-                    responseHeaders: captureResponseHeaders(upstreamRes.headers, responseDecoded),
-                    responseBody: raw,
-                    responseBytes: received.bytes,
-                    responseTruncated: false,
-                    status: upstreamRes.status,
-                    responseComplete: received.encodingError === undefined,
-                    responseError: received.encodingError ?? `cross-provider response translation failed: ${String(err)}`,
-                    streamed: upstreamStreamed,
-                    modelDialect: target.id,
-                    extraTransformations: [protocolTranslationTransformation(target.id, dialect.id)],
-                });
-                res.writeHead(502, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({ error: { message: 'cross-provider response translation failed' } }));
-                return;
-            }
-            if (Buffer.byteLength(body) > (options.maxCapturedBytes ?? DEFAULT_MAX_CAPTURED_BYTES)) {
-                emitNetExchange({
-                    path: upstreamPath,
-                    responseHeaders: captureResponseHeaders(upstreamRes.headers, responseDecoded),
-                    responseBody: raw,
-                    responseBytes: received.bytes,
-                    responseTruncated: false,
-                    status: upstreamRes.status,
-                    responseComplete: false,
-                    responseError: 'cross-provider translated response exceeded capture limit',
-                    streamed: wantsStream,
-                    modelDialect: target.id,
-                    extraTransformations: [protocolTranslationTransformation(target.id, dialect.id)],
-                });
-                res.writeHead(502, { 'content-type': 'application/json' });
-                res.end(JSON.stringify({
-                    error: { message: 'cross-provider translated response exceeded capture limit' },
-                }));
-                return;
-            }
-            res.writeHead(upstreamRes.status, {
-                'content-type': wantsStream ? 'text/event-stream' : 'application/json',
-            });
-            res.end(body);
-            emitNetExchange({
-                path: upstreamPath,
-                responseHeaders: captureResponseHeaders(upstreamRes.headers, responseDecoded),
-                responseBody: raw,
-                responseBytes: received.bytes,
-                status: upstreamRes.status,
-                responseComplete: received.encodingError === undefined,
-                ...(received.encodingError === undefined ? {} : { responseError: received.encodingError }),
-                streamed: wantsStream,
-                modelDialect: target.id,
-                extraTransformations: [protocolTranslationTransformation(target.id, dialect.id)],
-            });
-            recordExchange(body, upstreamRes.status, wantsStream);
-            return;
-        }
         const contentType = upstreamType;
         const streamed = upstreamStreamed;
         res.writeHead(upstreamRes.status, { 'content-type': contentType });
@@ -1126,7 +663,6 @@ export async function createProxy(options) {
                 modelDialect: input.modelDialect ?? dialect.id,
                 transformations: [
                     ...captureHeaderTransformations(headers, recordableHeaders),
-                    ...requestTranslation,
                     ...captureEncodingTransformation('request.body', requestEncoding),
                     ...captureResponseHeaderTransformations(upstreamRes.headers),
                     ...captureEncodingTransformation('response.body', responseEncoding),
@@ -1177,7 +713,7 @@ export async function createProxy(options) {
      * a base URL; the client's own headers say which provider that was, and its own credential is
      * already on the request addressed to them.
      */
-    function passthroughOrigin(headers, forwardBase, opts = {}) {
+    function passthroughOrigin(headers, forwardBase) {
         if (options.passthroughUpstream !== undefined)
             return options.passthroughUpstream;
         // A relayed request's own destination, before anything configured: on a live call with no
@@ -1191,7 +727,7 @@ export async function createProxy(options) {
         // of one is how a fork's live embedding call left for the chat origin carrying the embedding
         // provider's own key: a 401 at best, and at worst an OpenAI-compatible gateway that answers
         // `/v1/embeddings` from a different model, putting foreign vectors in the fork's index.
-        if (forwardBase !== undefined && (opts.verbatim === true || options.forkModel === undefined)) {
+        if (forwardBase !== undefined) {
             return forwardBase;
         }
         const configured = [...new Set(Object.values(options.upstream ?? {}))];
@@ -1215,335 +751,35 @@ export async function createProxy(options) {
         return anthropic ? 'https://api.anthropic.com' : 'https://api.openai.com';
     }
     /**
-     * Serve a retrieval call: from the recording where there is one, live where there is not.
+     * An origin string as a host and a port, for the two places that record one.
      *
-     * The lookup is by the request itself rather than by a cursor. Two reasons, and both matter.
-     * The answer is a function of the request, so position carries no information — the same text
-     * embedded on turn 3 and on turn 40 has the same vector. And an index build issues these
-     * hundreds at a time from a worker pool, so there is no order for a cursor to follow.
+     * An origin that does not parse is still worth recording under the string we were given.
+     */
+    /**
+     * Why the call did not go out, with the origin in it made safe first.
      *
-     * A recorded call is consumed once, earliest first, so a run that asked the same thing twice
-     * gets both of its answers back and `retrieval=N/N` means every recorded call was reused —
-     * rather than one of them being served twice while another was never asked for.
+     * The message names the request, so it carries the origin — and undici quotes it verbatim:
+     * `Failed to parse URL from gw?key=SECRET123/v1/...`. Running only the prose rules over that
+     * leaves the key in, for the same shapes `scrubOrigin` exists to handle, so the known origin is
+     * replaced by its scrubbed form before the prose pass ever looks at the sentence.
      */
-    async function serveRetrieval(rule, path, rawBody, headers, recordableHeaders, res, startedAt, requestId, forwardBase) {
-        let key;
-        let parsed;
-        try {
-            parsed = JSON.parse(rawBody);
-            key = rule.key(parsed);
-        }
-        catch (err) {
-            // A body this rule cannot key is a body agenticreplay cannot promise anything about. Passthrough is
-            // the honest fallback: forward it, record the bytes, say it is not replayable.
-            if (options.mode === 'replay') {
-                stats.unmatched += 1;
-                const reason = `${path} could not be keyed for replay: ${String(err)}`;
-                options.onUnmatched?.({ seq: -1, index: -1, reason });
-                json(res, 502, {
-                    error: { message: `agenticreplay replay cannot reproduce ${path}: ${reason}` },
-                });
-                return;
-            }
-            await passThrough(path, rawBody, headers, recordableHeaders, res, startedAt, requestId, forwardBase);
-            return;
-        }
-        // Across the fork cursor deliberately, in every mode that has a recording. A fork asks the
-        // same documents about a different chat model; re-embedding them live would spend money to
-        // recompute a value that cannot have changed, and would make the fork's index differ from the
-        // parent's for no reason anyone asked for. `RetrievalRule.forkable` is `false` for the same
-        // reason, one level up.
-        //
-        // Exact first, then the batch. A pipeline assembles its batch from a worker pool, so the same
-        // set of texts arrives in a different order on every run and an exact key alone found nothing
-        // — measured: two replays of one recording, two different keys, neither recorded. Where the
-        // endpoint's own contract says `data[i]` answers `input[i]`, the recorded answer for each
-        // text can be handed back against that text's new position, which is not an approximation.
-        // See {@link BatchRetrieval}.
-        let match = retrievalIndex.byKey.get(key)?.[0];
-        let rebuilt;
-        if (match === undefined) {
-            const batchKey = rule.batch?.key(parsed);
-            const candidate = batchKey === undefined ? undefined : retrievalIndex.byBatch.get(batchKey)?.[0];
-            if (candidate !== undefined && candidate.rawResponse !== '') {
-                rebuilt = rule.batch?.reorder(safeParse(candidate.rawRequest), candidate.rawResponse, parsed);
-                // An inexact reorder is no match at all. Filling the gaps would put another document's
-                // vector in the index, and nothing downstream could tell.
-                if (rebuilt !== undefined)
-                    match = candidate;
-            }
-            else if (candidate !== undefined) {
-                match = candidate;
-            }
-        }
-        if (match !== undefined) {
-            // Consumed only where it is actually served. A recorded call agenticreplay cannot serve is still the
-            // answer to this request, and dropping it turned a client's retry — langchain retries a 502
-            // — into "no recorded retrieval call matches this request", which is false and sends the
-            // reader looking for a mismatch that is not there.
-            if (rebuilt !== undefined) {
-                consume(retrievalIndex, match);
-                stats.retrievalServed += 1;
-                stats.retrievalReordered += 1;
-                res.writeHead(match.status, { 'content-type': match.contentType });
-                res.end(rebuilt);
-                return;
-            }
-            if (match.rawResponse === '') {
-                // Recorded with `--retrieval-store=digest`: agenticreplay kept proof of the answer, not the answer.
-                const reason = `${path} was recorded with --retrieval-store=digest, so the trace holds a digest of ` +
-                    'the response and not the response. Re-record with the default (full) to replay it';
-                if (options.mode === 'replay' && !options.loose) {
-                    stats.unmatched += 1;
-                    options.onUnmatched?.({ seq: match.seq, index: -1, reason });
-                    json(res, 502, {
-                        error: { message: `agenticreplay replay cannot reproduce ${path}: ${reason}` },
-                    });
-                    return;
-                }
-            }
-            else {
-                consume(retrievalIndex, match);
-                stats.retrievalServed += 1;
-                res.writeHead(match.status, { 'content-type': match.contentType });
-                res.end(match.rawResponse);
-                return;
-            }
-        }
-        if (options.mode === 'replay' && !options.loose) {
-            stats.unmatched += 1;
-            const reason = `no recorded retrieval call matches this request (rule ${rule.id}, key ` +
-                `${key.slice(0, 12)}…). The recording holds ${stats.retrievalTotal} retrieval ` +
-                `call${stats.retrievalTotal === 1 ? '' : 's'}, and this is not one of them`;
-            options.onUnmatched?.({ seq: -1, index: -1, reason });
-            json(res, 502, {
-                error: { message: `agenticreplay replay cannot reproduce ${path}: ${reason}` },
-            });
-            return;
-        }
-        // Record, a fork past what it can serve, or a loose replay: make the call and keep the answer.
-        if (options.mode !== 'record')
-            stats.retrievalLive += 1;
-        await forwardRetrieval(rule, key, rule.batch?.key(parsed), path, rawBody, headers, recordableHeaders, res, startedAt, requestId, forwardBase);
-    }
-    /** A body that has already parsed once. Undefined rather than a throw where it has not. */
-    function safeParse(raw) {
-        try {
-            return JSON.parse(raw);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /** Make a retrieval call for real, and file it as a replayable `net.*` pair. */
-    async function forwardRetrieval(rule, key, batchKey, path, rawBody, headers, recordableHeaders, res, startedAt, requestId, forwardBase) {
-        stats.passedThrough += 1;
-        // On a recording, the count of retrieval calls *captured*. It is the same field replay uses
-        // for "how many the recording holds", which is the same quantity one command later — and it
-        // is what lets `capture.empty` tell an index build, whose every call is a retrieval call and
-        // every one of them replayable, apart from a run that captured nothing at all.
-        if (options.mode === 'record')
-            stats.retrievalTotal += 1;
-        // Verbatim: everything below forwards this request unchanged, so where it says it was going
-        // stands, fork or no fork. See `passthroughOrigin`.
-        const origin = passthroughOrigin(headers, forwardBase, { verbatim: true });
-        let upstreamRes;
-        try {
-            upstreamRes = await doFetch(`${origin}${path}`, {
-                method: 'POST',
-                headers: { 'content-type': 'application/json', ...headers, ...headersForOrigin(origin) },
-                body: rawBody,
-            });
-        }
-        catch (err) {
-            // The third of the three forwarding paths, and it had the same hole. An index build issues
-            // these hundreds at a time; a gateway that stops answering half way through used to leave
-            // a trace that simply had fewer retrieval calls in it than the run made, with nothing
-            // saying which ones or why.
-            //
-            // `status: 0` and the `net.*` shape, matching `passThrough`: no response header was ever
-            // seen, and a retrieval call is already recorded as network traffic rather than as a
-            // replayable model exchange.
-            options.onNetExchange?.({
-                requestId,
-                requestStartedAt: startedAt,
-                ...originParts(origin),
-                method: 'POST',
-                path,
-                intercepted: false,
-                rule: rule.id,
-                replayKey: key,
-                ...(batchKey === undefined ? {} : { batchKey }),
-                requestHeaders: recordableHeaders,
-                requestBody: rawBody,
-                requestBytes: Buffer.byteLength(rawBody),
-                requestTruncated: false,
-                status: 0,
-                responseHeaders: {},
-                responseBody: `agenticreplay did not forward this call: ${reasonFor(err, origin)}`,
-                responseTruncated: false,
-                responseComplete: false,
-                responseError: reasonFor(err, origin),
-                responseBytes: 0,
-                durationMs: Date.now() - startedAt,
-            });
-            throw err;
-        }
-        const responseEncoding = upstreamRes.headers.get('content-encoding') ?? undefined;
-        const responseHeaders = captureResponseHeaders(upstreamRes.headers, responseEncoding !== undefined && responseEncoding.trim() !== '');
-        res.writeHead(upstreamRes.status, {
-            'content-type': responseHeaders['content-type'] ?? 'application/json',
-        });
-        let piped;
-        try {
-            piped = await pipeThrough(upstreamRes, res, options.maxCapturedBytes ?? DEFAULT_MAX_CAPTURED_BYTES, plainBufferLimit);
-        }
-        catch (err) {
-            const partial = err instanceof ResponsePipeAbortedError
-                ? err.partial
-                : err.partial;
-            options.onNetExchange?.({
-                requestId,
-                requestStartedAt: startedAt,
-                ...originParts(origin),
-                method: 'POST',
-                path,
-                intercepted: false,
-                rule: rule.id,
-                replayKey: key,
-                ...(batchKey === undefined ? {} : { batchKey }),
-                requestHeaders: recordableHeaders,
-                requestBody: rawBody,
-                requestBytes: Buffer.byteLength(rawBody),
-                requestTruncated: false,
-                status: upstreamRes.status,
-                responseHeaders,
-                responseBody: partial?.text ?? '',
-                responseTruncated: partial?.truncated ?? false,
-                responseComplete: false,
-                responseError: String(err),
-                responseBytes: partial?.bytes ?? 0,
-                ...(err instanceof ResponsePipeAbortedError ? { abandoned: true } : {}),
-                durationMs: Date.now() - startedAt,
-            });
-            if (err instanceof ResponsePipeAbortedError)
-                return;
-            throw err;
-        }
-        const body = piped.text;
-        const digest = createHash('sha256').update(body).digest('hex');
-        const keepBody = (options.retrievalStore ?? 'full') === 'full';
-        const { host, port } = originParts(origin);
-        options.onNetExchange?.({
-            requestId,
-            requestStartedAt: startedAt,
-            host,
-            port,
-            method: 'POST',
-            path,
-            intercepted: false,
-            rule: rule.id,
-            replayKey: key,
-            // Only where the rule offers one. Its absence in a trace means exactly what it says: this
-            // call can be found again by its own body and by nothing else.
-            ...(batchKey === undefined ? {} : { batchKey }),
-            requestHeaders: recordableHeaders,
-            requestBody: rawBody,
-            requestBytes: Buffer.byteLength(rawBody),
-            requestTruncated: false,
-            status: upstreamRes.status,
-            responseHeaders,
-            // Dropped rather than trimmed under `digest`: half a vector is not a smaller answer, it is
-            // a wrong one, and the digest already says whether a later run agreed.
-            responseBody: keepBody ? body : '',
-            responseDigest: digest,
-            responseTruncated: piped.truncated,
-            responseComplete: !piped.truncated && piped.encodingError === undefined,
-            ...(piped.truncated
-                ? { responseError: 'response exceeded capture limit' }
-                : piped.encodingError === undefined
-                    ? {}
-                    : { responseError: piped.encodingError }),
-            responseBytes: piped.bytes,
-            durationMs: Date.now() - startedAt,
-            transformations: [
-                ...captureHeaderTransformations(headers, recordableHeaders),
-                ...captureResponseHeaderTransformations(upstreamRes.headers),
-                ...captureEncodingTransformation('response.body', responseEncoding),
-                ...captureUrlTransformations(origin),
-                ...binaryBodyTransformation('request.body', rawBody),
-                ...binaryBodyTransformation('response.body', body),
-            ],
-        });
-    }
-    /** Split a configured origin into the host and port an exchange records. */
     function originParts(origin) {
         try {
             const url = new URL(origin);
             return {
                 host: url.hostname,
-                port: url.port !== '' ? Number(url.port) : url.protocol === 'http:' ? 80 : 443,
+                port: url.port ? Number(url.port) : url.protocol === 'http:' ? 80 : 443,
             };
         }
         catch {
-            // An origin that does not parse is still worth recording under the string we were given —
-            // less anything secret in it. `host` goes into the trace verbatim (`persistNetExchange`
-            // writes it as a `net.request` attr), and §7 says a credential never gets written down.
-            // The trace's own redactor does not cover this: `hunter2` and `key=SECRET123` are under
-            // the 20-character entropy floor and match no shape rule.
-            //
-            // Dead above, live below. A caller that already has a response held a URL undici parsed,
-            // so the fallback cannot run on the success path; `passThrough`'s failure path is the one
-            // place it does, because an origin `new URL` rejects is exactly what made `doFetch` throw.
-            //
-            // `redactString` after the cut, not instead of it: its shape rules and 20-character
-            // entropy floor catch neither `hunter2` nor `key=SECRET123`, so it is a backstop for a
-            // real key that happens to be in there, not the thing doing the work.
             return { host: redactor.redactString(scrubOrigin(origin)).value, port: 443 };
         }
     }
-    /**
-     * Forward a POST no dialect claims, and record that it happened.
-     *
-     * It is recorded as `NetExchange` rather than `RecordedExchange` on purpose: agenticreplay holds the bytes
-     * but not the meaning, so it cannot match this request on replay or rewrite its model on a fork.
-     * Filing it with the model exchanges would inflate `reused=n/m` with turns replay will never
-     * serve, and an operator would be reading a fidelity number that is not one.
-     */
-    /**
-     * An origin string as a host and a port, for the two places that record one.
-     *
-     * An origin that does not parse is still worth recording under the string we were given.
-     */
-    /**
-     * Why the call did not go out, with the origin in it made safe first.
-     *
-     * The message names the request, so it carries the origin — and undici quotes it verbatim:
-     * `Failed to parse URL from gw?key=SECRET123/v1/...`. Running only the prose rules over that
-     * leaves the key in, for the same shapes `scrubOrigin` exists to handle, so the known origin is
-     * replaced by its scrubbed form before the prose pass ever looks at the sentence.
-     */
     function reasonFor(err, origin) {
         const scrubbed = String(err).split(origin).join(scrubOrigin(origin));
         return redactor.redactString(withoutCredentials(scrubbed)).value;
     }
     async function passThrough(path, rawBody, headers, recordableHeaders, res, startedAt, requestId, forwardBase, requestEncoding) {
-        // `hybrid` is a fork, and a fork runs a live agent — so it forwards, exactly as `record` does.
-        // Refusing here killed the fork on the first call agenticreplay could not read, which is the failure
-        // passthrough exists to prevent, reintroduced one mode over.
-        if (options.mode === 'replay') {
-            // Strict replay has the network blocked and no recording to serve from — agenticreplay never
-            // understood this call well enough to match it. Say so: a bare 502 mid-replay reads as agenticreplay
-            // being broken, when the honest fact is narrower and more useful than that.
-            stats.unmatched += 1;
-            const reason = `${path} was captured as opaque network traffic, not as a model exchange, so it ` +
-                'cannot be replayed. Recorded with --tls-intercept, or on a path no dialect claims.';
-            options.onUnmatched?.({ seq: -1, index: -1, reason });
-            json(res, 502, {
-                error: { message: `agenticreplay replay cannot reproduce ${path}: ${reason}` },
-            });
-            return;
-        }
         stats.passedThrough += 1;
         const origin = passthroughOrigin(headers, forwardBase);
         let upstreamRes;
@@ -2142,14 +1378,6 @@ export async function createProxy(options) {
                 recordableHeaders['content-length'] = length;
             }
             if (!dialect) {
-                // Before passthrough, and only where no dialect claims the path: a dialect is the richer
-                // reading of a call — replayable, forkable, counted in `exact` — and a rule that outranked
-                // one would turn a chat completion into opaque bytes keyed by their own body.
-                const rule = selectRetrievalRule(retrievalRules, dialectPath, forwardHost(forward));
-                if (rule && isReadable(rawBody)) {
-                    await serveRetrieval(rule, requestedPath, rawBody, headers, recordableHeaders, res, startedAt, requestId, forward?.base);
-                    return;
-                }
                 await passThrough(requestedPath, rawBody, headers, recordableHeaders, res, startedAt, requestId, forward?.base, inboundRequestEncoding);
                 return;
             }
@@ -2188,83 +1416,6 @@ export async function createProxy(options) {
                 json(res, 400, errorBody);
                 return;
             }
-            if (options.mode === 'record') {
-                await goLive(dialect, requestedPath, rawBody, headers, recordableHeaders, res, startedAt, requestId, inboundRequestEncoding, forward?.base);
-                return;
-            }
-            // Replay and hybrid: try the recording first.
-            let canonical;
-            try {
-                canonical = dialect.toCanonicalRequest(JSON.parse(rawBody));
-            }
-            catch (err) {
-                json(res, 400, { error: { message: `unparseable request body: ${String(err)}` } });
-                return;
-            }
-            const beyondFork = options.mode === 'hybrid' && matcher.cursor >= (options.forkAt ?? replayable.length);
-            if (!beyondFork) {
-                const result = matcher.match(canonical);
-                if (result.matched) {
-                    const exchange = replayable[result.index];
-                    if (result.reordered)
-                        stats.reordered += 1;
-                    if (result.divergence) {
-                        stats.matchedInexact += 1;
-                        stats.divergences += 1;
-                        options.onDivergence?.({ ...result.divergence, seq: exchange.seq });
-                    }
-                    else {
-                        stats.matchedExact += 1;
-                    }
-                    res.writeHead(exchange.status, {
-                        'content-type': exchange.streamed ? 'text/event-stream' : 'application/json',
-                    });
-                    res.end(exchange.rawResponse);
-                    return;
-                }
-                stats.unmatched += 1;
-                // Hybrid mode is *supposed* to continue live here — that is what forking means — but spec §4
-                // says replay must not silently approximate, and every inexact match is an event in the
-                // trace. Without this a fork could start diverging below its own fork point and every
-                // artifact it produced would look clean. Going live is the right behaviour; being quiet
-                // about it is not.
-                if (options.mode === 'hybrid' || options.loose) {
-                    stats.divergences += 1;
-                    options.onDivergence?.({
-                        level: 'major',
-                        rung: 4,
-                        distance: -1,
-                        detail: result.reason ?? 'request does not match the recording; served live instead',
-                        seq: replayable[result.index]?.seq ?? -1,
-                    });
-                }
-                if (!options.loose && options.mode === 'replay') {
-                    // Halt loudly. Inventing a reply here would make every downstream conclusion worthless.
-                    const reason = result.reason ?? 'request does not match the recording';
-                    options.onUnmatched?.({
-                        seq: replayable[result.index]?.seq ?? -1,
-                        index: result.index,
-                        reason,
-                    });
-                    // 400, emphatically not 409. Every mainstream client retries 408/409/429/5xx by default,
-                    // so a 409 halt is re-sent until the retry budget is gone — the operator gets a stalled
-                    // terminal and no reason, which is strictly worse than a wrong answer because it looks
-                    // like a hang in agenticreplay rather than a mismatch in the recording. 400 is terminal everywhere.
-                    //
-                    // The envelope is the provider's own error shape for the same reason: clients read
-                    // `error.message` and print it, so this sentence is what actually reaches the human.
-                    json(res, 400, {
-                        type: 'error',
-                        error: {
-                            type: 'invalid_request_error',
-                            message: `agenticreplay: replay halted — ${reason}. ` +
-                                'Re-run with `agenticreplay replay <run> --loose` to continue live from this point, ' +
-                                'or `agenticreplay show <run>` to see what was recorded.',
-                        },
-                    });
-                    return;
-                }
-            }
             await goLive(dialect, requestedPath, rawBody, headers, recordableHeaders, res, startedAt, requestId, inboundRequestEncoding, forward?.base);
         }
         finally {