@graphrefly/graphrefly 0.27.0 → 0.28.0

package/dist/index-DEwTb_fm.d.cts

@@ -0,0 +1,1957 @@
+import { a as Node, A as Actor } from './node-Cc1TniY8.cjs';
+import { D as DistillBundle, E as Extraction } from './composite-B-xqw4Kk.cjs';
+import { NodeInput } from './extra/sources.cjs';
+import { StorageHandle, StorageTier } from './extra/storage-core.cjs';
+import { G as Graph, a as GraphOptions, h as GraphAttachStorageOptions } from './graph-D48Qw9Cg.cjs';
+import { V as VectorIndexBundle, K as KnowledgeGraphGraph, L as LightCollectionBundle, a as VectorSearchResult } from './index-tbf2gKHd.cjs';
+import { T as TopicGraph } from './index-DyxjtScX.cjs';
+import { G as GateController, a as GateOptions } from './index-dtN7YA2x.cjs';
+import { T as TokenUsage, L as LLMAdapter, P as PricingFn, C as ChatMessage, a as LLMInvokeOptions, d as ToolDefinition, b as LLMResponse, 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, S as StreamDelta, k as TieredRate, l as composePricing, m as computePrice, n as createCapabilitiesRegistry, o as createPricingRegistry, r as registryPricing, z as zeroPrice } from './types-O3GzJY2U.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 } from './cascading-B-5zmAUv.cjs';
+import { R as ReactiveLogBundle } from './reactive-log-DPzuUDj5.cjs';
+import { a as CircuitBreakerOptions, e as CircuitBreaker, f as CircuitOpenError } from './resilience-Ba5-b4WD.cjs';
+import { F as FallbackAdapterOptions, a as FallbackFixture, b as FallbackMissError, c as FallbackMissPolicy, R as ReplayCacheKeyContext, d as ReplayCacheMissError, e as ReplayCacheMode, W as WithReplayCacheOptions, f as canonicalJson, g as fallbackAdapter, w as withReplayCache } from './fallback-BaTS7vVY.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. Rationale lives in
+ * `archive/docs/SESSION-rigor-infrastructure-plan.md` §"v2: reactive LLM
+ * statistics + pluggable pricing".
+ */
+
+/** 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;
+}
+/**
+ * Wrap any {@link LLMAdapter} with a reactive stats bundle.
+ *
+ * Implementation:
+ * - `stats.lastCall` is a `state<CallStatsEvent | undefined>` exposed via a
+ *   null-filtering derived so consumers see a typed `Node<CallStatsEvent>`.
+ * - Counters (`totalCalls` / `totalInputTokens` / `totalOutputTokens`) are
+ *   plain state nodes updated via `.emit()`.
+ * - `stats.allCalls` is a `reactiveLog<CallStatsEvent>` — bounded, supports
+ *   `tail(n)` / `slice(start, stop)` for dashboard views.
+ * - The wrapped adapter passes DATA through via a `derived` tap that writes
+ *   to the stats nodes as a side-effect. No pricing — users compose pricing
+ *   as a derived on top of `stats.lastCall`.
+ */
+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.
+ */
+
+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;
+}
+/** 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.
+ *
+ * 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 SDK instance (`@google/genai` or `@google/generative-ai` shape). */
+    sdk?: GoogleSdkLike;
+    fetchImpl?: typeof fetch;
+}
+interface GoogleSdkLike {
+    models: {
+        generateContent(params: Record<string, unknown>, opts?: {
+            signal?: AbortSignal;
+        }): Promise<GeminiResponse>;
+        generateContentStream?(params: Record<string, unknown>, opts?: {
+            signal?: AbortSignal;
+        }): AsyncIterable<GeminiResponse>;
+    };
+}
+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;
+
+/**
+ * Curated `cascadingLlmAdapter` presets — Node/browser-safe subset.
+ *
+ * Thin compositions over `cascadingLlmAdapter` + `createAdapter`. No new
+ * logic — just convenient defaults. Users needing finer control call
+ * `cascadingLlmAdapter` directly.
+ *
+ * Presets that depend on browser-only adapters (WebLLM, Chrome Nano) have
+ * been split out to [`./browser-presets.ts`](./browser-presets.ts) and are
+ * exported from the `@graphrefly/graphrefly/patterns/ai/browser`
+ * subpath so they don't leak into Node bundles.
+ *
+ * @module
+ */
+
+declare function dryRunPreset(): LLMAdapter;
+
+/**
+ * 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.
+ */
+
+type AgentLoopStatus = "idle" | "thinking" | "acting" | "done" | "error";
+/**
+ * A single chunk from any streaming source (LLM tokens, WebSocket, SSE, file tail).
+ * Generic enough for any streaming source, not just LLM.
+ */
+type StreamChunk = {
+    /** Identifier for the stream source (adapter name, URL, etc.). */
+    readonly source: string;
+    /** This chunk's content. */
+    readonly token: string;
+    /** Full accumulated text so far. */
+    readonly accumulated: string;
+    /** 0-based chunk counter. */
+    readonly index: number;
+};
+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 — use this for session-start snapshots
+     * that must stay stable for the lifetime of the activation.
+     */
+    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>;
+type FromLLMOptions = {
+    name?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: readonly ToolDefinition[];
+    systemPrompt?: string;
+};
+/**
+ * Reactive LLM invocation adapter. Returns a derived node that re-invokes
+ * the LLM whenever the messages dep changes.
+ *
+ * Uses `switchMap` internally — new invocations cancel stale in-flight ones.
+ */
+declare function fromLLM(adapter: LLMAdapter, messages: NodeInput<readonly ChatMessage[]>, opts?: FromLLMOptions): Node<LLMResponse | null>;
+type StreamingPromptNodeOptions = {
+    name?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Output format — `"json"` attempts JSON.parse on the final accumulated text. Default: `"text"`. */
+    format?: "text" | "json";
+    systemPrompt?: string;
+};
+/**
+ * Bundle returned by {@link streamingPromptNode}.
+ */
+type StreamingPromptNodeHandle<T> = {
+    /** Final parsed result (emits once per invocation, after stream completes). */
+    output: Node<T | null>;
+    /** Live stream topic — subscribe to `stream.latest` or `stream.events` for chunks. */
+    stream: TopicGraph<StreamChunk>;
+    /** Tear down the keepalive subscription 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`.
+ *
+ * Each token chunk is published to a {@link TopicGraph} as a {@link StreamChunk}.
+ * Extractors can mount on the topic independently (see {@link streamExtractor}).
+ * Zero overhead if nobody subscribes to the stream topic.
+ *
+ * The `output` node emits the final parsed result (like {@link promptNode}).
+ * The async boundary is handled by `fromAny` (spec §5.10 compliant).
+ */
+declare function streamingPromptNode<T = string>(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: StreamingPromptNodeOptions): StreamingPromptNodeHandle<T>;
+/**
+ * Mounts an extractor function on a streaming topic. Returns a derived node
+ * that emits extracted values as chunks arrive.
+ *
+ * `extractFn` receives the accumulated text from the latest chunk and returns
+ * the extracted value, or `null` if nothing detected yet. This is the building
+ * block for keyword flags, tool call detection, cost metering, etc.
+ *
+ * @param streamTopic - The stream topic to extract from.
+ * @param extractFn - `(accumulated: string) => T | null`.
+ * @param opts - Optional name.
+ * @returns Derived node emitting extracted values.
+ */
+declare function streamExtractor<T>(streamTopic: TopicGraph<StreamChunk>, 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>;
+/** 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 a streaming topic. Scans accumulated text
+ * for all configured patterns and emits an array of matches.
+ *
+ * Use cases: design invariant violations (`setTimeout`, `EventEmitter`), PII
+ * detection (SSN, email, phone), toxicity keywords, off-track reasoning.
+ *
+ * **Streaming optimization.** Maintains a cursor across chunks in `ctx.store`
+ * so each chunk scans only the delta region `accumulated.slice(scannedTo -
+ * maxPatternLength)` — not the full string. Default structural equals
+ * suppresses DATA emission when no new flags were found this chunk.
+ */
+declare function keywordFlagExtractor(streamTopic: TopicGraph<StreamChunk>, opts: KeywordFlagExtractorOptions): Node<readonly KeywordFlag[]>;
+/** 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(streamTopic: TopicGraph<StreamChunk>, opts?: {
+    name?: string;
+}): Node<readonly ExtractedToolCall[]>;
+/** A cost meter reading from the stream. */
+type CostMeterReading = {
+    readonly chunkCount: number;
+    readonly charCount: number;
+    readonly estimatedTokens: number;
+};
+type CostMeterOptions = {
+    /** Characters per token approximation. Default: 4 (GPT-family). */
+    charsPerToken?: number;
+    name?: string;
+};
+/**
+ * Mounts a cost meter on a streaming topic. Counts chunks, characters, and
+ * estimates token count. Compose with `budgetGate` for hard-stop when LLM
+ * output exceeds budget mid-generation.
+ *
+ * Default structural equals suppresses DATA emission when two consecutive
+ * readings are identical (same chunk count + char count + token estimate).
+ */
+declare function costMeterExtractor(streamTopic: TopicGraph<StreamChunk>, opts?: CostMeterOptions): Node<CostMeterReading>;
+/** Options for {@link redactor}. */
+type RedactorOptions = {
+    name?: string;
+};
+/**
+ * Stream extractor that replaces matched patterns in the accumulated text.
+ *
+ * Returns a derived node emitting a sanitized `StreamChunk` on every chunk:
+ * `accumulated` and `token` have matched substrings replaced by `replaceFn`.
+ * The default `replaceFn` replaces with `"[REDACTED]"`.
+ *
+ * Compose with `contentGate` for in-flight safety pipelines.
+ *
+ * @param streamTopic - Streaming topic to monitor.
+ * @param patterns    - Array of RegExps to match against accumulated text.
+ * @param replaceFn   - Replacement producer (default: always `"[REDACTED]"`).
+ */
+declare function redactor(streamTopic: TopicGraph<StreamChunk>, patterns: RegExp[], replaceFn?: (match: string, pattern: RegExp) => string, opts?: RedactorOptions): Node<StreamChunk>;
+/** 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.
+ *
+ * Emits a three-way decision on every new chunk:
+ * - `"allow"` — score below `threshold`
+ * - `"review"` — score in `[threshold, threshold × hardMultiplier)`
+ * - `"block"` — score at or above `threshold × hardMultiplier`
+ *
+ * Wire the output into a `valve` (automatic) or `gate` (human approval).
+ * This node does not itself control flow — it just classifies.
+ *
+ * @param streamTopic - Streaming topic to classify.
+ * @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(streamTopic: TopicGraph<StreamChunk>, classifier: ((accumulated: string) => number) | Node<number>, threshold: number, opts?: ContentGateOptions): Node<ContentDecision>;
+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 stream topic — subscribe to `stream.latest` for chunks. */
+    stream: TopicGraph<StreamChunk>;
+    /** Gate controller — approve, reject (aborts in-flight stream), modify. */
+    gate: GateController<T | null>;
+    /** Tear down everything. */
+    dispose: () => void;
+};
+/**
+ * Streaming LLM transform with human-in-the-loop gate integration.
+ *
+ * Composes {@link streamingPromptNode} with {@link gate} so that:
+ * - `gate.reject()` discards the pending value **and** aborts the in-flight
+ *   stream (cancels the `AbortController`).
+ * - `gate.modify()` transforms the pending value before forwarding downstream.
+ * - `gate.approve()` forwards the final result as normal.
+ *
+ * The abort-on-reject works by toggling an internal cancel signal that causes
+ * the `switchMap` inside `streamingPromptNode` to restart with an empty message
+ * list, which triggers the `AbortController.abort()` in the async generator's
+ * `finally` block.
+ */
+declare function gatedStream<T = string>(graph: Graph, name: string, adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: GatedStreamOptions): GatedStreamHandle<T>;
+type PromptNodeOptions = {
+    name?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Output format — `"json"` attempts JSON.parse on the response. Default: `"text"`. */
+    format?: "text" | "json";
+    /** Number of retries on transient errors. Default: 0. */
+    retries?: number;
+    /** Cache LLM responses for identical inputs. Default: false. */
+    cache?: boolean;
+    systemPrompt?: string;
+    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.
+ *
+ * @param adapter - LLM adapter (provider-agnostic).
+ * @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<T = string>(adapter: LLMAdapter, deps: readonly Node<unknown>[], prompt: string | ((...depValues: unknown[]) => string), opts?: PromptNodeOptions): Node<T | null>;
+/**
+ * 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.
+ *
+ * @category patterns.ai
+ */
+declare function handoff<T>(from: NodeInput<T | null>, toFactory: (input: Node<T>) => Node<T | null>, opts?: HandoffOptions): Node<T | null>;
+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;
+type ToolRegistryOptions = {
+    graph?: GraphOptions;
+};
+declare class ToolRegistryGraph extends Graph {
+    readonly definitions: Node<ReadonlyMap<string, ToolDefinition>>;
+    readonly schemas: Node<readonly ToolDefinition[]>;
+    constructor(name: string, opts?: ToolRegistryOptions);
+    register(tool: ToolDefinition): void;
+    unregister(name: string): void;
+    execute(name: string, args: Record<string, unknown>): Promise<unknown>;
+    getDefinition(name: string): ToolDefinition | undefined;
+}
+declare function toolRegistry(name: string, opts?: ToolRegistryOptions): ToolRegistryGraph;
+/**
+ * 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[]>;
+/**
+ * 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;
+type LLMExtractorOptions = {
+    adapter: LLMAdapter;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+};
+/**
+ * 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] }`.
+ */
+declare function llmExtractor<TRaw, TMem>(systemPrompt: string, opts: LLMExtractorOptions): (raw: TRaw, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
+type LLMConsolidatorOptions = LLMExtractorOptions;
+/**
+ * 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>>;
+/** 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. Default: rule-based (all dimensions 0.5). */
+    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;
+};
+/**
+ * Creates a 3D admission filter function compatible with `agentMemory`'s
+ * `admissionFilter` option. Scores each candidate on persistence, structure,
+ * and personalValue, then applies thresholds.
+ */
+declare function admissionFilter3D(opts?: AdmissionScore3DOptions): (raw: unknown) => boolean;
+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?: StorageTier;
+    /** Options forwarded to `graph.attachStorage` for the archive tier. */
+    archiveStorageOptions?: GraphAttachStorageOptions;
+};
+type MemoryTiersBundle<TMem> = {
+    /** Permanent tier: never evicted. */
+    readonly permanent: LightCollectionBundle<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 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 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: VectorIndexBundle<TMem> | null;
+    /** Knowledge graph (null if not enabled). */
+    readonly kg: KnowledgeGraphGraph<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;
+};
+declare function agentMemory<TMem = unknown>(name: string, source: NodeInput<unknown>, opts: AgentMemoryOptions<TMem>): AgentMemoryGraph<TMem>;
+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[]>;
+};
+/** A single tool execution outcome: `{id, content}` where content is a JSON string. */
+interface ToolResult {
+    readonly id: string;
+    readonly content: string;
+}
+/**
+ * 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` / `execute` at boundary)
+ * - `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
+ */
+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[]>;
+    /** @deprecated Use `turn` instead. Pre-1.0 rename — this alias will be removed. */
+    readonly turnCount: Node<number>;
+    private readonly _terminalResult;
+    private readonly _disposeRunWiring;
+    /**
+     * Per-agent monotonic run counter. Incremented at the start of every
+     * `run()` call; stamped onto `_terminalResult`'s DATA emissions so a
+     * caller's `awaitSettled` predicate resolves only on the matching run
+     * (prevents stale-resolution under re-entrant-ish composition).
+     */
+    private _runVersion;
+    /** 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. Each call increments an
+     * internal `_runVersion` and filters `_terminalResult` emissions by that
+     * version — belt-and-suspenders against stale resolution.
+     */
+    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;
+/** 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;
+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;
+/** 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;
+type GraphFromSpecOptions = {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Callback to construct topology before values are applied (passed to `Graph.fromSnapshot`). */
+    build?: (g: Graph) => void;
+    /** Extra instructions appended to the system prompt. */
+    systemPromptExtra?: string;
+};
+/**
+ * Ask an LLM to compose a Graph from a natural-language description.
+ *
+ * The LLM returns a JSON graph definition which is validated and then
+ * constructed via `Graph.fromSnapshot()`.
+ *
+ * @param naturalLanguage - The problem/use-case description.
+ * @param adapter - LLM adapter for the generation call.
+ * @param opts - Model options and optional `build` callback for node factories.
+ * @returns A constructed Graph.
+ * @throws On invalid LLM output or validation failure.
+ */
+declare function graphFromSpec(naturalLanguage: string, adapter: LLMAdapter, opts?: GraphFromSpecOptions): Promise<Graph>;
+/** 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;
+};
+/**
+ * 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>;
+
+declare const index_AdapterProvider: typeof AdapterProvider;
+type index_AdapterStats = AdapterStats;
+declare const index_AdapterTier: typeof AdapterTier;
+type index_AdmissionScore3DOptions = AdmissionScore3DOptions;
+type index_AdmissionScores = AdmissionScores;
+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;
+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_FromLLMOptions = FromLLMOptions;
+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_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_MemoryTier = MemoryTier;
+type index_MemoryTiersBundle<TMem> = MemoryTiersBundle<TMem>;
+type index_MemoryTiersOptions<TMem> = MemoryTiersOptions<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_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_StrategyOperation = StrategyOperation;
+type index_StrategyPlan = StrategyPlan;
+type index_StreamChunk = StreamChunk;
+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_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_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_dryRunPreset: typeof dryRunPreset;
+declare const index_fallbackAdapter: typeof fallbackAdapter;
+declare const index_fromLLM: typeof fromLLM;
+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_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_observableAdapter: typeof observableAdapter;
+declare const index_openAICompatAdapter: typeof openAICompatAdapter;
+declare const index_parseRateLimitFromError: typeof parseRateLimitFromError;
+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_systemPromptBuilder: typeof systemPromptBuilder;
+declare const index_toolCallExtractor: typeof toolCallExtractor;
+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_AdmissionScores as AdmissionScores, 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, 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_FromLLMOptions as FromLLMOptions, 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_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_MemoryTier as MemoryTier, type index_MemoryTiersBundle as MemoryTiersBundle, type index_MemoryTiersOptions as MemoryTiersOptions, 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_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_StrategyOperation as StrategyOperation, type index_StrategyPlan as StrategyPlan, type index_StreamChunk as StreamChunk, 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, 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_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_dryRunPreset as dryRunPreset, index_fallbackAdapter as fallbackAdapter, index_fromLLM as fromLLM, index_frozenContext as frozenContext, index_gatedStream as gatedStream, index_gaugesAsContext as gaugesAsContext, index_googleAdapter as googleAdapter, index_graphFromSpec as graphFromSpec, index_handoff as handoff, index_keywordFlagExtractor as keywordFlagExtractor, index_knobsAsTools as knobsAsTools, index_llmConsolidator as llmConsolidator, index_llmExtractor as llmExtractor, index_observableAdapter as observableAdapter, index_openAICompatAdapter as openAICompatAdapter, index_parseRateLimitFromError as parseRateLimitFromError, 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_systemPromptBuilder as systemPromptBuilder, index_toolCallExtractor as toolCallExtractor, 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 RetrievalTrace as $, type AdapterStats as A, type BudgetCaps as B, type CallStatsEvent as C, type DryRunAdapterOptions as D, type ExtractedToolCall as E, type FromLLMOptions as F, type GatedStreamHandle as G, type HandoffOptions as H, type HttpErrorLike as I, type KeywordFlagExtractorOptions as J, type KeywordFlag as K, type KnobsAsToolsResult as L, type LLMConsolidatorOptions as M, type LLMExtractorOptions as N, LLMTimeoutError as O, type McpToolSchema as P, type MemoryTier as Q, type MemoryTiersBundle as R, type MemoryTiersOptions as S, type OpenAIToolSchema as T, type PromptNodeOptions as U, type RedactorOptions as V, type ResilientAdapterBundle as W, type ResilientAdapterOptions as X, type RetrievalEntry as Y, type RetrievalPipelineOptions as Z, type RetrievalQuery as _, type AdmissionScore3DOptions as a, type StrategyOperation as a0, type StrategyPlan as a1, type StreamChunk as a2, type StreamingPromptNodeHandle as a3, type StreamingPromptNodeOptions as a4, type SuggestStrategyOptions as a5, type SystemPromptHandle as a6, ToolRegistryGraph as a7, type ToolRegistryOptions as a8, type ToolResult as a9, llmExtractor as aA, observableAdapter as aB, parseRateLimitFromError as aC, promptNode as aD, redactor as aE, resilientAdapter as aF, streamExtractor as aG, streamingPromptNode as aH, suggestStrategy as aI, systemPromptBuilder as aJ, toolCallExtractor as aK, toolRegistry as aL, toolSelector as aM, validateGraphDef as aN, withBreaker as aO, withBudgetGate as aP, withDryRun as aQ, withRateLimiter as aR, withRetry as aS, withTimeout as aT, type ToolSelectorOptions as aa, type WithBreakerOptions as ab, type WithBudgetGateOptions as ac, type WithDryRunBundle as ad, type WithDryRunOptions as ae, type WithRateLimiterOptions as af, type WithRetryOptions as ag, admissionFilter3D as ah, agentLoop as ai, agentMemory as aj, anthropicAdapter as ak, chatStream as al, contentGate as am, costMeterExtractor as an, dryRunAdapter as ao, dryRunPreset as ap, fromLLM as aq, frozenContext as ar, gatedStream as as, gaugesAsContext as at, googleAdapter as au, graphFromSpec as av, handoff as aw, keywordFlagExtractor as ax, knobsAsTools as ay, llmConsolidator as az, type AdmissionScores as b, AgentLoopGraph as c, type AgentLoopOptions as d, type AgentLoopStatus as e, type AgentMemoryGraph as f, type AgentMemoryOptions as g, type AnthropicAdapterOptions as h, index as i, type AnthropicSdkLike as j, BudgetExhaustedError as k, type BudgetGateBundle as l, type BudgetTotals as m, ChatStreamGraph as n, type ChatStreamOptions as o, type ContentDecision as p, type ContentGateOptions as q, type CostMeterOptions as r, type CostMeterReading as s, type FrozenContextOptions as t, type GatedStreamOptions as u, type GaugesAsContextOptions as v, type GoogleAdapterOptions as w, type GoogleSdkLike as x, type GraphDefValidation as y, type GraphFromSpecOptions as z };