@theokit/sdk 4.53.1 → 4.55.0

package/dist/providers.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var chunk6HTXPPHK_cjs = require('./chunk-6HTXPPHK.cjs');
+require('./chunk-NIRE5CNO.cjs');
+require('./chunk-5USCYPPI.cjs');
+require('./chunk-BVZW2B5V.cjs');
+require('./chunk-52NKC5HT.cjs');
+require('./chunk-K3FW2XZD.cjs');
+require('./chunk-JTB5Q42C.cjs');
+require('./chunk-NUKRL3I6.cjs');
+
+
+
+Object.defineProperty(exports, "getProviderProfile", {
+  enumerable: true,
+  get: function () { return chunk6HTXPPHK_cjs.getProviderProfile; }
+});
+Object.defineProperty(exports, "listProviders", {
+  enumerable: true,
+  get: function () { return chunk6HTXPPHK_cjs.listProviders; }
+});
+//# sourceMappingURL=providers.cjs.map
+//# sourceMappingURL=providers.cjs.map

package/dist/providers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"providers.cjs"}

package/dist/providers.d.cts

@@ -0,0 +1,29 @@
+/**
+ * The provider registry, as public API.
+ *
+ * It was `@internal`, which meant the SDK was the only thing that could answer "which providers
+ * exist, and what does each one need?". `theokit` consequently kept a hand-written list of three —
+ * against the 46 registered here — so an agent declaring `ollama/qwen2.5:3b` routed to whatever
+ * key happened to be set instead of to Ollama (usetheokit/theokit#326).
+ *
+ * A second table that nothing forces to agree with the first is not a cache, it is a future bug.
+ * These two functions exist so there is one table.
+ *
+ * Both ensure the builtins are registered before answering: registration is lazy (it happens when
+ * an agent is created, a run is routed, or a provider is defined), so a caller asking early would
+ * otherwise get an empty registry and reasonably conclude the SDK knows nothing.
+ */
+import type { ProviderProfile } from "./internal/providers/types.js";
+/**
+ * Every registered provider — builtins, the JSON catalog, and anything a plugin registered.
+ *
+ * @public
+ */
+export declare function listProviders(): readonly ProviderProfile[];
+/**
+ * One provider by name or alias (`lm-studio` resolves to `lmstudio`), or `undefined` when nothing
+ * has registered it.
+ *
+ * @public
+ */
+export declare function getProviderProfile(name: string): ProviderProfile | undefined;

package/dist/providers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The provider registry, as public API.
+ *
+ * It was `@internal`, which meant the SDK was the only thing that could answer "which providers
+ * exist, and what does each one need?". `theokit` consequently kept a hand-written list of three —
+ * against the 46 registered here — so an agent declaring `ollama/qwen2.5:3b` routed to whatever
+ * key happened to be set instead of to Ollama (usetheokit/theokit#326).
+ *
+ * A second table that nothing forces to agree with the first is not a cache, it is a future bug.
+ * These two functions exist so there is one table.
+ *
+ * Both ensure the builtins are registered before answering: registration is lazy (it happens when
+ * an agent is created, a run is routed, or a provider is defined), so a caller asking early would
+ * otherwise get an empty registry and reasonably conclude the SDK knows nothing.
+ */
+import type { ProviderProfile } from "./internal/providers/types.js";
+/**
+ * Every registered provider — builtins, the JSON catalog, and anything a plugin registered.
+ *
+ * @public
+ */
+export declare function listProviders(): readonly ProviderProfile[];
+/**
+ * One provider by name or alias (`lm-studio` resolves to `lmstudio`), or `undefined` when nothing
+ * has registered it.
+ *
+ * @public
+ */
+export declare function getProviderProfile(name: string): ProviderProfile | undefined;

package/dist/providers.js

@@ -0,0 +1,10 @@
+export { getProviderProfile, listProviders } from './chunk-2BDH744Z.js';
+import './chunk-Q4CMI2LP.js';
+import './chunk-44MBDIHG.js';
+import './chunk-UQGQFBRL.js';
+import './chunk-3OR54XG4.js';
+import './chunk-IDCKSLYH.js';
+import './chunk-T7XEKOVW.js';
+import './chunk-T7O6K6PX.js';
+//# sourceMappingURL=providers.js.map
+//# sourceMappingURL=providers.js.map

package/dist/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"providers.js"}

