@theokit/sdk 0.0.0-compat-580-20260905204608

package/dist/agent-N6WJ54ML.js

@@ -0,0 +1,58 @@
+export { Agent } from './chunk-OYD3U3LY.js';
+import './chunk-K2VMFZQ5.js';
+import './chunk-AWINL3ZC.js';
+import './chunk-K2BQQ445.js';
+import './chunk-7SZAV6QG.js';
+import './chunk-AW6F6HZR.js';
+import './chunk-2SFBB54R.js';
+import './chunk-55GB6JYQ.js';
+import './chunk-H73MEMQB.js';
+import './chunk-OR6XIWLB.js';
+import './chunk-SADXXGWU.js';
+import './chunk-AAEZSPTC.js';
+import './chunk-K3NH62DG.js';
+import './chunk-UBR5PWD7.js';
+import './chunk-2XC6KDJM.js';
+import './chunk-XB4GI5RZ.js';
+import './chunk-24MGQDK3.js';
+import './chunk-2WXHA33T.js';
+import './chunk-HKCKOAIO.js';
+import './chunk-N6OOOYFZ.js';
+import './chunk-KVNWIAO4.js';
+import './chunk-SVQIW5RJ.js';
+import './chunk-FD2UT76F.js';
+import './chunk-7I5Z3UBJ.js';
+import './chunk-FJWQP6EE.js';
+import './chunk-NAF4L3T6.js';
+import './chunk-CFE6QF2Q.js';
+import './chunk-6X6ID4MO.js';
+import './chunk-LX7SEXOQ.js';
+import './chunk-2XRAWOZZ.js';
+import './chunk-SAGRF4IB.js';
+import './chunk-EH6XD3FY.js';
+import './chunk-UKMBRMGT.js';
+import './chunk-4MMWFSCD.js';
+import './chunk-G7BLGBRN.js';
+import './chunk-VE6DFSKU.js';
+import './chunk-JOFVLOFY.js';
+import './chunk-WE22OXQA.js';
+import './chunk-6PWOWXMC.js';
+import './chunk-TA3K7SBK.js';
+import './chunk-Q5EWJPRY.js';
+import './chunk-EIQFAOFD.js';
+import './chunk-3JHIFQ4I.js';
+import './chunk-OQRGVTQF.js';
+import './chunk-WMWEI3NS.js';
+import './chunk-JNAA4G4H.js';
+import './chunk-6M2OIS4Y.js';
+import './chunk-R7WIIPUR.js';
+import './chunk-XYFGKVZ7.js';
+import './chunk-VWUXIVEI.js';
+import './chunk-AGACYRJ2.js';
+import './chunk-JMDDYA22.js';
+import './chunk-V22DZIXO.js';
+import './chunk-NJWYQWDL.js';
+import './chunk-ALUN2B4W.js';
+import './chunk-CZJ6Q7CW.js';
+//# sourceMappingURL=agent-N6WJ54ML.js.map
+//# sourceMappingURL=agent-N6WJ54ML.js.map

package/dist/agent-N6WJ54ML.js.map

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

package/dist/agent-builder.d.ts

