@raisindb/client 0.5.7 → 0.5.9

package/dist/{conversation-list-store-BaeGM2lx.d.ts → conversation-list-store-CHaqGtSi.d.ts}

@@ -215,6 +215,15 @@ declare enum RequestType {
     FlowCancel = "flow_cancel",
     FlowSubscribeEvents = "flow_subscribe_events",
     FlowUnsubscribeEvents = "flow_unsubscribe_events",
+    AgentRunCreate = "agent_run_create",
+    AgentRunGet = "agent_run_get",
+    AgentRunBySubject = "agent_run_by_subject",
+    AgentRunList = "agent_run_list",
+    AgentRunEvents = "agent_run_events",
+    AgentRunSubscribe = "agent_run_subscribe",
+    AgentRunUnsubscribe = "agent_run_unsubscribe",
+    AgentRunControl = "agent_run_control",
+    AgentRunChildren = "agent_run_children",
     FunctionInvoke = "function_invoke",
     FunctionInvokeSync = "function_invoke_sync",
     ScheduledInvocationCreate = "scheduled_invocation_create",
@@ -3022,6 +3031,617 @@ declare function readTokensFromFragment(hashOrUrl: string): {
     refreshToken: string | null;
 } | null;
 
+/**
+ * Child runs, the durable mailbox, structured checkpoints and usage
+ * accounting — the wire types of `/api/agent-runs/{repo}/{run}/children…`.
+ *
+ * A child is an ordinary durable run with a typed objective. Its terminal
+ * hand-back lands in the parent's mailbox (and completes any tool or wait
+ * parked on it); nothing polls a transient result.
+ */
+/** What context a child starts with. */
+type ChildContext = {
+    mode: 'none';
+} | {
+    mode: 'recent_turns';
+    turns: number;
+    items?: unknown[];
+} | {
+    mode: 'snapshot';
+    checkpoint_no?: number;
+    data?: unknown;
+};
+/** The typed objective of a child. */
+interface ChildObjective {
+    title: string;
+    instructions?: string;
+    context?: ChildContext;
+    /** Tool function paths (`*` suffix = prefix); empty = unrestricted. */
+    allowed_tools?: string[];
+    /** Write roots `{workspace, path, ops?}`, narrowed to the parent's grant. */
+    allowed_writes?: Array<{
+        workspace: string;
+        path?: string;
+        ops?: string[];
+    }>;
+    expected_artifacts?: Array<{
+        kind: string;
+        locator?: unknown;
+        description?: string;
+        required?: boolean;
+    }>;
+    acceptance_checks?: Array<{
+        id: string;
+        description?: string;
+        check?: unknown;
+        required?: boolean;
+    }>;
+    hand_back?: {
+        required_fields?: string[];
+        schema?: unknown;
+        description?: string;
+    };
+}
+/** Spawn options. */
+interface SpawnChildOptions {
+    objective: ChildObjective;
+    budgets?: Record<string, unknown>;
+    /** Default `fail`: a child paused on budget would stall its parent. */
+    onExceeded?: 'pause' | 'fail';
+    /** Idempotency key: a retry returns the same child. */
+    spawnKey?: string;
+    subject?: {
+        workspace: string;
+        path: string;
+        node_id?: string;
+    };
+    asAgent?: string;
+    agentRef?: string;
+    input?: unknown;
+    executorConfig?: Record<string, unknown>;
+    /** Server-driven child: its reducer function (any language). */
+    reducer?: {
+        function_path: string;
+        handler?: string;
+    };
+    /** Server-driven child on the parent's own reducer. */
+    inheritReducer?: boolean;
+    branch?: string;
+}
+/** The answer to a spawn. */
+interface SpawnChildResult {
+    child_run_id: string;
+    child_no: number;
+    created: boolean;
+    budgets: Record<string, unknown>;
+    /** Resume key a tool answers `waiting` with to wait for the child. */
+    resume_key: string;
+}
+/** What a parent does to a child. */
+type ChildAction = {
+    action: 'message';
+    message: unknown;
+} | {
+    action: 'steer';
+    input: unknown;
+} | {
+    action: 'interrupt';
+    mode?: 'stop' | 'pause';
+    reason?: string;
+} | {
+    action: 'resume';
+};
+/** One mailbox item with its payload (a hand-back envelope or a message). */
+interface MailboxEntry {
+    item: {
+        mail_no: number;
+        kind: 'completion' | 'message';
+        from_run: string;
+        seq: number;
+        result_key: string;
+        status?: string;
+    };
+    payload: unknown;
+}
+/** A structured checkpoint write (compaction). */
+interface CheckpointOptions {
+    fence?: {
+        owner: string;
+        epoch: number;
+    };
+    /** The in-flight operation doing the compaction (instead of a fence). */
+    operationId?: string;
+    reason?: 'compaction' | 'pause' | 'periodic' | 'before_terminal' | 'domain_requested' | 'delegation';
+    summary?: string;
+    transcriptCutoff?: {
+        workspace: string;
+        path: string;
+        node_id?: string;
+    };
+    /** Objective, constraints, decisions, pending questions, … */
+    state?: unknown;
+    largeRefs?: Array<{
+        key: string;
+        bytes: number;
+        content_type: string;
+    }>;
+}
+
+/**
+ * Durable agent runs over HTTP.
+ *
+ * A run is a server-side, crash-safe execution of an agent: a monotonic event
+ * log, a lifecycle (`queued → running → waiting/paused → completed/failed/
+ * stopped`), and atomic, idempotent controls (stop, pause, resume, steer,
+ * approve, answer). Two ways to drive one:
+ *
+ * - **server-driven** — create it with a `reducer` (any function, in any
+ *   supported language); the server's job queue drives it and you watch it
+ *   with {@link AgentRunsApi.stream};
+ * - **client-driven** — create it without a reducer and drive it yourself with
+ *   the lease calls ({@link AgentRunsApi.acquire}, {@link AgentRunsApi.begin},
+ *   {@link AgentRunsApi.finish}, ...). Your operations are still durable and
+ *   fenced, and anyone authorized can still stop or steer the run.
+ */
+
+/** Where a run lives, what it is about, and what it runs as. */
+interface CreateAgentRunOptions {
+    /** What the run is about (one live run per subject). */
+    subject: {
+        workspace: string;
+        path: string;
+        node_id?: string | null;
+    };
+    /** Branch (default "main"). */
+    branch?: string;
+    /** Opaque agent reference, e.g. an agent node path. */
+    agentRef?: string;
+    /** Idempotency key for the create (a retried create returns the same run). */
+    createKey?: string;
+    /** Limits; exceeding one pauses (default) or fails the run. */
+    budgets?: Record<string, unknown>;
+    /** Input, delivered to the reducer as `run_started.data.input`. */
+    input?: unknown;
+    /** Server-driven: the reducer function. Omit for a client-driven run. */
+    reducer?: {
+        function_path: string;
+        handler?: string;
+    };
+    /** Opaque executor configuration (e.g. `model_turn_function`). */
+    executorConfig?: Record<string, unknown>;
+    /** A secret whose holder may control the run. */
+    controlCapability?: string;
+    /** Run as this agent (`"ws:/path"` or `"/path"`), on your behalf. */
+    asAgent?: string;
+}
+/** The answer to a create. */
+interface CreateAgentRunResult {
+    run_id: string;
+    /** False when the subject's live run (or the create key's run) came back. */
+    created: boolean;
+    status: AgentRunStatus;
+}
+type AgentRunStatus = 'queued' | 'running' | 'waiting' | 'paused' | 'cancelling' | 'completed' | 'failed' | 'stopped';
+/** A run as a reader sees it. */
+interface AgentRunView {
+    run: Record<string, unknown> & {
+        run_id: string;
+        last_seq: number;
+    };
+    status: AgentRunStatus;
+    /** The plan to display, already overridden by the run status. */
+    projection: {
+        items?: Array<{
+            key: string;
+            title: string;
+            status: string;
+        }>;
+        summary?: string;
+    } | null;
+}
+/** One durable event (`seq` is contiguous from 1). */
+interface AgentRunEvent {
+    run_id: string;
+    seq: number;
+    at_ms: number;
+    turn?: number | null;
+    op_id?: string | null;
+    kind: {
+        type: string;
+        [key: string]: unknown;
+    };
+}
+/** The answer to a control. */
+type AgentRunControlAck = {
+    ack: 'applied';
+    seq: number;
+} | {
+    ack: 'duplicate';
+    original_seq: number;
+} | {
+    ack: 'rejected';
+    reason: string;
+    seq: number;
+};
+/** A control command, as the server's contract spells it. */
+type AgentRunCommand = {
+    command: 'stop';
+    reason?: string;
+} | {
+    command: 'pause';
+} | {
+    command: 'resume';
+    budget_increase?: Record<string, unknown>;
+    accept_reducer_change?: boolean;
+} | {
+    command: 'steer';
+    input: unknown;
+} | {
+    command: 'approve';
+    request_id: string;
+    decision: {
+        decision: 'approve';
+    } | {
+        decision: 'reject';
+        reason?: string;
+    };
+    subject_digest: string;
+} | {
+    command: 'provide_input';
+    request_id: string;
+    value: unknown;
+};
+/** A lease held by a client driver; present it on every driver call. */
+interface AgentRunFence {
+    owner: string;
+    epoch: number;
+}
+/** Begin an operation (client-driven runs). */
+interface BeginOperationOptions {
+    kind: 'model_turn' | 'tool_call' | 'compaction' | string;
+    input?: unknown;
+    replay_safe?: boolean;
+    non_interruptible?: boolean;
+    for_call_id?: string;
+    answers?: string[];
+}
+/** Finish an operation (client-driven runs). */
+interface FinishOperationOptions {
+    outcome: 'succeeded' | 'waiting' | 'retryable' | 'blocked' | 'failed' | 'cancelled';
+    payload?: unknown;
+    tool_calls?: string[];
+    usage?: {
+        input_tokens: number;
+        output_tokens: number;
+    };
+    resume_key?: string;
+}
+/** How the API reaches the server (supplied by the HTTP client). */
+interface AgentRunsTransport {
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+    /** Absolute URL for `path`. */
+    url(path: string): string;
+    /** Headers for a raw fetch (auth, tenant). */
+    headers(): Record<string, string>;
+    fetch: typeof fetch;
+}
+/** What a run is about: `{workspace, path, node_id?}` or `"workspace:/path"`. */
+type AgentRunSubject = {
+    workspace: string;
+    path?: string;
+    node_id?: string | null;
+} | string;
+/** `"ws:/path"` → `{workspace, path}`. */
+declare function subjectOf(subject: AgentRunSubject): {
+    workspace: string;
+    path?: string;
+    node_id?: string | null;
+};
+/** A fresh control id (controls are idempotent per id; retry with the SAME id). */
+declare function newControlId(prefix?: string): string;
+declare class AgentRunsApi {
+    private repository;
+    private transport;
+    constructor(repository: string, transport: AgentRunsTransport);
+    private base;
+    /** Create a run, or get back the subject's live run. */
+    create(options: CreateAgentRunOptions): Promise<CreateAgentRunResult>;
+    /** Every run about `subject` you may see, newest (the live one) first. */
+    bySubject(subject: AgentRunSubject, limit?: number): Promise<AgentRunView[]>;
+    /** Read a run (record + effective projection). */
+    get(runId: string): Promise<AgentRunView>;
+    /** Your runs in one status (default "running"). */
+    list(status?: AgentRunStatus, limit?: number): Promise<AgentRunView[]>;
+    /** Durable events after `afterSeq` (gap-free; page with the last seq). */
+    events(runId: string, afterSeq?: number, limit?: number): Promise<AgentRunEvent[]>;
+    /** Any control. Retrying with the same `controlId` is a no-op. */
+    control(runId: string, command: AgentRunCommand, controlId?: string, capability?: string): Promise<AgentRunControlAck>;
+    stop(runId: string, reason?: string, controlId?: string): Promise<AgentRunControlAck>;
+    pause(runId: string, controlId?: string): Promise<AgentRunControlAck>;
+    resume(runId: string, controlId?: string): Promise<AgentRunControlAck>;
+    /** Queue input for the run's next safe boundary. */
+    steer(runId: string, input: unknown, controlId?: string): Promise<AgentRunControlAck>;
+    /** Decide an approval request; the digest ties it to one changeset. */
+    approve(runId: string, requestId: string, subjectDigest: string, reject?: {
+        reason?: string;
+    }, controlId?: string): Promise<AgentRunControlAck>;
+    /** Answer an input request. */
+    answer(runId: string, requestId: string, value: unknown, controlId?: string): Promise<AgentRunControlAck>;
+    /**
+     * Stream the run's events: replay after `afterSeq`, then live. Ends after
+     * the run's terminal event. Resume after a disconnect with the last `seq`.
+     */
+    stream(runId: string, afterSeq?: number, signal?: AbortSignal): AsyncGenerator<AgentRunEvent>;
+    /** Take the lease of a queued client-driven run. */
+    acquire(runId: string): Promise<AgentRunFence>;
+    renew(runId: string, fence: AgentRunFence): Promise<AgentRunStatus>;
+    release(runId: string, fence: AgentRunFence): Promise<AgentRunStatus>;
+    /** Begin an operation; returns the active operation (its `op_id`). */
+    begin(runId: string, fence: AgentRunFence, op: BeginOperationOptions): Promise<{
+        op_id: string;
+    } & Record<string, unknown>>;
+    /** Record an operation's result. */
+    finish(runId: string, fence: AgentRunFence, opId: string, result: FinishOperationOptions): Promise<AgentRunStatus>;
+    /** Open approval/input requests and wait (`kind: "approval" | "input"`). */
+    wait(runId: string, fence: AgentRunFence, requests: Array<Record<string, unknown>>): Promise<AgentRunStatus>;
+    /** End a client-driven run. */
+    complete(runId: string, fence: AgentRunFence, status: 'completed' | 'failed', outcome: {
+        kind: string;
+        code?: string;
+        message?: string;
+        detail?: unknown;
+    }): Promise<AgentRunStatus>;
+    /** Spawn a child with a typed objective; its budgets come out of this run's. */
+    spawnChild(runId: string, options: SpawnChildOptions): Promise<SpawnChildResult>;
+    /** Every child of a run: the parent's link plus the child's live status. */
+    children(runId: string): Promise<Array<{
+        link: Record<string, unknown>;
+        status?: AgentRunStatus;
+        usage?: unknown;
+    }>>;
+    /** Inspect one child: record, events after `afterSeq`, usage, checkpoint. */
+    inspectChild(runId: string, childId: string, afterSeq?: number, limit?: number): Promise<Record<string, unknown>>;
+    /** Message, steer, interrupt or resume a child (idempotent per `controlId`). */
+    controlChild(runId: string, childId: string, action: ChildAction, controlId?: string): Promise<AgentRunControlAck>;
+    messageChild(runId: string, childId: string, message: unknown, controlId?: string): Promise<AgentRunControlAck>;
+    steerChild(runId: string, childId: string, input: unknown, controlId?: string): Promise<AgentRunControlAck>;
+    interruptChild(runId: string, childId: string, reason?: string, mode?: 'stop' | 'pause', controlId?: string): Promise<AgentRunControlAck>;
+    /** A client-driven parent waits (under its lease) for a child's hand-back. */
+    waitChild(runId: string, childId: string, fence: AgentRunFence, expiresAtMs?: number): Promise<AgentRunStatus>;
+    /** Unacknowledged mailbox items (hand-backs and child messages). */
+    mailbox(runId: string): Promise<MailboxEntry[]>;
+    /** Acknowledge mailbox items up to `upTo`. */
+    ackMailbox(runId: string, upTo: number): Promise<{
+        remaining: number;
+    }>;
+    /** A child posts a message to its parent's mailbox (idempotent per id). */
+    postToParent(runId: string, messageId: string, message: unknown): Promise<{
+        mail_no: number;
+    }>;
+    /** Write a structured checkpoint (compaction keeps state, not prose). */
+    checkpoint(runId: string, options: CheckpointOptions): Promise<Record<string, unknown>>;
+    /** Read a checkpoint (default: latest) with its structured state. */
+    readCheckpoint(runId: string, checkpointNo?: number): Promise<{
+        checkpoint: Record<string, unknown>;
+        state: unknown;
+    }>;
+    /** Usage accounting: own, children, reserved, spare. */
+    usage(runId: string): Promise<Record<string, unknown>>;
+}
+
+/**
+ * The node-development surface over HTTP: RaisinDB's hierarchy as a
+ * structured workspace a client — or an agent — can develop in safely.
+ *
+ * - **Locators** name a node as `{repository, branch, workspace, path,
+ *   node_id, revision}`; the id is identity across moves, the revision is
+ *   what you saw.
+ * - **Roots** bound every call: a path outside them (including a `..` climb)
+ *   is refused, and a root can restrict the operations allowed inside it.
+ * - **Changesets** are atomic: {@link NodeDevApi.dryRun} plans,
+ *   {@link NodeDevApi.propose} stores a reviewable record with a digest,
+ *   {@link NodeDevApi.commit} applies it (optionally bound to the approved
+ *   digest), and {@link NodeDevApi.apply} does both. A stale
+ *   `expected_revision` comes back as a `conflict` result — nothing is
+ *   written — and an `idempotency_key` makes a retry return the first receipt.
+ * - **Branches** are worktrees: fork, diff, merge (conflicts reported, never
+ *   guessed), discard.
+ */
+/** A subtree of one workspace, and the operations allowed inside it. */
+interface WorkRoot {
+    workspace: string;
+    /** Absolute subtree path (default `/`). */
+    path?: string;
+    /** Allowed operations (default: all). */
+    ops?: Array<'read' | 'create' | 'update' | 'delete' | 'move' | 'copy'>;
+}
+/** A node revision under a named scheme. */
+interface NodeRevision {
+    value: string;
+    alg: string;
+}
+/** A canonical locator. */
+interface NodeLocator {
+    repository: string;
+    branch: string;
+    workspace: string;
+    path: string;
+    node_id?: string;
+    revision?: NodeRevision;
+}
+/** A path (relative to the first root, or absolute), or `{ path?, node_id?, workspace? }`. */
+type NodeTarget = string | {
+    workspace?: string;
+    path?: string;
+    node_id?: string;
+};
+/** One changeset operation. */
+type ChangeOp = {
+    op: 'create';
+    path: string;
+    node_type: string;
+    workspace?: string;
+    archetype?: string;
+    properties?: Record<string, unknown>;
+} | {
+    op: 'patch';
+    target: NodeTarget;
+    expected_revision?: string | NodeRevision;
+    set?: Record<string, unknown>;
+    unset?: string[];
+    archetype?: string;
+} | {
+    op: 'move';
+    target: NodeTarget;
+    to_parent: NodeTarget;
+    new_name?: string;
+    expected_revision?: string | NodeRevision;
+} | {
+    op: 'rename';
+    target: NodeTarget;
+    new_name: string;
+    expected_revision?: string | NodeRevision;
+} | {
+    op: 'copy';
+    source: NodeTarget;
+    to_parent: NodeTarget;
+    new_name?: string;
+} | {
+    op: 'delete';
+    target: NodeTarget;
+    expected_revision?: string | NodeRevision;
+    recursive?: boolean;
+};
+/** Fields every call accepts. */
+interface NodeDevCommon {
+    /** The working roots (or `workspace` for a whole workspace). */
+    roots?: WorkRoot[];
+    workspace?: string;
+    /** Branch (default `main`). */
+    branch?: string;
+    /** Return a `raisin.tool-result/1` envelope instead of the typed result. */
+    envelope?: boolean;
+}
+/** A changeset request. */
+interface ChangesetOptions extends NodeDevCommon {
+    ops: ChangeOp[];
+    idempotencyKey?: string;
+    message?: string;
+    /** Index of the op whose node is the primary artifact. */
+    primary?: number;
+    /** Artifact kind reported in tool results. */
+    kind?: string;
+}
+/** Why an op cannot commit as reviewed. */
+interface NodeDevConflict {
+    index: number;
+    code: string;
+    message: string;
+    expected?: string;
+    actual?: NodeLocator;
+}
+/** One op's committed effect. */
+interface OpReceipt {
+    index: number;
+    action: 'created' | 'updated' | 'moved' | 'copied' | 'deleted';
+    old?: NodeLocator;
+    new?: NodeLocator;
+    changed_properties?: string[];
+    created_descendants?: NodeLocator[];
+    deleted_descendants?: NodeLocator[];
+    moved_descendants?: Array<{
+        from_path: string;
+        to: NodeLocator;
+    }>;
+    rewritten_references?: Array<{
+        workspace: string;
+        node_id: string;
+        path?: string;
+        property: string;
+        target_id: string;
+    }>;
+}
+/** Exactly what committed. */
+interface Receipt {
+    changeset_id: string;
+    repository: string;
+    branch: string;
+    committed_revision?: string;
+    ops: OpReceipt[];
+    replayed: boolean;
+}
+/** The outcome of a commit or apply. */
+type CommitOutcome = {
+    result: 'committed';
+    receipt: Receipt;
+} | {
+    result: 'conflict';
+    changeset_id: string;
+    conflicts: NodeDevConflict[];
+    digest: string;
+};
+/** How requests reach the server (the HTTP client provides it). */
+interface NodeDevTransport {
+    request<T>(method: string, path: string, body?: unknown): Promise<T>;
+}
+/** The node-development surface of one repository. */
+declare class NodeDevApi {
+    private readonly repository;
+    private readonly transport;
+    constructor(repository: string, transport: NodeDevTransport);
+    /** Call any method by name (the typed helpers below all use this). */
+    call<T = unknown>(method: string, request: Record<string, unknown>): Promise<T>;
+    private changeset;
+    stat(target: NodeTarget, o?: NodeDevCommon): Promise<unknown>;
+    read(target: NodeTarget, o?: NodeDevCommon & {
+        keys?: string[];
+    }): Promise<unknown>;
+    list(target?: NodeTarget, o?: NodeDevCommon & {
+        limit?: number;
+    }): Promise<unknown>;
+    diff(target: NodeTarget, from: {
+        branch?: string;
+        revision?: string;
+    }, to: {
+        branch?: string;
+        revision?: string;
+    }, o?: NodeDevCommon): Promise<unknown>;
+    /** Changes inside the roots after `since` (a cursor from a previous call). */
+    watch(since?: string, o?: NodeDevCommon & {
+        limit?: number;
+    }): Promise<{
+        changes: unknown[];
+        cursor?: string;
+    }>;
+    dryRun(o: ChangesetOptions): Promise<unknown>;
+    propose(o: ChangesetOptions): Promise<{
+        changeset: {
+            changeset_id: string;
+            plan: {
+                digest: string;
+            };
+        };
+        created: boolean;
+    }>;
+    getChangeset(changesetId: string, o?: NodeDevCommon): Promise<unknown>;
+    listChangesets(o?: NodeDevCommon & {
+        status?: 'proposed' | 'committed' | 'discarded';
+        limit?: number;
+    }): Promise<unknown>;
+    /** Commit; pass the reviewed digest to bind the commit to that approval. */
+    commit(changesetId: string, expectedDigest?: string, o?: NodeDevCommon): Promise<CommitOutcome>;
+    discard(changesetId: string, o?: NodeDevCommon): Promise<unknown>;
+    /** Propose and commit in one call. */
+    apply(o: ChangesetOptions): Promise<CommitOutcome>;
+    forkBranch(name: string, o?: NodeDevCommon): Promise<unknown>;
+    diffBranch(base?: string, o?: NodeDevCommon): Promise<unknown>;
+    mergeBranch(target: string, o?: NodeDevCommon & {
+        dryRun?: boolean;
+        message?: string;
+    }): Promise<unknown>;
+    discardBranch(o?: NodeDevCommon): Promise<unknown>;
+}
+
 /**
  * RaisinDB HTTP client for server-side rendering (SSR)
  *
@@ -3484,6 +4104,17 @@ declare class RaisinHttpClient extends EventEmitter {
      * @param input - Input data passed to the function
      * @returns Execution ID and job ID for tracking
      */
+    /**
+     * Durable agent runs of `repository`: create, read, control, stream, and
+     * drive them directly (see {@link AgentRunsApi}).
+     */
+    agentRuns(repository: string): AgentRunsApi;
+    /**
+     * The node-development surface of `repository`: typed reads, atomic
+     * changesets with review and idempotency, branch worktrees (see
+     * {@link NodeDevApi}).
+     */
+    nodeDev(repository: string): NodeDevApi;
     invokeFunction(repository: string, functionName: string, input?: Record<string, unknown>, options?: FunctionInvokeOptions): Promise<FunctionInvokeResponse>;
     /**
      * Invoke a server-side function synchronously.
@@ -3597,6 +4228,10 @@ declare class HttpDatabase {
     /**
      * Get FunctionsApi for invoking server-side functions via HTTP
      */
+    /** Durable agent runs of this repository. */
+    agentRuns(): AgentRunsApi;
+    /** The node-development surface of this repository. */
+    nodeDev(): NodeDevApi;
     functions(): HttpFunctionsApi;
     /**
      * The retrieval implementation behind {@link search} and {@link ask}.
@@ -4656,6 +5291,101 @@ declare class FlowsApi {
     }>;
 }
 
+/**
+ * Durable agent runs over the WebSocket connection you already hold.
+ *
+ * The same contract as {@link AgentRunsApi} (HTTP), without a second
+ * transport: find the run of a conversation, follow it live, control it and
+ * read its children. `subscribe` is gap-free and resumable — it replays the
+ * durable log after `afterSeq`, then follows it, delivering every event once
+ * and in `seq` order even across a reconnect (pass the last `seq` you saw).
+ *
+ * ```ts
+ * const runs = db.runs();
+ * const [live] = await runs.bySubject('ai:/agents/builder/inbox/chats/c1');
+ * const sub = await runs.subscribe(live.run.run_id, { afterSeq: 0 });
+ * for await (const ev of sub) console.log(ev.seq, ev.kind.type);
+ * await runs.stop(live.run.run_id, 'user asked');
+ * ```
+ */
+
+type SendRequest = (payload: unknown, requestType: string, context?: RequestContext) => Promise<unknown>;
+/** A child as its parent lists it. */
+interface AgentRunChildView {
+    link: Record<string, unknown> & {
+        run_id: string;
+        child_no: number;
+    };
+    status: AgentRunStatus | null;
+    usage: Record<string, unknown> | null;
+}
+/** Options of {@link AgentRunsWsApi.subscribe}. */
+interface AgentRunSubscribeOptions {
+    /** Replay events after this seq (0 = from the start). */
+    afterSeq?: number;
+    /** Called for every event, in seq order (in addition to iteration). */
+    onEvent?: (event: AgentRunEvent) => void;
+    /** Called once when the run ended and its log is complete. */
+    onEnd?: (lastSeq: number) => void;
+    /** Stop following. */
+    signal?: AbortSignal;
+}
+/** A live subscription: iterate it, or use the callbacks. */
+interface AgentRunSubscription extends AsyncIterable<AgentRunEvent> {
+    /** The last seq delivered (resume from it after a reconnect). */
+    readonly lastSeq: number;
+    /** Resolves when the run ended or the subscription was closed. */
+    readonly done: Promise<void>;
+    /** Stop following. */
+    unsubscribe(): Promise<void>;
+}
+declare class AgentRunsWsApi {
+    private context;
+    private sendRequest;
+    private eventHandler;
+    constructor(context: RequestContext, sendRequest: SendRequest, eventHandler: EventHandler);
+    private call;
+    /** Create a run, or get back the subject's live run. */
+    create(options: CreateAgentRunOptions): Promise<CreateAgentRunResult>;
+    /** Read a run (record + effective projection). */
+    get(runId: string): Promise<AgentRunView>;
+    /**
+     * Every run about `subject` (a conversation, a document) you may see,
+     * newest first — the live run, if there is one, comes first.
+     */
+    bySubject(subject: AgentRunSubject, limit?: number): Promise<AgentRunView[]>;
+    /** The newest run of `subject`, or null. */
+    latest(subject: AgentRunSubject): Promise<AgentRunView | null>;
+    /** Your runs in one status (default "running"). */
+    list(status?: AgentRunStatus, limit?: number): Promise<AgentRunView[]>;
+    /** Durable events after `afterSeq`. */
+    events(runId: string, afterSeq?: number, limit?: number): Promise<AgentRunEvent[]>;
+    /** The children a run spawned, with their current status. */
+    children(runId: string): Promise<AgentRunChildView[]>;
+    /** Any control. Retrying with the same `controlId` is a no-op. */
+    control(runId: string, command: AgentRunCommand, controlId?: string, capability?: string): Promise<AgentRunControlAck>;
+    stop(runId: string, reason?: string, controlId?: string): Promise<AgentRunControlAck>;
+    pause(runId: string, controlId?: string): Promise<AgentRunControlAck>;
+    resume(runId: string, controlId?: string): Promise<AgentRunControlAck>;
+    /** Queue input for the run's next safe boundary. */
+    steer(runId: string, input: unknown, controlId?: string): Promise<AgentRunControlAck>;
+    /** Decide an approval request; the digest ties it to one changeset. */
+    approve(runId: string, requestId: string, subjectDigest: string, reject?: {
+        reason?: string;
+    }, controlId?: string): Promise<AgentRunControlAck>;
+    /** Answer an input request. */
+    answer(runId: string, requestId: string, value: unknown, controlId?: string): Promise<AgentRunControlAck>;
+    /**
+     * Follow a run: replay after `afterSeq`, then live, until the run ends.
+     *
+     * Events that reach the socket before the subscription is known here are
+     * not lost: the durable log is read once the listener is in place, live
+     * events are held until that read is merged, and every seq is delivered
+     * exactly once, in order.
+     */
+    subscribe(runId: string, options?: AgentRunSubscribeOptions): Promise<AgentRunSubscription>;
+}
+
 /**
  * Chat types for the RaisinDB JS SDK.
  *
@@ -6037,6 +6767,7 @@ declare class Database {
     private getSignAssetUrl?;
     private httpOptions?;
     private _flowsApi?;
+    private _runsApi?;
     private _functionsApi?;
     private _conversationManager?;
     private _flowClient?;
@@ -6141,6 +6872,11 @@ declare class Database {
      * Get FlowsApi for running flows via WebSocket
      */
     flows(): FlowsApi;
+    /**
+     * Durable agent runs over this WebSocket connection: find a subject's run,
+     * follow it live (gap-free, resumable), control it, list its children.
+     */
+    runs(): AgentRunsWsApi;
     /**
      * Get FunctionsApi for invoking server-side functions via WebSocket
      */
@@ -7459,4 +8195,4 @@ declare class ConversationListStore {
     private notify;
 }
 
-export { type CurrentUser$1 as $, AuthManager as A, type BatchUpload as B, ConnectionState as C, Database as D, type EventMessage as E, type FlowClientOptions as F, type SearchOptions as G, type HttpClientOptions as H, type IdentityUser as I, type SearchPassage as J, type ClientMode as K, type CurrentUser as L, type UserNode as M, type Node as N, type AuthEvent as O, type PlanProjection as P, type AuthStateChange as Q, RaisinClient as R, type SubscriptionFilters as S, type ToolCallInfo as T, UploadErrorCode as U, type AuthStateChangeCallback as V, type WorkspaceScope as W, type UserChangeEvent as X, type UserChangeCallback as Y, HttpDatabase as Z, HttpWorkspaceClient as _, type ConversationStoreSnapshot as a, type AuditQueryPayload as a$, type UserNode$1 as a0, type SignAssetOptions as a1, type SignedAssetUrl as a2, type DatabaseHttpOptions as a3, WorkspaceClient as a4, WorkspaceManager as a5, type WorkspaceCreateOptions as a6, type WorkspaceUpdateOptions as a7, NodeOperations as a8, type NodeCreateOptions as a9, createSqlHandler as aA, EventHandler as aB, EventSubscriptions as aC, type EventCallback as aD, type Subscription as aE, Connection as aF, type ConnectionOptions as aG, MemoryTokenStorage as aH, LocalStorageTokenStorage as aI, type TokenStorage as aJ, type IdentityAuthResponse as aK, type IdentityAuthError as aL, type RequestEnvelope as aM, type ResponseEnvelope as aN, type NodeEventPayload as aO, type RequestContext as aP, type ErrorInfo as aQ, type ResponseMetadata as aR, type IncomingRelation as aS, type NodeRelationships as aT, type NodeCreatePayload as aU, type NodeCreateDeepPayload as aV, type NodeUpdatePayload as aW, type NodeDeletePayload as aX, type NodeGetPayload as aY, type NodeHistoryPayload as aZ, type RevisionEntry as a_, type NodeCreateDeepOptions as aa, type NodeUpdateOptions as ab, type NodeQueryOptions as ac, Transaction as ad, type TransactionOptions as ae, NodeTypes as af, Archetypes as ag, ElementTypes as ah, Branches as ai, type BranchDiff as aj, type BranchDivergence as ak, type CrossBranchCopySummary as al, type CrossBranchNodeChange as am, type NodeDiffInfo as an, Tags as ao, SchedulerApi as ap, type ListInvocationsFilter as aq, type ScheduleInvocationOptions as ar, type ScheduledInvocation as as, type ScheduledInvocationRef as at, type ScheduledInvocationTargetKind as au, HttpNodeTypes as av, HttpArchetypes as aw, HttpElementTypes as ax, type SchemaCommit as ay, SqlQuery as az, type ChatMessage as b, Uploader as b$, type AuditLogEntry as b0, type NodeQueryPayload as b1, type RelationAddPayload as b2, type RelationRemovePayload as b3, type RelationsGetPayload as b4, type SqlQueryPayload as b5, type SqlResult as b6, type Workspace as b7, type WorkspaceCreatePayload as b8, type WorkspaceGetPayload as b9, type LoggerConfig as bA, type UploadStatus as bB, type UploadOptions as bC, type UploadProgress as bD, type UploadResult as bE, type Upload as bF, type CreateUploadRequest as bG, type CreateUploadResponse as bH, type ChunkUploadResponse as bI, type UploadStatusResponse as bJ, type CompleteUploadRequest as bK, type CompleteUploadResponse as bL, type BatchFileProgress as bM, UploadError as bN, DEFAULT_CHUNK_SIZE as bO, DEFAULT_MAX_RETRIES as bP, DEFAULT_RETRY_BASE_DELAY as bQ, DEFAULT_RETRY_MAX_DELAY as bR, DEFAULT_NODE_TYPE as bS, DEFAULT_BRANCH as bT, DEFAULT_BATCH_CONCURRENCY as bU, BrowserFileSource as bV, NodeFileSource as bW, createFileSource as bX, getContentType as bY, calculateChunkCount as bZ, getChunkRange as b_, type WorkspaceDeletePayload as ba, type WorkspaceUpdatePayload as bb, type SubscribePayload as bc, type UnsubscribePayload as bd, type SubscriptionResponse as be, type AuthenticatePayload as bf, type AuthenticateResponse as bg, type RefreshTokenPayload as bh, type TransactionBeginPayload as bi, type TransactionBeginResponse as bj, type TransactionCommitPayload as bk, type TransactionCommitResponse as bl, type TransactionRollbackPayload as bm, RequestType as bn, ResponseStatus as bo, encodeMessage as bp, decodeMessage as bq, isEventMessage as br, isResponseEnvelope as bs, ReconnectManager as bt, LogLevel as bu, logger as bv, configureLogger as bw, setLogLevel as bx, getLogLevel as by, getLoggerConfig as bz, ConversationStore as c, type AiErrorBehavior as c$, UploadManager as c0, FlowClient as c1, type FlowRunResult as c2, type FlowCollectResult as c3, FunctionsApi as c4, HttpFunctionsApi as c5, IdentityAuthApi as c6, readTokensFromFragment as c7, type IdentityAuthResult as c8, type IdentityAuthTransport as c9, type StepFailedEvent as cA, type FlowWaitingEvent as cB, type FlowResumedEvent as cC, type FlowCompletedEvent as cD, type FlowFailedEvent as cE, type TextChunkEvent as cF, type ToolCallStartedEvent as cG, type ToolCallCompletedEvent as cH, type ThoughtChunkEvent as cI, type ConversationCreatedEvent as cJ, type MessageSavedEvent as cK, type LogEvent as cL, isTerminalEvent as cM, type RaisinReference as cN, type ContainerType as cO, type StepErrorBehavior as cP, type FlowErrorStrategy as cQ, type RetryConfig as cR, type RetryStrategy as cS, type HumanTaskType as cT, type CanonicalTaskType as cU, type TaskOption as cV, type HandoffTarget as cW, type ChatTerminationMode as cX, type ChatTerminationConfig as cY, type ChatStepConfig as cZ, type AiToolMode as c_, type IdentityInfo as ca, type IdentityMe as cb, type MagicLinkSent as cc, type MagicLinkOptions as cd, type AuthProviders as ce, type FunctionInvokeOptions as cf, type FunctionInvokeResponse as cg, type FunctionInvokeSyncResponse as ch, McpClient as ci, type McpTransport as cj, type McpFrameStream as ck, type McpJsonRpcFrame as cl, type McpToolDescriptor as cm, type McpContentBlock as cn, type McpCallToolResult as co, type McpResourceContents as cp, type McpReadResourceResult as cq, type McpResourceUpdate as cr, type McpResourceSubscription as cs, type FlowRunResponse as ct, type FlowInstanceStatus as cu, type FlowInstanceStatusResponse as cv, type FlowMetrics as cw, type StepStartedEvent as cx, type StepCompletedEvent as cy, type StepUsage as cz, type ConversationListItem as d, type AiContainerConfig as d0, type FlowDefinitionNodeBase as d1, type FlowStepProperties as d2, type FlowDefinitionStep as d3, type ContainerRule as d4, type FanOutConfig as d5, type MergeStrategy as d6, type FlowDefinitionContainer as d7, type LoopConfig as d8, type FlowDefinitionNode as d9, type ChatToolCallCompletedEvent as dA, type ChatThoughtChunkEvent as dB, type ToolCallRecord as dC, type MessageChild as dD, type PlanTask as dE, type ChatConversationCreatedEvent as dF, type ChatMessageSavedEvent as dG, type ChatMessageDeliveredEvent as dH, type ChatLogEvent as dI, ConversationManager as dJ, DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS as dK, type ListConversationsOptions as dL, type CreateConversationOptions as dM, type SendMessageOptions as dN, type ConversationSubscription as dO, type PlanActionReceipt as dP, type PlanActionOptions as dQ, type ConversationManagerOptions as dR, projectPlansFromMessages as dS, type FlowDefinition as da, type InboxTask as db, type InboxTaskStatus as dc, type TaskCompletionResult as dd, RETRY_STRATEGIES as de, getRefDisplayName as df, getRefPath as dg, isFlowDefinitionStep as dh, isFlowDefinitionContainer as di, InboxApi as dj, type InboxApiOptions as dk, type ListTasksOptions as dl, type ListTasksResponse as dm, type ChatEvent as dn, type Conversation as dp, type ConversationType as dq, type ConversationStatus as dr, type MessageBody as ds, type ChatTextChunkEvent as dt, type ChatAssistantMessageEvent as du, type ChatWaitingEvent as dv, type ChatCompletedEvent as dw, type ChatFailedEvent as dx, type ChatDoneEvent as dy, type ChatToolCallStartedEvent as dz, ConversationListStore as e, type ConversationStoreOptions as f, type ConversationListStoreOptions as g, type ConversationListSnapshot as h, FlowsApi as i, type FlowExecutionEvent as j, type PlanProjectionTask as k, type PropertyValue as l, type RelationRef as m, type ClientOptions as n, type Credentials as o, RaisinHttpClient as p, type RetryOptions as q, type UploaderConfig as r, type FileSource as s, type BatchUploadOptions as t, type BatchUploadResult as u, type BatchProgress as v, type ReconnectOptions as w, type Answer as x, type AskOptions as y, type Citation as z };
+export { type CurrentUser$1 as $, AuthManager as A, type BatchUpload as B, ConnectionState as C, Database as D, type EventMessage as E, type FlowClientOptions as F, type SearchOptions as G, type HttpClientOptions as H, type IdentityUser as I, type SearchPassage as J, type ClientMode as K, type CurrentUser as L, type UserNode as M, type Node as N, type AuthEvent as O, type PlanProjection as P, type AuthStateChange as Q, RaisinClient as R, type SubscriptionFilters as S, type ToolCallInfo as T, UploadErrorCode as U, type AuthStateChangeCallback as V, type WorkspaceScope as W, type UserChangeEvent as X, type UserChangeCallback as Y, HttpDatabase as Z, HttpWorkspaceClient as _, type ConversationStoreSnapshot as a, type CreateAgentRunResult as a$, type UserNode$1 as a0, type SignAssetOptions as a1, type SignedAssetUrl as a2, type DatabaseHttpOptions as a3, WorkspaceClient as a4, WorkspaceManager as a5, type WorkspaceCreateOptions as a6, type WorkspaceUpdateOptions as a7, NodeOperations as a8, type NodeCreateOptions as a9, type CheckpointOptions as aA, type MailboxEntry as aB, type SpawnChildOptions as aC, type SpawnChildResult as aD, NodeDevApi as aE, type ChangeOp as aF, type ChangesetOptions as aG, type CommitOutcome as aH, type NodeDevCommon as aI, type NodeDevConflict as aJ, type NodeDevTransport as aK, type NodeLocator as aL, type NodeRevision as aM, type NodeTarget as aN, type OpReceipt as aO, type Receipt as aP, type WorkRoot as aQ, type AgentRunCommand as aR, type AgentRunControlAck as aS, type AgentRunEvent as aT, type AgentRunFence as aU, type AgentRunStatus as aV, type AgentRunSubject as aW, type AgentRunView as aX, type AgentRunsTransport as aY, type BeginOperationOptions as aZ, type CreateAgentRunOptions as a_, type NodeCreateDeepOptions as aa, type NodeUpdateOptions as ab, type NodeQueryOptions as ac, Transaction as ad, type TransactionOptions as ae, NodeTypes as af, Archetypes as ag, ElementTypes as ah, Branches as ai, type BranchDiff as aj, type BranchDivergence as ak, type CrossBranchCopySummary as al, type CrossBranchNodeChange as am, type NodeDiffInfo as an, Tags as ao, SchedulerApi as ap, AgentRunsApi as aq, newControlId as ar, subjectOf as as, AgentRunsWsApi as at, type AgentRunChildView as au, type AgentRunSubscribeOptions as av, type AgentRunSubscription as aw, type ChildAction as ax, type ChildContext as ay, type ChildObjective as az, type ChatMessage as b, ResponseStatus as b$, type FinishOperationOptions as b0, type ListInvocationsFilter as b1, type ScheduleInvocationOptions as b2, type ScheduledInvocation as b3, type ScheduledInvocationRef as b4, type ScheduledInvocationTargetKind as b5, HttpNodeTypes as b6, HttpArchetypes as b7, HttpElementTypes as b8, type SchemaCommit as b9, type NodeHistoryPayload as bA, type RevisionEntry as bB, type AuditQueryPayload as bC, type AuditLogEntry as bD, type NodeQueryPayload as bE, type RelationAddPayload as bF, type RelationRemovePayload as bG, type RelationsGetPayload as bH, type SqlQueryPayload as bI, type SqlResult as bJ, type Workspace as bK, type WorkspaceCreatePayload as bL, type WorkspaceGetPayload as bM, type WorkspaceDeletePayload as bN, type WorkspaceUpdatePayload as bO, type SubscribePayload as bP, type UnsubscribePayload as bQ, type SubscriptionResponse as bR, type AuthenticatePayload as bS, type AuthenticateResponse as bT, type RefreshTokenPayload as bU, type TransactionBeginPayload as bV, type TransactionBeginResponse as bW, type TransactionCommitPayload as bX, type TransactionCommitResponse as bY, type TransactionRollbackPayload as bZ, RequestType as b_, SqlQuery as ba, createSqlHandler as bb, EventHandler as bc, EventSubscriptions as bd, type EventCallback as be, type Subscription as bf, Connection as bg, type ConnectionOptions as bh, MemoryTokenStorage as bi, LocalStorageTokenStorage as bj, type TokenStorage as bk, type IdentityAuthResponse as bl, type IdentityAuthError as bm, type RequestEnvelope as bn, type ResponseEnvelope as bo, type NodeEventPayload as bp, type RequestContext as bq, type ErrorInfo as br, type ResponseMetadata as bs, type IncomingRelation as bt, type NodeRelationships as bu, type NodeCreatePayload as bv, type NodeCreateDeepPayload as bw, type NodeUpdatePayload as bx, type NodeDeletePayload as by, type NodeGetPayload as bz, ConversationStore as c, type McpCallToolResult as c$, encodeMessage as c0, decodeMessage as c1, isEventMessage as c2, isResponseEnvelope as c3, ReconnectManager as c4, LogLevel as c5, logger as c6, configureLogger as c7, setLogLevel as c8, getLogLevel as c9, calculateChunkCount as cA, getChunkRange as cB, Uploader as cC, UploadManager as cD, FlowClient as cE, type FlowRunResult as cF, type FlowCollectResult as cG, FunctionsApi as cH, HttpFunctionsApi as cI, IdentityAuthApi as cJ, readTokensFromFragment as cK, type IdentityAuthResult as cL, type IdentityAuthTransport as cM, type IdentityInfo as cN, type IdentityMe as cO, type MagicLinkSent as cP, type MagicLinkOptions as cQ, type AuthProviders as cR, type FunctionInvokeOptions as cS, type FunctionInvokeResponse as cT, type FunctionInvokeSyncResponse as cU, McpClient as cV, type McpTransport as cW, type McpFrameStream as cX, type McpJsonRpcFrame as cY, type McpToolDescriptor as cZ, type McpContentBlock as c_, getLoggerConfig as ca, type LoggerConfig as cb, type UploadStatus as cc, type UploadOptions as cd, type UploadProgress as ce, type UploadResult as cf, type Upload as cg, type CreateUploadRequest as ch, type CreateUploadResponse as ci, type ChunkUploadResponse as cj, type UploadStatusResponse as ck, type CompleteUploadRequest as cl, type CompleteUploadResponse as cm, type BatchFileProgress as cn, UploadError as co, DEFAULT_CHUNK_SIZE as cp, DEFAULT_MAX_RETRIES as cq, DEFAULT_RETRY_BASE_DELAY as cr, DEFAULT_RETRY_MAX_DELAY as cs, DEFAULT_NODE_TYPE as ct, DEFAULT_BRANCH as cu, DEFAULT_BATCH_CONCURRENCY as cv, BrowserFileSource as cw, NodeFileSource as cx, createFileSource as cy, getContentType as cz, type ConversationListItem as d, type ChatEvent as d$, type McpResourceContents as d0, type McpReadResourceResult as d1, type McpResourceUpdate as d2, type McpResourceSubscription as d3, type FlowRunResponse as d4, type FlowInstanceStatus as d5, type FlowInstanceStatusResponse as d6, type FlowMetrics as d7, type StepStartedEvent as d8, type StepCompletedEvent as d9, type ChatTerminationConfig as dA, type ChatStepConfig as dB, type AiToolMode as dC, type AiErrorBehavior as dD, type AiContainerConfig as dE, type FlowDefinitionNodeBase as dF, type FlowStepProperties as dG, type FlowDefinitionStep as dH, type ContainerRule as dI, type FanOutConfig as dJ, type MergeStrategy as dK, type FlowDefinitionContainer as dL, type LoopConfig as dM, type FlowDefinitionNode as dN, type FlowDefinition as dO, type InboxTask as dP, type InboxTaskStatus as dQ, type TaskCompletionResult as dR, RETRY_STRATEGIES as dS, getRefDisplayName as dT, getRefPath as dU, isFlowDefinitionStep as dV, isFlowDefinitionContainer as dW, InboxApi as dX, type InboxApiOptions as dY, type ListTasksOptions as dZ, type ListTasksResponse as d_, type StepUsage as da, type StepFailedEvent as db, type FlowWaitingEvent as dc, type FlowResumedEvent as dd, type FlowCompletedEvent as de, type FlowFailedEvent as df, type TextChunkEvent as dg, type ToolCallStartedEvent as dh, type ToolCallCompletedEvent as di, type ThoughtChunkEvent as dj, type ConversationCreatedEvent as dk, type MessageSavedEvent as dl, type LogEvent as dm, isTerminalEvent as dn, type RaisinReference as dp, type ContainerType as dq, type StepErrorBehavior as dr, type FlowErrorStrategy as ds, type RetryConfig as dt, type RetryStrategy as du, type HumanTaskType as dv, type CanonicalTaskType as dw, type TaskOption as dx, type HandoffTarget as dy, type ChatTerminationMode as dz, ConversationListStore as e, type Conversation as e0, type ConversationType as e1, type ConversationStatus as e2, type MessageBody as e3, type ChatTextChunkEvent as e4, type ChatAssistantMessageEvent as e5, type ChatWaitingEvent as e6, type ChatCompletedEvent as e7, type ChatFailedEvent as e8, type ChatDoneEvent as e9, type ChatToolCallStartedEvent as ea, type ChatToolCallCompletedEvent as eb, type ChatThoughtChunkEvent as ec, type ToolCallRecord as ed, type MessageChild as ee, type PlanTask as ef, type ChatConversationCreatedEvent as eg, type ChatMessageSavedEvent as eh, type ChatMessageDeliveredEvent as ei, type ChatLogEvent as ej, ConversationManager as ek, DEFAULT_SEND_MESSAGE_INACTIVITY_TIMEOUT_MS as el, type ListConversationsOptions as em, type CreateConversationOptions as en, type SendMessageOptions as eo, type ConversationSubscription as ep, type PlanActionReceipt as eq, type PlanActionOptions as er, type ConversationManagerOptions as es, projectPlansFromMessages as et, type ConversationStoreOptions as f, type ConversationListStoreOptions as g, type ConversationListSnapshot as h, FlowsApi as i, type FlowExecutionEvent as j, type PlanProjectionTask as k, type PropertyValue as l, type RelationRef as m, type ClientOptions as n, type Credentials as o, RaisinHttpClient as p, type RetryOptions as q, type UploaderConfig as r, type FileSource as s, type BatchUploadOptions as t, type BatchUploadResult as u, type BatchProgress as v, type ReconnectOptions as w, type Answer as x, type AskOptions as y, type Citation as z };