@get-bb/plugin-sdk 0.4.30 → 0.4.35

package/bundled-types/bb-plugin-sdk-internal-host-policy.d.ts

@@ -61,9 +61,393 @@ interface ProviderNativeRootsInputLike {
     readonly project?: readonly ProviderNativeRootInput[];
 }
 
+declare const environmentSchema: z.ZodObject<{
+    baseBranch: z.ZodNullable<z.ZodString>;
+    branchName: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNumber;
+    defaultBranch: z.ZodNullable<z.ZodString>;
+    hostId: z.ZodString;
+    id: z.ZodString;
+    isGitRepo: z.ZodBoolean;
+    isWorktree: z.ZodBoolean;
+    managed: z.ZodBoolean;
+    mergeBaseBranch: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+    path: z.ZodNullable<z.ZodString>;
+    projectId: z.ZodString;
+    status: z.ZodEnum<{
+        destroyed: "destroyed";
+        destroying: "destroying";
+        error: "error";
+        provisioning: "provisioning";
+        ready: "ready";
+        retiring: "retiring";
+    }>;
+    updatedAt: z.ZodNumber;
+    workspaceProvisionType: z.ZodEnum<{
+        "managed-worktree": "managed-worktree";
+        personal: "personal";
+        unmanaged: "unmanaged";
+    }>;
+}, z.core.$strip>;
+type Environment = z.infer<typeof environmentSchema>;
+
+declare const hostSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    id: z.ZodString;
+    lastRejectedProtocolVersion: z.ZodNullable<z.ZodNumber>;
+    lastSeenAt: z.ZodNullable<z.ZodNumber>;
+    maxPermissionMode: z.ZodEnum<{
+        "accept-edits": "accept-edits";
+        auto: "auto";
+        full: "full";
+    }>;
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        connected: "connected";
+        disconnected: "disconnected";
+    }>;
+    type: z.ZodEnum<{
+        persistent: "persistent";
+    }>;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+type Host = z.infer<typeof hostSchema>;
+
+declare const projectSchema: z.ZodObject<{
+    createdAt: z.ZodNumber;
+    gitRemoteUrl: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        personal: "personal";
+        standard: "standard";
+    }>;
+    name: z.ZodString;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+type Project = z.infer<typeof projectSchema>;
+
+declare const reasoningLevelSchema: z.ZodEnum<{
+    high: "high";
+    low: "low";
+    max: "max";
+    medium: "medium";
+    none: "none";
+    ultra: "ultra";
+    ultracode: "ultracode";
+    xhigh: "xhigh";
+}>;
+type ReasoningLevel = z.infer<typeof reasoningLevelSchema>;
+declare const serviceTierSchema: z.ZodEnum<{
+    default: "default";
+    fast: "fast";
+}>;
+type ServiceTier = z.infer<typeof serviceTierSchema>;
+declare const permissionModeSchema: z.ZodEnum<{
+    "accept-edits": "accept-edits";
+    auto: "auto";
+    full: "full";
+}>;
+type PermissionMode = z.infer<typeof permissionModeSchema>;
+declare const promptInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mentions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        end: z.ZodNumber;
+        resource: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"thread">;
+            label: z.ZodString;
+            projectId: z.ZodOptional<z.ZodString>;
+            threadId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"project">;
+            label: z.ZodString;
+            projectId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"section">;
+            label: z.ZodString;
+            sectionId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            entryKind: z.ZodEnum<{
+                directory: "directory";
+                file: "file";
+            }>;
+            kind: z.ZodLiteral<"path">;
+            label: z.ZodString;
+            path: z.ZodString;
+            source: z.ZodEnum<{
+                "thread-storage": "thread-storage";
+                workspace: "workspace";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            argumentHint: z.ZodNullable<z.ZodString>;
+            kind: z.ZodLiteral<"command">;
+            label: z.ZodString;
+            name: z.ZodString;
+            origin: z.ZodEnum<{
+                builtin: "builtin";
+                project: "project";
+                user: "user";
+            }>;
+            source: z.ZodEnum<{
+                command: "command";
+                skill: "skill";
+            }>;
+            trigger: z.ZodEnum<{
+                "/": "/";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            itemId: z.ZodString;
+            kind: z.ZodLiteral<"plugin">;
+            label: z.ZodString;
+            pluginId: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        start: z.ZodNumber;
+    }, z.core.$strip>>>;
+    text: z.ZodString;
+    type: z.ZodLiteral<"text">;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        "agent-only": "agent-only";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    url: z.ZodString;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        "agent-only": "agent-only";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodLiteral<"localImage">;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        "agent-only": "agent-only";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    mimeType: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodLiteral<"localFile">;
+    visibility: z.ZodOptional<z.ZodEnum<{
+        "agent-only": "agent-only";
+    }>>;
+}, z.core.$strip>], "type">;
+type PromptInput = z.infer<typeof promptInputSchema>;
+declare const callerExecutionInputSourceSchema: z.ZodEnum<{
+    "client-preference": "client-preference";
+    explicit: "explicit";
+}>;
+type CallerExecutionInputSource = z.infer<typeof callerExecutionInputSourceSchema>;
+
 declare const PROVIDER_FORK_VALUES: readonly ["none", "tip", "checkpoint"];
 type ProviderFork = (typeof PROVIDER_FORK_VALUES)[number];
 