@@ -0,0 +1,72 @@
+import type { AgentDefinition, AgentOptions, CloudOptions, CustomTool, LocalOptions, MemorySettings, ModelSelection, SDKAgent, SkillsSettings, SystemPromptResolver } from "./types/agent.js";
+import type { ContextSettings } from "./types/context.js";
+import type { McpServerConfig } from "./types/mcp.js";
+import type { PluginsSettings, ProviderRoutingSettings } from "./types/providers.js";
+/**
+ * Terminal-method callbacks injected by `Agent.builder()` so that
+ * `agent-builder.ts` does NOT need a static import of `Agent` — keeps the
+ * dependency graph acyclic (G6).
+ *
+ * Exported, and NOT carrying the internal-visibility JSDoc tag, because
+ * `AgentBuilder` is `@public` and so is its constructor: `new AgentBuilder(deps)`
+ * is callable by anyone, which makes this parameter's type part of the published
+ * contract whether or not we intended it. Hiding it did not make it private — it
+ * made the emitted `.d.ts` say `constructor(deps?: AgentBuilderDeps)` with no such
+ * type in the file (#335). Prefer `Agent.builder()`, which injects these for you;
+ * this is the seam it uses, not an argument callers are expected to construct.
+ *
+ * @public
+ */
+export interface AgentBuilderDeps {
+    create: (options: AgentOptions) => Promise<SDKAgent>;
+    getOrCreate: (agentId: string, options: AgentOptions) => Promise<SDKAgent>;
+}
+/**
+ * Fluent builder for {@link AgentOptions}. Chainable setters mutate internal
+ * state and return `this`. Three terminals:
+ *
+ * - `.build()` — synchronous snapshot (shallow clone) of accumulated options.
+ * - `.create()` — calls the injected `create` (Agent.create).
+ * - `.getOrCreate(agentId)` — calls the injected `getOrCreate` (Agent.getOrCreate).
+ *
+ * Validation runs inside the terminals via `validateAgentOptions`. See ADR D25.
+ *
+ * @public
+ */
+export declare class AgentBuilder {
+    private opts;
+    private readonly deps;
+    constructor(deps?: AgentBuilderDeps);
+    /** SE8 — accepts a bare-string id shorthand (`"openai/gpt-4o-mini"`) or a {@link ModelSelection}. */
+    model(m: string | ModelSelection): this;
+    apiKey(k: string): this;
+    name(n: string): this;
+    systemPrompt(p: string | SystemPromptResolver): this;
+    local(l: LocalOptions): this;
+    cloud(c: CloudOptions): this;
+    memory(m: MemorySettings): this;
+    tools(t: CustomTool[]): this;
+    mcpServers(s: Record<string, McpServerConfig>): this;
+    agents(a: Record<string, AgentDefinition>): this;
+    context(c: ContextSettings): this;
+    providers(p: ProviderRoutingSettings): this;
+    plugins(p: PluginsSettings): this;
+    skills(s: SkillsSettings): this;
+    agentId(id: string): this;
+    /**
+     * Synchronous snapshot of the accumulated options. Returns a SHALLOW CLONE
+     * so external mutation of the result doesn't pollute the builder state (EC-2).
+     */
+    build(): AgentOptions;
+    /**
+     * Validate + create a fresh agent. Delegates to `Agent.create` via the
+     * injected `deps.create`. Throws if the builder was instantiated without
+     * deps (i.e., direct `new AgentBuilder()` instead of `Agent.builder()`).
+     */
+    create(): Promise<SDKAgent>;
+    /**
+     * Resume an existing agent or create one if the ID is unknown. Delegates to
+     * `Agent.getOrCreate` via the injected `deps.getOrCreate` (ADR D22).
+     */
+    getOrCreate(agentId: string): Promise<SDKAgent>;
+}

package/dist/agent-factory-registry-UU46BUMU.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunkNINIJCHU_cjs = require('./chunk-NINIJCHU.cjs');
+
+
+
+Object.defineProperty(exports, "getAgentFacade", {
+  enumerable: true,
+  get: function () { return chunkNINIJCHU_cjs.getAgentFacade; }
+});
+Object.defineProperty(exports, "setAgentFacade", {
+  enumerable: true,
+  get: function () { return chunkNINIJCHU_cjs.setAgentFacade; }
+});
+//# sourceMappingURL=agent-factory-registry-UU46BUMU.cjs.map
+//# sourceMappingURL=agent-factory-registry-UU46BUMU.cjs.map

package/dist/agent-factory-registry-UU46BUMU.cjs.map

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

package/dist/agent-factory-registry-ZVTABLEY.js

@@ -0,0 +1,3 @@
+export { getAgentFacade, setAgentFacade } from './chunk-6X6ID4MO.js';
+//# sourceMappingURL=agent-factory-registry-ZVTABLEY.js.map
+//# sourceMappingURL=agent-factory-registry-ZVTABLEY.js.map

package/dist/agent-factory-registry-ZVTABLEY.js.map

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

package/dist/agent-factory.d.ts

