agenticreplay 0.1.0 → 0.1.2

package/node_modules/@agenticreplay/plugin-api/dist/plugins.d.ts

@@ -0,0 +1,258 @@
+import type { CanonicalChunk, CanonicalRequest, ModelInfo, Money, Usage } from './canonical.js';
+/** Everything an adapter needs to know about the run it is preparing. */
+export interface RecordContext {
+    runId: string;
+    cwd: string;
+    /** Base URL of the local recording proxy, e.g. http://127.0.0.1:51733 */
+    proxyUrl: string;
+    /** Directory the run may write scratch config into. */
+    runDir: string;
+    /** Argv the user passed after the agent name. */
+    userArgs: string[];
+    env: Record<string, string | undefined>;
+}
+/** How to launch the instrumented agent. */
+export interface Launch {
+    command: string;
+    args: string[];
+    /** Environment overlay merged onto the parent environment. */
+    env: Record<string, string>;
+    cwd?: string;
+    /** Files the adapter wrote (rewritten MCP configs, shims) for cleanup and provenance. */
+    tempFiles?: string[];
+}
+/** How to launch and instrument one agent harness. */
+export interface Adapter {
+    id: string;
+    /**
+     * Other names this adapter answers to on the command line.
+     *
+     * The id is a stable internal handle written into every manifest; an alias is what a human
+     * types, which is almost always the name of the binary they run. `claude-code` and `claude` are
+     * the canonical example — keeping them separate means the manifest stays unambiguous while
+     * `agenticreplay record claude` does what anyone would expect it to.
+     */
+    aliases?: readonly string[];
+    /** Semver range of harness versions this adapter is tested against. */
+    harnessVersions?: string;
+    /**
+     * How this adapter gets the agent's traffic to agenticreplay.
+     *
+     * `env` — the default, and what every harness-specific adapter does: point a base-URL variable
+     * at the proxy, or install the fetch hook, so the agent connects to a local origin in plaintext.
+     *
+     * `transport` — the adapter redirects nothing and relies on `--tls-intercept`, which is applied
+     * to the launched child by the run rather than by the adapter. Declared rather than inferred,
+     * because "sets no base-URL variable" is otherwise indistinguishable from the broken adapter the
+     * contract's `redirects-model-traffic` check exists to catch. An adapter that says `transport`
+     * is asserting that pointing nowhere is the intent, and takes the check's exemption in exchange.
+     *
+     * `config` — the adapter redirects through a configuration file rather than the environment,
+     * for a harness that keeps its origin in one and reads no variable for it. MiniMax Code is the
+     * first: `MINIMAX_DATA_DIR` moves the whole data directory, and the config agenticreplay writes there
+     * carries the redirect. It takes the same exemption as `transport` and for the same reason —
+     * the redirect is real but is not an environment variable, so a check that only reads the
+     * launch environment is scoring it against a mechanism it does not use. What it redirects is
+     * checked where the file can actually be read: the adapter's own tests.
+     */
+    capture?: 'env' | 'transport' | 'config';
+    detect(cwd: string): Promise<boolean>;
+    prepare(ctx: RecordContext): Promise<Launch>;
+    /**
+     * The harness's own session records, where it keeps any.
+     *
+     * AgenticReplay's capture layers see what a run *did*; only the harness knows what it was *asked*. A run
+     * driven by hand has its prompts nowhere on the wire, so without this a replay launches an agent
+     * with nothing to make it ask anything. Supplying it is what makes an interactive recording
+     * replayable and forkable at all.
+     */
+    session?: SessionSupport;
+    /**
+     * Arguments that load an MCP config from a path, for a harness that takes one.
+     *
+     * The environment variables agenticreplay sets alongside this are read by none of the harnesses it
+     * targets: Claude Code loads MCP servers from `.mcp.json`, from the user config, or from
+     * `--mcp-config`, and ignores `CLAUDE_MCP_CONFIG` entirely — so `agenticreplay record --mcp-config`
+     * instrumented a copy of the file and then launched an agent that never opened it. The capture
+     * reported success and recorded no frames, which is the same silent shape the base-URL variables
+     * had before an adapter passed those on the command line too.
+     */
+    mcpConfigArgs?(path: string): string[] | undefined;
+    /**
+     * Arguments that drive this harness through a recorded prompt with no terminal attached.
+     *
+     * `recorded` is the argv the run was made with, so an adapter can extend it rather than replace
+     * it — the flags that shaped the recording still have to shape the replay.
+     */
+    driveArgs?(prompts: string[], recorded: string[]): string[] | undefined;
+    /**
+     * What this harness leaves on disk that the run cannot be understood or reproduced without.
+     *
+     * Optional, and most harnesses need none of it: a coding agent's output *is* the working tree,
+     * which the ordinary snapshot already captures. A pipeline is the case this exists for — its
+     * whole product is an index or a cache, written to a path its own `.gitignore` excludes,
+     * because nobody wants a hundred megabytes of vectors in their repository.
+     */
+    artifacts?: HarnessArtifacts;
+    /**
+     * Argv for a replay, for a harness that carries no prompt at all.
+     *
+     * {@link driveArgs} answers "what makes the agent ask the recorded question again", and it only
+     * applies to a harness with a transcript agenticreplay can read. A pipeline has neither: its argv *is*
+     * the whole instruction and there is nothing to recover. This hook is reached before the
+     * transcript is consulted, so such an adapter can still adjust what the replay runs — clamping
+     * a concurrency flag, say — instead of having no say at all.
+     *
+     * Return undefined to leave the recorded argv exactly as it was, which is what every adapter
+     * that does not implement this gets.
+     */
+    replayArgs?(recorded: string[]): string[] | undefined;
+}
+/** Paths a harness writes that the ordinary snapshot would miss, and what to do about them. */
+export interface HarnessArtifacts {
+    /**
+     * Paths to snapshot even when the workspace's own `.gitignore` excludes them.
+     *
+     * The snapshot is a `git add` against a shadow index, so it honours the workspace's ignore
+     * rules — correct for a coding agent, where `node_modules/` and `dist/` are noise, and wrong
+     * for a pipeline, where the ignored directory is the entire product. `vector_store/` and
+     * `cache/` are the first two lines of IndexRAG's `.gitignore`, and without them a recording of
+     * an indexing run holds the model calls that built an index and no trace of the index.
+     *
+     * It cannot be used to smuggle a secret into a trace: the sensitive pathspecs are applied to
+     * this add as well, so an adapter declaring `.` still cannot capture `.env`.
+     */
+    capture?: readonly string[];
+    /**
+     * Paths to put back to the state the recording *started* in, before a replay launches.
+     *
+     * A pipeline resumes: it reads its own cache, sees which items are already done, and does the
+     * rest. Replayed on top of the recording's finished cache it does nothing at all — every model
+     * call is skipped, nothing is asked, and the replay reports a run it never reproduced. That is
+     * `reused=0/6 exit=0` over a recording that was perfectly good.
+     *
+     * Not "delete these". AgenticReplay clears them and then restores the recording's initial snapshot over
+     * the top, so they end up holding exactly what they held when recording began — which for a
+     * recording of one mid-pipeline stage is a *populated* cache, and deleting that would take away
+     * the stage's own input. The clearing is what the plain restore cannot do: it writes the files
+     * the tree names and leaves everything else alone, so a cache the recording never had survives
+     * it.
+     *
+     * Whole directories rather than "the invalid parts": IndexRAG's resume skips by `chunk_id`
+     * including entries it recorded as failures, so keeping what looks valid silently promotes the
+     * previous run's failures to completed work. Nothing is lost either way — an exact replay
+     * restores the working tree when it ends, and where it will not (`--in-place`), agenticreplay says so
+     * and leaves these alone.
+     */
+    resetBeforeReplay?: readonly string[];
+    /**
+     * The flag that makes this harness run one request at a time, and the value that does it.
+     *
+     * Declared, never applied on its own: clamping concurrency changes the run being replayed, and
+     * a replay that quietly runs the pipeline differently from the recording is not a replay. It is
+     * what `agenticreplay replay --serialize` reaches for when the operator asks for determinism explicitly.
+     */
+    concurrencyFlag?: {
+        flag: string;
+        serialValue: string;
+    };
+}
+/**
+ * A non-model HTTP call whose answer is a pure function of its request.
+ *
+ * The proxy's own comment on passthrough says agenticreplay "holds the bytes but not the meaning, so it
+ * cannot match this request on replay" — and for an embedding that is the one thing it does not
+ * need. `embed(model, input)` is deterministic in a way a chat completion is not: the same text
+ * to the same model is the same vector, every time, from any provider. So this class of call is
+ * *replayable* without any translator, matched on the request itself rather than on a ladder.
+ *
+ * It is deliberately not forkable, and `forkable` is `false` rather than absent so that saying so
+ * is part of the type. Substituting the embedding model would change the vector space the index
+ * was built in — every stored vector would have to be recomputed, and the comparison a fork
+ * exists to make ("same run, different model") would be against a different index. That is a
+ * rebuild, not a fork. Changing the *chat* model over a fixed index is the useful question, and
+ * it is exactly what keeping retrieval on the recording makes possible.
+ */
+export interface RetrievalRule {
+    /** Stable id, written into the trace so a reader can tell which rule claimed a call. */
+    id: string;
+    /**
+     * Whether this rule claims the endpoint. The path is the one the client actually appended, so
+     * a base URL rewritten through `/forward/` presents as `/embeddings` rather than
+     * `/v1/embeddings` — match on the suffix, not on a version segment that lives in the base.
+     */
+    matches(path: string, host?: string): boolean;
+    /**
+     * The value a replay looks this call up by. Defaults to a digest of the whole request body with
+     * its keys sorted, which is the strictest honest answer: anything a caller varies is part of
+     * what it asked for until a rule says otherwise.
+     */
+    key(raw: unknown): string;
+    /** One line for the timeline — "12 texts, text-embedding-3-small". Optional. */
+    describe?(raw: unknown): string;
+    /**
+     * How to match a batch whose items arrived in a different order, where the endpoint's own
+     * contract makes that safe.
+     *
+     * A retrieval call is usually a *batch* — one request carrying many texts — and the order of
+     * that batch is routinely accidental. IndexRAG assembles it from a thread pool that appends
+     * results as they complete; LlamaIndex, GraphRAG and LightRAG all have the same shape. So two
+     * runs of the same pipeline over the same documents send the same set of texts in a different
+     * sequence, and a key over the request body says they asked different questions. Measured: two
+     * replays of one recording produced two different keys, and neither matched what was recorded.
+     *
+     * This is safe here and would not be for a model call, because the API says so: OpenAI's
+     * embeddings response carries `data[i].index` and defines `data[i]` as the embedding of
+     * `input[i]`. An embedding does not depend on what sat next to it in the batch. So the recorded
+     * answer for each text can be found and handed back against that text's new position — which is
+     * not an approximation, it is the same answer to the same question.
+     *
+     * Optional, and absent by default on any endpoint whose contract does not guarantee that.
+     */
+    batch?: BatchRetrieval;
+    /** Always false. See the note above: changing an embedding model is a rebuild, not a fork. */
+    readonly forkable: false;
+}
+/** Matching a retrieval batch whose order differs, for an endpoint where order carries nothing. */
+export interface BatchRetrieval {
+    /**
+     * A key over the request with its batch reduced to a multiset, or undefined when this request
+     * is not a batch this rule can reorder — a single input, or a shape it does not recognise.
+     */
+    key(raw: unknown): string | undefined;
+    /**
+     * The recorded response rebuilt so that item *i* answers the live request's item *i*, or
+     * undefined when it cannot be done exactly. Undefined halts the replay, which is the right
+     * answer: a partial reorder would hand some documents another document's vector.
+     */
+    reorder(recordedRequest: unknown, recordedResponse: string, liveRequest: unknown): string | undefined;
+}
+/** How to find, read and resume a harness's own session transcripts. */
+export interface SessionSupport {
+    /** Directory the harness writes session transcripts into, or undefined if it keeps none. */
+    dir(cwd: string, env: Record<string, string | undefined>): string | undefined;
+    /** Pull the session id and the user's turns out of one transcript. */
+    parse(bytes: Uint8Array): {
+        id?: string;
+        prompts: string[];
+    };
+    /** Arguments that resume that session, for a fork continuing where the run stopped. */
+    resumeArgs(id: string): string[];
+}
+/** How to reach a model when the replay cursor goes live. */
+export interface Provider {
+    id: string;
+    models(): Promise<ModelInfo[]>;
+    invoke(req: CanonicalRequest, signal?: AbortSignal): AsyncIterable<CanonicalChunk>;
+    price(usage: Usage, model: string): Money | null;
+}
+export interface ProviderFactory {
+    id: string;
+    create(options: ProviderOptions): Provider;
+}
+export interface ProviderOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    headers?: Record<string, string>;
+}
+//# sourceMappingURL=plugins.d.ts.map

