@graphrefly/graphrefly 0.25.0 → 0.27.0

package/dist/ai-CaR_912Q.d.cts

@@ -0,0 +1,1033 @@
+import { N as Node, a as NodeOptions, t as NodeActions, A as Actor } from './node-BmerH3kS.cjs';
+import { D as DistillBundle, E as Extraction } from './composite-C7PcQvcs.cjs';
+import { NodeInput } from './extra/sources.cjs';
+import { a as StorageHandle, S as StorageTier } from './storage-DdWlZo6U.cjs';
+import { a as Graph, G as GraphOptions, k as GraphAttachStorageOptions } from './graph-DNCrvZSn.cjs';
+import { V as VectorIndexBundle, K as KnowledgeGraphGraph, L as LightCollectionBundle, a as VectorSearchResult } from './memory-C6Z2tGpC.cjs';
+import { T as TopicGraph } from './messaging-Gt4LPbyA.cjs';
+import { D as DerivedFn } from './sugar-D02n5JjF.cjs';
+
+/**
+ * Orchestration patterns (roadmap §4.1).
+ *
+ * Domain-layer helpers that build workflow shapes on top of core + extra primitives.
+ * Exported under the `patterns.orchestration` namespace to avoid collisions with
+ * Phase 2 operator names (for example `gate`, `forEach`).
+ */
+
+type StepRef = string | Node<unknown>;
+type OrchestrationMeta = {
+    orchestration?: true;
+    orchestration_type?: string;
+};
+type OrchestrationStepOptions = Omit<NodeOptions<unknown>, "describeKind" | "name" | "meta"> & {
+    deps?: ReadonlyArray<StepRef>;
+    meta?: Record<string, unknown> & OrchestrationMeta;
+};
+type BranchResult<T> = {
+    branch: "then" | "else";
+    value: T;
+};
+type SensorControls<T> = {
+    node: Node<T>;
+    push(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type LoopOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    iterations?: number | StepRef;
+};
+type WaitOptions = Omit<OrchestrationStepOptions, "deps">;
+type SubPipelineBuilder = (sub: Graph) => void;
+/**
+ * Creates an orchestration graph container.
+ */
+declare function pipeline(name: string, opts?: GraphOptions): Graph;
+/**
+ * Registers a workflow task node.
+ */
+declare function task<T>(graph: Graph, name: string, run: DerivedFn<T>, opts?: OrchestrationStepOptions): Node<T>;
+/**
+ * Emits tagged branch outcomes (`then` / `else`) for each source value.
+ */
+declare function branch<T>(graph: Graph, name: string, source: StepRef, predicate: (value: T) => boolean, opts?: Omit<OrchestrationStepOptions, "deps">): Node<BranchResult<T>>;
+/**
+ * Forwards source values only while `control` is truthy.
+ */
+declare function valve<T>(graph: Graph, name: string, source: StepRef, control: StepRef, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+type ApprovalOptions = Omit<OrchestrationStepOptions, "deps"> & {
+    isApproved?: (value: unknown) => boolean;
+};
+/**
+ * Human/LLM approval gate over a source value.
+ */
+declare function approval<T>(graph: Graph, name: string, source: StepRef, approver: StepRef, opts?: ApprovalOptions): Node<T>;
+interface GateOptions {
+    /** Maximum queue size. Oldest values are FIFO-dropped when exceeded. Default: Infinity. */
+    maxPending?: number;
+    /** Start in open mode (auto-approve). Default: false. */
+    startOpen?: boolean;
+    meta?: Record<string, unknown>;
+}
+/** Control surface returned by {@link gate}. */
+interface GateController<T> {
+    /** The output node registered in the graph (subscribe to receive approved values). */
+    node: Node<T>;
+    /** Reactive queue of values waiting for approval. */
+    pending: Node<T[]>;
+    /** Derived count of pending items. */
+    count: Node<number>;
+    /** Whether the gate is currently open (auto-approving). */
+    isOpen: Node<boolean>;
+    /** Approve and forward the next `count` pending values (default: 1). */
+    approve(count?: number): void;
+    /** Reject (discard) the next `count` pending values (default: 1). */
+    reject(count?: number): void;
+    /**
+     * Transform and forward `count` pending values (default: 1).
+     * `fn` receives `(value, index, pending)` — Array.map-style.
+     */
+    modify(fn: (value: T, index: number, pending: readonly T[]) => T, count?: number): void;
+    /** Flush all pending values and auto-approve future values. */
+    open(): void;
+    /** Re-enable manual gating (stop auto-approving). */
+    close(): void;
+}
+/**
+ * Human-in-the-loop gate: queues incoming values from `source` and lets an external
+ * controller {@link GateController.approve approve}, {@link GateController.reject reject},
+ * or {@link GateController.modify modify} them before forwarding downstream.
+ *
+ * Observable surfaces (`pending`, `count`, `isOpen`) are reactive nodes registered in
+ * the graph. The gate output node is also registered.
+ */
+declare function gate<T>(graph: Graph, name: string, source: StepRef, opts?: GateOptions): GateController<T>;
+/**
+ * Registers a workflow side-effect step that runs `run` for each upstream
+ * DATA value.
+ *
+ * `run` receives the full `NodeActions` and is the **sole emission point** —
+ * call `actions.emit(v)` or `actions.down(msgs)` inside `run` to produce
+ * downstream output. If `run` does not emit, this step acts as a pure
+ * side-effect sink (graph-observable but no output). Throwing inside `run`
+ * terminates the step with ERROR.
+ */
+declare function forEach<T>(graph: Graph, name: string, source: StepRef, run: (value: T, actions: NodeActions) => void, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+/**
+ * Registers a join step that emits a tuple of latest dependency values.
+ */
+declare function join<T extends readonly unknown[]>(graph: Graph, name: string, deps: {
+    [K in keyof T]: StepRef;
+}, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+/**
+ * Registers a loop step that applies `iterate` to each source value N times.
+ */
+declare function loop<T>(graph: Graph, name: string, source: StepRef, iterate: (value: T, iteration: number, actions: NodeActions) => T, opts?: LoopOptions): Node<T>;
+/**
+ * Mounts and returns a child workflow graph.
+ */
+declare function subPipeline(graph: Graph, name: string, childOrBuild?: Graph | SubPipelineBuilder, opts?: GraphOptions): Graph;
+/**
+ * Registers a producer-style sensor source and returns imperative controls.
+ */
+declare function sensor<T>(graph: Graph, name: string, initial?: T, opts?: Omit<NodeOptions<unknown>, "name" | "describeKind" | "meta"> & {
+    meta?: Record<string, unknown>;
+}): SensorControls<T>;
+/**
+ * Registers a delayed-forwarding step (value-level wait).
+ */
+declare function wait<T>(graph: Graph, name: string, source: StepRef, ms: number, opts?: WaitOptions): Node<T>;
+/**
+ * Registers an error-recovery step for a source.
+ */
+declare function onFailure<T>(graph: Graph, name: string, source: StepRef, recover: (err: unknown, actions: NodeActions) => T, opts?: Omit<OrchestrationStepOptions, "deps">): Node<T>;
+
+type orchestration_ApprovalOptions = ApprovalOptions;
+type orchestration_BranchResult<T> = BranchResult<T>;
+type orchestration_GateController<T> = GateController<T>;
+type orchestration_GateOptions = GateOptions;
+type orchestration_LoopOptions = LoopOptions;
+type orchestration_OrchestrationStepOptions = OrchestrationStepOptions;
+type orchestration_SensorControls<T> = SensorControls<T>;
+type orchestration_StepRef = StepRef;
+type orchestration_SubPipelineBuilder = SubPipelineBuilder;
+type orchestration_WaitOptions = WaitOptions;
+declare const orchestration_approval: typeof approval;
+declare const orchestration_branch: typeof branch;
+declare const orchestration_forEach: typeof forEach;
+declare const orchestration_gate: typeof gate;
+declare const orchestration_join: typeof join;
+declare const orchestration_loop: typeof loop;
+declare const orchestration_onFailure: typeof onFailure;
+declare const orchestration_pipeline: typeof pipeline;
+declare const orchestration_sensor: typeof sensor;
+declare const orchestration_subPipeline: typeof subPipeline;
+declare const orchestration_task: typeof task;
+declare const orchestration_valve: typeof valve;
+declare const orchestration_wait: typeof wait;
+declare namespace orchestration {
+  export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, type orchestration_GateController as GateController, type orchestration_GateOptions as GateOptions, type orchestration_LoopOptions as LoopOptions, type orchestration_OrchestrationStepOptions as OrchestrationStepOptions, type orchestration_SensorControls as SensorControls, type orchestration_StepRef as StepRef, type orchestration_SubPipelineBuilder as SubPipelineBuilder, type orchestration_WaitOptions as WaitOptions, orchestration_approval as approval, orchestration_branch as branch, orchestration_forEach as forEach, orchestration_gate as gate, orchestration_join as join, orchestration_loop as loop, orchestration_onFailure as onFailure, orchestration_pipeline as pipeline, orchestration_sensor as sensor, orchestration_subPipeline as subPipeline, orchestration_task as task, orchestration_valve as valve, orchestration_wait as wait };
+}
+
+/**
+ * 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.
+ */
+
+/** A single chat message in a conversation. */
+type ChatMessage = {
+    readonly role: "system" | "user" | "assistant" | "tool";
+    readonly content: string;
+    readonly name?: string;
+    readonly toolCallId?: string;
+    readonly toolCalls?: readonly ToolCall[];
+    readonly metadata?: Record<string, unknown>;
+};
+/** A tool invocation request from an LLM. */
+type ToolCall = {
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: Record<string, unknown>;
+};
+/** The response from an LLM invocation. */
+type LLMResponse = {
+    readonly content: string;
+    readonly toolCalls?: readonly ToolCall[];
+    readonly usage?: {
+        readonly inputTokens: number;
+        readonly outputTokens: number;
+    };
+    readonly finishReason?: string;
+    readonly metadata?: Record<string, unknown>;
+};
+/** Provider-agnostic LLM client adapter protocol. */
+type LLMAdapter = {
+    invoke(messages: readonly ChatMessage[], opts?: LLMInvokeOptions): NodeInput<LLMResponse>;
+    stream(messages: readonly ChatMessage[], opts?: LLMInvokeOptions): AsyncIterable<string>;
+};
+type LLMInvokeOptions = {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: readonly ToolDefinition[];
+    systemPrompt?: string;
+    signal?: AbortSignal;
+};
+/** A tool definition for LLM consumption. */
+type ToolDefinition = {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+    readonly handler: (args: Record<string, unknown>) => NodeInput<unknown>;
+    /**
+     * V0 version of the backing node at `knobsAsTools()` call time (§6.0b).
+     * Snapshot — re-call `knobsAsTools()` to refresh.
+     */
+    readonly version?: {
+        id: string;
+        version: number;
+    };
+};
+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 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>;
+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;
+/**
+ * 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[];
+};
+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;
+};
+/** 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">;
+};
+/** 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;
+    /** 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;
+};
+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;
+};
+declare class AgentLoopGraph extends Graph {
+    readonly chat: ChatStreamGraph;
+    readonly tools: ToolRegistryGraph;
+    readonly status: Node<AgentLoopStatus>;
+    readonly turnCount: Node<number>;
+    readonly lastResponse: Node<LLMResponse | null>;
+    private readonly _statusState;
+    private readonly _turnCountState;
+    private readonly _adapter;
+    private readonly _maxTurns;
+    private readonly _stopWhen?;
+    private readonly _onToolCall?;
+    private readonly _systemPrompt?;
+    private readonly _model?;
+    private readonly _temperature?;
+    private readonly _maxTokens?;
+    private _running;
+    private _abortController;
+    constructor(name: string, opts: AgentLoopOptions);
+    /**
+     * Start the agent loop with a user message. The loop runs reactively:
+     * think (LLM call) → act (tool execution) → repeat until done.
+     *
+     * Messages accumulate across calls. Call `chat.clear()` before `run()`
+     * to reset conversation history.
+     */
+    run(userMessage: string): Promise<LLMResponse | null>;
+    private _invokeLLM;
+    private _shouldStop;
+    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>;
+
+type ai_AdmissionScore3DOptions = AdmissionScore3DOptions;
+type ai_AdmissionScores = AdmissionScores;
+type ai_AgentLoopGraph = AgentLoopGraph;
+declare const ai_AgentLoopGraph: typeof AgentLoopGraph;
+type ai_AgentLoopOptions = AgentLoopOptions;
+type ai_AgentLoopStatus = AgentLoopStatus;
+type ai_AgentMemoryGraph<TMem = unknown> = AgentMemoryGraph<TMem>;
+type ai_AgentMemoryOptions<TMem = unknown> = AgentMemoryOptions<TMem>;
+type ai_ChatMessage = ChatMessage;
+type ai_ChatStreamGraph = ChatStreamGraph;
+declare const ai_ChatStreamGraph: typeof ChatStreamGraph;
+type ai_ChatStreamOptions = ChatStreamOptions;
+type ai_ContentDecision = ContentDecision;
+type ai_ContentGateOptions = ContentGateOptions;
+type ai_CostMeterOptions = CostMeterOptions;
+type ai_CostMeterReading = CostMeterReading;
+type ai_ExtractedToolCall = ExtractedToolCall;
+type ai_FromLLMOptions = FromLLMOptions;
+type ai_GatedStreamHandle<T> = GatedStreamHandle<T>;
+type ai_GatedStreamOptions = GatedStreamOptions;
+type ai_GaugesAsContextOptions = GaugesAsContextOptions;
+type ai_GraphDefValidation = GraphDefValidation;
+type ai_GraphFromSpecOptions = GraphFromSpecOptions;
+type ai_KeywordFlag = KeywordFlag;
+type ai_KeywordFlagExtractorOptions = KeywordFlagExtractorOptions;
+type ai_KnobsAsToolsResult = KnobsAsToolsResult;
+type ai_LLMAdapter = LLMAdapter;
+type ai_LLMConsolidatorOptions = LLMConsolidatorOptions;
+type ai_LLMExtractorOptions = LLMExtractorOptions;
+type ai_LLMInvokeOptions = LLMInvokeOptions;
+type ai_LLMResponse = LLMResponse;
+type ai_McpToolSchema = McpToolSchema;
+type ai_MemoryTier = MemoryTier;
+type ai_MemoryTiersBundle<TMem> = MemoryTiersBundle<TMem>;
+type ai_MemoryTiersOptions<TMem> = MemoryTiersOptions<TMem>;
+type ai_OpenAIToolSchema = OpenAIToolSchema;
+type ai_PromptNodeOptions = PromptNodeOptions;
+type ai_RedactorOptions = RedactorOptions;
+type ai_RetrievalEntry<TMem> = RetrievalEntry<TMem>;
+type ai_RetrievalPipelineOptions<TMem> = RetrievalPipelineOptions<TMem>;
+type ai_RetrievalQuery = RetrievalQuery;
+type ai_RetrievalTrace<TMem> = RetrievalTrace<TMem>;
+type ai_StrategyOperation = StrategyOperation;
+type ai_StrategyPlan = StrategyPlan;
+type ai_StreamChunk = StreamChunk;
+type ai_StreamingPromptNodeHandle<T> = StreamingPromptNodeHandle<T>;
+type ai_StreamingPromptNodeOptions = StreamingPromptNodeOptions;
+type ai_SuggestStrategyOptions = SuggestStrategyOptions;
+type ai_SystemPromptHandle = SystemPromptHandle;
+type ai_ToolCall = ToolCall;
+type ai_ToolDefinition = ToolDefinition;
+type ai_ToolRegistryGraph = ToolRegistryGraph;
+declare const ai_ToolRegistryGraph: typeof ToolRegistryGraph;
+type ai_ToolRegistryOptions = ToolRegistryOptions;
+declare const ai_admissionFilter3D: typeof admissionFilter3D;
+declare const ai_agentLoop: typeof agentLoop;
+declare const ai_agentMemory: typeof agentMemory;
+declare const ai_chatStream: typeof chatStream;
+declare const ai_contentGate: typeof contentGate;
+declare const ai_costMeterExtractor: typeof costMeterExtractor;
+declare const ai_fromLLM: typeof fromLLM;
+declare const ai_gatedStream: typeof gatedStream;
+declare const ai_gaugesAsContext: typeof gaugesAsContext;
+declare const ai_graphFromSpec: typeof graphFromSpec;
+declare const ai_keywordFlagExtractor: typeof keywordFlagExtractor;
+declare const ai_knobsAsTools: typeof knobsAsTools;
+declare const ai_llmConsolidator: typeof llmConsolidator;
+declare const ai_llmExtractor: typeof llmExtractor;
+declare const ai_promptNode: typeof promptNode;
+declare const ai_redactor: typeof redactor;
+declare const ai_streamExtractor: typeof streamExtractor;
+declare const ai_streamingPromptNode: typeof streamingPromptNode;
+declare const ai_suggestStrategy: typeof suggestStrategy;
+declare const ai_systemPromptBuilder: typeof systemPromptBuilder;
+declare const ai_toolCallExtractor: typeof toolCallExtractor;
+declare const ai_toolRegistry: typeof toolRegistry;
+declare const ai_validateGraphDef: typeof validateGraphDef;
+declare namespace ai {
+  export { type ai_AdmissionScore3DOptions as AdmissionScore3DOptions, type ai_AdmissionScores as AdmissionScores, ai_AgentLoopGraph as AgentLoopGraph, type ai_AgentLoopOptions as AgentLoopOptions, type ai_AgentLoopStatus as AgentLoopStatus, type ai_AgentMemoryGraph as AgentMemoryGraph, type ai_AgentMemoryOptions as AgentMemoryOptions, type ai_ChatMessage as ChatMessage, ai_ChatStreamGraph as ChatStreamGraph, type ai_ChatStreamOptions as ChatStreamOptions, type ai_ContentDecision as ContentDecision, type ai_ContentGateOptions as ContentGateOptions, type ai_CostMeterOptions as CostMeterOptions, type ai_CostMeterReading as CostMeterReading, type ai_ExtractedToolCall as ExtractedToolCall, type ai_FromLLMOptions as FromLLMOptions, type ai_GatedStreamHandle as GatedStreamHandle, type ai_GatedStreamOptions as GatedStreamOptions, type ai_GaugesAsContextOptions as GaugesAsContextOptions, type ai_GraphDefValidation as GraphDefValidation, type ai_GraphFromSpecOptions as GraphFromSpecOptions, type ai_KeywordFlag as KeywordFlag, type ai_KeywordFlagExtractorOptions as KeywordFlagExtractorOptions, type ai_KnobsAsToolsResult as KnobsAsToolsResult, type ai_LLMAdapter as LLMAdapter, type ai_LLMConsolidatorOptions as LLMConsolidatorOptions, type ai_LLMExtractorOptions as LLMExtractorOptions, type ai_LLMInvokeOptions as LLMInvokeOptions, type ai_LLMResponse as LLMResponse, type ai_McpToolSchema as McpToolSchema, type ai_MemoryTier as MemoryTier, type ai_MemoryTiersBundle as MemoryTiersBundle, type ai_MemoryTiersOptions as MemoryTiersOptions, type ai_OpenAIToolSchema as OpenAIToolSchema, type ai_PromptNodeOptions as PromptNodeOptions, type ai_RedactorOptions as RedactorOptions, type ai_RetrievalEntry as RetrievalEntry, type ai_RetrievalPipelineOptions as RetrievalPipelineOptions, type ai_RetrievalQuery as RetrievalQuery, type ai_RetrievalTrace as RetrievalTrace, type ai_StrategyOperation as StrategyOperation, type ai_StrategyPlan as StrategyPlan, type ai_StreamChunk as StreamChunk, type ai_StreamingPromptNodeHandle as StreamingPromptNodeHandle, type ai_StreamingPromptNodeOptions as StreamingPromptNodeOptions, type ai_SuggestStrategyOptions as SuggestStrategyOptions, type ai_SystemPromptHandle as SystemPromptHandle, type ai_ToolCall as ToolCall, type ai_ToolDefinition as ToolDefinition, ai_ToolRegistryGraph as ToolRegistryGraph, type ai_ToolRegistryOptions as ToolRegistryOptions, ai_admissionFilter3D as admissionFilter3D, ai_agentLoop as agentLoop, ai_agentMemory as agentMemory, ai_chatStream as chatStream, ai_contentGate as contentGate, ai_costMeterExtractor as costMeterExtractor, ai_fromLLM as fromLLM, ai_gatedStream as gatedStream, ai_gaugesAsContext as gaugesAsContext, ai_graphFromSpec as graphFromSpec, ai_keywordFlagExtractor as keywordFlagExtractor, ai_knobsAsTools as knobsAsTools, ai_llmConsolidator as llmConsolidator, ai_llmExtractor as llmExtractor, ai_promptNode as promptNode, ai_redactor as redactor, ai_streamExtractor as streamExtractor, ai_streamingPromptNode as streamingPromptNode, ai_suggestStrategy as suggestStrategy, ai_systemPromptBuilder as systemPromptBuilder, ai_toolCallExtractor as toolCallExtractor, ai_toolRegistry as toolRegistry, ai_validateGraphDef as validateGraphDef };
+}
+
+export { type ToolRegistryOptions as $, type AdmissionScore3DOptions as A, type MemoryTiersBundle as B, type ChatMessage as C, type MemoryTiersOptions as D, type ExtractedToolCall as E, type FromLLMOptions as F, type GateController as G, type RetrievalEntry as H, type RetrievalPipelineOptions as I, type RetrievalQuery as J, type KeywordFlag as K, type LLMAdapter as L, type McpToolSchema as M, type RetrievalTrace as N, type OpenAIToolSchema as O, type PromptNodeOptions as P, type StrategyPlan as Q, type RedactorOptions as R, type StrategyOperation as S, type StreamChunk as T, type StreamingPromptNodeHandle as U, type StreamingPromptNodeOptions as V, type SuggestStrategyOptions as W, type SystemPromptHandle as X, type ToolCall as Y, type ToolDefinition as Z, ToolRegistryGraph as _, ai as a, admissionFilter3D as a0, agentLoop as a1, agentMemory as a2, chatStream as a3, contentGate as a4, costMeterExtractor as a5, fromLLM as a6, gatedStream as a7, gaugesAsContext as a8, graphFromSpec as a9, keywordFlagExtractor as aa, knobsAsTools as ab, llmConsolidator as ac, llmExtractor as ad, promptNode as ae, redactor as af, streamExtractor as ag, streamingPromptNode as ah, suggestStrategy as ai, systemPromptBuilder as aj, toolCallExtractor as ak, toolRegistry as al, validateGraphDef as am, type AdmissionScores as b, AgentLoopGraph as c, type AgentLoopOptions as d, type AgentLoopStatus as e, type AgentMemoryGraph as f, type AgentMemoryOptions as g, ChatStreamGraph as h, type ChatStreamOptions as i, type ContentDecision as j, type ContentGateOptions as k, type CostMeterOptions as l, type CostMeterReading as m, type GatedStreamHandle as n, orchestration as o, type GatedStreamOptions as p, type GaugesAsContextOptions as q, type GraphDefValidation as r, type GraphFromSpecOptions as s, type KeywordFlagExtractorOptions as t, type KnobsAsToolsResult as u, type LLMConsolidatorOptions as v, type LLMExtractorOptions as w, type LLMInvokeOptions as x, type LLMResponse as y, type MemoryTier as z };