@@ -0,0 +1,24 @@
+import type { AgentOptions, SDKAgent } from "./types/agent.js";
+/**
+ * Handle returned by {@link createAgentFactory}. See ADR D23 for merge
+ * semantics.
+ *
+ * @public
+ */
+export interface AgentFactory {
+    /**
+     * Create a fresh agent for this session. Equivalent to `Agent.create(merged)`
+     * where `merged` is `common` ⊕ `overrides` ⊕ `{ agentId }`.
+     */
+    forSession(agentId: string, overrides?: Partial<AgentOptions>): Promise<SDKAgent>;
+    /**
+     * Resume an existing agent for this session, or create one if the ID is
+     * unknown. Equivalent to `Agent.getOrCreate(agentId, merged)`.
+     */
+    getOrCreate(agentId: string, overrides?: Partial<AgentOptions>): Promise<SDKAgent>;
+}
+/** SE36 — `AgentFactory.create` replaces `createAgentFactory` (ADR 0015). Merges with the `AgentFactory` interface. @public */
+export declare class AgentFactory {
+    private constructor();
+    static create(common: Partial<AgentOptions>): AgentFactory;
+}

package/dist/agent-generate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SE9 — integrated structured output: `agent.generate(input, { output })` runs the
+ * agent's NORMAL tool loop (the user's tools run first) and then coerces the final
+ * answer into a Zod schema, returning a validated, inferred-typed object.
+ *
+ * This is SUGAR over `generateObject` (ADR D33) — it does NOT fork the
+ * synthetic-forced-tool machinery. Phase 1 is the user's own `agent.send()` run;
+ * phase 2 reuses `generateObjectImpl` over the run's final answer.
+ *
+ * @public
+ */
+export type { GenerateOptions, GenerateRunResult } from "./types/run.js";

package/dist/agent-session-store-AFML3AXC.js

@@ -0,0 +1,6 @@
+export { appendCompactBoundaryRecord, persistTurn, readSessionMessages } from './chunk-2WXHA33T.js';
+import './chunk-JOFVLOFY.js';
+import './chunk-3JHIFQ4I.js';
+import './chunk-CZJ6Q7CW.js';
+//# sourceMappingURL=agent-session-store-AFML3AXC.js.map
+//# sourceMappingURL=agent-session-store-AFML3AXC.js.map

package/dist/agent-session-store-AFML3AXC.js.map

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

package/dist/agent-session-store-MTSIY3MH.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var chunkYIFFF23U_cjs = require('./chunk-YIFFF23U.cjs');
+require('./chunk-GZV6AVRL.cjs');
+require('./chunk-JLRLCBJ4.cjs');
+require('./chunk-6LHQPOMI.cjs');
+
+
+
+Object.defineProperty(exports, "appendCompactBoundaryRecord", {
+  enumerable: true,
+  get: function () { return chunkYIFFF23U_cjs.appendCompactBoundaryRecord; }
+});
+Object.defineProperty(exports, "persistTurn", {
+  enumerable: true,
+  get: function () { return chunkYIFFF23U_cjs.persistTurn; }
+});
+Object.defineProperty(exports, "readSessionMessages", {
+  enumerable: true,
+  get: function () { return chunkYIFFF23U_cjs.readSessionMessages; }
+});
+//# sourceMappingURL=agent-session-store-MTSIY3MH.cjs.map
+//# sourceMappingURL=agent-session-store-MTSIY3MH.cjs.map

package/dist/agent-session-store-MTSIY3MH.cjs.map

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

package/dist/agent.d.ts