package/node_modules/@agenticreplay/plugin-api/dist/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEhG,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,MAAM,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CACzC;AAED,4CAA4C;AAC5C,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,8DAA8D;IAC9D,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,sDAAsD;AACtD,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,uEAAuE;IACvE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,EAAE,KAAK,GAAG,WAAW,GAAG,QAAQ,CAAC;IACzC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,OAAO,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB;;;;;;;;;OASG;IACH,aAAa,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;IACnD;;;;;OAKG;IACH,SAAS,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;IACxE;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC;CACvD;AAED,+FAA+F;AAC/F,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACzD;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,aAAa;IAC5B,wFAAwF;IACxF,EAAE,EAAE,MAAM,CAAC;IACX;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9C;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1B,gFAAgF;IAChF,QAAQ,CAAC,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAAC;IAChC;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,8FAA8F;IAC9F,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;CAC1B;AAED,mGAAmG;AACnG,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IACtC;;;;OAIG;IACH,OAAO,CACL,eAAe,EAAE,OAAO,EACxB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,OAAO,GACnB,MAAM,GAAG,SAAS,CAAC;CACvB;AAED,wEAAwE;AACxE,MAAM,WAAW,cAAc;IAC7B,4FAA4F;IAC5F,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAAC;IAC9E,sEAAsE;IACtE,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC7D,uFAAuF;IACvF,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAClC;AAED,6DAA6D;AAC7D,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAC/B,MAAM,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,cAAc,CAAC,CAAC;IACnF,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC;CAClD;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAAC;CAC5C;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC"}

