@vauban-org/agent-sdk 0.16.0

package/dist/replay/replay.js

@@ -0,0 +1,115 @@
+/**
+ * replayFrom — deterministic agent run replay.
+ *
+ * Given a runId, a ReplayLoader (fetches original trace + recorded artifacts),
+ * and a ReplayRunner (re-executes the agent with virtualized dependencies),
+ * replayFrom produces a ReplayResult containing:
+ *   - The replayed trace.
+ *   - A match flag: true iff rootHash of replay === rootHash of original.
+ *   - A diff array listing step-level field mismatches (when match is false).
+ *
+ * Design invariant:
+ *   Replay proves byte-identical traces when ClockPort, RandomPort, and
+ *   LLMResponseCache are virtualized. It does NOT prove LLM provider-side
+ *   determinism — the provider may return different tokens under identical
+ *   inputs (temperature, context window, batching).
+ *
+ * @module replay/replay
+ */
+// ─── NonDeterministicReplayError ─────────────────────────────────────────────
+/**
+ * Thrown when strict-mode replay detects a non-deterministic deviation
+ * that cannot be represented as a diff (e.g. step count mismatch, missing steps).
+ *
+ * For field-level mismatches, see ReplayResult.diff instead.
+ */
+export class NonDeterministicReplayError extends Error {
+    stepIndex;
+    reason;
+    constructor(stepIndex, reason) {
+        super(`Non-deterministic replay at step ${stepIndex}: ${reason}`);
+        this.stepIndex = stepIndex;
+        this.reason = reason;
+        this.name = "NonDeterministicReplayError";
+    }
+}
+// ─── diffTraces ───────────────────────────────────────────────────────────────
+/**
+ * Compute a step-level diff between two traces.
+ * Returns an empty array if the traces are identical at the step level.
+ */
+function diffTraces(original, replayed) {
+    const diffs = [];
+    const minLen = Math.min(original.steps.length, replayed.steps.length);
+    for (let i = 0; i < minLen; i++) {
+        const origStep = original.steps[i];
+        const repStep = replayed.steps[i];
+        for (const field of Object.keys(origStep)) {
+            const ov = origStep[field];
+            const rv = repStep[field];
+            // Compare via JSON serialization to handle nested objects correctly
+            if (JSON.stringify(ov) !== JSON.stringify(rv)) {
+                diffs.push({ stepIndex: i, field, original: ov, replayed: rv });
+            }
+        }
+    }
+    // If step counts differ, flag the extra/missing steps
+    if (original.steps.length !== replayed.steps.length) {
+        diffs.push({
+            stepIndex: minLen,
+            field: "index",
+            original: original.steps.length,
+            replayed: replayed.steps.length,
+        });
+    }
+    return diffs;
+}
+// ─── replayFrom ───────────────────────────────────────────────────────────────
+/**
+ * Main replay entry point.
+ *
+ * 1. Loads the original trace and recorded artifacts via ReplayLoader.
+ * 2. Builds a ReplayContext with RecordedClock, RecordedRandom, and LLM cache.
+ * 3. Re-executes the agent via ReplayRunner.run().
+ * 4. Compares rootHashes and computes a step-level diff if they differ.
+ *
+ * @param runId   The original run identifier to replay.
+ * @param loader  Host-provided loader for trace + artifacts.
+ * @param runner  Host-provided runner that wires the agent to virtualised deps.
+ * @param opts    Optional overrides: replay mode, step index to replay from.
+ */
+export async function replayFrom(runId, loader, runner, opts) {
+    const mode = opts?.mode ?? "strict";
+    // 1. Load original artifacts
+    const [originalTrace, artifacts] = await Promise.all([
+        loader.loadOriginalTrace(runId),
+        loader.loadCacheEntries(runId),
+    ]);
+    // 2. Import concrete implementations lazily to avoid circular references
+    const { RecordedClock } = await import("./clock.js");
+    const { RecordedRandom } = await import("./random.js");
+    const clock = new RecordedClock(artifacts.recordedTs);
+    const random = new RecordedRandom(artifacts.recordedNext, artifacts.recordedUuids, mode);
+    // 3. Build the replay context
+    const replayRunId = globalThis.crypto.randomUUID();
+    const ctx = {
+        originalRunId: runId,
+        replayRunId,
+        mode,
+        clock,
+        random,
+        cache: artifacts.cache,
+    };
+    // 4. Re-execute
+    const replayTrace = await runner.run(ctx, originalTrace);
+    // 5. Compare
+    const match = originalTrace.rootHash === replayTrace.rootHash;
+    const diff = match ? [] : diffTraces(originalTrace, replayTrace);
+    return {
+        replayRunId,
+        trace: replayTrace,
+        match,
+        diff,
+    };
+}
+//# sourceMappingURL=replay.js.map

