agentfootprint 1.22.0 → 2.0.1

package/dist/types/patterns/Debate.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Debate — two agents alternate proposing + critiquing, a judge decides.
+ *
+ * Paper: "Improving Factuality and Reasoning in Language Models through
+ *        Multiagent Debate" — Du et al., 2023
+ *        (https://arxiv.org/abs/2305.14325).
+ *
+ * Pattern: Factory → produces a `Runner` built from
+ *          `Sequence(Proposer → Critic → Judge)` by default, or an
+ *          iterated `Loop(Sequence(…))` when `rounds > 1`.
+ * Role:    patterns/ layer.
+ * Emits:   Everything Sequence + Loop + LLMCall emit.
+ */
+import type { LLMProvider } from '../adapters/types.js';
+import type { Runner } from '../core/runner.js';
+export interface DebateOptions {
+    readonly provider: LLMProvider;
+    readonly model: string;
+    /** Proposer persona — asserts a position given the question. */
+    readonly proposerPrompt: string;
+    /** Critic persona — argues against the proposer's position. */
+    readonly criticPrompt: string;
+    /** Judge persona — reads the debate transcript, returns the verdict. */
+    readonly judgePrompt: string;
+    /** Rounds of propose+critique before the judge weighs in. Default 1. */
+    readonly rounds?: number;
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly name?: string;
+    readonly id?: string;
+}
+/**
+ * Build a Debate Runner. One debate "round" = Proposer → Critic. After
+ * N rounds, the Judge sees the final exchange and renders the verdict.
+ * The Judge's output is the Runner's return value.
+ */
+export declare function debate(opts: DebateOptions): Runner<{
+    message: string;
+}, string>;
+//# sourceMappingURL=Debate.d.ts.map

package/dist/types/patterns/Debate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Debate.d.ts","sourceRoot":"","sources":["../../../src/patterns/Debate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,wEAAwE;IACxE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,CAAC,CA6C/E"}

package/dist/types/patterns/MapReduce.d.ts

@@ -0,0 +1,67 @@
+/**
+ * MapReduce — fan-out N LLMCalls over deterministic input shards, reduce.
+ *
+ * Origin: classic map-reduce (Dean & Ghemawat, 2004) applied to
+ *         LLM context-window constraints. Seen in long-document
+ *         summarization: split → summarize each → combine.
+ *
+ * Pattern: Factory → produces a Runner composing `Parallel` of N
+ *          shard-aware branches. Each branch is an LLMCall wrapped so it
+ *          extracts its shard index from the input by position.
+ * Role:    patterns/ layer. Pure composition over existing primitives.
+ *
+ * Shard count is fixed at build time — consumer supplies `shardCount`
+ * and a `split(input, shardCount)` function that MUST return exactly
+ * `shardCount` strings. The extracted strings are packed into one
+ * `message` at run time (delimiter `\u001F`) so each branch can pick
+ * its own index. For run-time-variable shard counts, factor MapReduce
+ * inside a wrapping Runner that rebuilds the Parallel per call.
+ */
+import type { LLMProvider } from '../adapters/types.js';
+import type { Runner } from '../core/runner.js';
+import type { MergeFn, MergeWithLLMOptions } from '../core-flow/Parallel.js';
+export interface MapReduceOptions {
+    readonly provider: LLMProvider;
+    readonly model: string;
+    /** System prompt applied to every shard's LLMCall. */
+    readonly mapPrompt: string;
+    /**
+     * Number of shards to fan out. Must be >= 2 (for one-shard, use
+     * `LLMCall` directly). Fixed at build time.
+     */
+    readonly shardCount: number;
+    /**
+     * Splitter invoked at run time with `(input, shardCount)`. MUST return
+     * exactly `shardCount` strings. If it returns fewer, remaining shards
+     * receive empty strings; more are truncated.
+     */
+    readonly split: (input: string, shardCount: number) => readonly string[];
+    /**
+     * Reducer — either a pure fn combining the N shard outputs, OR an LLM
+     * synthesizer.
+     */
+    readonly reduce: {
+        readonly kind: 'fn';
+        readonly fn: MergeFn;
+    } | {
+        readonly kind: 'llm';
+        readonly opts: MergeWithLLMOptions;
+    };
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly name?: string;
+    readonly id?: string;
+}
+/**
+ * Build a MapReduce Runner. At run time:
+ *   1. The splitter runs the consumer's `split(input, shardCount)` and
+ *      packs the resulting N shards into a delimited string.
+ *   2. Parallel fans out to N branches. Each branch's wrapper extracts
+ *      its own shard from the packed input and feeds it to the shared
+ *      LLMCall.
+ *   3. The reducer combines the N branch outputs into the final string.
+ */
+export declare function mapReduce(opts: MapReduceOptions): Runner<{
+    message: string;
+}, string>;
+//# sourceMappingURL=MapReduce.d.ts.map

package/dist/types/patterns/MapReduce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapReduce.d.ts","sourceRoot":"","sources":["../../../src/patterns/MapReduce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAIxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAM7E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,SAAS,MAAM,EAAE,CAAC;IACzE;;;OAGG;IACH,QAAQ,CAAC,MAAM,EACX;QAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;QAAC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;KAAE,GAC7C;QAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAA;KAAE,CAAC;IACjE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,CAAC,CA6CrF"}

package/dist/types/patterns/Reflection.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Reflection — iterative self-refinement via critic + revise.
+ *
+ * Paper: "Self-Refine: Iterative Refinement with Self-Feedback" —
+ *        Madaan et al., 2023 (https://arxiv.org/abs/2303.17651).
+ *
+ * Pattern: Factory (GoF) → produces a `Runner` built from a `Loop`
+ *          whose body is `Sequence(Propose → Critique → Revise)`.
+ * Role:    patterns/ layer. Pure composition — no new abstractions.
+ * Emits:   Loop's composition.iteration_start / iteration_exit plus
+ *          every inner LLMCall's stream.llm_start/end.
+ */
+import type { LLMProvider } from '../adapters/types.js';
+import type { Runner } from '../core/runner.js';
+export interface ReflectionOptions {
+    readonly provider: LLMProvider;
+    readonly model: string;
+    /** System prompt for the initial / revision proposer. */
+    readonly proposerPrompt: string;
+    /**
+     * System prompt for the critic. Should instruct the critic to return
+     * "DONE" (or a consumer-chosen sentinel) when the proposal is good
+     * enough — that string is checked by `untilCritiqueContains` to stop
+     * the refinement loop.
+     */
+    readonly criticPrompt: string;
+    /**
+     * Stop string the critic should emit when satisfied. When the critic's
+     * response contains this substring, the loop exits and the last
+     * proposal is returned. Default: 'DONE'.
+     */
+    readonly untilCritiqueContains?: string;
+    /** Max refinement iterations. Default 3. */
+    readonly maxIterations?: number;
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly name?: string;
+    readonly id?: string;
+}
+/**
+ * Build a Reflection Runner. Each iteration:
+ *   1. Propose — LLMCall writes a candidate answer based on the input
+ *   2. Critique — LLMCall judges the candidate; exit marker stops loop
+ *   3. Revise — next iteration's propose sees the previous critique
+ *
+ * Each iteration's output (the candidate proposal) becomes the next
+ * iteration's input. The final iteration's proposal is returned.
+ */
+export declare function reflection(opts: ReflectionOptions): Runner<{
+    message: string;
+}, string>;
+//# sourceMappingURL=Reflection.d.ts.map

package/dist/types/patterns/Reflection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Reflection.d.ts","sourceRoot":"","sources":["../../../src/patterns/Reflection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,yDAAyD;IACzD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IACxC,4CAA4C;IAC5C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,CAAC,CA8CvF"}

package/dist/types/patterns/SelfConsistency.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SelfConsistency — sample N answers, pick the majority.
+ *
+ * Paper: "Self-Consistency Improves Chain of Thought Reasoning in
+ * Language Models" — Wang et al., 2022 (https://arxiv.org/abs/2203.11171).
+ *
+ * Pattern: Factory (GoF) → produces a `Runner` that composes `Parallel`
+ *          of N `LLMCall` branches with a majority-vote merge function.
+ * Role:    patterns/ layer. Pure composition of core primitives +
+ *          core-flow compositions — no new abstractions.
+ * Emits:   Everything `Parallel` + `LLMCall` emit (stream / composition /
+ *          context). No pattern-specific event domain needed; consumers
+ *          observe via the standard typed listeners.
+ */
+import type { LLMProvider } from '../adapters/types.js';
+import type { Runner } from '../core/runner.js';
+export interface SelfConsistencyOptions {
+    readonly provider: LLMProvider;
+    readonly model: string;
+    readonly systemPrompt: string;
+    /** Number of parallel samples. 3 / 5 are typical; paper uses up to 40. */
+    readonly samples: number;
+    /** Sampling temperature. Defaults to a higher value (0.7) to get diverse samples. */
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    /**
+     * Consumer-provided extractor: given a full LLM response, return the
+     * "vote token" (e.g., the final answer stripped of the chain-of-thought
+     * preamble). Defaults to returning the trimmed string.
+     */
+    readonly extract?: (response: string) => string;
+    readonly name?: string;
+    readonly id?: string;
+}
+/**
+ * Build a SelfConsistency Runner. Given a system prompt, the Runner
+ * runs `samples` parallel LLMCalls with the same input, extracts each
+ * response's vote token, then returns the most-frequent token. Ties
+ * are broken by the first response's extract.
+ */
+export declare function selfConsistency(opts: SelfConsistencyOptions): Runner<{
+    message: string;
+}, string>;
+//# sourceMappingURL=SelfConsistency.d.ts.map

package/dist/types/patterns/SelfConsistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelfConsistency.d.ts","sourceRoot":"","sources":["../../../src/patterns/SelfConsistency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGhD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,qFAAqF;IACrF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,sBAAsB,GAAG,MAAM,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,CAAC,CAoDjG"}

package/dist/types/patterns/Swarm.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Swarm — multi-agent handoff. At each step, an LLM-driven routing
+ * decision picks which agent handles the next turn.
+ *
+ * Origin: OpenAI Swarm experiment (2024). Useful for specialist
+ *         routing — each agent has a narrow role + its own tools.
+ *
+ * Pattern: Factory → produces a `Runner` built from
+ *          `Loop(Conditional(route-to-agent))`.
+ * Role:    patterns/ layer. Pure composition over existing primitives.
+ *          Agent roster is FIXED at build time; the routing decision
+ *          is made at runtime by a consumer-supplied `route(input)`
+ *          function (sync — pure over `{ message }`).
+ *
+ * For LLM-driven routing (the classic Swarm style), the consumer
+ * composes a "router" LLMCall as the first step of each iteration and
+ * parses its response in their `route()` function.
+ */
+import type { Runner } from '../core/runner.js';
+export interface SwarmAgent {
+    /** Stable id used in events + routing decisions. */
+    readonly id: string;
+    /** Display name for topology / narrative. */
+    readonly name?: string;
+    /** The runner that handles a turn when selected. */
+    readonly runner: Runner<{
+        message: string;
+    }, string>;
+}
+export interface SwarmOptions {
+    /**
+     * The fixed agent roster. Must contain >= 2 agents. The order doesn't
+     * matter — the `route` function selects by id.
+     */
+    readonly agents: readonly SwarmAgent[];
+    /**
+     * Routing function — receives the current message and returns the
+     * selected agent's id. Pure sync; evaluated before each iteration's
+     * chosen agent runs. Return `undefined` or an unknown id to halt
+     * the swarm (the loop's `until` guard fires).
+     */
+    readonly route: (input: {
+        readonly message: string;
+    }) => string | undefined;
+    /** Max hand-offs before the loop halts. Default 10. */
+    readonly maxHandoffs?: number;
+    readonly name?: string;
+    readonly id?: string;
+}
+/**
+ * Build a Swarm Runner. Each iteration:
+ *   1. Router evaluates `route(input)` to pick an agent id.
+ *   2. Conditional dispatches to that agent's runner.
+ *   3. Agent's output becomes the next iteration's input.
+ * Loop halts when `route` returns a halt-sentinel id (or unknown id
+ * falling to the `done` branch) OR when `maxHandoffs` is reached.
+ */
+export declare function swarm(opts: SwarmOptions): Runner<{
+    message: string;
+}, string>;
+//# sourceMappingURL=Swarm.d.ts.map

package/dist/types/patterns/Swarm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Swarm.d.ts","sourceRoot":"","sources":["../../../src/patterns/Swarm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,EAAE,MAAM,CAAC,CAAC;CACtD;AAED,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,KAAK,MAAM,GAAG,SAAS,CAAC;IAC5E,uDAAuD;IACvD,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,CAAC,CA2C7E"}

package/dist/types/patterns/ToT.d.ts

@@ -0,0 +1,54 @@
+/**
+ * ToT — Tree of Thoughts: breadth-first iterative expansion + pruning.
+ *
+ * Paper: "Tree of Thoughts: Deliberate Problem Solving with Large
+ *        Language Models" — Yao et al., 2023
+ *        (https://arxiv.org/abs/2305.10601).
+ *
+ * Pattern: Factory → produces a `Runner` built from `Loop(depth times,
+ *          Parallel(K thought branches) + prune-to-top-M)`.
+ * Role:    patterns/ layer. Pure composition over existing primitives.
+ *          Build-time-fixed depth + branching factor; runtime frontier
+ *          is pruned to `beamWidth` per level via a consumer-supplied
+ *          scorer.
+ *
+ * Tradeoff vs. full DFS: this shipped variant is BFS with constant
+ * width. True DFS with backtracking or adaptive branching factor would
+ * need runtime-variable Parallel (DynamicParallel) or recursion.
+ */
+import type { LLMProvider } from '../adapters/types.js';
+import type { Runner } from '../core/runner.js';
+export interface ToTOptions {
+    readonly provider: LLMProvider;
+    readonly model: string;
+    /** System prompt for the thought-generation LLMCall. */
+    readonly thoughtPrompt: string;
+    /** Depth of the tree (number of expansion iterations). */
+    readonly depth: number;
+    /** Branching factor — K thoughts generated per frontier node per iteration. */
+    readonly branchingFactor: number;
+    /**
+     * Scorer: given a thought, return a numeric score. Higher is better.
+     * The top `beamWidth` thoughts survive each level; the rest are pruned.
+     * Synchronous so pruning is deterministic.
+     */
+    readonly score: (thought: string) => number;
+    /** Beam width — how many thoughts survive after each level. Default 1 (greedy). */
+    readonly beamWidth?: number;
+    readonly temperature?: number;
+    readonly maxTokens?: number;
+    readonly name?: string;
+    readonly id?: string;
+}
+/**
+ * Build a ToT Runner. At run time:
+ *   1. Seed — treat the input message as the initial frontier of 1 thought.
+ *   2. For each of `depth` iterations:
+ *      a. Parallel fan-out: generate `branchingFactor` new thoughts.
+ *      b. Score all new thoughts, keep top `beamWidth`, pass to next iteration.
+ *   3. Return the single best-scoring thought from the final frontier.
+ */
+export declare function tot(opts: ToTOptions): Runner<{
+    message: string;
+}, string>;
+//# sourceMappingURL=ToT.d.ts.map

package/dist/types/patterns/ToT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToT.d.ts","sourceRoot":"","sources":["../../../src/patterns/ToT.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAIhD,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IAC5C,mFAAmF;IACnF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,MAAM,CAAC,CAwDzE"}

package/dist/types/patterns/index.d.ts

@@ -1,22 +1,23 @@
 /**
- * agentfootprint/patterns — canonical agent composition patterns.
+ * patterns/ — factory functions that compose primitives + core-flow
+ * into well-known agent patterns from the research literature.
  *
- * Each pattern is a thin factory over the existing concepts (`FlowChart`,
- * `Parallel`, `Conditional`, `Agent`, `LLMCall`, `RAG`, `Swarm`). No new
- * primitives. The source of each file shows the composition — read it to
- * learn how to build your own.
+ * Each pattern is:
+ *   - A factory function returning a `Runner` — drops into any
+ *     `Sequence.step()`, `Parallel.branch()`, etc.
+ *   - Purely composed — no new primitives, no state machinery beyond
+ *     what the underlying compositions provide.
+ *   - Documented with the canonical paper reference.
  *
- * @example
- * ```ts
- * import { treeOfThoughts, reflexion, planExecute, mapReduce } from 'agentfootprint/patterns';
- * ```
+ * Build-time-fixed cardinality: all patterns take a FIXED
+ * shard/branch/agent count at build time. Run-time-variable branching
+ * is a separate (not-yet-shipped) feature and would need a
+ * `DynamicParallel` primitive.
  */
-export { planExecute } from './planExecute';
-export type { PlanExecuteOptions } from './planExecute';
-export { mapReduce } from './mapReduce';
-export type { MapReduceOptions, MapReduceMapper, MapReduceReduceConfig } from './mapReduce';
-export { treeOfThoughts } from './treeOfThoughts';
-export type { TreeOfThoughtsOptions } from './treeOfThoughts';
-export { reflexion } from './reflexion';
-export type { ReflexionOptions } from './reflexion';
+export { selfConsistency, type SelfConsistencyOptions } from './SelfConsistency.js';
+export { reflection, type ReflectionOptions } from './Reflection.js';
+export { debate, type DebateOptions } from './Debate.js';
+export { mapReduce, type MapReduceOptions } from './MapReduce.js';
+export { tot, type ToTOptions } from './ToT.js';
+export { swarm, type SwarmOptions, type SwarmAgent } from './Swarm.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/patterns/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/patterns/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAE5F,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/patterns/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,SAAS,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,GAAG,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC"}

package/dist/types/providers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * agentfootprint/providers — LLM provider adapters.
+ *
+ * Pattern: Adapter (GoF) — concrete `LLMProvider` implementations that
+ *          translate the agentfootprint port to a specific vendor SDK.
+ * Role:    Outer ring (Hexagonal). Swappable at runtime; the Agent
+ *          knows nothing about vendor specifics.
+ *
+ * What's here today:
+ *   • `mock` / `MockProvider` — deterministic + realistic-mode mock
+ *   • `anthropic` / `AnthropicProvider` — real provider (Claude)
+ *   • `openai` / `OpenAIProvider` — real provider (GPT)
+ *
+ * Bring your own (BYO):
+ *   For Bedrock / Ollama / Cohere / on-prem / fine-tuned models,
+ *   implement the `LLMProvider` interface (see `LLMProvider` exported
+ *   from the main barrel) — `complete()` is required, `stream()` is
+ *   optional. The `MockProvider` source is the canonical reference.
+ */
+export { MockProvider, mock, type MockProviderOptions, type LatencyMs, } from './adapters/llm/MockProvider.js';
+export { anthropic, AnthropicProvider, type AnthropicProviderOptions, } from './adapters/llm/AnthropicProvider.js';
+export { openai, OpenAIProvider, ollama, type OpenAIProviderOptions, } from './adapters/llm/OpenAIProvider.js';
+export { bedrock, BedrockProvider, type BedrockProviderOptions, } from './adapters/llm/BedrockProvider.js';
+export { browserAnthropic, BrowserAnthropicProvider, type BrowserAnthropicProviderOptions, } from './adapters/llm/BrowserAnthropicProvider.js';
+export { browserOpenai, BrowserOpenAIProvider, type BrowserOpenAIProviderOptions, } from './adapters/llm/BrowserOpenAIProvider.js';
+export { createProvider, type ProviderKind, type CreateProviderOptions, } from './adapters/llm/createProvider.js';
+export type { LLMProvider, LLMRequest, LLMResponse, LLMChunk, LLMMessage, LLMToolSchema, } from './adapters/types.js';
+//# sourceMappingURL=providers.d.ts.map

package/dist/types/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACL,YAAY,EACZ,IAAI,EACJ,KAAK,mBAAmB,EACxB,KAAK,SAAS,GACf,MAAM,gCAAgC,CAAC;AAExC,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,KAAK,wBAAwB,GAC9B,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,MAAM,EACN,cAAc,EACd,MAAM,EACN,KAAK,qBAAqB,GAC3B,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EACL,OAAO,EACP,eAAe,EACf,KAAK,sBAAsB,GAC5B,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EACL,gBAAgB,EAChB,wBAAwB,EACxB,KAAK,+BAA+B,GACrC,MAAM,4CAA4C,CAAC;AAEpD,OAAO,EACL,aAAa,EACb,qBAAqB,EACrB,KAAK,4BAA4B,GAClC,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EACL,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,qBAAqB,GAC3B,MAAM,kCAAkC,CAAC;AAE1C,YAAY,EACV,WAAW,EACX,UAAU,EACV,WAAW,EACX,QAAQ,EACR,UAAU,EACV,aAAa,GACd,MAAM,qBAAqB,CAAC"}

package/dist/types/recorders/core/AgentRecorder.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AgentRecorder — forwards `agentfootprint.agent.*` emits to the dispatcher.
+ *
+ * Pattern: Factory (GoF) returning an EmitBridge instance.
+ * Role:    Convenience constructor for the agent-lifecycle bridge recorder.
+ *          Same mechanics as StreamRecorder, scoped to agent.* events
+ *          (turns + iterations + route decisions + handoffs).
+ * Emits:   agentfootprint.agent.turn_start / turn_end / iteration_start /
+ *          iteration_end / route_decided / handoff
+ */
+import { EmitBridge, type EmitBridgeOptions } from './EmitBridge.js';
+export type AgentRecorderOptions = Omit<EmitBridgeOptions, 'id' | 'prefix'> & {
+    readonly id?: string;
+};
+export declare function agentRecorder(options: AgentRecorderOptions): EmitBridge;
+//# sourceMappingURL=AgentRecorder.d.ts.map

package/dist/types/recorders/core/AgentRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/AgentRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG;IAC5E,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,UAAU,CAOvE"}

package/dist/types/recorders/core/CompositionRecorder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * CompositionRecorder — forwards `agentfootprint.composition.*` emits to the dispatcher.
+ *
+ * Pattern: Factory (GoF) returning an EmitBridge instance.
+ * Role:    Convenience constructor for the composition-domain bridge recorder.
+ *          Compositions (Sequence, Parallel, Conditional, Loop) typedEmit
+ *          composition.enter/exit/fork_start/branch_complete/merge_end/
+ *          route_decided/iteration_start/iteration_exit from their internal
+ *          stages; this recorder observes via footprintjs's EmitRecorder
+ *          channel and re-dispatches with typed payloads + meta.
+ * Emits:   agentfootprint.composition.*
+ */
+import { EmitBridge, type EmitBridgeOptions } from './EmitBridge.js';
+export type CompositionRecorderOptions = Omit<EmitBridgeOptions, 'id' | 'prefix'> & {
+    readonly id?: string;
+};
+export declare function compositionRecorder(options: CompositionRecorderOptions): EmitBridge;
+//# sourceMappingURL=CompositionRecorder.d.ts.map

package/dist/types/recorders/core/CompositionRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompositionRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/CompositionRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG;IAClF,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,UAAU,CAOnF"}

package/dist/types/recorders/core/ContextRecorder.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ContextRecorder — observes footprintjs subflow + scope events, emits
+ * grouped `context.*` domain events via the EventDispatcher.
+ *
+ * Pattern: Observer (GoF) + Pipes & Filters (Hohpe & Woolf, 2003).
+ * Role:    Core semantic grouping layer for the 3-slot model. Watches
+ *          slot subflows (sf-system-prompt / sf-messages / sf-tools) and
+ *          translates raw writes into context.injected / evicted /
+ *          slot_composed / budget_pressure events.
+ * Emits:   agentfootprint.context.injected
+ *          agentfootprint.context.evicted
+ *          agentfootprint.context.slot_composed
+ *          agentfootprint.context.budget_pressure
+ */
+import type { CombinedRecorder, FlowSubflowEvent, WriteEvent } from 'footprintjs';
+import type { EventDispatcher } from '../../events/dispatcher.js';
+import { type RunContext } from '../../bridge/eventMeta.js';
+/**
+ * Supplies the recorder with run-level context. Passed at construction
+ * time (static fields) OR updated via `updateRunContext` between runs
+ * when reusing one recorder across multiple executor runs.
+ */
+export interface ContextRecorderOptions {
+    readonly dispatcher: EventDispatcher;
+    readonly id?: string;
+    readonly getRunContext: () => RunContext;
+}
+export declare class ContextRecorder implements CombinedRecorder {
+    readonly id: string;
+    private readonly dispatcher;
+    private readonly getRunContext;
+    private readonly slotStack;
+    private readonly seenInjections;
+    constructor(options: ContextRecorderOptions);
+    onSubflowEntry(event: FlowSubflowEvent): void;
+    onSubflowExit(event: FlowSubflowEvent): void;
+    onWrite(event: WriteEvent): void;
+    private currentSlot;
+    private handleInjectionsWrite;
+    private handleSlotComposedWrite;
+    private handleEvictionsWrite;
+    private handleBudgetPressureWrite;
+    private emitInjected;
+    private dispatch;
+    private asInjectionArray;
+    private asSlotComposition;
+    private asEvictionArray;
+    private asPressureArray;
+}
+//# sourceMappingURL=ContextRecorder.d.ts.map

package/dist/types/recorders/core/ContextRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContextRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/ContextRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAClF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAIlE,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAS5E;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,aAAa,EAAE,MAAM,UAAU,CAAC;CAC1C;AAED,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IAIjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqB;IAI/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAkC;gBAErD,OAAO,EAAE,sBAAsB;IAQ3C,cAAc,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAQ7C,aAAa,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI;IAa5C,OAAO,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAyChC,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,qBAAqB;IAY7B,OAAO,CAAC,uBAAuB;IAM/B,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,yBAAyB;IAQjC,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,QAAQ;IAmBhB,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,eAAe;CAUxB"}

package/dist/types/recorders/core/CostRecorder.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CostRecorder — forwards `agentfootprint.cost.*` emits to the dispatcher.
+ *
+ * Pattern: Factory (GoF) returning an EmitBridge instance.
+ * Role:    Bridges `cost.tick` + `cost.limit_hit` emits from LLMCall / Agent
+ *          stages (via `emitCostTick`) to the EventDispatcher so typed
+ *          consumer listeners fire.
+ * Emits:   agentfootprint.cost.tick / cost.limit_hit
+ */
+import { EmitBridge, type EmitBridgeOptions } from './EmitBridge.js';
+export type CostRecorderOptions = Omit<EmitBridgeOptions, 'id' | 'prefix'> & {
+    readonly id?: string;
+};
+export declare function costRecorder(options: CostRecorderOptions): EmitBridge;
+//# sourceMappingURL=CostRecorder.d.ts.map

package/dist/types/recorders/core/CostRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CostRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/CostRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG;IAC3E,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,UAAU,CAOrE"}

package/dist/types/recorders/core/EmitBridge.d.ts

@@ -0,0 +1,31 @@
+/**
+ * EmitBridge — forwards footprintjs emits whose name starts with a given
+ * prefix to the EventDispatcher, enriched with EventMeta.
+ *
+ * Pattern: Adapter (GoF) + Pipes & Filters (Hohpe & Woolf, 2003).
+ * Role:    Single reusable translation layer for every "pass-through"
+ *          prefix recorder (StreamRecorder, AgentRecorder, and any
+ *          future domain whose events are emitted via typedEmit()).
+ * Emits:   Any event whose name matches `prefix` — type derived from the
+ *          emit name and validated by the consumer's EventMap subscription.
+ */
+import type { CombinedRecorder, EmitEvent } from 'footprintjs';
+import type { EventDispatcher } from '../../events/dispatcher.js';
+import { type RunContext } from '../../bridge/eventMeta.js';
+export interface EmitBridgeOptions {
+    readonly dispatcher: EventDispatcher;
+    /** Recorder id — must be unique among attached recorders. */
+    readonly id: string;
+    /** Event-name prefix this bridge forwards (e.g. 'agentfootprint.stream.'). */
+    readonly prefix: string;
+    readonly getRunContext: () => RunContext;
+}
+export declare class EmitBridge implements CombinedRecorder {
+    readonly id: string;
+    private readonly dispatcher;
+    private readonly prefix;
+    private readonly getRunContext;
+    constructor(options: EmitBridgeOptions);
+    onEmit(event: EmitEvent): void;
+}
+//# sourceMappingURL=EmitBridge.d.ts.map

package/dist/types/recorders/core/EmitBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmitBridge.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/EmitBridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,6DAA6D;IAC7D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,EAAE,MAAM,UAAU,CAAC;CAC1C;AAED,qBAAa,UAAW,YAAW,gBAAgB;IACjD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;gBAErC,OAAO,EAAE,iBAAiB;IAOtC,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;CAkB/B"}

package/dist/types/recorders/core/EvalRecorder.d.ts

@@ -0,0 +1,17 @@
+/**
+ * EvalRecorder — forwards `agentfootprint.eval.*` emits to the dispatcher.
+ *
+ * Pattern: Factory over EmitBridge.
+ * Role:    Bridges consumer-emitted `eval.score` + `eval.threshold_crossed`
+ *          events to typed listeners. Evaluation is a consumer concern
+ *          (LLM-based grading, heuristic checks, reference-output diffs),
+ *          so the library only provides transport — not any built-in
+ *          evaluators.
+ * Emits:   agentfootprint.eval.score / eval.threshold_crossed
+ */
+import { EmitBridge, type EmitBridgeOptions } from './EmitBridge.js';
+export type EvalRecorderOptions = Omit<EmitBridgeOptions, 'id' | 'prefix'> & {
+    readonly id?: string;
+};
+export declare function evalRecorder(options: EvalRecorderOptions): EmitBridge;
+//# sourceMappingURL=EvalRecorder.d.ts.map

package/dist/types/recorders/core/EvalRecorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvalRecorder.d.ts","sourceRoot":"","sources":["../../../../src/recorders/core/EvalRecorder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG,IAAI,CAAC,iBAAiB,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG;IAC3E,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,UAAU,CAOrE"}

package/dist/types/recorders/core/MemoryRecorder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MemoryRecorder — forwards `agentfootprint.memory.*` emits to the dispatcher.
+ *
+ * Pattern: Factory over EmitBridge.
+ * Role:    Bridges memory-layer events (strategy_applied, attached,
+ *          detached, written) emitted by consumer memory adapters.
+ *          The library does not ship a memory implementation; consumers
+ *          plug in their own store and emit these events where relevant
+ *          (e.g., before/after sliding-window summarization).
+ * Emits:   agentfootprint.memory.strategy_applied / attached /
+ *          detached / written
+ */
+import { EmitBridge, type EmitBridgeOptions } from './EmitBridge.js';
+export type MemoryRecorderOptions = Omit<EmitBridgeOptions, 'id' | 'prefix'> & {
+    readonly id?: string;
+};
+export declare function memoryRecorder(options: MemoryRecorderOptions): EmitBridge;
+//# sourceMappingURL=MemoryRecorder.d.ts.map