package/node_modules/@agenticreplay/plugin-api/dist/plugins.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugins.js.map

package/node_modules/@agenticreplay/plugin-api/dist/plugins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.js","sourceRoot":"","sources":["../src/plugins.ts"],"names":[],"mappings":""}

package/node_modules/@agenticreplay/plugin-api/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@agenticreplay/plugin-api",
+  "version": "0.1.2",
+  "type": "module",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/askdkc/AgenticReplay.git",
+    "directory": "packages/plugin-api"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  }
+}

package/node_modules/@agenticreplay/providers/dist/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @agenticreplay/providers — all of AgenticReplay's wire-format knowledge in one place.
+ *
+ * Two layers, deliberately separable:
+ *
+ *   translate/  pure functions between provider wire bodies and the canonical IR. The recording
+ *               proxy uses these on intercepted bytes; nothing here touches the network.
+ *   pricing     what a recorded exchange cost, or null when the model is unknown.
+ *
+ * Two rules hold everywhere: translation never throws on an unfamiliar body, and anything the
+ * canonical IR cannot hold is parked under a namespaced `metadata` key so the round trip back to
+ * the wire is lossless. Raw bytes stay the source of truth for exact replay regardless.
+ *
+ * This package used to carry a third layer — live `Provider` clients for Anthropic and anything
+ * OpenAI-shaped, plus a registry to resolve one by id — and nothing ever called it. Roughly 400
+ * lines of production code and 570 of tests, kept because the docstring claimed the live path went
+ * through it. It never did: when a replay cursor goes live the proxy forwards the agent's own bytes
+ * to a configured upstream and translates only where a fork changed the model. Routing that through
+ * a `Provider` would mean re-serialising a request agenticreplay already holds verbatim, which loses
+ * fidelity for nothing, so the layer was not one push away from being used — it was the wrong shape
+ * for the only job it could have had.
+ *
+ * The `Provider` interface itself is still published, in `@agenticreplay/plugin-api`, for an
+ * out-of-tree implementation and for a future live path that wants one. What is gone is the pile of
+ * unused code behind it. To point agenticreplay at a different model API today: `agenticreplay setup`, or
+ * `--upstream-anthropic` / `--upstream-openai`.
+ */
+export * from './translate/util.js';
+export * from './translate/sse.js';
+export * from './translate/anthropic.js';
+export * from './translate/openai.js';
+export * from './pricing.js';
+export * from './translate/openai-responses.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@agenticreplay/providers/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,iCAAiC,CAAC"}