package/dist/registry-VFKX7WOP.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var chunkNGESVVJN_cjs = require('./chunk-NGESVVJN.cjs');
+require('./chunk-BUUUWQMB.cjs');
+require('./chunk-CQGYNZ3K.cjs');
+require('./chunk-2C72DXQF.cjs');
+require('./chunk-I6TGFUCO.cjs');
+require('./chunk-K3FW2XZD.cjs');
+require('./chunk-JTB5Q42C.cjs');
+require('./chunk-NUKRL3I6.cjs');
+
+
+
+Object.defineProperty(exports, "__getSubscribersCountForTests", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.__getSubscribersCountForTests; }
+});
+Object.defineProperty(exports, "__resetTaskRegistryForTests", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.__resetTaskRegistryForTests; }
+});
+Object.defineProperty(exports, "cancel", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.cancel; }
+});
+Object.defineProperty(exports, "configure", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.configure; }
+});
+Object.defineProperty(exports, "get", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.get; }
+});
+Object.defineProperty(exports, "list", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.list; }
+});
+Object.defineProperty(exports, "submit", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.submit; }
+});
+Object.defineProperty(exports, "subscribe", {
+  enumerable: true,
+  get: function () { return chunkNGESVVJN_cjs.subscribe; }
+});
+//# sourceMappingURL=registry-VFKX7WOP.cjs.map
+//# sourceMappingURL=registry-VFKX7WOP.cjs.map

package/dist/{registry-63ASMXT4.cjs.map → registry-VFKX7WOP.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"registry-63ASMXT4.cjs"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"registry-VFKX7WOP.cjs"}

package/dist/registry-VFP3WWQP.js

@@ -0,0 +1,10 @@
+export { __getSubscribersCountForTests, __resetTaskRegistryForTests, cancel, configure, get, list, submit, subscribe } from './chunk-SUKXXLWD.js';
+import './chunk-K2BQQ445.js';
+import './chunk-OC4NTGMN.js';
+import './chunk-RUDY2GTT.js';
+import './chunk-VF7EWVDG.js';
+import './chunk-IDCKSLYH.js';
+import './chunk-T7XEKOVW.js';
+import './chunk-T7O6K6PX.js';
+//# sourceMappingURL=registry-VFP3WWQP.js.map
+//# sourceMappingURL=registry-VFP3WWQP.js.map

package/dist/{registry-O7FJ2MPM.js.map → registry-VFP3WWQP.js.map}

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","file":"registry-O7FJ2MPM.js"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"registry-VFP3WWQP.js"}

package/dist/retry.cjs

@@ -1,14 +1,15 @@
 'use strict';
 
-var chunkVW6M4B3Z_cjs = require('./chunk-VW6M4B3Z.cjs');
-require('./chunk-LPVIRJVF.cjs');
-require('./chunk-BM6N4KHO.cjs');
+var chunkHY57ULY2_cjs = require('./chunk-HY57ULY2.cjs');
+require('./chunk-K3FW2XZD.cjs');
+require('./chunk-JTB5Q42C.cjs');
+require('./chunk-NUKRL3I6.cjs');
 
 
 
 Object.defineProperty(exports, "Retry", {
   enumerable: true,
-  get: function () { return chunkVW6M4B3Z_cjs.Retry; }
+  get: function () { return chunkHY57ULY2_cjs.Retry; }
 });
 //# sourceMappingURL=retry.cjs.map
 //# sourceMappingURL=retry.cjs.map

package/dist/retry.js

@@ -1,5 +1,6 @@
-export { Retry } from './chunk-VC5ABJXC.js';
-import './chunk-U4UJHOSH.js';
-import './chunk-5F5NWKPN.js';
+export { Retry } from './chunk-NLTVXLGT.js';
+import './chunk-IDCKSLYH.js';
+import './chunk-T7XEKOVW.js';
+import './chunk-T7O6K6PX.js';
 //# sourceMappingURL=retry.js.map
 //# sourceMappingURL=retry.js.map

