@get-bb/plugin-sdk 0.4.24 → 0.4.27

package/bundled-types/bb-plugin-sdk-provider-bridge.d.ts

@@ -87,14 +87,6 @@ interface JsonObject {
 type JsonValue = string | number | boolean | null | JsonValue[] | JsonObject;
 declare const jsonValueSchema: z.ZodType<JsonValue>;
 
-/**
- * Raw SDK task-type discriminants for the background tasks bb materializes as
- * timeline rows: dynamic workflows (the Workflow tool), backgrounded shell
- * commands (Bash with run_in_background), and backgrounded subagents. They
- * share the provider task event family (task_started / task_progress /
- * task_updated / task_notification). Other task types such as monitors share
- * the family too but are not materialized.
- */
 declare const LOCAL_WORKFLOW_TASK_TYPE = "local_workflow";
 declare const LOCAL_BASH_TASK_TYPE = "local_bash";
 declare function isBackgroundAgentTaskType(taskType: string): boolean;
@@ -152,11 +144,6 @@ declare const workflowPhaseSnapshotSchema: z.ZodObject<{
     title: z.ZodString;
 }, z.core.$strip>;
 type WorkflowPhaseSnapshot = z.infer<typeof workflowPhaseSnapshotSchema>;
-/**
- * Full merged workflow state at a point in time. Providers emit progress as
- * delta batches; the adapter folds them by (record type, index) so every
- * persisted snapshot supersedes the previous one.
- */
 declare const workflowProgressSnapshotSchema: z.ZodObject<{
     agents: z.ZodArray<z.ZodObject<{
         agentType: z.ZodOptional<z.ZodString>;
@@ -200,19 +187,7 @@ declare const backgroundTaskUsageSchema: z.ZodObject<{
     totalTokens: z.ZodNumber;
 }, z.core.$strip>;
 type BackgroundTaskUsage = z.infer<typeof backgroundTaskUsageSchema>;
-/**
- * Canonical derivation from the provider-reported task status to the shared
- * item-status machinery: paused stays pending because a paused workflow is
- * resumable; stopped maps to interrupted (user/system stop, not a failure).
- */
 declare function backgroundTaskItemStatus(taskStatus: BackgroundTaskStatus): "completed" | "failed" | "interrupted" | "pending";
-/**
- * Whether the provider-reported status already describes a finished task.
- * Settle backstops (thread restart, daemon crash, lease expiry) must preserve
- * these statuses instead of rewriting them to "stopped": a workflow whose
- * completion patch arrived before its terminal notification is completed, not
- * interrupted.
- */
 declare function isSettledBackgroundTaskStatus(taskStatus: BackgroundTaskStatus): boolean;
 
 declare const threadEventItemPresentationSchema: z.ZodObject<{
@@ -553,12 +528,6 @@ declare const pluginPendingInteractionPayloadSchema: z.ZodObject<{
     title: z.ZodString;
 }, z.core.$strip>;
 type PluginPendingInteractionPayload = z.infer<typeof pluginPendingInteractionPayloadSchema>;
-/**
- * The open request family. A plain union rather than a discriminated one
- * because the plugin member's `kind` is a namespace pattern, not a literal;
- * the core literal (`user_question`) contains no "/" so the members never
- * overlap.
- */
 declare const interactionRequestPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"user_question">;
     questions: z.ZodArray<z.ZodObject<{
@@ -579,11 +548,6 @@ declare const interactionRequestPayloadSchema: z.ZodUnion<readonly [z.ZodObject<
     title: z.ZodString;
 }, z.core.$strip>]>;
 type InteractionRequestPayload = z.infer<typeof interactionRequestPayloadSchema>;
-/**
- * The payload a provider raises through `interaction/request`: an approval,
- * a user question, or a plugin-defined request. A plain union because the
- * plugin member's kind is a namespace pattern, not a literal.
- */
 declare const pendingInteractionPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
     availableDecisions: z.ZodArray<z.ZodEnum<{
         allow_for_session: "allow_for_session";
@@ -1199,11 +1163,6 @@ declare const threadEventPlanStepSchema: z.ZodObject<{
     step: z.ZodString;
 }, z.core.$strip>;
 type ThreadEventPlanStep = z.infer<typeof threadEventPlanStepSchema>;
-/**
- * How a `search` item looked for things: `content` searches inside files
- * (grep, Claude `Grep`), `path` matches file names (Claude `Glob`, `fd`),
- * `list` enumerates a directory (`ls`, codex `list_dir`).
- */
 declare const threadEventSearchModeSchema: z.ZodEnum<{
     content: "content";
     list: "list";
@@ -1246,17 +1205,6 @@ declare const providerRawEventSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ProviderRawEvent = z.infer<typeof providerRawEventSchema>;
 
-/**
- * Order is load-bearing: `reasoningRank` (index) drives model-switch
- * reconciliation. "none" (no extended thinking) sits at the bottom — only
- * providers that expose a thinking-off variant list it (currently Cursor and
- * Pi models whose `thinkingLevelMap` advertises `off`).
- * "ultracode" sits between "xhigh" and "max" because its underlying effort IS
- * xhigh (plus standing workflow orchestration) — a model without ultracode
- * support should reconcile down to xhigh, not up to max.
- * "ultra" is a Codex-native top tier (max effort plus automatic task
- * delegation) exposed only by some models; it ranks above "max".
- */
 declare const reasoningLevelValues: readonly ["none", "low", "medium", "high", "xhigh", "ultracode", "max", "ultra"];
 declare const reasoningLevelSchema: z.ZodEnum<{
     high: "high";
@@ -1274,13 +1222,6 @@ declare const serviceTierSchema: z.ZodEnum<{
     fast: "fast";
 }>;
 type ServiceTier = z.infer<typeof serviceTierSchema>;
-/**
- * Controls how a provider should incorporate server-owned instructions into its
- * system prompt.
- *
- * - `append`: keep the provider's preset system prompt and append instructions.
- * - `replace`: use the provided instructions as the full system prompt.
- */
 declare const instructionModeValues: readonly ["append", "replace"];
 declare const instructionModeSchema: z.ZodEnum<{
     append: "append";
@@ -1389,10 +1330,6 @@ interface PromptCommandSelector {
     trigger: PromptMentionCommandTrigger;
     name: string;
 }
-/**
- * Whether input consists solely of one selected built-in `/compact` mention.
- * Raw matching text and project/user commands intentionally do not qualify.
- */
 declare function isStandaloneBuiltinCompactCommand(input: readonly PromptInput[]): boolean;
 declare function removeCommandMentionsFromPromptInput(input: readonly PromptInput[], selector: PromptCommandSelector): PromptInput[];
 declare const runtimePermissionScopeValues: readonly ["workspace", "full"];
@@ -1428,10 +1365,8 @@ type RuntimePermissionPolicy = z.infer<typeof runtimePermissionPolicySchema>;
 declare const clientTurnRequestIdSchema: z.ZodString;
 type ClientTurnRequestId = z.infer<typeof clientTurnRequestIdSchema>;
 
-/** A namespaced extension kind, `"<pluginId>/<name>"`. */
 type ExtensionKind = `${string}/${string}`;
 declare function isExtensionKind(value: string): value is ExtensionKind;
-/** Parses to the {@link ExtensionKind} type, so consumers can split it. */
 declare const extensionKindSchema: z.ZodString & z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>;
 
 declare const modelReasoningEffortSchema: z.ZodObject<{
@@ -1480,32 +1415,6 @@ declare const availableModelSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 type AvailableModel = z.infer<typeof availableModelSchema>;
-/**
- * Typed recovery hints a provider bridge raises instead of error text the
- * runtime would otherwise have to pattern-match (`provider/recovery`, see
- * `providerRecoveryNotificationSchema` in @bb/provider-bridge-protocol).
- *
- * - `sessionArchived`: the provider refused because its session is archived;
- *   the runtime unarchives and retries.
- * - `authRequired`: credentials are missing or expired; typed error plus a
- *   health refresh.
- * - `restartRecommended`: the bridge wants a fresh process; the runtime
- *   restarts it and resumes the session.
- * - `staleTurn`: the steer or stop named a turn that is no longer live; the
- *   runtime drops it.
- * - `rateLimited`: the provider throttled the request; the runtime schedules
- *   a retry.
- *
- * Consumed by `sendCommand` in packages/agent-runtime/src/runtime.ts, which
- * reads the hint off the bridge's rejection and acts on it (unarchive and
- * retry, typed `auth_required` / `rate_limited` errors, bridge restart,
- * rate-limit retry); `steerTurn` there claims `staleTurn`. The hints the
- * runtime cannot fully act on itself (`authRequired`, `restartRecommended`,
- * and a `rateLimited` that is terminal or ends the retry ladder), plus every
- * hint raised as a notification, are also forwarded to the daemon through
- * `onProviderRecovery`, which is where the health re-check after
- * `authRequired` happens.
- */
 declare const providerRecoveryKindValues: readonly ["sessionArchived", "authRequired", "restartRecommended", "staleTurn", "rateLimited"];
 declare const providerRecoveryKindSchema: z.ZodEnum<{
     authRequired: "authRequired";
@@ -1515,20 +1424,6 @@ declare const providerRecoveryKindSchema: z.ZodEnum<{
     staleTurn: "staleTurn";
 }>;
 type ProviderRecoveryKind = z.infer<typeof providerRecoveryKindSchema>;
-/**
- * A bb-injected tool handed to a provider bridge at session construction.
- *
- * `presentation` is how a call to this tool reads as a timeline row (grammar
- * v3, docs/provider-plugin-api.md §3): the bridge stamps it on the
- * `item.open`/`item.close` for the call beside `server: "bb"`, so no core
- * table of bb tool names is needed to label the row. The server resolves it
- * once, at its boundary, for every tool it injects — from the owning
- * plugin's declaration, falling back to a generic label and the plugin's
- * glyph. Optional on the wire while the grammar migrates (A1, additive then
- * delete): a definition recorded before the field existed carries none, and
- * a bridge then presents the call generically; the stabilization pass makes
- * it required.
- */
 declare const dynamicToolSchema: z.ZodObject<{
     description: z.ZodString;
     inputSchema: z.ZodUnknown;
@@ -1560,93 +1455,35 @@ declare const ULTRACODE_REASONING_EFFORT: ModelReasoningEffort;
 declare const MAX_REASONING_EFFORT: ModelReasoningEffort;
 declare function reasoningEffortsForLevels(levels: readonly ReasoningLevel[]): ModelReasoningEffort[];
 
-/**
- * Shared adapter utilities.
- *
- * Functions and constants duplicated across the claude-code, pi, and codex
- * adapters are extracted here so each adapter imports from one place.
- */
-
 declare function toOptionalString(value: unknown): string | undefined;
 declare function toOptionalRecord(value: unknown): Record<string, unknown> | undefined;
-/**
- * The environment overrides a bridge may hand its provider: the requested
- * variables minus any name a shell would refuse. A rejected name is dropped,
- * never passed through — a provider that inherits an unquotable name can fail
- * its whole session on one bad key.
- */
 declare function buildShellEnvOverrides(envVars?: Record<string, string>): Record<string, string>;
 declare function toNonNegativeNumber(value: unknown): number;
 declare function normalizeProviderCommandOutput(args: {
     emptyPlaceholders: readonly string[];
     text: string;
 }): string | undefined;
-/**
- * Extracts text from tool result content.
- * Handles strings, arrays of text blocks, and `{ content: [...] }` wrappers.
- */
 declare function extractResultText(content: unknown): string;
-/** The empty breakdown a bridge's per-session usage accumulator starts from. */
 declare const ZERO_TOKEN_USAGE: ThreadEventTokenUsageBreakdown;
-/**
- * Sum a turn's usage into a running total, field by field. The `usage` delta
- * carries both the turn's usage and the session total; a provider that only
- * reports per-turn usage keeps the total itself with this, starting from
- * {@link ZERO_TOKEN_USAGE} at every session construction (the same boundary
- * as the `session.reset` delta).
- */
 declare function addTokenUsage(total: ThreadEventTokenUsageBreakdown, last: ThreadEventTokenUsageBreakdown): ThreadEventTokenUsageBreakdown;
 
 interface BoundedLineReaderArgs {
     input: NodeJS.ReadableStream;
-    /** Complete lines, without their terminator. */
     onLine: (line: string) => void;
-    /**
-     * An oversized line was discarded (bytes counted so far when the cap was
-     * passed). Reading continues from the next terminator, so one runaway
-     * message costs its own content and nothing else.
-     */
     onOverflow: (bytes: number) => void;
     onClose?: () => void;
     maxLineBytes?: number;
 }
-/**
- * Newline-delimited reader with a hard per-line cap — `readline` with the
- * bound it lacks. CR is stripped so a CRLF producer parses as JSON.
- */
 declare function readBoundedLines(args: BoundedLineReaderArgs): void;
 
-/**
- * JSON-RPC error codes on the bridge wire.
- *
- * The hygiene rules these back (from #853): an undecodable request is
- * answered with `INVALID_PARAMS` carrying the validation issues — never
- * silently dropped; an unrecognized method is answered with
- * `METHOD_NOT_FOUND`; request vs response is discriminated on the presence of
- * `method`, never on result-shape guessing.
- */
 declare const BRIDGE_JSON_RPC_ERRORS: {
-    /** Standard JSON-RPC: params failed schema validation. */
     readonly INVALID_PARAMS: -32602;
-    /** Standard JSON-RPC: method not implemented by this bridge. */
     readonly METHOD_NOT_FOUND: -32601;
-    /** Generic bridge failure. */
     readonly BRIDGE_ERROR: -32000;
-    /** A turn/steer arrived but the session has no active turn. */
     readonly NO_ACTIVE_TURN: -32001;
-    /** thread/resume for a session the provider can no longer restore. */
     readonly SESSION_NOT_RESTORABLE: -32002;
-    /** thread/fork with a checkpoint on a bridge that only forks at the tip. */
     readonly FORK_CHECKPOINT_UNSUPPORTED: -32003;
 };
-/**
- * A typed recovery hint: what went wrong in the provider's own terms and
- * whether the runtime may retry after acting on it. One payload, two
- * carriers: a rejected request carries it as `error.data.recovery` (the
- * JSON-RPC id is the correlation); a condition with no request to ride on
- * (a terminal 401 mid-turn) rides the `provider/recovery` notification.
- * Never both for one event. The runtime keys on `kind` and matches no text.
- */
 declare const providerRecoveryHintSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         authRequired: "authRequired";
@@ -1659,10 +1496,6 @@ declare const providerRecoveryHintSchema: z.ZodObject<{
     retryable: z.ZodBoolean;
 }, z.core.$strip>;
 type ProviderRecoveryHint = z.infer<typeof providerRecoveryHintSchema>;
-/**
- * Optional `error.data` on any bridge → runtime JSON-RPC error response.
- * Additive: a response without `data` is a plain failure.
- */
 declare const bridgeErrorDataSchema: z.ZodObject<{
     recovery: z.ZodOptional<z.ZodObject<{
         kind: z.ZodEnum<{
@@ -1686,12 +1519,6 @@ type BridgeJsonRpcResponse$1 = {
 } | {
     jsonrpc: "2.0";
     id: BridgeJsonRpcId;
-    /**
-     * `data` is JSON-RPC 2.0's own slot for structured detail beside the
-     * human-readable `message`. bb uses it to carry a typed recovery hint,
-     * so the runtime reads what went wrong instead of matching the
-     * message text.
-     */
     error: {
         code: number;
         message: string;
@@ -1699,14 +1526,6 @@ type BridgeJsonRpcResponse$1 = {
     };
 };
 type BridgeSendError = (id: BridgeJsonRpcId, code: number, message: string, data?: BridgeErrorData) => void;
-/**
- * Throw this from a request handler to reject the request with a typed
- * recovery hint: `runBridgeRequest` answers with `error.data.recovery`, the
- * same way a `ProviderRequestDecodeError` becomes `INVALID_PARAMS`. A handler
- * that answers by hand passes the hint to `sendError` as `data` instead.
- * Rejecting a request? Put the hint here. No request to reject? Send the
- * `provider/recovery` notification. Never both for one event.
- */
 declare class BridgeRecoveryError extends Error {
     readonly code: number;
     readonly recovery: ProviderRecoveryHint;
@@ -1740,43 +1559,13 @@ interface BridgeRecorderChildStreams {
     stdin?: Writable | null;
     stdout?: Readable | null;
 }
-/**
- * Whether this process records. A bridge whose provider pipe is owned by an
- * SDK (Claude's Agent SDK) checks this to decide whether to take the spawn
- * over; bridges that spawn their child themselves just call
- * `experimental_recordProviderChildIo`.
- */
 declare function experimental_isProviderBridgeRecording(): boolean;
-/**
- * Tee the provider child a bridge just spawned into the recording, scoped to
- * the bb thread it serves (null for process-level children such as a
- * model-list probe). A no-op unless record mode is on, so bridges call it
- * unconditionally right after `spawn()`.
- */
 declare function experimental_recordProviderChildIo(child: BridgeRecorderChildStreams, scope: {
     threadId: string | null;
 }): void;
 
-/**
- * The environment a bridge hands its provider child when it wants the child
- * to see the bridge's own environment (ACP agents and the Claude CLI need
- * `BB_CLI` and friends so `bb` works inside their shells). Two variables are
- * bridge-process facts that must never leak downward: the Electron node flag,
- * and the record-mode directory — a recorded provider child that happened to
- * be a bb bridge itself would otherwise start recording too.
- */
 declare function withoutBridgeRuntimeEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 
-/**
- * Shared tool call helpers for bridge processes.
- *
- * Both claude-code and pi bridges forward tool calls from the provider SDK
- * to the host-daemon and feed responses back. This module provides:
- * - The JSON-RPC request type for forwarding tool calls
- * - Response decoding for tool call results from the host-daemon
- * - Generic JSON-RPC response decoding (for matching tool call responses)
- */
-
 interface BridgeToolCallRequest {
     jsonrpc: "2.0";
     id: string | number;
@@ -1812,16 +1601,10 @@ declare const jsonRpcErrorResponseSchema: z.ZodObject<{
 }, z.core.$strip>;
 type BridgeJsonRpcResponse = z.infer<typeof jsonRpcSuccessResponseSchema> | z.infer<typeof jsonRpcErrorResponseSchema>;
 declare function decodeBridgeJsonRpcResponse(input: unknown): BridgeJsonRpcResponse | null;
-/** An image on a tool call result, split out of an `inputImage` data URL. */
 interface BridgeToolCallImage {
     data: string;
     mimeType: string;
 }
-/**
- * A tool result block in the one shape every consumer already accepts: MCP's
- * `CallToolResult.content` (claude-code and acp) and pi's `AgentToolResult.content`
- * declare the same two members with the same field names.
- */
 type BridgeToolCallContent = {
     type: "text";
     text: string;
@@ -1836,26 +1619,12 @@ declare function decodeToolCallResponsePayload(result: unknown): {
     images: BridgeToolCallImage[];
     isError: boolean;
 };
-/**
- * Renders a decoded payload as tool result blocks, dropping empty text so an
- * image-only result carries the image alone.
- */
 declare function buildBridgeToolCallContent(result: {
     content: string;
     contentBlocks?: BridgeToolCallContent[];
     images?: BridgeToolCallImage[];
 }): BridgeToolCallContent[];
 
-/**
- * Structural contracts shared by the runtime's generic adapter and the bridge
- * implementations that translate a provider's native protocol.
- *
- * These are the shapes a bridge produces or consumes while it maps its
- * provider onto the canonical protocol. They live in the kit (rather than in
- * `@bb/agent-runtime`) so a bridge shipped from a plugin never depends on the
- * runtime package.
- */
-
 interface ProviderRequestCommandPlan {
     kind: "request";
     method: string;
@@ -1870,25 +1639,12 @@ interface DecodedInteractiveRequest {
     requestId: string | number;
     method: string;
     providerThreadId: string;
-    /**
-     * Non-empty BB turn id when known. Use null as the canonical unresolved
-     * value so the runtime can resolve from the active turn; empty strings are
-     * malformed adapter output.
-     */
     turnId: string | null;
     payload: PendingInteractionPayload;
     threadId?: string;
 }
 interface PreparedProviderCommandDispatch {
     rollback(): void;
-    /**
-     * Claims the prepared correlation if no provider event has consumed it yet,
-     * proving this dispatch still owns unstarted work. Returns true (and drops
-     * the correlation, so nothing can consume it twice) when the provider never
-     * started a turn for this dispatch; false once it did. Callers use it to
-     * settle a prompt the provider accepted and finished without emitting any
-     * turn activity, without fabricating a turn from a late signal.
-     */
     claim(): boolean;
 }
 interface BuildInteractiveResponseArgs {
@@ -1942,79 +1698,32 @@ declare function mimeTypeFromExtension(filePath: string): string;
 
 interface BridgeToolCallResult {
     content: string;
-    /** Ordered provider result blocks; absent on local transport failures. */
     contentBlocks?: BridgeToolCallContent[];
-    /** Absent on the failure paths below, which have no image to report. */
     images?: BridgeToolCallImage[];
     isError?: boolean;
 }
 interface ForwardBridgeToolCallArgs {
     arguments: Record<string, unknown>;
     providerThreadId: string;
-    /**
-     * The session the pending call belongs to. `resolvePendingToolCalls`
-     * error-resolves by scope identity, so a bridge passes its own session
-     * object and settles that session's calls on close/replace without touching
-     * calls minted by a successor session under the same thread id.
-     */
     scope: object;
     threadId: string;
     toolName: string;
 }
 interface PendingToolCallTracker {
-    /**
-     * Mints an `item/tool/call` JSON-RPC request toward the runtime and returns
-     * a promise settled by the matching response (or by
-     * `resolvePendingToolCalls`). Never rejects: failures resolve as
-     * `isError: true` results.
-     */
     forwardToolCall: (args: ForwardBridgeToolCallArgs) => Promise<BridgeToolCallResult>;
-    /** Returns true when the response settled a pending tool call. */
     handleToolCallResponse: (response: BridgeJsonRpcResponse) => boolean;
-    /** Error-resolves every pending call minted under `scope`. */
     resolvePendingToolCalls: (scope: object, message: string) => void;
 }
-/**
- * Tracks the bridge's outgoing tool-call requests: mints request ids, sends
- * the `item/tool/call` envelope, and matches responses back to their waiting
- * promise via `decodeToolCallResponsePayload`.
- */
 declare function createPendingToolCallTracker(options: {
     sendToolCall: (request: BridgeToolCallRequest) => void;
 }): PendingToolCallTracker;
 
-/**
- * The single statement of when an interactive provider request is answered
- * without ever reaching the user.
- *
- * Both sides of the bridge boundary enforce it and they must agree: a bridge
- * auto-denies its provider's own permission prompts, and the runtime
- * auto-denies the inbound requests that still arrive (a bridge whose provider
- * only learns the policy after the prompt is already in flight). Stating it
- * twice is how the two sides drift, so it lives in the kit — the one place a
- * plugin-shipped bridge and `@bb/agent-runtime` can both import from.
- */
-
 interface InteractiveRequestPolicyInput {
     permissionEscalation: PermissionEscalation | null;
 }
 declare function shouldAutoDenyInteractiveRequest(policy: InteractiveRequestPolicyInput): boolean;
 
 declare const THREAD_DELTA_NOTIFICATION_METHOD = "thread/delta";
-/**
- * Declarative presentation a bridge attaches to an item at `item.open` (and
- * re-states on `item.close`, whose item is the full terminal shape). The
- * assembler persists it on the canonical item so the row renders after the
- * plugin is uninstalled or upgraded, and so mobile renders every kind without
- * plugin code. The same schema as the persisted field
- * (`threadEventItemPresentationSchema` in @bb/domain) — one vocabulary, no
- * translation.
- *
- * Optional in grammar v3 while rows persisted before bridges stamped it are
- * upgraded at read time; it becomes required together with the
- * `legacy-tool-item-backfill` migration that stamps those rows and retires
- * that adapter.
- */
 declare const deltaPresentationSchema: z.ZodObject<{
     detail: z.ZodOptional<z.ZodString>;
     icon: z.ZodObject<{
@@ -2032,31 +1741,12 @@ declare const deltaPresentationSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type DeltaPresentation = z.infer<typeof deltaPresentationSchema>;
-/**
- * Provider-native join key for an item. `providerItemId` is the provider's
- * own id (a tool-call id); `channel` distinguishes provider-anonymous item
- * families (e.g. compaction); `parentRef` is the provider-native id of the
- * parent tool call for nested items. The assembler translates all of these to
- * bb-minted ids.
- */
 declare const deltaItemKeySchema: z.ZodObject<{
     channel: z.ZodOptional<z.ZodString>;
     parentRef: z.ZodOptional<z.ZodString>;
     providerItemId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type DeltaItemKey = z.infer<typeof deltaItemKeySchema>;
-/**
- * The parsed item shapes a bridge classifies its provider's tool traffic
- * into. Everything richer (diffs, pending statuses, echoed fields on close)
- * is assembler-owned construction. Output-ish optional fields (aggregated
- * output, exit code, results) exist for providers whose native item payloads
- * carry them wholesale (codex). When both a shape field and its generic close
- * counterpart are present, precedence is per-shape: for `command` the generic
- * close fields (`aggregatedOutput`, `exitCode`) win over the shape's, but for
- * `tool` the shape's `result` wins over the close's `resultText`. The
- * asymmetry is deliberate — it preserves byte-equivalence with the original
- * codex-vs-pi translator conversions.
- */
 declare const deltaFileChangeSchema: z.ZodObject<{
     diff: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
@@ -2070,15 +1760,6 @@ declare const deltaFileChangeSchema: z.ZodObject<{
     path: z.ZodString;
 }, z.core.$strip>;
 type DeltaFileChange = z.infer<typeof deltaFileChangeSchema>;
-/**
- * A provider background task (claude workflows, backgrounded shells and
- * subagents). The full snapshot is re-embedded per event — the bridge owns the
- * dialect fold (per-index workflow records, generation counting) and the
- * assembler only re-emits it. The family's canonical events are structurally
- * thread-scoped by the domain grammar (`item/backgroundTask/progress` and
- * `item/backgroundTask/completed`), so its progress/close deltas need no open
- * turn; only the spawning `item.open` (→ `item/started`) is turn-scoped.
- */
 declare const deltaBackgroundTaskShapeSchema: z.ZodObject<{
     description: z.ZodString;
     error: z.ZodOptional<z.ZodString>;
@@ -2147,29 +1828,12 @@ declare const deltaBackgroundTaskShapeSchema: z.ZodObject<{
     workflowName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type DeltaBackgroundTaskShape = z.infer<typeof deltaBackgroundTaskShapeSchema>;
-/**
- * A file the agent read (grammar v3). Claude `Read` is the top generic tool in
- * the production corpus — 7,568 calls rendered as opaque `tool` rows — and
- * codex reads files through `cat`/`sed -n` commands the bridge already
- * classifies as read intents. `cmd` carries that native shell form when the
- * read ran through a command rather than a structured tool.
- */
 declare const deltaFileReadShapeSchema: z.ZodObject<{
     cmd: z.ZodOptional<z.ZodString>;
     path: z.ZodString;
     type: z.ZodLiteral<"fileRead">;
 }, z.core.$strip>;
 type DeltaFileReadShape = z.infer<typeof deltaFileReadShapeSchema>;
-/**
- * Grep, glob and directory listing as one shape (grammar v3), discriminated
- * by `mode`: `content` searches inside files (Claude `Grep`, `rg`), `path`
- * matches file names (Claude `Glob`, `fd`), `list` enumerates a directory
- * (`ls`, codex `list_dir`). `query` is the pattern — text or a regex for
- * `content`, a glob for `path`, an optional filter for `list` (empty when the
- * whole directory is listed); `path` is the root the search ran under when
- * the provider named one; `cmd` is the native shell form when it ran through
- * a command.
- */
 declare const deltaSearchShapeSchema: z.ZodObject<{
     cmd: z.ZodOptional<z.ZodString>;
     mode: z.ZodEnum<{
@@ -2182,18 +1846,6 @@ declare const deltaSearchShapeSchema: z.ZodObject<{
     type: z.ZodLiteral<"search">;
 }, z.core.$strip>;
 type DeltaSearchShape = z.infer<typeof deltaSearchShapeSchema>;
-/**
- * Delegated work (grammar v3): one shape for the three encodings in the
- * production data — codex `spawnAgent`/`wait` tool calls, the Claude `Agent`
- * tool with nested child turns, and backgrounded `local_agent` background
- * tasks — and for what the `thread/openWork` notification used to report,
- * since an open delegation IS open work. `childRef` is the provider-native child id; the
- * child's own deltas link back through `parentRef`. `background: true` marks
- * a delegation that outlives its turn: the assembler routes its progress and
- * close to the thread-scoped `item/delegation/*` events exactly as it does
- * for `backgroundTask`. The terminal `status` rides `item.close`, as
- * for `command` and `tool`; `summary` is the child's terminal summary.
- */
 declare const deltaDelegationShapeSchema: z.ZodObject<{
     background: z.ZodBoolean;
     childRef: z.ZodString;
@@ -2202,15 +1854,6 @@ declare const deltaDelegationShapeSchema: z.ZodObject<{
     type: z.ZodLiteral<"delegation">;
 }, z.core.$strip>;
 type DeltaDelegationShape = z.infer<typeof deltaDelegationShapeSchema>;
-/**
- * A structured plan snapshot as an item (grammar v3): codex `update_plan`
- * (295 production threads, discarded by the UI while it only rode the
- * turn-level `turn.plan`), ACP `plan` updates, and Claude
- * `TaskCreate`/`TaskUpdate`/`TodoWrite`. Each snapshot carries the full step
- * list and supersedes the previous one. The turn-level `turn.plan` delta is
- * gone: every in-repo bridge speaks this form, and the persisted
- * `turn/plan/updated` event type stays as read-only history.
- */
 declare const deltaPlanStepsShapeSchema: z.ZodObject<{
     explanation: z.ZodOptional<z.ZodString>;
     steps: z.ZodArray<z.ZodObject<{
@@ -2225,21 +1868,6 @@ declare const deltaPlanStepsShapeSchema: z.ZodObject<{
     type: z.ZodLiteral<"planSteps">;
 }, z.core.$strip>;
 type DeltaPlanStepsShape = z.infer<typeof deltaPlanStepsShapeSchema>;
-/**
- * A plugin-defined item kind outside the core vocabulary (grammar v3).
- * `kind` is the namespaced `"<pluginId>/<name>"` the plugin declared in its
- * provider registration (`extensionKinds`); only the namespace shape is
- * validated here. The payload is opaque JSON at this layer: the assembler
- * copies it onto the canonical item, and the server validates it against the
- * plugin's declared item schema for `kind` at ingest, persisting a
- * `provider/unhandled` in its place on a miss.
- *
- * The shape carries no presentation of its own: presentation lives in ONE
- * place, the `item.open`/`item.close` delta's `presentation` field, and for
- * an extension shape that field is REQUIRED (enforced by the delta schema
- * below) — an extension item has no core renderer, so the declarative base
- * is the only thing every client can show.
- */
 declare const deltaExtensionShapeSchema: z.ZodObject<{
     kind: z.ZodString & z.ZodType<`${string}/${string}`, string, z.core.$ZodTypeInternals<`${string}/${string}`, string>>;
     payload: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
@@ -2403,12 +2031,6 @@ declare const deltaItemShapeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "type">;
 type DeltaItemShape = z.infer<typeof deltaItemShapeSchema>;
 type DeltaItemShapeType = DeltaItemShape["type"];
-/**
- * The re-embedded snapshot an `item.progress` may carry for work that
- * outlives its turn. `backgroundTask` is the v2 form; `delegation` joins it in
- * v3 for background delegations (the assembler routes it to
- * `item/delegation/progress`).
- */
 declare const deltaProgressSnapshotSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     description: z.ZodString;
     error: z.ZodOptional<z.ZodString>;
@@ -2483,13 +2105,6 @@ declare const deltaProgressSnapshotSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
     type: z.ZodLiteral<"delegation">;
 }, z.core.$strip>], "type">;
 type DeltaProgressSnapshot = z.infer<typeof deltaProgressSnapshotSchema>;
-/**
- * The streamed-text channels: which text item a stream feeds and which of its
- * fields the text lands in. `agentMessage` and `plan` items have one text;
- * a `reasoning` item has `summary` (`reasoningSummary`) and `content`
- * (`reasoningText`). A delta for an unknown item key synthesizes the
- * channel's `item/started`.
- */
 declare const deltaTextChannelSchema: z.ZodEnum<{
     agentMessage: "agentMessage";
     plan: "plan";
@@ -2497,26 +2112,11 @@ declare const deltaTextChannelSchema: z.ZodEnum<{
     reasoningText: "reasoningText";
 }>;
 type DeltaTextChannel = z.infer<typeof deltaTextChannelSchema>;
-/**
- * Item-keyed output channels (codex): channels that NEVER synthesize an open
- * — fabricating a commandExecution without its command would be worse than
- * the anomaly. The structural split between `item.textDelta` and
- * `item.outputDelta` is what encodes that rule.
- */
 declare const deltaOutputChannelSchema: z.ZodEnum<{
     command: "command";
     fileChange: "fileChange";
 }>;
 type DeltaOutputChannel = z.infer<typeof deltaOutputChannelSchema>;
-/**
- * Turnless fallback: item/stream deltas never open turns — only `turn.open`,
- * a claiming `turn.boundary`, and accepted-input lifecycle settlement do.
- * When a turn-scoped delta arrives with no turn to attach to, the assembler
- * surfaces this raw payload as a thread-scoped `provider/unhandled` (the
- * bridges' old "no active turn" guard, applied centrally). Absent, the
- * turnless delta is dropped silently. Irrelevant for deltas carrying a
- * `providerTurnId` (a vouched turn always resolves).
- */
 declare const deltaNoTurnFallbackSchema: z.ZodObject<{
     raw: z.ZodObject<{
         id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
@@ -3309,7 +2909,6 @@ declare const threadDeltaSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "kind">;
 type ThreadDelta = z.infer<typeof threadDeltaSchema>;
 type ThreadDeltaKind = ThreadDelta["kind"];
-/** `thread/delta` notification params: batched deltas for one thread. */
 declare const threadDeltaNotificationParamsSchema: z.ZodObject<{
     deltas: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         clientRequestId: z.ZodString;
@@ -4095,90 +3694,43 @@ declare const threadDeltaNotificationParamsSchema: z.ZodObject<{
 }, z.core.$loose>;
 type ThreadDeltaNotificationParams = z.infer<typeof threadDeltaNotificationParamsSchema>;
 
-/**
- * The first non-empty line of `text`, capped at
- * {@link PRESENTATION_TITLE_MAX_LENGTH} with an ellipsis; undefined when
- * there is nothing to headline, so the row carries no `title` at all.
- */
 declare function presentationTitle(text: string): string | undefined;
-/** Row details are capped by the persisted presentation schema. */
 declare function presentationDetail(text: string): string;
-/** `presentation` with `title` stamped on it, or untouched when there is none. */
 declare function withTitle(presentation: DeltaPresentation, title: string | undefined): DeltaPresentation;
-/** The last path segment — a headline names the file, not its directory. */
 declare function presentationFileName(path: string): string;
 declare const COMPACTION_PRESENTATION: DeltaPresentation;
 declare const REASONING_PRESENTATION: DeltaPresentation;
 declare function fileReadPresentation(path: string): DeltaPresentation;
-/** `content` searches inside files; `path` matches file names. */
 declare function searchPresentation(args: {
     mode: "content" | "path";
     query: string;
 }): DeltaPresentation;
-/** A web search; `query` is the headline, or undefined when the agent sent none. */
 declare function webSearchPresentation(query: string | undefined): DeltaPresentation;
 declare function webFetchPresentation(url: string): DeltaPresentation;
-/**
- * A plan-steps snapshot. The headline is the step in progress — what the
- * agent is doing now. Collapsed by default: the todo banner reads the
- * snapshot; the row is bookkeeping.
- */
 declare function planStepsPresentation(steps: readonly {
     step: string;
     status?: string;
 }[]): DeltaPresentation;
-/**
- * A tool with no core kind and no presentation of its own — a provider's
- * own dynamic tool, an unknown built-in, or a bb-injected tool whose
- * definition predates the field: a generic label under bb's own glyph.
- */
 declare function toolPresentation(tool: string): DeltaPresentation;
 
-/**
- * The bridge export shape.
- *
- * A provider bridge is a module inside its plugin's `bb.host` artifact that
- * *exports* its surface instead of starting itself: the daemon-side bootstrap
- * imports the artifact, finds this export, and owns the process boundary
- * (argv, plugin-scoped directories, stdin framing, signals). That inversion is
- * what lets one artifact carry both a bridge and a host RPC entry, and what
- * lets a bridge be imported by tests without taking over stdio.
- */
-/** The name a bridge must export from its plugin's host artifact. */
 declare const PROVIDER_BRIDGE_EXPORT_NAME = "experimental_providerBridge";
-/** Where this bridge process may keep files, scoped to the owning plugin. */
 interface ProviderBridgeContext {
-    /** The plugin that ships this bridge. */
     pluginId: string;
-    /** Persistent, per-plugin, survives daemon restarts and plugin updates. */
     dataDir: string;
-    /** This process only; removed when it exits. */
     tempDir: string;
 }
 interface ProviderBridgeDefinition {
-    /** One decoded stdin line of the Provider Bridge Protocol. */
     handleLine: (line: string) => void;
-    /**
-     * Called once before the first line is read, with the process's
-     * plugin-scoped directories. Omit it when the bridge keeps no files.
-     */
     start?: (context: ProviderBridgeContext) => void;
-    /** Stdin closed: the runtime is gone and the bridge must shut down. */
     onClose?: () => void;
     onSigterm?: () => void;
     onSigint?: () => void;
 }
 interface ProviderBridgeEntry extends ProviderBridgeDefinition {
-    /** Bumped when the bootstrap↔bridge contract changes incompatibly. */
     experimental_apiVersion: 1;
 }
 declare function experimental_defineProviderBridge(definition: ProviderBridgeDefinition): ProviderBridgeEntry;
 
-/**
- * Sessionless provider maintenance query. `providerOptions` carries the same
- * provider-scoped statics as model/list (notably an ACP launch spec), while
- * `providerId` lets one bridge implementation serve several provider ids.
- */
 declare const providerMaintenanceParamsSchema: z.ZodObject<{
     cwd: z.ZodOptional<z.ZodString>;
     providerId: z.ZodString;
@@ -4198,11 +3750,6 @@ declare const providerInstallationStatusParamsSchema: z.ZodObject<{
     }>>;
 }, z.core.$loose>;
 type ProviderInstallationStatusParams = z.infer<typeof providerInstallationStatusParamsSchema>;
-/**
- * Cheap, host-local readiness reported by a provider implementation. Network
- * usage and update checks deliberately live outside this result so choosing a
- * provider for the composer never waits on them.
- */
 declare const providerHealthSchema: z.ZodObject<{
     accountEmail: z.ZodNullable<z.ZodString>;
     canInstall: z.ZodBoolean;
@@ -4222,7 +3769,6 @@ declare const providerHealthSchema: z.ZodObject<{
     statusMessage: z.ZodNullable<z.ZodString>;
 }, z.core.$loose>;
 type ProviderHealth = z.infer<typeof providerHealthSchema>;
-/** One usage window reported by a provider subscription. */
 declare const providerUsageWindowSchema: z.ZodObject<{
     cost: z.ZodOptional<z.ZodObject<{
         limitUsdCents: z.ZodNumber;
@@ -4233,7 +3779,6 @@ declare const providerUsageWindowSchema: z.ZodObject<{
     usedPercent: z.ZodNumber;
 }, z.core.$loose>;
 type ProviderUsageWindow = z.infer<typeof providerUsageWindowSchema>;
-/** Live usage for one provider, normalized by that provider's bridge. */
 declare const providerUsageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     accountEmail: z.ZodNullable<z.ZodString>;
     planLabel: z.ZodNullable<z.ZodString>;
@@ -4320,11 +3865,6 @@ declare const providerInstallationActionKindSchema: z.ZodEnum<{
     update: "update";
 }>;
 type ProviderInstallationActionKind = z.infer<typeof providerInstallationActionKindSchema>;
-/**
- * An installation action that a provider currently knows how to perform.
- * Only the display command crosses the product boundary; the executable plan
- * is resolved afresh by `provider/installation/run` on the host.
- */
 declare const providerInstallationActionSchema: z.ZodObject<{
     command: z.ZodString;
     kind: z.ZodEnum<{
@@ -4343,7 +3883,6 @@ declare const providerInstallationSourceSchema: z.ZodEnum<{
     npmGlobal: "npmGlobal";
 }>;
 type ProviderInstallationSource = z.infer<typeof providerInstallationSourceSchema>;
-/** Provider-owned installation and update state for one host. */
 declare const providerInstallationStatusSchema: z.ZodObject<{
     currentVersion: z.ZodNullable<z.ZodString>;
     executableName: z.ZodString;
@@ -4383,10 +3922,6 @@ declare const providerInstallationRunParamsSchema: z.ZodObject<{
     providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$loose>;
 type ProviderInstallationRunParams = z.infer<typeof providerInstallationRunParamsSchema>;
-/**
- * A typed process plan. The provider chooses the executable and arguments;
- * the daemon chooses the environment and cwd and owns process supervision.
- */
 declare const providerInstallationCommandSchema: z.ZodObject<{
     args: z.ZodArray<z.ZodString>;
     command: z.ZodString;
@@ -4403,10 +3938,6 @@ declare const providerInstallationVerificationSchema: z.ZodDiscriminatedUnion<[z
     version: z.ZodString;
 }, z.core.$loose>], "kind">;
 type ProviderInstallationVerification = z.infer<typeof providerInstallationVerificationSchema>;
-/**
- * `available: false` handles a stale action safely: status may have changed
- * between rendering a button and the daemon resolving the execution plan.
- */
 declare const providerInstallationRunResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     available: z.ZodLiteral<false>;
     message: z.ZodString;
@@ -4429,70 +3960,27 @@ declare const providerInstallationRunResultSchema: z.ZodDiscriminatedUnion<[z.Zo
 }, z.core.$loose>], "available">;
 type ProviderInstallationRunResult = z.infer<typeof providerInstallationRunResultSchema>;
 
-/**
- * The executable's absolute path: the path itself when `command` is
- * absolute and executable (a launch seam may name one), otherwise the first
- * `which`/`where` hit; null when the host has no such command.
- */
 declare function resolveExecutablePath(command: string): Promise<string | null>;
-/**
- * `<command> <args>` stdout and stderr, trimmed, within the installation
- * check budget; null when the command is missing, fails or times out.
- */
 declare function commandOutput(command: string, args: readonly string[]): Promise<string | null>;
-/** The first `x.y.z[-prerelease]` token in `value` (an optional `v` prefix dropped). */
 declare function versionFrom(value: string | null): string | null;
-/**
- * `<command> --version` → the version it printed (stdout or stderr), null
- * when the command is missing or does not answer within the probe budget.
- */
 declare function readCliVersion(command: string): Promise<string | null>;
-/**
- * Semver-style compare: numeric core first, then a prerelease sorts before
- * its release (`1.2.0-beta.1` < `1.2.0`). Anything that is not `x.y.z[-pre]`
- * reads as `0.0.0`.
- */
 declare function compareVersions(left: string, right: string): number;
-/** The npm executable for this platform. */
 declare function npmCommand(): string;
-/** A command line for display: each argument single-quoted unless it is plain. */
 declare function formatCommand(command: string, args: readonly string[]): string;
-/**
- * `npm install -g <package>@latest`: the install action for an npm-published
- * CLI, and the update action for one without a self-updater.
- */
 declare function npmGlobalInstallCommand(npmPackage: string): ProviderInstallationCommand;
-/** The registry's latest version of the package (`npm view <package> version`). */
 declare function npmLatestVersion(npmPackage: string): Promise<string | null>;
 interface NpmGlobalPackageProbe {
-    /** npm's global bin directory (`npm prefix -g`, plus `bin` off Windows); null when npm is absent. */
     npmBin: string | null;
-    /** The version npm has installed globally for the package; null when none. */
     npmGlobalPackageVersion: string | null;
 }
-/** What npm knows about a globally installed package. */
 declare function probeNpmGlobalPackage(npmPackage: string): Promise<NpmGlobalPackageProbe>;
-/**
- * Where an installed CLI came from: inside npm's global bin directory it is
- * npm's (`npmGlobal`), anywhere else it is the user's own (`external`).
- */
 declare function npmGlobalInstallSource(args: {
     installed: boolean;
     executablePath: string | null;
     npmBin: string | null;
 }): ProviderInstallationSource;
-/**
- * How the runtime verifies an install run: an install is done once the
- * executable exists; an update is done once the version reaches the latest
- * the status saw, or — when the registry was unreachable — once it changed.
- */
 declare function installationVerification(status: Pick<ProviderInstallationStatus, "currentVersion" | "latestVersion">, action: "install" | "update"): ProviderInstallationVerification;
-/**
- * A vendor's `curl | bash` installer, run from a temp file so a truncated
- * download never executes half a script.
- */
 declare function downloadedInstallerCommand(url: string): ProviderInstallationCommand;
-/** A usage percentage as the integer 0–100 the usage surfaces render. */
 declare function clampPercent(value: number): number;
 
 type JsonRpcObject = Record<string, unknown>;
@@ -4544,13 +4032,6 @@ declare function getRecordProperty(value: StringRecord, key: string): StringReco
 declare function getStringProperty(value: StringRecord, key: string): string | undefined;
 declare function getRawSdkMessage(event: JsonRpcMessage): StringRecord | null;
 
-/**
- * Zod schemas for well-known tool arguments used by both Claude Code and Pi
- * bridges.
- *
- * These tools genuinely use different arg names across SDK versions, so the
- * schemas express the real variants rather than picking one.
- */
 declare const bashArgsSchema: z.ZodObject<{
     command: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
@@ -4560,80 +4041,17 @@ declare const textBlockSchema: z.ZodObject<{
     type: z.ZodLiteral<"text">;
 }, z.core.$strip>;
 
-/**
- * The bb Provider Bridge Protocol version.
- *
- * Negotiated in both directions during `initialize`. Bump only for changes an
- * older bridge or runtime cannot tolerate: removing a method, changing the
- * meaning of an existing field, or tightening a previously lenient parse.
- * Additive changes (new optional capability, new method a bridge may not
- * implement, new notification the runtime may not understand) do NOT bump the
- * version — unknown methods answer -32601, unknown notifications are ignored,
- * and unknown capability fields pass through. That tolerance is the point of
- * the protocol: bridges version with their plugin, not with the daemon.
- *
- * Version history:
- * - 2 (2026-08): the narrow-grammar cutover. `thread/event` is gone; the
- *   timeline rides `thread/delta` exclusively and the runtime assembles
- *   canonical events. A version-1 bridge still emits `thread/event`
- *   notifications the runtime no longer understands, so the runtime rejects
- *   a mismatched handshake instead of silently showing an empty timeline.
- * - 1: the original dialect — bridges emitted finished `ThreadEvent`s on
- *   `thread/event`.
- */
 declare const PROVIDER_BRIDGE_PROTOCOL_VERSION: 2;
-/**
- * The `thread/delta` grammar versions. The grammar is versioned separately
- * from the JSON-RPC envelope (see `grammarVersions` in handshake.ts): v2 was
- * the narrow grammar that shipped with protocol version 2; v3 adds the core
- * item kinds `fileRead`, `search`, `delegation` and `planSteps`, declarative
- * `presentation` on `item.open`/`item.close`, plugin extension kinds
- * (`extension` items, `extension.state`), and replaces v2's two streaming
- * dialects and two usage dialects with one of each (`item.textDelta`/
- * `item.textClose`, `usage` + `contextWindow`). A bridge reports the range
- * it speaks; the runtime reports the range its assembler accepts; both emit
- * the highest common version. The runtime's assembler speaks v3 only; a
- * bridge that predates `grammarVersions` reads as `[2, 2]` and is refused at
- * the handshake.
- */
 declare const THREAD_DELTA_GRAMMAR_V2: 2;
 declare const THREAD_DELTA_GRAMMAR_V3: 3;
 
-/**
- * The inclusive `[min, max]` range of `thread/delta` grammar versions a bridge
- * speaks. Distinct from the JSON-RPC `protocolVersion`: the envelope can stay
- * put while the delta vocabulary grows, and a bridge that speaks both v2 and
- * v3 says so here instead of forcing a daemon bump.
- */
 declare const bridgeGrammarVersionsSchema: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
 type BridgeGrammarVersions = z.infer<typeof bridgeGrammarVersionsSchema>;
-/**
- * How the bridge delivers `turn/steer` while a turn is live. `inject` feeds
- * the steer text into the running model loop (claude, codex); `queue` holds
- * it for the next prompt boundary (ACP v1 cancels the live prompt and
- * re-prompts with the queued text). The runtime sends `turn/steer` either
- * way and drops a steer whose turn is gone on the bridge's `staleTurn`
- * recovery hint whatever the mode; nothing reads the mode yet (see
- * `steerMode` below).
- */
 declare const bridgeSteerModeSchema: z.ZodEnum<{
     inject: "inject";
     queue: "queue";
 }>;
 type BridgeSteerMode = z.infer<typeof bridgeSteerModeSchema>;
-/**
- * Session-behavior facts the bridge reports at `initialize`. These are
- * deliberately NOT provider declarations: the code that implements a feature
- * is the code that reports it, so a handshake fact cannot drift from behavior
- * the way a declared boolean can.
- *
- * Every field defaults on parse so an older bridge that omits a capability is
- * read as not having it — absence is a definite "no", never an error, and the
- * parsed object always carries explicit values internally.
- *
- * The schema is loose: unknown capability fields from a newer bridge pass
- * through untouched so a newer plugin works against an older runtime.
- */
 declare const bridgeCapabilitiesSchema: z.ZodObject<{
     approvalEnforcedBy: z.ZodDefault<z.ZodEnum<{
         provider: "provider";
@@ -4658,7 +4076,6 @@ declare const bridgeCapabilitiesSchema: z.ZodObject<{
     threadRename: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$loose>;
 type BridgeCapabilities = z.infer<typeof bridgeCapabilitiesSchema>;
-/** Runtime → bridge `initialize` params. */
 declare const initializeParamsSchema: z.ZodObject<{
     client: z.ZodObject<{
         name: z.ZodString;
@@ -4667,7 +4084,6 @@ declare const initializeParamsSchema: z.ZodObject<{
     grammarVersions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     protocolVersion: z.ZodNumber;
 }, z.core.$loose>;
-/** Bridge → runtime `initialize` result. */
 declare const initializeResultSchema: z.ZodObject<{
     capabilities: z.ZodPipe<z.ZodTransform<{}, unknown>, z.ZodObject<{
         approvalEnforcedBy: z.ZodDefault<z.ZodEnum<{
@@ -4696,20 +4112,6 @@ declare const initializeResultSchema: z.ZodObject<{
 }, z.core.$loose>;
 type InitializeResult = z.infer<typeof initializeResultSchema>;
 
-/**
- * The canonical execution options carried on session and turn commands.
- *
- * Deliberately provider-agnostic: there are no provider-specific fields here
- * and none may be added. Provider-flavored knobs (Claude's plan mode, memory
- * and subagent toggles, mock-CLI traffic, …) travel in `providerOptions` — an
- * opaque bag the provider's own plugin derives from its settings and only its
- * bridge interprets. The runtime and server pass it through untouched.
- *
- * The runtime never diffs these options. They ride every command; the bridge
- * reconciles internally (apply live where it can, rebuild its provider
- * session where it must) and a rebuild is always reported via the
- * `session/replaced` notification — never silent.
- */
 declare const bridgeExecutionOptionsSchema: z.ZodIntersection<z.ZodObject<{
     envVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     instructions: z.ZodOptional<z.ZodString>;
@@ -4754,13 +4156,6 @@ declare const bridgeExecutionOptionsSchema: z.ZodIntersection<z.ZodObject<{
 }, z.core.$strip>], "permissionMode">>;
 type BridgeExecutionOptions = z.infer<typeof bridgeExecutionOptionsSchema>;
 
-/**
- * Canonical runtime → bridge request methods. One vocabulary for every
- * provider: a bridge maps these to its provider's native dialect internally
- * (codex `thread/stop` → `turn/interrupt`, `thread/discard` →
- * `thread/archive`, …). Methods gated by a handshake capability are simply
- * never sent to a bridge that did not advertise them.
- */
 declare const BRIDGE_REQUEST_METHODS: {
     readonly initialize: "initialize";
     readonly modelList: "model/list";
@@ -5371,13 +4766,6 @@ declare const turnSteerParamsSchema: z.ZodObject<{
     providerThreadId: z.ZodString;
     threadId: z.ZodString;
 }, z.core.$loose>;
-/**
- * The canonical skill-injection payload. One shape for every provider: the
- * staged roots plus their skills. Each bridge transforms a root into its
- * provider's native form (a Claude local plugin, a codex extra skills root, a
- * pi additional skill path, an ACP prompt listing) — the per-provider shapes
- * never cross the wire.
- */
 declare const skillsConfigureParamsSchema: z.ZodObject<{
     roots: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -5389,13 +4777,6 @@ declare const skillsConfigureParamsSchema: z.ZodObject<{
     }, z.core.$loose>>;
 }, z.core.$loose>;
 
-/**
- * Bridge → runtime notifications. Everything timeline-bound (assistant text,
- * tool calls, token usage, context-window usage, …) rides `thread/delta`
- * (see thread-delta.ts) as parsed semantic deltas the runtime's assembler
- * turns into canonical `ThreadEvent`s. The notifications here are runtime
- * signals that are not timeline events.
- */
 declare const BRIDGE_NOTIFICATION_METHODS: {
     readonly threadIdentity: "thread/identity";
     readonly sessionReplaced: "session/replaced";
@@ -5403,26 +4784,6 @@ declare const BRIDGE_NOTIFICATION_METHODS: {
     readonly providerRecovery: "provider/recovery";
     readonly error: "error";
 };
-/**
- * A typed recovery hint: the bridge tells the runtime WHAT went wrong in the
- * runtime's own vocabulary, so the runtime never matches provider error text
- * (the codex regex set, the account-restart list, the archive idempotency
- * string match all go away in WS4). A runtime signal, not a timeline item —
- * the user-visible consequence, when there is one, is the `provider/error`
- * delta the bridge emits alongside, and the timeline stays free of
- * "restarting the bridge" noise. Lives here with `session/replaced` rather
- * than in `thread/delta` for the same reason `provider/raw` does: it is
- * consumed by the runtime's recovery logic, never persisted.
- *
- * `threadId` is absent for provider-wide conditions (`authRequired`,
- * `rateLimited` at the account level) and present when the hint is about one
- * session (`sessionArchived`, `staleTurn`). `retryable` says whether the
- * runtime may retry the failed command after acting on the hint.
- *
- * Unsolicited hints only: a condition that is the reason a runtime request
- * failed rides that request's error response as `error.data.recovery`
- * (see `bridgeErrorDataSchema`), never this notification as well.
- */
 declare const providerRecoveryNotificationSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         authRequired: "authRequired";
@@ -5437,11 +4798,6 @@ declare const providerRecoveryNotificationSchema: z.ZodObject<{
 }, z.core.$loose>;
 type ProviderRecoveryNotification = z.infer<typeof providerRecoveryNotificationSchema>;
 
-/**
- * Bridge → runtime requests: the two channels where the provider needs an
- * answer from bb mid-turn. Both carry canonical bb shapes — the bridge maps
- * its provider's native forms in both directions.
- */
 declare const BRIDGE_INBOUND_REQUEST_METHODS: {
     readonly toolCall: "item/tool/call";
     readonly interactionRequest: "interaction/request";
@@ -5449,22 +4805,8 @@ declare const BRIDGE_INBOUND_REQUEST_METHODS: {
 
 interface SanitizeInheritedChildProcessEnvArgs {
     env: NodeJS.ProcessEnv;
-    /**
-     * The user's login-shell PATH, substituted for the inherited one. Omit to
-     * keep the parent's PATH: that is a real distinction, not a default. A
-     * daemon started by launchd or systemd inherits a minimal PATH that finds
-     * none of the user's tools, so anything spawning user-facing executables
-     * (plugin hosts, provider bridges) passes the resolved shell PATH, while a
-     * child that must run exactly what the parent runs must not.
-     */
     shellPath?: string;
 }
-/**
- * The one answer to "what does a bb-spawned child process inherit": the
- * parent's env minus bb runtime-owned variables (`BB_*`) and `NODE_ENV`,
- * optionally with the user's login-shell PATH substituted. Callers overlay
- * only the child-specific bb env they intentionally expose afterward.
- */
 declare function sanitizeInheritedChildProcessEnv(args: SanitizeInheritedChildProcessEnvArgs): NodeJS.ProcessEnv;
 
 declare const acpLaunchSpecSchema: z.ZodObject<{
@@ -5576,13 +4918,6 @@ declare const acpLaunchSpecSchema: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 type AcpLaunchSpec = z.infer<typeof acpLaunchSpecSchema>;
-/**
- * The spec with its empty optional parts dropped: a `modelCli` that lists
- * nothing, a `permissionCli` that names no mode, and every absent field.
- * Two specs that launch the same agent then compare equal field by field,
- * which is what the SDK's `normalizeHostDaemonAcpLaunchSpec` (0.4.x) promised
- * a bridge; nothing in this repository keys on the normalized form any more.
- */
 declare function normalizeAcpLaunchSpec(spec: AcpLaunchSpec): AcpLaunchSpec;
 
 /**