package/node_modules/@agenticreplay/providers/dist/index.js

@@ -0,0 +1,34 @@
+/**
+ * @agenticreplay/providers — all of AgenticReplay's wire-format knowledge in one place.
+ *
+ * Two layers, deliberately separable:
+ *
+ *   translate/  pure functions between provider wire bodies and the canonical IR. The recording
+ *               proxy uses these on intercepted bytes; nothing here touches the network.
+ *   pricing     what a recorded exchange cost, or null when the model is unknown.
+ *
+ * Two rules hold everywhere: translation never throws on an unfamiliar body, and anything the
+ * canonical IR cannot hold is parked under a namespaced `metadata` key so the round trip back to
+ * the wire is lossless. Raw bytes stay the source of truth for exact replay regardless.
+ *
+ * This package used to carry a third layer — live `Provider` clients for Anthropic and anything
+ * OpenAI-shaped, plus a registry to resolve one by id — and nothing ever called it. Roughly 400
+ * lines of production code and 570 of tests, kept because the docstring claimed the live path went
+ * through it. It never did: when a replay cursor goes live the proxy forwards the agent's own bytes
+ * to a configured upstream and translates only where a fork changed the model. Routing that through
+ * a `Provider` would mean re-serialising a request agenticreplay already holds verbatim, which loses
+ * fidelity for nothing, so the layer was not one push away from being used — it was the wrong shape
+ * for the only job it could have had.
+ *
+ * The `Provider` interface itself is still published, in `@agenticreplay/plugin-api`, for an
+ * out-of-tree implementation and for a future live path that wants one. What is gone is the pile of
+ * unused code behind it. To point agenticreplay at a different model API today: `agenticreplay setup`, or
+ * `--upstream-anthropic` / `--upstream-openai`.
+ */
+export * from './translate/util.js';
+export * from './translate/sse.js';
+export * from './translate/anthropic.js';
+export * from './translate/openai.js';
+export * from './pricing.js';
+export * from './translate/openai-responses.js';
+//# sourceMappingURL=index.js.map