package/dist/replay/replay.js.map

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

package/dist/resilience/bulkhead.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Bulkhead — bound concurrent execution of an async operation.
+ *
+ * Sprint-468. Wrap a function so at most `maxConcurrent` invocations
+ * are active at once; additional calls queue up to `maxQueued` before
+ * rejecting with BulkheadFullError. Prevents a slow backend from
+ * exhausting the agent's event loop or memory.
+ *
+ * Usage:
+ *   const safeArchive = bulkhead(brain.archiveKnowledge.bind(brain), {
+ *     name: "brain.archive",
+ *     maxConcurrent: 5,
+ *     maxQueued: 50,
+ *   });
+ */
+export interface BulkheadOptions {
+    /** Label for BulkheadFullError messages. */
+    name: string;
+    /** In-flight invocation cap. Default 5. */
+    maxConcurrent?: number;
+    /** Queue depth cap. Reject once full. Default 50. */
+    maxQueued?: number;
+}
+export declare class BulkheadFullError extends Error {
+    readonly bulkheadName: string;
+    constructor(bulkheadName: string, queueDepth: number);
+}
+export interface BulkheadStats {
+    active: number;
+    queued: number;
+}
+export interface Bulkhead<TArgs extends unknown[], TResult> {
+    (...args: TArgs): Promise<TResult>;
+    readonly stats: BulkheadStats;
+}
+export declare function bulkhead<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: BulkheadOptions): Bulkhead<TArgs, TResult>;
+//# sourceMappingURL=bulkhead.d.ts.map

package/dist/resilience/bulkhead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkhead.d.ts","sourceRoot":"","sources":["../../src/resilience/bulkhead.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,eAAe;IAC9B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAClB,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAOrD;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO;IACxD,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;CAC/B;AAED,wBAAgB,QAAQ,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACvD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,EACxC,OAAO,EAAE,eAAe,GACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CA6C1B"}

package/dist/resilience/bulkhead.js

@@ -0,0 +1,65 @@
+/**
+ * Bulkhead — bound concurrent execution of an async operation.
+ *
+ * Sprint-468. Wrap a function so at most `maxConcurrent` invocations
+ * are active at once; additional calls queue up to `maxQueued` before
+ * rejecting with BulkheadFullError. Prevents a slow backend from
+ * exhausting the agent's event loop or memory.
+ *
+ * Usage:
+ *   const safeArchive = bulkhead(brain.archiveKnowledge.bind(brain), {
+ *     name: "brain.archive",
+ *     maxConcurrent: 5,
+ *     maxQueued: 50,
+ *   });
+ */
+export class BulkheadFullError extends Error {
+    bulkheadName;
+    constructor(bulkheadName, queueDepth) {
+        super(`Bulkhead "${bulkheadName}" full — queue depth ${queueDepth} reached.`);
+        this.name = "BulkheadFullError";
+        this.bulkheadName = bulkheadName;
+    }
+}
+export function bulkhead(fn, options) {
+    const maxConcurrent = options.maxConcurrent ?? 5;
+    const maxQueued = options.maxQueued ?? 50;
+    let active = 0;
+    const queue = [];
+    const acquire = () => {
+        if (active < maxConcurrent) {
+            active += 1;
+            return Promise.resolve();
+        }
+        if (queue.length >= maxQueued) {
+            return Promise.reject(new BulkheadFullError(options.name, queue.length));
+        }
+        return new Promise((resolve) => {
+            queue.push(() => {
+                active += 1;
+                resolve();
+            });
+        });
+    };
+    const release = () => {
+        active -= 1;
+        const next = queue.shift();
+        if (next)
+            next();
+    };
+    async function run(...args) {
+        await acquire();
+        try {
+            return await fn(...args);
+        }
+        finally {
+            release();
+        }
+    }
+    const wrapper = run;
+    Object.defineProperty(wrapper, "stats", {
+        get: () => ({ active, queued: queue.length }),
+    });
+    return wrapper;
+}
+//# sourceMappingURL=bulkhead.js.map