+declare const threadQueuedMessageSchema: z.ZodObject<{
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mentions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            end: z.ZodNumber;
+            resource: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"thread">;
+                label: z.ZodString;
+                projectId: z.ZodOptional<z.ZodString>;
+                threadId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"project">;
+                label: z.ZodString;
+                projectId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"section">;
+                label: z.ZodString;
+                sectionId: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                entryKind: z.ZodEnum<{
+                    directory: "directory";
+                    file: "file";
+                }>;
+                kind: z.ZodLiteral<"path">;
+                label: z.ZodString;
+                path: z.ZodString;
+                source: z.ZodEnum<{
+                    "thread-storage": "thread-storage";
+                    workspace: "workspace";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                argumentHint: z.ZodNullable<z.ZodString>;
+                kind: z.ZodLiteral<"command">;
+                label: z.ZodString;
+                name: z.ZodString;
+                origin: z.ZodEnum<{
+                    builtin: "builtin";
+                    project: "project";
+                    user: "user";
+                }>;
+                source: z.ZodEnum<{
+                    command: "command";
+                    skill: "skill";
+                }>;
+                trigger: z.ZodEnum<{
+                    "/": "/";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                icon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                itemId: z.ZodString;
+                kind: z.ZodLiteral<"plugin">;
+                label: z.ZodString;
+                pluginId: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            start: z.ZodNumber;
+        }, z.core.$strip>>>;
+        text: z.ZodString;
+        type: z.ZodLiteral<"text">;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            "agent-only": "agent-only";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        url: z.ZodString;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            "agent-only": "agent-only";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        path: z.ZodString;
+        type: z.ZodLiteral<"localImage">;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            "agent-only": "agent-only";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        mimeType: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        path: z.ZodString;
+        sizeBytes: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodLiteral<"localFile">;
+        visibility: z.ZodOptional<z.ZodEnum<{
+            "agent-only": "agent-only";
+        }>>;
+    }, z.core.$strip>], "type">>;
+    createdAt: z.ZodNumber;
+    editable: z.ZodBoolean;
+    failureReason: z.ZodNullable<z.ZodString>;
+    groupWithNext: z.ZodBoolean;
+    id: z.ZodString;
+    model: z.ZodString;
+    payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+    }, z.core.$strip>, z.ZodObject<{
+        attempt: z.ZodNumber;
+        kind: z.ZodLiteral<"retry">;
+        reason: z.ZodString;
+        retryOfTurnRequestId: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    permissionMode: z.ZodEnum<{
+        "accept-edits": "accept-edits";
+        auto: "auto";
+        full: "full";
+    }>;
+    reasoningLevel: z.ZodEnum<{
+        high: "high";
+        low: "low";
+        max: "max";
+        medium: "medium";
+        none: "none";
+        ultra: "ultra";
+        ultracode: "ultracode";
+        xhigh: "xhigh";
+    }>;
+    sendAt: z.ZodNullable<z.ZodNumber>;
+    serviceTier: z.ZodEnum<{
+        default: "default";
+        fast: "fast";
+    }>;
+    threadId: z.ZodString;
+    updatedAt: z.ZodNumber;
+    waitingOn: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"time">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"thread-busy">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"turn-starting">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"provisioning">;
+    }, z.core.$strip>, z.ZodObject<{
+        hostName: z.ZodString;
+        kind: z.ZodLiteral<"host-offline">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"interaction">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"plugin">;
+        pluginId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+type ThreadQueuedMessage = z.infer<typeof threadQueuedMessageSchema>;
+
+declare const threadCreateOriginSchema: z.ZodEnum<{
+    app: "app";
+    cli: "cli";
+    plugin: "plugin";
+    sdk: "sdk";
+}>;
+type ThreadCreateOrigin = z.infer<typeof threadCreateOriginSchema>;
+type ExecutionInputFieldSource = CallerExecutionInputSource;
+declare const startedOnBehalfOfSchema: z.ZodObject<{
+    initiator: z.ZodEnum<{
+        agent: "agent";
+        system: "system";
+    }>;
+    senderThreadId: z.ZodString;
+}, z.core.$strip>;
+type StartedOnBehalfOf = z.infer<typeof startedOnBehalfOfSchema>;
+declare const threadResponseSchema: z.ZodObject<{
+    activeBackgroundAgentCount: z.ZodNumber;
+    archivedAt: z.ZodNullable<z.ZodNumber>;
+    canSpawnChild: z.ZodBoolean;
+    createdAt: z.ZodNumber;
+    deletedAt: z.ZodNullable<z.ZodNumber>;
+    environmentId: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    lastReadAt: z.ZodNullable<z.ZodNumber>;
+    latestAttentionAt: z.ZodNumber;
+    originKind: z.ZodNullable<z.ZodEnum<{
+        fork: "fork";
+    }>>;
+    originPluginId: z.ZodNullable<z.ZodString>;
+    parentThreadId: z.ZodNullable<z.ZodString>;
+    pinnedAt: z.ZodNullable<z.ZodNumber>;
+    projectId: z.ZodString;
+    providerId: z.ZodString;
+    queuedMessageCount: z.ZodNumber;
+    runtime: z.ZodObject<{
+        displayStatus: z.ZodEnum<{
+            "host-reconnecting": "host-reconnecting";
+            "waiting-for-host": "waiting-for-host";
+            active: "active";
+            error: "error";
+            idle: "idle";
+            pending: "pending";
+            provisioning: "provisioning";
+            starting: "starting";
+            stopping: "stopping";
+        }>;
+        hostReconnectGraceExpiresAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    sectionId: z.ZodNullable<z.ZodString>;
+    sourceThreadId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        active: "active";
+        error: "error";
+        idle: "idle";
+        pending: "pending";
+        starting: "starting";
+        stopping: "stopping";
+    }>;
+    title: z.ZodNullable<z.ZodString>;
+    titleFallback: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodNumber;
+    visibility: z.ZodEnum<{
+        hidden: "hidden";
+        visible: "visible";
+    }>;
+}, z.core.$strip>;
+type ThreadResponse = z.infer<typeof threadResponseSchema>;
+
 /**
  * A value that survives a JSON round trip without coercion or data loss.
  *
@@ -75,7 +459,7 @@ type JsonValue = string | number | boolean | null | JsonValue[] | {
 };
 
 /**
- * The validator-neutral subset of Standard Schema v1 used by plugin RPC.
+ * The validator-neutral subset of Standard Schema v1 used by plugin contracts.
  * Zod 4 schemas implement this interface directly; other validators can do
  * the same without becoming part of BB's public protocol.
  */
@@ -107,11 +491,6 @@ interface PluginRpcMethodContract<InputSchema extends StandardSchemaV1 = Standar
     readonly output: OutputSchema;
 }
 
