norns-sdk 0.0.0-stage → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,679 @@
+import { LanguageModel, JSONSchema7, FlexibleSchema } from 'ai';
+export { jsonSchema } from 'ai';
+import { SocketConnectOption } from 'phoenix';
+
+/** Where a run is: on the way, finished, or parked on a human. */
+type RunStatus = "pending" | "running" | "waiting" | "completed" | "failed" | "error";
+/** The question a run is parked on when its status is `"waiting"`. */
+interface WaitingFor {
+    question: string;
+    toolCallId: string;
+    askedAt: string | undefined;
+}
+interface Run {
+    id: number;
+    agentId: number;
+    conversationId: number | null;
+    parentRunId: number | null;
+    gardId: number | null;
+    status: RunStatus;
+    triggerType: string;
+    input: Record<string, unknown>;
+    output: string | null;
+    /** Present when `status` is `"waiting"`: answer it with `client.runs.reply()`. */
+    waitingFor: WaitingFor | null;
+    failureMetadata: Record<string, unknown>;
+    inputTokens: number;
+    outputTokens: number;
+    /** Dollars as a decimal string, so nothing rounds them through a float. */
+    cost: {
+        usd: string;
+        unpriced: boolean;
+    } | null;
+    insertedAt: string;
+    updatedAt: string;
+}
+interface RunEvent {
+    id: number;
+    sequence: number;
+    eventType: string;
+    payload: Record<string, unknown>;
+    source: string;
+    insertedAt: string;
+}
+/** An agent as the server describes it. */
+interface AgentInfo {
+    id: number;
+    name: string;
+    purpose: string | null;
+    status: string;
+    model: string;
+    systemPrompt: string;
+    maxSteps: number;
+    contextStrategy: string;
+    contextWindow: number;
+    archivedAt: string | null;
+    insertedAt: string;
+    updatedAt: string;
+}
+interface Conversation {
+    id: number;
+    agentId: number;
+    key: string;
+    summary: string | null;
+    messageCount: number;
+    tokenEstimate: number;
+    insertedAt: string;
+    updatedAt: string;
+}
+/** What `sendMessage()` returns. */
+interface MessageResult {
+    runId: number;
+    /** `"accepted"` when not waiting; otherwise the run's status when the wait ended. */
+    status: "accepted" | RunStatus;
+    output: string | null;
+    conversationKey: string | undefined;
+    /** The agent is parked on a question and will not move until it is answered. */
+    isWaiting: boolean;
+    waitingFor: WaitingFor | null;
+}
+/** Every stream payload carries the run and agent it belongs to. */
+interface Tagged {
+    run_id: number;
+    agent_id: number;
+}
+/**
+ * An event from a run as it happens, keyed by `type`. The two terminal
+ * events are `completed` and `error`. Unknown types pass through as
+ * `{ type: string, data: object }` so a newer server never breaks a client.
+ */
+type StreamEvent = {
+    type: "agent_started";
+    data: Tagged;
+} | {
+    type: "llm_response";
+    data: Tagged & {
+        step: number;
+        finish_reason: string;
+        content: string;
+        tool_calls: Array<{
+            id: string;
+            name: string;
+            arguments: unknown;
+        }> | null;
+    };
+} | {
+    type: "tool_call";
+    data: Tagged & {
+        name: string;
+        arguments: unknown;
+    };
+} | {
+    type: "tool_result";
+    data: Tagged & {
+        tool_call_id: string;
+        name: string;
+        content: string;
+        [key: string]: unknown;
+    };
+} | {
+    type: "waiting_for_user";
+    data: Tagged & {
+        tool_call_id: string;
+        question: string;
+    };
+} | {
+    type: "waiting_timer";
+    data: Tagged & {
+        seconds: number;
+        reason: string | null;
+    };
+} | {
+    type: "context_compacted";
+    data: Tagged & {
+        step: number;
+        dropped: number;
+        kept: number;
+    };
+} | {
+    type: "completed";
+    data: Tagged & {
+        output: string;
+    };
+} | {
+    type: "error";
+    data: Tagged & {
+        error: string;
+    };
+} | {
+    type: string;
+    data: Tagged & Record<string, unknown>;
+};
+
+/** A class that behaves like the browser `WebSocket`; the global one by default. */
+type WebSocketConstructor = new (url: string, protocols?: string | string[]) => object;
+interface NornsClientOptions {
+    /** The Norns base URL. Defaults to `NORNS_URL`. */
+    url?: string;
+    /** The tenant's bearer token. Defaults to `NORNS_API_KEY`. */
+    apiKey?: string;
+    /** Replace the global `fetch`, for tests or custom transport. */
+    fetch?: typeof globalThis.fetch;
+    /** Replace the global `WebSocket` for streams. */
+    transport?: WebSocketConstructor;
+    /** Extra options for the Phoenix socket that streams use. */
+    socketOptions?: Partial<SocketConnectOption>;
+}
+/** An agent's id, or its name. */
+type AgentRef = number | string;
+interface SendMessageOptions {
+    /** Key for multi-turn conversations, e.g. a Slack user id. */
+    conversationKey?: string;
+    /** Opaque context stored on the run. */
+    context?: Record<string, unknown>;
+    /** Pin the run to a gard. */
+    gardId?: number;
+    /**
+     * Poll until the run completes, fails, or parks on a question. A parked
+     * agent is waiting on you, so the wait ends there too.
+     */
+    wait?: boolean;
+    /** How long to wait, with `wait`. Default 30 seconds. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface StreamOptions {
+    conversationKey?: string;
+    context?: Record<string, unknown>;
+    gardId?: number;
+    /** Give up if no event arrives for this long. Default 2 minutes. */
+    idleTimeoutMs?: number;
+    signal?: AbortSignal;
+}
+interface ListRunsOptions {
+    /** How many the server returns, most recent first. Default 50. */
+    limit?: number;
+    status?: RunStatus;
+    agentId?: number;
+}
+/**
+ * Talks to Norns from application code: sends messages, reads runs, streams
+ * events. For serving an agent, see `NornsWorker`.
+ *
+ *     const client = new NornsClient({ url, apiKey });
+ *     const result = await client.sendMessage("support-bot", "Where's my order?", { wait: true });
+ */
+declare class NornsClient {
+    #private;
+    readonly url: string;
+    constructor(options?: NornsClientOptions);
+    readonly agents: {
+        list: () => Promise<AgentInfo[]>;
+        /** By id, or by name. */
+        get: (agent: AgentRef) => Promise<AgentInfo>;
+        /**
+         * Create the agent, or update it to match the definition if it exists,
+         * so code changes are always picked up. The worker does this on start.
+         */
+        ensure: (definition: AgentDefinition) => Promise<AgentInfo>;
+    };
+    /**
+     * Send a message to an agent. Returns at once with the run id, or, with
+     * `wait`, once the run completes, fails, or parks on a question.
+     */
+    sendMessage(agent: AgentRef, content: string, options?: SendMessageOptions): Promise<MessageResult>;
+    /**
+     * Send a message and iterate the run's events as they happen, until it
+     * completes or errors.
+     *
+     *     for await (const event of client.stream("researcher", "Summarise this")) {
+     *       if (event.type === "completed") console.log(event.data.output);
+     *     }
+     */
+    stream(agent: AgentRef, content: string, options?: StreamOptions): AsyncGenerator<StreamEvent, void, undefined>;
+    readonly runs: {
+        get: (runId: number) => Promise<Run>;
+        /**
+         * The tenant's runs, most recent first. Use it to find runs nobody holds
+         * a handle to, above all the ones parked on an `ask_human` question:
+         *
+         *     for (const run of await client.runs.list({ status: "waiting" })) {
+         *       console.log(run.id, run.waitingFor?.question);
+         *     }
+         *
+         * `status` and `agentId` filter the page the server returned, so a
+         * narrow filter over a busy tenant may need a larger `limit`.
+         */
+        list: (options?: ListRunsOptions) => Promise<Run[]>;
+        events: (runId: number) => Promise<RunEvent[]>;
+        /**
+         * Answer a run parked on an `ask_human` question. Sending the agent a
+         * normal message does the same and is usually what a chat client wants;
+         * this targets one specific run.
+         */
+        reply: (runId: number, answer: string) => Promise<void>;
+        /** Re-run a finished or failed run's message. Returns the new run id. */
+        retry: (runId: number) => Promise<number>;
+        /** Iterate an existing run's events as they happen, until it finishes. */
+        watch: (runId: number, options?: Pick<StreamOptions, "idleTimeoutMs" | "signal">) => AsyncGenerator<StreamEvent, void, undefined>;
+    };
+    readonly conversations: {
+        list: (agent: AgentRef) => Promise<Conversation[]>;
+        get: (agent: AgentRef, key: string) => Promise<Conversation>;
+        /** Reset a conversation: its history is gone, the next message starts fresh. */
+        delete: (agent: AgentRef, key: string) => Promise<void>;
+    };
+}
+
+/**
+ * Where the SDK writes what it is doing. Anything with these four methods
+ * works: `console`, pino, winston, or your own.
+ */
+interface Logger {
+    debug(message: string, ...rest: unknown[]): void;
+    info(message: string, ...rest: unknown[]): void;
+    warn(message: string, ...rest: unknown[]): void;
+    error(message: string, ...rest: unknown[]): void;
+}
+/** Logs info and above to the console, prefixed so it is easy to grep. */
+declare const consoleLogger: Logger;
+declare const silentLogger: Logger;
+
+/** Turns the model name on an LLM task into something the AI SDK can call. */
+type ModelResolver = (modelId: string) => LanguageModel | Promise<LanguageModel>;
+/** A provider, or a registry from `createProviderRegistry()`. */
+interface ModelSource {
+    languageModel(modelId: string): LanguageModel;
+}
+type ModelsOption = ModelResolver | ModelSource;
+/**
+ * Split `"provider/model"` (or `"provider:model"`) into its parts, inferring
+ * the provider from the model's name when there is no prefix.
+ */
+declare function inferProvider(model: string): {
+    provider: string;
+    modelId: string;
+};
+
+type Capability = "llm" | "tools";
+interface NornsWorkerOptions {
+    /** The agent, or agents, this worker serves. */
+    agents: AgentDefinition | AgentDefinition[];
+    /** The Norns base URL. Defaults to `NORNS_URL`. */
+    url?: string;
+    /** The tenant's bearer token. Defaults to `NORNS_API_KEY`. */
+    apiKey?: string;
+    /**
+     * How a model name on an LLM task becomes a model to call: a function, a
+     * provider (`anthropic`), or a registry from `createProviderRegistry()`.
+     * By default the provider is inferred from the name and its `@ai-sdk/*`
+     * package loaded; API keys come from the provider's own env var.
+     */
+    models?: ModelsOption;
+    /** What this worker serves. Default both; `["tools"]` for a worker with no LLM access. */
+    capabilities?: Capability[];
+    /** A stable identity. Defaults to `NORNS_WORKER_ID`, else a random one. */
+    workerId?: string;
+    /** Claim a gard (defaults to `NORNS_GARD`); needs `claimToken`. */
+    gard?: string | number;
+    /** Defaults to `NORNS_GARD_CLAIM_TOKEN`. */
+    claimToken?: string;
+    /** How long `stop()` waits for in-flight tasks. Default 30 s, or `NORNS_SHUTDOWN_TIMEOUT` (seconds). */
+    shutdownTimeoutMs?: number;
+    /** Drain on SIGINT/SIGTERM. Default true. */
+    handleSignals?: boolean;
+    /** Where to log. `null` for silence. Default: the console. */
+    logger?: Logger | null;
+    /**
+     * Where completed side-effecting calls are remembered across restarts.
+     * Defaults to `NORNS_STATE_DIR`, else the system temp dir; `null` disables.
+     */
+    stateDir?: string | null;
+    /** Replace the global `fetch` (used to register the agents). */
+    fetch?: typeof globalThis.fetch;
+    /** Replace the global `WebSocket`. */
+    transport?: WebSocketConstructor;
+    /** Extra options for the Phoenix socket. */
+    socketOptions?: Partial<SocketConnectOption>;
+}
+interface RegisterPortOptions {
+    name?: string;
+    url?: string;
+    protocol?: string;
+}
+interface RegisteredPort {
+    id: number;
+    internalPort: number;
+    url: string | null;
+}
+type WorkerState = "idle" | "starting" | "running" | "draining" | "stopped";
+/**
+ * Serves agents: connects to Norns, registers their tools, and handles the
+ * LLM and tool tasks it is sent.
+ *
+ *     const worker = new NornsWorker({ agents: [supportBot] });
+ *     await worker.start();   // resolves once joined; Ctrl-C drains and exits
+ *
+ * `start()` resolves when the worker has joined, so the rest of your program
+ * can carry on; the open socket keeps the process alive. `stop()` drains:
+ * Norns stops sending work, in-flight tasks finish and report, and the
+ * worker leaves. `stopped` settles when that is done.
+ */
+declare class NornsWorker {
+    #private;
+    readonly url: string;
+    readonly workerId: string;
+    readonly gard: string | number | undefined;
+    constructor(options: NornsWorkerOptions);
+    /** The agents this worker serves. */
+    get agents(): readonly AgentDefinition[];
+    get state(): WorkerState;
+    /**
+     * Settles once the worker has stopped: resolves after a drain, rejects
+     * with `JoinError` or `GardDestroyedError` when it was forced off.
+     */
+    get stopped(): Promise<void>;
+    /**
+     * Register the agents, connect, and join. Resolves once Norns has accepted
+     * the worker; rejects with `JoinError` when it never will (bad claim
+     * token, destroyed gard). A server that is down is retried until it is up.
+     */
+    start(): Promise<void>;
+    /**
+     * Drain and stop: tell Norns to send no more work, finish the tasks in
+     * flight (up to the shutdown timeout), report them, leave. Tasks still
+     * running at the deadline are dropped and Norns re-dispatches them.
+     */
+    stop(): Promise<void>;
+    /**
+     * Expose a service port for the dashboard. Only in a gard: the gard is
+     * inferred from the connection. Call it from a tool after starting a
+     * service.
+     */
+    registerPort(internalPort: number, options?: RegisterPortOptions): Promise<RegisteredPort>;
+}
+
+/**
+ * What a tool's `execute` is told about the call, besides its input.
+ *
+ * `signal` aborts when the worker gives up on the call: the socket dropped
+ * (Norns re-dispatches the task) or a drain hit its deadline. A long tool
+ * should pass it to whatever it waits on.
+ */
+interface ToolContext {
+    taskId: string;
+    runId: number | undefined;
+    agentId: number | undefined;
+    /**
+     * Set when Norns considers the call side-effecting. Same run, same step,
+     * same tool call, same key, however many times it is dispatched; hand it
+     * to a provider that dedupes (most payment APIs take one) and the effect
+     * survives this worker dying mid-call too.
+     */
+    idempotencyKey: string | undefined;
+    signal: AbortSignal;
+    worker: NornsWorker;
+}
+/** A Zod schema, any Standard Schema, an `ai` `Schema`, or raw JSON Schema. */
+type ToolInputSchema = FlexibleSchema | JSONSchema7;
+/** The argument type `execute` receives for a given `input` schema. */
+type InferToolInput<S> = S extends FlexibleSchema<infer T> ? T : Record<string, unknown>;
+interface ToolOptions<S extends ToolInputSchema = ToolInputSchema> {
+    /** What the model calls it by. */
+    name: string;
+    /** What the model reads to decide when to call it. */
+    description: string;
+    /**
+     * The input shape. A Zod object schema gives a typed, validated `execute`;
+     * leave it out for a tool that takes nothing.
+     */
+    input?: S;
+    /**
+     * Mark a tool whose call must not happen twice. Norns then names each call
+     * with an idempotency key, and a re-dispatched call is answered from the
+     * result this worker kept rather than run again.
+     */
+    sideEffect?: boolean;
+    /**
+     * The handler. Return a string, or anything JSON-serialisable (it is
+     * stringified for the model). Throwing reports an error result; the model
+     * sees the message.
+     */
+    execute: (input: InferToolInput<S>, context: ToolContext) => unknown | Promise<unknown>;
+}
+type ValidationResult<T> = {
+    success: true;
+    value: T;
+} | {
+    success: false;
+    error: Error;
+};
+/** A tool ready to register with a worker: what `tool()` returns. */
+interface ToolDefinition<I = unknown> {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JSONSchema7;
+    readonly sideEffect: boolean;
+    /** Validates and coerces an input against the schema, when there is one. */
+    readonly validate: ((value: unknown) => Promise<ValidationResult<I>>) | undefined;
+    execute(input: I, context: ToolContext): Promise<unknown>;
+}
+/**
+ * Define a tool.
+ *
+ *     const searchDocs = tool({
+ *       name: "search_docs",
+ *       description: "Search product documentation.",
+ *       input: z.object({ query: z.string() }),
+ *       execute: async ({ query }) => db.search(query),
+ *     });
+ */
+declare function tool<S extends ToolInputSchema>(options: ToolOptions<S>): ToolDefinition<InferToolInput<S>>;
+
+type AgentMode = "task" | "conversation";
+type CheckpointPolicy = "every_step" | "on_tool_call" | "manual";
+type ContextStrategy = "sliding_window" | "none";
+type OnFailure = "stop" | "retry_last_step";
+type SubagentConversation = "per_launch" | "per_parent";
+/** Fold older history into a summary once a response reports `compactAt` input tokens. */
+interface ContextPolicy {
+    compactAt: number;
+    /** Messages kept verbatim after the fold. */
+    keep: number;
+}
+/** What this agent may do with `launch_agent` and `list_agents`. */
+interface SubagentPolicy {
+    mode?: "open" | "allowlist" | "disabled";
+    allowedAgents?: string[];
+    allowListAgents?: boolean;
+    maxDepth?: number;
+}
+interface AgentOptions {
+    name: string;
+    /** Shown to other agents by `list_agents`. */
+    purpose?: string;
+    /**
+     * The model name as the provider knows it, e.g. `"claude-sonnet-5"`,
+     * `"gpt-4o"`. Prefix it (`"openai/gpt-4o"`) to pin the provider.
+     */
+    model?: string;
+    systemPrompt?: string;
+    /** What this worker serves for the agent (see `allowedTools` for what it is offered). */
+    tools?: ToolDefinition[];
+    mode?: AgentMode;
+    checkpointPolicy?: CheckpointPolicy;
+    contextStrategy?: ContextStrategy;
+    contextWindow?: number;
+    maxSteps?: number;
+    onFailure?: OnFailure;
+    /** Pair with `contextStrategy: "none"`; the summarisation is served by this worker. */
+    contextPolicy?: ContextPolicy;
+    /**
+     * The ceiling on one response, not on the history. Unset leaves it to the
+     * worker (8192). Raise it for an agent whose turns are long.
+     */
+    maxTokens?: number;
+    /**
+     * Names from `tools` this agent is offered. Unset offers every tool
+     * registered in the tenant, other agents' included. Built-ins (`ask_human`,
+     * `wait`, `launch_agent`, `list_agents`) are never filtered.
+     */
+    allowedTools?: string[];
+    subagents?: SubagentPolicy;
+    /** When launched by another agent: a fresh conversation per launch, or one per parent. */
+    subagentConversation?: SubagentConversation;
+}
+/** A complete agent definition: `defineAgent()`'s result. */
+interface AgentDefinition {
+    readonly name: string;
+    readonly purpose: string | undefined;
+    readonly model: string;
+    readonly systemPrompt: string;
+    readonly tools: readonly ToolDefinition[];
+    readonly mode: AgentMode;
+    readonly checkpointPolicy: CheckpointPolicy;
+    readonly contextStrategy: ContextStrategy;
+    readonly contextWindow: number;
+    readonly maxSteps: number;
+    readonly onFailure: OnFailure;
+    readonly contextPolicy: ContextPolicy | undefined;
+    readonly maxTokens: number | undefined;
+    readonly allowedTools: readonly string[] | undefined;
+    readonly subagents: SubagentPolicy | undefined;
+    readonly subagentConversation: SubagentConversation | undefined;
+}
+declare const DEFAULT_MODEL = "claude-sonnet-5";
+/**
+ * Define an agent. Defaults are filled in and the combination is checked
+ * here, so a mistake fails where it was written rather than on the server.
+ */
+declare function defineAgent(options: AgentOptions): AgentDefinition;
+
+/** Base class for every error this SDK raises. */
+declare class NornsError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/** The Norns API answered with a non-2xx status. */
+declare class NornsApiError extends NornsError {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message?: string);
+}
+/** The thing asked for does not exist (404). */
+declare class NotFoundError extends NornsApiError {
+    constructor(what: string, body?: unknown);
+}
+/** A wait or a stream ran out of time. */
+declare class NornsTimeoutError extends NornsError {
+    constructor(message: string);
+}
+/**
+ * The worker's channel join was rejected for a reason a retry cannot fix:
+ * a bad claim token, a destroyed or missing gard, an invalid registration.
+ */
+declare class JoinError extends NornsError {
+    readonly reason: string;
+    readonly code: string | undefined;
+    constructor(reason: string, code?: string);
+}
+/** The gard this worker claimed was destroyed while it was connected. */
+declare class GardDestroyedError extends NornsError {
+    constructor(gard: string | number | undefined);
+}
+/** A stream's socket closed before the run reached a terminal event. */
+declare class StreamClosedError extends NornsError {
+    readonly reason: unknown;
+    constructor(reason: unknown);
+}
+
+/**
+ * The provider-neutral wire format Norns speaks, and its translation to and
+ * from the AI SDK. Also the prose the worker writes for the model: Norns
+ * never does ("Content is opaque"), so composing the system prompt,
+ * rendering kinded messages, eliding old tool results, and choosing the
+ * run's final output all happen here.
+ */
+
+interface NeutralToolCall {
+    id: string;
+    name: string;
+    arguments: unknown;
+}
+interface NeutralMessage {
+    role: "user" | "assistant" | "tool" | "system";
+    content?: unknown;
+    tool_calls?: NeutralToolCall[];
+    tool_call_id?: string;
+    name?: string;
+    is_error?: boolean;
+    /** Set on messages Norns resolved itself; the worker renders them. */
+    kind?: string;
+    data?: Record<string, unknown>;
+}
+interface NeutralTool {
+    name: string;
+    description?: string;
+    parameters?: JSONSchema7;
+    input_schema?: JSONSchema7;
+}
+interface LlmTask {
+    task_id: string;
+    purpose?: "compact";
+    model?: string;
+    system_prompt?: string | null;
+    summary?: string | null;
+    date?: string | null;
+    messages?: NeutralMessage[];
+    /** In place of `messages` once this worker holds the run's history (see HistoryCache). */
+    messages_delta?: {
+        base_count: number;
+        drop: number;
+        append: NeutralMessage[];
+    };
+    tools?: NeutralTool[];
+    context_policy?: unknown;
+    max_tokens?: number | null;
+    agent_id?: number;
+    run_id?: number;
+    step?: number;
+}
+interface ToolTask {
+    task_id: string;
+    tool_name: string;
+    input?: Record<string, unknown>;
+    agent_id?: number;
+    run_id?: number;
+    idempotency_key?: string;
+}
+interface Usage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens?: number;
+    cache_write_tokens?: number;
+}
+type NeutralFinishReason = "stop" | "tool_call" | "length" | "error";
+type LlmResult = {
+    status: "ok";
+    content: string;
+    finish_reason: NeutralFinishReason;
+    usage: Usage;
+    tool_calls?: NeutralToolCall[];
+    model?: string;
+    final_output?: string;
+} | {
+    status: "error";
+    error: string;
+};
+type ToolResult = {
+    status: "ok";
+    result: string;
+    duplicate?: true;
+} | {
+    status: "error";
+    error: string;
+};
+
+export { DEFAULT_MODEL, GardDestroyedError, JoinError, NornsApiError, NornsClient, NornsError, NornsTimeoutError, NornsWorker, NotFoundError, StreamClosedError, consoleLogger, defineAgent, inferProvider, silentLogger, tool };
+export type { AgentDefinition, AgentInfo, AgentMode, AgentOptions, AgentRef, Capability, CheckpointPolicy, ContextPolicy, ContextStrategy, Conversation, InferToolInput, ListRunsOptions, LlmResult, LlmTask, Logger, MessageResult, ModelResolver, ModelSource, ModelsOption, NeutralMessage, NeutralToolCall, NornsClientOptions, NornsWorkerOptions, OnFailure, RegisterPortOptions, RegisteredPort, Run, RunEvent, RunStatus, SendMessageOptions, StreamEvent, StreamOptions, SubagentConversation, SubagentPolicy, ToolContext, ToolDefinition, ToolInputSchema, ToolOptions, ToolResult, ToolTask, WaitingFor, WebSocketConstructor };