@ai-matrx/agents 0.5.1 → 0.6.1

package/dist/react/index.d.ts

@@ -0,0 +1,540 @@
+type AgentProjectionStatus = "pending" | "streaming" | "awaiting-tools" | "complete" | "error" | "cancelled";
+interface AgentProjectionOperation {
+    operationId: string;
+    operation: string;
+    parentOperationId: string | null;
+    status: "active" | "success" | "failed" | "cancelled";
+    metadata: Record<string, unknown> | null;
+    result: Record<string, unknown> | null;
+}
+interface AgentProjectionTool {
+    callId: string;
+    toolName: string;
+    status: "started" | "progress" | "step" | "preview" | "completed" | "error" | "delegated";
+    message: string | null;
+    data: Record<string, unknown> | null;
+}
+interface AgentProjectionRenderBlock {
+    blockId: string;
+    blockIndex: number;
+    type: string;
+    status: "streaming" | "complete" | "error";
+    content: string | null;
+    data: Record<string, unknown> | null;
+    metadata: Record<string, unknown> | null;
+}
+interface AgentRequestProjection {
+    requestId: string;
+    conversationId: string | null;
+    status: AgentProjectionStatus;
+    answer: string;
+    reasoning: string;
+    reasoningActive: boolean;
+    phase: string | null;
+    phaseHistory: string[];
+    operations: Record<string, AgentProjectionOperation>;
+    tools: Record<string, AgentProjectionTool>;
+    renderBlocks: Record<string, AgentProjectionRenderBlock>;
+    renderBlockOrder: string[];
+    completion: Record<string, unknown> | null;
+    error: Record<string, unknown> | null;
+    lastTransportSeq: number;
+    eventCount: number;
+}
+
+/**
+ * `@ai-matrx/agents/matrx` — the Matrx transport port.
+ *
+ * The ONE seam between this package's wire semantics and a host's connection
+ * policy. This package owns WHAT is said to the AI Matrx server — paths,
+ * methods, JSON bodies, streaming Accept headers, the `Last-Event-ID` cursor
+ * header — and the host owns HOW the connection is made:
+ *
+ * - base-URL / backend-channel resolution (global, sandbox override, local
+ *   engine, EC2-dedicated — whatever ladder the host runs);
+ * - credentials (Supabase JWT `Authorization: Bearer`, guest
+ *   `X-Fingerprint-ID`, or the API-key lane) — NEVER implemented here;
+ * - the `X-Organization-Id` context header;
+ * - retry policy, network-level timeouts, and diagnostics capture.
+ *
+ * A host implements the port in a few lines:
+ *
+ * ```ts
+ * const transport: MatrxTransport = {
+ *   fetch: (path, init) =>
+ *     fetch(`${baseUrl}${path}`, {
+ *       ...init,
+ *       headers: { ...init.headers, ...authHeaders() },
+ *     }),
+ * };
+ * ```
+ *
+ * The port is deliberately structural and `fetch`-shaped so `@ai-matrx/data`'s
+ * `/api` transport can implement it without importing this package.
+ */
+/**
+ * The request this package hands the port. A strict subset of `RequestInit`,
+ * so a host can spread it straight into `fetch`.
+ */
+interface MatrxTransportRequest {
+    method: "GET" | "POST";
+    /**
+     * Wire-semantic headers the CALL requires (`Content-Type`, `Accept`,
+     * `Last-Event-ID`). The host merges its policy headers (auth, org) on top;
+     * it must not drop these.
+     */
+    headers: Record<string, string>;
+    /** Pre-serialized JSON body, present on POST calls that carry one. */
+    body?: string;
+    /** Caller cancellation. The host must wire it to the underlying fetch. */
+    signal?: AbortSignal;
+}
+/**
+ * The transport port. `path` is server-relative and always starts with `/`
+ * (`/ai/...`, `/runtime/...`); the host prepends its resolved base URL.
+ */
+interface MatrxTransport {
+    fetch(path: string, init: MatrxTransportRequest): Promise<Response>;
+}
+
+/**
+ * The PRODUCTION `MatrxTransport` — the full connection pipeline every Matrx
+ * host used to hand-roll, moved in under C22 (THE HARD PARTS LIVE IN THE
+ * PACKAGE). A host constructs it from identity alone:
+ *
+ * ```ts
+ * const transport = createMatrxTransport({
+ *   baseUrl: "https://server.app.matrxserver.com",
+ *   credentials,                       // CredentialsPort (@ai-matrx/data)
+ *   organizationId: () => activeOrgId, // omit for conversation-lane calls
+ * });
+ * ```
+ *
+ * Everything else is defaulted to the proven production values:
+ *
+ * - **timeouts** — connect 15s (for a non-streaming FastAPI handler this is
+ *   effectively time-to-response), total UNCAPPED (the port cannot tell a JSON
+ *   call from a long-lived NDJSON/SSE stream; the connect timeout is the JSON
+ *   guard), via `@ai-matrx/data/net`'s `resilientFetch`;
+ * - **protocol** — the AI API version transform (`applyAiApiVersion`, default
+ *   v2) + the loud v2 → v1 transport fallback (`./protocol`);
+ * - **credentials** — read fresh from the injected `CredentialsPort` on EVERY
+ *   call, so a token refresh mid-run is picked up; mapped to headers by the
+ *   ONE `credentialToHeaders`;
+ * - **org context** — the fail-closed `X-Organization-Id` binding
+ *   (`./org-context`): configured lanes REQUIRE an org and refuse before the
+ *   wire; unconfigured lanes (conversation-scoped calls, which carry org in
+ *   the body) send none;
+ * - **error classification** — every failure normalizes through
+ *   `normalizeMatrxError` into the ONE `MatrxCallError` envelope;
+ * - **diagnostics** — a typed sink the host wires to its capture/telemetry
+ *   (`onRequest`, `onError`, `onProtocolDowngrade`); wiring it is optional,
+ *   the transport works silently without it.
+ *
+ * Header merge order is part of the port contract: wire headers first
+ * (`Content-Type` / `Accept` / `Last-Event-ID` — the package's), then
+ * credentials, then resolver policy headers, then the org header. Policy
+ * headers never carry `Content-Type` — the wire owns it, and a policy
+ * `Content-Type` merged over a GET SSE call would corrupt the wire, so the
+ * factory strips it defensively.
+ */
+
+/**
+ * The ONE classified error shape for Matrx client calls — the envelope hosts
+ * branch on instead of string-matching exceptions. Structurally compatible
+ * with matrx-frontend's `ApiCallError` by design.
+ */
+interface MatrxCallError {
+    type: "auth_error" | "network_error" | "http_error" | "validation_error" | "abort_error" | "unknown";
+    message: string;
+    /** HTTP status code, if applicable. */
+    status?: number;
+    /** Raw error detail from the server (the parsed error body). */
+    serverDetail?: unknown;
+    /** Machine code preserved through normalization (server `code`, org-context code, …). */
+    code?: string;
+    /** Original exception identity for diagnostics. */
+    name?: string;
+    /** Original exception stack. */
+    stack?: string;
+}
+
+/**
+ * The conversation-start contract — client-minted `conversation_id`, `is_new`,
+ * `store` — typed exactly per the cross-repo System of Record
+ * (`common-docs/systems/agents/conversation-start-contract/FEATURE.md`;
+ * server truth `aidream/services/conversation_context/scope.py::
+ * ConversationStartRequest`).
+ *
+ * Every request that STARTS a conversation sends all three fields, no
+ * defaults:
+ *
+ * | `is_new` | `store` | Result                                                   |
+ * |----------|---------|----------------------------------------------------------|
+ * | true     | true    | Create the row with the caller's id — 409 if it exists   |
+ * | true     | false   | No row. The id is correlation only (ephemeral run)       |
+ * | false    | true    | Continue it — 404 if the caller doesn't own it           |
+ * | false    | false   | Ephemeral run on a known id; nothing read, nothing written |
+ *
+ * `store` is the ONLY ephemeral signal; `is_new` is the caller's assertion
+ * about the id, never a persistence switch. `prior_messages` (the client-owned
+ * transcript of an ephemeral multi-turn run) is only valid with
+ * `store: false` — the union below makes the invalid combination
+ * unrepresentable, mirroring the server's 422.
+ *
+ * Continue routes (`POST /ai/conversations/{id}`) take the id from the path
+ * and do not carry this triple.
+ */
+/** Recursive JSON value — the package's honest type for free-form wire bags. */
+type MatrxJsonValue = string | number | boolean | null | MatrxJsonValue[] | {
+    [key: string]: MatrxJsonValue;
+};
+/** A JSON object on the wire. */
+type MatrxJsonObject = {
+    [key: string]: MatrxJsonValue;
+};
+/**
+ * One LLM message on the request wire — `prior_messages` entries for
+ * stateless multi-turn runs. Mirrors aidream's `ChatMessageInput`
+ * (`aidream/schemas/messages.py`, `extra="allow"` — additional provider
+ * fields round-trip untouched).
+ */
+interface MatrxChatMessage {
+    role: string;
+    content?: string | MatrxJsonValue[] | null;
+    name?: string | null;
+    tool_call_id?: string | null;
+    tool_calls?: MatrxJsonObject[] | null;
+    [extra: string]: MatrxJsonValue | undefined;
+}
+/** `is_new: true, store: true` — create the row with the caller's id. */
+interface MatrxStoredConversationCreate {
+    conversation_id: string;
+    is_new: true;
+    store: true;
+}
+/** `is_new: false, store: true` — continue an owned stored conversation via a start route. */
+interface MatrxStoredConversationContinue {
+    conversation_id: string;
+    is_new: false;
+    store: true;
+}
+/**
+ * `store: false` — ephemeral: nothing read, nothing written; the id is the
+ * caller's correlation handle. This is the ONLY member that may carry
+ * `prior_messages` (the server 422s a client transcript on a stored run).
+ */
+interface MatrxEphemeralConversation {
+    conversation_id: string;
+    is_new: boolean;
+    store: false;
+    prior_messages?: MatrxChatMessage[];
+}
+/** The full conversation-start triple, one member per contract cell. */
+type MatrxConversationStart = MatrxStoredConversationCreate | MatrxStoredConversationContinue | MatrxEphemeralConversation;
+
+/**
+ * Canonical AI Matrx NDJSON wire kernel.
+ *
+ * This module is deliberately independent of React, Redux, Next.js, Supabase,
+ * and generated application types. Every Matrx client uses it to turn the
+ * backend's byte stream into the same normalized `{ event, data }` envelopes.
+ * Host runtimes remain responsible for HTTP/auth errors and for deciding what
+ * each event means in their state model.
+ */
+interface MatrxStreamEnvelope<TData = unknown> {
+    event: string;
+    data: TData;
+    /** Monotonic transport sequence from full envelopes, when supplied. */
+    stream_seq?: number;
+}
+interface MatrxNdjsonIssue {
+    line: string;
+    error: unknown;
+    /** One-based physical NDJSON line number. */
+    lineNumber: number;
+    /** True when an unterminated trailing fragment was parsed by `finish()`. */
+    atCompletion: boolean;
+}
+interface MatrxStreamEnvelopeObservation {
+    /** Exact parsed JSON value before compact/full normalization. */
+    raw: unknown;
+    envelope: MatrxStreamEnvelope;
+    line: string;
+    lineNumber: number;
+    atCompletion: boolean;
+}
+
+/**
+ * Internal request plumbing for `@ai-matrx/agents/matrx`. Not part of the
+ * public surface — `matrx/index.ts` deliberately does not re-export this
+ * module. Everything here is pure: no globals, no work at import time.
+ */
+
+/**
+ * Options for every streaming call, riding the NDJSON kernel's contract.
+ * Public via `./run`'s re-export.
+ */
+interface MatrxStreamCallOptions {
+    /** Abort the fetch and end the events iterator. */
+    signal?: AbortSignal;
+    /** Bounded background read-ahead (see `stream/ndjson`). */
+    maxReadAhead?: number;
+    /** Malformed NDJSON is non-fatal but must never disappear silently. */
+    onMalformedLine?: (issue: MatrxNdjsonIssue) => void;
+    /** Valid JSON with no recognized Matrx envelope. */
+    onUnknownEnvelope?: (value: unknown) => void;
+    /** Observe every valid envelope in its exact wire form. */
+    onValidEnvelope?: (observation: MatrxStreamEnvelopeObservation) => void;
+}
+
+/**
+ * Agent run lifecycle against the AI Matrx API — start, continue, resume,
+ * cancel — over the `MatrxTransport` port, with every streaming response
+ * parsed through the package's ONE NDJSON wire kernel (`stream/ndjson`).
+ *
+ * Server truth (verified against aidream source):
+ * - `POST /ai/agents/{agent_id}`                — start   (`aidream/api/routers/agents.py`)
+ * - `POST /ai/conversations/{conversation_id}`  — continue (`aidream/api/routers/conversations.py`)
+ * - `POST /ai/conversations/{conversation_id}/resume` — resume after
+ *   client-delegated tool suspension (same router)
+ * - `POST /ai/cancel/{request_id}?mode=interrupt` — cancel (`aidream/api/routers/cancel.py`)
+ *
+ * Response headers arrive before the body: `X-Conversation-ID` and
+ * `X-Request-ID` are surfaced on the run handle immediately. `X-Request-ID`
+ * is the ONLY id the server accepts for cancel — a client-local id means
+ * nothing to it.
+ *
+ * Host policy stays out: no retry, no store, no timeouts, no persistence
+ * (C10: no-persistence). Cancellation is the caller's `AbortSignal`; a client
+ * disconnect never stops server work (`detach_on_disconnect`).
+ */
+
+/**
+ * Stable identity of the durable entity whose saved context owns a run —
+ * the server reloads the row and uses ITS scope (`ContextAnchor`,
+ * `aidream/services/conversation_context/scope.py`).
+ */
+interface MatrxContextAnchor {
+    resource_type: string;
+    resource_id: string;
+}
+/**
+ * Scope and source fields shared by every scoped request
+ * (`ScopedRequest` / `AcceptsInjectedScope` server-side). All optional here;
+ * the start request narrows `organization_id` to required.
+ */
+interface MatrxRequestScope {
+    organization_id?: string;
+    project_id?: string | null;
+    task_id?: string | null;
+    /** Active context-scope ids from the client's global picker (membership-validated server-side). */
+    scope_ids?: string[] | null;
+    /** Active scope-TYPE ids — a type-level selection with no specific scope chosen. */
+    active_scope_type_ids?: string[] | null;
+    context_anchor?: MatrxContextAnchor | null;
+    /** Stable application slug that initiated the request. */
+    source_app?: string | null;
+    /** Stable feature slug within the source application. */
+    source_feature?: string | null;
+    /** "user" = a person directly triggered this; "auto" = client automation; omit for API callers. */
+    initiation?: "user" | "auto" | null;
+    /** Specific connected desktop instance allowed to claim delegated local tools. */
+    target_instance_id?: string | null;
+}
+/**
+ * Fields shared by start/continue turn requests (tool injection, client
+ * capability envelope, context object). The complex bags (`tools`, `client`,
+ * `user`, `config_overrides`) are typed as JSON objects — their authoritative
+ * schemas are the server's Pydantic models and the generated API types;
+ * this package stays payload-agnostic about them by design.
+ */
+interface MatrxTurnFields {
+    /** What the human typed (string), or structured input parts. Never smuggle machine content here. */
+    user_input?: string | MatrxJsonValue[] | null;
+    /** Per-run model/config overrides (LLMParams shape). */
+    config_overrides?: MatrxJsonObject | null;
+    debug?: boolean;
+    /** Additive tool specs merged into the agent's resolved tool set. */
+    tools?: MatrxJsonObject[];
+    /** When set, becomes the agent's ENTIRE tool set for the turn. */
+    tools_replace?: MatrxJsonObject[] | null;
+    /** Client capability envelope (`ClientContext`). */
+    client?: MatrxJsonObject | null;
+    /** Per-request user-level tool inclusion/exclusion overrides. */
+    user?: MatrxJsonObject | null;
+    /** Per-route context object, free-form by design. */
+    context?: MatrxJsonObject;
+    writable_variables?: string[];
+    allow_context_create?: boolean;
+    /** Request-snapshot capture override (tri-state; omit for the platform default). */
+    snapshot?: boolean | null;
+}
+/**
+ * `POST /ai/agents/{agent_id}` body (`AgentStartRequest` server-side).
+ * The conversation-start triple is required by construction; `organization_id`
+ * is required (the server 422s a blank one — it never manufactures an org).
+ * `stream` is not accepted here: this client is the streaming path and always
+ * sends `stream: true`.
+ */
+type MatrxAgentStartRequest = MatrxConversationStart & Omit<MatrxRequestScope, "organization_id"> & MatrxTurnFields & {
+    organization_id: string;
+    /** Variable name → value map filling the agent's declared variables. */
+    variables?: MatrxJsonObject | null;
+    /** Run the versions table row instead of the live agent row. */
+    is_version?: boolean;
+    max_iterations?: number;
+    max_retries_per_iteration?: number;
+};
+/** `POST /ai/conversations/{id}` body (`ConversationContinueRequest` server-side). */
+type MatrxConversationContinueRequest = MatrxRequestScope & MatrxTurnFields & {
+    /** Re-run the conversation's current persisted state (recovery after a failed turn); omit `user_input`. */
+    retry?: boolean;
+};
+/** `POST /ai/cancel/{request_id}` response (`CancelResponse` server-side). */
+interface MatrxCancelResponse {
+    status: string;
+    request_id: string;
+    spine_executions_signalled: string[];
+}
+
+/**
+ * Runtime operations — the canonical reconnect & resume read surface of the
+ * execution spine, over the `MatrxTransport` port.
+ *
+ * Server truth (verified against aidream source,
+ * `aidream/api/routers/runtime_operations.py` + `aidream/services/runtime/
+ * reconnect.py`; mounted at bare `/runtime`):
+ * - `GET  /runtime/operations/{request_id}`            — identify by `X-Request-ID`
+ * - `GET  /runtime/operations/by-link/{kind}/{id}`     — identify by feature record
+ * - `GET  /runtime/executions/{id}/events`             — durable seq-cursored page
+ * - `GET  /runtime/executions/{id}/events/stream`      — SSE replay-then-follow,
+ *   `id:` = per-tree seq, reconnect with `Last-Event-ID`
+ * - `POST /runtime/operations/{request_id}/rejoin`     — replay + follow the
+ *   ORIGINAL NDJSON response while its detached task is alive (409 when live
+ *   delivery is unavailable — fall back to the durable lifecycle stream)
+ *
+ * The contract: identify → recover durable progress → follow live → re-query
+ * the final result from the feature's own record. Token text is deliberately
+ * never replayed on the lifecycle stream — that is what `/rejoin` is for.
+ *
+ * The SSE wire rides the package's own `stream/sse` kernel. This module owns
+ * ONE connection's semantics (frames → typed events, cursor advancement,
+ * terminal `end`); stall timers, retry budgets, and reconnect loops stay host
+ * policy — every yielded item carries the cursor the next attempt resumes from.
+ */
+
+/** `matrx_runtime.models.ExecutionStatus` — the only progress column. */
+type MatrxRuntimeExecutionStatus = "pending" | "running" | "paused" | "waiting_input" | "completed" | "failed" | "cancelled";
+/** One durable spine event on the wire (`OperationEvent`) — `seq` is the reconnect cursor. */
+interface MatrxRuntimeOperationEvent {
+    seq: number | null;
+    /** Lifecycle vocabulary: created | started | paused | resumed | waiting_input | completed | failed | cancelled | checkpoint_saved | note. */
+    kind: string;
+    execution_id: string;
+    root_execution_id: string | null;
+    detail: MatrxJsonObject | null;
+    created_at: string | null;
+}
+
+/**
+ * `useAgentRun` — the package's run/stream hook: start, continue, and cancel
+ * an agent run over an injected `MatrxTransport`, with the streamed state
+ * exposed as the parity-proven request projection
+ * (`@ai-matrx/agents/projection/request` — the ONE event interpreter).
+ *
+ * The hook owns the whole loop the hosts used to hand-roll: the streaming
+ * call, folding every NDJSON envelope through `projectAgentEvent`, terminal
+ * status/error interpretation, unmount/stale-run teardown, and server-side
+ * cancel by the run's `X-Request-ID` (the ONLY id the cancel route accepts).
+ * The host injects only the transport — typically the production
+ * `createMatrxTransport` from `@ai-matrx/agents/matrx`.
+ */
+
+type AgentRunPhase = "idle" | "starting" | "streaming" | "complete" | "error" | "cancelled";
+interface UseAgentRunOptions {
+    /** The transport (or a per-run factory — resolved fresh at each start). */
+    transport: MatrxTransport | (() => MatrxTransport);
+    /** Stream-kernel knobs forwarded to every run (malformed-line hooks, read-ahead). */
+    streamOptions?: Omit<MatrxStreamCallOptions, "signal">;
+    /** Fired after every folded event with the fresh projection. */
+    onProjection?: (projection: AgentRequestProjection) => void;
+    /** Fired when a run fails, with the classified envelope. */
+    onError?: (error: MatrxCallError) => void;
+}
+interface UseAgentRun {
+    /** The lifecycle phase of the CURRENT run. */
+    phase: AgentRunPhase;
+    /** The live projection of the current run (null before the first start). */
+    projection: AgentRequestProjection | null;
+    /** Server-assigned `X-Request-ID` — feeds cancel and reconnect. */
+    requestId: string | null;
+    /** Server-assigned `X-Conversation-ID`. */
+    conversationId: string | null;
+    /** The classified failure of the current run, when phase is "error". */
+    error: MatrxCallError | null;
+    /** Start an agent run (`POST /ai/agents/{agent_id}`); resolves the final projection. */
+    start: (agentId: string, request: MatrxAgentStartRequest) => Promise<AgentRequestProjection>;
+    /** Continue a stored conversation (`POST /ai/conversations/{id}`); resolves the final projection. */
+    continueConversation: (conversationId: string, request: MatrxConversationContinueRequest) => Promise<AgentRequestProjection>;
+    /**
+     * Server-side cancel of the current run by its `X-Request-ID`.
+     * `mode: "interrupt"` = stop-and-fork. Resolves null when no run id is
+     * known yet. The stream stays open until the server ends it — everything
+     * already streamed persists.
+     */
+    cancel: (mode?: "cancel" | "interrupt") => Promise<MatrxCancelResponse | null>;
+    /** Abort the in-flight fetch/stream locally (server work continues by design). */
+    abort: () => void;
+    /** Clear state back to idle (aborts any in-flight run first). */
+    reset: () => void;
+}
+declare function useAgentRun(options: UseAgentRunOptions): UseAgentRun;
+
+/**
+ * `useFollowRuntimeOperation` — the reconnect follower as a hook: follow one
+ * runtime operation's durable lifecycle stream
+ * (`GET /runtime/executions/{id}/events/stream`, `@ai-matrx/agents/stream/sse`
+ * under the hood) with the FULL production reconnect policy built in —
+ * stall watchdog, bounded retry budget, `Last-Event-ID` cursor — via
+ * `followRuntimeOperationToEnd`. Tuning knobs are typed and default to the
+ * proven production values (45s stall, 60 × 2s budget).
+ *
+ * The host injects the transport and what each event MEANS (`onEvent`);
+ * everything else is package policy.
+ */
+
+interface UseFollowRuntimeOperationOptions {
+    /** The transport (typically the production `createMatrxTransport`). */
+    transport: MatrxTransport | (() => MatrxTransport);
+    /** The execution to follow — null/undefined idles the hook. */
+    executionId: string | null | undefined;
+    /** Resume cursor — the operation view's `last_event_seq` (0 = from start). */
+    lastEventSeq?: number;
+    /** Gate — false tears the follow down (default true when an id is set). */
+    enabled?: boolean;
+    /** Stall watchdog, ms. Default 45_000. */
+    stallTimeoutMs?: number;
+    /** Consecutive-failure budget. Default 60. */
+    reconnectLimit?: number;
+    /** Delay between attempts, ms. Default 2_000. */
+    reconnectDelayMs?: number;
+    /** Fired per durable spine event (lifecycle transitions + notes). */
+    onEvent?: (event: MatrxRuntimeOperationEvent, seq: number | null) => void;
+    /** Fired once when the follow settles (server `end`, exhausted budget, or teardown). */
+    onSettled?: (result: {
+        ended: boolean;
+        status: MatrxRuntimeExecutionStatus | null;
+    }) => void;
+}
+interface UseFollowRuntimeOperation {
+    /** True while a follow loop is live for the current execution. */
+    following: boolean;
+    /** True once the server sent the terminal `end` frame. */
+    ended: boolean;
+    /** The root status from the `end` frame, when ended. */
+    status: MatrxRuntimeExecutionStatus | null;
+}
+declare function useFollowRuntimeOperation(options: UseFollowRuntimeOperationOptions): UseFollowRuntimeOperation;
+
+export { type AgentRunPhase, type UseAgentRun, type UseAgentRunOptions, type UseFollowRuntimeOperation, type UseFollowRuntimeOperationOptions, useAgentRun, useFollowRuntimeOperation };