broods 0.54.1 → 0.55.0

package/dist/index.d.ts

@@ -2,112 +2,52 @@ import { SystemModelMessage, LanguageModelCallOptions, RequestOptions, streamTex
 import * as convex_values from 'convex/values';
 import { Infer } from 'convex/values';
 
-/**
- * Account-owned code hook upload validation for Convex config-plane sync.
- * Mirrors core's account hook upload contract without requiring the Node runtime.
- */
 declare const AGENT_HOOK_EVENT_NAMES: readonly ["agent.started", "agent.step.finished", "agent.finished", "agent.failed", "agent.approval.required", "tool.call.started", "tool.call.finished", "tool.result", "subagent.task.started", "subagent.task.finished", "channel.message.received", "channel.message.sending"];
 type AgentHookEventName = (typeof AGENT_HOOK_EVENT_NAMES)[number];
 
-/**
- * Every Vercel AI SDK provider that ships language models, the community
- * providers on the same spec that take an API key (`cloudflare`, `llmgateway`,
- * `ollama`, `openrouter`), `custom` (any OpenAI-compatible endpoint), and
- * `chatgpt` (OpenAI on a Sign in with ChatGPT login instead of an API key).
- * Image-, speech- and transcription-only providers are deliberately absent:
- * they cannot back `config.model`.
- */
 declare const ACCOUNT_MODEL_PROVIDER_NAMES: readonly ["alibaba", "anthropic", "azure", "baseten", "bedrock", "cerebras", "chatgpt", "cloudflare", "cohere", "custom", "deepinfra", "deepseek", "fireworks", "google", "groq", "huggingface", "llmgateway", "minimax", "mistral", "moonshotai", "ollama", "openai", "openrouter", "perplexity", "togetherai", "v0", "vercel", "vertex", "xai", "zai"];
 type AccountModelProviderName = (typeof ACCOUNT_MODEL_PROVIDER_NAMES)[number];
 
-/**
- * Agent config validation, the only copy of it: Convex config HTTP checks a
- * config on write and core re-checks the stored config on every run. Pure
- * module: safe for the default Convex runtime. The public projection lives in
- * ./responses.ts.
- */
-
 declare const AGENT_HARNESS_TYPES: readonly ["claude-code", "codex", "deepagents", "opencode", "pi"];
 declare const AGENT_HARNESS_DEBUG_LEVELS: readonly ["error", "warn", "info", "debug", "trace"];
 declare const AGENT_HARNESS_PERMISSION_MODES: readonly ["allow-reads", "allow-edits", "allow-all"];
 declare const AGENT_LIFECYCLE_EVENT_NAMES: readonly ["agent.started", "agent.step.finished", "agent.finished", "agent.failed", "agent.approval.required", "tool.call.started", "tool.call.finished", "tool.result", "subagent.task.started", "subagent.task.finished"];
 
-/**
- * Shared validation for MCP server registrations (#331). One normalizer
- * serves every write path (CLI sync, direct API, dashboard). A `url` makes an "http" row
- * core connects to over the stateless 2026-07-28 transport; a `bundle` makes
- * a "hosted" row, hashed here so sha256 always travels with the bundle; the
- * S3 bundle writer (aws/bundles.ts) marks whether Cloudflare Dynamic Workers
- * can run it. Auth header values may carry ${NAME}
- * account env refs; they resolve into the encrypted agent config at sync
- * time, never on this row, and credential-bearing headers must use one
- * instead of an inline secret. `oauth` follows the same rule: clientSecret
- * and refreshToken must be ${NAME} refs, so the row never holds a secret.
- */
-
-/**
- * OAuth 2.0 refresh-token grant for an external row. Core mints access tokens
- * at connect time and sends `Authorization: Bearer <token>`, so a server
- * whose tokens expire (Google's Workspace MCP endpoints) still works where a
- * static header cannot. Secret fields hold ${NAME} refs on the row.
- */
 interface McpOauth {
     clientId: string;
     clientSecret: string;
     refreshToken: string;
-    /** Token endpoint, https only; core defaults to https://oauth2.googleapis.com/token. */
     tokenUrl?: string;
 }
 
-/**
- * Agent configuration: types for the per-agent settings object and the
- * runtime projection of a stored config. The validation rules are the config
- * plane's (`@broods/convex/model/agentRules`), so a config is judged the same
- * on write and on every run. Decrypting the stored blob is
- * `../convex/account-keys.ts`.
- * Account types and auth live in `./accounts.ts` and `../auth.ts`.
- */
-
 interface AgentConfig {
     agent?: AgentBehaviorConfig;
     harness?: AgentHarnessConfig;
     model?: AgentModelConfig;
     provider?: AgentProviderConfig;
+    /** Sandbox record ids. The first is the default for bash, workspaces and a harness. */
     sandboxes?: string[];
     workspaces?: AgentWorkspaceRef[];
     session?: AgentSessionConfig;
     hooks?: AgentHooksConfig;
     channels?: AgentChannelsConfig;
     tools?: AgentToolsConfig;
-    /** Connected MCP servers, keyed by their config-plane row id (#331). */
     mcp?: AgentMcpConfig;
-    /**
-     * Tool names withheld for this run, applied after the tool set is built.
-     * Set by a channel record; a channel can take a tool away, never add one.
-     * Names that are not present are ignored.
-     */
+    /** Withheld after the tool set is built; a channel can take a tool away, never add one. */
     denyTools?: string[];
     skills?: AgentSkillsConfig;
     subagent?: AgentSubagentConfig;
     scheduler?: AgentSchedulerConfig;
-    /**
-     * Registers the `browse` tool, which runs Obscura on the first sandbox. That
-     * sandbox must be lambda with image "obscura" and network allow-all, or a
-     * machine; manifest sync refuses anything else it can see.
-     */
+    /** `browse` runs on the first sandbox: a machine, or lambda "obscura" with allow-all. */
     browser?: {
         enabled?: boolean;
     };
-    /** Policies that gate this agent. Each one carries its own enforcement mode. */
     policies?: string[];
+    /** Opens the runtime-key path; account keys, cron and channel webhooks never need it. */
     publicAccess?: boolean;
     allowRunOverrides?: boolean;
     [key: string]: unknown;
 }
-/**
- * What a code hook reads as ctx.config: the model and the names of what the
- * agent can use. An allow-list, so no credential field can reach hook code.
- */
 interface HookAgentConfig {
     readonly model: {
         readonly provider?: AccountModelProviderName;
@@ -123,6 +63,7 @@ interface HookAgentConfig {
     readonly denyTools: readonly string[];
 }
 interface AgentBehaviorConfig {
+    /** Steps per turn. 0 lifts the cap; unset is the harness default. */
     maxTurn?: number;
     system?: string | SystemModelMessage | SystemModelMessage[];
     [key: string]: unknown;
@@ -148,10 +89,6 @@ interface AgentSkillsConfig {
     allowed?: string[];
     [key: string]: unknown;
 }
-/**
- * Opt-in for the `schedule` tool. Off by default: a scheduled task starts
- * billable agent runs long after the turn that asked for it.
- */
 interface AgentSchedulerConfig {
     enabled?: boolean;
     [key: string]: unknown;
@@ -161,33 +98,16 @@ interface AgentSubagentConfig {
     allowed?: string[];
     context?: "new" | "inherited";
     mode?: "ephemeral" | "persistent";
-    /**
-     * Publishes child reasoning, text, and tool stream parts to the existing
-     * WebSocket/JetStream response path. Off by default.
-     */
     stream?: boolean;
-    /**
-     * Controls what the parent agent sees from a finished subagent (AI SDK
-     * "controlling what the model sees"): `full` = the child's whole transcript,
-     * `result` = only its final result (default), `none` = nothing. A
-     * `subagent.task.finished` code hook overrides this for custom shaping.
-     */
+    /** What the parent sees of a finished child; default `result`. A code hook can override it. */
     visibility?: "full" | "result" | "none";
-    /**
-     * Model for virtual subagents (no `agentId`), laid over the parent's
-     * `model` key by key. The child keeps the parent's tools, MCP, sandboxes,
-     * hooks and policies. A registered agent always runs on its own model.
-     */
+    /** Virtual subagents only, merged over the parent's `model`; registered agents use their own. */
     model?: Partial<AgentModelConfig>;
     [key: string]: unknown;
 }
 interface AgentModelConfig extends LanguageModelCallOptions, Partial<Pick<RequestOptions, "maxRetries" | "timeout">> {
     provider?: AccountModelProviderName;
     modelId?: string;
-    /**
-     * Speech-to-text model for inbound audio, on the same provider and key as
-     * `modelId`. Defaults to the widest-container model the provider ships.
-     */
     transcriptionModelId?: string;
     providerOptions?: AgentModelProviderOptions;
     output?: AgentModelOutputConfig;
@@ -214,14 +134,10 @@ type AgentModelOutputMetadata = {
 type AgentProviderConfig = Partial<Record<AccountModelProviderName, AgentProviderSettings>>;
 interface AgentProviderSettings {
     apiKey?: string;
-    /** OpenAI-compatible endpoint (`custom`). Snake form, as documented. */
     base_url?: string;
-    /** OpenAI-compatible endpoint (`custom`). AI-SDK form; the dashboard writes both. */
     baseURL?: string;
-    /** Cloudflare AI Gateway id (`cloudflare`). Set, requests go through the gateway. */
     gatewayId?: string;
     headers?: Record<string, string>;
-    /** Endpoint label; becomes the provider id and the pi harness env prefix. */
     name?: string;
     organization?: string;
     project?: string;
@@ -230,6 +146,7 @@ interface AgentProviderSettings {
 interface AgentWorkspaceRef {
     name: string;
     workspaceId: string;
+    /** Unset inherits the default; `null` is read-only, read from S3 without a mount. */
     sandbox?: string | null;
 }
 interface AgentSessionConfig {
@@ -241,35 +158,19 @@ interface AgentSessionPruningConfig {
     enabled?: boolean;
     [key: string]: unknown;
 }
-/**
- * Compaction after a finished turn, on unless `enabled: false`. It runs once
- * the turn's last model call read `maxContextLength` input tokens or more
- * (default 500000), or after the provider refused a turn for context length.
- * `/compact` works whatever this says.
- */
+/** On by default: runs once a turn's last call read `maxContextLength` (500000) tokens. */
 interface AgentSessionAutoCompactionConfig {
     enabled?: boolean;
     maxContextLength?: number;
     [key: string]: unknown;
 }
 interface AgentHooksConfig {
-    /** Outbound event webhooks. An agent may register several independent endpoints. */
     webhooks?: AgentWebhookHookConfig[];
-    /**
-     * Uploaded code hooks. Each entry references an accountHooks bundle by id; the
-     * bundle runs in the V8 isolate at the matching fire-points and its validated
-     * return is folded into mutable harness state.
-     */
     code?: AgentCodeHookConfig[];
     [key: string]: unknown;
 }
 interface AgentCodeHookConfig {
     hookId: string;
-    /**
-     * Optional narrowing of the events this reference reacts to. Omitted => the
-     * bundle's own declared `events` set. Any listed event outside the bundle's
-     * declared set is ignored at runtime.
-     */
     events?: AgentHookEventName[];
     enabled?: boolean;
     [key: string]: unknown;
@@ -287,22 +188,14 @@ type AgentToolsConfig = Record<string, AgentToolConfig>;
 interface AgentToolConfig {
     enabled?: boolean;
     needsApproval?: boolean;
-    async?: boolean;
     config?: Record<string, unknown>;
     [key: string]: unknown;
 }
 type AgentMcpConfig = Record<string, AgentMcpEntry>;
 interface AgentMcpEntry {
     enabled?: boolean;
-    /** Applies to every tool the server exposes. */
     needsApproval?: boolean;
-    /** Extra request headers; values resolved from account env vars at sync. */
     headers?: Record<string, string>;
-    /**
-     * Overrides for the row's oauth credentials; values resolved from account
-     * env vars at sync, so the row's ${NAME} refs never reach the token
-     * endpoint. tokenUrl stays on the row, where registration checked it.
-     */
     oauth?: Partial<Omit<McpOauth, "tokenUrl">>;
     [key: string]: unknown;
 }
@@ -317,17 +210,11 @@ interface AgentChannelsConfig {
     teams?: AgentTeamsChannelConfig;
     twilio?: AgentTwilioChannelConfig;
     zalo?: AgentZaloChannelConfig;
-    matrix?: AgentMatrixChannelConfig;
     instagram?: AgentInstagramChannelConfig;
     messenger?: AgentMessengerChannelConfig;
     whatsapp?: AgentWhatsAppChannelConfig;
     [key: string]: unknown;
 }
-/**
- * How an attached partitioned workspace splits its folders for runs arriving
- * through this door. `shared` mounts the workspace root; `conversation` mounts
- * a private child folder per thread, issue or chat under `alias`.
- */
 type ChannelPartition = {
     by: "shared";
     alias?: never;
@@ -342,7 +229,6 @@ interface AgentTelegramChannelConfig {
     webhookSecret?: string;
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
-    /** Bot's @username, e.g. `support_bot`. Set it to answer only when the agent is mentioned. */
     botUsername?: string;
     reactionEmoji?: string;
     trace?: "enabled" | "disabled";
@@ -357,31 +243,20 @@ interface AgentGitHubChannelConfig {
     privateKey?: string;
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
-    /** Bot username for @-mention detection (e.g. "my-bot" or "my-bot[bot]"). */
     botUserName?: string;
-    /** Bot's numeric GitHub user ID for self-message detection. */
     botUserId?: number;
-    /** When false, the bot does not auto-trigger on new issues (opened/edited/reopened). Defaults to true. The bot still triggers when assigned to an issue. */
     triggerOnIssueOpen?: boolean;
-    /** When false, the bot does not auto-trigger on new PRs (opened/edited/reopened). Defaults to true. The bot still triggers when assigned to a PR. */
     triggerOnPROpen?: boolean;
     trace?: "enabled" | "disabled";
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/**
- * A Linear member the agent comments as, through that member's personal API
- * key. The agent answers comments that mention `@userName` on issues, and
- * `webhookSecret` checks every delivery.
- */
 interface AgentLinearChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
     id?: string;
     apiKey?: string;
-    /** Linear GraphQL endpoint. Defaults to `https://api.linear.app/graphql`. */
     apiUrl?: string;
-    /** The member's display name, e.g. `acme-agent`. `@acme-agent` addresses the agent. */
     userName?: string;
     webhookSecret?: string;
     trace?: "enabled" | "disabled";
@@ -407,41 +282,12 @@ interface AgentDiscordChannelConfig {
     publicKey?: string;
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
-    /** Bot's Discord user id. Set it to answer only when the agent is mentioned. */
     botUserId?: string;
-    /** Role ids that count as mentioning the agent, e.g. an on-call role. */
     mentionRoleIds?: string[];
     trace?: "enabled" | "disabled";
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/**
- * A Matrix account the agent speaks as. Matrix has no bot concept, so this is
- * usually a person's own account: replies carry a per-message profile named
- * `botName`, and `mentionText` decides what addresses the agent, because a
- * mention of the account would also be a mention of its owner.
- */
-interface AgentMatrixChannelConfig {
-    id?: string;
-    /** Homeserver base URL, e.g. `https://matrix.org`. */
-    apiUrl?: string;
-    /** Access token of the account; `apps/matrix-forwarder` syncs with it. */
-    botToken?: string;
-    /** Room ids. */
-    allowedChannelIds?: string[];
-    /** Matrix user ids, e.g. `@alice:matrix.org`. */
-    allowedUserIds?: string[];
-    /** Name replies are shown under. Unset, replies look like the account's own messages. */
-    botName?: string;
-    /**
-     * Text that addresses the agent, e.g. `@georgi-ai`. Unset, a mention of the
-     * account does. Other messages are stored as context either way.
-     */
-    mentionText?: string;
-    trace?: "enabled" | "disabled";
-    partition?: ChannelPartition;
-    [key: string]: unknown;
-}
 interface AgentPancakeChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
@@ -464,73 +310,46 @@ interface AgentZaloChannelConfig {
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/**
- * An Instagram professional account, reached through a Meta app with
- * Instagram Login. `accountId` is the account the webhook entries name.
- */
 interface AgentInstagramChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
     id?: string;
-    /** Instagram user access token with `instagram_business_manage_messages`. */
     accessToken?: string;
-    /** Instagram professional account id. */
     accountId?: string;
-    /** Graph API version, e.g. `v26.0`. Defaults to the SDK's. */
     apiVersion?: string;
-    /** Meta app secret; signs every webhook POST. */
     appSecret?: string;
     userName?: string;
-    /** The verify token typed into the Meta webhook settings. */
     verifyToken?: string;
     trace?: "enabled" | "disabled";
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/** A Facebook Page the agent answers Messenger DMs for. */
 interface AgentMessengerChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
     id?: string;
-    /** Graph API version, e.g. `v21.0`. Defaults to the SDK's. */
     apiVersion?: string;
-    /** Meta app secret; signs every webhook POST. */
     appSecret?: string;
-    /** Page access token for the Page the app is subscribed to. */
     pageAccessToken?: string;
     userName?: string;
-    /** The verify token typed into the Meta webhook settings. */
     verifyToken?: string;
     trace?: "enabled" | "disabled";
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/**
- * A Google Chat app on the HTTP endpoint connection. It posts as the service
- * account in `credentials`, and a webhook is accepted when its Google-signed
- * token names `endpointUrl` or `googleChatProjectNumber` as the audience.
- */
 interface AgentGoogleChatChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
     id?: string;
-    /** The service-account key JSON, as downloaded from Google Cloud. */
     credentials?: string;
-    /** Audience when the app authenticates with "HTTP endpoint URL". */
     endpointUrl?: string;
-    /** Audience when the app authenticates with "Project number". */
     googleChatProjectNumber?: string;
-    /** `service-{projectNumber}@gcp-sa-gsuiteaddons.iam.gserviceaccount.com`, for an app built as a Workspace add-on. */
     workspaceAddOnServiceAccountEmail?: string;
     userName?: string;
     trace?: "enabled" | "disabled";
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/**
- * A Microsoft Teams bot registered in Azure Bot Service, authenticated with a
- * client secret. `appTenantId` is required unless `appType` is `MultiTenant`.
- */
 interface AgentTeamsChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
@@ -545,11 +364,6 @@ interface AgentTeamsChannelConfig {
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/**
- * A Twilio number or Messaging Service for SMS and MMS. `authToken` checks
- * Twilio's signature, which covers the exact public URL Twilio called, so
- * `webhookUrl` is only set when that URL is not the broods webhook URL.
- */
 interface AgentTwilioChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
@@ -557,22 +371,16 @@ interface AgentTwilioChannelConfig {
     accountSid?: string;
     apiUrl?: string;
     authToken?: string;
-    /** `MG...`. Replies go through the service instead of the number texted. */
     messagingServiceSid?: string;
-    /** E.164 number, e.g. `+15551234567`. Messages to another number go to the agent holding it. */
     phoneNumber?: string;
     statusCallbackUrl?: string;
     userName?: string;
-    /** The URL entered in the Twilio console, when it is not `{PUBLIC_BASE_URL}/v1/webhooks/...`. */
+    /** The URL Twilio calls, when not the broods webhook: its signature covers the exact URL. */
     webhookUrl?: string;
     trace?: "enabled" | "disabled";
     partition?: ChannelPartition;
     [key: string]: unknown;
 }
-/**
- * A WhatsApp Business Cloud API number. `appSecret` signs every delivery and
- * `verifyToken` answers Meta's subscription handshake.
- */
 interface AgentWhatsAppChannelConfig {
     allowedChannelIds?: string[];
     allowedUserIds?: string[];
@@ -589,18 +397,8 @@ interface AgentWhatsAppChannelConfig {
     [key: string]: unknown;
 }
 
-/**
- * Cron-job records and patch-merge helpers for the runtime. Input
- * normalization lives in the config plane (packages/convex/model/cronRules.ts,
- * the single home of those rules).
- */
-
 type CronStatus = "active" | "paused";
 type CronLastStatus = "started" | "completed" | "failed";
-/**
- * One-of run payload mirroring the agent direct API's AgentRunInput: provide a
- * single `input` string (wrapped into one user message) or a full `events` list.
- */
 type CronRunInput = {
     input: string;
     events?: never;
@@ -633,20 +431,9 @@ type UpdateCronInput = {
     input?: never;
 });
 
-/**
- * The sandbox provider list: the one list the schema validator, the config
- * rules, core's executor registry and the SDK derive from. A leaf on purpose,
- * so `schema.ts` can read it without pulling the rules' import graph.
- */
 declare const SANDBOX_PROVIDERS: readonly ["sandbox", "lambda", "e2b", "daytona", "vercel", "cloudflare", "worker", "machine", "custom"];
 type SandboxProvider = (typeof SANDBOX_PROVIDERS)[number];
 
-/**
- * Sandbox-config validation for the Convex config plane. Ports core's former
- * storage/sandbox-config.ts normalizer so the public /v1/sandboxes contract
- * is unchanged. The public projection lives in ./responses.ts.
- */
-
 declare const SANDBOX_IMAGES: readonly ["browser", "obscura"];
 declare const SANDBOX_RUNTIMES: readonly ["bash", "python", "node"];
 declare const SANDBOX_PERMISSION_MODES: readonly ["edit", "ask", "bypass"];
@@ -657,9 +444,6 @@ type PermissionMode = (typeof SANDBOX_PERMISSION_MODES)[number];
 type NetworkMode = (typeof SANDBOX_NETWORK_MODES)[number];
 type SandboxSize = (typeof SANDBOX_SIZE_NAMES)[number];
 type SandboxImage = (typeof SANDBOX_IMAGES)[number];
-/**
- * Idle and maximum lifetime controls for a persistent sandbox.
- */
 interface SandboxLifecycleConfig {
     idleTimeoutSeconds?: number;
     maxLifetimeSeconds?: number;
@@ -669,9 +453,6 @@ interface SandboxNetworkConfig {
     allowDomains?: string[];
     allowCidrs?: string[];
 }
-/**
- * Account-scoped reusable sandbox configuration referenced by agents.
- */
 interface SandboxConfig {
     provider: SandboxProvider;
     fallbackProvider?: SandboxProvider;
@@ -691,99 +472,49 @@ interface SandboxConfig {
     options?: Record<string, unknown>;
 }
 
-/**
- * Sandbox config: account-scoped, reusable sandbox definitions referenced by
- * agents via `config.sandboxes`. A sandbox is a collection of Claude-Code-style
- * tools (bash/read/write/edit/glob/grep) backed by a provider. Stored encrypted
- * at rest because `envVars`/`options` may hold secrets. Validation and the
- * public projection live in packages/convex/model/sandboxRules.ts. The exec
- * wire contract a sandbox server speaks is here too, since the SDK publishes it.
- */
-
-/**
- * One exec, POSTed as JSON to `<endpoint>/exec`. The `lambda` MicroVM image
- * speaks it and the `custom` provider lets an account point core at its own
- * server that does. snake_case on purpose: the image shipped it first.
- */
 interface SandboxExecRequest {
-    /** Which interpreter runs `code`. Core sends `bash`. */
     runtime: RuntimeName;
     code: string;
-    /** Workspace namespace; selects the working directory. Absent for a stateless run. */
+    /** Selects the working directory; absent for a stateless run. */
     namespace?: string;
-    /** Root the namespace sits under; the server picks its default when absent. */
     workspace_root?: string;
-    /** The server kills the process and answers `timed_out: true` once this passes. */
     timeout_ms: number;
-    /** Positional arguments for `code`. */
     args?: string[];
-    /** The process environment, set over an empty one or the server's start-up defaults (HOME, TMPDIR, PATH). */
     env: Record<string, string>;
 }
-/** The JSON answer to one exec; HTTP 200 even when the code failed. */
+/** HTTP 200 even when the code failed. */
 interface SandboxExecResponse {
-    /** False when the process failed, timed out, or the request was invalid. */
     ok: boolean;
     runtime?: string;
     /** Null when the process was killed by the timeout. */
     exit_code?: number | null;
     timed_out: boolean;
-    /** Wall-clock time of the exec. */
     duration_ms: number;
     stdout: string;
     stderr: string;
-    /** True when the server already cut stdout or stderr. */
     truncated?: boolean;
-    /** CPU time of the exec in microseconds, for usage metering. */
     cpu_usec?: number;
-    /** The machine's vCPU-s and GB-s above its baseline since boot. MicroVM only. */
+    /** MicroVM only: vCPU-s and GB-s above the machine's baseline since boot. */
     burst?: {
         vcpu_seconds: number;
         gb_seconds: number;
     };
 }
 
-/**
- * Workspace isolation levels, the one list the config plane, core, the
- * dashboard and the CLI read. No imports on purpose: the CLI bundles this file
- * without the Convex runtime behind workspaceRules (like modelProviders.ts).
- */
 declare const WORKSPACE_ISOLATION_LEVELS: readonly ["conversation", "agent"];
-/**
- * How a workspace splits its files. "conversation" mounts a folder per channel
- * partition, "agent" gives every attached agent its own folder. Unset shares
- * one root between every agent and conversation.
- */
+/** A folder per channel partition or per agent; unset shares one root. */
 type WorkspaceIsolation = (typeof WORKSPACE_ISOLATION_LEVELS)[number];
 
-/**
- * Workspace-config validation for the Convex config plane. Ports core's
- * former storage/workspace-config.ts normalizer so the public /v1/workspaces
- * contract is unchanged. Workspace config holds no secrets (a roleArn is not
- * a secret, and R2 keys are `${NAME}` env refs), so it is stored and returned
- * in plaintext. Pure module, safe
- * for the default Convex runtime. The public projection lives in
- * ./responses.ts. Core runs the storage access rule too, so it reads the env
- * names of both sides.
- */
-
 declare const WORKSPACE_STORAGE_PROVIDERS: readonly ["s3"];
 type WorkspaceStorageProvider = (typeof WORKSPACE_STORAGE_PROVIDERS)[number];
 type WorkspaceStorageAuth = {
     type: "managed";
-}
-/**
- * The role's trust policy requires the account's Broods-assigned
- * sts:ExternalId (`storageTrust.ts`); a customer never sets one here.
- */
- | {
+} | {
     type: "assumeRole";
     roleArn: string;
 } | {
     type: "r2";
-    /** `${NAME}` ref to the parent R2 token's access key id. */
     accessKeyId: string;
-    /** `${NAME}` ref to the parent R2 token's secret access key. */
     secretAccessKey: string;
 };
 interface WorkspaceStorageConfig {
@@ -807,11 +538,6 @@ interface WorkspaceConfig {
     };
 }
 
-/**
- * Versioned policy document accepted by account-management CRUD, as the
- * `agentPolicies` and `accountRoles` tables store it. `mode` says how hard
- * the policy bites where it is attached; omitted reads as `audit`.
- */
 declare const policyDocumentValidator: convex_values.VObject<{
     mode?: "enforce" | "audit" | undefined;
     version: 1;
@@ -891,7 +617,6 @@ declare const policyDocumentValidator: convex_values.VObject<{
             resourceIds?: string[] | undefined;
         } | undefined, {
             toolNames: convex_values.VArray<string[] | undefined, convex_values.VString<string, "required">, "optional">;
-            /** MCP registration ids, for scoping tool.call rules per server (#331). */
             mcpIds: convex_values.VArray<string[] | undefined, convex_values.VString<string, "required">, "optional">;
             workspaceIds: convex_values.VArray<string[] | undefined, convex_values.VString<string, "required">, "optional">;
             workspaceNames: convex_values.VArray<string[] | undefined, convex_values.VString<string, "required">, "optional">;
@@ -917,18 +642,9 @@ declare const policyDocumentValidator: convex_values.VObject<{
 }, "required", "version" | "mode" | "rules">;
 type PolicyDocument = Infer<typeof policyDocumentValidator>;
 
-/**
- * Channel record validation for the config plane, the single home of the
- * normalizers core's `shared/domain/channel-record.ts` re-exports. Kept free
- * of Convex imports so the rules stay unit-testable; the public projection
- * lives in ./responses.ts.
- */
-/** Where a reply lands: its own thread, or wherever the message came from. */
 declare const CHANNEL_REPLY_TARGETS: readonly ["thread", "source"];
 type ChannelReplyIn = (typeof CHANNEL_REPLY_TARGETS)[number];
 
-/** Telegram channel adapter. */
-
 interface TelegramSource {
     chatId: number;
     commandToken?: string;
@@ -939,13 +655,6 @@ interface TelegramSource {
     fromUsername?: string;
 }
 
-/**
- * Google Chat channel adapter, for a Chat app on an HTTP endpoint. The Chat
- * SDK adapter is the transport: it verifies Google's signed token, reads the
- * message and posts the reply as the app's service account. Pub/Sub delivery
- * is not wired, so the app hears direct messages and @-mentions only.
- */
-
 interface GoogleChatSource {
     messageName: string;
     spaceName: string;
@@ -955,11 +664,6 @@ interface GoogleChatSource {
     userName?: string;
 }
 
-/**
- * GitHub channel adapter. Event filtering and source mapping live here; auth and
- * API calls go through the Chat SDK.
- */
-
 interface GitHubSource {
     owner: string;
     repo: string;
@@ -972,30 +676,18 @@ interface GitHubSource {
     target: "issue" | "issue_comment" | "pull_request" | "pull_request_review_comment";
 }
 
-/**
- * Linear channel adapter, for @-mentions in issue comments. The Chat SDK
- * adapter is the transport: it posts the reply under the comment thread and
- * reacts to the comment. The signature check is the Linear SDK's webhook
- * client, the same one the adapter runs. There is no streaming: every edit of
- * a Linear comment comes back as another webhook delivery.
- */
-
 interface LinearSource {
-    /** The comment that mentioned the agent, where the reaction goes. */
     commentId: string;
     issueId: string;
-    /** `linear:{issueId}:c:{rootCommentId}`: the reply nests under the root comment. */
     threadId: string;
 }
 
-/** Slack channel adapter. */
-
 interface SlackSource {
     teamId: string;
     channelId: string;
-    /** Where the reply goes. Unset posts to the channel. */
+    /** Where the reply goes; unset posts to the channel. */
     threadTs?: string;
-    /** The thread the message arrived in, unset when it arrived in the channel. */
+    /** The thread the message arrived in. */
     inThreadTs?: string;
     messageTs?: string;
     responseUrl?: string;
@@ -1003,8 +695,6 @@ interface SlackSource {
     userId?: string;
 }
 
-/** Discord channel adapter. */
-
 interface DiscordSource {
     applicationId: string;
     interactionToken?: string;
@@ -1017,37 +707,6 @@ interface DiscordSource {
     userId?: string;
 }
 
-/**
- * Matrix channel adapter.
- *
- * Matrix delivers nothing over a webhook, so `apps/matrix-forwarder` holds a
- * `/sync` long-poll per account, decrypts what arrives and POSTs each room
- * message here. The forwarder also holds the account's end-to-end encryption
- * keys, which is why every event sent into a room goes back through it.
- * Media never does: an attachment's key rides the decrypted event, so this
- * module downloads, decrypts, encrypts and uploads files against the
- * homeserver itself.
- *
- * The wire shapes shared with the forwarder live in `matrix-wire.ts`.
- */
-
-/** Where a reply goes: the room, and the thread when the message was in one. */
-interface MatrixSource {
-    encrypted: boolean;
-    messageId: string;
-    roomId: string;
-    threadRootId?: string;
-    userId: string;
-}
-
-/**
- * Pancake channel adapter.
- *
- * Per-conversation policy (e.g. skipping human-owned conversations by tag) is
- * not baked in: the parsed source carries `tagIds` so a user `onMessageReceived`
- * hook can decide to drop the message.
- */
-
 interface PancakeSource {
     pageId: string;
     conversationId: string;
@@ -1060,14 +719,6 @@ interface PancakeSource {
     tagIds?: string[];
 }
 
-/**
- * Microsoft Teams channel adapter, on the Bot Framework. The Chat SDK adapter
- * is the transport that reads the activity and posts the reply; the inbound
- * token is checked with the Teams SDK's JWT validator, set up for Bot Framework
- * connector tokens only, since the Chat SDK only reaches it through a full
- * `Chat` instance.
- */
-
 interface TeamsSource {
     conversationId: string;
     messageId: string;
@@ -1076,40 +727,18 @@ interface TeamsSource {
     userName?: string;
 }
 
-/**
- * The core HTTP contract every handler speaks, plus generic request/response
- * helpers. Handlers take a CoreRequest + RequestContext and return a Web
- * Response; the transport edge (`src/server.ts`) builds the CoreRequest from
- * a real request. Keep route-specific logic out of here.
- */
 declare global {
     interface BunFetchRequestInit {
         timeout?: number | boolean;
     }
 }
 
-/**
- * Twilio channel adapter, for SMS and MMS on a Twilio number or Messaging
- * Service. The Chat SDK adapter is the transport: it checks Twilio's
- * signature, reads the form Twilio posts and sends the reply. SMS has no typing
- * indicator and no reactions, so those actions do nothing.
- */
-
 interface TwilioSource {
-    /** The person's number, where the reply goes. */
     from: string;
     messageSid: string;
-    /** The Twilio number they texted. */
     to: string;
 }
 
-/**
- * WhatsApp channel adapter, on the WhatsApp Business Cloud API. The Chat SDK
- * adapter is the transport: it checks Meta's signature, reads the message and
- * posts the reply. Meta's GET subscription handshake is answered here too,
- * because it arrives on the same webhook URL.
- */
-
 interface WhatsAppSource {
     messageId: string;
     phoneNumberId: string;
@@ -1118,8 +747,6 @@ interface WhatsAppSource {
     userWaId: string;
 }
 
-/** Zalo channel adapter, on the official Zalo Bot API. */
-
 declare const ZALO_CHAT_TYPES: readonly ["PRIVATE", "GROUP"];
 type ZaloChatType = (typeof ZALO_CHAT_TYPES)[number];
 interface ZaloSource {
@@ -1132,20 +759,6 @@ interface ZaloSource {
     date?: number;
 }
 
-/**
- * What Messenger and Instagram share. Both deliver Meta Graph webhooks: a GET
- * subscription handshake answered with the verify token, an
- * `X-Hub-Signature-256` HMAC over every POST, and one envelope of batched
- * messaging events whose entries each name the Page or account they are for.
- * Both reply through a Chat SDK adapter used as transport only. Each channel
- * file builds its transport and names how the two differ.
- */
-
-/**
- * Where a Messenger or Instagram message came from. `recipientId` is the Page
- * or Instagram professional account that received it; `threadId` is the Chat
- * SDK thread the reply goes to.
- */
 interface MetaSource {
     messageId: string;
     recipientId: string;
@@ -1153,32 +766,10 @@ interface MetaSource {
     threadId: string;
 }
 
-/**
- * Instagram DM channel adapter, on the Instagram API with Instagram Login. The
- * Chat SDK adapter reads the message and posts the reply, media included; the
- * Meta webhook handshake, signature check and event walk are shared with
- * Messenger in `meta-channel.ts`.
- */
-
 type InstagramSource = MetaSource;
 
-/**
- * Facebook Messenger channel adapter, on the Messenger Platform Send API. The
- * Chat SDK adapter reads the message, posts the reply and names the Page its
- * token belongs to; the Meta webhook handshake, signature check and event walk
- * are shared with Instagram in `meta-channel.ts`.
- */
-
 type MessengerSource = MetaSource;
 
-/**
- * Canonical CLI manifest wire types, the single source of truth shared by the
- * backend (cliSync.ts, cliHttp.ts) and the SDK/CLI (packages/broods).
- *
- * This file intentionally has no runtime imports (its values are plain
- * lists) so the SDK can import it without pulling the Convex server module
- * graph into its typecheck.
- */
 type CliManifestResource = {
     kind: "agent" | "workspace" | "sandbox" | "cron" | "skill" | "hook" | "mcp" | "policy" | "channelRecord";
     name: string;
@@ -1196,26 +787,17 @@ type GeneratedIds = {
     policies: Record<string, string>;
     channelRecords: Record<string, string>;
 };
-/** Where a Production stage runs. */
 declare const DEPLOYMENT_REGIONS: readonly ["ap-southeast-1", "eu-west-1", "us-east-1"];
 type DeploymentRegion = (typeof DEPLOYMENT_REGIONS)[number];
 type CliManifest = {
     version: 1;
     project: string;
     stage: string;
-    /**
-     * Production only: the region its first deploy pins (eu-west-1 when unset).
-     * A later deploy naming another region is refused.
-     */
+    /** Production only: pinned by the first deploy; a later deploy naming another is refused. */
     region?: DeploymentRegion;
     resources: CliManifestResource[];
 };
 
-/**
- * Type contracts inherited from Convex and core domain/runtime modules.
- * Keep this file type-only so the public SDK does not bundle backend code.
- */
-
 type Id<TableName extends string = string> = string & {
     readonly __tableName?: TableName;
 };
@@ -1238,37 +820,22 @@ type AgentRunOverrides = {
     model?: AgentRunModelOverrides;
 };
 type AgentRunEventInput = {
-    /** Shorthand for a single user text message. */
     input: string;
     events?: never;
     answers?: never;
 } | {
-    /** Full-fidelity event list for multimodal content or tool responses. */
     events: [ModelMessage, ...ModelMessage[]];
     input?: never;
     answers?: never;
 };
-/**
- * Resolves a run's events from either the explicit `events` list or the `input`
- * string shorthand, matching the core direct API's event contract.
- */
 declare function resolveRunEvents(input: AgentRunEventInput): ModelMessage[];
 
-/**
- * Shared direct-run stream contracts and SSE parsing helpers.
- */
-
 type AgentStreamPart = TextStreamPart<ToolSet> | {
     type: "structured-output";
     output: unknown;
 };
-/** Yield the payload of each `data:` line from an SSE response body. */
 declare function readSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;
 
-/**
- * Shared WebSocket wire message contracts used by the SDK client and gateway.
- */
-
 type IngressMode = "reject" | "followup" | "collect" | "steer";
 type IngressStatus = "accepted" | "queued" | "applied" | "processing" | "awaiting_approval" | "awaiting_input" | "completed" | "failed" | "expired";
 /** One open `ask_questions` prompt while a run is `awaiting_input`. */
@@ -1299,9 +866,8 @@ type AgentRunAnswerInput = {
     events?: never;
 };
 /**
- * A frame too large for NATS arrives as its own `type` with `truncated: true`
- * and `originalBytes`, its payload dropped. Read the full result from the run
- * status.
+ * A frame too large for NATS keeps its `type`, gains `truncated: true` and `originalBytes`,
+ * and drops its payload: read the full result from the run status.
  */
 type WebSocketStreamMessage = AgentStreamPart | {
     type: "question-request";
@@ -1346,9 +912,8 @@ type WebSocketServerMessage = {
     statusUrl?: string;
 } | WebSocketOutputMessage | WebSocketStreamMessage;
 /**
- * Durable-stream envelope around one stream part. The SDK unwraps `data` for
- * handlers and surfaces the envelope itself through `onOutput` so clients can
- * persist `cursor` for attach-based resume.
+ * The SDK unwraps `data` for handlers and passes this envelope to `onOutput`, so a client
+ * can persist `cursor` to resume with `attach`.
  */
 type WebSocketOutputMessage = {
     type: "output";
@@ -1389,13 +954,6 @@ type WebSocketClientCancelMessage = {
 };
 type WebSocketClientMessage = WebSocketClientExecuteMessage | WebSocketClientControlMessage | WebSocketClientAttachMessage | WebSocketClientCancelMessage;
 
-/**
- * Wire types for the public account-manage and harness APIs. These mirror
- * the deployed API contract (docs/api-reference/openapi.yaml is the source
- * of truth); they are intentionally independent of the runtime internals so
- * the SDK keeps working when the runtime is ported.
- */
-
 interface Account {
     account: {
         accountId: string;
@@ -1410,9 +968,7 @@ interface Agent {
 }
 interface AsyncRequestAccepted {
     statusUrl: string;
-    /** Account-unique id for this run; what the status URL names. */
     runId: string;
-    /** The eventId sent with the request, echoed back. */
     eventId: string;
     agentId: string;
     status?: "accepted" | "queued" | "applied" | "processing";
@@ -1420,10 +976,9 @@ interface AsyncRequestAccepted {
 }
 interface AsyncStatus {
     status: "accepted" | "queued" | "applied" | "processing" | "awaiting_approval" | "awaiting_input" | "completed" | "failed" | "expired" | "not_found";
-    /** Set on every core answer. Absent only on the `not_found` the SDK returns for a 404. */
+    /** Absent only on the `not_found` the SDK returns for a 404. */
     runId?: string;
     eventId?: string;
-    /** The agent that owns the run. A subagent run names the child agent. */
     agentId?: string;
     conversationKey?: string;
     requestedMode?: "reject" | "followup" | "collect" | "steer";
@@ -1432,7 +987,6 @@ interface AsyncStatus {
     result?: unknown;
     response?: unknown;
     error?: string;
-    /** True when `failed` was a deliberate /stop, not a fault. */
     stoppedByUser?: boolean;
     approvals?: ToolApprovalSummary[];
     questions?: PendingQuestion[];
@@ -1479,7 +1033,6 @@ interface Skill {
         size?: number;
     }>;
 }
-/** A tool call held for user approval by an `ask`-mode sandbox. */
 interface ToolApprovalSummary {
     approvalId: string;
     toolCallId: string;
@@ -1491,11 +1044,6 @@ interface Workspace {
     name: string;
 }
 
-/**
- * Shared WebSocket wire-protocol types for the observability gateway, used by
- * the gateway, the SDK/CLI, and the dashboard. Pure types + tiny pure helpers,
- * zero runtime deps. Kept separate from the agent-test websocket-contracts.
- */
 declare const MAX_OBSERVABILITY_BACKFILL = 500;
 type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
 type ObservabilityLogEntry = {
@@ -1568,38 +1116,20 @@ type ObservabilityErrorMessage = {
     error: string;
 };
 type ObservabilityServerMessage = ObservabilityReadyMessage | ObservabilityBackfillMessage | ObservabilityLogMessage | ObservabilitySpanMessage | ObservabilityErrorMessage;
-/** Narrow an unknown wire value to a LogLevel. */
 declare function isLogLevel(value: unknown): value is LogLevel;
 declare function isObservabilityClientMessage(v: unknown): v is ObservabilityClientMessage;
-/** Whether a span is a top-level run, each of which owns its own trace. */
 declare function isRootSpanKind(kind: ObservabilitySpanRow["kind"]): boolean;
-/**
- * Narrow a wire value to a sandbox log id. Strict on purpose: the gateway
- * interpolates it into LogQL, so only the UUID shape core mints may pass.
- */
+/** Strict on purpose: the gateway interpolates it into LogQL. */
 declare function isSandboxLogId(value: unknown): value is string;
-/** Whether a value is a real trace id a log line can be followed to. */
 declare function isTraceId(value: unknown): value is string;
 
-/**
- * Configurable client for running deployed agents over direct core SSE.
- * Stream chunks are the Vercel AI SDK's `TextStreamPart` parts that core emits.
- */
-
 declare const DEFAULT_CORE_BASE_URL = "https://gateway.broods.app";
-/**
- * Input for a single agent run. The core direct API is event-based (a list of
- * Vercel AI SDK model messages), so `events` is the full-fidelity form. Use it
- * for multimodal content (images/files), ephemeral system messages, or
- * tool-approval responses. `input` is a shorthand for a single user text message
- * and is wrapped into one user event. Provide exactly one of the two.
- */
 type AgentRunInputBase = {
     conversationKey?: string;
     eventId?: string;
-    /** Busy-conversation behavior. Defaults to `steer`: join the live run at its next step boundary (falls back to a FIFO follow-up). */
+    /** When the conversation is busy. Default `steer` joins the live run at its next step. */
     mode?: "reject" | "followup" | "collect" | "steer";
-    /** Stable retry identity within the conversation; defaults to eventId. */
+    /** Defaults to `eventId`. */
     idempotencyKey?: string;
 } & AgentRunOverrides;
 type AgentRunInput = AgentRunInputBase & AgentRunEventInput;
@@ -1607,7 +1137,6 @@ interface AgentRunResult {
     text: string;
     events: TextStreamPart<ToolSet>[];
 }
-/** Input for `continue`: the conversation to re-enter. */
 interface AgentContinueInput {
     /** The key given to `run`, or the scoped key a dashboard trace row shows. */
     conversationKey: string;
@@ -1633,19 +1162,13 @@ interface AgentReference<Name extends string = string> {
     readonly id: string;
     readonly project: string;
     readonly stage: string;
-    /**
-     * Authoritative scope of the stage's runtime key, embedded by codegen
-     * from the deploy response. When present the client posts to the scoped URL
-     * `/v1/projects/{projectSlug}/stages/{stageSlug}/agents/{endpointId}` (matching the
-     * dashboard); when absent it falls back to the base URL.
-     */
     readonly endpointId?: string;
     readonly projectSlug?: string;
     readonly stageSlug?: string;
 }
 interface ChannelReference {
     readonly kind: "channel";
-    readonly type: "telegram" | "gchat" | "github" | "linear" | "slack" | "discord" | "matrix" | "pancake" | "teams" | "twilio" | "zalo" | "whatsapp" | "instagram" | "messenger";
+    readonly type: "telegram" | "gchat" | "github" | "linear" | "slack" | "discord" | "pancake" | "teams" | "twilio" | "zalo" | "whatsapp" | "instagram" | "messenger";
     readonly agentName: string;
     readonly agentId: string;
     readonly accountId: string;
@@ -1661,20 +1184,12 @@ interface ResourceApi {
     readonly policies?: Record<string, unknown>;
 }
 interface BroodsClientOptions {
-    /**
-     * Base URL of the core service to call directly. Use `https://gateway.broods.app`
-     * for the hosted service. If you only have a domain, use `host` instead.
-     */
     baseUrl?: string;
-    /** Hostname or URL of the core service. `gateway.broods.app` becomes `https://gateway.broods.app`. */
     host?: string;
-    /** Runtime key used as the Bearer token for direct runtime calls. */
     apiKey?: string;
     /**
-     * The signed-in user's token, sent beside the runtime key on every call.
-     * Pass a function to get a fresh one per call (a browser fetches it from
-     * your backend, which signs it with `signUserToken`). An agent that
-     * requires one refuses the runtime key without it.
+     * Sent beside the runtime key; an agent that requires one refuses the key alone.
+     * A function fetches a fresh token per call, e.g. one your backend signs with `signUserToken`.
      */
     userToken?: string | (() => string | Promise<string>);
     fetch?: typeof fetch;
@@ -1692,62 +1207,37 @@ declare class BroodsClient {
     private readonly userToken?;
     private readonly fetchImpl;
     constructor(options?: BroodsClientOptions);
-    /** Return the public provider webhook URL for a generated channel reference. */
     channelWebhookUrl(ref: ChannelReference): string;
-    /**
-     * Return the provider webhook URL for an account's channel. The URL names no
-     * agent, since every channel of one type in an account shares it, so this is
-     * what to paste into the provider when several agents sit behind the same app.
-     */
+    /** Names no agent: paste it into the provider when several agents share one app. */
     accountWebhookUrl(accountId: string, channelType: ChannelReference["type"]): string;
-    /**
-     * Return the provider webhook URL pinned to one stage. Production keeps the
-     * bare account URL from `accountWebhookUrl`.
-     */
+    /** Pinned to one non-production stage; production uses `accountWebhookUrl`. */
     stageWebhookUrl(accountId: string, endpointId: string, channelType: ChannelReference["type"]): string;
     agent<const Name extends string>(ref: AgentReference<Name>): AgentHandle;
     agent(name: string, agentId: string): AgentHandle;
-    /** Run an agent and accumulate the streamed text and raw parts. */
     run(ref: AgentReference, input: AgentRunInput): Promise<AgentRunResult>;
     run(input: AgentRunInput & {
         agentId: string;
         agentName?: string;
     }): Promise<AgentRunResult>;
-    /** Stream an agent run, yielding each AI SDK `TextStreamPart` as it arrives. */
     stream(ref: AgentReference, input: AgentRunInput): AsyncGenerator<TextStreamPart<ToolSet>>;
     stream(input: AgentRunInput & {
         agentId: string;
         agentName?: string;
     }): AsyncGenerator<TextStreamPart<ToolSet>>;
-    /** Start an async agent run and return the status id/URL used for polling. */
     runAsync(ref: AgentReference, input: AgentRunInput): Promise<AsyncAgentRun>;
     runAsync(input: AgentRunInput & {
         agentId: string;
         agentName?: string;
     }): Promise<AsyncAgentRun>;
-    /**
-     * Re-enter a conversation whose last turn stopped short (step cap, provider
-     * fault). Core adds one "continue" user turn on the persisted history and
-     * runs it like a background run; a live channel session answers in its channel.
-     */
+    /** Re-enter a conversation whose last turn stopped short (step cap, provider fault). */
     continue(ref: AgentReference, input: AgentContinueInput): Promise<AsyncAgentRun>;
     continue(input: AgentContinueInput & {
         agentId: string;
     }): Promise<AsyncAgentRun>;
-    /** Fetch one async status snapshot by status URL or run id. */
     getAsyncStatus(status: AsyncRequestAccepted | string): Promise<AsyncStatus>;
-    /** Poll async status until it reaches completed, failed, awaiting_approval, awaiting_input, or timeout. */
     waitForAsyncStatus(status: AsyncRequestAccepted | string, options?: AsyncPollOptions): Promise<AsyncStatus>;
-    /**
-     * Scoped invoke URL for a deployed agent. When codegen embedded the runtime
-     * key's scope, this is
-     * `/v1/projects/{projectSlug}/stages/{stageSlug}/agents/{endpointId}` (the
-     * same URL the dashboard shows, so core can validate the key against the
-     * path); otherwise it falls back to the single run endpoint.
-     */
     private scopedUrl;
     private asyncAgentRun;
-    /** POST a run body that must answer 202 and wrap the accepted run for polling. */
     private postAcceptedRun;
     private openStream;
     private fetchCore;
@@ -1758,33 +1248,14 @@ declare class BroodsClient {
 }
 declare function normalizeHttpServiceUrl(value: string): string;
 
-/** The HTTP header a token rides on. */
 declare const USER_TOKEN_HEADER = "x-broods-user-token";
-/** A token naming a later expiry is refused: it is a bearer for its whole life. */
 declare const USER_TOKEN_MAX_TTL_MS: number;
 
-/**
- * Server-side signing of end-user tokens. The runtime key (`bsk_`) sits in a
- * frontend, so it cannot say who is using it; your backend, which knows the
- * signed-in user, signs a short-lived token with the stage's signing secret
- * (`bsig_`, from the dashboard's Runtime key tab) and hands it to the
- * frontend. Core then keeps every conversation that request touches under
- * that user, so one visitor can never read or steer another's. Never ship the
- * signing secret to a browser.
- */
-
-/**
- * The env var `signUserToken` reads the signing secret from, and the one
- * `broods dev` / `broods deploy` write it to in `.env.local`.
- */
 declare const USER_TOKEN_SECRET_ENV = "BROODS_USER_TOKEN_SECRET";
 interface SignUserTokenInput {
     /** Your own id for the signed-in user. Letters, digits and `._@+=-`, at most 128. */
     userId: string;
-    /**
-     * The conversation keys this user may use. Omit to allow any key, which
-     * still lands under this user only.
-     */
+    /** Conversation keys this user may use. Omit to allow any key, still under this user only. */
     conversations?: string[];
     /** Lifetime in ms. Defaults to 10 minutes, at most 60. */
     ttlMs?: number;
@@ -1792,38 +1263,26 @@ interface SignUserTokenInput {
     secret?: string;
 }
 /**
- * A user token for the runtime key: pass it as `userToken` to `BroodsClient`
- * or `BroodsWebSocketClient`, or send it in the `X-Broods-User-Token` header.
+ * Signs a short-lived token for your signed-in user, so core keeps that user's conversations
+ * apart. Call it on your backend only: never ship the `bsig_` secret to a browser. Pass the
+ * token as `userToken` to `BroodsClient` or `BroodsWebSocketClient`.
  * @throws when no signing secret is set or an input is out of range
  */
 declare function signUserToken(input: SignUserTokenInput): Promise<string>;
 
-/**
- * Connections: external accounts an agent acts through, one of each type per
- * Broods account. `broods connect <type>` opens the provider's sign-in; the
- * deployment trades the code, checks the ID token and keeps the tokens, and
- * core refreshes them from then on. `chatgpt` backs the `chatgpt` model
- * provider. Plain data, so the CLI, the config plane, core and the dashboard
- * read one copy.
- */
 declare const CONNECTION_TYPE_NAMES: readonly ["chatgpt"];
 type ConnectionType = (typeof CONNECTION_TYPE_NAMES)[number];
-/** Starts a sign-in: `POST /v1/account/connections/{type}/start`. */
 interface ConnectionStart {
-    /** The loopback address the provider redirects back to. */
     redirectUri: string;
     codeChallenge: string;
     state: string;
     nonce: string;
 }
-/** The provider's consent screen, plus the client and host id the PUT echoes back. */
 interface ConnectionStartResult {
     authorizeUrl: string;
-    /** The client the consent runs on; a redirect that signs in again may omit it. */
     clientId: string;
     hostId: string;
 }
-/** Finishes a sign-in: `PUT /v1/account/connections/{type}` with the redirect's code. */
 interface ConnectionCode {
     code: string;
     codeVerifier: string;
@@ -1833,71 +1292,37 @@ interface ConnectionCode {
     clientId: string;
     hostId: string;
 }
-/** A connection as the API answers it: never its tokens. */
 interface Connection {
     type: ConnectionType;
     clientId: string;
-    /** The deployment's `ext_agent_host_id`, kept across sign-ins. */
     hostId: string;
     email?: string;
     scopes: string[];
-    /** ISO 8601 access-token expiry; Broods refreshes it before then. */
     expiresAt: string;
     updatedAt: string;
-    /** Answered by a sign-in only: the models the plan may call. */
     models?: string[];
 }
 
-/**
- * Account config-plane client for the broods public account REST API.
- *
- * This is the DYNAMIC counterpart to the config-first `broods dev` / `broods
- * deploy` flow: `broods dev` syncs the predefined resources declared in your
- * `broods/` folder, while `BroodsAccountClient` creates and mutates the full
- * account config plane at runtime: agents, sandboxes (config + lifecycle),
- * workspaces (config + files), tools, policies, skills, crons, and the account
- * itself. One caller is a multi-tenant app provisioning one agent per customer
- * from its own backend.
- *
- * Kept intentionally standalone (import from `broods/account`): pure fetch,
- * no Node built-ins, no `.env` file loading, so it runs in edge/worker
- * runtimes such as Convex actions, Cloudflare Workers, and the browser-less
- * server runtimes, as well as Node and Bun.
- *
- * Auth: every call sends `Authorization: Bearer {accountSecret}` to
- * `{baseUrl}/v1/...`, or a short-lived `bsts_` role session token from
- * `assumeRole()`, limited to what the role's policy allows. Secrets inside
- * agent configs are encrypted at rest by the platform and come back redacted
- * (`********`) on reads.
- */
-
-/** A config PATCH body: objects merge key by key, `null` deletes a key, arrays and scalars replace. */
+/** Objects merge key by key, `null` deletes a key, arrays and scalars replace. */
 type ConfigPatch<T> = T extends readonly unknown[] ? T : T extends object ? {
     [K in keyof T]?: ConfigPatch<T[K]> | null;
 } : T;
 interface BroodsAccountClientOptions {
-    /** Base URL of the broods gateway. Falls back to `BROODS_BASE_URL`, then `https://gateway.broods.app`. */
     baseUrl?: string;
-    /** Account key used as the Bearer token. Falls back to `BROODS_ACCOUNT_SECRET`. */
     accountSecret?: string;
-    /**
-     * Short-lived `bsts_` role session token (from {@link BroodsAccountClient.assumeRole})
-     * used as the Bearer instead of the account key. The session can only do
-     * what its role's policy allows. Falls back to `BROODS_SESSION_TOKEN`.
-     */
+    /** From {@link BroodsAccountClient.assumeRole}; wins over `accountSecret`. */
     sessionToken?: string;
     fetch?: typeof fetch;
 }
-/** Public account record returned by `GET /v1/account`. */
 interface BroodsAccount {
     accountId: string;
     username: string;
     status: string;
-    /** Days an audit row is kept; absent means the 90 day default. */
+    /** Absent means the 90 day default. */
     auditRetentionDays?: number;
     [key: string]: unknown;
 }
-/** Public agent record; `config` comes back with secret values redacted. */
+/** `config` secrets come back redacted as `********`. */
 interface AccountAgent {
     accountId: string;
     agentId: string;
@@ -1914,20 +1339,16 @@ interface CreateAgentResult {
     name: string;
     description?: string;
 }
-/** Write-only account environment variable metadata. */
 interface AccountEnvVar {
     name: string;
-    /** ISO 8601, like every other timestamp in the API. */
     updatedAt: string;
 }
 
-/** Fields accepted by `PATCH /v1/agents/{id}`. `config` is deep-merged; `null` values delete keys. */
 interface UpdateAgentInput {
     name?: string;
     description?: string | null;
     config?: ConfigPatch<AgentConfig>;
 }
-/** Public workspace record returned by the workspaces routes. */
 interface AccountWorkspace {
     accountId: string;
     workspaceId: string;
@@ -1937,7 +1358,6 @@ interface AccountWorkspace {
     createdAt: string;
     updatedAt: string;
 }
-/** One entry of a workspace file listing (`GET /v1/workspaces/{id}/files`). */
 interface WorkspaceFileEntry {
     path: string;
     name: string;
@@ -1945,7 +1365,7 @@ interface WorkspaceFileEntry {
     sizeBytes?: number;
     updatedAt?: string;
 }
-/** Public sandbox config record; `config` comes back with secret values (e.g. `envVars`) redacted. */
+/** `config` secrets such as `envVars` come back redacted. */
 interface AccountSandbox {
     accountId: string;
     sandboxId: string;
@@ -1956,7 +1376,6 @@ interface AccountSandbox {
     updatedAt: string;
     [key: string]: unknown;
 }
-/** Public agent-policy record returned by the policies routes. */
 interface AccountPolicy {
     accountId: string;
     policyId: string;
@@ -1967,11 +1386,7 @@ interface AccountPolicy {
     createdAt: string;
     updatedAt: string;
 }
-/**
- * Public account-role record returned by the roles routes. The policy uses the
- * API action namespace (`"agents:read"`, `"crons:write"`, ...); `projectId` and
- * `stageId` bound which runtime keys may assume the role.
- */
+/** `policy` uses API actions (`agents:read`); `projectId` + `stageId` bound who may assume it. */
 interface AccountRole {
     accountId: string;
     roleId: string;
@@ -1983,7 +1398,6 @@ interface AccountRole {
     createdAt: string;
     updatedAt: string;
 }
-/** One link of an agent actor's delegation chain: who asked, or an agent that delegated. */
 type AuditPrincipalLink = {
     kind: "user";
     id: string;
@@ -1997,10 +1411,8 @@ type AuditPrincipalLink = {
     agentId: string;
 };
 /**
- * One row of the account's hash-chained audit ledger, as `GET /v1/audit`
- * serves it. `hash` is sha256 over the canonical JSON of every field but
- * `hash` itself (an absent optional field is left out, not null), with
- * `prevHash` linking it to the row before.
+ * `hash` is sha256 of the canonical JSON of every other field (an absent optional is left
+ * out, not null); `prevHash` is the previous row's `hash`.
  */
 interface AuditEvent {
     accountId: string;
@@ -2030,44 +1442,31 @@ interface AuditEvent {
     stageId?: string;
     traceId?: string;
 }
-/** A page of ledger rows plus the chain head to compare the last row against. */
 interface AuditPage {
     events: AuditEvent[];
-    /** Pass as `since` to read the rows after this page. */
     nextSince: number;
     head: {
         seq: number;
         hash: string;
     } | null;
 }
-/** Result of `GET /v1/audit/verify`: the chain recomputed over the checked range. */
 interface AuditVerification {
     ok: boolean;
     brokenAtSeq?: number;
     checkedFrom?: number;
     checkedTo?: number;
 }
-/** The account's audit export target. The signing secret never comes back. */
 interface AuditSink {
     kind: "webhook";
     url: string;
-    /** Highest seq the receiver acknowledged. */
     exportedSeq: number;
     lastError?: string;
     updatedAt: string;
 }
-/** Short-lived role session minted by `POST /v1/account/assume-role`. */
 interface AssumeRoleResult {
-    /** `bsts_` bearer token; pass it as `sessionToken` to a new client. */
     token: string;
-    /** ISO timestamp when the session stops working. */
     expiresAt: string;
 }
-/**
- * One real place a team talks, bound to an agent: a Slack channel, a Discord
- * channel, a repo. The runtime reads it on the inbound webhook to decide who
- * answers there and with what instructions, workspaces and policies.
- */
 interface AccountChannel {
     accountId: string;
     channelId: string;
@@ -2093,39 +1492,26 @@ interface ChannelRecordConfig {
         name: string;
         workspaceId: string;
     }>;
-    /** Added to whatever the agent already carries. Each policy holds its own mode. */
     policies?: string[];
-    /**
-     * Tool names withheld in this channel, applied after the tool set is built,
-     * so it also covers sandbox tools (`bash`, `read`, …) that `config.tools`
-     * cannot name. Narrowing only; unknown names are ignored.
-     */
+    /** Also covers sandbox tools (`bash`, `read`, …); unknown names are ignored. */
     denyTools?: string[];
-    /**
-     * Where the reply lands. `source` answers wherever the message came from, and
-     * threads only when the message already did. Slack only. No other provider
-     * gives the runtime a second place to reply.
-     */
+    /** Slack only. `source` replies where the message came from, threading only if it was. */
     replyIn?: ChannelReplyIn;
     partition?: ChannelPartition;
-    /** Images the agent may stand a sandbox up from for a thread here. */
     sandboxImages?: string[];
-    /** Named groups of people, readable from policy conditions as `userRoles`. */
+    /** Readable from policy conditions as `userRoles`. */
     tagRoles?: Array<{
         roleId: string;
         userIds: string[];
     }>;
 }
-/** The stage a resource belongs to. Same name in two stages = two resources. */
 interface StageScope {
     project: string;
     stage: string;
 }
 /**
- * OAuth 2.0 refresh-token grant on an external MCP row. The runtime mints and
- * refreshes access tokens and sends `Authorization: Bearer <token>` itself.
- * `clientSecret` and `refreshToken` must be `${NAME}` account env refs;
- * `tokenUrl` defaults to https://oauth2.googleapis.com/token.
+ * Refresh-token grant; the runtime mints the Bearer itself. `clientSecret` and `refreshToken`
+ * must be `${NAME}` env refs; `tokenUrl` defaults to https://oauth2.googleapis.com/token.
  */
 interface McpOauthInput {
     clientId: string;
@@ -2133,9 +1519,8 @@ interface McpOauthInput {
     refreshToken: string;
     tokenUrl?: string;
 }
-/** Where a hosted MCP server may run. */
+/** `auto` (the default) runs a hosted bundle on Cloudflare Workers when it can, else Lambda. */
 type McpRuntime = "auto" | "lambda";
-/** Public MCP server registration returned by the `/v1/mcp` routes (#331). */
 interface AccountMcp {
     accountId: string;
     serverId: string;
@@ -2143,16 +1528,12 @@ interface AccountMcp {
     stageId: string;
     name: string;
     description?: string;
+    /** `http` sets `url`, `hosted` sets `sha256`/`runtime`, `machine` sets `sandbox`/`command`. */
     transport: "http" | "hosted" | "machine";
-    /** External servers only; a hosted row has no endpoint of its own. */
     url?: string;
-    /** Machine servers only: the sandbox (by name) that serves it. */
     sandbox?: string;
-    /** Machine servers only: argv of the stdio server a lambda sandbox runs. */
     command?: string[];
-    /** Hosted servers only: content hash of the uploaded bundle. */
     sha256?: string;
-    /** Hosted servers only: "auto" or "lambda". */
     runtime?: McpRuntime;
     headers?: Record<string, string>;
     oauth?: McpOauthInput;
@@ -2163,11 +1544,7 @@ interface AccountMcp {
     updatedAt: string;
     deletedAt?: string;
 }
-/**
- * Fields accepted by `POST /v1/mcp`: `url` connects, `bundle` uploads inline
- * (≤10 MB); a larger bundle goes through `uploadMcpBundle` first; `sandbox`
- * runs it on that sandbox: a machine's daemon, or `command` on a lambda VM.
- */
+/** `bundle` inline is ≤10 MB, a larger one goes through `uploadMcpBundle` first. */
 interface CreateMcpInput {
     name: string;
     description?: string;
@@ -2180,14 +1557,8 @@ interface CreateMcpInput {
     headers?: Record<string, string>;
     oauth?: McpOauthInput;
     allowedTools?: string[];
-    /**
-     * Hosted servers only. "auto" (the default) runs it on Cloudflare Workers
-     * when its bundle can run there, on Lambda otherwise; "lambda" always runs
-     * it on Lambda.
-     */
     runtime?: McpRuntime;
 }
-/** Fields accepted by `PATCH /v1/mcp/{serverId}`; every field is optional. */
 interface UpdateMcpInput {
     name?: string;
     description?: string;
@@ -2200,19 +1571,10 @@ interface UpdateMcpInput {
     headers?: Record<string, string>;
     oauth?: McpOauthInput;
     allowedTools?: string[];
-    /**
-     * Hosted servers only. "auto" (the default) runs it on Cloudflare Workers
-     * when its bundle can run there, on Lambda otherwise; "lambda" always runs
-     * it on Lambda.
-     */
     runtime?: McpRuntime;
     disabled?: boolean;
 }
-/**
- * Body of a skill upload (`POST /v1/skills`, `PUT /v1/skills/{skillName}`).
- * `json` needs `name`/`description`/`content`; `files` needs base64 `files`
- * including a root `SKILL.md`; `github` needs a tree `url`.
- */
+/** `json` needs name, description, content; `files` a root `SKILL.md`; `github` a tree `url`. */
 interface SkillUploadInput {
     source: "json" | "files" | "github";
     name?: string;
@@ -2225,101 +1587,72 @@ interface SkillUploadInput {
     }>;
     url?: string;
 }
-/** Result of `POST /v1/account/rotate-secret`. The returned `secret` is the new account key, shown once; the old key stops working immediately. */
 interface RotateSecretResult {
     account: BroodsAccount;
     secret: string;
 }
 /**
- * Result of `GET /v1/account/storage-trust`: what a workspace's own AWS role
- * must trust. Broods assigns `externalId` per account and sends it on every
- * AssumeRole of an `assumeRole` workspace's role; it is never set in config.
+ * `externalId` is per account and sent on every AssumeRole; it is never set in config.
+ * `principalArn` and `trustPolicy` are absent on a deployment with no AWS.
  */
 interface StorageTrust {
     externalId: string;
-    /** The Broods AWS principal to trust; absent on a deployment with no AWS. */
     principalArn?: string;
-    /** A ready-to-paste trust policy JSON; absent on a deployment with no AWS. */
     trustPolicy?: string;
 }
-/** Result of `DELETE /v1/account`: the account and all account-scoped data are removed; `cleanup` reports per-resource deletion counts. */
 interface DeleteAccountResult {
     deleted: boolean;
     cleanup?: Record<string, number>;
 }
-/** Result of a suspend/resume/terminate sandbox lifecycle action. */
 interface SandboxLifecycleResult {
     status: string;
 }
-/** Result of `POST /v1/sandboxes/{id}/snapshot`. */
 interface SandboxSnapshotResult {
     status: string;
     snapshotId?: string;
     externalImageId?: string;
 }
-/** Sealed ticket from `POST /v1/sandboxes/{id}/terminal`; hand `token` to the gateway terminal WebSocket at `websocketPath`. */
 interface SandboxTerminalTicket {
     token: string;
     expiresAt: number;
     websocketPath: string;
 }
-/** Non-2xx response from the account API (404s on id routes return null instead). */
 declare class BroodsAccountApiError extends Error {
     readonly status: number;
     readonly body: string;
     constructor(method: string, path: string, status: number, body: string);
 }
-/** Build a validated account env-var reference for use in an agent config. */
 declare function envPlaceholder(name: string): string;
-/**
- * The credential the environment supplies, with a role session winning over
- * the account key. The constructor throws through this same resolution, so
- * callers that can run without an account credential (`broods mcp` with only a
- * stored login) probe here instead of catching the constructor.
- */
+/** The constructor's env fallback, for callers that must not throw without one. */
 declare function resolveEnvCredential(): string | undefined;
 /**
- * Typed client for the broods account config API. All `get`/`update`/`delete`
- * methods return `null`/`false` when the resource does not exist (HTTP 404) so
- * callers can implement upsert flows without try/catch; every other non-2xx
- * status throws {@link BroodsAccountApiError}.
+ * Lookups, updates and deletes return `null`/`false` on a 404, so upserts need no try/catch.
+ * Any other failure throws {@link BroodsAccountApiError}.
  */
 declare class BroodsAccountClient {
     private readonly baseUrl;
     private readonly bearerToken;
     private readonly fetchImpl;
     constructor(options?: BroodsAccountClientOptions);
-    /** The account this secret belongs to. Its `accountId` is the first segment of channel webhook URLs. */
     getAccount(): Promise<BroodsAccount>;
-    /** The external id and Broods principal this account's own storage roles must trust. */
     getStorageTrust(): Promise<StorageTrust>;
-    /** Update account metadata (username/description). Returns null when the account is gone. Runtime config is managed through the agent endpoints. */
     updateAccount(patch: {
         username?: string;
         description?: string | null;
-        /** 1 to 3650 days, or null to return to the 90 day default. */
+        /** 1 to 3650 days, or null for the 90 day default. */
         auditRetentionDays?: number | null;
     }): Promise<BroodsAccount | null>;
     /**
-     * Exchange a role for a short-lived `bsts_` session token. Callable with
-     * the account key, a CLI login token, or a runtime key (the latter
-     * only into roles scoped to the key's own project/stage). Construct a new
-     * client with `{ sessionToken: result.token }` to act as the role.
+     * A runtime key may assume only roles scoped to its own project and stage.
+     * Act as the role with `new BroodsAccountClient({ sessionToken: result.token })`.
      */
     assumeRole(roleId: string, options?: {
         ttlSeconds?: number;
     }): Promise<AssumeRoleResult>;
-    /** Rotate the account key. The returned `secret` is the new key, shown once, and the current key stops working immediately, so persist it before the process exits. */
+    /** The old key dies at once and `secret` is shown only once: persist it before exiting. */
     rotateSecret(): Promise<RotateSecretResult>;
-    /** Delete this account and cascade-clean every account-scoped resource. `cleanup` reports per-resource deletion counts. */
     deleteAccount(): Promise<DeleteAccountResult>;
-    /**
-     * Provider webhook URL for one of the account's channels. Paste this into the
-     * provider's webhook settings (Slack Event Subscriptions, Zalo OA webhook,
-     * Pancake page webhook). Routing is per account + channel: the credentials
-     * that verify the request pick the receiving agent, and a channel record
-     * binds each place to the agent that should answer there.
-     */
+    /** One URL per account and channel type; the credentials that verify a request pick the agent. */
     webhookUrl(accountId: string, channelType: string): string;
     listAgents(): Promise<AccountAgent[]>;
     createAgent(input: {
@@ -2328,31 +1661,22 @@ declare class BroodsAccountClient {
         config: AgentConfig;
     }): Promise<CreateAgentResult>;
     getAgent(agentId: string): Promise<AccountAgent | null>;
-    /** PATCH an agent. `config` deep-merges into the stored config; `null` leaves delete keys. Returns null when the agent is gone. */
     updateAgent(agentId: string, patch: UpdateAgentInput): Promise<AccountAgent | null>;
     deleteAgent(agentId: string): Promise<boolean>;
-    /** List account environment variable names and update timestamps; values are never returned. */
     listEnvVars(): Promise<AccountEnvVar[]>;
-    /** Create or replace one write-only account environment variable. */
     setEnvVar(name: string, value: string): Promise<void>;
-    /** Delete one account environment variable. Returns false when it is already absent. */
     deleteEnvVar(name: string): Promise<boolean>;
-    /** The account's connections (`broods connect`), never their tokens. */
     listConnections(): Promise<Connection[]>;
-    /** The account's connection of one type, or null when there is none. */
     getConnection(type: ConnectionType): Promise<Connection | null>;
-    /** Starts a sign-in: the provider's consent screen for `broods connect` to open. */
     startConnection(type: ConnectionType, start: ConnectionStart): Promise<ConnectionStartResult>;
-    /** Finishes a sign-in with the code the browser brought back; the deployment keeps the tokens. */
     connect(type: ConnectionType, code: ConnectionCode): Promise<Connection>;
-    /** Forget a connection and revoke it at the provider. False when there was none. */
     disconnect(type: ConnectionType): Promise<boolean>;
     listCrons(): Promise<Cron[]>;
     createCron(input: CreateCronInput): Promise<Cron>;
     getCron(cronId: string): Promise<Cron | null>;
     updateCron(cronId: string, patch: UpdateCronInput): Promise<Cron | null>;
     deleteCron(cronId: string): Promise<boolean>;
-    /** Run history for a cron, newest first. Returns [] when the cron is gone. */
+    /** Newest first. */
     listCronRuns(cronId: string, options?: {
         limit?: number;
     }): Promise<CronRun[]>;
@@ -2369,19 +1693,14 @@ declare class BroodsAccountClient {
         config?: ConfigPatch<WorkspaceConfig>;
     }): Promise<AccountWorkspace | null>;
     deleteWorkspace(workspaceId: string): Promise<boolean>;
-    /** Flat listing of every file in the workspace's S3-backed filesystem. Returns [] when the workspace is gone. */
     listWorkspaceFiles(workspaceId: string): Promise<WorkspaceFileEntry[]>;
-    /** Short-lived download URL for one workspace file. Returns null when the workspace or file is gone. */
     getWorkspaceFileUrl(workspaceId: string, path: string): Promise<string | null>;
-    /** Upload or replace one workspace file from base64 content. Throws when the workspace is gone (404). */
     uploadWorkspaceFile(workspaceId: string, input: {
         path: string;
         contentBase64: string;
         contentType?: string;
     }): Promise<WorkspaceFileEntry>;
-    /** Rename a workspace file or folder. Returns how many objects moved; throws when the workspace or source path is gone. */
     renameWorkspaceFile(workspaceId: string, path: string, newPath: string): Promise<number>;
-    /** Delete a workspace file or folder. Returns how many objects were deleted, 0 when the workspace or path is gone. */
     deleteWorkspaceFile(workspaceId: string, path: string): Promise<number>;
     listSandboxes(): Promise<AccountSandbox[]>;
     createSandbox(input: {
@@ -2390,30 +1709,24 @@ declare class BroodsAccountClient {
         config?: SandboxConfig;
     }): Promise<AccountSandbox>;
     getSandbox(sandboxId: string): Promise<AccountSandbox | null>;
-    /** PATCH a sandbox config. `config` deep-merges into the stored config; `null` leaves delete keys. Returns null when the sandbox is gone. */
     updateSandbox(sandboxId: string, patch: {
         name?: string;
         description?: string | null;
         config?: ConfigPatch<SandboxConfig>;
     }): Promise<AccountSandbox | null>;
     deleteSandbox(sandboxId: string): Promise<boolean>;
-    /** Suspend a persistent sandbox reservation. Throws on 404/403/409 (missing sandbox, foreign reservation, or unsupported provider). */
     suspendSandbox(sandboxId: string, reservationKey: string): Promise<SandboxLifecycleResult>;
-    /** Resume a persistent sandbox reservation. Throws on 404/403/409. */
     resumeSandbox(sandboxId: string, reservationKey: string): Promise<SandboxLifecycleResult>;
-    /** Terminate a persistent sandbox reservation and drop its live-instance row. Throws on 404/403/409. */
     terminateSandbox(sandboxId: string, reservationKey: string): Promise<SandboxLifecycleResult>;
-    /** Snapshot a persistent sandbox reservation into an image any sandbox of that provider on the same stage can pin with `snapshot` (`sandbox`, `daytona`, `e2b`, `vercel`, or `lambda`, which answers `building` until its image build lands). The snapshot is locked to the stage of the sandbox it was taken from: pinning it on another stage throws a 400. Throws on 404/403/409. */
+    /**
+     * Providers `sandbox`, `daytona`, `e2b`, `vercel` and `lambda` (`building` until its image
+     * lands). Only the source stage may pin the snapshot; any other stage gets a 400.
+     */
     snapshotSandbox(sandboxId: string, reservationKey: string, name: string): Promise<SandboxSnapshotResult>;
-    /** Mint a short-lived sealed ticket for an interactive PTY session on a persistent sandbox (`sandbox`/`lambda`/`cloudflare` providers). Throws on 404/403/409. */
+    /** Providers `sandbox`, `lambda` and `cloudflare` only. */
     openSandboxTerminal(sandboxId: string, reservationKey: string): Promise<SandboxTerminalTicket>;
-    /** MCP servers live in one stage, so the collection routes need a scope. */
     listMcp(scope: StageScope): Promise<AccountMcp[]>;
     createMcp(scope: StageScope, input: CreateMcpInput): Promise<AccountMcp>;
-    /**
-     * Upload a hosted MCP bundle too large for the JSON body; returns the
-     * `bundleStorageId` + `sha256` pair `createMcp`/`updateMcp` accept.
-     */
     uploadMcpBundle(bundle: string): Promise<{
         bundleStorageId: string;
         sha256: string;
@@ -2428,7 +1741,6 @@ declare class BroodsAccountClient {
         document: PolicyDocument;
     }): Promise<AccountPolicy>;
     getPolicy(policyId: string): Promise<AccountPolicy | null>;
-    /** PATCH a policy. `description: null` clears it. Returns null when the policy is gone. */
     updatePolicy(policyId: string, patch: {
         name?: string;
         description?: string | null;
@@ -2436,9 +1748,8 @@ declare class BroodsAccountClient {
         status?: string;
     }): Promise<AccountPolicy | null>;
     deletePolicy(policyId: string): Promise<boolean>;
-    /** Roles are account-secret only: a session cannot list, mint, or edit roles. */
+    /** Roles need the account key: a session cannot list, mint, or edit them. */
     listRoles(): Promise<AccountRole[]>;
-    /** Create a role whose policy uses the API action namespace. `projectId`/`stageId` must be provided together. */
     createRole(input: {
         name: string;
         policy: PolicyDocument;
@@ -2446,41 +1757,36 @@ declare class BroodsAccountClient {
         stageId?: string;
     }): Promise<AccountRole>;
     getRole(roleId: string): Promise<AccountRole | null>;
-    /** PATCH a role. `status: "disabled"` kills every live session of the role. Returns null when the role is gone. */
+    /** `status: "disabled"` kills every live session of the role. */
     updateRole(roleId: string, patch: {
         name?: string;
         policy?: PolicyDocument;
         status?: "active" | "disabled";
     }): Promise<AccountRole | null>;
     deleteRole(roleId: string): Promise<boolean>;
-    /** The audit ledger: rows since a seq, chain verification, and the webhook sink. */
     readonly audit: {
-        /** Rows with `seq > since`, oldest first, at most `limit` (default 100, max 500). */
+        /** Rows with `seq > since`, oldest first; `limit` defaults to 100, max 500. */
         list: (options?: {
             since?: number;
             limit?: number;
         }) => Promise<AuditPage>;
         /**
-         * Recompute the chain over `[fromSeq, toSeq]`, from the oldest kept row by
-         * default, at most 1000 rows per call. `ok` covers only `checkedFrom` to
-         * `checkedTo`; on a longer ledger call again with `fromSeq: checkedTo + 1`.
+         * At most 1000 rows per call: `ok` covers only `checkedFrom` to `checkedTo`, so on a longer
+         * ledger call again with `fromSeq: checkedTo + 1`.
          */
         verify: (options?: {
             fromSeq?: number;
             toSeq?: number;
         }) => Promise<AuditVerification>;
-        /** The account's sink, or null when none is set. */
         getSink: () => Promise<AuditSink | null>;
-        /** Set the one webhook sink. `url` must be public https; `secret` signs each batch. */
+        /** `url` must be public https; `secret` signs each batch. */
         setSink: (input: {
             url: string;
             secret: string;
         }) => Promise<AuditSink>;
-        /** Remove the sink; exports stop and rows age out on retention alone. Returns whether one existed. */
         deleteSink: () => Promise<boolean>;
     };
     listChannels(): Promise<AccountChannel[]>;
-    /** Bind one real chat channel to an agent. One active record per place. */
     createChannel(input: {
         platform: string;
         externalId: string;
@@ -2490,7 +1796,6 @@ declare class BroodsAccountClient {
         config: ChannelRecordConfig;
     }): Promise<AccountChannel>;
     getChannel(channelId: string): Promise<AccountChannel | null>;
-    /** PATCH a channel. `description: null` clears it. Returns null when it is gone. */
     updateChannel(channelId: string, patch: {
         name?: string;
         description?: string | null;
@@ -2499,24 +1804,15 @@ declare class BroodsAccountClient {
         status?: "active" | "deleted";
     }): Promise<AccountChannel | null>;
     deleteChannel(channelId: string): Promise<boolean>;
-    /** All skills for the account, each with its `<accountId>/<name>` path. */
     listSkills(): Promise<Skill[]>;
-    /** Upload a new skill from JSON content, a base64 file bundle, or a GitHub tree URL. Every bundle must include a root `SKILL.md`. */
     createSkill(input: SkillUploadInput): Promise<Skill>;
     getSkill(skillName: string): Promise<Skill | null>;
-    /** Replace a skill's bundle in place (`PUT`). Throws when the skill is gone (404). */
     uploadSkill(skillName: string, input: SkillUploadInput): Promise<Skill>;
     deleteSkill(skillName: string): Promise<boolean>;
-    /** POST a sandbox lifecycle action, throwing on any non-2xx (including 404, since these are not upsert flows). */
     private sandboxAction;
     private request;
 }
 
-/**
- * WebSocket client for deployed-agent endpoints.
- * Uses the gateway URL when configured, or derives one from the core service URL.
- */
-
 type WebSocketRunInput = {
     agent?: AgentReference;
     agentId?: string;
@@ -2543,12 +1839,10 @@ type WebSocketAttachInput = Omit<WebSocketClientAttachMessage, "type"> & {
 };
 interface WebSocketHandlers {
     /**
-     * Receives every server message with durable output envelopes unwrapped:
-     * stream parts arrive as themselves (`message.type === "text-delta"`), never
-     * nested under `data`. Use `onOutput` when the envelope cursor is needed.
+     * Every server message with output envelopes unwrapped: a stream part arrives as itself
+     * (`message.type === "text-delta"`), never under `data`. `onOutput` gets the cursor.
      */
     onMessage?(message: WebSocketServerMessage): void;
-    /** Receives the raw durable output envelope (cursor, replay flag, part). */
     onOutput?(output: WebSocketOutputMessage): void;
     onMeta?(meta: Extract<WebSocketServerMessage, {
         type: "meta";
@@ -2564,15 +1858,14 @@ interface WebSocketSubscription {
 interface BroodsWebSocketClientOptions {
     /** Base URL of the core service. Use `https://...`; the client converts it to `wss://...`. */
     baseUrl?: string;
-    /** Hostname or URL of the core service. `gateway.broods.app` becomes `https://gateway.broods.app`. */
+    /** Hostname or URL of the core service, e.g. `gateway.broods.app`; `https://` is added. */
     host?: string;
-    /** Runtime key used as the WebSocket token. Defaults to BROODS_API_KEY from the environment or local .env files. */
+    /** Runtime key sent as the WebSocket token. Defaults to BROODS_API_KEY (env or .env files). */
     apiKey?: string;
     /**
-     * The signed-in user's token (from `signUserToken` on your backend). Each
-     * socket carries it from its upgrade on; an agent that requires one refuses
-     * the runtime key without it. Tokens are short-lived, so a long-lived client
-     * passes a fresh one per run as `userToken` on the input instead.
+     * The signed-in user's token from `signUserToken`; an agent that requires one refuses the
+     * runtime key without it. Tokens are short-lived: a long-lived client passes a fresh one
+     * per run as the input's `userToken` instead.
      */
     userToken?: string;
     WebSocket?: WebSocketConstructorLike;
@@ -2610,20 +1903,8 @@ declare class BroodsWebSocketClient {
     private resolveWebSocket;
 }
 declare function toWebSocketBaseUrl(url: string): string;
-/**
- * The credential travels as a `Sec-WebSocket-Protocol` entry rather than in
- * the URL, so it never lands in proxy or access logs, and so does the user
- * token. The gateway answers with `broods.v1`, which is what completes a
- * handshake that offered subprotocols.
- */
 declare function webSocketSubprotocols(apiKey: string, userToken?: string): string[];
 
-/**
- * Resource definition helpers for the code-first `broods/` project folder.
- *
- * Every runtime function here is synchronous.
- */
-
 declare const RESOURCE_MARKER: unique symbol;
 declare const CONFIG_MARKER: unique symbol;
 declare const CONNECTION_MARKER: unique symbol;
@@ -2631,7 +1912,6 @@ interface EnvRef<Name extends string = string> {
     readonly __beeblastEnv: true;
     readonly name: Name;
 }
-/** Callable accessor for {@link env}. */
 interface EnvAccessor {
     <const Name extends string>(name: Name): EnvRef<Name>;
 }
@@ -2646,7 +1926,6 @@ interface BroodsProjectConfig {
         [name: string]: string | undefined;
     };
     dashboardUrl?: string;
-    /** Convex control-plane base URL for sync/env calls; defaults to the URL discovered at login. */
     baseUrl?: string;
 }
 interface BroodsConfigDefinition {
@@ -2661,143 +1940,67 @@ interface ResourceDefinition<Kind extends ResourceKind, Name extends string, Con
     readonly description?: string;
     readonly config: Config;
 }
-/**
- * Authoring shape for every resource helper: the resource's own `name` (plus an
- * optional human `description`) sits inline with that resource's config keys.
- */
 type ResourceInput<Name extends string, Config> = {
     name: Name;
     description?: string;
 } & Config;
-/**
- * Provider-specific sandbox knobs. `reservationKey` names the reserved machine a
- * `persistent` sandbox reconnects to when no workspace is mounted; unset, each
- * agent gets its own, and pinning one string on two sandboxes shares a machine.
- * Keys are scoped to the account, so they cannot reach another account's machine.
- * A `custom` sandbox names its server with `endpoint` (https, required), an
- * optional bearer `token` and extra static `headers`; a credential header's
- * value is an `env("NAME")` ref.
- */
 type SandboxDefinitionOptions = Record<string, unknown> & {
+    /** The machine a `persistent` sandbox reconnects to; one key on two sandboxes shares it. */
     reservationKey?: string;
-    /** daytona: mount workspaces (its snapshot must ship mount-s3). sandbox: mount even with no workspace. */
+    /** daytona: mount workspaces (snapshot needs mount-s3); sandbox: mount even without one. */
     mountAwsS3Buckets?: boolean;
+    /** `custom` sandbox: its https server, with a bearer `token` and `env()` credential headers. */
     endpoint?: string;
     token?: string | EnvRef;
     headers?: Record<string, string | EnvRef>;
 };
-/**
- * Code-first sandbox config input. Mirrors core's `SandboxConfig` but lets
- * `envVars` values be `env("NAME")` references (compiled to `${NAME}` placeholders
- * at sync time, exactly like provider `apiKey`). Add overrides here if more
- * sandbox fields should accept env refs.
- */
 type SandboxDefinitionConfig = Omit<SandboxConfig, "envVars" | "options"> & {
     envVars?: Record<string, string | EnvRef | undefined>;
     options?: SandboxDefinitionOptions;
 };
 type HarnessType = NonNullable<AgentConfig["harness"]>["type"];
-/** Harness settings. The harness runs on the agent's first sandbox. */
 type HarnessDefinition = NonNullable<AgentConfig["harness"]>;
 interface SkillDefinitionConfig {
-    /**
-     * Folder containing SKILL.md plus optional scripts/assets. Relative paths are
-     * resolved from the `broods/` project directory.
-     */
+    /** Folder holding SKILL.md, relative to the `broods/` project directory. */
     path: string;
 }
 type PolicyDefinitionConfig = Omit<PolicyDocument, "version"> & {
     version?: PolicyDocument["version"];
 };
-/**
- * Fetch-style MCP handler for a hosted server: what
- * `createMcpHandler(...)` from @modelcontextprotocol/server returns: either
- * the request function itself or an object exposing it as `fetch`.
- */
 type McpHandler = ((request: Request) => Response | Promise<Response>) | {
     fetch(request: Request): Response | Promise<Response>;
 };
-/**
- * MCP server registration (#331): external (`url`), hosted (`handler`), or on
- * a sandbox (`sandbox`). Either way the server's tools are offered as
- * `<name>__<tool>`; an external row is dialed over the stateless HTTP
- * transport (spec 2026-07-28) at agent registration time. The name namespaces
- * those tools, so it must be 1-32 lowercase letters, digits, or hyphens,
- * starting with a letter.
- */
+/** Tools are offered as `<name>__<tool>`: the name is 1-32 of a-z, 0-9, "-", letter first. */
 interface McpDefinitionConfig {
-    /** External server's MCP endpoint; http(s), no embedded credentials. */
     url?: string;
-    /**
-     * Instead of `url` or `handler`: the sandbox that runs this server. On a
-     * machine sandbox its daemon runs the entry with the same name in its
-     * `--mcp` file; on a lambda sandbox the VM runs `command`.
-     */
+    /** A machine sandbox runs its `--mcp` file's entry of this name; a lambda one runs `command`. */
     sandbox?: SandboxResource | string;
-    /**
-     * Argv of the stdio server, required when `sandbox` is a lambda sandbox,
-     * e.g. `["obscura", "mcp"]`. A machine sandbox's daemon ignores it.
-     */
     command?: string[];
-    /**
-     * Hosted alternative to `url`: declare the server inline as
-     * `handler: createMcpHandler(factory, { legacy: "reject" })` from
-     * @modelcontextprotocol/server, right next to the `defineMcp` call; Broods
-     * speaks MCP 2026-07-28 only. The CLI bundles the defining module
-     * and the platform hosts it, one invocation per batch of requests: with
-     * `runtime` "auto" on Cloudflare Workers when the bundle builds for them,
-     * on Lambda otherwise.
-     */
+    /** Hosted: `createMcpHandler(factory, { legacy: "reject" })`; MCP 2026-07-28 only. */
     handler?: McpHandler;
-    /**
-     * Hosted servers only. "auto" (the default) runs the handler on Cloudflare
-     * Workers when it builds for them; "lambda" always ships the Node build to
-     * Lambda, for a server that needs Node APIs Workers lack.
-     */
+    /** "auto" runs on Workers when the bundle builds for them; "lambda" ships the Node build. */
     runtime?: McpRuntime;
-    /**
-     * Extra request headers. Credential-bearing headers (Authorization,
-     * X-Api-Key, ...) must reference an account env var by name inside a plain
-     * string, e.g. `"Bearer ${TOKEN}"`. `env()` returns an object, so a template
-     * literal around it sends `[object Object]`. Never carry an inline secret.
-     */
+    /** A credential header names an env var in a plain string, `"Bearer ${TOKEN}"`, never `env()`. */
     headers?: Record<string, string>;
-    /**
-     * OAuth 2.0 refresh-token grant for an external server whose access tokens
-     * expire (Google's Workspace MCP endpoints). The runtime mints, caches and
-     * refreshes access tokens and sends `Authorization: Bearer <token>` itself,
-     * so do not also set an Authorization header. `clientSecret` and
-     * `refreshToken` must be `env("NAME")` refs; `tokenUrl` defaults to
-     * https://oauth2.googleapis.com/token.
-     */
+    /** The runtime sends the bearer itself: set no Authorization header. Secrets are `env()`. */
     oauth?: {
         clientId: string | EnvRef;
         clientSecret: string | EnvRef;
         refreshToken: string | EnvRef;
         tokenUrl?: string;
     };
-    /** Tool names agents may use from this server; omit to allow all. */
     allowedTools?: string[];
 }
-type ChannelType = "telegram" | "gchat" | "github" | "linear" | "slack" | "discord" | "matrix" | "pancake" | "teams" | "twilio" | "zalo" | "whatsapp" | "instagram" | "messenger";
-/**
- * A connection is one app install: the credentials an agent needs before a
- * provider can reach it at all. Channels point at a connection; a connection
- * never points back, which is what keeps the reference graph acyclic.
- */
+type ChannelType = "telegram" | "gchat" | "github" | "linear" | "slack" | "discord" | "pancake" | "teams" | "twilio" | "zalo" | "whatsapp" | "instagram" | "messenger";
+/** One app install. Channels point at it and it never points back, so references stay acyclic. */
 interface ConnectionDefinition<Type extends ChannelType, Config> {
     readonly [CONNECTION_MARKER]: true;
     readonly kind: "connection";
     readonly type: Type;
     readonly partition?: ChannelPartition;
-    /** `partition` is lifted out of the authored input, so it is not in here. */
     readonly config: Omit<Config, "partition">;
 }
-/**
- * An agent bound to a channel. Every bound agent runs when a message arrives;
- * `reply: false` runs it with a silenced channel, so it can work without
- * speaking in the room.
- */
+/** Every bound agent runs; `reply: false` runs it without speaking in the room. */
 type ChannelAgentInput = AgentResource | {
     agent: AgentResource;
     reply?: boolean;
@@ -2805,16 +2008,10 @@ type ChannelAgentInput = AgentResource | {
 type RequiredChannelKeys<Config, Keys extends keyof Config> = Required<Pick<Config, Keys>> & Omit<Config, Keys>;
 type ChannelSecret = string | EnvRef | undefined;
 type ConnectionIdentityInput = {
-    /** Include the dashboard trace link in channel replies. Off by default. */
     trace?: "enabled" | "disabled";
     partition?: ChannelPartition;
-    /**
-     * Rooms this connection answers in, on top of every channel declared against
-     * it. Use `["*"]` to answer everywhere instead, which is the only reason to
-     * name rooms here at all: a room with rules belongs in a channel resource.
-     */
+    /** Rooms beyond its channels'; `["*"]` answers everywhere. A room with rules is a channel. */
     allowedChannelIds?: readonly string[];
-    /** Provider user ids allowed to trigger the agent. `["*"]` or omitted is everyone. */
     allowedUserIds?: readonly string[];
 };
 type TelegramConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentTelegramChannelConfig, "apiUrl" | "botToken" | "webhookSecret" | "botUsername" | "reactionEmoji">, "botToken" | "webhookSecret">> & ConnectionIdentityInput;
@@ -2823,7 +2020,6 @@ type GitHubConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentGitHubCh
 type LinearConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentLinearChannelConfig, "apiKey" | "apiUrl" | "userName" | "webhookSecret">, "apiKey" | "userName" | "webhookSecret">> & ConnectionIdentityInput;
 type SlackConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentSlackChannelConfig, "apiUrl" | "botToken" | "signingSecret" | "reactionEmoji">, "botToken" | "signingSecret">> & ConnectionIdentityInput;
 type DiscordConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentDiscordChannelConfig, "apiUrl" | "botToken" | "publicKey" | "botUserId" | "mentionRoleIds">, "botToken" | "publicKey">> & ConnectionIdentityInput;
-type MatrixConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentMatrixChannelConfig, "apiUrl" | "botToken" | "botName" | "mentionText">, "apiUrl" | "botToken">> & ConnectionIdentityInput;
 type TeamsConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentTeamsChannelConfig, "apiUrl" | "appId" | "appPassword" | "appTenantId" | "appType" | "userName">, "appId" | "appPassword">> & ConnectionIdentityInput;
 type WhatsAppConnectionInput = EnvRefString<RequiredChannelKeys<Pick<AgentWhatsAppChannelConfig, "accessToken" | "apiUrl" | "apiVersion" | "appSecret" | "phoneNumberId" | "userName" | "verifyToken">, "accessToken" | "appSecret" | "phoneNumberId" | "verifyToken">> & ConnectionIdentityInput;
 interface PancakeConnectionInput extends ConnectionIdentityInput {
@@ -2845,7 +2041,6 @@ type GitHubConnectionDefinition = ConnectionDefinition<"github", GitHubConnectio
 type LinearConnectionDefinition = ConnectionDefinition<"linear", LinearConnectionInput>;
 type SlackConnectionDefinition = ConnectionDefinition<"slack", SlackConnectionInput>;
 type DiscordConnectionDefinition = ConnectionDefinition<"discord", DiscordConnectionInput>;
-type MatrixConnectionDefinition = ConnectionDefinition<"matrix", MatrixConnectionInput>;
 type PancakeConnectionDefinition = ConnectionDefinition<"pancake", PancakeConnectionInput>;
 type TeamsConnectionDefinition = ConnectionDefinition<"teams", TeamsConnectionInput>;
 type TwilioConnectionDefinition = ConnectionDefinition<"twilio", TwilioConnectionInput>;
@@ -2853,32 +2048,18 @@ type ZaloConnectionDefinition = ConnectionDefinition<"zalo", ZaloConnectionInput
 type InstagramConnectionDefinition = ConnectionDefinition<"instagram", InstagramConnectionInput>;
 type MessengerConnectionDefinition = ConnectionDefinition<"messenger", MessengerConnectionInput>;
 type WhatsAppConnectionDefinition = ConnectionDefinition<"whatsapp", WhatsAppConnectionInput>;
-type AnyConnectionDefinition = TelegramConnectionDefinition | GoogleChatConnectionDefinition | GitHubConnectionDefinition | LinearConnectionDefinition | SlackConnectionDefinition | DiscordConnectionDefinition | MatrixConnectionDefinition | PancakeConnectionDefinition | TeamsConnectionDefinition | TwilioConnectionDefinition | ZaloConnectionDefinition | WhatsAppConnectionDefinition | InstagramConnectionDefinition | MessengerConnectionDefinition;
-/**
- * One real place a team talks: a Slack channel, a Discord channel, a repo. It
- * narrows and adds, and never grants what a bound agent lacks: instructions
- * append, policies union, tools and workspaces only narrow. It names the
- * connection it belongs to, so `platform` is never written by hand.
- */
+type AnyConnectionDefinition = TelegramConnectionDefinition | GoogleChatConnectionDefinition | GitHubConnectionDefinition | LinearConnectionDefinition | SlackConnectionDefinition | DiscordConnectionDefinition | PancakeConnectionDefinition | TeamsConnectionDefinition | TwilioConnectionDefinition | ZaloConnectionDefinition | WhatsAppConnectionDefinition | InstagramConnectionDefinition | MessengerConnectionDefinition;
+/** Never grants what a bound agent lacks: instructions append, policies union, the rest narrows. */
 type ChannelDefinitionConfig = {
     connection: AnyConnectionDefinition;
-    /**
-     * Provider id of the place, from the per-platform field on the input. A list
-     * fans out to one record per id at deploy time.
-     */
     externalId: string | readonly string[];
-    /** Team, guild or repo owner the place sits in, when the provider has one. */
     workspaceRef?: string;
-    /** Every one of these runs. Omit and the connection's own agent answers. */
+    /** Omit and the connection's own agent answers. */
     agents?: readonly ChannelAgentInput[];
-    /** Appended after each agent's own system prompt, never replacing it. */
     instructions?: string;
-    /** Selects from what the agent already attaches; anything else is dropped. */
     workspaces?: readonly AgentWorkspaceInput[];
-    /** Added to whatever the agent already carries. Each policy holds its own mode. */
     policies?: readonly (PolicyResource | string)[];
     denyTools?: readonly string[];
-    /** Where the reply lands. Slack only. */
     replyIn?: ChannelReplyIn;
     partition?: ChannelPartition;
     sandboxImages?: readonly string[];
@@ -2887,102 +2068,76 @@ type ChannelDefinitionConfig = {
         userIds: readonly string[];
     }[];
 };
-/** Rules shared by every channel, whatever the provider calls its rooms. */
 type ChannelRulesInput = Omit<ChannelDefinitionConfig, "connection" | "externalId" | "workspaceRef" | "replyIn">;
 type SlackChannelInput = ChannelRulesInput & {
     connection: SlackConnectionDefinition;
-    /** Slack channel id, e.g. "C0123ABCD". */
+    /** e.g. "C0123ABCD". */
     channelId: string;
-    /** Slack team id the channel sits in. */
     teamId?: string;
-    /** Where the reply lands. Slack is the only provider with a choice. */
     replyIn?: ChannelReplyIn;
 };
 type DiscordChannelInput = ChannelRulesInput & {
     connection: DiscordConnectionDefinition;
-    /** Discord channel id (a snowflake). */
     channelId: string;
-    /** Guild the channel sits in. */
     guildId?: string;
 };
-type MatrixChannelInput = ChannelRulesInput & {
-    connection: MatrixConnectionDefinition;
-    /** Matrix room id, e.g. "!abc123:matrix.org". */
-    channelId: string;
-};
 type GoogleChatChannelInput = ChannelRulesInput & {
     connection: GoogleChatConnectionDefinition;
-    /** Google Chat space name, e.g. "spaces/AAAAxxxx". */
+    /** e.g. "spaces/AAAAxxxx". */
     spaceName: string;
 };
 type GitHubChannelInput = ChannelRulesInput & {
     connection: GitHubConnectionDefinition;
-    /** Repository full name, e.g. "beeblast/api". */
+    /** "owner/name". */
     repo: string;
 };
 type LinearChannelInput = ChannelRulesInput & {
     connection: LinearConnectionDefinition;
-    /** Team key, e.g. "ENG", or several that share one set of rules. */
+    /** Team key, e.g. "ENG". */
     team: string | readonly string[];
 };
 type TeamsChannelInput = ChannelRulesInput & {
     connection: TeamsConnectionDefinition;
-    /** Teams channel id, or a chat's conversation id, e.g. "19:abc@thread.tacv2". */
+    /** Channel or chat conversation id, e.g. "19:abc@thread.tacv2". */
     channelId: string;
-    /** Team the channel sits in. */
     teamId?: string;
 };
 type TelegramChannelInput = ChannelRulesInput & {
     connection: TelegramConnectionDefinition;
-    /** Telegram chat id, e.g. "-1001234567". */
     chatId: string;
 };
 type TwilioChannelInput = ChannelRulesInput & {
     connection: TwilioConnectionDefinition;
-    /** Sender's number in E.164, e.g. "+15551234567", or several. */
+    /** Sender's number in E.164, e.g. "+15551234567". */
     from: string | readonly string[];
 };
 type ZaloChannelInput = ChannelRulesInput & {
     connection: ZaloConnectionDefinition;
-    /** Zalo user or group chat id, or several that share one set of rules. */
     chatId: string | readonly string[];
 };
 type InstagramChannelInput = ChannelRulesInput & {
     connection: InstagramConnectionDefinition;
-    /** Instagram-scoped id (IGSID) of the person, or several. */
     igsid: string | readonly string[];
 };
 type MessengerChannelInput = ChannelRulesInput & {
     connection: MessengerConnectionDefinition;
-    /** Page-scoped id (PSID) of the person, or several. */
     psid: string | readonly string[];
 };
 type WhatsAppChannelInput = ChannelRulesInput & {
     connection: WhatsAppConnectionDefinition;
-    /** Customer's WhatsApp id, their number with country code and no "+", or several. */
+    /** The number with country code and no "+". */
     waId: string | readonly string[];
 };
 type PancakeChannelInput = ChannelRulesInput & {
     connection: PancakeConnectionDefinition;
-    /** Pancake conversation id. */
     conversationId: string;
 };
-/**
- * Per-agent workspace mount with an optional sandbox override. A bare
- * `defineWorkspace(...)` inherits the agent's first sandbox; the object form lets
- * a single workspace pin its own sandbox, or set `sandbox: null` to force the
- * workspace read-only (no compute attached).
- */
 interface AgentWorkspaceRefInput {
     workspace: WorkspaceResource | string;
+    /** Omit for the agent's first sandbox; `null` mounts it read-only, with no compute. */
     sandbox?: SandboxResource | string | null;
 }
 type AgentWorkspaceInput = WorkspaceResource | AgentWorkspaceRefInput;
-/**
- * `subagent` block where `allowed` may reference other `defineAgent(...)`
- * resources directly; the compiler rewrites them to agent names and the backend
- * resolves those to deploy-time agent ids.
- */
 type AgentSubagentDefinitionConfig = Omit<NonNullable<AgentConfig["subagent"]>, "allowed"> & {
     allowed?: readonly (AgentResource | string)[];
 };
@@ -2991,31 +2146,21 @@ type AgentSkillsDefinitionConfig = Omit<NonNullable<AgentConfig["skills"]>, "all
 };
 interface HookContext {
     fetch: typeof fetch;
-    /** The model and the names of the agent's tools, MCP servers, channels, skills and subagents. Never credentials. */
+    /** The model and the agent's tool, server, channel, skill and subagent names; no credentials. */
     config: HookAgentConfig;
     /**
-     * Mutable per-request scratchpad shared across this agent request's hooks.
-     * Seed it in an early hook (e.g. `onStart`) and read or modify it later.
-     * Every loop hook, `onSubagentFinish`, and the reply's `onMessageSending`
-     * see the same state. Keep it JSON-serializable. `onMessageReceived`,
-     * delayed background replies, and each subagent's own run get fresh state.
+     * Shared by one request's hooks; keep it JSON-serializable. `onMessageReceived`, delayed
+     * replies and each subagent's own run start fresh.
      */
     state: Record<string, unknown>;
 }
 type Handler<Event, Result> = (ctx: HookContext, event: Event) => Result | void | Promise<Result | void>;
-/**
- * Channel-specific routing data attached to an inbound message. Inherited from
- * the core channel adapters (via contracts.ts) so an `onMessageReceived` hook
- * that narrows on `event.channel` always sees exactly what core emits (e.g.
- * Pancake `tagIds`).
- */
 type TelegramMessageSource = TelegramSource;
 type GoogleChatMessageSource = GoogleChatSource;
 type GitHubMessageSource = GitHubSource;
 type LinearMessageSource = LinearSource;
 type SlackMessageSource = SlackSource;
 type DiscordMessageSource = DiscordSource;
-type MatrixMessageSource = MatrixSource;
 type PancakeMessageSource = PancakeSource;
 type TeamsMessageSource = TeamsSource;
 type TwilioMessageSource = TwilioSource;
@@ -3023,10 +2168,6 @@ type ZaloMessageSource = ZaloSource;
 type InstagramMessageSource = InstagramSource;
 type MessengerMessageSource = MessengerSource;
 type WhatsAppMessageSource = WhatsAppSource;
-/**
- * Inbound channel message passed to `onMessageReceived`, discriminated on
- * `channel` so each variant exposes its channel's strongly-typed `source`.
- */
 type ChannelMessageReceived = {
     channel: "telegram";
     text: string;
@@ -3051,10 +2192,6 @@ type ChannelMessageReceived = {
     channel: "discord";
     text: string;
     source: DiscordMessageSource;
-} | {
-    channel: "matrix";
-    text: string;
-    source: MatrixMessageSource;
 } | {
     channel: "pancake";
     text: string;
@@ -3085,15 +2222,9 @@ type ChannelMessageReceived = {
     source: MessengerMessageSource;
 };
 /**
- * Inline agent hook callbacks. Handlers are serialized with `.toString()`,
- * bundled into one account hook, and run in a fresh V8 isolate. Keep them
- * self-contained: use only `ctx`, `event`, and JavaScript globals. Do not rely
- * on imports or closure variables. Arrow functions and function expressions are
- * preferred so the serialized source is valid as an object-literal value.
- *
- * Subagent runs fire hooks too: a registered subagent runs its own hooks, a
- * prompt-only (virtual) subagent inherits this bundle, always with fresh
- * `ctx.state`. `onSubagentFinish` fires on the parent with the parent's state.
+ * Serialized with `.toString()` into a fresh V8 isolate: use only `ctx`, `event` and JS globals,
+ * no imports or closures, and prefer arrow functions. A registered subagent runs its own hooks,
+ * a prompt-only one inherits these; `onSubagentFinish` fires on the parent with its state.
  */
 interface AgentHooks {
     onStart?: Handler<{
@@ -3142,6 +2273,7 @@ interface AgentHooks {
     }, {
         visibleResult?: unknown;
     }>;
+    /** Returned `metadata` (opaque JSON) is stored and resurfaces on `onStart`'s messages. */
     onMessageReceived?: Handler<ChannelMessageReceived, {
         drop?: boolean;
         text?: string;
@@ -3155,31 +2287,15 @@ interface AgentHooks {
         text?: string;
     }>;
 }
-/**
- * Code-first agent config input. Built from an explicit `Pick` of `AgentConfig`
- * (not `Omit`) so the SDK input type does NOT inherit `AgentConfig`'s
- * `[key: string]: unknown` index signature, which would otherwise disable
- * TypeScript's excess-property checks and silently accept typos like
- * `workspace:` instead of `workspaces:`. Add a key here when core's `AgentConfig`
- * gains a new top-level field that should be code-definable.
- */
-/**
- * SDK-facing model-provider constructor settings. Open by design: everything a
- * provider's Vercel AI SDK factory accepts is forwarded verbatim, so there is no
- * key list to keep in sync. Only the keys broods reads itself are named (and so
- * typo-checked at run time by `validateProviderConfig`); every string field also
- * accepts an `env("NAME")` reference.
- */
+/** Forwarded verbatim to the provider's AI SDK factory; only the named keys are checked. */
 interface ProviderSettingsInput {
     apiKey?: string | EnvRef;
     base_url?: string | EnvRef;
     baseURL?: string | EnvRef;
-    /** `cloudflare` only: the AI Gateway every request goes through. */
     gatewayId?: string;
     headers?: Record<string, string | EnvRef>;
     [key: string]: unknown;
 }
-/** Per-provider settings; provider names stay synced with core's `AgentConfig`. */
 type ProviderConfigInput = Partial<Record<keyof NonNullable<AgentConfig["provider"]>, ProviderSettingsInput>>;
 type AgentDefinitionConfig = EnvRefString<Pick<AgentConfig, "agent" | "model" | "scheduler" | "browser" | "session" | "tools" | "mcp">> & {
     provider?: ProviderConfigInput;
@@ -3189,50 +2305,30 @@ type AgentDefinitionConfig = EnvRefString<Pick<AgentConfig, "agent" | "model" |
         webhooks?: readonly EnvRefString<AgentWebhookHookConfig>[];
     };
     connections?: readonly AnyConnectionDefinition[];
-    /**
-     * Sandboxes this agent runs on. The first is the default: bash with no
-     * workspace runs there, workspaces without their own sandbox mount it, and a
-     * harness runs on it. The model reaches the others by name.
-     */
+    /** The first runs the harness, bash and any workspace without its own sandbox. */
     sandboxes?: readonly (SandboxResource | string)[];
     workspaces?: readonly AgentWorkspaceInput[];
     subagent?: AgentSubagentDefinitionConfig;
     skills?: AgentSkillsDefinitionConfig;
-    /** Policies that gate this agent. Each one carries its own enforcement mode. */
     policies?: readonly (PolicyResource | string)[];
-    /**
-     * Opt the agent into the public runtime endpoint (SSE/WebSocket via the
-     * runtime key). Off by default: when unset the public endpoint
-     * refuses requests for this agent. Reach a private agent through an
-     * internal endpoint or a channel webhook. See issue #65.
-     */
+    /** Serve this agent on the public runtime endpoint. Off by default. */
     publicAccess?: boolean;
-    /**
-     * Let a runtime-key caller send `system` and `model` overrides on a run. Off
-     * by default: such a run is refused with `403 run_overrides_disabled`.
-     */
+    /** Accept `system` and `model` run overrides; off answers `403 run_overrides_disabled`. */
     allowRunOverrides?: boolean;
 };
 type CronDefinitionConfig = Omit<CreateCronInput, "agentId" | "name"> & {
     agent: AgentResource | string;
 };
 type AgentResource<Name extends string = string> = ResourceDefinition<"agent", Name, AgentDefinitionConfig>;
-/**
- * Code-first workspace config. Says `partitioned` where storage says
- * `isolation`. "conversation" permits a per-conversation split that a
- * channel's `partition` performs; "agent" splits the workspace per attached
- * agent on its own, with no partition needed. R2 keys take `env("NAME")`.
- */
 type WorkspaceDefinitionConfig = Omit<WorkspaceConfig, "isolation" | "storage"> & {
     storage?: WorkspaceStorageDefinition;
-    /** How to split this workspace: per conversation or per agent. */
+    /** "conversation" lets a channel's `partition` split it; "agent" splits it per agent. */
     partitioned?: WorkspaceIsolation;
 };
 type WorkspaceStorageAuthConfig = NonNullable<WorkspaceConfig["storage"]["auth"]>;
 type WorkspaceR2Auth = Extract<WorkspaceStorageAuthConfig, {
     type: "r2";
 }>;
-/** Workspace storage as authored: only the R2 keys take `env()`. */
 type WorkspaceStorageDefinition = Omit<WorkspaceConfig["storage"], "auth"> & {
     auth?: Exclude<WorkspaceStorageAuthConfig, {
         type: "r2";
@@ -3250,29 +2346,11 @@ type CronResource<Name extends string = string> = ResourceDefinition<"cron", Nam
 type ChannelResource<Name extends string = string> = ResourceDefinition<"channelRecord", Name, ChannelDefinitionConfig>;
 type AnyResource = AgentResource | WorkspaceResource | SandboxResource | CronResource | SkillResource | McpResource | PolicyResource | ChannelResource;
 /**
- * References an account/environment variable resolved on the SERVER at runtime.
- * Set it with `broods env set <NAME>` or in the dashboard (the Convex-style
- * `convex env set` model). It is a deferred reference, never read from your local
- * environment and never baked into the deployed config:
- *
- *   apiKey: env("OPENAI_API_KEY")
- *
- * It compiles to a `${NAME}` placeholder the harness fills in at run time. This is
- * NOT `process.env`: agent configs are compiled locally, so `process.env.NAME` would
- * bake the literal local value into the deployed config instead of deferring it.
- *
- * The reference must resolve: syncing a manifest whose `env("NAME")` has no value
- * stored for the stage is rejected outright, so an unset or misspelled name fails
- * the sync instead of reaching the runtime as a literal `${NAME}`. `broods dev`
- * pushes matching `.env.local` values first, so a local value is enough there.
+ * A stage env var (`broods env set NAME`) the server fills in at run time, e.g.
+ * `apiKey: env("OPENAI_API_KEY")`. Not `process.env`, which bakes the local value into the config.
+ * A sync is refused while a referenced name has no stored value; `broods dev` pushes `.env.local`.
  */
 declare const env: EnvAccessor;
-/**
- * Shared builder behind every `define*` helper below. The public helpers are
- * thin, per-kind typed front doors: each pins its `kind` (the discriminant the
- * sync/codegen pipeline switches on) and splits the flat authoring input back
- * into the `{ name, description?, config }` shape the manifest wire format uses.
- */
 declare function defineAgent<const Name extends string>(input: ResourceInput<Name, AgentDefinitionConfig>): AgentResource<Name>;
 declare function defineBroods(config: BroodsProjectConfig): BroodsConfigDefinition;
 declare function defineCron<const Name extends string>(input: ResourceInput<Name, CronDefinitionConfig>): CronResource<Name>;
@@ -3287,7 +2365,6 @@ declare function defineGitHubConnection(config: GitHubConnectionInput): GitHubCo
 declare function defineGoogleChatConnection(config: GoogleChatConnectionInput): GoogleChatConnectionDefinition;
 declare function defineInstagramConnection(config: InstagramConnectionInput): InstagramConnectionDefinition;
 declare function defineLinearConnection(config: LinearConnectionInput): LinearConnectionDefinition;
-declare function defineMatrixConnection(config: MatrixConnectionInput): MatrixConnectionDefinition;
 declare function defineMessengerConnection(config: MessengerConnectionInput): MessengerConnectionDefinition;
 declare function definePancakeConnection(config: PancakeConnectionInput): PancakeConnectionDefinition;
 declare function defineSlackConnection(config: SlackConnectionInput): SlackConnectionDefinition;
@@ -3301,7 +2378,6 @@ declare function defineGitHubChannel<const Name extends string>(input: ResourceI
 declare function defineGoogleChatChannel<const Name extends string>(input: ResourceInput<Name, GoogleChatChannelInput>): ChannelResource<Name>;
 declare function defineInstagramChannel<const Name extends string>(input: ResourceInput<Name, InstagramChannelInput>): ChannelResource<Name>;
 declare function defineLinearChannel<const Name extends string>(input: ResourceInput<Name, LinearChannelInput>): ChannelResource<Name>;
-declare function defineMatrixChannel<const Name extends string>(input: ResourceInput<Name, MatrixChannelInput>): ChannelResource<Name>;
 declare function defineMessengerChannel<const Name extends string>(input: ResourceInput<Name, MessengerChannelInput>): ChannelResource<Name>;
 declare function definePancakeChannel<const Name extends string>(input: ResourceInput<Name, PancakeChannelInput>): ChannelResource<Name>;
 declare function defineSlackChannel<const Name extends string>(input: ResourceInput<Name, SlackChannelInput>): ChannelResource<Name>;
@@ -3314,5 +2390,5 @@ declare function isBroodsConfig(value: unknown): value is BroodsConfigDefinition
 declare function isConnectionDefinition(value: unknown): value is AnyConnectionDefinition;
 declare function isResource(value: unknown): value is AnyResource;
 
-export { BroodsAccountApiError, BroodsAccountClient, BroodsClient, BroodsWebSocketClient, DEFAULT_CORE_BASE_URL, IngressAcceptedError, MAX_OBSERVABILITY_BACKFILL, USER_TOKEN_HEADER, USER_TOKEN_MAX_TTL_MS, USER_TOKEN_SECRET_ENV, BroodsWebSocketClient as WebSocketClient, BroodsWebSocketClient as WebsocketClient, defineAgent, defineBroods, defineCron, defineDiscordChannel, defineDiscordConnection, defineGitHubChannel, defineGitHubConnection, defineGoogleChatChannel, defineGoogleChatConnection, defineHarness, defineInstagramChannel, defineInstagramConnection, defineLinearChannel, defineLinearConnection, defineMatrixChannel, defineMatrixConnection, defineMcp, defineMessengerChannel, defineMessengerConnection, definePancakeChannel, definePancakeConnection, definePolicy, defineSandbox, defineSkill, defineSlackChannel, defineSlackConnection, defineTeamsChannel, defineTeamsConnection, defineTelegramChannel, defineTelegramConnection, defineTwilioChannel, defineTwilioConnection, defineWhatsAppChannel, defineWhatsAppConnection, defineWorkspace, defineZaloChannel, defineZaloConnection, env, envPlaceholder, isBroodsConfig, isConnectionDefinition, isLogLevel, isObservabilityClientMessage, isResource, isRootSpanKind, isSandboxLogId, isTraceId, normalizeHttpServiceUrl, readSseStream, resolveEnvCredential, resolveRunEvents, signUserToken, toWebSocketBaseUrl, webSocketSubprotocols };
-export type { Account, AccountAgent, AccountChannel, AccountEnvVar, AccountMcp, AccountPolicy, AccountRole, AccountSandbox, AccountWorkspace, Agent, AgentChannelsConfig, AgentCodeHookConfig, AgentConfig, AgentConfigDoc, AgentContinueInput, AgentDefinitionConfig, AgentDiscordChannelConfig, AgentGitHubChannelConfig, AgentGoogleChatChannelConfig, AgentHandle, AgentHookEventName, AgentHooks, AgentHooksConfig, AgentInstagramChannelConfig, AgentLinearChannelConfig, AgentMatrixChannelConfig, AgentMessengerChannelConfig, AgentPancakeChannelConfig, AgentProviderSettings, AgentReference, AgentResource, AgentRunAnswerInput, AgentRunEventInput, AgentRunInput, AgentRunModelOverrides, AgentRunOverrides, AgentRunResult, AgentSkillsDefinitionConfig, AgentSlackChannelConfig, AgentStreamPart, AgentSubagentDefinitionConfig, AgentTeamsChannelConfig, AgentTelegramChannelConfig, AgentTwilioChannelConfig, AgentWebhookHookConfig, AgentWhatsAppChannelConfig, AgentWorkspaceInput, AgentWorkspaceRef, AgentWorkspaceRefInput, AgentZaloChannelConfig, AnyConnectionDefinition, AnyResource, AssumeRoleResult, AsyncAgentRun, AsyncPollOptions, AsyncRequestAccepted, AsyncStatus, AuditEvent, AuditPage, AuditPrincipalLink, AuditSink, AuditVerification, BroodsAccount, BroodsAccountClientOptions, BroodsClientOptions, BroodsConfigDefinition, BroodsProjectConfig, BroodsWebSocketClientOptions, ChannelAgentInput, ChannelDefinitionConfig, ChannelMessageReceived, ChannelPartition, ChannelRecordConfig, ChannelReference, ChannelReplyIn, ChannelResource, ChannelType, CliManifest, CliManifestResource, ConfigPatch, Connection, ConnectionCode, ConnectionDefinition, ConnectionStart, ConnectionStartResult, ConnectionType, CreateAgentResult, CreateCronInput, CreateMcpInput, Cron, CronDefinitionConfig, CronDoc, CronLastStatus, CronResource, CronRun, CronStatus, DeleteAccountResult, DeploymentRegion, DiscordChannelInput, DiscordConnectionDefinition, DiscordConnectionInput, DiscordMessageSource, DiscordSource, Doc, EnvAccessor, EnvRef, EnvRefString, GeneratedIds, GitHubChannelInput, GitHubConnectionDefinition, GitHubConnectionInput, GitHubMessageSource, GitHubSource, GoogleChatChannelInput, GoogleChatConnectionDefinition, GoogleChatConnectionInput, GoogleChatMessageSource, GoogleChatSource, HarnessDefinition, HarnessType, HookAgentConfig, HookContext, Id, IngressMode, IngressStatus, InstagramChannelInput, InstagramConnectionDefinition, InstagramConnectionInput, InstagramMessageSource, InstagramSource, LinearChannelInput, LinearConnectionDefinition, LinearConnectionInput, LinearMessageSource, LinearSource, LogLevel, MatrixChannelInput, MatrixConnectionDefinition, MatrixConnectionInput, MatrixMessageSource, MatrixSource, McpDefinitionConfig, McpHandler, McpOauthInput, McpResource, McpRuntime, MessengerChannelInput, MessengerConnectionDefinition, MessengerConnectionInput, MessengerMessageSource, MessengerSource, ObservabilityBackfillMessage, ObservabilityClientMessage, ObservabilityErrorMessage, ObservabilityFetchTraceMessage, ObservabilityLogEntry, ObservabilityLogMessage, ObservabilityReadyMessage, ObservabilityServerMessage, ObservabilitySpanMessage, ObservabilitySpanRow, ObservabilitySubscribeMessage, ObservabilityUnsubscribeMessage, PancakeChannelInput, PancakeConnectionDefinition, PancakeConnectionInput, PancakeMessageSource, PancakeSource, PendingQuestion, PolicyDefinitionConfig, PolicyDocument, PolicyResource, ProjectDoc, ProviderConfigInput, ProviderSettingsInput, QuestionAnswer, ResourceApi, ResourceDefinition, ResourceInput, ResourceKind, RotateSecretResult, Sandbox, SandboxConfig, SandboxConfigDoc, SandboxDefinitionConfig, SandboxDefinitionOptions, SandboxExecRequest, SandboxExecResponse, SandboxLifecycleResult, SandboxProvider, SandboxResource, SandboxSnapshotResult, SandboxTerminalTicket, SignUserTokenInput, Skill, SkillDefinitionConfig, SkillResource, SkillUploadInput, SlackChannelInput, SlackConnectionDefinition, SlackConnectionInput, SlackMessageSource, SlackSource, StageDoc, StageScope, StorageTrust, TaskWaitingOn, TeamsChannelInput, TeamsConnectionDefinition, TeamsConnectionInput, TeamsMessageSource, TeamsSource, TelegramChannelInput, TelegramConnectionDefinition, TelegramConnectionInput, TelegramMessageSource, TelegramSource, ToolApprovalSummary, TwilioChannelInput, TwilioConnectionDefinition, TwilioConnectionInput, TwilioMessageSource, TwilioSource, UpdateAgentInput, UpdateCronInput, UpdateMcpInput, WebSocketAttachInput, WebSocketClientAttachMessage, WebSocketClientCancelMessage, WebSocketClientControlMessage, WebSocketClientExecuteMessage, WebSocketClientMessage, WebSocketConstructorLike, WebSocketHandlers, WebSocketLike, WebSocketOutputMessage, WebSocketRunInput, WebSocketServerMessage, WebSocketStreamMessage, WebSocketSubscription, WhatsAppChannelInput, WhatsAppConnectionDefinition, WhatsAppConnectionInput, WhatsAppMessageSource, WhatsAppSource, Workspace, WorkspaceConfig, WorkspaceConfigDoc, WorkspaceDefinitionConfig, WorkspaceFileEntry, WorkspaceIsolation, WorkspaceResource, WorkspaceStorageDefinition, ZaloChannelInput, ZaloConnectionDefinition, ZaloConnectionInput, ZaloMessageSource, ZaloSource };
+export { BroodsAccountApiError, BroodsAccountClient, BroodsClient, BroodsWebSocketClient, DEFAULT_CORE_BASE_URL, IngressAcceptedError, MAX_OBSERVABILITY_BACKFILL, USER_TOKEN_HEADER, USER_TOKEN_MAX_TTL_MS, USER_TOKEN_SECRET_ENV, BroodsWebSocketClient as WebSocketClient, BroodsWebSocketClient as WebsocketClient, defineAgent, defineBroods, defineCron, defineDiscordChannel, defineDiscordConnection, defineGitHubChannel, defineGitHubConnection, defineGoogleChatChannel, defineGoogleChatConnection, defineHarness, defineInstagramChannel, defineInstagramConnection, defineLinearChannel, defineLinearConnection, defineMcp, defineMessengerChannel, defineMessengerConnection, definePancakeChannel, definePancakeConnection, definePolicy, defineSandbox, defineSkill, defineSlackChannel, defineSlackConnection, defineTeamsChannel, defineTeamsConnection, defineTelegramChannel, defineTelegramConnection, defineTwilioChannel, defineTwilioConnection, defineWhatsAppChannel, defineWhatsAppConnection, defineWorkspace, defineZaloChannel, defineZaloConnection, env, envPlaceholder, isBroodsConfig, isConnectionDefinition, isLogLevel, isObservabilityClientMessage, isResource, isRootSpanKind, isSandboxLogId, isTraceId, normalizeHttpServiceUrl, readSseStream, resolveEnvCredential, resolveRunEvents, signUserToken, toWebSocketBaseUrl, webSocketSubprotocols };
+export type { Account, AccountAgent, AccountChannel, AccountEnvVar, AccountMcp, AccountPolicy, AccountRole, AccountSandbox, AccountWorkspace, Agent, AgentChannelsConfig, AgentCodeHookConfig, AgentConfig, AgentConfigDoc, AgentContinueInput, AgentDefinitionConfig, AgentDiscordChannelConfig, AgentGitHubChannelConfig, AgentGoogleChatChannelConfig, AgentHandle, AgentHookEventName, AgentHooks, AgentHooksConfig, AgentInstagramChannelConfig, AgentLinearChannelConfig, AgentMessengerChannelConfig, AgentPancakeChannelConfig, AgentProviderSettings, AgentReference, AgentResource, AgentRunAnswerInput, AgentRunEventInput, AgentRunInput, AgentRunModelOverrides, AgentRunOverrides, AgentRunResult, AgentSkillsDefinitionConfig, AgentSlackChannelConfig, AgentStreamPart, AgentSubagentDefinitionConfig, AgentTeamsChannelConfig, AgentTelegramChannelConfig, AgentTwilioChannelConfig, AgentWebhookHookConfig, AgentWhatsAppChannelConfig, AgentWorkspaceInput, AgentWorkspaceRef, AgentWorkspaceRefInput, AgentZaloChannelConfig, AnyConnectionDefinition, AnyResource, AssumeRoleResult, AsyncAgentRun, AsyncPollOptions, AsyncRequestAccepted, AsyncStatus, AuditEvent, AuditPage, AuditPrincipalLink, AuditSink, AuditVerification, BroodsAccount, BroodsAccountClientOptions, BroodsClientOptions, BroodsConfigDefinition, BroodsProjectConfig, BroodsWebSocketClientOptions, ChannelAgentInput, ChannelDefinitionConfig, ChannelMessageReceived, ChannelPartition, ChannelRecordConfig, ChannelReference, ChannelReplyIn, ChannelResource, ChannelType, CliManifest, CliManifestResource, ConfigPatch, Connection, ConnectionCode, ConnectionDefinition, ConnectionStart, ConnectionStartResult, ConnectionType, CreateAgentResult, CreateCronInput, CreateMcpInput, Cron, CronDefinitionConfig, CronDoc, CronLastStatus, CronResource, CronRun, CronStatus, DeleteAccountResult, DeploymentRegion, DiscordChannelInput, DiscordConnectionDefinition, DiscordConnectionInput, DiscordMessageSource, DiscordSource, Doc, EnvAccessor, EnvRef, EnvRefString, GeneratedIds, GitHubChannelInput, GitHubConnectionDefinition, GitHubConnectionInput, GitHubMessageSource, GitHubSource, GoogleChatChannelInput, GoogleChatConnectionDefinition, GoogleChatConnectionInput, GoogleChatMessageSource, GoogleChatSource, HarnessDefinition, HarnessType, HookAgentConfig, HookContext, Id, IngressMode, IngressStatus, InstagramChannelInput, InstagramConnectionDefinition, InstagramConnectionInput, InstagramMessageSource, InstagramSource, LinearChannelInput, LinearConnectionDefinition, LinearConnectionInput, LinearMessageSource, LinearSource, LogLevel, McpDefinitionConfig, McpHandler, McpOauthInput, McpResource, McpRuntime, MessengerChannelInput, MessengerConnectionDefinition, MessengerConnectionInput, MessengerMessageSource, MessengerSource, ObservabilityBackfillMessage, ObservabilityClientMessage, ObservabilityErrorMessage, ObservabilityFetchTraceMessage, ObservabilityLogEntry, ObservabilityLogMessage, ObservabilityReadyMessage, ObservabilityServerMessage, ObservabilitySpanMessage, ObservabilitySpanRow, ObservabilitySubscribeMessage, ObservabilityUnsubscribeMessage, PancakeChannelInput, PancakeConnectionDefinition, PancakeConnectionInput, PancakeMessageSource, PancakeSource, PendingQuestion, PolicyDefinitionConfig, PolicyDocument, PolicyResource, ProjectDoc, ProviderConfigInput, ProviderSettingsInput, QuestionAnswer, ResourceApi, ResourceDefinition, ResourceInput, ResourceKind, RotateSecretResult, Sandbox, SandboxConfig, SandboxConfigDoc, SandboxDefinitionConfig, SandboxDefinitionOptions, SandboxExecRequest, SandboxExecResponse, SandboxLifecycleResult, SandboxProvider, SandboxResource, SandboxSnapshotResult, SandboxTerminalTicket, SignUserTokenInput, Skill, SkillDefinitionConfig, SkillResource, SkillUploadInput, SlackChannelInput, SlackConnectionDefinition, SlackConnectionInput, SlackMessageSource, SlackSource, StageDoc, StageScope, StorageTrust, TaskWaitingOn, TeamsChannelInput, TeamsConnectionDefinition, TeamsConnectionInput, TeamsMessageSource, TeamsSource, TelegramChannelInput, TelegramConnectionDefinition, TelegramConnectionInput, TelegramMessageSource, TelegramSource, ToolApprovalSummary, TwilioChannelInput, TwilioConnectionDefinition, TwilioConnectionInput, TwilioMessageSource, TwilioSource, UpdateAgentInput, UpdateCronInput, UpdateMcpInput, WebSocketAttachInput, WebSocketClientAttachMessage, WebSocketClientCancelMessage, WebSocketClientControlMessage, WebSocketClientExecuteMessage, WebSocketClientMessage, WebSocketConstructorLike, WebSocketHandlers, WebSocketLike, WebSocketOutputMessage, WebSocketRunInput, WebSocketServerMessage, WebSocketStreamMessage, WebSocketSubscription, WhatsAppChannelInput, WhatsAppConnectionDefinition, WhatsAppConnectionInput, WhatsAppMessageSource, WhatsAppSource, Workspace, WorkspaceConfig, WorkspaceConfigDoc, WorkspaceDefinitionConfig, WorkspaceFileEntry, WorkspaceIsolation, WorkspaceResource, WorkspaceStorageDefinition, ZaloChannelInput, ZaloConnectionDefinition, ZaloConnectionInput, ZaloMessageSource, ZaloSource };