package/node_modules/@agenticreplay/providers/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAC7B,cAAc,iCAAiC,CAAC"}

package/node_modules/@agenticreplay/providers/dist/pricing.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Open pricing data, usable by AgenticReplay and by any gateway that wants the same numbers.
+ *
+ * Prices are USD per million tokens, as published by each vendor's pricing page (checked
+ * 2026-08-29):
+ *   Anthropic   https://www.anthropic.com/pricing
+ *   OpenAI      https://openai.com/api/pricing
+ *   Z.ai (GLM)  https://z.ai/pricing
+ *   Alibaba     https://www.alibabacloud.com/help/en/model-studio/models
+ *   DeepSeek    https://api-docs.deepseek.com/quick_start/pricing
+ * They move; treat them as indicative and override them from config when the exact figure is
+ * load-bearing. What must be right is the *resolution* below: a cost attached to the wrong model
+ * is worse than no cost at all, so unknown ids return null rather than a nearby guess.
+ */
+import type { ModelInfo, Money, Usage } from '@agenticreplay/plugin-api';
+export interface ModelPrice {
+    input_per_mtok: number;
+    output_per_mtok: number;
+    context_window?: number;
+}
+export declare const MODEL_PRICING: Record<string, ModelPrice>;
+/**
+ * Cache tiers, as multiples of the input price. Anthropic, OpenAI and DeepSeek all discount cache
+ * reads by roughly an order of magnitude and Anthropic charges a premium to write the cache;
+ * these are the two multipliers everyone converged on.
+ */
+export declare const CACHE_READ_MULTIPLIER = 0.1;
+export declare const CACHE_WRITE_MULTIPLIER = 1.25;
+/**
+ * Map a wire model id onto a pricing key, or null when nothing is known about it.
+ *
+ * The same model reaches us as `claude-opus-5`, `anthropic/claude-opus-5`,
+ * `claude-opus-5-20260101`, `openrouter/anthropic/claude-opus-5:beta` and
+ * `us.anthropic.claude-opus-5-20260101-v1:0`. Candidates are tried most-specific first, so a key
+ * that happens to look decorated (`deepseek-v3`) still wins over its own stripped form.
+ */
+export declare function resolveModelId(model: string): string | null;
+/** Ids this table prices, for error messages and model pickers. */
+export declare function knownModelIds(): string[];
+/** Prices and context window for a model id, keeping the id the caller used. */
+export declare function modelInfoFor(model: string): ModelInfo | null;
+/** Cost of one exchange, or null when the model is unknown. Never guesses. */
+export declare function priceFor(usage: Usage, model: string): Money | null;
+//# sourceMappingURL=pricing.d.ts.map