package/dist/{run-C8FBAC8o.d.cts → run-BYSHf58D.d.cts}

@@ -143,20 +143,51 @@ interface UserMessageAppendedUpdate {
     type: "user-message-appended";
     userMessage: UserMessage;
 }
-/** @public */
+/**
+ * A conversation summary produced during a run, delivered through `SendOptions.onDelta`.
+ *
+ * Nothing in this package emits it. It is declared so an exhaustive `switch` over
+ * {@link InteractionUpdate} compiles, and so a runtime that does produce summaries has a typed
+ * channel — do not build a feature that waits on it against the local runtime.
+ *
+ * @public
+ */
 interface SummaryUpdate {
     type: "summary";
     summary: string;
 }
-/** @public */
+/**
+ * Opens the bracket around a {@link SummaryUpdate}, for a UI that wants to show a pending state
+ * before the summary text exists. Paired with {@link SummaryCompletedUpdate}.
+ *
+ * Like the summary variants around it, nothing in this package emits it.
+ *
+ * @public
+ */
 interface SummaryStartedUpdate {
     type: "summary-started";
 }
-/** @public */
+/**
+ * Closes the bracket opened by {@link SummaryStartedUpdate}. Carries no payload — the summary text
+ * itself arrives as {@link SummaryUpdate}.
+ *
+ * Like the summary variants around it, nothing in this package emits it.
+ *
+ * @public
+ */
 interface SummaryCompletedUpdate {
     type: "summary-completed";
 }