package/dist/resilience/bulkhead.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulkhead.js","sourceRoot":"","sources":["../../src/resilience/bulkhead.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAWH,MAAM,OAAO,iBAAkB,SAAQ,KAAK;IACjC,YAAY,CAAS;IAC9B,YAAY,YAAoB,EAAE,UAAkB;QAClD,KAAK,CACH,aAAa,YAAY,wBAAwB,UAAU,WAAW,CACvE,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;QAChC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;CACF;AAYD,MAAM,UAAU,QAAQ,CACtB,EAAwC,EACxC,OAAwB;IAExB,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,CAAC,CAAC;IACjD,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC;IAE1C,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,MAAM,KAAK,GAAsB,EAAE,CAAC;IAEpC,MAAM,OAAO,GAAG,GAAkB,EAAE;QAClC,IAAI,MAAM,GAAG,aAAa,EAAE,CAAC;YAC3B,MAAM,IAAI,CAAC,CAAC;YACZ,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,IAAI,SAAS,EAAE,CAAC;YAC9B,OAAO,OAAO,CAAC,MAAM,CACnB,IAAI,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAClD,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACnC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE;gBACd,MAAM,IAAI,CAAC,CAAC;gBACZ,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,GAAS,EAAE;QACzB,MAAM,IAAI,CAAC,CAAC;QACZ,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,IAAI;YAAE,IAAI,EAAE,CAAC;IACnB,CAAC,CAAC;IAEF,KAAK,UAAU,GAAG,CAAC,GAAG,IAAW;QAC/B,MAAM,OAAO,EAAE,CAAC;QAChB,IAAI,CAAC;YACH,OAAO,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;QAC3B,CAAC;gBAAS,CAAC;YACT,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED,MAAM,OAAO,GAAG,GAA+B,CAAC;IAChD,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE;QACtC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;KAC9C,CAAC,CAAC;IACH,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/resilience/circuit-breaker.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Circuit breaker — Hystrix-style state machine.
+ *
+ * Sprint-468. Wrap an unreliable async operation so N consecutive
+ * failures trip the breaker OPEN (all subsequent calls fast-fail
+ * without invoking the operation) for `resetAfterMs`. After that a
+ * single probe call runs in HALF-OPEN state; success → back to CLOSED,
+ * failure → back to OPEN.
+ *
+ *   CLOSED (normal)
+ *     ├─ N failures ──► OPEN (fast-fail, window)
+ *     └─ success ──► CLOSED
+ *   OPEN
+ *     └─ after resetAfterMs ──► HALF-OPEN (1 probe)
+ *   HALF-OPEN
+ *     ├─ probe success ──► CLOSED
+ *     └─ probe failure ──► OPEN (new window)
+ *
+ * Usage:
+ *   const safeArchive = circuitBreaker(brain.archiveKnowledge.bind(brain), {
+ *     name: "brain.archive",
+ *     failureThreshold: 5,
+ *     resetAfterMs: 30_000,
+ *   });
+ */
+export type CircuitState = "closed" | "open" | "half-open";
+export interface CircuitBreakerOptions {
+    /** Operation identifier for CircuitOpenError messages. */
+    name: string;
+    /** Consecutive failures required to trip OPEN. Default 5. */
+    failureThreshold?: number;
+    /** How long to stay OPEN before the HALF-OPEN probe. Default 30s. */
+    resetAfterMs?: number;
+    /** Optional clock for tests. */
+    now?: () => number;
+    /**
+     * Predicate — classify an error as "should count as failure" vs
+     * "fast-exit without tripping". Default: every thrown value counts.
+     */
+    isFailure?: (err: unknown) => boolean;
+}
+export declare class CircuitOpenError extends Error {
+    readonly circuitName: string;
+    readonly retryAfterMs: number;
+    constructor(circuitName: string, retryAfterMs: number);
+}
+export interface CircuitBreaker<TArgs extends unknown[], TResult> {
+    (...args: TArgs): Promise<TResult>;
+    readonly state: CircuitState;
+    /** Consecutive failures in the current CLOSED window. */
+    readonly failureCount: number;
+    /** Force back to CLOSED (for tests or operational reset). */
+    reset(): void;
+}
+export declare function circuitBreaker<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: CircuitBreakerOptions): CircuitBreaker<TArgs, TResult>;
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/resilience/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../src/resilience/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;AAE3D,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qEAAqE;IACrE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CACvC;AAED,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;gBAClB,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;CAQtD;AAED,MAAM,WAAW,cAAc,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO;IAC9D,CAAC,GAAG,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,yDAAyD;IACzD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,6DAA6D;IAC7D,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,cAAc,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EAC7D,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,EACxC,OAAO,EAAE,qBAAqB,GAC7B,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CA2DhC"}