package/node_modules/@agenticreplay/providers/dist/pricing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing.d.ts","sourceRoot":"","sources":["../src/pricing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAEzE,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CASpD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAS3C;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyC3D;AAED,mEAAmE;AACnE,wBAAgB,aAAa,IAAI,MAAM,EAAE,CAExC;AAED,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAW5D;AAED,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,CAelE"}

package/node_modules/@agenticreplay/providers/dist/pricing.js

@@ -0,0 +1,126 @@
+/**
+ * Open pricing data, usable by AgenticReplay and by any gateway that wants the same numbers.
+ *
+ * Prices are USD per million tokens, as published by each vendor's pricing page (checked
+ * 2026-08-29):
+ *   Anthropic   https://www.anthropic.com/pricing
+ *   OpenAI      https://openai.com/api/pricing
+ *   Z.ai (GLM)  https://z.ai/pricing
+ *   Alibaba     https://www.alibabacloud.com/help/en/model-studio/models
+ *   DeepSeek    https://api-docs.deepseek.com/quick_start/pricing
+ * They move; treat them as indicative and override them from config when the exact figure is
+ * load-bearing. What must be right is the *resolution* below: a cost attached to the wrong model
+ * is worse than no cost at all, so unknown ids return null rather than a nearby guess.
+ */
+export const MODEL_PRICING = {
+    'claude-opus-5': { input_per_mtok: 15, output_per_mtok: 75, context_window: 200_000 },
+    'claude-sonnet-5': { input_per_mtok: 3, output_per_mtok: 15, context_window: 200_000 },
+    'claude-haiku-4-5': { input_per_mtok: 1, output_per_mtok: 5, context_window: 200_000 },
+    'gpt-5.2': { input_per_mtok: 1.25, output_per_mtok: 10, context_window: 400_000 },
+    'gpt-5-mini': { input_per_mtok: 0.25, output_per_mtok: 2, context_window: 400_000 },
+    'glm-5.3-flash': { input_per_mtok: 0.05, output_per_mtok: 0.15, context_window: 200_000 },
+    'qwen3-coder': { input_per_mtok: 0.3, output_per_mtok: 1.2, context_window: 262_144 },
+    'deepseek-v3': { input_per_mtok: 0.27, output_per_mtok: 1.1, context_window: 128_000 },
+};
+/**
+ * Cache tiers, as multiples of the input price. Anthropic, OpenAI and DeepSeek all discount cache
+ * reads by roughly an order of magnitude and Anthropic charges a premium to write the cache;
+ * these are the two multipliers everyone converged on.
+ */
+export const CACHE_READ_MULTIPLIER = 0.1;
+export const CACHE_WRITE_MULTIPLIER = 1.25;
+const DATE_SUFFIX = /-(\d{4}-\d{2}-\d{2}|\d{8}|\d{6})$/;
+const VERSION_SUFFIX = /-v\d+$/;
+const ALIAS_SUFFIX = /-(latest|default)$/;
+const REGION_PREFIX = /^[a-z]{2,3}\./;
+const VENDOR_PREFIX = /^(anthropic|openai|google|meta|mistral|amazon|deepseek|qwen|alibaba|zhipuai|z-ai)\./;
+/**
+ * Map a wire model id onto a pricing key, or null when nothing is known about it.
+ *
+ * The same model reaches us as `claude-opus-5`, `anthropic/claude-opus-5`,
+ * `claude-opus-5-20260101`, `openrouter/anthropic/claude-opus-5:beta` and
+ * `us.anthropic.claude-opus-5-20260101-v1:0`. Candidates are tried most-specific first, so a key
+ * that happens to look decorated (`deepseek-v3`) still wins over its own stripped form.
+ */
+export function resolveModelId(model) {
+    if (typeof model !== 'string')
+        return null;
+    let id = model.trim().toLowerCase();
+    if (id === '')
+        return null;
+    const candidates = [];
+    const push = (value) => {
+        if (value !== '' && !candidates.includes(value))
+            candidates.push(value);
+    };
+    push(id);
+    id = id.slice(id.lastIndexOf('/') + 1);
+    push(id);
+    const colon = id.indexOf(':');
+    if (colon !== -1) {
+        id = id.slice(0, colon);
+        push(id);
+    }
+    if (REGION_PREFIX.test(id) && VENDOR_PREFIX.test(id.replace(REGION_PREFIX, ''))) {
+        id = id.replace(REGION_PREFIX, '');
+        push(id);
+    }
+    if (VENDOR_PREFIX.test(id)) {
+        id = id.replace(VENDOR_PREFIX, '');
+        push(id);
+    }
+    for (let round = 0; round < 4; round += 1) {
+        const before = id;
+        for (const suffix of [VERSION_SUFFIX, ALIAS_SUFFIX, DATE_SUFFIX]) {
+            if (suffix.test(id)) {
+                id = id.replace(suffix, '');
+                push(id);
+            }
+        }
+        if (id === before)
+            break;
+    }
+    for (const candidate of candidates) {
+        if (Object.hasOwn(MODEL_PRICING, candidate))
+            return candidate;
+    }
+    return null;
+}
+/** Ids this table prices, for error messages and model pickers. */
+export function knownModelIds() {
+    return Object.keys(MODEL_PRICING);
+}
+/** Prices and context window for a model id, keeping the id the caller used. */
+export function modelInfoFor(model) {
+    const key = resolveModelId(model);
+    const price = key === null ? undefined : MODEL_PRICING[key];
+    if (!price)
+        return null;
+    const info = {
+        id: model,
+        input_price_per_mtok: price.input_per_mtok,
+        output_price_per_mtok: price.output_per_mtok,
+    };
+    if (price.context_window !== undefined)
+        info.context_window = price.context_window;
+    return info;
+}
+/** Cost of one exchange, or null when the model is unknown. Never guesses. */
+export function priceFor(usage, model) {
+    const key = resolveModelId(model);
+    const price = key === null ? undefined : MODEL_PRICING[key];
+    if (!price)
+        return null;
+    const u = usage ?? {};
+    const amount = (finite(u.input_tokens) * price.input_per_mtok +
+        finite(u.output_tokens) * price.output_per_mtok +
+        finite(u.cache_read_tokens) * price.input_per_mtok * CACHE_READ_MULTIPLIER +
+        finite(u.cache_write_tokens) * price.input_per_mtok * CACHE_WRITE_MULTIPLIER) /
+        1_000_000;
+    // Ten decimal places is well under a millionth of a cent and keeps binary dust out of reports.
+    return { amount: Math.round(amount * 1e10) / 1e10, currency: 'USD' };
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+//# sourceMappingURL=pricing.js.map

package/node_modules/@agenticreplay/providers/dist/pricing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pricing.js","sourceRoot":"","sources":["../src/pricing.ts"],"names":[],"mappings":"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"}

package/node_modules/@agenticreplay/providers/dist/translate/anthropic.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Anthropic Messages API <-> canonical IR.
+ *
+ * Lossless for the round trip that matters: an intercepted request body converted to canonical and
+ * back must be byte-equivalent enough to re-send. Fields the canonical IR has no room for
+ * (`top_k`, `tool_choice`, `thinking`, per-tool `cache_control`, block-form system prompts) are
+ * parked under namespaced `metadata` keys and restored on the way out. Canonical values always
+ * win over the parked originals, so a fork that edits the system prompt is not silently ignored.
+ *
+ * Responses translate both ways too, in both wire forms — the JSON body and the SSE event
+ * sequence — because a forked replay has to hand the agent a reply in the dialect it speaks.
+ * Serializing a canonical response and re-parsing it here returns it unchanged; the parsers in
+ * this file are the specification for what the canonical form means.
+ */
+import type { CanonicalChunk, CanonicalContent, CanonicalRequest, CanonicalResponse, StopReason, Usage } from '@agenticreplay/plugin-api';
+/** Unconsumed top-level request fields, parked verbatim. */
+export declare const ANTHROPIC_EXTRA = "anthropic.extra";
+/** The original block-form system prompt, so `cache_control` survives the round trip. */
+export declare const ANTHROPIC_SYSTEM_BLOCKS = "anthropic.system_blocks";
+/** The original tool definitions by name, so server tools and `cache_control` survive. */
+export declare const ANTHROPIC_TOOL_ORIGINALS = "anthropic.tool_originals";
+export declare function anthropicToCanonicalRequest(body: unknown): CanonicalRequest;
+export declare function anthropicBlockToCanonical(raw: unknown): CanonicalContent | undefined;
+export declare function canonicalToAnthropicRequest(req: CanonicalRequest): Record<string, unknown>;
+export declare function canonicalBlockToAnthropic(block: CanonicalContent): Record<string, unknown>;
+export declare function anthropicToCanonicalResponse(body: unknown): CanonicalResponse;
+export declare function anthropicStopReason(value: unknown): StopReason;
+export declare function anthropicUsage(value: unknown): Usage;
+/**
+ * The non-streamed body the Messages API returns for one assistant turn.
+ *
+ * This is the half of translation a cross-provider fork needs: a reply obtained from any provider
+ * has to be handed back to the agent in the dialect that agent speaks.
+ */
+export declare function canonicalToAnthropicResponse(res: CanonicalResponse): Record<string, unknown>;
+/**
+ * The event sequence the Messages API streams for one assistant turn.
+ *
+ * Every frame carries both an `event:` name and a `type` inside its payload because SDKs dispatch
+ * on one or the other, and blocks are announced empty and then filled by deltas the way a real
+ * stream fills them — `AnthropicStreamAssembler` has to be able to read this back unchanged.
+ */
+export declare function canonicalToAnthropicSse(res: CanonicalResponse): string;
+/**
+ * Incremental assembler shared by `parseAnthropicSse` (recorded streams) and the live provider.
+ * Feed chunks, take the canonical deltas it returns, then ask for the assembled response.
+ */
+export declare class AnthropicStreamAssembler {
+    private readonly decoder;
+    private readonly blocks;
+    private readonly order;
+    private id;
+    private model;
+    private stop;
+    private usage;
+    private errorText;
+    push(chunk: string): CanonicalChunk[];
+    flush(): CanonicalChunk[];
+    result(): CanonicalResponse;
+    private handle;
+    private blockAt;
+    private mergeUsage;
+}
+/** Assemble a complete response from a recorded Anthropic SSE stream. */
+export declare function parseAnthropicSse(chunks: string[] | string): CanonicalResponse;
+//# sourceMappingURL=anthropic.d.ts.map

package/node_modules/@agenticreplay/providers/dist/translate/anthropic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../../src/translate/anthropic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAEhB,gBAAgB,EAChB,iBAAiB,EAEjB,UAAU,EACV,KAAK,EACN,MAAM,2BAA2B,CAAC;AAenC,4DAA4D;AAC5D,eAAO,MAAM,eAAe,oBAAoB,CAAC;AACjD,yFAAyF;AACzF,eAAO,MAAM,uBAAuB,4BAA4B,CAAC;AACjE,0FAA0F;AAC1F,eAAO,MAAM,wBAAwB,6BAA6B,CAAC;AAyBnE,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,OAAO,GAAG,gBAAgB,CAkD3E;AAeD,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAqCpF;AAeD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuC1F;AASD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyB1F;AAMD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,OAAO,GAAG,iBAAiB,CAyB7E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAM9D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAQpD;AAMD;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsB5F;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAsCtE;AAuDD;;;GAGG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,EAAE,CAAM;IAChB,OAAO,CAAC,KAAK,CAAM;IACnB,OAAO,CAAC,IAAI,CAA0B;IACtC,OAAO,CAAC,KAAK,CAAgD;IAC7D,OAAO,CAAC,SAAS,CAAqB;IAEtC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,EAAE;IAMrC,KAAK,IAAI,cAAc,EAAE;IAMzB,MAAM,IAAI,iBAAiB;IA4B3B,OAAO,CAAC,MAAM;IAmFd,OAAO,CAAC,OAAO;IAiBf,OAAO,CAAC,UAAU;CAanB;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,iBAAiB,CAK9E"}