@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-UPSiS-X7.d.cts

@@ -1,2680 +0,0 @@
-import { T as TokenUsage, L as LLMAdapter, P as PricingFn, C as ChatMessage, a as LLMInvokeOptions, d as ToolDefinition, b as LLMResponse, S as StreamDelta, c as ToolCall, e as CapabilitiesRegistry, M as ModelCapabilities, f as ModelFeatures, g as ModelLimits, h as ModelPricing, i as PriceBreakdown, j as PricingRegistry, R as Rate, k as TieredRate, l as composePricing, m as computePrice, n as createCapabilitiesRegistry, o as createPricingRegistry, p as pricingFor, r as registryPricing, z as zeroPrice } from './types-C0_yquda.cjs';
-import { a as CascadeExhaustionReport, A as AdapterProvider, b as AdapterTier, d as AllTiersExhaustedError, C as CascadingLlmAdapterOptions, e as CreateAdapterOptions, O as OpenAICompatAdapterOptions, f as OpenAICompatPreset, g as OpenAISdkLike, h as cascadingLlmAdapter, c as createAdapter, o as openAICompatAdapter, t as tier } from './cascading-BglDkMdX.cjs';
-import { N as Node, A as Actor } from './node-kK3CvTrR.cjs';
-import { a as ReactiveLogBundle } from './reactive-log-DIGdYqQ6.cjs';
-import { b as CircuitBreakerOptions, C as CircuitBreaker, c as CircuitOpenError } from './index-C1T3d7V-.cjs';
-import { NodeInput } from './extra/sources.cjs';
-import { W as WithReplayCacheOptions, F as FallbackAdapterOptions, a as FallbackFixture, b as FallbackMissError, c as FallbackMissPolicy, R as ReplayCacheKeyContext, d as ReplayCacheMissError, e as ReplayCacheMode, f as canonicalJson, g as fallbackAdapter, w as withReplayCache } from './fallback-74oxi34l.cjs';
-import { E as Extraction, a as DistillOptions, D as DistillBundle, f as DEFAULT_DECAY_RATE } from './decay-CFlLvXUT.cjs';
-import { G as Graph, a as GraphOptions, i as GraphCheckpointRecord, h as GraphAttachStorageOptions } from './graph-CWvEUQAq.cjs';
-import { T as TopicGraph } from './index-C5ri2Axc.cjs';
-import { G as GateController, c as GateOptions } from './pipeline-graph-CIKhynsF.cjs';
-import { V as VectorSearchResult, C as CollectionGraph, a as VectorIndexGraph, K as KnowledgeGraph } from './index-B17QddL1.cjs';
-import { StorageHandle } from './extra/storage-core.cjs';
-import { SnapshotStorageTier } from './extra/storage-tiers.cjs';
-import { c as GraphSpecCatalog } from './index-CS0LTlB8.cjs';
-
-/**
- * Observable adapter wrapper — the "inverted statistics" surface.
- *
- * The library emits structured facts (token counts, latency, timestamps)
- * as reactive nodes. Users compose interpretation (pricing, dashboards,
- * telemetry, budget breakers) as derived layers on top.
- */
-
-/** One call's structured statistics — emitted after `invoke()` / `stream()` settles. */
-interface CallStatsEvent {
-    /** `monotonicNs()` at call completion — use for event ordering. */
-    readonly timestamp: number;
-    /** `wallClockNs()` at call start — use for human-readable attribution. */
-    readonly wallClock: number;
-    readonly provider: string;
-    readonly model: string;
-    readonly tier?: string;
-    readonly usage: TokenUsage;
-    readonly latencyMs: number;
-    /** `"invoke"` or `"stream"`. */
-    readonly method: "invoke" | "stream";
-    /** Populated when the call errored — usage may be zero or partial. */
-    readonly error?: {
-        readonly type: string;
-        readonly message: string;
-    };
-}
-interface AdapterStats {
-    /**
-     * Reactive node for the most-recent call event. Emits `null` initially
-     * (no calls yet); emits a {@link CallStatsEvent} after each call. Subscribe
-     * and filter `!= null` if you want a `Node<CallStatsEvent>`.
-     */
-    readonly lastCall: Node<CallStatsEvent | null>;
-    /** Full event log (bounded by `opts.logMax`, default 1000). */
-    readonly allCalls: ReactiveLogBundle<CallStatsEvent>;
-    /** Total calls observed since last reset. */
-    readonly totalCalls: Node<number>;
-    /** Sum of every input-token class across observed calls. */
-    readonly totalInputTokens: Node<number>;
-    /** Sum of every output-token class across observed calls. */
-    readonly totalOutputTokens: Node<number>;
-    /** Reset all counters + clear the log. */
-    reset(): void;
-    /**
-     * Release the internal keepalive subscriptions on the three counter
-     * derives (`totalCalls` / `totalInputTokens` / `totalOutputTokens`) so the
-     * bundle can be GC'd when the caller discards it. Idempotent. Long-lived
-     * adapter bundles (module-level singletons) can ignore; transient bundles
-     * (per-request / per-user) should call on teardown.
-     */
-    dispose(): void;
-}
-/**
- * Wrap any {@link LLMAdapter} with a reactive stats bundle.
- *
- * Implementation (Unit 10 B):
- * - `stats.lastCall` is a `state<CallStatsEvent | null>`.
- * - Counters (`totalCalls` / `totalInputTokens` / `totalOutputTokens`) are
- *   **derived views** over `allCalls.entries` — self-maintaining, no manual
- *   `.cache + 1 + emit` pattern, visible topology in `describe()`.
- * - `stats.allCalls` is a `reactiveLog<CallStatsEvent>` — bounded, supports
- *   `tail(n)` / `slice(start, stop)` for dashboard views.
- * - The wrapped adapter passes DATA through via `adaptInvokeResult`, which
- *   uses `onFirstData` internally to guard against re-subscription double-fire
- *   and wires `.catch` for Promise-path error recording (Unit 10 A).
- */
-declare function observableAdapter(inner: LLMAdapter, opts?: {
-    logMax?: number;
-    name?: string;
-}): {
-    adapter: LLMAdapter;
-    stats: AdapterStats;
-};
-
-/**
- * `withBreaker` — circuit-breaker middleware for LLM adapters.
- *
- * Reuses the library's existing `circuitBreaker` primitive from
- * `extra/resilience.ts`. When the breaker is open, calls throw
- * `CircuitOpenError` instead of hitting the provider.
- */
-
-interface WithBreakerOptions extends CircuitBreakerOptions {
-    /**
-     * Optional external breaker — pass a shared instance to wire the same
-     * breaker across multiple adapters (e.g. all tiers of a `cascadingLlmAdapter`).
-     */
-    breaker?: CircuitBreaker;
-}
-declare function withBreaker(inner: LLMAdapter, opts?: WithBreakerOptions): {
-    adapter: LLMAdapter;
-    breaker: CircuitBreaker;
-};
-
-/**
- * `withBudgetGate` — cap an adapter by calls / tokens / USD.
- *
- * Totals are an O(1)-per-event running accumulator (a `state<BudgetTotals>`
- * updated imperatively inside `record()`), not a derived reduce over the
- * full log — avoids the quadratic cost at sustained traffic while preserving
- * the reactive surface. The full log is still exposed via the bundle for
- * dashboards / auditors.
- *
- * Budgets are enforced imperatively at `invoke()` / `stream()` entry — the
- * running totals + `isOpen.cache` are read; if closed, the call rejects /
- * throws `BudgetExhaustedError` without hitting the wrapped adapter. On
- * success, the call's usage is appended to the log AND debits the running
- * totals in a single synchronous update.
- *
- * Wave A Unit 11 Q4: rejected-Promise path now wires `.catch` (via
- * `adaptInvokeResult.onError`) so failed invoke calls record a CallStatsEvent
- * with `error` populated. Prior code silently dropped rejection from the
- * `totals` / `log` surface.
- */
-
-declare class BudgetExhaustedError extends Error {
-    readonly which: string;
-    readonly limit: number;
-    readonly observed: number;
-    name: string;
-    constructor(which: string, limit: number, observed: number);
-}
-interface BudgetCaps {
-    calls?: number;
-    inputTokens?: number;
-    outputTokens?: number;
-    usd?: number;
-}
-interface BudgetTotals {
-    calls: number;
-    inputTokens: number;
-    outputTokens: number;
-    usd: number;
-}
-interface BudgetGateBundle {
-    totals: Node<BudgetTotals>;
-    isOpen: Node<boolean>;
-    log: ReactiveLogBundle<CallStatsEvent>;
-    reset(): void;
-}
-interface WithBudgetGateOptions {
-    caps: BudgetCaps;
-    /**
-     * Optional pricing function for USD gating. If omitted, `caps.usd` is
-     * ignored (caps.calls / caps.inputTokens / caps.outputTokens still apply).
-     */
-    pricingFn?: PricingFn;
-    /**
-     * Edge-triggered: fires exactly once when the gate transitions from
-     * open to closed. Subsequent invoke/stream attempts against a closed
-     * gate do NOT re-fire `onExhausted` — use the reactive `isOpen` node
-     * if you need per-attempt notifications. Receives the cap key that
-     * triggered the transition.
-     */
-    onExhausted?: (which: keyof BudgetCaps) => void;
-    /** Name for logs / describe output. */
-    name?: string;
-    /** Max events retained in the log (default 1000). */
-    logMax?: number;
-}
-/**
- * Wrap an adapter with budget enforcement. Returns `{adapter, budget}` so
- * callers can subscribe to the bundle for dashboards.
- */
-declare function withBudgetGate(inner: LLMAdapter, opts: WithBudgetGateOptions): {
-    adapter: LLMAdapter;
-    budget: BudgetGateBundle;
-};
-
-/**
- * `withDryRun` — short-circuit to a fake adapter when a flag is on.
- *
- * Useful for CI / preflight / cost-safety pipelines: wrap a real adapter,
- * pass `enabled: true` (or a reactive flag) to bypass the wire call. Default
- * shim is {@link dryRunAdapter}; callers can supply their own.
- *
- * **Returns `{adapter, dispose}`** — call `dispose()` to release the internal
- * keepalive on the reactive `enabled` input. Long-lived adapter instances
- * (module-level singletons) can ignore dispose; transient adapters (per-
- * request or per-user) should call it on teardown to allow the source to
- * be GC'd.
- */
-
-interface WithDryRunOptions {
-    /**
-     * Toggle — `true` always dry-runs; `false` always passes through; a
-     * `NodeInput<boolean>` reads the current value at call time (factory-time
-     * seed pattern, live-tunable).
-     */
-    enabled: NodeInput<boolean>;
-    /** Dry-run adapter override. Default: `dryRunAdapter({ provider: inner.provider, model: inner.model })`. */
-    mock?: LLMAdapter;
-}
-interface WithDryRunBundle {
-    adapter: LLMAdapter;
-    /**
-     * Release the internal keepalive subscription on the reactive `enabled`
-     * input. Idempotent. Safe to ignore on long-lived adapters.
-     */
-    dispose(): void;
-}
-declare function withDryRun(inner: LLMAdapter, opts: WithDryRunOptions): WithDryRunBundle;
-
-/**
- * Adaptive rate limiter — reactive, live-tunable, 429-aware.
- *
- * Wraps two `tokenBucket` instances (requests, tokens) with:
- *   - Reactive `rpm` / `tpm` knobs that can be re-tuned at runtime via `NodeInput<number>`.
- *   - An adaptation signal input (`Node<RateLimitSignal>`) that feeds back
- *     provider 429 / retry-after / x-ratelimit-* headers to tighten limits.
- *   - A `clampCooldownMs` TTL on signal-induced caps so a transient 429 doesn't
- *     permanently throttle — caps decay back to user-configured values after
- *     the cooldown elapses.
- *   - TPM-miss recovery: consumed RPM tokens are returned to the request
- *     bucket when the TPM admit fails, via `TokenBucket.putBack`.
- *   - Imperative `acquire()` for bridging to Promise-based call paths
- *     (used by the `withRateLimiter` adapter middleware).
- *
- * **Timer policy:** sleeps use `ResettableTimer` (documented spec §5.10
- * escape hatch in `src/extra/timer.ts`) rather than `fromTimer` to avoid
- * allocating a new Node per acquire cycle.
- *
- * Design lives in `docs/optimizations.md` § "Reactive adaptive rate limiter".
- */
-
-/**
- * Rate-limit signal emitted by an adaptation source (e.g., an HTTP 429 parser).
- *
- * Any subset of fields may be present. The adaptive rate limiter uses:
- * - `retryAfterMs` — blocks acquire() for this duration.
- * - `rpmCap` / `tpmCap` — tightens effective rpm/tpm to this value (decays
- *   back to the user-configured cap after `clampCooldownMs`).
- * - `usageHint` — updates the last-known rpm/tpm usage ratio for logging.
- */
-interface RateLimitSignal {
-    /** Throttle duration — pause acquire() for this long. */
-    retryAfterMs?: number;
-    /** Hard cap for requests-per-minute; effective rpm = min(current, rpmCap) while clamp is active. */
-    rpmCap?: number;
-    /** Hard cap for tokens-per-minute; effective tpm = min(current, tpmCap) while clamp is active. */
-    tpmCap?: number;
-    /** Observed usage-percentage hint (0..1) — for observability, not gating. */
-    usageHint?: {
-        rpm?: number;
-        tpm?: number;
-    };
-    /** Free-form provider-specific payload. */
-    metadata?: Record<string, unknown>;
-}
-interface AdaptiveRateLimiterBundle {
-    /** Effective requests-per-minute (post-signal-clamp). Reactive. */
-    readonly effectiveRpm: Node<number>;
-    /** Effective tokens-per-minute (post-signal-clamp). Reactive. */
-    readonly effectiveTpm: Node<number>;
-    /** Last adaptation signal observed. */
-    readonly lastSignal: Node<RateLimitSignal>;
-    /** Pending `acquire()` callers waiting for capacity. */
-    readonly pending: Node<number>;
-    /** Current request-token-bucket fill (approximate). */
-    readonly rpmAvailable: Node<number>;
-    /** Current token-bucket fill (approximate). */
-    readonly tpmAvailable: Node<number>;
-    /**
-     * Imperative bridge: wait until `requestCost` request-tokens and
-     * `tokenCost` tokens are available, then consume them. Honors the
-     * most recent `retryAfterMs` from adaptation signals. Rejects with
-     * an `AbortError`-named error if `signal` aborts while waiting.
-     * `requestCost` defaults to 1; `tokenCost` defaults to 0 (rpm-only gating).
-     */
-    acquire(opts?: {
-        requestCost?: number;
-        tokenCost?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Feed back observed token usage (post-call) so the TPM bucket reflects
-     * real consumption rather than the pre-call estimate. A positive `delta`
-     * debits additional TPM (undershot estimate); a negative `delta` credits
-     * back overshoot (`putBack`).
-     */
-    recordUsage(delta: number): void;
-    /** Manually feed an adaptation signal — useful for tests. */
-    recordSignal(sig: RateLimitSignal): void;
-    /** Dispose internal subscriptions and pending timers. */
-    dispose(): void;
-}
-
-/**
- * HTTP 429 / rate-limit parser.
- *
- * Produces a {@link RateLimitSignal} from provider HTTP errors so adaptive
- * rate limiters can tighten effective limits. Normalizes:
- * - `Retry-After` (seconds or HTTP-date)
- * - `x-ratelimit-reset` / `x-ratelimit-reset-tokens` (epoch secs or duration)
- * - `x-ratelimit-remaining-{requests,tokens}` + `x-ratelimit-limit-*`
- * - Anthropic `anthropic-ratelimit-*` headers
- * - OpenAI / OpenRouter / Groq headers (same family)
- * - Error message regex fallbacks for providers without structured headers
- */
-
-interface HttpErrorLike {
-    status?: number;
-    headers?: Headers | Record<string, string | string[] | undefined>;
-    message?: string;
-}
-/**
- * Extract a {@link RateLimitSignal} from a fetch-style error object, a Response,
- * or any object exposing `.status` + `.headers` + `.message`.
- *
- * Returns `undefined` if no rate-limit information can be extracted.
- */
-declare function parseRateLimitFromError(err: unknown): RateLimitSignal | undefined;
-
-/**
- * `withRateLimiter` — adapter middleware bridging to the reactive
- * `adaptiveRateLimiter` primitive.
- *
- * - Consumes live `rpm`/`tpm` caps as reactive `NodeInput<number>` so
- *   callers can retune at runtime (e.g. from a `ModelLimits.rpm` node).
- * - Adapts to provider 429 responses via `http429Parser` fed into the
- *   limiter's `adaptation` signal.
- * - `costFn` estimates token cost pre-call (e.g. char-based approximation);
- *   the post-call actual usage is fed back via `limiter.recordUsage()`.
- */
-
-interface WithRateLimiterOptions {
-    /** Live rpm cap (defaults to `Infinity`). */
-    rpm?: NodeInput<number>;
-    /** Live tpm cap (defaults to `Infinity`). */
-    tpm?: NodeInput<number>;
-    /**
-     * Pre-call token-cost estimate. Default: 0 (only rpm gates). Override with
-     * e.g. a char-based heuristic:
-     * `(msgs) => Math.ceil(msgs.reduce((s, m) => s + m.content.length, 0) / 4)`.
-     */
-    costFn?: (messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => number;
-    /**
-     * Manual adaptation signal source. Defaults to a signal derived from
-     * provider errors via `parseRateLimitFromError` — users can supply a
-     * custom signal chain if they route errors elsewhere.
-     */
-    adaptation?: NodeInput<RateLimitSignal>;
-    burstMultiplier?: number;
-    name?: string;
-    /**
-     * Share an existing {@link AdaptiveRateLimiterBundle} across multiple
-     * adapter wraps. When provided, `withRateLimiter` reuses this bundle
-     * instead of constructing a new one — useful when the RPM/TPM cap is
-     * logically per-provider but the caller wants to harden multiple adapters
-     * (e.g. primary + fallback of the same vendor) against the shared cap.
-     *
-     * When `limiter` is set, `rpm` / `tpm` / `adaptation` / `burstMultiplier`
-     * / `name` are ignored (the supplied bundle owns those). `costFn` is still
-     * used per-wrap — each wrap supplies its own cost estimator.
-     */
-    limiter?: AdaptiveRateLimiterBundle;
-}
-/**
- * Wrap an adapter with adaptive rate limiting. Returns `{adapter, limiter}`
- * so callers can subscribe to limiter internals (rpmAvailable, pending, etc.)
- * for dashboards.
- */
-declare function withRateLimiter(inner: LLMAdapter, opts?: WithRateLimiterOptions): {
-    adapter: LLMAdapter;
-    limiter: AdaptiveRateLimiterBundle;
-};
-
-/**
- * `withRetry` — retry `invoke()` / `stream()` on transient errors.
- *
- * Streaming retry is tricky: we retry only if the stream fails before
- * yielding any tokens. Once tokens have started flowing, we surface the
- * error to avoid replaying from scratch (which would double-bill and
- * confuse consumers). Opt out of streaming retry via `opts.retryStreaming = false`.
- *
- * Uses `ResettableTimer` for backoff sleeps (spec §5.10 escape hatch, same
- * pattern as `extra/resilience.ts`). Abort-aware — early-aborts before the
- * first attempt and cleans up the abort listener on both the timer-fires
- * and abort paths.
- */
-
-interface WithRetryOptions {
-    /** Max total attempts (including the first). Default 3. */
-    attempts?: number;
-    /** Base delay in ms. Default 500. */
-    baseDelayMs?: number;
-    /** Max delay in ms. Default 10_000. */
-    maxDelayMs?: number;
-    /**
-     * Delay strategy. Default `"decorrelated"` — AWS-style `random(baseDelay,
-     * min(maxDelay, prev * 3))` which smooths retry storms and matches common
-     * SDK expectations. `"exp"` and `"linear"` produce deterministic schedules
-     * when `jitter: false`.
-     */
-    strategy?: "exp" | "linear" | "decorrelated";
-    /**
-     * Add randomized jitter. Ignored for `strategy: "decorrelated"` (which is
-     * inherently jittered). For `exp`/`linear`, symmetric jitter in `[0.5x,
-     * 1.5x]` of the nominal delay.
-     */
-    jitter?: boolean;
-    /**
-     * Predicate: should this error trigger a retry? Default retries network /
-     * 5xx / 429 / transient errors, but not 4xx (other than 429), aborts, or
-     * `BudgetExhaustedError` from upstream middleware.
-     */
-    shouldRetry?: (err: unknown, attempt: number) => boolean;
-    /** Retry streaming calls if they fail pre-first-token. Default true. */
-    retryStreaming?: boolean;
-}
-declare function withRetry(inner: LLMAdapter, opts?: WithRetryOptions): LLMAdapter;
-
-/**
- * `resilientAdapter` — compose `withRateLimiter` + `withBudgetGate` +
- * `withBreaker` + `withTimeout` + `withRetry` + fallback over an {@link LLMAdapter}.
- *
- * Call-path peer of {@link resilientPipeline} (which operates on a reactive
- * `Node<T>` chain). Use `resilientPipeline` when composing graph sources; use
- * `resilientAdapter` when wrapping an adapter so downstream users see a
- * single hardened `invoke`/`stream` surface.
- *
- * Composition order (innermost to outermost, mirrors `resilientPipeline`):
- *
- * ```text
- *   rateLimit → budget → breaker → timeout → retry → fallback
- * ```
- *
- * Rationale:
- * - **rateLimit innermost** — each attempt acquires a fresh slot; a retry
- *   after a 429 waits for admission rather than bursting past the cap.
- * - **budget next** — per-attempt gate close short-circuits retries once a
- *   cap trips.
- * - **breaker next** — each attempt observes circuit health; open breaker
- *   fast-fails retries into fallback.
- * - **timeout before retry** — each retry re-arms a fresh per-attempt
- *   deadline. If `timeout` wrapped `retry`, a single deadline would cover
- *   the entire retry chain — surprising for callers.
- * - **retry before fallback** — fallback is entered only after the primary
- *   exhausts its retry budget (or immediately fails in a way the predicate
- *   doesn't retry).
- *
- * Every option is optional — omit the field and that layer is skipped. The
- * returned bundle exposes the primary adapter plus the internal bundles
- * (`rateLimiter`, `budget`, `breaker`) so callers can wire them into
- * dashboards, alerts, or `graphLens`.
- *
- * Fallback is implemented via {@link cascadingLlmAdapter}: when `fallback`
- * is provided, the wrapped primary adapter is placed at tier 0 and the
- * fallback adapter at tier 1. For N-tier cascades, use `cascadingLlmAdapter`
- * directly and wrap each tier with `resilientAdapter`.
- *
- * @module
- */
-
-/** Options for {@link resilientAdapter}. Every field is optional — omit to skip that layer. */
-interface ResilientAdapterOptions {
-    /** Admission control. See {@link withRateLimiter}. */
-    rateLimit?: WithRateLimiterOptions;
-    /** Cost/cap gate. See {@link withBudgetGate}. */
-    budget?: WithBudgetGateOptions;
-    /** Circuit breaker. See {@link withBreaker}. */
-    breaker?: WithBreakerOptions;
-    /** Per-attempt deadline in milliseconds. Omit to skip the timeout wrap. */
-    timeoutMs?: number;
-    /** Retry policy on transient errors. See {@link withRetry}. */
-    retry?: WithRetryOptions;
-    /**
-     * Fallback adapter engaged when the primary (post-retry) fails. Implemented
-     * via {@link cascadingLlmAdapter} — the primary becomes tier 0, the
-     * fallback becomes tier 1. For N-tier cascades, use `cascadingLlmAdapter`
-     * directly and wrap each tier with `resilientAdapter` as needed.
-     */
-    fallback?: LLMAdapter;
-    /** Name used as the primary tier name in the fallback cascade. Default `"primary"`. */
-    name?: string;
-    /**
-     * Called when the cascade switches from one tier to the next after a
-     * failure. Only fires when `fallback` is set. Threaded directly to the
-     * inner {@link cascadingLlmAdapter}.
-     */
-    onFallback?: (from: string, to: string, error: unknown) => void;
-    /**
-     * Called when every tier in the cascade has been exhausted (all failed,
-     * skipped by filter, or skipped by breaker). Only fires when `fallback`
-     * is set. Threaded directly to the inner {@link cascadingLlmAdapter}.
-     */
-    onExhausted?: (report: CascadeExhaustionReport) => void;
-    /**
-     * Content-addressed replay cache wrapped OUTERMOST — a cache HIT short-
-     * circuits the entire stack (rate-limit / budget / breaker / retry /
-     * fallback), saving money and latency. Cache MISSes flow through the
-     * normal stack; the successful result is stored on success. See
-     * {@link withReplayCache}.
-     */
-    cache?: WithReplayCacheOptions;
-}
-/** Output bundle of {@link resilientAdapter}. */
-interface ResilientAdapterBundle {
-    /** The final hardened adapter. */
-    adapter: LLMAdapter;
-    /** Rate-limiter internals (for dashboards). Present only when `opts.rateLimit` was set. */
-    rateLimiter?: AdaptiveRateLimiterBundle;
-    /** Budget gate internals (for dashboards). Present only when `opts.budget` was set. */
-    budget?: BudgetGateBundle;
-    /** Circuit breaker (for dashboards). Present only when `opts.breaker` was set. */
-    breaker?: CircuitBreaker;
-}
-/**
- * Wrap `inner` with the standard resilience stack. See module docs for the
- * composition order and rationale.
- *
- * @example
- * ```ts
- * const { adapter, budget, breaker } = resilientAdapter(openai, {
- *   rateLimit: { rpm: 60, tpm: 90_000 },
- *   budget: { caps: { usd: 5 } },
- *   breaker: { failureThreshold: 5, resetTimeoutMs: 30_000 },
- *   timeoutMs: 30_000,
- *   retry: { attempts: 3 },
- *   fallback: webllm,  // cascades to local on exhaustion
- * });
- *
- * // `adapter` is drop-in for anything expecting LLMAdapter.
- * // Subscribe to `budget.totals`, `breaker.state`, etc. for dashboards.
- * ```
- */
-declare function resilientAdapter(inner: LLMAdapter, opts?: ResilientAdapterOptions): ResilientAdapterBundle;
-
-/**
- * `withTimeout` — cancel `invoke()` / `stream()` after `ms` elapse.
- *
- * Wires a child AbortSignal so provider adapters can honor the cancellation
- * (all shipped adapters forward `signal` through to their fetch / SDK call).
- *
- * Uses `ResettableTimer` rather than raw `setTimeout` — same pattern as
- * `extra/resilience.ts` (spec §5.10 escape hatch documented on the class).
- */
-
-declare class LLMTimeoutError extends Error {
-    readonly ms: number;
-    name: string;
-    constructor(ms: number);
-}
-declare function withTimeout(inner: LLMAdapter, ms: number): LLMAdapter;
-
-/**
- * AnthropicAdapter — default fetch-backed, optional SDK-backed.
- *
- * - `anthropicAdapter({ apiKey })` uses native `fetch` + SSE parsing.
- * - `anthropicAdapter({ sdk })` delegates to a user-provided `@anthropic-ai/sdk` instance.
- *
- * Token usage mapping:
- * - `input_tokens`                                → `input.regular`
- * - `cache_read_input_tokens`                     → `input.cacheRead`
- * - `cache_creation.ephemeral_5m_input_tokens`    → `input.cacheWrite5m`
- * - `cache_creation.ephemeral_1h_input_tokens`    → `input.cacheWrite1h`
- * - `cache_creation_input_tokens` (legacy)        → `input.cacheWrite5m` (default TTL)
- * - `output_tokens`                               → `output.regular`
- * - `server_tool_use.web_search_requests`         → `auxiliary.webSearchRequests`
- */
-
-interface AnthropicAdapterOptions {
-    /** API key. Falls back to `process.env.ANTHROPIC_API_KEY` on Node. */
-    apiKey?: string;
-    /** Default model (overridable per-call via `LLMInvokeOptions.model`). */
-    model?: string;
-    /** Override the base URL. Default `https://api.anthropic.com`. */
-    baseURL?: string;
-    /** API version header. Default `"2023-06-01"`. */
-    anthropicVersion?: string;
-    /** Additional headers to send on every request (overridden by per-call). */
-    headers?: Record<string, string>;
-    /**
-     * User-provided SDK instance. When present, the adapter delegates to it
-     * (uses `.messages.create`) instead of native fetch.
-     * Shape matches `@anthropic-ai/sdk` `.messages` API; any object with a
-     * compatible `create`/`stream` contract works.
-     */
-    sdk?: AnthropicSdkLike;
-    /** Custom fetch (useful for tests). Default `globalThis.fetch`. */
-    fetchImpl?: typeof fetch;
-}
-/** Minimal SDK shape we interoperate with. */
-interface AnthropicSdkLike {
-    messages: {
-        create(params: Record<string, unknown>, opts?: {
-            signal?: AbortSignal;
-        }): Promise<AnthropicMessageResponse>;
-        stream?(params: Record<string, unknown>, opts?: {
-            signal?: AbortSignal;
-        }): AsyncIterable<AnthropicStreamEvent>;
-    };
-}
-interface AnthropicMessageResponse {
-    id: string;
-    content: ReadonlyArray<{
-        type: "text";
-        text: string;
-    } | {
-        type: "tool_use";
-        id: string;
-        name: string;
-        input: Record<string, unknown>;
-    } | {
-        type: "thinking";
-        thinking: string;
-    } | {
-        type: string;
-        [key: string]: unknown;
-    }>;
-    stop_reason?: string;
-    usage: AnthropicUsage;
-    model?: string;
-}
-interface AnthropicUsage {
-    input_tokens?: number;
-    output_tokens?: number;
-    cache_read_input_tokens?: number;
-    cache_creation_input_tokens?: number;
-    cache_creation?: {
-        ephemeral_5m_input_tokens?: number;
-        ephemeral_1h_input_tokens?: number;
-    };
-    server_tool_use?: {
-        web_search_requests?: number;
-    };
-}
-type AnthropicStreamEvent = {
-    type: "message_start";
-    message: {
-        usage: AnthropicUsage;
-    };
-} | {
-    type: "content_block_start";
-    index: number;
-    content_block: Record<string, unknown>;
-} | {
-    type: "content_block_delta";
-    index: number;
-    delta: Record<string, unknown>;
-} | {
-    type: "content_block_stop";
-    index: number;
-} | {
-    type: "message_delta";
-    delta: {
-        stop_reason?: string;
-        usage?: AnthropicUsage;
-    };
-} | {
-    type: "message_stop";
-} | {
-    type: string;
-    [key: string]: unknown;
-};
-declare function anthropicAdapter(opts?: AnthropicAdapterOptions): LLMAdapter;
-
-/**
- * DryRunAdapter — zero-cost mock provider.
- *
- * Returns a deterministic fake response (plus a configurable hook for
- * customization). Useful for: pipeline smoke tests, CI without API keys,
- * local development, and as the leaf of a `cascadingLlmAdapter` when every
- * real tier fails.
- *
- * The library ships a minimal implementation only — richer scenario-
- * scripted mocks (per-stage responses, call recording) belong at the test
- * harness layer, not in the shipped library.
- *
- * Uses `ResettableTimer` for simulated latency (spec §5.10 escape hatch
- * documented on the class), and throws an `AbortError`-named Error on
- * abort so retry/timeout middleware can classify it.
- */
-
-interface DryRunAdapterOptions {
-    provider?: string;
-    model?: string;
-    /** Generate the fake response. Defaults to echoing the last user message. */
-    respond?: (messages: readonly ChatMessage[], opts?: LLMInvokeOptions) => string;
-    /**
-     * Generate a fake usage object. Defaults to a simple character-count
-     * heuristic (`input = sum(messages) / 4`, `output = content / 4`).
-     */
-    usage?: (messages: readonly ChatMessage[], content: string) => TokenUsage;
-    /** Simulated latency in milliseconds (applied to both invoke and stream). */
-    latencyMs?: number;
-    /** Stream chunk size in characters. Default 16. */
-    streamChunkSize?: number;
-}
-/**
- * Create a DryRun adapter.
- *
- * @example
- * ```ts
- * const adapter = dryRunAdapter({ respond: (msgs) => "hello from dry-run" });
- * const resp = await Promise.resolve(adapter.invoke([{ role: "user", content: "hi" }]));
- * ```
- */
-declare function dryRunAdapter(opts?: DryRunAdapterOptions): LLMAdapter;
-
-/**
- * GoogleAdapter — default fetch-backed, optional SDK-backed.
- *
- * The SDK-backed path targets the `@google/genai` SDK shape:
- * `client.models.generateContent({ model, contents, config })` — single
- * param, with generation params and `abortSignal` under `config`. The
- * legacy `@google/generative-ai` two-arg `(params, {signal})` shape is no
- * longer accepted; pass a `GoogleGenAI` instance via `opts.sdk`.
- *
- * Maps Gemini `usageMetadata`:
- * - `promptTokenCount` minus `cachedContentTokenCount` → `input.regular`
- * - `cachedContentTokenCount`                          → `input.cacheRead`
- * - `candidatesTokenCount`                             → `output.regular`
- * - `thoughtsTokenCount`                               → `output.reasoning`
- * - `toolUsePromptTokenCount`                          → `input.toolUse`
- * - `promptTokensDetails[]`                            → `input.{image,audio,video}` per modality
- */
-
-interface GoogleAdapterOptions {
-    /** API key. Falls back to `process.env.GOOGLE_API_KEY` / `GEMINI_API_KEY` on Node. */
-    apiKey?: string;
-    model?: string;
-    baseURL?: string;
-    /** Extra headers on every request. */
-    headers?: Record<string, string>;
-    /**
-     * Optional `@google/genai` SDK instance (e.g. `new GoogleGenAI({apiKey})`).
-     * When omitted, the adapter uses the fetch-backed path against the
-     * Generative Language REST API.
-     */
-    sdk?: GoogleSdkLike;
-    fetchImpl?: typeof fetch;
-}
-/**
- * Duck-type matching the `@google/genai` (`GoogleGenAI`) SDK shape:
- * single-param `generateContent({ model, contents, config })` where
- * generation parameters and `abortSignal` live under `config`.
- *
- * The `@google/generative-ai` predecessor's two-arg `(params, {signal})`
- * shape is no longer accepted.
- */
-interface GoogleSdkLike {
-    models: {
-        generateContent(params: GoogleSdkRequestParams): Promise<GeminiResponse>;
-        generateContentStream?(params: GoogleSdkRequestParams): Promise<AsyncIterable<GeminiResponse>> | AsyncIterable<GeminiResponse>;
-    };
-}
-/** Single-param request shape consumed by `@google/genai`'s `models.generateContent`. */
-interface GoogleSdkRequestParams {
-    model: string;
-    contents: unknown;
-    config?: GoogleSdkRequestConfig;
-}
-/**
- * Generation config under the new SDK. `abortSignal` is the cancellation
- * channel — there is no second-arg `{signal}`.
- */
-interface GoogleSdkRequestConfig {
-    abortSignal?: AbortSignal;
-    temperature?: number;
-    maxOutputTokens?: number;
-    systemInstruction?: unknown;
-    tools?: unknown;
-    thinkingConfig?: unknown;
-    [extra: string]: unknown;
-}
-interface GeminiResponse {
-    candidates?: ReadonlyArray<{
-        content?: {
-            role?: string;
-            parts?: ReadonlyArray<{
-                text?: string;
-                thought?: boolean;
-                functionCall?: {
-                    name: string;
-                    args: Record<string, unknown>;
-                };
-            }>;
-        };
-        finishReason?: string;
-    }>;
-    usageMetadata?: GeminiUsage;
-    modelVersion?: string;
-}
-interface GeminiUsage {
-    promptTokenCount?: number;
-    candidatesTokenCount?: number;
-    totalTokenCount?: number;
-    thoughtsTokenCount?: number;
-    cachedContentTokenCount?: number;
-    toolUsePromptTokenCount?: number;
-    promptTokensDetails?: ReadonlyArray<{
-        modality: string;
-        tokenCount: number;
-    }>;
-    candidatesTokensDetails?: ReadonlyArray<{
-        modality: string;
-        tokenCount: number;
-    }>;
-    cacheTokensDetails?: ReadonlyArray<{
-        modality: string;
-        tokenCount: number;
-    }>;
-}
-declare function googleAdapter(opts?: GoogleAdapterOptions): LLMAdapter;
-
-/**
- * `frozenContext` — prefix-cache-friendly snapshot of upstream context.
- *
- * @module
- */
-
-type FrozenContextOptions = {
-    /**
-     * Reactive signal that triggers re-materialization. Each `DATA` emission
-     * from this node re-reads the source and refreshes the frozen value.
-     * Typical shapes: `fromTimer(ms)` for periodic refresh, a stage-transition
-     * node for event-driven refresh, or a manual `state<number>` the caller
-     * increments via `setState(n + 1)`.
-     *
-     * When omitted, the frozen value is materialized exactly once (on first
-     * subscribe) and never refreshes for the lifetime of the activation —
-     * use this for session-start snapshots that must stay stable. The
-     * single-shot latch IS reset on `INVALIDATE` (graph-wide flush via
-     * `graph.signal([[INVALIDATE]])`), so callers who need an "evict and
-     * re-materialize" escape hatch get one through the standard graph
-     * lifecycle without having to wire a `refreshTrigger`.
-     */
-    refreshTrigger?: NodeInput<unknown>;
-    name?: string;
-};
-/**
- * Freeze a reactive source into a stable snapshot that only re-materializes
- * on explicit trigger. Built for long-running harness loops where system
- * prompts include `agentMemory` / stage context — every reactive change to
- * the source invalidates the LLM provider's prefix cache, so re-rendering
- * the prompt every turn is expensive.
- *
- * `frozenContext(source)` reads the source once and caches the value;
- * downstream `promptNode` compositions see a stable reference until the
- * optional `refreshTrigger` fires.
- *
- * Trade-off: slightly stale context vs. prefix cache hit rate. For most
- * harness apps, the memory snapshot at session start is "good enough" —
- * refreshing on a coarse-grained trigger (`fromCron("*\/30min")`, stage
- * transition) preserves 90%+ prefix cache hits while keeping context useful.
- *
- * @example
- * ```ts
- * // Freeze agent memory for the duration of a stage.
- * const frozen = frozenContext(memory.context, {
- *   refreshTrigger: stage,  // re-materialize on stage change
- * });
- * const reply = promptNode({ context: frozen, ... });
- * ```
- *
- * @category patterns.ai
- */
-declare function frozenContext<T>(source: NodeInput<T>, opts?: FrozenContextOptions): Node<T | null>;
-
-/** Options accepted by {@link promptCall}, {@link llmExtractor}, and {@link llmConsolidator}. */
-type PromptCallOptions = {
-    adapter: LLMAdapter;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /**
-     * Optional name forwarded to the underlying `promptNode` (used as the
-     * `<name>::messages` / `<name>::call` / `<name>::output` path prefix).
-     * Defaults differ per call site so multiple `promptCall`s wired into the
-     * same graph don't collide on `prompt_node::output`.
-     */
-    name?: string;
-};
-/**
- * Build a one-shot LLM JSON-call factory: each invocation wraps `input` in a
- * fresh `state(input)`, delegates to `promptNode({format: "json"})`, and
- * returns a `NodeInput<TOut>` that the caller plugs into `distill` /
- * `agentLoop` / any reactive composition that accepts `NodeInput`.
- *
- * **Per-call lifecycle.** The returned `NodeInput<TOut>` is a producer that
- * emits exactly one `DATA` per upstream input (per Tier 1.2 Session C lock —
- * `promptNode` guarantees one DATA per wave). When the consumer's switchMap
- * supersedes it, the per-call `state(input)` and the inner `prompt_node::call`
- * tear down together.
- *
- * @param systemPrompt - System message sent on every call.
- * @param buildUserContent - Per-input user-content builder (must be JSON-stringifiable).
- * @param opts - Adapter + model/temperature/maxTokens + optional name prefix.
- * @param defaultName - Path-prefix fallback when `opts.name` is omitted.
- * @returns Factory `(input: TIn) => NodeInput<TOut>`.
- *
- * @category patterns
- */
-declare function promptCall<TIn, TOut>(systemPrompt: string, buildUserContent: (input: TIn) => string, opts: PromptCallOptions, defaultName: string): (input: TIn) => NodeInput<TOut>;
-/** Options accepted by {@link llmExtractor} and {@link llmConsolidator}. */
-type LLMExtractorOptions = PromptCallOptions & {
-    /**
-     * Cap the dedup-hint slice of `existingKeys` passed to the LLM. Larger
-     * stores ship more keys (better dedup recall) at the cost of prompt size.
-     * Default 100. Set to `Infinity` to forward every key.
-     */
-    maxExistingKeys?: number;
-};
-/** Alias for backward compatibility. */
-type LLMConsolidatorOptions = LLMExtractorOptions;
-/**
- * Returns an `extractFn` callback for `distill()` that invokes an LLM to
- * extract structured memories from raw input.
- *
- * The system prompt should instruct the LLM to return JSON matching
- * `Extraction<TMem>` shape: `{ upsert: [{ key, value }], remove?: [key] }`.
- *
- * Built on `promptNode({format: "json"})` — inherits markdown-fence stripping
- * and content-preview parse errors. Stack `withRetry` on the adapter for
- * transient-error tolerance (see `patterns/ai/adapters/middleware/retry.ts`).
- */
-declare function llmExtractor<TRaw, TMem>(systemPrompt: string, opts: LLMExtractorOptions): (raw: TRaw, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-/**
- * Returns a `consolidateFn` callback for `distill()` that invokes an LLM to
- * cluster and merge related memories.
- */
-declare function llmConsolidator<TMem>(systemPrompt: string, opts: LLMConsolidatorOptions): (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-
-/**
- * `promptNode` — universal LLM transform as a reactive derived node.
- *
- * The shape: `deps → messagesNode (derived) → switchMap → call (producer) → output`.
- * Each upstream wave is one LLM call; superseding waves cancel the in-flight
- * call via the abort signal threaded through `nodeSignal(opts.abort)`.
- *
- * The producer-shape on the inner is load-bearing: it emits exactly one DATA
- * + COMPLETE per wave, so the outer switchMap sees one DATA per wave (matches
- * the `HarnessExecutor` contract). A `derived([call], parse)` would have its
- * own first-run / push-on-subscribe semantics that can leak a transient null
- * before the real response arrives — observed and reverted in an earlier
- * attempt; see SESSION-ai-harness-module-review.md line 3654 for context.
- * Locked as path (b) producer-based by Session C (2026-04-27).
- *
- * **Retry / replay-cache.** Stack middleware on the adapter:
- *
- * ```ts
- * import { withRetry, withReplayCache } from "@graphrefly/graphrefly/patterns/ai";
- *
- * const adapter = withRetry(
- *   withReplayCache(baseAdapter, { keyFn: (ctx) => ctx.messages[0].content }),
- *   { count: 3, backoff: 200 },
- * );
- * const result = promptNode(adapter, [input], (q) => q);
- * ```
- *
- * `promptNode` no longer ships `retries` / `cache` options — they duplicated
- * middleware already at the adapter layer.
- *
- * **Cross-wave cache (COMPOSITION-GUIDE §32).** The switchMap output cache
- * survives across new outer DATAs — `promptNode`'s cached value persists
- * until the next wave fully resolves. Consumers that need to distinguish
- * "fresh value for THIS session" from "stale cache from a prior session"
- * (e.g. `agentLoop` resetting on new `run()`) must add a `state()` mirror
- * at their session boundary and depend on the mirror, not the `promptNode`
- * output directly. `promptNode` itself stays primitive — it does not
- * embed a state-mirror.
- *
- * @module
- */
-
-type PromptNodeOptions = {
-    name?: string;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /**
-     * Output format:
-     * - `"text"` (default) — emit the response content as a string.
-     * - `"json"` — `JSON.parse` the content (markdown fences stripped).
-     * - `"raw"` — emit the full {@link LLMResponse} object (subsumes the
-     *   pre-Tier-2.3 `fromLLM` shape; use this when you need `usage` /
-     *   `toolCalls` / `finishReason` alongside `content`).
-     */
-    format?: "text" | "json" | "raw";
-    /**
-     * Reactive tool definitions forwarded to the adapter. Pair with
-     * `format: "raw"` (or read `toolCalls` from a downstream parser) when
-     * tool-calling is in scope.
-     *
-     * **Reactive declared edge** (DF12, Tier 7): `tools` is a `Node` so the
-     * tools list participates in `describe()` topology and `explain()` causal
-     * chains. The tools Node is added to `messagesNode`'s declared deps —
-     * tools changes re-invoke the LLM (treated as a new call envelope).
-     * Wrap with `distinctUntilChanged` upstream if your tool selector emits
-     * noisy duplicates that would otherwise spam the adapter. See
-     * COMPOSITION-GUIDE §31 (Dynamic tool selection) for the canonical
-     * `toolSelector` pattern that produces this Node.
-     *
-     * **Activation note:** since `tools` is a real declared dep, `messagesNode`
-     * waits for the tools Node to DATA at least once before firing
-     * (push-on-subscribe SENTINEL gate). Pass a `state<ToolDefinition[]>([])`
-     * if you want immediate activation with no tools, or the latest published
-     * `toolSelector.tools` Node.
-     */
-    tools?: Node<readonly ToolDefinition[]>;
-    /**
-     * Optional system prompt. Forwarded via `opts.systemPrompt` to the adapter
-     * only — never pushed as a `{role:"system"}` message (avoiding the
-     * double-send class of bug where adapters that normalize both shapes end
-     * up with two system entries).
-     */
-    systemPrompt?: string;
-    /**
-     * Optional reactive abort signal. When the node emits `true`, the in-flight
-     * `adapter.invoke()` call is cancelled via `AbortController.abort()`.
-     * Threaded through `nodeSignal(abort)` — a one-shot bridge. Useful inside
-     * agent state machines where a separate `aborted` state should cancel the
-     * current LLM call without superseding via switchMap.
-     */
-    abort?: Node<boolean>;
-    meta?: Record<string, unknown>;
-};
-/**
- * Universal LLM transform: wraps a prompt template + model adapter into a reactive derived node.
- * Re-invokes the LLM whenever any dep changes. Suitable for triage, QA, hypothesis, parity, etc.
- *
- * **Topology** (visible in `describe()`):
- * ```
- * <deps...>, [tools?]  → <name>::messages   (derived, meta.ai = prompt_node)
- * <name>::messages     → <name>::output     (switchMap product, meta.ai = prompt_node::output)
- *   per-wave inner:    <name>::call         (producer, meta.ai = prompt_node::call)
- * ```
- * When `opts.tools` is supplied, the tools `Node` is appended to
- * `messagesNode`'s declared deps so it appears as a real edge in `describe()`
- * / `explain()` (DF12, Tier 7).
- *
- * **No-input semantics** (matches the codebase-wide SENTINEL convention):
- * - **Initial no-input** (no real input has ever arrived) — emits nothing.
- *   Outer cache stays `undefined`; `subscribe` consumers see no DATA event.
- *   Use this to keep downstream gating clean: a `withLatestFrom`-paired
- *   trigger won't fire until the LLM has actually produced something.
- * - **Mid-flow no-input** (input dropped to nullish after at least one
- *   real LLM call) — emits `null` as a domain "input went away" signal.
- *   Downstream consumers can distinguish "haven't started" from "input
- *   gone."
- *
- * **Retries / caching:** stack `withRetry` / `withReplayCache` middleware on the
- * `adapter` argument — `promptNode` no longer ships its own duplicated retry /
- * cache loops (pre-1.0 cleanup, see review session 1).
- *
- * @param adapter - LLM adapter (provider-agnostic). Wrap with `withRetry` /
- *                   `withReplayCache` middleware for transient-error tolerance
- *                   or replay caching.
- * @param deps - Input nodes whose values feed the prompt.
- * @param prompt - Static string or template function receiving dep values.
- * @param opts - Optional configuration.
- * @returns `Node` emitting LLM responses (string or parsed JSON).
- */
-declare function promptNode(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts: PromptNodeOptions & {
-    format: "raw";
-}): Node<LLMResponse | null>;
-declare function promptNode<T = string>(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: Omit<PromptNodeOptions, "format"> & {
-    format?: "text" | "json";
-}): Node<T | null>;
-
-/**
- * `streamingPromptNode` + `gatedStream` — streaming LLM transforms.
- *
- * **Wave A Unit 2 rewrite:**
- * - `StreamChunk` retired. The live stream surface is now `deltaTopic:
- *   TopicGraph<StreamDelta & {seq, ts}>` — every adapter delta (token,
- *   thinking, tool-call, usage, finish) is published in order. The previous
- *   shape retained the accumulated text per-chunk, producing O(N²) memory;
- *   the new shape stores only per-delta payloads (O(N)).
- * - New `accumulatedText: Node<string>` on the bundle — lazy-built via
- *   `ctx.store` over token-type deltas. Text-only extractors (`streamExtractor`,
- *   `keywordFlagExtractor`, `toolCallExtractor`) consume this node.
- * - `retainedLimit?: number` option exposed for the delta topic (no default —
- *   session scale is domain-specific per Unit 2 Q2).
- * - Unconditional `keepalive(output)` removed — callers subscribe as needed.
- * - System-prompt double-send fixed (matches promptNode Unit 1 fix).
- * - `format: "json"` throws on parse error with a content-preview diagnostic
- *   (parity with `promptNode`).
- * - Shared body between `streamingPromptNode` and `gatedStream` extracted
- *   into `streamingInvoke` per Unit 2 locked scope.
- *
- * @module
- */
-
-/**
- * A single delta published to the `deltaTopic`. Every adapter emission is
- * forwarded — not just token deltas — so consumers see the full event log
- * (thinking, tool-call-delta, usage, finish).
- */
-type StampedDelta = StreamDelta & {
-    /** Monotonic per-stream counter starting at 0. */
-    readonly seq: number;
-    /** Wall-clock nanoseconds at publish time (spec §5.11 central timer). */
-    readonly ts: number;
-};
-type StreamingPromptNodeOptions = {
-    name?: string;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /** Output format — `"json"` attempts JSON.parse on accumulated text. Throws on parse failure. Default: `"text"`. */
-    format?: "text" | "json";
-    systemPrompt?: string;
-    meta?: Record<string, unknown>;
-    /**
-     * Optional retention cap on the delta topic. Omit for unbounded retention
-     * (the topic grows until `dispose()`). Recommended values: `8_192` for
-     * single-shot 8K-token responses, `1_000_000` for persistent session
-     * topics, or explicit `dispose()` for worker-pool patterns.
-     */
-    retainedLimit?: number;
-};
-/**
- * Bundle returned by {@link streamingPromptNode}.
- */
-type StreamingPromptNodeHandle<T> = {
-    /** Final parsed result (emits once per invocation, after stream completes). */
-    output: Node<T | null>;
-    /** Live delta topic — every adapter delta in order, stamped with `seq` + `ts`. */
-    deltaTopic: TopicGraph<StampedDelta>;
-    /**
-     * Reactive accumulated-text view — lazy-built over `deltaTopic.latest`
-     * filtered on `type === "token"`. Text-only extractors compose on this.
-     * Emits the empty string before any token arrives.
-     */
-    accumulatedText: Node<string>;
-    /** Tear down the delta topic and release resources. */
-    dispose: () => void;
-};
-/**
- * Streaming LLM transform: wraps a prompt template + adapter into a reactive
- * streaming pipeline. Re-invokes the LLM whenever any dep changes; the
- * previous in-flight stream is canceled automatically via `switchMap`.
- *
- * Every adapter delta is published to `deltaTopic` stamped with `seq` + `ts`.
- * Text consumers subscribe to `accumulatedText` (auto-maintained). Delta-
- * specific consumers (`costMeterExtractor` on `usage` deltas) subscribe to
- * `deltaTopic` directly and filter by `delta.type`.
- *
- * The async boundary is handled by `fromAny(asyncGenerator)` (spec §5.10).
- */
-declare function streamingPromptNode<T = string>(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: StreamingPromptNodeOptions): StreamingPromptNodeHandle<T>;
-type GatedStreamOptions = StreamingPromptNodeOptions & {
-    /** Gate options (maxPending, startOpen). */
-    gate?: Omit<GateOptions, "meta">;
-};
-/**
- * Bundle returned by {@link gatedStream}.
- */
-type GatedStreamHandle<T> = {
-    /** Final parsed result (after gate approval). */
-    output: Node<T | null>;
-    /** Live delta topic — every adapter delta in order, stamped with `seq` + `ts`. */
-    deltaTopic: TopicGraph<StampedDelta>;
-    /** Reactive accumulated-text view. */
-    accumulatedText: Node<string>;
-    /**
-     * Gate controller — approve, reject (aborts in-flight stream), modify.
-     * The gate's DATA domain is `T` (not `T | null`): the pre-gate `filter`
-     * drops nulls, so the pending queue never holds a null. The controller's
-     * `node` output type stays `T | null` only because `gate.approve()` on an
-     * empty queue would surface `null` — callers should treat `null` as "no
-     * value" rather than as a modeled null signal.
-     */
-    gate: GateController<T>;
-    /** Tear down the delta topic + gate keepalive. */
-    dispose: () => void;
-};
-/**
- * Streaming LLM transform with human-in-the-loop gate integration.
- *
- * Composes {@link streamingPromptNode} with `gate` so that:
- * - `gate.reject()` discards the pending value **and** aborts the in-flight
- *   stream (toggles an internal cancel signal → switchMap restart → abort).
- * - `gate.modify()` transforms the pending value before forwarding downstream.
- * - `gate.approve()` forwards the final result as normal.
- *
- * Wave A Unit 2 defers full `gatedStream` review to Wave B Unit 17 (the
- * `gate()` primitive itself is reviewed there). This implementation retains
- * the existing gate API while adopting the Unit 2 delta-topic shape.
- */
-declare function gatedStream<T = string>(graph: Graph, name: string, adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: GatedStreamOptions): GatedStreamHandle<T>;
-
-/**
- * `systemPromptBuilder` — assembles a reactive system prompt from sections.
- *
- * @module
- */
-
-/**
- * Assembles a system prompt from reactive sections. Each section is a
- * `NodeInput<string>` — the prompt updates when any section changes.
- */
-type SystemPromptHandle = Node<string> & {
-    dispose: () => void;
-};
-declare function systemPromptBuilder(sections: readonly NodeInput<string>[], opts?: {
-    separator?: string;
-    name?: string;
-}): SystemPromptHandle;
-
-/**
- * Cost meter extractor — derives live cost readings from the delta topic.
- *
- * **Wave A Unit 3 rewrite:** signature takes `deltaTopic: TopicGraph<StampedDelta>`
- * instead of the old `TopicGraph<StreamChunk>`. The meter prefers real
- * `usage` deltas from the adapter; when no `usage` has been seen yet it
- * falls back to a char-based estimate over token deltas and stamps
- * `estimated: true` on the reading. Chunk count is the count of
- * token-type deltas seen (was `chunk.index + 1`).
- *
- * @module
- */
-
-/** A cost meter reading from the stream. */
-type CostMeterReading = {
-    readonly chunkCount: number;
-    readonly charCount: number;
-    readonly estimatedTokens: number;
-    /**
-     * `true` when no adapter `usage` delta has been observed yet —
-     * `estimatedTokens` is a char-based heuristic and should be treated as an
-     * approximation. Flips to `false` once a real `usage` delta arrives.
-     */
-    readonly estimated: boolean;
-};
-type CostMeterOptions = {
-    /** Characters per token approximation. Default: 4 (GPT-family). */
-    charsPerToken?: number;
-    name?: string;
-};
-/**
- * Mounts a cost meter on the delta topic. Prefers real `usage` deltas from
- * the provider; falls back to char-based estimation on token deltas alone
- * (with `meta.estimated: true` on the reading).
- *
- * Default structural equals suppresses DATA emission when two consecutive
- * readings are identical.
- */
-declare function costMeterExtractor(deltaTopic: TopicGraph<StampedDelta>, opts?: CostMeterOptions): Node<CostMeterReading>;
-
-/**
- * Keyword-flag extractor — scans accumulated stream text for configured patterns.
- * @module
- */
-
-/** A keyword match detected in the stream. */
-type KeywordFlag = {
-    readonly label: string;
-    readonly pattern: RegExp;
-    readonly match: string;
-    readonly position: number;
-};
-type KeywordFlagExtractorOptions = {
-    patterns: readonly {
-        pattern: RegExp;
-        label: string;
-    }[];
-    name?: string;
-    /**
-     * Maximum length of any pattern's literal text. Used as an overlap window
-     * when cursoring through the accumulated stream so matches that span
-     * chunk boundaries aren't missed. Default: 128.
-     */
-    maxPatternLength?: number;
-};
-/**
- * Mounts a keyword-flag extractor on accumulated text. Scans for all
- * configured patterns and emits an array of matches.
- *
- * **Wave A Unit 3 rewrite:** signature takes `accumulatedText: Node<string>`
- * instead of the old `TopicGraph<StreamChunk>`. Patterns are compiled once
- * at factory time (was per-chunk). `maxPatternLength` is validated at
- * factory time — any pattern whose source exceeds the window throws
- * immediately.
- *
- * Use cases: design invariant violations (`setTimeout`, `EventEmitter`), PII
- * detection (SSN, email, phone), toxicity keywords, off-track reasoning.
- *
- * **Streaming optimization.** Maintains a cursor across waves in `ctx.store`
- * so each emission scans only the delta region `accumulated.slice(scannedTo -
- * maxPatternLength)` — not the full string. Reactivation clears `ctx.store`
- * and resumes from offset 0 (COMPOSITION-GUIDE §20 RAM semantics).
- *
- * Default structural equals suppresses DATA emission when no new flags were
- * found this wave.
- */
-declare function keywordFlagExtractor(accumulatedText: Node<string>, opts: KeywordFlagExtractorOptions): Node<readonly KeywordFlag[]>;
-
-/**
- * Generic stream extractor — mounts an extract function on accumulated text.
- *
- * **Wave A Unit 3 rewrite:** signature changed from
- * `streamExtractor(topic: TopicGraph<StreamChunk>, fn)` to
- * `streamExtractor(accumulatedText: Node<string>, fn)`. The Unit 2 delta-
- * topic redesign removed the per-chunk `accumulated` field; callers pass
- * `streamingPromptNode(...).accumulatedText` (or any other `Node<string>`
- * source of accumulated text). Source-agnostic — the extractor doesn't care
- * whether the text came from an LLM, WebSocket, SSE tail, or file reader.
- *
- * @module
- */
-
-/**
- * Mounts an extractor function on a reactive accumulated-text source. Returns
- * a derived node that emits extracted values as the text grows.
- *
- * @param accumulatedText - Reactive `Node<string>` of accumulated text.
- * @param extractFn - `(accumulated: string) => T | null`.
- * @param opts - Optional name + structural equals.
- * @returns Derived node emitting extracted values.
- */
-declare function streamExtractor<T>(accumulatedText: Node<string>, extractFn: (accumulated: string) => T | null, opts?: {
-    name?: string;
-    /**
-     * Optional structural equals for the extractor output. When two
-     * consecutive chunks produce structurally-equal outputs, the framework
-     * emits `RESOLVED` instead of `DATA`, saving downstream work. Default:
-     * reference equality (`Object.is`). The library cannot know your
-     * output shape — supply this when your `extractFn` returns structured
-     * objects or arrays.
-     */
-    equals?: (a: T | null, b: T | null) => boolean;
-}): Node<T | null>;
-
-/**
- * Tool-call extractor — scans accumulated stream text for complete JSON tool call objects.
- * @module
- */
-
-/** A tool call detected in the stream. */
-type ExtractedToolCall = {
-    readonly name: string;
-    readonly arguments: Record<string, unknown>;
-    readonly raw: string;
-    readonly startIndex: number;
-};
-/**
- * Mounts a tool-call extractor on a streaming topic. Scans accumulated text
- * for complete JSON objects containing `"name"` and `"arguments"` keys (the
- * standard tool_call shape). Partial JSON is ignored until the closing brace.
- *
- * Feeds into the tool interception chain for reactive tool gating mid-stream.
- *
- * **Streaming optimization.** Maintains a cursor (`scanFrom`) in `ctx.store`
- * so each chunk resumes brace-scanning from the position after the last
- * complete parse (or the last incomplete open brace). Already-parsed objects
- * are not re-parsed. Default structural equals suppresses DATA emission when
- * no new tool call completed this chunk.
- */
-declare function toolCallExtractor(accumulatedText: Node<string>, opts?: {
-    name?: string;
-}): Node<readonly ExtractedToolCall[]>;
-
-/**
- * Content gate — classifies accumulated stream text as allow / review / block.
- * @module
- */
-
-/** Content safety decision. */
-type ContentDecision = "allow" | "block" | "review";
-/** Options for {@link contentGate}. */
-type ContentGateOptions = {
-    /**
-     * Hard-block threshold multiplier (default 1.5).
-     * Scores above `threshold * hardMultiplier` emit `"block"`.
-     * Scores between `threshold` and that emit `"review"`.
-     */
-    hardMultiplier?: number;
-    name?: string;
-};
-/**
- * Derived node that classifies accumulated stream text as `"allow"`,
- * `"review"`, or `"block"` based on a classifier score.
- *
- * **Wave A Unit 3 rewrite:** signature now takes `accumulatedText: Node<string>`
- * instead of a `TopicGraph<StreamChunk>` (the `StreamChunk` shape was retired
- * when the delta topic replaced the per-chunk accumulated-text shape).
- *
- * Emits a three-way decision on every text change:
- * - `"allow"` — score below `threshold`
- * - `"review"` — score in `[threshold, threshold × hardMultiplier)`
- * - `"block"` — score at or above `threshold × hardMultiplier`
- *
- * @param accumulatedText - Reactive accumulated-text source
- *                          (`streamingPromptNode(...).accumulatedText`).
- * @param classifier - `(accumulated: string) => number` scoring function, or
- *                     a `Node<number>` for live scores.
- * @param threshold - Score at which output becomes `"review"` or `"block"`.
- */
-declare function contentGate(accumulatedText: Node<string>, classifier: ((accumulated: string) => number) | Node<number>, threshold: number, opts?: ContentGateOptions): Node<ContentDecision>;
-
-/**
- * Redactor — stream extractor that replaces matched patterns in accumulated text.
- *
- * **Wave A Unit 3 rewrite:** signature now takes `accumulatedText: Node<string>`
- * instead of the retired `TopicGraph<StreamChunk>`. The output is a
- * `Node<string>` carrying the sanitized accumulated text — compose with
- * `contentGate` or downstream UI directly.
- *
- * @module
- */
-
-/** Options for {@link redactor}. */
-type RedactorOptions = {
-    name?: string;
-};
-/**
- * Derived node that replaces matched patterns in accumulated text.
- *
- * @param accumulatedText - Reactive accumulated-text source.
- * @param patterns - Array of RegExps to match against the text.
- * @param replaceFn - Replacement producer (default: always `"[REDACTED]"`).
- * @returns `Node<string>` emitting the sanitized accumulated text.
- */
-declare function redactor(accumulatedText: Node<string>, patterns: RegExp[], replaceFn?: (match: string, pattern: RegExp) => string, opts?: RedactorOptions): Node<string>;
-
-type ChatStreamOptions = {
-    graph?: GraphOptions;
-    maxMessages?: number;
-};
-declare class ChatStreamGraph extends Graph {
-    private readonly _log;
-    readonly messages: Node<readonly ChatMessage[]>;
-    readonly latest: Node<ChatMessage | null>;
-    readonly messageCount: Node<number>;
-    constructor(name: string, opts?: ChatStreamOptions);
-    append(role: ChatMessage["role"], content: string, extra?: Partial<ChatMessage>): void;
-    appendToolResult(callId: string, content: string): void;
-    clear(): void;
-    allMessages(): readonly ChatMessage[];
-}
-declare function chatStream(name: string, opts?: ChatStreamOptions): ChatStreamGraph;
-
-/**
- * Options for {@link handoff}.
- */
-type HandoffOptions = {
-    /**
-     * Reactive gate: when this node's value is `true`, output flows from
-     * `from` to the `to` specialist; when `false`, `from`'s output flows
-     * through unchanged and `to` stays dormant. Omit to always hand off —
-     * useful when `from` is itself a router whose output shape already
-     * encodes routing intent.
-     */
-    condition?: NodeInput<boolean>;
-    name?: string;
-};
-/**
- * Multi-agent handoff recipe — route `from`'s output into a specialist
- * agent `toFactory` when `condition` is open. Thin composition over
- * `switchMap` + gate; not a new primitive, just a named shape.
- *
- * The "handoff" pattern (popularized by the OpenAI Agents SDK) covers two
- * idioms:
- *
- * 1. **Full handoff** — a triage agent routes the conversation to a
- *    specialist, and the specialist becomes the active agent for the rest
- *    of the turn. Accumulated context (memory, tool definitions) can travel
- *    along by threading the same `agentMemory` bundle into both.
- * 2. **Agents-as-tools** — the manager keeps control and calls the
- *    specialist like a tool for a bounded subtask. Build this by registering
- *    a `promptNode` instance as a `ToolDefinition` on the parent via
- *    `toolRegistry`.
- *
- * This sugar covers (1) — a reactive route from one agent's output into a
- * specialist factory. For (2) wire a tool registry manually; the pattern is
- * additive with this one.
- *
- * @example Full handoff on a triage signal.
- * ```ts
- * import { handoff, promptNode } from "@graphrefly/graphrefly/patterns/ai";
- *
- * const triage = promptNode(adapter, [userMessage], (msg) =>
- *   `Classify urgency of: ${msg}. Reply "high" or "normal".`);
- * const isUrgent = derived([triage], ([v]) => v === "high");
- *
- * const specialist = handoff(
- *   userMessage,
- *   (input) => promptNode(specialistAdapter, [input], (m) => `Respond urgently: ${m}`),
- *   { condition: isUrgent },
- * );
- * ```
- *
- * @param from - Source node whose value is threaded into the specialist.
- * @param toFactory - Factory that takes `from` (as a reactive source) and
- *   returns the specialist node. Called once, lazily, when the first
- *   subscriber activates.
- * @param opts - Optional reactive `condition` gate + name.
- * @returns Node emitting the specialist's output when the gate is open, or
- *   `from`'s value when the gate is closed. Null when `from` is null.
- *
- * **Performance caveat (Wave A Unit 5):** the specialist is mounted per
- * source emission — each `v != null` DATA on `from` allocates a fresh
- * `state<T>(v)` + invokes `toFactory`, and switchMap cancels the prior
- * branch. For per-turn routing (≤1 emit/sec) this is negligible. For
- * high-frequency sources (per-token routing, tight event loops), batch
- * upstream (e.g. via `audit`, `throttle`, or `distinctUntilChanged`) before
- * handing off — each mount/unmount cycle spins up full subgraphs
- * (`messagesNode` + adapter bridge + output for a `promptNode` specialist).
- *
- * @category patterns.ai
- */
-declare function handoff<T>(from: NodeInput<T | null>, toFactory: (input: Node<T>) => Node<T | null>, opts?: HandoffOptions): Node<T | null>;
-
-type ToolRegistryOptions = {
-    graph?: GraphOptions;
-};
-/**
- * `ToolRegistryGraph` — name-keyed registry of {@link ToolDefinition}s.
- *
- * **Reactive-only execution.** The only execution path is
- * {@link executeReactive}, which returns a `Node<unknown>` for the handler
- * result. Composing factories (`toolExecution`, `agentLoop`) consume it
- * directly inside `retrySource` / `switchMap` chains. There is intentionally
- * no imperative `execute()` Promise method — the registry was originally a
- * dual-boundary class (imperative + reactive) and the imperative path was
- * the only thing in the codebase bridging through `Promise.resolve().then()`
- * to feed `fromAny`. Removing it left every consumer on a single
- * reactive-all-the-way path with real abort propagation.
- *
- * For non-reactive callers (debug scripts, one-shot tests), bridge with
- * `awaitSettled(toolRegistry.executeReactive(name, args))`.
- *
- * **Wave A Unit 6 refactor:** internal storage migrated from `state<Map>`
- * (O(N) Map-copy per mutation) to `ReactiveMapBundle<string, ToolDefinition>`
- * (O(1) mutations + version counter).
- */
-declare class ToolRegistryGraph extends Graph {
-    readonly definitions: Node<ReadonlyMap<string, ToolDefinition>>;
-    readonly schemas: Node<readonly ToolDefinition[]>;
-    private readonly _bundle;
-    constructor(name: string, opts?: ToolRegistryOptions);
-    register(tool: ToolDefinition): void;
-    unregister(name: string): void;
-    /**
-     * Reactive execution — returns a `Node<unknown>` that emits the handler
-     * result. The returned node is a `producer` that:
-     *
-     * 1. Mints a per-call `AbortController` whose `signal` is threaded into
-     *    the handler call AND into `fromAny` (so a `fromPromise` /
-     *    `fromAsyncIter` inner abandons cleanly when the consumer
-     *    unsubscribes).
-     * 2. Runs `tool.handler(args, {signal})` inside a try/catch — a
-     *    synchronous throw surfaces as `[[ERROR, err]]` downstream instead
-     *    of escaping the producer.
-     * 3. Forwards every message from the inner `fromAny` chain to the
-     *    producer's outputs.
-     * 4. On teardown (subscriber count drops to zero, e.g. `switchMap`
-     *    supersede) calls `ac.abort()` and unsubscribes the inner.
-     *    Signal-aware handlers (e.g. `fetch(url, {signal})`) actually stop.
-     *
-     * Each call mints a fresh node tied to a fresh `handler(args, ...)`
-     * invocation — call `executeReactive` again for repeated invocations.
-     *
-     * @throws `Error` synchronously when `name` is not registered (no node is
-     *   constructed — the caller gets a pre-wiring failure rather than a
-     *   silent ERROR wave on an empty graph).
-     */
-    executeReactive(name: string, args: Record<string, unknown>): Node<unknown>;
-    getDefinition(name: string): ToolDefinition | undefined;
-}
-declare function toolRegistry(name: string, opts?: ToolRegistryOptions): ToolRegistryGraph;
-
-/**
- * `toolExecution` — reactive per-tool-call executor with retry + rescue.
- *
- * Lifted from the inlined `executeToolReactively` helper inside `agent-loop.ts`
- * so it can be consumed standalone by any caller with a reactive `toolCalls`
- * batch — not just `agentLoop`. The shape is: one input `Node<readonly
- * ToolCall[]>` + a `ToolRegistryGraph` → one output `Node<readonly
- * ToolResult[]>`. Each call maps to a per-call `retrySource(executeReactive)`
- * → optional `rescue` chain that emits the handler result on success, or a
- * JSON-wrapped `{ error }` payload on terminal failure so the LLM can see the
- * error as tool output and decide whether to try again via another tool call.
- *
- * **Cancellation.** `executeReactive` mints a per-call `AbortController` and
- * threads its signal into the handler call. When `switchMap` supersedes the
- * inner (a fresh `toolCalls` batch arrives) or the outer graph tears down,
- * the per-call node unsubscribes and `ac.abort()` fires. Signal-aware
- * handlers (`fetch(url, {signal})`, child-process kill, DB cancel) actually
- * stop in-flight work; handlers that ignore the signal still complete to
- * their original termination, but their result is discarded.
- *
- * @module
- */
-
-/** A single tool execution outcome: `{id, content}` where content is a JSON string. */
-interface ToolResult {
-    readonly id: string;
-    readonly content: string;
-}
-type ToolExecutionOptions = {
-    /**
-     * Reactive tool-call batch. Each non-empty emission triggers a fresh
-     * per-call execution fan-out; superseding emissions cancel the prior fan.
-     */
-    toolCalls: Node<readonly ToolCall[]>;
-    /** Registry that resolves tool name → handler. */
-    tools: ToolRegistryGraph;
-    /**
-     * Retry count per individual tool call. `retrySource({count: N})` retries
-     * up to N times on error (N retries = N+1 total attempts). Default: 1.
-     */
-    retryCount?: number;
-    /**
-     * How to surface a terminal error after retries are exhausted.
-     * - `"rescue"` (default): emit `{id, content: JSON.stringify({error})}`
-     *   so the LLM sees the failure as structured tool output and can decide
-     *   how to react. Sibling calls in the same batch continue to their own
-     *   completion; one call's failure does not affect the others.
-     * - `"propagate"`: let the ERROR propagate downstream. **Blast radius:**
-     *   the per-batch `derived` join auto-errors when any per-call node
-     *   terminates with ERROR, so one call's failure discards every sibling's
-     *   DATA (even ones that already settled with a valid ToolResult). Use
-     *   `"propagate"` only when a single tool failure should be fatal for the
-     *   whole batch; prefer `"rescue"` when you want the LLM to see partial
-     *   results plus per-call error markers.
-     */
-    onError?: "rescue" | "propagate";
-};
-/**
- * Reactive executor for a batch of LLM tool calls.
- *
- * Each DATA emission on `toolCalls` dispatches a fresh per-call fan-out: for
- * every call in the batch, construct a `retrySource(fromAny(tools.execute(
- * name, args)))` node, optionally `rescue` it into a JSON error shape, and
- * join the results via a `derived` whose first-run gate waits for every call
- * to settle before emitting the batch. Empty batches (`calls.length === 0`)
- * are a caller-side invariant violation (the upstream gate should emit
- * RESOLVED for empty batches, not DATA) and trigger a loud error — callers
- * that want to accept empty batches should upstream-filter them first.
- *
- * Reference-equality + content-equality dedup is applied to the output batch
- * so duplicate re-emissions from a completing retrySource don't propagate.
- *
- * @param opts - `{ toolCalls, tools, retryCount?, onError? }`.
- * @returns `Node<readonly ToolResult[]>` — one ToolResult per input ToolCall.
- */
-declare function toolExecution(opts: ToolExecutionOptions): Node<readonly ToolResult[]>;
-
-/**
- * Options for {@link toolSelector}.
- */
-interface ToolSelectorOptions {
-    readonly name?: string;
-}
-/**
- * Reactive tool availability (COMPOSITION-GUIDE §31). Given a base tool set
- * (reactive or static) and one or more reactive predicates, emit the filtered
- * subset of tools currently allowed. Feeds into `promptNode({ tools: Node<...> })`
- * so the LLM sees a reactive menu instead of a frozen config.
- *
- * Each predicate is a `NodeInput<(tool) => boolean>`. A tool is included iff
- * **every** predicate returns `true`. When any predicate value is `null` /
- * `undefined` (e.g. upstream not yet ready) that predicate is treated as a
- * pass-through — the tool isn't excluded on its basis. Predicate updates
- * recompute the selected set.
- *
- * Pairs with `toolInterceptor` (§D9 / §31): **selection** controls what's
- * offered to the LLM (pre-generation UX); **interception** gates what's
- * executed after the LLM chooses (post-generation security). Tool selection
- * is NOT a security boundary — an LLM can hallucinate tool calls outside
- * its offered set; always pair with `toolInterceptor` for enforcement.
- *
- * @example
- * ```ts
- * const hasBudget = derived([costMeter], (c) => c.total < BUDGET);
- * const canDestroy = state(false, { name: "destructive-allowed" });
- * const tools = toolSelector(registry.schemas, [
- *   derived([hasBudget], (b) => (t) => !t.meta?.expensive || b === true),
- *   derived([canDestroy], (c) => (t) => !t.meta?.destructive || c === true),
- * ]);
- * const agent = promptNode(graph, "agent", { ..., tools });
- * ```
- */
-declare function toolSelector(allTools: NodeInput<readonly ToolDefinition[]>, constraints: readonly NodeInput<(tool: ToolDefinition) => boolean>[], opts?: ToolSelectorOptions): Node<readonly ToolDefinition[]>;
-
-/** Generic per-dimension thresholds. Any dim below its threshold → reject. */
-type AdmissionThresholds<Dims extends string> = Partial<Record<Dims, number>>;
-type AdmissionScoredOptions<Dims extends string, TRaw = unknown> = {
-    /** Score function — must return a finite number for every dimension named in `thresholds`. */
-    scoreFn: (raw: TRaw) => Readonly<Record<Dims, number>>;
-    /** Per-dim minimums. Dims absent here are scored but not gated. */
-    thresholds?: AdmissionThresholds<Dims>;
-};
-/**
- * Generic N-dimension admission filter. Rejects any input where one of the
- * configured threshold dimensions scores below its minimum. Missing scores
- * (`undefined` / `null`) AND non-finite values (`NaN`, `±Infinity`) are
- * treated as below all thresholds — reject by default rather than admit.
- *
- * @example
- * ```ts
- * const filter = admissionScored({
- *   scoreFn: (raw: Note) => ({ relevance: scoreRelevance(raw), age: ageScore(raw) }),
- *   thresholds: { relevance: 0.4 },  // age scored but ungated
- * });
- * ```
- */
-declare function admissionScored<Dims extends string, TRaw = unknown>(opts: AdmissionScoredOptions<Dims, TRaw>): (raw: TRaw) => boolean;
-/** Scores for the three admission dimensions. Each 0–1. */
-type AdmissionScores = {
-    readonly persistence: number;
-    readonly structure: number;
-    readonly personalValue: number;
-};
-type AdmissionScore3DOptions = {
-    /** Custom scoring function. Required — the previous always-0.5 default was misleading. */
-    scoreFn: (raw: unknown) => AdmissionScores;
-    /** Minimum persistence score to admit (default 0.3). */
-    persistenceThreshold?: number;
-    /** Minimum personalValue score to admit (default 0.3). */
-    personalValueThreshold?: number;
-    /** Require structure score > 0 to admit (default false). */
-    requireStructured?: boolean;
-};
-/**
- * 3D admission sugar — the persistence / structure / personalValue triple
- * commonly used in agent-memory literature. Composes `admissionScored`
- * with thresholds derived from the option fields. Use directly when those
- * three named dimensions match your domain, or use `admissionScored` with
- * an arbitrary dimension set instead.
- *
- * `requireStructured: true` rejects entries where `structure <= 0` (matches
- * the pre-Unit-8 `requireStructured && scores.structure <= 0` check).
- * Implemented as a final-step predicate around `admissionScored` rather
- * than a `Number.MIN_VALUE` threshold, which would have been a footgun for
- * future readers.
- */
-declare function admissionFilter3D(opts: AdmissionScore3DOptions): (raw: unknown) => boolean;
-
-type RetrievalQuery = {
-    readonly text?: string;
-    readonly vector?: readonly number[];
-    readonly entityIds?: readonly string[];
-    /**
-     * Optional hierarchical context breadcrumb — e.g.
-     * `["projects", "auth", "tokens"]`. When both the query and a candidate
-     * entry supply a `context`, the retrieval pipeline applies a score boost
-     * proportional to `contextWeight` for entries whose context overlaps
-     * (shared prefix). Entries or queries without `context` are scored
-     * flatly (backward-compatible).
-     */
-    readonly context?: readonly string[];
-};
-type RetrievalPipelineOptions<TMem> = {
-    /** Max candidates from vector search (default 20). */
-    topK?: number;
-    /** KG expansion depth in hops (default 1). */
-    graphDepth?: number;
-    /** Token budget for final packing (default 2000). */
-    budget?: number;
-    /** Cost function for budget packing. */
-    cost: (mem: TMem) => number;
-    /** Score function for ranking. */
-    score: (mem: TMem, context: unknown) => number;
-    /**
-     * Optional accessor: extracts the hierarchical context breadcrumb from a
-     * memory entry. Used with {@link RetrievalQuery.context} and
-     * `contextWeight` to boost entries whose context overlaps the query.
-     * Entries that don't expose context stay at flat behavior.
-     */
-    contextOf?: (mem: TMem) => readonly string[] | undefined;
-    /**
-     * Boost multiplier applied to a candidate's score when its `context`
-     * shares a prefix with the query's `context`. Score is multiplied by
-     * `(1 + contextWeight * sharedDepth / queryDepth)`. Default: 0 (no
-     * context boost).
-     */
-    contextWeight?: number;
-};
-/** A single entry in the retrieval result, with causal trace metadata. */
-type RetrievalEntry<TMem> = {
-    readonly key: string;
-    readonly value: TMem;
-    readonly score: number;
-    readonly sources: ReadonlyArray<"vector" | "graph" | "store">;
-    /**
-     * Hierarchical context breadcrumb for this entry, when
-     * `RetrievalPipelineOptions.contextOf` is supplied and returns a value.
-     */
-    readonly context?: readonly string[];
-};
-/** Causal trace for a retrieval run. */
-type RetrievalTrace<TMem> = {
-    readonly vectorCandidates: ReadonlyArray<VectorSearchResult<TMem>>;
-    readonly graphExpanded: ReadonlyArray<string>;
-    readonly ranked: ReadonlyArray<RetrievalEntry<TMem>>;
-    readonly packed: ReadonlyArray<RetrievalEntry<TMem>>;
-};
-
-type MemoryTier = "permanent" | "active" | "archived";
-type MemoryTiersOptions<TMem> = {
-    /** Exponential decay rate per second for active tier.
-     *  Default: 7-day half-life ≈ ln(2)/(7×86400) ≈ 0.00000114. */
-    decayRate?: number;
-    /** Max entries in the active tier before archiving lowest-scored (default 1000). */
-    maxActive?: number;
-    /** Score threshold below which active entries get archived (default 0.1). */
-    archiveThreshold?: number;
-    /** Predicate: true → entry belongs in permanent tier (default: never). */
-    permanentFilter?: (key: string, mem: TMem) => boolean;
-    /** Storage tier for the archive. Omit to disable archiving. */
-    archiveTier?: SnapshotStorageTier<GraphCheckpointRecord>;
-    /** Options forwarded to `graph.attachSnapshotStorage` for the archive tier. */
-    archiveStorageOptions?: GraphAttachStorageOptions;
-};
-
-type MemoryTiersBundle<TMem> = {
-    /**
-     * Permanent tier: never evicted. Backed by a `collection({ranked:false})`
-     * Graph (Tier 2.3 — was previously a `LightCollectionBundle`; the no-Graph
-     * bundle shape was folded into the unified `CollectionGraph`).
-     */
-    readonly permanent: CollectionGraph<TMem>;
-    /** Active entries node (reactive, holds ReadonlyMap). */
-    readonly activeEntries: Node<unknown>;
-    /** Archive storage handle (null if no tier configured). */
-    readonly archiveHandle: StorageHandle | null;
-    /** Classify a key into its current tier. */
-    tierOf: (key: string) => MemoryTier;
-    /** Move a key to the permanent tier. */
-    markPermanent: (key: string, value: TMem) => void;
-};
-
-type MemoryWithVectorsOptions<TMem> = {
-    /** Embedding dimension. Must match the `embedFn` output length. */
-    dimension: number;
-    /** Extract an embedding vector for a memory entry. */
-    embedFn: (mem: TMem) => readonly number[] | undefined;
-};
-/**
- * Attach a vector index to a `DistillBundle`. Indexes every entry in the
- * store as it changes. Returns the `VectorIndexGraph` so retrieval can read
- * its `entries` and call `search()`.
- *
- * The indexer's keepalive is registered with `graph.addDisposer` so it tears
- * down on `graph.destroy()`. The returned `dispose()` is also available for
- * early release without destroying the parent graph.
- */
-declare function memoryWithVectors<TMem>(graph: Graph, store: DistillBundle<TMem>, opts: MemoryWithVectorsOptions<TMem>): {
-    vectors: VectorIndexGraph<TMem>;
-    dispose: () => void;
-};
-type MemoryWithKGOptions<TMem> = {
-    /**
-     * Mount path for the KG subgraph on the parent graph. Defaults to `name`.
-     * Pass a different value when the parent graph reserves a stable mount
-     * path (e.g. `agentMemory` mounts at `"kg"` regardless of outer name).
-     */
-    mountPath?: string;
-    /**
-     * Extract entities + relations for a memory entry. Omit to mount an empty
-     * KG without an indexer effect — caller upserts entities / relations
-     * directly on the returned `kg` handle.
-     */
-    entityFn?: (key: string, mem: TMem) => {
-        entities?: Array<{
-            id: string;
-            value: unknown;
-        }>;
-        relations?: Array<{
-            from: string;
-            to: string;
-            relation: string;
-            weight?: number;
-        }>;
-    } | undefined;
-};
-/**
- * Attach a knowledge graph alongside a `DistillBundle`. Inner graph is named
- * `${name}-kg`; mount path defaults to `name` but can be overridden via
- * `opts.mountPath` so a parent factory (e.g. `agentMemory`) can keep a stable
- * mount path independent of the inner graph's identity.
- *
- * If `opts.entityFn` is omitted, no indexer effect is wired — the empty KG is
- * mounted for manual `upsertEntity` / `link` use.
- *
- * Indexer keepalive (when present) is registered with `graph.addDisposer`;
- * explicit `dispose()` is also available.
- */
-declare function memoryWithKG<TMem>(graph: Graph, store: DistillBundle<TMem>, name: string, opts: MemoryWithKGOptions<TMem>): {
-    kg: KnowledgeGraph<unknown, string>;
-    dispose: () => void;
-};
-/**
- * Full options for {@link memoryWithTiers} (Tier 4.1 B + 4.3 B refactor,
- * 2026-04-29). Combines tier-policy options with the distill-side options
- * needed to construct the underlying store — `memoryWithTiers` is now the
- * **construction site** for the distill bundle so it can wire
- * `reactiveMap.retention` into the store at construction (eliminating the
- * §7 feedback cycle the previous `tierClassifier` effect carried).
- *
- * The retention config built internally maps tier policy to the substrate:
- * - `archiveThreshold` → `retention.archiveThreshold`
- * - `maxActive` → `retention.maxSize`
- * - per-entry `decay(score(mem, ctx), age, decayRate)` → `retention.score`
- *   (capturing `latestCtx` + `entryCreatedAtNs` via closure-mirror; permanent
- *   entries score `Infinity` to bypass eviction).
- */
-type MemoryWithTiersOptions<TMem> = MemoryTiersOptions<TMem> & Omit<DistillOptions<TMem>, "mapOptions" | "score" | "context"> & {
-    /** Score function — same signature as `agentMemory.score`. */
-    score: (mem: TMem, context: unknown) => number;
-    /** Optional reactive context node (passed to `score`). */
-    context?: NodeInput<unknown>;
-};
-/**
- * Attach 3-tier storage (active / archived / permanent) to a fresh distill
- * store, wiring `reactiveMap.retention` at construction so archival happens
- * synchronously inside the substrate's mutation pipeline (no §7 feedback
- * cycle). Promotes `permanentKeys` and `entryCreatedAtNs` to reactive maps
- * mounted on the graph (Tier 4.3 B — Unit 7 Q3) so `describe()`/`explain()`
- * can walk to "why was X archived?".
- *
- * **API shape** (Tier 4.1 B, 2026-04-29 — breaking change vs. pre-refactor):
- * `memoryWithTiers` constructs the distill bundle internally rather than
- * accepting a pre-built one. Callers pass `(graph, source, extractFn,
- * opts)`. The bundle is exposed as `result.store` for downstream composers
- * (vectors / KG / retrieval).
- *
- * - `permanentFilter`-matching entries score `Infinity` in retention →
- *   never archived. Independent permanent-promotion effect upserts them
- *   into the `permanent` collection.
- * - Below-threshold entries → retention archives synchronously.
- * - Over-`maxActive` entries → retention's `maxSize` evicts lowest-scored.
- */
-declare function memoryWithTiers<TRaw, TMem>(graph: Graph, source: NodeInput<TRaw>, extractFn: (raw: Node<TRaw>, existing: Node<ReadonlyMap<string, TMem>>) => NodeInput<Extraction<TMem>>, opts: MemoryWithTiersOptions<TMem>): {
-    store: DistillBundle<TMem>;
-    tiers: MemoryTiersBundle<TMem>;
-    dispose: () => void;
-};
-type MemoryRetrievalOptions<TMem> = {
-    /** Score function (same shape as `agentMemory.score`). */
-    score: (mem: TMem, context: unknown) => number;
-    /** Cost function for budget packing. */
-    cost: (mem: TMem) => number;
-    /** Token / cost budget. Default 2000. */
-    budget?: number;
-    /** Top-K vector candidates. Default 20. */
-    topK?: number;
-    /** KG expansion depth in hops. Default 1. */
-    graphDepth?: number;
-    /** Hierarchical-context boost weight. Default 0. */
-    contextWeight?: number;
-    /** Hierarchical-context accessor for entries. */
-    contextOf?: (mem: TMem) => readonly string[] | undefined;
-    /** Optional reactive context node (passed to `score`). */
-    context?: NodeInput<unknown>;
-};
-type MemoryRetrievalBundle<TMem> = {
-    /** State node mirroring the latest packed retrieval result. */
-    readonly retrieval: Node<ReadonlyArray<RetrievalEntry<TMem>>>;
-    /** State node mirroring the latest retrieval trace. */
-    readonly retrievalTrace: Node<RetrievalTrace<TMem> | null>;
-    /** Imperative consumer API — synchronous; reads cache at call time. */
-    readonly retrieve: (query: RetrievalQuery) => ReadonlyArray<RetrievalEntry<TMem>>;
-    /** Reactive sibling — chain into the graph. Mirrors observability state. */
-    readonly retrieveReactive: (queryInput: NodeInput<RetrievalQuery | null>) => Node<ReadonlyArray<RetrievalEntry<TMem>>>;
-};
-/**
- * Build the retrieval pipeline (vector + KG + budget packing) over a
- * `DistillBundle` and optional `vectors` / `kg` bundles.
- *
- * Both consumer surfaces (`retrieve`, `retrieveReactive`) write to the same
- * `retrieval` + `retrievalTrace` state nodes — observers subscribed to those
- * see ALL queries regardless of which API issued them.
- */
-declare function memoryRetrieval<TMem>(graph: Graph, store: DistillBundle<TMem>, vectors: VectorIndexGraph<TMem> | null, kg: KnowledgeGraph<unknown, string> | null, opts: MemoryRetrievalOptions<TMem>): MemoryRetrievalBundle<TMem>;
-
-/**
- * Reactive agent loop — autonomous multi-turn LLM agent with tool execution.
- */
-type AgentLoopStatus = "idle" | "thinking" | "acting" | "done" | "error";
-
-type AgentLoopOptions = {
-    graph?: GraphOptions;
-    adapter: LLMAdapter;
-    tools?: readonly ToolDefinition[];
-    systemPrompt?: string;
-    maxTurns?: number;
-    stopWhen?: (response: LLMResponse) => boolean;
-    onToolCall?: (call: ToolCall) => void;
-    maxMessages?: number;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /**
-     * Reactive tool-call splice (COMPOSITION-GUIDE §31 "interception is security").
-     * When set, the raw `toolCalls` node is piped through this transform before
-     * reaching the executor. The transform is a pure reactive composition —
-     * `(calls: Node<readonly ToolCall[]>) => Node<readonly ToolCall[]>` — so the
-     * gate is visible in `describe()` / `explain()` as a real edge (no hidden
-     * imperative wraps; §24).
-     *
-     * Typical uses:
-     * - **Filter / block** — `derived([calls, policy], ([raw, p]) => raw.filter(p))`
-     * - **Throttle / debounce** — `throttle(calls, windowMs)`
-     * - **Human-in-the-loop approval** — pipe through a `gate` controller so
-     *   calls wait for human approval before reaching the executor.
-     *
-     * The public `agent.toolCalls` node surfaces the POST-intercept stream, so
-     * audit / telemetry consumers see what the executor actually runs. The raw
-     * pre-intercept stream is not exposed — tests that need it should run
-     * without `interceptToolCalls` set (the identity case).
-     */
-    interceptToolCalls?: (calls: Node<readonly ToolCall[]>) => Node<readonly ToolCall[]>;
-};
-/**
- * Reactive agent loop.
- *
- * The loop is a reactive state machine wired entirely from graph primitives:
- * `chat.messages` + `tools.schemas` + gating state feed a `promptInput`
- * derived; `switchMap` turns non-null inputs into an LLM invocation via
- * `fromAny(adapter.invoke(...))`. The LLM response drives chat writes and
- * status transitions via effects. Tool calls flow through a reactive
- * executor (`retrySource` + `rescue`) that retries once on error and
- * surfaces terminal errors as JSON-shaped `ToolResult` payloads for the
- * LLM to react to.
- *
- * **No imperative control flow inside the reactive layer** (spec §5.8-5.12):
- * no `while` loops, no manual `await adapter.invoke`, no polling.
- * `agent.run()` is a thin `awaitSettled` bridge so callers can still `await`
- * the loop if they want a Promise.
- *
- * Public surface:
- * - `chat` / `tools` — subgraphs (imperative `append` at boundary, reactive `executeReactive` for tool invocation)
- * - `status` / `turn` / `aborted` — state nodes with explicit initials
- * - `lastResponse` / `toolCalls` / `toolResults` — reactive outputs (SENTINEL until first emission; callers use `awaitSettled` / `subscribe`)
- * - `run(userMessage?, signal?)` — optional user append + Promise bridge
- * - `abort()` — imperative abort shim; flips `aborted` state
- *
- * **Lifecycle: single-mount.** `AgentLoopGraph` instances expect to be
- * constructed once and used until `destroy()`. The internal closure mirrors
- * (`latestTurn` / `latestAborted` / `latestStatus` / `latestMessages` /
- * `latestSchemas`) are wired by subscribe-and-capture at construction time;
- * their corresponding `addDisposer`-registered subscriptions are torn down
- * on subgraph unmount or `destroy()`. After teardown the mirrors freeze at
- * their last value, so re-using a destroyed instance — calling `run()`
- * again, or remounting under a new parent — would silently feed stale
- * mirror data into `promptInput`. If you need to "reset" an agent, build a
- * fresh `AgentLoopGraph` instance instead of recycling.
- */
-declare class AgentLoopGraph extends Graph {
-    readonly chat: ChatStreamGraph;
-    readonly tools: ToolRegistryGraph;
-    /** Current agent status. `initial: "idle"` — always has a real value. */
-    readonly status: Node<AgentLoopStatus>;
-    /** Turn count (completed LLM invocations this run). `initial: 0`. */
-    readonly turn: Node<number>;
-    /** Aborted flag; flipped by `abort()` or external `AbortSignal`. `initial: false`. */
-    readonly aborted: Node<boolean>;
-    /**
-     * Most recent LLM response. State-backed mirror driven by the response
-     * effect. `initial: null` — subscribers can read the cache synchronously;
-     * `awaitSettled(lastResponse)` or `firstWhere(lastResponse, v => v != null)`
-     * bridges to the first non-null value as a Promise.
-     */
-    readonly lastResponse: Node<LLMResponse | null>;
-    /** Tool-call batch emitted by the most recent LLM response. SENTINEL. */
-    readonly toolCalls: Node<readonly ToolCall[]>;
-    /** Tool-result batch (one entry per call) after reactive execution. SENTINEL. */
-    readonly toolResults: Node<readonly ToolResult[]>;
-    private readonly _terminalResult;
-    private readonly _disposeRunWiring;
-    /** Guards against overlapping `run()` calls. */
-    private _running;
-    /**
-     * Abort controller for the currently-running `adapter.invoke`. Minted per
-     * switchMap project; aborted when the reactive `aborted` node flips true
-     * OR when the caller's external `AbortSignal` fires. Threaded into
-     * `adapter.invoke({ signal })` AND `fromAny(promise, { signal })`, so the
-     * reactive layer sees ERROR when the wire call is cancelled.
-     */
-    private _currentAbortController;
-    constructor(name: string, opts: AgentLoopOptions);
-    /**
-     * Bridge to `Promise<LLMResponse>` over the reactive pipeline.
-     *
-     * - If `userMessage` is provided, appends it as a user message and
-     *   transitions status to `"thinking"` to kick the loop.
-     * - If `signal` is provided, binds it to the reactive `aborted` node
-     *   AND threads into `adapter.invoke({ signal })` so the wire call can
-     *   cancel mid-flight. The reactive `aborted` state + effect 3 guarantee
-     *   that even an adapter that ignores `signal` will stop emitting into
-     *   the agent graph.
-     * - Resolves when `status === "done"` with the final LLM response.
-     *   Rejects with `AbortError` when the abort signal fires pre-response.
-     *   Rejects with the stage error when `status === "error"`.
-     *
-     * **Concurrency:** `run()` refuses to overlap with a pending call on the
-     * same agent. Attempting to call `run()` while a previous `run()` is
-     * still in-flight throws a `RangeError` immediately. Stale-resolution
-     * safety is provided by `awaitSettled({skipCurrent: true})`, which
-     * ignores the cached initial DATA from any previous run and resolves
-     * only on a fresh post-subscribe emission of `_terminalResult`.
-     */
-    run(userMessage?: string, signal?: AbortSignal): Promise<LLMResponse | null>;
-    /**
-     * Flip the reactive `aborted` state. Equivalent to setting an external
-     * `AbortSignal` — the pipeline observes and transitions to `"done"`.
-     */
-    abort(): void;
-    destroy(): void;
-}
-declare function agentLoop(name: string, opts: AgentLoopOptions): AgentLoopGraph;
-
-type AgentMemoryOptions<TMem = unknown> = {
-    graph?: GraphOptions;
-    /** LLM adapter for extraction and consolidation. */
-    adapter?: LLMAdapter;
-    /** System prompt for the extractor LLM. */
-    extractPrompt?: string;
-    /** Custom extractFn (overrides adapter + extractPrompt). */
-    extractFn?: (raw: unknown, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-    /** System prompt for the consolidation LLM. */
-    consolidatePrompt?: string;
-    /** Custom consolidateFn (overrides adapter + consolidatePrompt). */
-    consolidateFn?: (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-    /** Reactive trigger for consolidation (caller supplies e.g. `fromTimer`). */
-    consolidateTrigger?: NodeInput<unknown>;
-    /** Score function for budget packing (required). */
-    score: (mem: TMem, context: unknown) => number;
-    /** Cost function for budget packing (required). */
-    cost: (mem: TMem) => number;
-    /** Token budget for compact view (default 2000). */
-    budget?: number;
-    /** Context node for scoring. */
-    context?: NodeInput<unknown>;
-    /** Admission filter (default: admit all). */
-    admissionFilter?: (candidate: unknown) => boolean;
-    /** Vector index dimensions (> 0 enables vector index for retrieval). */
-    vectorDimensions?: number;
-    /**
-     * B12: optional accessor for an entry's hierarchical context breadcrumb
-     * (e.g. `["projects", "auth", "tokens"]`). When supplied alongside
-     * `contextWeight > 0`, retrieval applies a score boost for entries whose
-     * context shares a prefix with the query's `context`. Entries without
-     * a breadcrumb are scored flatly.
-     */
-    contextOf?: (mem: TMem) => readonly string[] | undefined;
-    /**
-     * B12: hierarchical context boost multiplier. Score is scaled by
-     * `(1 + contextWeight * sharedDepth / queryDepth)` when both the query
-     * and entry supply a `context`. Default: 0.
-     */
-    contextWeight?: number;
-    /** Extract embedding vector from a memory entry (enables vector index). */
-    embedFn?: (mem: TMem) => readonly number[] | undefined;
-    /** Enable knowledge graph for entity/relation tracking. */
-    enableKnowledgeGraph?: boolean;
-    /** Extract entities and relations from a memory entry. */
-    entityFn?: (key: string, mem: TMem) => {
-        entities?: Array<{
-            id: string;
-            value: unknown;
-        }>;
-        relations?: Array<{
-            from: string;
-            to: string;
-            relation: string;
-            weight?: number;
-        }>;
-    } | undefined;
-    /** 3-tier storage configuration. Omit to use single-tier (existing behavior). */
-    tiers?: MemoryTiersOptions<TMem>;
-    /** Retrieval pipeline configuration. Requires vector index or knowledge graph. */
-    retrieval?: {
-        /** Max candidates from vector search (default 20). */
-        topK?: number;
-        /** KG expansion depth in hops (default 1). */
-        graphDepth?: number;
-    };
-    /** Periodic reflection/consolidation configuration. */
-    reflection?: {
-        /** Interval in ms between consolidation runs (default 300_000 = 5 min). */
-        interval?: number;
-        /** Enable/disable periodic reflection (default true when consolidateFn is available). */
-        enabled?: boolean;
-    };
-};
-type AgentMemoryGraph<TMem = unknown> = Graph & {
-    readonly distillBundle: DistillBundle<TMem>;
-    readonly compact: Node<Array<{
-        key: string;
-        value: TMem;
-        score: number;
-    }>>;
-    readonly size: Node<number>;
-    /** Vector index bundle (null if not enabled). */
-    readonly vectors: VectorIndexGraph<TMem> | null;
-    /** Knowledge graph (null if not enabled). */
-    readonly kg: KnowledgeGraph<unknown, string> | null;
-    /** Memory tiers bundle (null if not configured). */
-    readonly memoryTiers: MemoryTiersBundle<TMem> | null;
-    /** Retrieval result node (null if no retrieval pipeline configured). */
-    readonly retrieval: Node<ReadonlyArray<RetrievalEntry<TMem>>> | null;
-    /** Latest retrieval trace for observability (null if no retrieval pipeline). */
-    readonly retrievalTrace: Node<RetrievalTrace<TMem> | null> | null;
-    /**
-     * Execute a retrieval query (null if no retrieval pipeline).
-     *
-     * **Synchronous consumer API** — returns the result immediately and batch-writes
-     * `retrieval` and `retrievalTrace` state nodes for observers. Reads the store
-     * snapshot and context value **at call time** (external-boundary read).
-     *
-     * **Do not call from inside a reactive fn body** (derived fn, subscribe callback,
-     * effect body). The cache reads would become transitive protocol violations and
-     * may observe wave-progressive rather than wave-final state.
-     *
-     * **Caller-batch caveat:** if invoked inside a caller's `batch(() => ...)` alongside
-     * upstream store mutations, the store snapshot reflects what has been committed to
-     * `store.entries.cache` at call time. State-backed stores update cache synchronously
-     * so batched inserts are visible; derived-backed store transforms may defer. If you
-     * need fresh state after batched mutations, call `retrieve` after the batch returns.
-     */
-    readonly retrieve: ((query: RetrievalQuery) => ReadonlyArray<RetrievalEntry<TMem>>) | null;
-    /**
-     * Reactive sibling of {@link retrieve}. Given a reactive
-     * `RetrievalQuery | null` source, returns a `Node` emitting the packed
-     * retrieval results. Composable with graph topology — subscribe it,
-     * chain it into `promptNode`, or switchMap over a user-input node.
-     * Null when no retrieval pipeline is configured.
-     */
-    readonly retrieveReactive: ((queryInput: NodeInput<RetrievalQuery | null>) => Node<ReadonlyArray<RetrievalEntry<TMem>>>) | null;
-};
-/**
- * Pre-wired agentic memory graph. Sugar over `distill` plus the
- * `memoryWithVectors` / `memoryWithKG` / `memoryWithTiers` / `memoryRetrieval`
- * composers. Power users who want a subset of capabilities can call those
- * composers directly; this factory bundles them into one ergonomic call.
- */
-declare function agentMemory<TMem = unknown>(name: string, source: NodeInput<unknown>, opts: AgentMemoryOptions<TMem>): AgentMemoryGraph<TMem>;
-
-type GaugesAsContextOptions = {
-    /** Group gauges by `meta.tags` (default true). */
-    groupByTags?: boolean;
-    /** Separator between gauge lines (default "\n"). */
-    separator?: string;
-    /**
-     * V0 delta mode (§6.0b): only include nodes whose `v.version` exceeds
-     * the corresponding entry in this map. Nodes without V0 or not in the
-     * map are always included. Callers maintain this map across calls.
-     *
-     * The `id` field guards against node replacement: if a node is removed
-     * and re-added under the same name (new id), it is always included.
-     */
-    sinceVersion?: ReadonlyMap<string, {
-        id: string;
-        version: number;
-    }>;
-};
-/**
- * Format a graph's readable (gauge) nodes as a context string for LLM
- * system prompts.
- *
- * Gauges are nodes with `meta.description` or `meta.format`. Values are
- * formatted using `meta.format` and `meta.unit` hints.
- *
- * @param graph - The graph to introspect.
- * @param actor - Optional actor for guard-scoped describe.
- * @param options - Formatting options.
- * @returns A formatted string ready for system prompt injection.
- */
-declare function gaugesAsContext(graph: Graph, actor?: Actor, options?: GaugesAsContextOptions): string;
-
-type GraphFromSpecOptions = {
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /** Fn/source catalog for resolving named node factories from the LLM-generated spec. */
-    catalog?: GraphSpecCatalog;
-    /** Extra instructions appended to the system prompt. */
-    systemPromptExtra?: string;
-    /**
-     * Optional AbortSignal forwarded to `adapter.invoke({ signal })`. Lets
-     * callers cancel the in-flight LLM call (e.g. when the reactive variant
-     * supersedes mid-flight). When the signal aborts, the underlying call
-     * propagates the abort and `graphFromSpec` rejects with the abort reason.
-     */
-    signal?: AbortSignal;
-};
-/**
- * Ask an LLM to compose a Graph from a natural-language description.
- *
- * The LLM returns a JSON {@link GraphSpec} which is validated, catalog-expanded,
- * and instantiated via {@link compileSpec} (gains catalog validation, template
- * expansion, and feedback wiring that `Graph.fromSnapshot` bypasses).
- *
- * @param naturalLanguage - The problem/use-case description.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options and optional catalog for named node factories.
- * @returns A constructed Graph.
- * @throws On invalid LLM output, validation failure, or unresolvable deps.
- */
-declare function graphFromSpec(naturalLanguage: string, adapter: LLMAdapter, opts?: GraphFromSpecOptions): Promise<Graph>;
-/**
- * Reactive variant of {@link graphFromSpec}: re-invokes the LLM and
- * recompiles the graph whenever `input` emits a new natural-language
- * description. Useful inside the harness or refine loop when the spec text
- * itself is a reactive value (e.g. fed by a `state(...)` knob, a memory
- * snapshot, or an upstream `promptNode` output).
- *
- * **Supersede:** when the input changes mid-flight, switchMap tears the
- * inner producer down. The producer's cleanup aborts the in-flight LLM
- * call via an internal `AbortController` (threaded into `graphFromSpec`'s
- * new `signal` option) AND destroys any Graph that lands after cancel —
- * no token leak, no unreferenced compiled graphs. If the user's input
- * already changed by the time the LLM responds, the about-to-be-discarded
- * Graph is freed instead of orphaned.
- *
- * **Lifetime of the latest emitted Graph:** the caller owns each Graph
- * that actually reaches them. If you keep multiple historical values, call
- * `prev?.destroy()` before storing the new one.
- *
- * @param input - Reactive source of natural-language descriptions.
- * @param adapter - LLM adapter for the generation call.
- * @param opts - Model options and optional catalog for named node factories.
- * @returns `Node<Graph | null>` — emits the latest compiled graph, or `null`
- *           while the input is empty / unsettled.
- */
-declare function graphFromSpecReactive(input: NodeInput<string>, adapter: LLMAdapter, opts?: GraphFromSpecOptions): Node<Graph | null>;
-
-/** OpenAI function-calling tool schema. */
-type OpenAIToolSchema = {
-    readonly type: "function";
-    readonly function: {
-        readonly name: string;
-        readonly description: string;
-        readonly parameters: Record<string, unknown>;
-    };
-};
-/** MCP (Model Context Protocol) tool schema. */
-type McpToolSchema = {
-    readonly name: string;
-    readonly description: string;
-    readonly inputSchema: Record<string, unknown>;
-};
-/** Result of {@link knobsAsTools}. */
-type KnobsAsToolsResult = {
-    /** OpenAI function-calling tool schemas. */
-    readonly openai: readonly OpenAIToolSchema[];
-    /** MCP tool schemas. */
-    readonly mcp: readonly McpToolSchema[];
-    /** GraphReFly ToolDefinitions with handlers that call `graph.set()`. */
-    readonly definitions: readonly ToolDefinition[];
-};
-/**
- * Derive tool schemas from a graph's writable (knob) nodes.
- *
- * Knobs are state nodes whose `meta.access` is `"llm"`, `"both"`, or absent
- * (default: writable). Each knob becomes a tool that calls `graph.set()`.
- *
- * Speaks **domain language** (spec §5.4): the returned schemas use node names
- * and meta descriptions — no protocol internals exposed.
- *
- * @param graph - The graph to introspect.
- * @param actor - Optional actor for guard-scoped describe.
- * @returns OpenAI, MCP, and GraphReFly tool schemas.
- */
-declare function knobsAsTools(graph: Graph, actor?: Actor): KnobsAsToolsResult;
-
-/** A single operation in a strategy plan. */
-type StrategyOperation = {
-    readonly type: "add_node";
-    readonly name: string;
-    readonly nodeType: string;
-    readonly meta?: Record<string, unknown>;
-    readonly initial?: unknown;
-} | {
-    readonly type: "remove_node";
-    readonly name: string;
-} | {
-    readonly type: "connect";
-    readonly from: string;
-    readonly to: string;
-} | {
-    readonly type: "disconnect";
-    readonly from: string;
-    readonly to: string;
-} | {
-    readonly type: "set_value";
-    readonly name: string;
-    readonly value: unknown;
-} | {
-    readonly type: "update_meta";
-    readonly name: string;
-    readonly key: string;
-    readonly value: unknown;
-};
-/** Structured strategy plan returned by {@link suggestStrategy}. */
-type StrategyPlan = {
-    readonly summary: string;
-    readonly operations: readonly StrategyOperation[];
-    readonly reasoning: string;
-};
-type SuggestStrategyOptions = {
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    actor?: Actor;
-    /**
-     * Optional AbortSignal forwarded to `adapter.invoke({ signal })`. Lets
-     * callers cancel the in-flight LLM call (e.g. when the reactive variant
-     * supersedes mid-flight). When the signal aborts, the underlying call
-     * propagates the abort and `suggestStrategy` rejects with the abort reason.
-     */
-    signal?: AbortSignal;
-};
-/**
- * Ask an LLM to analyze a graph and suggest topology/parameter changes
- * to solve a stated problem.
- *
- * Returns a structured plan — does NOT auto-apply. The caller reviews
- * and selectively applies operations.
- *
- * @param graph - The graph to analyze.
- * @param problem - Natural-language problem statement.
- * @param adapter - LLM adapter for the analysis call.
- * @param opts - Model and actor options.
- * @returns A structured strategy plan.
- * @throws On invalid LLM output.
- */
-declare function suggestStrategy(graph: Graph, problem: string, adapter: LLMAdapter, opts?: SuggestStrategyOptions): Promise<StrategyPlan>;
-/**
- * Reactive variant of {@link suggestStrategy}: re-invokes the LLM whenever
- * the `problem` source emits, sampling the latest `graph` value (via
- * `withLatestFrom`) to describe. The graph is the *secondary* dep — only
- * problem changes re-trigger analysis. This breaks the feedback cycle that
- * would otherwise arise if downstream consumers wired `apply(plan)` back
- * into the same graph node (graph mutation must not auto-fire a re-analysis).
- *
- * @param graph - Reactive source of graphs to analyze.
- * @param problem - Reactive source of natural-language problem statements.
- * @param adapter - LLM adapter for the analysis call.
- * @param opts - Model and actor options.
- * @returns `Node<StrategyPlan | null>` — emits the latest plan, or `null`
- *           while inputs are unsettled.
- */
-declare function suggestStrategyReactive(graph: Node<Graph | null>, problem: NodeInput<string>, adapter: LLMAdapter, opts?: SuggestStrategyOptions): Node<StrategyPlan | null>;
-
-/** Validation result from {@link validateGraphDef}. */
-type GraphDefValidation = {
-    readonly valid: boolean;
-    readonly errors: readonly string[];
-};
-/**
- * Validate an LLM-generated graph definition before passing to
- * `Graph.fromSnapshot()`.
- *
- * Checks:
- * - Required fields: `name`, `nodes`, `edges`
- * - Node types are valid enum values
- * - Edge `from`/`to` reference existing nodes
- * - No duplicate edge entries
- *
- * @param def - The graph definition to validate (parsed JSON).
- * @returns Validation result with errors array.
- */
-declare function validateGraphDef(def: unknown): GraphDefValidation;
-
-/**
- * AI surface patterns (roadmap §4.4).
- *
- * Domain-layer factories for LLM-backed agents, chat, tool registries, and
- * agentic memory. Composed from core + extra + Phase 3–4.3 primitives.
- *
- * This file is the public barrel — it re-exports symbols from the sibling
- * folders (`prompts/`, `extractors/`, `safety/`, `agents/`, `memory/`,
- * `graph-integration/`, and the existing `adapters/` tree). No implementation
- * code lives here; see each sibling folder for the actual primitives.
- *
- * @module
- */
-
-declare const index_AdapterProvider: typeof AdapterProvider;
-type index_AdapterStats = AdapterStats;
-declare const index_AdapterTier: typeof AdapterTier;
-type index_AdmissionScore3DOptions = AdmissionScore3DOptions;
-type index_AdmissionScoredOptions<Dims extends string, TRaw = unknown> = AdmissionScoredOptions<Dims, TRaw>;
-type index_AdmissionScores = AdmissionScores;
-type index_AdmissionThresholds<Dims extends string> = AdmissionThresholds<Dims>;
-type index_AgentLoopGraph = AgentLoopGraph;
-declare const index_AgentLoopGraph: typeof AgentLoopGraph;
-type index_AgentLoopOptions = AgentLoopOptions;
-type index_AgentLoopStatus = AgentLoopStatus;
-type index_AgentMemoryGraph<TMem = unknown> = AgentMemoryGraph<TMem>;
-type index_AgentMemoryOptions<TMem = unknown> = AgentMemoryOptions<TMem>;
-declare const index_AllTiersExhaustedError: typeof AllTiersExhaustedError;
-type index_AnthropicAdapterOptions = AnthropicAdapterOptions;
-type index_AnthropicSdkLike = AnthropicSdkLike;
-type index_BudgetCaps = BudgetCaps;
-type index_BudgetExhaustedError = BudgetExhaustedError;
-declare const index_BudgetExhaustedError: typeof BudgetExhaustedError;
-type index_BudgetGateBundle = BudgetGateBundle;
-type index_BudgetTotals = BudgetTotals;
-type index_CallStatsEvent = CallStatsEvent;
-declare const index_CapabilitiesRegistry: typeof CapabilitiesRegistry;
-declare const index_CascadeExhaustionReport: typeof CascadeExhaustionReport;
-declare const index_CascadingLlmAdapterOptions: typeof CascadingLlmAdapterOptions;
-declare const index_ChatMessage: typeof ChatMessage;
-type index_ChatStreamGraph = ChatStreamGraph;
-declare const index_ChatStreamGraph: typeof ChatStreamGraph;
-type index_ChatStreamOptions = ChatStreamOptions;
-declare const index_CircuitOpenError: typeof CircuitOpenError;
-type index_ContentDecision = ContentDecision;
-type index_ContentGateOptions = ContentGateOptions;
-type index_CostMeterOptions = CostMeterOptions;
-type index_CostMeterReading = CostMeterReading;
-declare const index_CreateAdapterOptions: typeof CreateAdapterOptions;
-declare const index_DEFAULT_DECAY_RATE: typeof DEFAULT_DECAY_RATE;
-type index_DryRunAdapterOptions = DryRunAdapterOptions;
-type index_ExtractedToolCall = ExtractedToolCall;
-declare const index_FallbackAdapterOptions: typeof FallbackAdapterOptions;
-declare const index_FallbackFixture: typeof FallbackFixture;
-declare const index_FallbackMissError: typeof FallbackMissError;
-declare const index_FallbackMissPolicy: typeof FallbackMissPolicy;
-type index_FrozenContextOptions = FrozenContextOptions;
-type index_GatedStreamHandle<T> = GatedStreamHandle<T>;
-type index_GatedStreamOptions = GatedStreamOptions;
-type index_GaugesAsContextOptions = GaugesAsContextOptions;
-type index_GoogleAdapterOptions = GoogleAdapterOptions;
-type index_GoogleSdkLike = GoogleSdkLike;
-type index_GoogleSdkRequestConfig = GoogleSdkRequestConfig;
-type index_GoogleSdkRequestParams = GoogleSdkRequestParams;
-type index_GraphDefValidation = GraphDefValidation;
-type index_GraphFromSpecOptions = GraphFromSpecOptions;
-type index_HandoffOptions = HandoffOptions;
-type index_HttpErrorLike = HttpErrorLike;
-type index_KeywordFlag = KeywordFlag;
-type index_KeywordFlagExtractorOptions = KeywordFlagExtractorOptions;
-type index_KnobsAsToolsResult = KnobsAsToolsResult;
-declare const index_LLMAdapter: typeof LLMAdapter;
-type index_LLMConsolidatorOptions = LLMConsolidatorOptions;
-type index_LLMExtractorOptions = LLMExtractorOptions;
-declare const index_LLMInvokeOptions: typeof LLMInvokeOptions;
-declare const index_LLMResponse: typeof LLMResponse;
-type index_LLMTimeoutError = LLMTimeoutError;
-declare const index_LLMTimeoutError: typeof LLMTimeoutError;
-type index_McpToolSchema = McpToolSchema;
-type index_MemoryRetrievalBundle<TMem> = MemoryRetrievalBundle<TMem>;
-type index_MemoryRetrievalOptions<TMem> = MemoryRetrievalOptions<TMem>;
-type index_MemoryTier = MemoryTier;
-type index_MemoryTiersBundle<TMem> = MemoryTiersBundle<TMem>;
-type index_MemoryTiersOptions<TMem> = MemoryTiersOptions<TMem>;
-type index_MemoryWithKGOptions<TMem> = MemoryWithKGOptions<TMem>;
-type index_MemoryWithTiersOptions<TMem> = MemoryWithTiersOptions<TMem>;
-type index_MemoryWithVectorsOptions<TMem> = MemoryWithVectorsOptions<TMem>;
-declare const index_ModelCapabilities: typeof ModelCapabilities;
-declare const index_ModelFeatures: typeof ModelFeatures;
-declare const index_ModelLimits: typeof ModelLimits;
-declare const index_ModelPricing: typeof ModelPricing;
-declare const index_OpenAICompatAdapterOptions: typeof OpenAICompatAdapterOptions;
-declare const index_OpenAICompatPreset: typeof OpenAICompatPreset;
-declare const index_OpenAISdkLike: typeof OpenAISdkLike;
-type index_OpenAIToolSchema = OpenAIToolSchema;
-declare const index_PriceBreakdown: typeof PriceBreakdown;
-declare const index_PricingFn: typeof PricingFn;
-declare const index_PricingRegistry: typeof PricingRegistry;
-type index_PromptCallOptions = PromptCallOptions;
-type index_PromptNodeOptions = PromptNodeOptions;
-declare const index_Rate: typeof Rate;
-type index_RedactorOptions = RedactorOptions;
-declare const index_ReplayCacheKeyContext: typeof ReplayCacheKeyContext;
-declare const index_ReplayCacheMissError: typeof ReplayCacheMissError;
-declare const index_ReplayCacheMode: typeof ReplayCacheMode;
-type index_ResilientAdapterBundle = ResilientAdapterBundle;
-type index_ResilientAdapterOptions = ResilientAdapterOptions;
-type index_RetrievalEntry<TMem> = RetrievalEntry<TMem>;
-type index_RetrievalPipelineOptions<TMem> = RetrievalPipelineOptions<TMem>;
-type index_RetrievalQuery = RetrievalQuery;
-type index_RetrievalTrace<TMem> = RetrievalTrace<TMem>;
-type index_StampedDelta = StampedDelta;
-type index_StrategyOperation = StrategyOperation;
-type index_StrategyPlan = StrategyPlan;
-declare const index_StreamDelta: typeof StreamDelta;
-type index_StreamingPromptNodeHandle<T> = StreamingPromptNodeHandle<T>;
-type index_StreamingPromptNodeOptions = StreamingPromptNodeOptions;
-type index_SuggestStrategyOptions = SuggestStrategyOptions;
-type index_SystemPromptHandle = SystemPromptHandle;
-declare const index_TieredRate: typeof TieredRate;
-declare const index_TokenUsage: typeof TokenUsage;
-declare const index_ToolCall: typeof ToolCall;
-declare const index_ToolDefinition: typeof ToolDefinition;
-type index_ToolExecutionOptions = ToolExecutionOptions;
-type index_ToolRegistryGraph = ToolRegistryGraph;
-declare const index_ToolRegistryGraph: typeof ToolRegistryGraph;
-type index_ToolRegistryOptions = ToolRegistryOptions;
-type index_ToolResult = ToolResult;
-type index_ToolSelectorOptions = ToolSelectorOptions;
-type index_WithBreakerOptions = WithBreakerOptions;
-type index_WithBudgetGateOptions = WithBudgetGateOptions;
-type index_WithDryRunBundle = WithDryRunBundle;
-type index_WithDryRunOptions = WithDryRunOptions;
-type index_WithRateLimiterOptions = WithRateLimiterOptions;
-declare const index_WithReplayCacheOptions: typeof WithReplayCacheOptions;
-type index_WithRetryOptions = WithRetryOptions;
-declare const index_admissionFilter3D: typeof admissionFilter3D;
-declare const index_admissionScored: typeof admissionScored;
-declare const index_agentLoop: typeof agentLoop;
-declare const index_agentMemory: typeof agentMemory;
-declare const index_anthropicAdapter: typeof anthropicAdapter;
-declare const index_canonicalJson: typeof canonicalJson;
-declare const index_cascadingLlmAdapter: typeof cascadingLlmAdapter;
-declare const index_chatStream: typeof chatStream;
-declare const index_composePricing: typeof composePricing;
-declare const index_computePrice: typeof computePrice;
-declare const index_contentGate: typeof contentGate;
-declare const index_costMeterExtractor: typeof costMeterExtractor;
-declare const index_createAdapter: typeof createAdapter;
-declare const index_createCapabilitiesRegistry: typeof createCapabilitiesRegistry;
-declare const index_createPricingRegistry: typeof createPricingRegistry;
-declare const index_dryRunAdapter: typeof dryRunAdapter;
-declare const index_fallbackAdapter: typeof fallbackAdapter;
-declare const index_frozenContext: typeof frozenContext;
-declare const index_gatedStream: typeof gatedStream;
-declare const index_gaugesAsContext: typeof gaugesAsContext;
-declare const index_googleAdapter: typeof googleAdapter;
-declare const index_graphFromSpec: typeof graphFromSpec;
-declare const index_graphFromSpecReactive: typeof graphFromSpecReactive;
-declare const index_handoff: typeof handoff;
-declare const index_keywordFlagExtractor: typeof keywordFlagExtractor;
-declare const index_knobsAsTools: typeof knobsAsTools;
-declare const index_llmConsolidator: typeof llmConsolidator;
-declare const index_llmExtractor: typeof llmExtractor;
-declare const index_memoryRetrieval: typeof memoryRetrieval;
-declare const index_memoryWithKG: typeof memoryWithKG;
-declare const index_memoryWithTiers: typeof memoryWithTiers;
-declare const index_memoryWithVectors: typeof memoryWithVectors;
-declare const index_observableAdapter: typeof observableAdapter;
-declare const index_openAICompatAdapter: typeof openAICompatAdapter;
-declare const index_parseRateLimitFromError: typeof parseRateLimitFromError;
-declare const index_pricingFor: typeof pricingFor;
-declare const index_promptCall: typeof promptCall;
-declare const index_promptNode: typeof promptNode;
-declare const index_redactor: typeof redactor;
-declare const index_registryPricing: typeof registryPricing;
-declare const index_resilientAdapter: typeof resilientAdapter;
-declare const index_streamExtractor: typeof streamExtractor;
-declare const index_streamingPromptNode: typeof streamingPromptNode;
-declare const index_suggestStrategy: typeof suggestStrategy;
-declare const index_suggestStrategyReactive: typeof suggestStrategyReactive;
-declare const index_systemPromptBuilder: typeof systemPromptBuilder;
-declare const index_tier: typeof tier;
-declare const index_toolCallExtractor: typeof toolCallExtractor;
-declare const index_toolExecution: typeof toolExecution;
-declare const index_toolRegistry: typeof toolRegistry;
-declare const index_toolSelector: typeof toolSelector;
-declare const index_validateGraphDef: typeof validateGraphDef;
-declare const index_withBreaker: typeof withBreaker;
-declare const index_withBudgetGate: typeof withBudgetGate;
-declare const index_withDryRun: typeof withDryRun;
-declare const index_withRateLimiter: typeof withRateLimiter;
-declare const index_withReplayCache: typeof withReplayCache;
-declare const index_withRetry: typeof withRetry;
-declare const index_withTimeout: typeof withTimeout;
-declare const index_zeroPrice: typeof zeroPrice;
-declare namespace index {
-  export { index_AdapterProvider as AdapterProvider, type index_AdapterStats as AdapterStats, index_AdapterTier as AdapterTier, type index_AdmissionScore3DOptions as AdmissionScore3DOptions, type index_AdmissionScoredOptions as AdmissionScoredOptions, type index_AdmissionScores as AdmissionScores, type index_AdmissionThresholds as AdmissionThresholds, index_AgentLoopGraph as AgentLoopGraph, type index_AgentLoopOptions as AgentLoopOptions, type index_AgentLoopStatus as AgentLoopStatus, type index_AgentMemoryGraph as AgentMemoryGraph, type index_AgentMemoryOptions as AgentMemoryOptions, index_AllTiersExhaustedError as AllTiersExhaustedError, type index_AnthropicAdapterOptions as AnthropicAdapterOptions, type index_AnthropicSdkLike as AnthropicSdkLike, type index_BudgetCaps as BudgetCaps, index_BudgetExhaustedError as BudgetExhaustedError, type index_BudgetGateBundle as BudgetGateBundle, type index_BudgetTotals as BudgetTotals, type index_CallStatsEvent as CallStatsEvent, index_CapabilitiesRegistry as CapabilitiesRegistry, index_CascadeExhaustionReport as CascadeExhaustionReport, index_CascadingLlmAdapterOptions as CascadingLlmAdapterOptions, index_ChatMessage as ChatMessage, index_ChatStreamGraph as ChatStreamGraph, type index_ChatStreamOptions as ChatStreamOptions, index_CircuitOpenError as CircuitOpenError, type index_ContentDecision as ContentDecision, type index_ContentGateOptions as ContentGateOptions, type index_CostMeterOptions as CostMeterOptions, type index_CostMeterReading as CostMeterReading, index_CreateAdapterOptions as CreateAdapterOptions, index_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, type index_DryRunAdapterOptions as DryRunAdapterOptions, type index_ExtractedToolCall as ExtractedToolCall, index_FallbackAdapterOptions as FallbackAdapterOptions, index_FallbackFixture as FallbackFixture, index_FallbackMissError as FallbackMissError, index_FallbackMissPolicy as FallbackMissPolicy, type index_FrozenContextOptions as FrozenContextOptions, type index_GatedStreamHandle as GatedStreamHandle, type index_GatedStreamOptions as GatedStreamOptions, type index_GaugesAsContextOptions as GaugesAsContextOptions, type index_GoogleAdapterOptions as GoogleAdapterOptions, type index_GoogleSdkLike as GoogleSdkLike, type index_GoogleSdkRequestConfig as GoogleSdkRequestConfig, type index_GoogleSdkRequestParams as GoogleSdkRequestParams, type index_GraphDefValidation as GraphDefValidation, type index_GraphFromSpecOptions as GraphFromSpecOptions, type index_HandoffOptions as HandoffOptions, type index_HttpErrorLike as HttpErrorLike, type index_KeywordFlag as KeywordFlag, type index_KeywordFlagExtractorOptions as KeywordFlagExtractorOptions, type index_KnobsAsToolsResult as KnobsAsToolsResult, index_LLMAdapter as LLMAdapter, type index_LLMConsolidatorOptions as LLMConsolidatorOptions, type index_LLMExtractorOptions as LLMExtractorOptions, index_LLMInvokeOptions as LLMInvokeOptions, index_LLMResponse as LLMResponse, index_LLMTimeoutError as LLMTimeoutError, type index_McpToolSchema as McpToolSchema, type index_MemoryRetrievalBundle as MemoryRetrievalBundle, type index_MemoryRetrievalOptions as MemoryRetrievalOptions, type index_MemoryTier as MemoryTier, type index_MemoryTiersBundle as MemoryTiersBundle, type index_MemoryTiersOptions as MemoryTiersOptions, type index_MemoryWithKGOptions as MemoryWithKGOptions, type index_MemoryWithTiersOptions as MemoryWithTiersOptions, type index_MemoryWithVectorsOptions as MemoryWithVectorsOptions, index_ModelCapabilities as ModelCapabilities, index_ModelFeatures as ModelFeatures, index_ModelLimits as ModelLimits, index_ModelPricing as ModelPricing, index_OpenAICompatAdapterOptions as OpenAICompatAdapterOptions, index_OpenAICompatPreset as OpenAICompatPreset, index_OpenAISdkLike as OpenAISdkLike, type index_OpenAIToolSchema as OpenAIToolSchema, index_PriceBreakdown as PriceBreakdown, index_PricingFn as PricingFn, index_PricingRegistry as PricingRegistry, type index_PromptCallOptions as PromptCallOptions, type index_PromptNodeOptions as PromptNodeOptions, index_Rate as Rate, type index_RedactorOptions as RedactorOptions, index_ReplayCacheKeyContext as ReplayCacheKeyContext, index_ReplayCacheMissError as ReplayCacheMissError, index_ReplayCacheMode as ReplayCacheMode, type index_ResilientAdapterBundle as ResilientAdapterBundle, type index_ResilientAdapterOptions as ResilientAdapterOptions, type index_RetrievalEntry as RetrievalEntry, type index_RetrievalPipelineOptions as RetrievalPipelineOptions, type index_RetrievalQuery as RetrievalQuery, type index_RetrievalTrace as RetrievalTrace, type index_StampedDelta as StampedDelta, type index_StrategyOperation as StrategyOperation, type index_StrategyPlan as StrategyPlan, index_StreamDelta as StreamDelta, type index_StreamingPromptNodeHandle as StreamingPromptNodeHandle, type index_StreamingPromptNodeOptions as StreamingPromptNodeOptions, type index_SuggestStrategyOptions as SuggestStrategyOptions, type index_SystemPromptHandle as SystemPromptHandle, index_TieredRate as TieredRate, index_TokenUsage as TokenUsage, index_ToolCall as ToolCall, index_ToolDefinition as ToolDefinition, type index_ToolExecutionOptions as ToolExecutionOptions, index_ToolRegistryGraph as ToolRegistryGraph, type index_ToolRegistryOptions as ToolRegistryOptions, type index_ToolResult as ToolResult, type index_ToolSelectorOptions as ToolSelectorOptions, type index_WithBreakerOptions as WithBreakerOptions, type index_WithBudgetGateOptions as WithBudgetGateOptions, type index_WithDryRunBundle as WithDryRunBundle, type index_WithDryRunOptions as WithDryRunOptions, type index_WithRateLimiterOptions as WithRateLimiterOptions, index_WithReplayCacheOptions as WithReplayCacheOptions, type index_WithRetryOptions as WithRetryOptions, index_admissionFilter3D as admissionFilter3D, index_admissionScored as admissionScored, index_agentLoop as agentLoop, index_agentMemory as agentMemory, index_anthropicAdapter as anthropicAdapter, index_canonicalJson as canonicalJson, index_cascadingLlmAdapter as cascadingLlmAdapter, index_chatStream as chatStream, index_composePricing as composePricing, index_computePrice as computePrice, index_contentGate as contentGate, index_costMeterExtractor as costMeterExtractor, index_createAdapter as createAdapter, index_createCapabilitiesRegistry as createCapabilitiesRegistry, index_createPricingRegistry as createPricingRegistry, index_dryRunAdapter as dryRunAdapter, index_fallbackAdapter as fallbackAdapter, index_frozenContext as frozenContext, index_gatedStream as gatedStream, index_gaugesAsContext as gaugesAsContext, index_googleAdapter as googleAdapter, index_graphFromSpec as graphFromSpec, index_graphFromSpecReactive as graphFromSpecReactive, index_handoff as handoff, index_keywordFlagExtractor as keywordFlagExtractor, index_knobsAsTools as knobsAsTools, index_llmConsolidator as llmConsolidator, index_llmExtractor as llmExtractor, index_memoryRetrieval as memoryRetrieval, index_memoryWithKG as memoryWithKG, index_memoryWithTiers as memoryWithTiers, index_memoryWithVectors as memoryWithVectors, index_observableAdapter as observableAdapter, index_openAICompatAdapter as openAICompatAdapter, index_parseRateLimitFromError as parseRateLimitFromError, index_pricingFor as pricingFor, index_promptCall as promptCall, index_promptNode as promptNode, index_redactor as redactor, index_registryPricing as registryPricing, index_resilientAdapter as resilientAdapter, index_streamExtractor as streamExtractor, index_streamingPromptNode as streamingPromptNode, index_suggestStrategy as suggestStrategy, index_suggestStrategyReactive as suggestStrategyReactive, index_systemPromptBuilder as systemPromptBuilder, index_tier as tier, index_toolCallExtractor as toolCallExtractor, index_toolExecution as toolExecution, index_toolRegistry as toolRegistry, index_toolSelector as toolSelector, index_validateGraphDef as validateGraphDef, index_withBreaker as withBreaker, index_withBudgetGate as withBudgetGate, index_withDryRun as withDryRun, index_withRateLimiter as withRateLimiter, index_withReplayCache as withReplayCache, index_withRetry as withRetry, index_withTimeout as withTimeout, index_zeroPrice as zeroPrice };
-}
-
-export { type OpenAIToolSchema as $, type AdapterStats as A, type BudgetCaps as B, type CallStatsEvent as C, type DryRunAdapterOptions as D, type ExtractedToolCall as E, type FrozenContextOptions as F, type GatedStreamHandle as G, type GoogleSdkRequestParams as H, type GraphDefValidation as I, type GraphFromSpecOptions as J, type HandoffOptions as K, type HttpErrorLike as L, type KeywordFlag as M, type KeywordFlagExtractorOptions as N, type KnobsAsToolsResult as O, type LLMConsolidatorOptions as P, type LLMExtractorOptions as Q, LLMTimeoutError as R, type McpToolSchema as S, type MemoryRetrievalBundle as T, type MemoryRetrievalOptions as U, type MemoryTier as V, type MemoryTiersBundle as W, type MemoryTiersOptions as X, type MemoryWithKGOptions as Y, type MemoryWithTiersOptions as Z, type MemoryWithVectorsOptions as _, type AdmissionScore3DOptions as a, toolExecution as a$, type PromptCallOptions as a0, type PromptNodeOptions as a1, type RedactorOptions as a2, type ResilientAdapterBundle as a3, type ResilientAdapterOptions as a4, type RetrievalEntry as a5, type RetrievalPipelineOptions as a6, type RetrievalQuery as a7, type RetrievalTrace as a8, type StampedDelta as a9, frozenContext as aA, gatedStream as aB, gaugesAsContext as aC, googleAdapter as aD, graphFromSpec as aE, graphFromSpecReactive as aF, handoff as aG, keywordFlagExtractor as aH, knobsAsTools as aI, llmConsolidator as aJ, llmExtractor as aK, memoryRetrieval as aL, memoryWithKG as aM, memoryWithTiers as aN, memoryWithVectors as aO, observableAdapter as aP, parseRateLimitFromError as aQ, promptCall as aR, promptNode as aS, redactor as aT, resilientAdapter as aU, streamExtractor as aV, streamingPromptNode as aW, suggestStrategy as aX, suggestStrategyReactive as aY, systemPromptBuilder as aZ, toolCallExtractor as a_, type StrategyOperation as aa, type StrategyPlan as ab, type StreamingPromptNodeHandle as ac, type StreamingPromptNodeOptions as ad, type SuggestStrategyOptions as ae, type SystemPromptHandle as af, type ToolExecutionOptions as ag, ToolRegistryGraph as ah, type ToolRegistryOptions as ai, type ToolResult as aj, type ToolSelectorOptions as ak, type WithBreakerOptions as al, type WithBudgetGateOptions as am, type WithDryRunBundle as an, type WithDryRunOptions as ao, type WithRateLimiterOptions as ap, type WithRetryOptions as aq, admissionFilter3D as ar, admissionScored as as, agentLoop as at, agentMemory as au, anthropicAdapter as av, chatStream as aw, contentGate as ax, costMeterExtractor as ay, dryRunAdapter as az, type AdmissionScoredOptions as b, toolRegistry as b0, toolSelector as b1, validateGraphDef as b2, withBreaker as b3, withBudgetGate as b4, withDryRun as b5, withRateLimiter as b6, withRetry as b7, withTimeout as b8, type AdmissionScores as c, type AdmissionThresholds as d, AgentLoopGraph as e, type AgentLoopOptions as f, type AgentLoopStatus as g, type AgentMemoryGraph as h, index as i, type AgentMemoryOptions as j, type AnthropicAdapterOptions as k, type AnthropicSdkLike as l, BudgetExhaustedError as m, type BudgetGateBundle as n, type BudgetTotals as o, ChatStreamGraph as p, type ChatStreamOptions as q, type ContentDecision as r, type ContentGateOptions as s, type CostMeterOptions as t, type CostMeterReading as u, type GatedStreamOptions as v, type GaugesAsContextOptions as w, type GoogleAdapterOptions as x, type GoogleSdkLike as y, type GoogleSdkRequestConfig as z };