package/dist/resilience/circuit-breaker.js

@@ -0,0 +1,93 @@
+/**
+ * Circuit breaker — Hystrix-style state machine.
+ *
+ * Sprint-468. Wrap an unreliable async operation so N consecutive
+ * failures trip the breaker OPEN (all subsequent calls fast-fail
+ * without invoking the operation) for `resetAfterMs`. After that a
+ * single probe call runs in HALF-OPEN state; success → back to CLOSED,
+ * failure → back to OPEN.
+ *
+ *   CLOSED (normal)
+ *     ├─ N failures ──► OPEN (fast-fail, window)
+ *     └─ success ──► CLOSED
+ *   OPEN
+ *     └─ after resetAfterMs ──► HALF-OPEN (1 probe)
+ *   HALF-OPEN
+ *     ├─ probe success ──► CLOSED
+ *     └─ probe failure ──► OPEN (new window)
+ *
+ * Usage:
+ *   const safeArchive = circuitBreaker(brain.archiveKnowledge.bind(brain), {
+ *     name: "brain.archive",
+ *     failureThreshold: 5,
+ *     resetAfterMs: 30_000,
+ *   });
+ */
+export class CircuitOpenError extends Error {
+    circuitName;
+    retryAfterMs;
+    constructor(circuitName, retryAfterMs) {
+        super(`Circuit "${circuitName}" is OPEN — fast-fail. Retry after ${retryAfterMs}ms.`);
+        this.name = "CircuitOpenError";
+        this.circuitName = circuitName;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export function circuitBreaker(fn, options) {
+    const failureThreshold = options.failureThreshold ?? 5;
+    const resetAfterMs = options.resetAfterMs ?? 30_000;
+    const now = options.now ?? (() => Date.now());
+    const isFailure = options.isFailure ?? (() => true);
+    let state = "closed";
+    let failureCount = 0;
+    let openedAt = 0;
+    async function run(...args) {
+        if (state === "open") {
+            const elapsed = now() - openedAt;
+            if (elapsed < resetAfterMs) {
+                throw new CircuitOpenError(options.name, resetAfterMs - elapsed);
+            }
+            state = "half-open";
+        }
+        try {
+            const result = await fn(...args);
+            if (state === "half-open") {
+                state = "closed";
+                failureCount = 0;
+            }
+            else {
+                failureCount = 0;
+            }
+            return result;
+        }
+        catch (err) {
+            if (!isFailure(err))
+                throw err;
+            if (state === "half-open") {
+                state = "open";
+                openedAt = now();
+                throw err;
+            }
+            failureCount += 1;
+            if (failureCount >= failureThreshold) {
+                state = "open";
+                openedAt = now();
+            }
+            throw err;
+        }
+    }
+    const wrapper = run;
+    Object.defineProperty(wrapper, "state", { get: () => state });
+    Object.defineProperty(wrapper, "failureCount", {
+        get: () => failureCount,
+    });
+    Object.defineProperty(wrapper, "reset", {
+        value: () => {
+            state = "closed";
+            failureCount = 0;
+            openedAt = 0;
+        },
+    });
+    return wrapper;
+}
+//# sourceMappingURL=circuit-breaker.js.map

package/dist/resilience/circuit-breaker.js.map

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

package/dist/resilience/idempotent.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Idempotency cache — dedupe duplicate calls by a caller-supplied key.
+ *
+ * Sprint-468. Wrap an async operation so repeated calls with the same
+ * key return the cached result without re-invoking the operation.
+ * Essential for retry-safe writes (BrainPort.archiveKnowledge on
+ * retryable failures).
+ *
+ * Defaults to an in-memory LRU with 1024 entries / 5 min TTL. Production
+ * hosts with multi-process topology should inject a shared
+ * implementation (e.g. Redis-backed) via the `cache` option.
+ *
+ * Usage:
+ *   const safe = idempotent(brain.archiveKnowledge.bind(brain), {
+ *     keyFor: (entry) => sha256(entry.content + entry.author),
+ *     ttlMs: 60_000,
+ *   });
+ */
+export interface IdempotencyCache<T> {
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    delete(key: string): void;
+}
+/**
+ * Simple bounded TTL cache. In-memory only; single-process.
+ * Eviction: oldest entry first when `maxEntries` is exceeded, and
+ * entries past `ttlMs` are skipped on read.
+ */
+export declare class BoundedTtlCache<T> implements IdempotencyCache<T> {
+    private readonly maxEntries;
+    private readonly ttlMs;
+    private readonly now;
+    private readonly store;
+    constructor(maxEntries: number, ttlMs: number, now?: () => number);
+    get(key: string): T | undefined;
+    set(key: string, value: T): void;
+    delete(key: string): void;
+    get size(): number;
+}
+export interface IdempotentOptions<TArgs extends unknown[], TResult> {
+    /** Derive a stable cache key from the call arguments. */
+    keyFor: (...args: TArgs) => string;
+    /** Optional cache implementation (defaults to BoundedTtlCache). */
+    cache?: IdempotencyCache<TResult>;
+    /** Default cache: entries count cap. Default 1024. */
+    maxEntries?: number;
+    /** Default cache: entry TTL in ms. Default 5 minutes. */
+    ttlMs?: number;
+}
+/**
+ * Wrap an async function so identical keyed calls share the same
+ * result. Failures are NOT cached — a failed call is retryable.
+ */
+export declare function idempotent<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options: IdempotentOptions<TArgs, TResult>): (...args: TArgs) => Promise<TResult>;
+/**
+ * Convenience: hash the JSON-serialisable arguments as the cache key.
+ * Useful when the args already fully determine the operation (e.g.
+ * BrainPort.archiveKnowledge takes a single entry object).
+ */
+export declare function hashKey(...parts: unknown[]): string;
+//# sourceMappingURL=idempotent.d.ts.map

package/dist/resilience/idempotent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idempotent.d.ts","sourceRoot":"","sources":["../../src/resilience/idempotent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAC;IAChC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACjC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED;;;;GAIG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,YAAW,gBAAgB,CAAC,CAAC,CAAC;IAG1D,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAJtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsD;gBAEzD,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,GAAG,GAAE,MAAM,MAAyB;IAGvD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAa/B,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAWhC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIzB,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED,MAAM,WAAW,iBAAiB,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO;IACjE,yDAAyD;IACzD,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,MAAM,CAAC;IACnC,mEAAmE;IACnE,KAAK,CAAC,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IAClC,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACzD,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,EACxC,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,OAAO,CAAC,GACzC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,CAgBtC;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAWnD"}

package/dist/resilience/idempotent.js

@@ -0,0 +1,103 @@
+/**
+ * Idempotency cache — dedupe duplicate calls by a caller-supplied key.
+ *
+ * Sprint-468. Wrap an async operation so repeated calls with the same
+ * key return the cached result without re-invoking the operation.
+ * Essential for retry-safe writes (BrainPort.archiveKnowledge on
+ * retryable failures).
+ *
+ * Defaults to an in-memory LRU with 1024 entries / 5 min TTL. Production
+ * hosts with multi-process topology should inject a shared
+ * implementation (e.g. Redis-backed) via the `cache` option.
+ *
+ * Usage:
+ *   const safe = idempotent(brain.archiveKnowledge.bind(brain), {
+ *     keyFor: (entry) => sha256(entry.content + entry.author),
+ *     ttlMs: 60_000,
+ *   });
+ */
+import { createHash } from "node:crypto";
+/**
+ * Simple bounded TTL cache. In-memory only; single-process.
+ * Eviction: oldest entry first when `maxEntries` is exceeded, and
+ * entries past `ttlMs` are skipped on read.
+ */
+export class BoundedTtlCache {
+    maxEntries;
+    ttlMs;
+    now;
+    store = new Map();
+    constructor(maxEntries, ttlMs, now = () => Date.now()) {
+        this.maxEntries = maxEntries;
+        this.ttlMs = ttlMs;
+        this.now = now;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (entry.expiresAt < this.now()) {
+            this.store.delete(key);
+            return undefined;
+        }
+        // Refresh LRU position.
+        this.store.delete(key);
+        this.store.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        if (this.store.size >= this.maxEntries) {
+            const oldest = this.store.keys().next().value;
+            if (oldest !== undefined)
+                this.store.delete(oldest);
+        }
+        this.store.set(key, {
+            value,
+            expiresAt: this.now() + this.ttlMs,
+        });
+    }
+    delete(key) {
+        this.store.delete(key);
+    }
+    get size() {
+        return this.store.size;
+    }
+}
+/**
+ * Wrap an async function so identical keyed calls share the same
+ * result. Failures are NOT cached — a failed call is retryable.
+ */
+export function idempotent(fn, options) {
+    const cache = options.cache ??
+        new BoundedTtlCache(options.maxEntries ?? 1024, options.ttlMs ?? 5 * 60_000);
+    return async (...args) => {
+        const key = options.keyFor(...args);
+        const hit = cache.get(key);
+        if (hit !== undefined)
+            return hit;
+        const result = await fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+}
+/**
+ * Convenience: hash the JSON-serialisable arguments as the cache key.
+ * Useful when the args already fully determine the operation (e.g.
+ * BrainPort.archiveKnowledge takes a single entry object).
+ */
+export function hashKey(...parts) {
+    const h = createHash("sha256");
+    for (const part of parts) {
+        let serialised;
+        if (typeof part === "string")
+            serialised = part;
+        else if (part === undefined)
+            serialised = "__undefined__";
+        else
+            serialised = JSON.stringify(part) ?? "__unserialisable__";
+        h.update(serialised);
+        h.update("\x1f"); // unit-separator
+    }
+    return h.digest("hex");
+}
+//# sourceMappingURL=idempotent.js.map

package/dist/resilience/idempotent.js.map

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

package/dist/resilience/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Resilience primitives — Hystrix-style patterns for port wrappers.
+ *
+ * Sprint-468. Three composable wrappers that turn any async function
+ * into a production-grade primitive:
+ *
+ *   - circuitBreaker : trip OPEN after N consecutive failures, recover
+ *     via HALF-OPEN probe. Prevents overload of a failing dependency.
+ *   - idempotent     : dedupe by a stable key; retry-safe writes.
+ *   - bulkhead       : bound concurrent in-flight calls + queue depth.
+ *
+ * These are orthogonal and composable:
+ *
+ *   const safe = circuitBreaker(
+ *     bulkhead(
+ *       idempotent(brain.archiveKnowledge.bind(brain), { keyFor: ... }),
+ *       { name: "brain.archive", maxConcurrent: 5 }
+ *     ),
+ *     { name: "brain.archive", failureThreshold: 5, resetAfterMs: 30_000 }
+ *   );
+ */
+export { circuitBreaker, CircuitOpenError, } from "./circuit-breaker.js";
+export type { CircuitBreaker, CircuitBreakerOptions, CircuitState, } from "./circuit-breaker.js";
+export { idempotent, hashKey, BoundedTtlCache, } from "./idempotent.js";
+export type { IdempotencyCache, IdempotentOptions, } from "./idempotent.js";
+export { bulkhead, BulkheadFullError, } from "./bulkhead.js";
+export type { Bulkhead, BulkheadOptions, BulkheadStats, } from "./bulkhead.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/resilience/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resilience/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,YAAY,GACb,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,UAAU,EACV,OAAO,EACP,eAAe,GAChB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EACL,QAAQ,EACR,iBAAiB,GAClB,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,QAAQ,EACR,eAAe,EACf,aAAa,GACd,MAAM,eAAe,CAAC"}

package/dist/resilience/index.js

@@ -0,0 +1,25 @@
+/**
+ * Resilience primitives — Hystrix-style patterns for port wrappers.
+ *
+ * Sprint-468. Three composable wrappers that turn any async function
+ * into a production-grade primitive:
+ *
+ *   - circuitBreaker : trip OPEN after N consecutive failures, recover
+ *     via HALF-OPEN probe. Prevents overload of a failing dependency.
+ *   - idempotent     : dedupe by a stable key; retry-safe writes.
+ *   - bulkhead       : bound concurrent in-flight calls + queue depth.
+ *
+ * These are orthogonal and composable:
+ *
+ *   const safe = circuitBreaker(
+ *     bulkhead(
+ *       idempotent(brain.archiveKnowledge.bind(brain), { keyFor: ... }),
+ *       { name: "brain.archive", maxConcurrent: 5 }
+ *     ),
+ *     { name: "brain.archive", failureThreshold: 5, resetAfterMs: 30_000 }
+ *   );
+ */
+export { circuitBreaker, CircuitOpenError, } from "./circuit-breaker.js";
+export { idempotent, hashKey, BoundedTtlCache, } from "./idempotent.js";
+export { bulkhead, BulkheadFullError, } from "./bulkhead.js";
+//# sourceMappingURL=index.js.map

package/dist/resilience/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/resilience/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EACL,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,EACL,UAAU,EACV,OAAO,EACP,eAAe,GAChB,MAAM,iBAAiB,CAAC;AAMzB,OAAO,EACL,QAAQ,EACR,iBAAiB,GAClB,MAAM,eAAe,CAAC"}

package/dist/router/index.d.ts

@@ -0,0 +1,3 @@
+export { createProviderRouter, ProviderRouterError, } from "./provider-router.js";
+export type { ProviderRouter, ProviderRouterRequest, ProviderRouterResponse, ProviderRouterOptions, AnthropicLike, } from "./provider-router.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/router/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/router/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,cAAc,EACd,qBAAqB,EACrB,sBAAsB,EACtB,qBAAqB,EACrB,aAAa,GACd,MAAM,sBAAsB,CAAC"}

package/dist/router/index.js

@@ -0,0 +1,2 @@
+export { createProviderRouter, ProviderRouterError, } from "./provider-router.js";
+//# sourceMappingURL=index.js.map

package/dist/router/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/router/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,sBAAsB,CAAC"}