@@ -0,0 +1,276 @@
+import { AgentBuilder } from "./agent-builder.js";
+import { type LiveAgentRegistry } from "./internal/runtime/registry/live-agent-registry.js";
+import type { AgentDescription, AgentOperationOptions, AgentOptions, GetAgentOptions, GetRunOptions, ListAgentsOptions, ListResult, ListRunsOptions, SDKAgent, SDKAgentInfo } from "./types/agent.js";
+import type { Run, RunResult } from "./types/run.js";
+import type { SessionMessage } from "./types/session-message.js";
+/**
+ * Result of a one-shot {@link Agent.prompt} call.
+ *
+ * @public
+ */
+export type AgentPromptResult = RunResult;
+/**
+ * Static façade for creating and managing Theo agents.
+ *
+ * @public
+ */
+export declare class Agent {
+    private constructor();
+    /**
+     * Live-agent cache for production deploys (Production-Readiness #2, ADRs D307-D310).
+     *
+     * Caches `SDKAgent` instances by id with LRU eviction (when `size > maxAgents`)
+     * and an idle-timeout sweep. Solves the OOM failure mode for long-running
+     * Node servers spawning fresh agents per conversation.
+     *
+     * Defaults: `maxAgents: 100`, `idleTimeoutMs: 30 min`, sweep `60s`.
+     * Configure for high-traffic SaaS:
+     *
+     * ```ts
+     * Agent.registry.configure({ maxAgents: 1000, idleTimeoutMs: 15 * 60_000 });
+     * process.on("SIGTERM", () => Agent.registry.evictAll());
+     * ```
+     *
+     * Cache hits are automatic in `Agent.getOrCreate` (T2.6). Disable the cache
+     * entirely via `configure({ maxAgents: 0 })` — every getOrCreate then
+     * re-initializes.
+     *
+     * @public
+     */
+    static readonly registry: LiveAgentRegistry;
+    /**
+     * Create a new agent. Pass either `local` or `cloud` to pick a runtime.
+     *
+     * @public
+     */
+    static create(options: AgentOptions): Promise<SDKAgent>;
+    /**
+     * One-shot prompt: create an agent, send a single message, wait, **dispose**.
+     *
+     * `Agent.prompt` is STATIC and owns the agent's whole lifecycle. To send to an
+     * agent you already hold, use the instance method — `agent.send(message)` —
+     * which keeps the conversation and does not dispose anything:
+     *
+     * ```ts
+     * const agent = await Agent.create({ ... });
+     * const run = await agent.send("first");     // NOT agent.prompt(...)
+     * const run2 = await agent.send("follow-up"); // full context retained
+     * ```
+     *
+     * There is no `agent.prompt()` (#302). The natural sentence for the second
+     * operation is "prompt the agent", so it is the method people reach for; the
+     * two differ in whether the agent survives the call, which is why they do not
+     * share a name.
+     *
+     * When `options.throwOnError === true`, rejects with `AgentRunError` if
+     * the run terminates with `status: 'error'` (instead of resolving with the
+     * error wrapped in the RunResult). Cancelled runs still resolve normally.
+     *
+     * @public
+     */
+    static prompt(message: string, options: AgentOptions): Promise<AgentPromptResult>;
+    /**
+     * Reattach to an existing agent by ID.
+     *
+     * @public
+     */
+    static resume(agentId: string, options?: Partial<AgentOptions>): Promise<SDKAgent>;
+    /**
+     * Start building an {@link AgentOptions} via fluent chain. See ADR D25.
+     * Terminals: `.build()`, `.create()`, `.getOrCreate(id)`.
+     *
+     * The builder receives `create` + `getOrCreate` as injected callbacks so
+     * that `agent-builder.ts` doesn't need a static import of `Agent` — keeps
+     * the module graph acyclic (G6).
+     *
+     * @public
+     */
+    static builder(): AgentBuilder;
+    /**
+     * Generate a typed object matching a Zod schema via a synthetic forced
+     * tool call (ADR D33). One-shot: create transient agent → send prompt →
+     * model calls `output` tool → parse args via Zod → return typed.
+     *
+     * @public
+     */
+    static generateObject<T extends import("zod").ZodType>(options: import("./generate-object.js").GenerateObjectOptions<T>): Promise<import("./generate-object.js").GenerateObjectResult<import("zod").z.infer<T>>>;
+    /**
+     * Stream a structured output object alongside intermediate `partial`
+     * deltas as the model accumulates its response (ADR D39). Returns an
+     * `AsyncIterator<StreamObjectEvent<T>>` that yields zero or more
+     * `partial` events and exactly one `complete` event at the end.
+     *
+     * The `complete` event carries the same `object: z.infer<T>` you would get
+     * from `Agent.generateObject` — same prompt + schema + model produces
+     * the same final object.
+     *
+     * @public
+     */
+    static streamObject<T extends import("zod").ZodType>(options: import("./stream-object.js").StreamObjectOptions<T>): AsyncGenerator<import("./stream-object.js").StreamObjectEvent<import("zod").z.infer<T>>, void, void>;
+    /**
+     * Run N prompts in parallel with bounded concurrency (ADRs D134-D140).
+     *
+     * Each prompt gets a fresh agent (create → send → wait → dispose). Failures
+     * are isolated per-prompt; the batch never throws on a single failure —
+     * inspect `result.ok` to discriminate success vs error. Default
+     * concurrency is 4. When `options.providers.apiKeys` has ≥2 keys per
+     * provider, all in-flight agents share a single credential pool via
+     * `AsyncLocalStorage` (EC-A) so rate-limit cooldowns are observed once
+     * instead of duplicated per agent.
+     *
+     * Streaming progress is opt-in via `onResult` / `onProgress`. `AbortSignal`
+     * cancels pending prompts; in-flight ones continue to completion (Node
+     * AbortSignal semantics). `signal.reason` propagates to `error` when set.
+     *
+     * @public
+     */
+    static batch(prompts: ReadonlyArray<string | import("./types/batch.js").BatchItem>, options: import("./types/batch.js").BatchOptions): Promise<import("./types/batch.js").BatchResult[]>;
+    /**
+     * Get an existing agent by ID, or create one with the supplied options if
+     * the ID is not yet registered. Eliminates the resume-vs-create boilerplate
+     * common to chat bots and other long-running agent consumers. See ADR D22.
+     *
+     * Resolution:
+     * 1. Try `Agent.resume(agentId, options)`. Return on success.
+     * 2. On `UnknownAgentError`, fall through to `Agent.create({ ...options, agentId })`.
+     * 3. On same-process race (`ConfigurationError(code: "agent_id_already_exists")`
+     *    during step 2), retry `Agent.resume` once and return the winner's handle.
+     * 4. Any other error propagates verbatim.
+     *
+     * Caveats:
+     * - The function-level `agentId` always wins over `options.agentId`.
+     * - Options differ between calls? Last-call-wins for this handle (matches `Agent.resume`).
+     * - A DISPOSED agent is replaced automatically. `dispose()` evicts the id from the
+     *   live cache (`liveAgentRegistry.forget`), so the next `getOrCreate(id)` builds a
+     *   fresh handle — no `Agent.delete(agentId)` needed.
+     *
+     *   This bullet used to say the opposite ("Disposed agents are NOT auto-deleted...
+     *   call `Agent.delete(agentId)` first"). It was measured false in M91:
+     *   `tests/agent-getorcreate-after-dispose.test.ts` builds an agent, disposes it, and
+     *   gets a different instance back. The claim was about the PERSISTENT registry and
+     *   read as being about the live cache — and consumers built around the wrong half.
+     *   The agent-builder's M85 interrupt rotates the session id to work around a
+     *   constraint that does not exist.
+     *
+     * - `close()` marks the handle disposed WITHOUT evicting the cache entry. It is
+     *   internal and unused today; if it becomes reachable, this bullet stops being true
+     *   for that path.
+     *
+     * @public
+     */
+    static getOrCreate(agentId: string, options: AgentOptions): Promise<SDKAgent>;
+    /**
+     * List agents (local or cloud). M107 — `cwd` is READ, not ignored. B-115 (2026-08-19) —
+     * `includeArchived` and `limit`/`cursor` are READ too now; see `ListAgentsOptions`'s doc for the
+     * pagination contract and why the unlimited (no `limit`) case is unaffected.
+     *
+     * @public
+     */
+    static list(options?: ListAgentsOptions): Promise<ListResult<SDKAgentInfo>>;
+    /**
+     * Get metadata for a single agent. B-115 (2026-08-19) — `cwd` is READ now (see
+     * `GetAgentOptions`'s doc); it used to be accepted and silently ignored.
+     *
+     * @public
+     */
+    static get(agentId: string, options?: GetAgentOptions): Promise<SDKAgentInfo>;
+    /**
+     * List runs for an agent. B-115 (2026-08-19) — `cwd` and `limit`/`cursor` are READ now (see
+     * `ListRunsOptions`'s doc); they used to be accepted and silently ignored.
+     *
+     * @public
+     */
+    static listRuns(agentId: string, options?: ListRunsOptions): Promise<ListResult<Run>>;
+    /**
+     * Get a single run.
+     *
+     * @public
+     */
+    static getRun(runId: string, options?: GetRunOptions): Promise<Run>;
+    /**
+     * Archive a cloud agent.
+     *
+     * @public
+     */
+    static archive(agentId: string, _options?: AgentOperationOptions): Promise<void>;
+    /**
+     * Restore an archived cloud agent.
+     *
+     * @public
+     */
+    static unarchive(agentId: string, _options?: AgentOperationOptions): Promise<void>;
+    /**
+     * Set the human-facing `name` of a registered agent (the label `Agent.list()` returns). The registry
+     * already carries a `name` field; this is the missing public mutator for it. Runtime-agnostic (mutates
+     * the local per-cwd registry for local agents; the cloud registry for cloud agents).
+     *
+     * @public
+     */
+    static rename(agentId: string, name: string, _options?: AgentOperationOptions): Promise<void>;
+    /**
+     * M50 — compact a LOCAL agent's persisted session transcript (Codex `/compact` parity): the
+     * history is summarized (recent user messages preserved verbatim + one marker'd summary) and an
+     * append-only `compact_boundary` + replacement chain is written — resume replays only the
+     * replacement + later turns. The summarizer defaults to the compression subsystem's aux-LLM
+     * (its first real caller); tests/consumers may inject their own.
+     *
+     * @public
+     */
+    static compact(agentId: string, options?: {
+        trigger?: "manual" | "auto";
+        summarize?: (messages: readonly import("./compaction.js").CompressibleMessage[]) => Promise<string>;
+    }): Promise<import("./internal/session/compact-session.js").CompactResult>;
+    /**
+     * M51 — inject a SYNTHETIC user+assistant pair into a LOCAL session's persisted transcript WITHOUT
+     * running an LLM turn (the Codex review-exit mechanism: the parent thread "learns" a result — e.g.
+     * review findings — so follow-ups work). Appends onto the DAG leaf and invalidates the in-memory
+     * cache; serialized on the per-agent write chain.
+     *
+     * @public
+     */
+    static injectSessionTurn(agentId: string, turn: {
+        userText: string;
+        assistantText: string;
+    }): Promise<void>;
+    /**
+     * theokit#146 — read a LOCAL agent's persisted transcript as STRUCTURE, for rendering.
+     *
+     * A resumed session already replays correctly to the model, but a host had no way to draw it:
+     * the only projection available folded a tool call to the string `[tool call] NAME`, dropping the
+     * call id and every argument. A card UI got prose, so cross-restart resume was worth less than
+     * starting fresh — which is what at least one consumer did.
+     *
+     * Each returned message carries both projections: `text` (unchanged, what the model replay uses)
+     * and `parts` (`text` / `tool_use` / `tool_result` with ids, names, arguments and the
+     * `toolUseId` that correlates a result back to its call).
+     *
+     * Read-only and local-only: it opens the agent's session store and walks the transcript, exactly
+     * as {@link Agent.compact} and {@link Agent.injectSessionTurn} do. It appends nothing.
+     *
+     * @throws UnknownAgentError when `agentId` names no local agent.
+     * @public
+     */
+    static transcript(agentId: string): Promise<readonly SessionMessage[]>;
+    /**
+     * theokit#123 — read-only introspection of a registered agent's tools and subagents.
+     *
+     * `Agent.list()` / `Agent.get()` enumerate agents and `agent.skills.list()` covers skills, but
+     * tools and subagents lived only on `RegisteredAgent.options` — an internal contract. A
+     * reflection endpoint (theokit-studio's `theokit dev`) therefore had to report empty lists for
+     * both, and say so with an `unavailable_reason`.
+     *
+     * A PROJECTION, not the options object. Tool handlers and subagent prompts are stripped: a
+     * handler is an executable that cannot cross a process boundary, and a prompt is the agent's
+     * instructions rather than its signature — a reflection endpoint serializes what it is handed.
+     *
+     * @throws UnknownAgentError when `agentId` names no registered agent.
+     * @public
+     */
+    static describe(agentId: string): Promise<AgentDescription>;
+    /**
+     * Permanently delete a cloud agent.
+     *
+     * @public
+     */
+    static delete(agentId: string, _options?: AgentOperationOptions): Promise<void>;
+}