-/**
- * Declarative settings descriptors (`bb.settings.define`). Deliberately plain
- * data — not zod — so the host can render settings forms and the CLI can
- * parse values without executing plugin code.
- */
 type PluginSettingDescriptor = {
     type: "string";
     label: string;
@@ -123,26 +502,179 @@ type PluginSettingDescriptor = {
      * be multi-line.
      */
     experimental_multiline?: boolean;
+    /** Synchronously validate without transforming a proposed value. */
+    experimental_schema?: StandardSchemaV1<string, string>;
     default?: string;
 } | {
     type: "boolean";
     label: string;
     description?: string;
+    /** Synchronously validate without transforming a proposed value. */
+    experimental_schema?: StandardSchemaV1<boolean, boolean>;
     default?: boolean;
 } | {
     type: "select";
     label: string;
     description?: string;
     options: string[];
+    /** Synchronously validate without transforming a proposed value. */
+    experimental_schema?: StandardSchemaV1<string, string>;
     default?: string;
 } | {
     type: "project";
     label: string;
     description?: string;
+    /** Synchronously validate without transforming a proposed value. */
+    experimental_schema?: StandardSchemaV1<string, string>;
     default?: string;
 };
 type PluginSettingDescriptors = Record<string, PluginSettingDescriptor>;
 type PluginSettingValue = string | boolean;
+/**
+ * What a `message.dispatch` hook answers.
+ *
+ * `proceed` lets the attempt continue. `wait` QUEUES the message as a row
+ * whose `waitingOn` names this plugin and carries `reason` verbatim; the
+ * row stays queued until `sendAt` comes due, capacity frees, the user sends
+ * it now, or the orphan sweep clears it because this plugin is no longer
+ * running. `sendAt` (epoch ms) sets the row's own `sendAt`, so core's due sweep
+ * re-attempts at that instant without the plugin holding a timer of its own —
+ * which is what a rate-limit window wants. `reject` refuses the attempt
+ * outright: `message` is shown to the user verbatim.
+ *
+ * There is deliberately no "handled it myself" answer and no amendment arm —
+ * a hook is a decision, never an owner or an author of the work.
+ */
+type MessageDispatchHookDecision = {
+    action: "proceed";
+} | {
+    action: "wait";
+    reason: string;
+    sendAt?: number | null;
+} | {
+    action: "reject";
+    message: string;
+};
+/**
+ * The execution tuple as core resolved it before this hook ran. `model` and
+ * the three option fields are null only when no default has been resolved for
+ * them yet; `providerId` is always resolved.
+ */
+interface PluginDispatchExecution {
+    providerId: string;
+    model: string | null;
+    reasoningLevel: ReasoningLevel | null;
+    serviceTier: ServiceTier | null;
+    permissionMode: PermissionMode | null;
+}
+/**
+ * Where each execution value came from. `explicit` is a user choice,
+ * `client-preference` a remembered client default, and null means core
+ * resolved it from project/provider defaults. A hook that must not act against
+ * a deliberate choice checks for `explicit` here.
+ */
+interface PluginDispatchExecutionSources {
+    providerId: ExecutionInputFieldSource | null;
+    model: ExecutionInputFieldSource | null;
+    reasoningLevel: ExecutionInputFieldSource | null;
+    serviceTier: ExecutionInputFieldSource | null;
+    permissionMode: ExecutionInputFieldSource | null;
+}
+/**
+ * The prompt this dispatch carries. `blocks` is the message itself; `text` is
+ * the concatenated text of its text blocks, which is what a rules-based hook
+ * actually wants to match on.
+ */
+interface PluginDispatchInput {
+    blocks: readonly PromptInput[];
+    text: string;
+}
+/**
+ * How this attempt would reach the provider.
+ *
+ * `start-turn` is a dispatch that begins a turn: a thread's first message, a
+ * plain send to an idle or `pending` thread, or a steer-mode message that
+ * found no running turn to join. `join-turn` is an injection into a turn that
+ * is already executing.
+ *
+ * Decision powers are identical for both — a steer is hooked exactly like a
+ * send, uniformly. A hook that limits concurrency proceeds on `join-turn`: the
+ * thread already holds its slot, so joining it asks for nothing new.
+ */
+type PluginDispatchAttemptKind = "join-turn" | "start-turn";
+/**
+ * What core hands a `message.dispatch` hook: the one checkpoint, run before a
+ * message reaches a provider. The exception is a user's explicit Send-now on a
+ * queued row, which bypasses the pass by design — it is the user overriding
+ * policy, and a policy that could veto its own override would not be one.
+ *
+ * It runs identically whether the attempt is inline (someone just sent) or
+ * from a drain (a queued row became eligible again), and whether the message
+ * is a thread's first, a follow-up, a steer, or a retry of a failed turn. A
+ * handler must therefore be idempotent for one logical dispatch: passes re-run
+ * on every drain, on restart, and on retry.
+ */
+interface MessageDispatchHookContext {
+    /**
+     * The target thread. Never null: thread creation is unhooked — it is a cheap
+     * row — so by the time the first message is decided about, the thread exists
+     * in `pending`, with its provider resolved and nothing provisioned.
+     */
+    thread: ThreadResponse;
+    project: Project;
+    /** Null until an environment is chosen (a queued or not-yet-provisioned thread). */
+    environment: Environment | null;
+    /**
+     * The machine the work will run on. Resolved from the environment when one
+     * is attached, and before that from the start intent the thread was created
+     * with — so a per-host policy counts a cold start against the pool it is
+     * about to occupy. Null only when neither names a machine.
+     */
+    host: Host | null;
+    input: PluginDispatchInput;
+    requestedExecution: PluginDispatchExecution;
+    /** Where each execution value came from. */
+    executionSources: PluginDispatchExecutionSources;
+    /** Whether this attempt starts a turn or joins a running one. */
+    attempt: PluginDispatchAttemptKind;
+    /**
+     * The queued row this attempt is re-trying, or null when the attempt is
+     * inline and no row has ever existed for it.
+     *
+     * This is how a hook tells a fresh send from a re-attempt of something it
+     * already decided about — the replacement for the old
+     * `isReleaseReevaluation`/`hold` pair. A hook that counts in-flight work
+     * should treat the two identically; a hook that logs should not
+     * double-count.
+     */
+    queuedMessage: ThreadQueuedMessage | null;
+    /** How the dispatch was requested; null for internal/core-driven sends. */
+    origin: ThreadCreateOrigin | null;
+    originPluginId: string | null;
+    startedOnBehalfOf: StartedOnBehalfOf | null;
+    parentThreadId: string | null;
+}
+/**
+ * The hooks a plugin can answer, each mapping its key to the context core
+ * hands the handler and the decision core acts on. `on()` and the handler type
+ * derive from this map — and so does the server's hook registry — so a
+ * half-added hook does not compile.
+ *
+ * One hook today: `message.dispatch`, THE admission checkpoint, run identically
+ * for a thread's first message, a follow-up, a steer, a retry, and every
+ * re-attempt a drain makes. It replaced the earlier `thread.create` +
+ * `turn.submit` pair, whose split was an accident of where the code happened to
+ * branch rather than a difference a plugin needed to see — the attempt's own
+ * `attempt` kind carries what actually differs.
+ */
+interface PluginHookSignatures {
+    "message.dispatch": {
+        context: MessageDispatchHookContext;
+        decision: MessageDispatchHookDecision;
+    };
+}
+type PluginHookName = keyof PluginHookSignatures;
+type PluginHookHandler<K extends PluginHookName> = (context: PluginHookSignatures[K]["context"]) => PluginHookSignatures[K]["decision"] | Promise<PluginHookSignatures[K]["decision"]>;
 interface PluginCliOutputLimitError {
     code: "plugin_cli_output_too_large";
     message: string;
@@ -698,7 +1230,12 @@ declare function isStandardSchema(value: unknown): value is StandardSchemaV1;
 declare function readRpcMethodContract(method: string, value: unknown): PluginRpcMethodContract;
 /** Duck-typed zod detection: plugin sources may carry their own zod copy,
  * so instanceof is useless — anything with safeParse is treated as zod. */
-declare function isZodSchemaLike(value: unknown): boolean;
+type ZodSchemaLike = {
+    safeParse: z.ZodType["safeParse"];
+    toJSONSchema?: z.ZodType["toJSONSchema"];
+};
+declare function isZodSchemaLike(value: unknown): value is ZodSchemaLike;
+declare function zodSchemaToJsonSchema(schema: ZodSchemaLike): unknown;
 /**
  * Reject recursive local references before a tool schema reaches a provider.
  * Some providers reject the complete tool list when any one schema contains a
@@ -764,6 +1301,24 @@ declare function agentToolIconRefusalMessage(toolName: string, problem: string):
  * that entry.
  */
 declare function providerWithoutBridgeMessage(providerId: string): string;
+/**
+ * Files a hook handler under its key in a per-hook record.
+ *
+ * The record is a mapped type over the hook-name union, so writing to it
+ * through a generic key is not expressible soundly in TypeScript: this call
+ * site knows `handler` matches `hook`, but the checker only knows both range
+ * over the union and so demands their intersection. The erasure is confined to
+ * this one function; every READ is sound, because a slot is typed for its own
+ * hook and the runner builds the context for the hook it read the handler from.
+ *
+ * Shared by the real host (`plugin-api.ts`) and the fake one so both register
+ * hooks by the same rule, which is the point of every other helper here.
+ */
+declare function storePluginHook<K extends PluginHookName>(records: {
+    [N in PluginHookName]: PluginHookHandler<N> | null;
+}, hook: K, handler: PluginHookHandler<K>): void;
+/** The refusal a second handler for one hook from one plugin gets. */
+declare function pluginHookAlreadyRegisteredMessage(hook: PluginHookName): string;
 
-export { AGENT_TOOL_NAME_PATTERN, BACKGROUND_NAME_PATTERN, CLI_COMMAND_NAME_PATTERN, KV_VALUE_MAX_BYTES, MENTION_PROVIDER_ID_PATTERN, PLUGIN_AGENT_DYNAMIC_INSTRUCTIONS_MAX_CHARS, PLUGIN_AGENT_SELECTION_MAX_IDS, PLUGIN_AGENT_STATIC_INSTRUCTIONS_MAX_CHARS, PLUGIN_AGENT_STATUS_LABEL_MAX_CHARS, PLUGIN_AGENT_TOOL_PARAMETERS_MAX_BYTES, PLUGIN_HTTP_METHODS, PLUGIN_MENTION_TRIGGER_VALUES, PLUGIN_PROVIDER_BRIDGE_OPTIONS_MAX_BYTES, PLUGIN_PROVIDER_COMPOSER_ACTION_VALUES, PLUGIN_PROVIDER_DISPLAY_NAME_MAX_CHARS, PLUGIN_PROVIDER_PERMISSION_MODE_VALUES, PLUGIN_PROVIDER_REASONING_LEVEL_VALUES, PROVIDER_ID_PATTERN, RESERVED_AGENT_TOOL_NAMES, RESERVED_BB_CLI_COMMANDS, RPC_METHOD_PATTERN, SERVER_DIRECT_AI_SERVICE_IDS, SETTING_KEY_PATTERN, adoptHttpRouteResponse, agentToolIconRefusalMessage, aiServiceAlreadyRegisteredMessage, assertAiServiceRegistrable, assertNoRecursiveJsonSchemaReferences, deriveValidatedProviderOptions, enforcePluginCliOutputLimit, isPluginMentionTrigger, isStandardSchema, isZodSchemaLike, normalizeMentionProviderTriggers, parsePluginAgentToolPresentation, pluginCliCollisionWarning, providerAlreadyRegisteredMessage, providerIconRefusalMessage, providerWithoutBridgeMessage, readRpcMethodContract, registerSettingDescriptors, rejectStaleAgentToolFields, summarizeParseIssues, undeclaredIconProblem, validatePluginAiServiceDeclaration, validatePluginProviderDeclaration, validateSettingsUpdate };
+export { AGENT_TOOL_NAME_PATTERN, BACKGROUND_NAME_PATTERN, CLI_COMMAND_NAME_PATTERN, KV_VALUE_MAX_BYTES, MENTION_PROVIDER_ID_PATTERN, PLUGIN_AGENT_DYNAMIC_INSTRUCTIONS_MAX_CHARS, PLUGIN_AGENT_SELECTION_MAX_IDS, PLUGIN_AGENT_STATIC_INSTRUCTIONS_MAX_CHARS, PLUGIN_AGENT_STATUS_LABEL_MAX_CHARS, PLUGIN_AGENT_TOOL_PARAMETERS_MAX_BYTES, PLUGIN_HTTP_METHODS, PLUGIN_MENTION_TRIGGER_VALUES, PLUGIN_PROVIDER_BRIDGE_OPTIONS_MAX_BYTES, PLUGIN_PROVIDER_COMPOSER_ACTION_VALUES, PLUGIN_PROVIDER_DISPLAY_NAME_MAX_CHARS, PLUGIN_PROVIDER_PERMISSION_MODE_VALUES, PLUGIN_PROVIDER_REASONING_LEVEL_VALUES, PROVIDER_ID_PATTERN, RESERVED_AGENT_TOOL_NAMES, RESERVED_BB_CLI_COMMANDS, RPC_METHOD_PATTERN, SERVER_DIRECT_AI_SERVICE_IDS, SETTING_KEY_PATTERN, adoptHttpRouteResponse, agentToolIconRefusalMessage, aiServiceAlreadyRegisteredMessage, assertAiServiceRegistrable, assertNoRecursiveJsonSchemaReferences, deriveValidatedProviderOptions, enforcePluginCliOutputLimit, isPluginMentionTrigger, isStandardSchema, isZodSchemaLike, normalizeMentionProviderTriggers, parsePluginAgentToolPresentation, pluginCliCollisionWarning, pluginHookAlreadyRegisteredMessage, providerAlreadyRegisteredMessage, providerIconRefusalMessage, providerWithoutBridgeMessage, readRpcMethodContract, registerSettingDescriptors, rejectStaleAgentToolFields, storePluginHook, summarizeParseIssues, undeclaredIconProblem, validatePluginAiServiceDeclaration, validatePluginProviderDeclaration, validateSettingsUpdate, zodSchemaToJsonSchema };
 export type { AiServiceHostBinding, NormalizedPluginProviderDeclaration };

package/bundled-types/bb-plugin-sdk-internal-plugin-app-collector.d.ts

@@ -5,7 +5,7 @@
 // Confused by the API, or need a symbol that isn't here? Clone the BB repo
 // and read the real source: https://github.com/get-bb/bb
 
-import { PluginHomepageSectionRegistration, PluginSettingsSectionRegistration, PluginNavPanelRegistration, PluginThreadPanelActionRegistration, PluginNewThreadPanelActionRegistration, ComposerCustomization, PluginPendingInteractionRegistration, PluginSidebarFooterActionRegistration, PluginThreadListRegistration, PluginThreadHeaderActionRegistration, PluginFileOpenerRegistration, PluginSourceCodeRendererRegistration, PluginDiffRendererRegistration, PluginMessageDirectiveRegistration, PluginMessageActionRegistration, PluginCommandPaletteActionRegistration, PluginProviderIconRegistration, PluginTimelineRendererRegistration, PluginContentScriptRegistration, PluginAppDefinition } from '@get-bb/plugin-sdk';
+import { PluginHomepageSectionRegistration, PluginSettingsSectionRegistration, PluginNavPanelRegistration, PluginThreadPanelActionRegistration, PluginNewThreadPanelActionRegistration, ComposerCustomization, PluginPendingInteractionRegistration, PluginSidebarFooterActionRegistration, ExperimentalSidebarNavigationRegistration, PluginThreadListRegistration, PluginThreadHeaderActionRegistration, PluginFileOpenerRegistration, PluginSourceCodeRendererRegistration, PluginDiffRendererRegistration, PluginMessageDirectiveRegistration, PluginMessageActionRegistration, PluginCommandPaletteActionRegistration, PluginProviderIconRegistration, PluginTimelineRendererRegistration, PluginContentScriptRegistration, PluginAppDefinition } from '@get-bb/plugin-sdk';
 
 /** Validated registrations produced by one plugin app setup execution. */
 interface CollectedPluginAppRegistrations {
@@ -17,6 +17,7 @@ interface CollectedPluginAppRegistrations {
     composerCustomizations: ComposerCustomization[];
     pendingInteractions: PluginPendingInteractionRegistration[];
     sidebarFooterActions: PluginSidebarFooterActionRegistration[];
+    experimentalSidebarNavigations: ExperimentalSidebarNavigationRegistration[];
     threadLists: PluginThreadListRegistration[];
     threadHeaderActions: PluginThreadHeaderActionRegistration[];
     fileOpeners: PluginFileOpenerRegistration[];

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

@@ -2587,7 +2587,6 @@ declare const threadEventSchema: z.ZodPipe<z.ZodUnknown, z.ZodUnion<readonly [z.
     threadId: z.ZodString;
     type: z.ZodLiteral<"client/thread/start">;
 }, z.core.$strip>, z.ZodObject<{
-    continuationOfRequestId: z.ZodOptional<z.ZodString>;
     direction: z.ZodLiteral<"outbound">;
     execution: z.ZodObject<{
         model: z.ZodString;
@@ -2794,6 +2793,8 @@ declare const threadEventSchema: z.ZodPipe<z.ZodUnknown, z.ZodUnion<readonly [z.
         params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>;
     requestId: z.ZodString;
+    retryAttempt: z.ZodOptional<z.ZodNumber>;
+    retryOfRequestId: z.ZodOptional<z.ZodString>;
     senderThreadId: z.ZodNullable<z.ZodString>;
     source: z.ZodEnum<{
         spawn: "spawn";