-/** @public */
+/**
+ * Incremental output from a shell command running inside a run.
+ *
+ * `event` is an untyped bag on purpose: this package neither produces nor narrows it, so a consumer
+ * that receives one should treat it as unvalidated input and check for the fields it needs rather
+ * than casting. As with the summary variants, nothing here emits this — it exists so the
+ * {@link InteractionUpdate} union covers a runtime that does.
+ *
+ * @public
+ */
 interface ShellOutputDeltaUpdate {
     type: "shell-output-delta";
     event: Record<string, unknown>;
@@ -219,6 +250,40 @@ declare function applyMode(verdict: PermissionAction, mode: PermissionMode, expl
  * a destructive shell call while leaving `ls` to fall through.
  */
 type ArgMatcher = string | RegExp | ((value: unknown) => boolean);
+/**
+ * One entry in a {@link PermissionEngine}'s ordered rule list.
+ *
+ * Order is the semantics. The engine walks the list and the first rule whose `tool` matches — and
+ * whose `args` matchers all pass, when it declares any — decides; nothing after it is consulted. Put
+ * the narrow rules first: a catch-all `tool` RegExp placed above a specific deny makes that deny
+ * unreachable, and nothing warns you.
+ *
+ * `args` is what lets one tool name resolve differently depending on what it is asked to do —
+ * `{ tool: "shell", args: { command: /rm\s+-rf/ }, action: "deny" }` blocks the destructive call and
+ * leaves `ls` to fall through to a later rule. Every declared matcher must pass.
+ *
+ * **A missing argument is NOT handled uniformly, and the difference bites in the unsafe direction.**
+ * For a string or RegExp matcher, an argument the call did not supply fails the matcher, so the rule
+ * does not match and evaluation continues. For a PREDICATE matcher the function is called anyway,
+ * with `undefined`:
+ *
+ * ```ts
+ * { tool: "shell", args: { command: (v) => v !== "prod" }, action: "allow" }
+ * // evaluate("shell", {}) → the predicate gets `undefined`, returns true, the rule MATCHES,
+ * // and a call that supplied no arguments at all is authorized.
+ *
+ * { tool: "shell", args: { command: (v) => v.includes("rm") }, action: "deny" }
+ * // evaluate("shell", {}) → TypeError thrown out of the permission gate.
+ * ```
+ *
+ * Until that is fixed (issue #367), guard the parameter in every predicate you write —
+ * `(v) => typeof v === "string" && v !== "prod"` — rather than relying on the matcher never being
+ * reached.
+ *
+ * A rule that matches yields an EXPLICIT verdict, and that is what makes it survive a permissive
+ * `PermissionMode`: `acceptEdits` auto-approves the unmatched default but still honours an explicit
+ * `ask` rule, and an explicit `deny` is immune to every mode, `bypass` included.
+ */
 interface PermissionRule {
     /** Tool name (exact string) or pattern (RegExp). */
     tool: string | RegExp;
@@ -241,6 +306,27 @@ interface PermissionEngineOptions {
      */
     readonly defaultAction?: PermissionAction;
 }
+/**
+ * Ordered first-match permission rules for tool invocations — the policy object you hand to
+ * `PermissionPlugin.create()` to have it enforced.
+ *
+ * On its own it enforces nothing. `evaluate(toolName, args, mode)` is a pure function returning
+ * `"allow" | "deny" | "ask"`, and no part of the SDK calls it until the engine is wrapped in a plugin
+ * and that plugin is registered on an agent. The plugin is where a verdict becomes behaviour: `deny`
+ * blocks the tool call, `allow` passes it through, and `ask` is routed to the host's `canUseTool`
+ * gate — with no gate configured, `ask` blocks. So constructing an engine and never registering it
+ * is a policy that does nothing, which is the mistake worth knowing about first.
+ *
+ * It is fail-closed by default: a call no rule matches resolves to `"ask"`, not `"allow"`, so a tool
+ * the rules never mention needs a human — or an explicit `{ defaultAction: "allow" }` — before it
+ * runs. Keep that default if you intend to use `PermissionMode: "plan"` for read-only behaviour,
+ * because `plan` gates on the RESOLVED verdict: an engine built with `defaultAction: "allow"` still
+ * allows every unmatched call under `plan`.
+ *
+ * The rules array is stored by reference and walked afresh on every `evaluate` call. Mutating the
+ * array you passed in therefore changes the policy of a live engine; build a new engine when you
+ * want a policy change to be a deliberate, visible event.
+ */
 declare class PermissionEngine {
     #private;
     private readonly rules;
@@ -274,7 +360,7 @@ declare class PermissionEngine {
  *
  * @public
  */
-type RunEvent = RunToolProgressEvent | RunRateLimitEvent | RunPermissionDeniedEvent | RunTaskStartedEvent | RunTaskUpdatedEvent | RunTaskCompletedEvent | RunCompactBoundaryEvent | RunCompactionFallbackEvent | RunTripwireEvent | RunCompletionCheckEvent | RunMcpServerFailedEvent;
+type RunEvent = RunToolProgressEvent | RunRateLimitEvent | RunPermissionDeniedEvent | RunTaskStartedEvent | RunTaskUpdatedEvent | RunTaskCompletedEvent | RunCompactBoundaryEvent | RunCompactionFallbackEvent | RunTripwireEvent | RunCompletionCheckEvent | RunMcpServerFailedEvent | RunMcpServerReadyEvent;
 /**
  * theokit#188 — an MCP server was configured but its tools could not be listed, so NONE of its
  * tools exist for this run.
@@ -294,6 +380,33 @@ interface RunMcpServerFailedEvent {
     /** Why listing failed — a spawn error, a handshake timeout, a protocol error. */
     readonly message: string;
 }
+/**
+ * usetheokit/theokit#426 — an MCP server came up, and these are the tools it delivered.
+ *
+ * The sibling of {@link RunMcpServerFailedEvent}, emitted from the same function, on the other
+ * branch. Without it a consumer could see what was CONFIGURED and what BROKE, and could not tell a
+ * server that came up with twelve tools from one that came up with none — which is exactly the case
+ * an operator opens a server-status panel to find. `tools: []` on a healthy server is a real and
+ * previously unreportable state.
+ *
+ * An EVENT rather than a getter, because the state is scoped to the run: with
+ * `mcpLifecycle: "run"` a server may not exist by the time anyone asks, so a getter would have to
+ * answer about something already gone. This says what was true when the run started.
+ *
+ * Emitted once per successfully-listed server per run.
+ */
+interface RunMcpServerReadyEvent {
+    readonly type: "mcp_server_ready";
+    /** The server as named in the MCP configuration — the key a consumer already lists it under. */
+    readonly serverName: string;
+    /**
+     * The tool names the server reported, as IT names them.
+     *
+     * Not the `mcp_<server>_<tool>` form the model sees: that spelling is sanitized for the provider,
+     * and a consumer matching it back to a server's own documentation would have to undo the mangling.
+     */
+    readonly tools: readonly string[];
+}
 /**
  * SE24 — a guardrail processor called `abort()`; the run stops with a tripwire.
  * Delivered via {@link SendOptions.onRunEvent} (mirrors the `RunResult.tripwire`
@@ -572,6 +685,20 @@ interface ModelSelection {
      * clamped — declaring 10M does not blow past the provider.
      */
     contextWindow?: number;
+    /**
+     * #332 — the endpoint THIS model should reach, for OpenAI-compatible and local servers.
+     *
+     * Without it the base URL came only from a process-wide env var (`OLLAMA_HOST`) or the provider
+     * profile's shipped default, so every `ollama/*` model in a process shared one host — an app
+     * could not run a small model on localhost and a large one on a GPU box.
+     *
+     * It outranks the env var deliberately: with the env var winning, whoever set it for one model
+     * would keep hijacking every other one, which is the same bug wearing a hat.
+     *
+     * Leaving it unset keeps the zero-config path exactly as it was — `ollama/qwen2.5:3b` still
+     * resolves to `http://localhost:11434` from the profile, with no key and no setup.
+     */
+    url?: string;
 }
 /**
  * SE12 — a read-only, text-only projection of one turn of the run's conversation,
@@ -679,11 +806,6 @@ interface ShellOutput {
     stderr: string;
     exitCode: number;
 }
-/**
- * Single step inside an agent turn.
- *
- * @public
- */
 /**
  * Result of a tool invocation. Pairs with the preceding `toolCall` step
  * by `callId`. `isError: true` when the tool returned a failure result.
@@ -699,6 +821,24 @@ interface ToolResult {
     result: string;
     isError: boolean;
 }
+/**
+ * A single step inside an agent turn, discriminated by `type`: an assistant message, a tool call, the
+ * tool result that pairs with it, or a thinking block.
+ *
+ * It reaches a caller by two routes that are NOT the same set. `Run.conversation()` returns the
+ * accumulated steps of a finished turn and includes `thinkingMessage`. `SendOptions.onStep` fires
+ * live while the turn runs and emits `assistantMessage`, `toolCall` and `toolResult` — but never
+ * `thinkingMessage`, which the loop builds only into the accumulated conversation. A UI that wants
+ * reasoning as it happens should read the `thinking-delta` / `thinking-completed` variants of
+ * `InteractionUpdate` through `onDelta` instead.
+ *
+ * `toolCall` and its `toolResult` arrive as an ordered pair matched by `callId`; a call whose result
+ * never came back has no `toolResult` step, so do not assume they alternate. Where a
+ * `thinkingMessage` exists it precedes the `assistantMessage` of the same turn — that is the order
+ * the provider requires of the message the block belongs to, not a presentation choice.
+ *
+ * @public
+ */
 type ConversationStep = {
     type: "assistantMessage";
     message: AssistantMessage;
@@ -1105,11 +1245,16 @@ interface RunGitInfo {
     }>;
 }
 /**
- * SE3 — provenance of the turn that produced a run: WHO triggered it. Stamped in
- * the multi-agent path (Squad / a2a / handoff / background-delegation) and
- * forwarded onto {@link RunResult.origin} — so consumers can attribute/route
- * turns by their trigger. Metadata-only; discriminate on `kind`. Mirrors the
- * Anthropic Agent SDK's `origin` shape.
+ * SE3 — provenance of the turn that produced a run: WHO triggered it. Metadata-only —
+ * it never changes routing or dispatch. Stamped in the multi-agent path (Squad / a2a /
+ * handoff / background-delegation) and forwarded onto {@link RunResult.origin}, so
+ * consumers can attribute/route turns by their trigger; discriminate on `kind`. Mirrors
+ * the Anthropic Agent SDK's `origin` shape.
+ *
+ * Producers: `peer` (Squad step / a2a envelope), `coordinator` (subagent delegation) and
+ * `auto-continuation` (the run-to-completion / stream-to-completion driver's continuation
+ * rounds) are stamped BY the SDK. `human` and `task-notification` are positive markers a
+ * HOST stamps (e.g. re-sending an agent after a background task completed).
  *
  * Encoding note (distinct from absence): an ABSENT origin (`undefined`) means the
  * provenance was NOT stamped — the default for a plain `agent.send()`. The explicit
@@ -1122,16 +1267,6 @@ interface RunGitInfo {
  *
  * @public
  */
-/**
- * SE3 — provenance of a turn (metadata-only; never changes routing/dispatch).
- * Producers: `peer` (Squad step / a2a envelope), `coordinator` (subagent
- * delegation), `auto-continuation` (the run-to-completion / stream-to-completion
- * driver's continuation rounds) are stamped BY the SDK. `human` and
- * `task-notification` are positive markers a HOST stamps (e.g. re-sending an
- * agent after a background task completed). Absent origin ⇒ `undefined`.
- *
- * @public
- */
 type MessageOrigin = 
 /** Explicitly a human-triggered turn — a positive marker a host stamps (NOT the
  *  same as an absent/unstamped origin, which is `undefined`). */
@@ -1202,9 +1337,13 @@ interface RunResult {
     error?: RunErrorDetail;
     /**
      * Token usage observed for this run (ADR D376). Populated in every
-     * status where ≥1 LLM call completed — including partial-failure
-     * runs (EC-5). `undefined` only when zero LLM calls executed (e.g.,
-     * abort before send).
+     * status where ≥1 LLM call COMPLETED — including partial-failure
+     * runs (EC-5). `undefined` when zero LLM calls executed (e.g. an
+     * abort before send) and, for the same reason, when the only call was
+     * cut mid-stream: the counts arrive with the provider's terminating
+     * frame, which a severed connection never delivers. Such a run can
+     * therefore return partial text (#371) with no usage to bill it
+     * against — the tokens were generated and are not reported here.
      *
      * @public
      */
@@ -1576,11 +1715,6 @@ interface CompletionCheckResult {
     /** `true` when the judge output could not be parsed — fail-safe `complete: false`. */
     parseFailed: boolean;
 }
-/**
- * Handle to a single prompt submission.
- *
- * @public
- */
 /**
  * theokit#140 - one element of {@link Run.events}: either a structural SDK message or a live delta.
  *
@@ -1611,6 +1745,24 @@ type RunTimelineEvent = {
     kind: "delta";
     update: InteractionUpdate;
 };
+/**
+ * Handle to a single prompt submission, returned by `agent.send()` before the model has answered.
+ *
+ * It is a live handle rather than a result — `status` is `"running"` when you receive it — and how
+ * you consume the turn is the decision it asks of you. Call `wait()` when only the final answer
+ * matters. Call `events()` when you want the whole timeline: structural messages and token/tool
+ * deltas interleaved in true order, from one source. That is the one to reach for instead of fusing
+ * `stream()` with `SendOptions.onDelta` yourself, which is what produced the ordering and
+ * duplicate-text bugs it replaces. `stream()` remains the SDKMessage-only view, and
+ * `conversation()` returns the finished turn grouped per turn instead of as a stream.
+ *
+ * `cancel()` moves the run to `"cancelled"`, aborts the stream and stops in-flight tool calls.
+ *
+ * Not every method is available on every runtime — see {@link RunOperation}. Ask `supports(op)`
+ * before calling an optional one and surface `unsupportedReason(op)`, rather than calling it and
+ * catching. The optional fields (`result`, `model`, `durationMs`, `git`, `createdAt`) fill in as the
+ * run progresses, so treat their absence as "not yet", not as an error.
+ */
 interface Run {
     readonly id: string;
     readonly agentId: string;