@get-bb/plugin-sdk 0.4.30 → 0.4.34

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

@@ -211,6 +211,7 @@ declare const changedMessageSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
                     active: "active";
                     error: "error";
                     idle: "idle";
+                    pending: "pending";
                     provisioning: "provisioning";
                     starting: "starting";
                     stopping: "stopping";
@@ -221,6 +222,7 @@ declare const changedMessageSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
                 active: "active";
                 error: "error";
                 idle: "idle";
+                pending: "pending";
                 starting: "starting";
                 stopping: "stopping";
             }>;
@@ -639,6 +641,67 @@ declare const pluginPendingInteractionSchema: z$1.ZodObject<{
 type PluginPendingInteraction = z$1.infer<typeof pluginPendingInteractionSchema>;
 type PendingInteraction = ProviderPendingInteraction | PluginPendingInteraction;
 
+declare const providerErrorInfoSchema: z$1.ZodObject<{
+    category: z$1.ZodEnum<{
+        "active-turn-not-steerable": "active-turn-not-steerable";
+        "bad-request": "bad-request";
+        "budget-exceeded": "budget-exceeded";
+        "connection-failed": "connection-failed";
+        "context-window-exceeded": "context-window-exceeded";
+        "max-output-tokens": "max-output-tokens";
+        "max-turns": "max-turns";
+        "rate-limit": "rate-limit";
+        "stream-disconnected": "stream-disconnected";
+        "structured-output-retries": "structured-output-retries";
+        "thread-rollback-failed": "thread-rollback-failed";
+        "too-many-failed-attempts": "too-many-failed-attempts";
+        billing: "billing";
+        internal: "internal";
+        overloaded: "overloaded";
+        policy: "policy";
+        sandbox: "sandbox";
+        unauthorized: "unauthorized";
+        unknown: "unknown";
+    }>;
+    httpStatusCode: z$1.ZodNullable<z$1.ZodNumber>;
+    providerCode: z$1.ZodNullable<z$1.ZodString>;
+}, z$1.core.$strip>;
+type ProviderErrorInfo = z$1.infer<typeof providerErrorInfoSchema>;
+declare const providerRateLimitStateSchema: z$1.ZodObject<{
+    kind: z$1.ZodEnum<{
+        "spend-control": "spend-control";
+        "subscription-window": "subscription-window";
+        credits: "credits";
+        unknown: "unknown";
+    }>;
+    overageReason: z$1.ZodNullable<z$1.ZodString>;
+    overageStatus: z$1.ZodNullable<z$1.ZodEnum<{
+        allowed: "allowed";
+        rejected: "rejected";
+        unavailable: "unavailable";
+        warning: "warning";
+    }>>;
+    providerId: z$1.ZodString;
+    reachedReason: z$1.ZodNullable<z$1.ZodString>;
+    status: z$1.ZodEnum<{
+        allowed: "allowed";
+        blocked: "blocked";
+        unknown: "unknown";
+        warning: "warning";
+    }>;
+    windows: z$1.ZodArray<z$1.ZodObject<{
+        label: z$1.ZodNullable<z$1.ZodString>;
+        providerKey: z$1.ZodNullable<z$1.ZodString>;
+        resetsAtMs: z$1.ZodNullable<z$1.ZodNumber>;
+        status: z$1.ZodEnum<{
+            allowed: "allowed";
+            blocked: "blocked";
+            unknown: "unknown";
+            warning: "warning";
+        }>;
+    }, z$1.core.$strip>>;
+}, z$1.core.$strip>;
+type ProviderRateLimitState = z$1.infer<typeof providerRateLimitStateSchema>;
 declare const threadEventSchema: z$1.ZodPipe<z$1.ZodUnknown, z$1.ZodUnion<readonly [z$1.ZodIntersection<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
     threadId: z$1.ZodString;
     type: z$1.ZodLiteral<"thread/started">;
@@ -2322,7 +2385,6 @@ declare const threadEventSchema: z$1.ZodPipe<z$1.ZodUnknown, z$1.ZodUnion<readon
     threadId: z$1.ZodString;
     type: z$1.ZodLiteral<"client/thread/start">;
 }, z$1.core.$strip>, z$1.ZodObject<{
-    continuationOfRequestId: z$1.ZodOptional<z$1.ZodString>;
     direction: z$1.ZodLiteral<"outbound">;
     execution: z$1.ZodObject<{
         model: z$1.ZodString;
@@ -2529,6 +2591,8 @@ declare const threadEventSchema: z$1.ZodPipe<z$1.ZodUnknown, z$1.ZodUnion<readon
         params: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
     }, z$1.core.$strip>;
     requestId: z$1.ZodString;
+    retryAttempt: z$1.ZodOptional<z$1.ZodNumber>;
+    retryOfRequestId: z$1.ZodOptional<z$1.ZodString>;
     senderThreadId: z$1.ZodNullable<z$1.ZodString>;
     source: z$1.ZodEnum<{
         spawn: "spawn";
@@ -2969,6 +3033,18 @@ declare const threadEventSchema: z$1.ZodPipe<z$1.ZodUnknown, z$1.ZodUnion<readon
 type ThreadEvent = z$1.infer<typeof threadEventSchema>;
 type ThreadEventType = ThreadEvent["type"];
 
+declare const projectSchema: z$1.ZodObject<{
+    createdAt: z$1.ZodNumber;
+    gitRemoteUrl: z$1.ZodNullable<z$1.ZodString>;
+    id: z$1.ZodString;
+    kind: z$1.ZodEnum<{
+        personal: "personal";
+        standard: "standard";
+    }>;
+    name: z$1.ZodString;
+    updatedAt: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type Project = z$1.infer<typeof projectSchema>;
 declare const projectSourceSchema: z$1.ZodObject<{
     createdAt: z$1.ZodNumber;
     hostId: z$1.ZodString;
@@ -3085,6 +3161,11 @@ declare const promptInputSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
     }>>;
 }, z$1.core.$strip>], "type">;
 type PromptInput = z$1.infer<typeof promptInputSchema>;
+declare const callerExecutionInputSourceSchema: z$1.ZodEnum<{
+    "client-preference": "client-preference";
+    explicit: "explicit";
+}>;
+type CallerExecutionInputSource = z$1.infer<typeof callerExecutionInputSourceSchema>;
 declare const resolvedThreadExecutionOptionsSchema: z$1.ZodObject<{
     model: z$1.ZodString;
     permissionMode: z$1.ZodEnum<{
@@ -3139,6 +3220,18 @@ declare const projectExecutionDefaultsSchema: z$1.ZodObject<{
 }, z$1.core.$strip>;
 type ProjectExecutionDefaults = z$1.infer<typeof projectExecutionDefaultsSchema>;
 
+/**
+ * Who owns a wait, as the denormalized `waitHolder` column stores it.
+ *
+ * This exists only because the orphan sweep and the per-plugin release both
+ * need an indexed equality lookup ("every row this plugin is holding"), which
+ * a JSON `waitingOn` cannot serve. It is written by the same single writer
+ * that writes `waitingOn`, derived from it — never set independently — so the
+ * two cannot drift. Core waits have no holder.
+ */
+declare const queuedMessageWaitHolderSchema: z$1.ZodTemplateLiteral<`plugin:${string}`>;
+type QueuedMessageWaitHolder = z$1.infer<typeof queuedMessageWaitHolderSchema>;
+
 declare const PROVIDER_FORK_VALUES: readonly ["none", "tip", "checkpoint"];
 type ProviderFork = (typeof PROVIDER_FORK_VALUES)[number];
 
@@ -3261,6 +3354,7 @@ declare const threadStatusSchema: z$1.ZodEnum<{
     active: "active";
     error: "error";
     idle: "idle";
+    pending: "pending";
     starting: "starting";
     stopping: "stopping";
 }>;
@@ -3364,9 +3458,19 @@ declare const threadQueuedMessageSchema: z$1.ZodObject<{
         }>>;
     }, z$1.core.$strip>], "type">>;
     createdAt: z$1.ZodNumber;
+    editable: z$1.ZodBoolean;
+    failureReason: z$1.ZodNullable<z$1.ZodString>;
     groupWithNext: z$1.ZodBoolean;
     id: z$1.ZodString;
     model: z$1.ZodString;
+    payload: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"inline">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        attempt: z$1.ZodNumber;
+        kind: z$1.ZodLiteral<"retry">;
+        reason: z$1.ZodString;
+        retryOfTurnRequestId: z$1.ZodString;
+    }, z$1.core.$strip>], "kind">;
     permissionMode: z$1.ZodEnum<{
         "accept-edits": "accept-edits";
         auto: "auto";
@@ -3382,11 +3486,31 @@ declare const threadQueuedMessageSchema: z$1.ZodObject<{
         ultracode: "ultracode";
         xhigh: "xhigh";
     }>;
+    sendAt: z$1.ZodNullable<z$1.ZodNumber>;
     serviceTier: z$1.ZodEnum<{
         default: "default";
         fast: "fast";
     }>;
+    threadId: z$1.ZodString;
     updatedAt: z$1.ZodNumber;
+    waitingOn: z$1.ZodNullable<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"time">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"thread-busy">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"turn-starting">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"provisioning">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        hostName: z$1.ZodString;
+        kind: z$1.ZodLiteral<"host-offline">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"interaction">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"plugin">;
+        pluginId: z$1.ZodString;
+        reason: z$1.ZodString;
+    }, z$1.core.$strip>], "kind">>;
 }, z$1.core.$strip>;
 type ThreadQueuedMessage = z$1.infer<typeof threadQueuedMessageSchema>;
 
@@ -3851,6 +3975,11 @@ declare const projectWithThreadsResponseSchema: z$1.ZodObject<{
         pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
         projectId: z$1.ZodString;
         providerId: z$1.ZodString;
+        queuedWork: z$1.ZodEnum<{
+            failed: "failed";
+            none: "none";
+            waiting: "waiting";
+        }>;
         runtime: z$1.ZodObject<{
             displayStatus: z$1.ZodEnum<{
                 "host-reconnecting": "host-reconnecting";
@@ -3858,6 +3987,7 @@ declare const projectWithThreadsResponseSchema: z$1.ZodObject<{
                 active: "active";
                 error: "error";
                 idle: "idle";
+                pending: "pending";
                 provisioning: "provisioning";
                 starting: "starting";
                 stopping: "stopping";
@@ -3870,6 +4000,7 @@ declare const projectWithThreadsResponseSchema: z$1.ZodObject<{
             active: "active";
             error: "error";
             idle: "idle";
+            pending: "pending";
             starting: "starting";
             stopping: "stopping";
         }>;
@@ -3960,6 +4091,11 @@ declare const sidebarBootstrapResponseSchema: z$1.ZodObject<{
             pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
             projectId: z$1.ZodString;
             providerId: z$1.ZodString;
+            queuedWork: z$1.ZodEnum<{
+                failed: "failed";
+                none: "none";
+                waiting: "waiting";
+            }>;
             runtime: z$1.ZodObject<{
                 displayStatus: z$1.ZodEnum<{
                     "host-reconnecting": "host-reconnecting";
@@ -3967,6 +4103,7 @@ declare const sidebarBootstrapResponseSchema: z$1.ZodObject<{
                     active: "active";
                     error: "error";
                     idle: "idle";
+                    pending: "pending";
                     provisioning: "provisioning";
                     starting: "starting";
                     stopping: "stopping";
@@ -3979,6 +4116,7 @@ declare const sidebarBootstrapResponseSchema: z$1.ZodObject<{
                 active: "active";
                 error: "error";
                 idle: "idle";
+                pending: "pending";
                 starting: "starting";
                 stopping: "stopping";
             }>;
@@ -4067,6 +4205,11 @@ declare const sidebarBootstrapResponseSchema: z$1.ZodObject<{
             pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
             projectId: z$1.ZodString;
             providerId: z$1.ZodString;
+            queuedWork: z$1.ZodEnum<{
+                failed: "failed";
+                none: "none";
+                waiting: "waiting";
+            }>;
             runtime: z$1.ZodObject<{
                 displayStatus: z$1.ZodEnum<{
                     "host-reconnecting": "host-reconnecting";
@@ -4074,6 +4217,7 @@ declare const sidebarBootstrapResponseSchema: z$1.ZodObject<{
                     active: "active";
                     error: "error";
                     idle: "idle";
+                    pending: "pending";
                     provisioning: "provisioning";
                     starting: "starting";
                     stopping: "stopping";
@@ -4086,6 +4230,7 @@ declare const sidebarBootstrapResponseSchema: z$1.ZodObject<{
                 active: "active";
                 error: "error";
                 idle: "idle";
+                pending: "pending";
                 starting: "starting";
                 stopping: "stopping";
             }>;
@@ -9573,6 +9718,14 @@ interface TimelineTurnRow extends TimelineRowBase {
 type TimelineSourceRow = TimelineConversationRow | TimelineWorkRow | TimelineSystemRow;
 type TimelineRow = TimelineSourceRow | TimelineTurnRow;
 
+declare const threadCreateOriginSchema: z$1.ZodEnum<{
+    app: "app";
+    cli: "cli";
+    plugin: "plugin";
+    sdk: "sdk";
+}>;
+type ThreadCreateOrigin = z$1.infer<typeof threadCreateOriginSchema>;
+type ExecutionInputFieldSource = CallerExecutionInputSource;
 declare const createExecutionInputSourcesSchema: z$1.ZodObject<{
     model: z$1.ZodOptional<z$1.ZodEnum<{
         "client-preference": "client-preference";
@@ -9596,6 +9749,14 @@ declare const createExecutionInputSourcesSchema: z$1.ZodObject<{
     }>>;
 }, z$1.core.$strict>;
 type CreateExecutionInputSources = z$1.infer<typeof createExecutionInputSourcesSchema>;
+declare const startedOnBehalfOfSchema: z$1.ZodObject<{
+    initiator: z$1.ZodEnum<{
+        agent: "agent";
+        system: "system";
+    }>;
+    senderThreadId: z$1.ZodString;
+}, z$1.core.$strip>;
+type StartedOnBehalfOf = z$1.infer<typeof startedOnBehalfOfSchema>;
 declare const createThreadRequestSchema: z$1.ZodObject<{
     environment: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
         environmentId: z$1.ZodString;
@@ -9760,6 +9921,7 @@ declare const createThreadRequestSchema: z$1.ZodObject<{
         xhigh: "xhigh";
     }>>;
     sectionId: z$1.ZodOptional<z$1.ZodNullable<z$1.ZodString>>;
+    sendAt: z$1.ZodOptional<z$1.ZodNumber>;
     serviceTier: z$1.ZodOptional<z$1.ZodEnum<{
         default: "default";
         fast: "fast";
@@ -10093,6 +10255,7 @@ declare const sendMessageRequestSchema: z$1.ZodObject<{
         ultracode: "ultracode";
         xhigh: "xhigh";
     }>>;
+    sendAt: z$1.ZodOptional<z$1.ZodNumber>;
     senderThreadId: z$1.ZodOptional<z$1.ZodString>;
     serviceTier: z$1.ZodOptional<z$1.ZodEnum<{
         default: "default";
@@ -10100,14 +10263,38 @@ declare const sendMessageRequestSchema: z$1.ZodObject<{
     }>>;
 }, z$1.core.$strip>;
 type SendMessageRequest = z$1.infer<typeof sendMessageRequestSchema>;
-declare const sendMessageResponseSchema: z$1.ZodObject<{
-    delivery: z$1.ZodEnum<{
-        deferred: "deferred";
-        queued: "queued";
-        sent: "sent";
-    }>;
+/**
+ * A discriminated union rather than a flat record with nullable extras: a
+ * `sent` message has no queued row and no wait, and modelling those as "null
+ * for now" would invite every caller to check fields that cannot exist.
+ */
+declare const sendMessageResponseSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+    delivery: z$1.ZodLiteral<"sent">;
     ok: z$1.ZodLiteral<true>;
-}, z$1.core.$strip>;
+}, z$1.core.$strip>, z$1.ZodObject<{
+    delivery: z$1.ZodLiteral<"queued">;
+    ok: z$1.ZodLiteral<true>;
+    queuedMessageId: z$1.ZodString;
+    sendAt: z$1.ZodNullable<z$1.ZodNumber>;
+    waitingOn: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"time">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"thread-busy">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"turn-starting">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"provisioning">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        hostName: z$1.ZodString;
+        kind: z$1.ZodLiteral<"host-offline">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"interaction">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"plugin">;
+        pluginId: z$1.ZodString;
+        reason: z$1.ZodString;
+    }, z$1.core.$strip>], "kind">;
+}, z$1.core.$strip>], "delivery">;
 type SendMessageResponse = z$1.infer<typeof sendMessageResponseSchema>;
 declare const editMessageRequestSchema: z$1.ZodObject<{
     executionInputSources: z$1.ZodOptional<z$1.ZodObject<{
@@ -10240,6 +10427,45 @@ declare const editMessageResponseSchema: z$1.ZodObject<{
     requestSequence: z$1.ZodNumber;
 }, z$1.core.$strict>;
 type EditMessageResponse = z$1.infer<typeof editMessageResponseSchema>;
+/**
+ * What a retry did, mirroring `sendMessageResponseSchema`: a retry is a
+ * dispatch of a turn that already exists, so it is delivered or queued on
+ * exactly the same terms as a send. The two retry-specific facts ride along,
+ * because a caller that let the server pick the turn has no other way to learn
+ * which one it picked.
+ */
+declare const retryTurnResponseSchema: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+    attempt: z$1.ZodNumber;
+    delivery: z$1.ZodLiteral<"sent">;
+    ok: z$1.ZodLiteral<true>;
+    turnRequestId: z$1.ZodString;
+}, z$1.core.$strip>, z$1.ZodObject<{
+    attempt: z$1.ZodNumber;
+    delivery: z$1.ZodLiteral<"queued">;
+    ok: z$1.ZodLiteral<true>;
+    queuedMessageId: z$1.ZodString;
+    sendAt: z$1.ZodNullable<z$1.ZodNumber>;
+    turnRequestId: z$1.ZodString;
+    waitingOn: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"time">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"thread-busy">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"turn-starting">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"provisioning">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        hostName: z$1.ZodString;
+        kind: z$1.ZodLiteral<"host-offline">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"interaction">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"plugin">;
+        pluginId: z$1.ZodString;
+        reason: z$1.ZodString;
+    }, z$1.core.$strip>], "kind">;
+}, z$1.core.$strip>], "delivery">;
+type RetryTurnResponse = z$1.infer<typeof retryTurnResponseSchema>;
 declare const createQueuedMessageRequestSchema: z$1.ZodObject<{
     executionInputSources: z$1.ZodOptional<z$1.ZodObject<{
         model: z$1.ZodOptional<z$1.ZodEnum<{
@@ -10551,9 +10777,19 @@ declare const sendQueuedMessageResponseSchema: z$1.ZodObject<{
             }>>;
         }, z$1.core.$strip>], "type">>;
         createdAt: z$1.ZodNumber;
+        editable: z$1.ZodBoolean;
+        failureReason: z$1.ZodNullable<z$1.ZodString>;
         groupWithNext: z$1.ZodBoolean;
         id: z$1.ZodString;
         model: z$1.ZodString;
+        payload: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+            kind: z$1.ZodLiteral<"inline">;
+        }, z$1.core.$strip>, z$1.ZodObject<{
+            attempt: z$1.ZodNumber;
+            kind: z$1.ZodLiteral<"retry">;
+            reason: z$1.ZodString;
+            retryOfTurnRequestId: z$1.ZodString;
+        }, z$1.core.$strip>], "kind">;
         permissionMode: z$1.ZodEnum<{
             "accept-edits": "accept-edits";
             auto: "auto";
@@ -10569,11 +10805,31 @@ declare const sendQueuedMessageResponseSchema: z$1.ZodObject<{
             ultracode: "ultracode";
             xhigh: "xhigh";
         }>;
+        sendAt: z$1.ZodNullable<z$1.ZodNumber>;
         serviceTier: z$1.ZodEnum<{
             default: "default";
             fast: "fast";
         }>;
+        threadId: z$1.ZodString;
         updatedAt: z$1.ZodNumber;
+        waitingOn: z$1.ZodNullable<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+            kind: z$1.ZodLiteral<"time">;
+        }, z$1.core.$strip>, z$1.ZodObject<{
+            kind: z$1.ZodLiteral<"thread-busy">;
+        }, z$1.core.$strip>, z$1.ZodObject<{
+            kind: z$1.ZodLiteral<"turn-starting">;
+        }, z$1.core.$strip>, z$1.ZodObject<{
+            kind: z$1.ZodLiteral<"provisioning">;
+        }, z$1.core.$strip>, z$1.ZodObject<{
+            hostName: z$1.ZodString;
+            kind: z$1.ZodLiteral<"host-offline">;
+        }, z$1.core.$strip>, z$1.ZodObject<{
+            kind: z$1.ZodLiteral<"interaction">;
+        }, z$1.core.$strip>, z$1.ZodObject<{
+            kind: z$1.ZodLiteral<"plugin">;
+            pluginId: z$1.ZodString;
+            reason: z$1.ZodString;
+        }, z$1.core.$strip>], "kind">>;
     }, z$1.core.$strip>;
 }, z$1.core.$strip>;
 type SendQueuedMessageResponse = z$1.infer<typeof sendQueuedMessageResponseSchema>;
@@ -10610,6 +10866,11 @@ declare const threadListResponseSchema: z$1.ZodArray<z$1.ZodObject<{
     pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
     projectId: z$1.ZodString;
     providerId: z$1.ZodString;
+    queuedWork: z$1.ZodEnum<{
+        failed: "failed";
+        none: "none";
+        waiting: "waiting";
+    }>;
     runtime: z$1.ZodObject<{
         displayStatus: z$1.ZodEnum<{
             "host-reconnecting": "host-reconnecting";
@@ -10617,6 +10878,7 @@ declare const threadListResponseSchema: z$1.ZodArray<z$1.ZodObject<{
             active: "active";
             error: "error";
             idle: "idle";
+            pending: "pending";
             provisioning: "provisioning";
             starting: "starting";
             stopping: "stopping";
@@ -10629,6 +10891,7 @@ declare const threadListResponseSchema: z$1.ZodArray<z$1.ZodObject<{
         active: "active";
         error: "error";
         idle: "idle";
+        pending: "pending";
         starting: "starting";
         stopping: "stopping";
     }>;
@@ -10702,6 +10965,11 @@ declare const threadSearchResponseSchema: z$1.ZodObject<{
                 pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
                 projectId: z$1.ZodString;
                 providerId: z$1.ZodString;
+                queuedWork: z$1.ZodEnum<{
+                    failed: "failed";
+                    none: "none";
+                    waiting: "waiting";
+                }>;
                 runtime: z$1.ZodObject<{
                     displayStatus: z$1.ZodEnum<{
                         "host-reconnecting": "host-reconnecting";
@@ -10709,6 +10977,7 @@ declare const threadSearchResponseSchema: z$1.ZodObject<{
                         active: "active";
                         error: "error";
                         idle: "idle";
+                        pending: "pending";
                         provisioning: "provisioning";
                         starting: "starting";
                         stopping: "stopping";
@@ -10721,6 +10990,7 @@ declare const threadSearchResponseSchema: z$1.ZodObject<{
                     active: "active";
                     error: "error";
                     idle: "idle";
+                    pending: "pending";
                     starting: "starting";
                     stopping: "stopping";
                 }>;
@@ -10785,6 +11055,11 @@ declare const threadSearchResponseSchema: z$1.ZodObject<{
                 pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
                 projectId: z$1.ZodString;
                 providerId: z$1.ZodString;
+                queuedWork: z$1.ZodEnum<{
+                    failed: "failed";
+                    none: "none";
+                    waiting: "waiting";
+                }>;
                 runtime: z$1.ZodObject<{
                     displayStatus: z$1.ZodEnum<{
                         "host-reconnecting": "host-reconnecting";
@@ -10792,6 +11067,7 @@ declare const threadSearchResponseSchema: z$1.ZodObject<{
                         active: "active";
                         error: "error";
                         idle: "idle";
+                        pending: "pending";
                         provisioning: "provisioning";
                         starting: "starting";
                         stopping: "stopping";
@@ -10804,6 +11080,7 @@ declare const threadSearchResponseSchema: z$1.ZodObject<{
                     active: "active";
                     error: "error";
                     idle: "idle";
+                    pending: "pending";
                     starting: "starting";
                     stopping: "stopping";
                 }>;
@@ -10838,6 +11115,7 @@ declare const threadResponseSchema: z$1.ZodObject<{
     pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
     projectId: z$1.ZodString;
     providerId: z$1.ZodString;
+    queuedMessageCount: z$1.ZodNumber;
     runtime: z$1.ZodObject<{
         displayStatus: z$1.ZodEnum<{
             "host-reconnecting": "host-reconnecting";
@@ -10845,6 +11123,7 @@ declare const threadResponseSchema: z$1.ZodObject<{
             active: "active";
             error: "error";
             idle: "idle";
+            pending: "pending";
             provisioning: "provisioning";
             starting: "starting";
             stopping: "stopping";
@@ -10857,6 +11136,7 @@ declare const threadResponseSchema: z$1.ZodObject<{
         active: "active";
         error: "error";
         idle: "idle";
+        pending: "pending";
         starting: "starting";
         stopping: "stopping";
     }>;
@@ -10940,6 +11220,7 @@ declare const threadWithIncludesResponseSchema: z$1.ZodObject<{
     pinnedAt: z$1.ZodNullable<z$1.ZodNumber>;
     projectId: z$1.ZodString;
     providerId: z$1.ZodString;
+    queuedMessageCount: z$1.ZodNumber;
     runtime: z$1.ZodObject<{
         displayStatus: z$1.ZodEnum<{
             "host-reconnecting": "host-reconnecting";
@@ -10947,6 +11228,7 @@ declare const threadWithIncludesResponseSchema: z$1.ZodObject<{
             active: "active";
             error: "error";
             idle: "idle";
+            pending: "pending";
             provisioning: "provisioning";
             starting: "starting";
             stopping: "stopping";
@@ -10959,6 +11241,7 @@ declare const threadWithIncludesResponseSchema: z$1.ZodObject<{
         active: "active";
         error: "error";
         idle: "idle";
+        pending: "pending";
         starting: "starting";
         stopping: "stopping";
     }>;
@@ -11301,9 +11584,19 @@ declare const threadQueuedMessageListResponseSchema: z$1.ZodArray<z$1.ZodObject<
         }>>;
     }, z$1.core.$strip>], "type">>;
     createdAt: z$1.ZodNumber;
+    editable: z$1.ZodBoolean;
+    failureReason: z$1.ZodNullable<z$1.ZodString>;
     groupWithNext: z$1.ZodBoolean;
     id: z$1.ZodString;
     model: z$1.ZodString;
+    payload: z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"inline">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        attempt: z$1.ZodNumber;
+        kind: z$1.ZodLiteral<"retry">;
+        reason: z$1.ZodString;
+        retryOfTurnRequestId: z$1.ZodString;
+    }, z$1.core.$strip>], "kind">;
     permissionMode: z$1.ZodEnum<{
         "accept-edits": "accept-edits";
         auto: "auto";
@@ -11319,11 +11612,31 @@ declare const threadQueuedMessageListResponseSchema: z$1.ZodArray<z$1.ZodObject<
         ultracode: "ultracode";
         xhigh: "xhigh";
     }>;
+    sendAt: z$1.ZodNullable<z$1.ZodNumber>;
     serviceTier: z$1.ZodEnum<{
         default: "default";
         fast: "fast";
     }>;
+    threadId: z$1.ZodString;
     updatedAt: z$1.ZodNumber;
+    waitingOn: z$1.ZodNullable<z$1.ZodDiscriminatedUnion<[z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"time">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"thread-busy">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"turn-starting">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"provisioning">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        hostName: z$1.ZodString;
+        kind: z$1.ZodLiteral<"host-offline">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"interaction">;
+    }, z$1.core.$strip>, z$1.ZodObject<{
+        kind: z$1.ZodLiteral<"plugin">;
+        pluginId: z$1.ZodString;
+        reason: z$1.ZodString;
+    }, z$1.core.$strip>], "kind">>;
 }, z$1.core.$strip>>;
 type ThreadQueuedMessageListResponse = z$1.infer<typeof threadQueuedMessageListResponseSchema>;
 declare const threadChildSummaryResponseSchema: z$1.ZodObject<{
@@ -11427,6 +11740,35 @@ declare const threadListQuerySchema: z$1.ZodObject<{
     }>>;
 }, z$1.core.$strip>;
 type ThreadListQuery = z$1.infer<typeof threadListQuerySchema>;
+/**
+ * Grouping for `GET /threads/count`. Omitted, the route answers one total.
+ * `host` groups by the host the thread's environment lives on; a thread with
+ * no environment yet counts under the `null` key.
+ */
+declare const threadCountGroupBySchema: z$1.ZodEnum<{
+    host: "host";
+    project: "project";
+    provider: "provider";
+}>;
+type ThreadCountGroupBy = z$1.infer<typeof threadCountGroupBySchema>;
+/**
+ * `total` is always the count of every matching thread. `groups` is present
+ * exactly when `groupBy` was requested — an ungrouped count has no group list,
+ * rather than one anonymous group.
+ */
+declare const threadCountResponseSchema: z$1.ZodObject<{
+    groups: z$1.ZodOptional<z$1.ZodArray<z$1.ZodObject<{
+        count: z$1.ZodNumber;
+        key: z$1.ZodNullable<z$1.ZodString>;
+    }, z$1.core.$strip>>>;
+    total: z$1.ZodNumber;
+}, z$1.core.$strip>;
+type ThreadCountResponse = z$1.infer<typeof threadCountResponseSchema>;
+declare const threadRunningResponseSchema: z$1.ZodArray<z$1.ZodObject<{
+    hostId: z$1.ZodNullable<z$1.ZodString>;
+    id: z$1.ZodString;
+}, z$1.core.$strip>>;
+type ThreadRunningResponse = z$1.infer<typeof threadRunningResponseSchema>;
 declare const threadSearchQuerySchema: z$1.ZodObject<{
     limitPerGroup: z$1.ZodOptional<z$1.ZodString>;
     query: z$1.ZodString;
@@ -12196,6 +12538,56 @@ interface PluginPendingInteractionProps {
  */
 interface PluginSidebarFooterActionProps {
 }
+/** Display and accessibility metadata for a host-owned sidebar shortcut. */
+interface ExperimentalSidebarNavigationShortcut {
+    label: string;
+    ariaKeyShortcuts: string;
+}
+/** Host-owned behavior represented by one sidebar navigation item. */
+type ExperimentalSidebarNavigationAction = {
+    kind: "new-thread";
+} | {
+    kind: "search-threads";
+} | {
+    kind: "open-extensions";
+} | {
+    kind: "open-plugin-panel";
+    pluginId: string;
+    panelId: string;
+};
+/** Semantic icon identity for one sidebar navigation item. */
+type ExperimentalSidebarNavigationIcon = {
+    kind: "host";
+    name: "extensions" | "new-thread" | "search";
+} | {
+    kind: "plugin";
+    pluginId: string;
+    icon: string | null;
+};
+/** One host-owned destination or action a plugin may arrange. */
+interface ExperimentalSidebarNavigationItem {
+    id: string;
+    label: string;
+    icon: ExperimentalSidebarNavigationIcon;
+    action: ExperimentalSidebarNavigationAction;
+    isDisabled: boolean;
+    shortcut: ExperimentalSidebarNavigationShortcut | null;
+    experimental_splitProps: {
+        onPointerDown?: (event: react.PointerEvent<HTMLElement>) => void;
+    };
+}
+/** How the host should activate a sidebar navigation item. */
+interface ExperimentalSidebarNavigationActivationOptions {
+    openInSplit: boolean;
+}
+/** Props passed to an `experimental_sidebarNavigation` component. */
+interface ExperimentalSidebarNavigationProps {
+    items: readonly ExperimentalSidebarNavigationItem[];
+    activeItemId: string | null;
+    isCompactViewport: boolean;
+    experimental_activate(itemId: string, options: ExperimentalSidebarNavigationActivationOptions): void;
+    experimental_Original: ComponentType;
+}
 /**
  * Props passed to an `experimental_threadList` component — the sidebar's
  * scrolling thread area, replaced wholesale by one plugin.
@@ -12973,6 +13365,16 @@ interface PluginThreadListRegistration {
     description?: string;
     component: ComponentType<PluginThreadListProps>;
 }
+/** Replace the bounded navigation controls above the sidebar thread list. */
+interface ExperimentalSidebarNavigationRegistration {
+    /** Unique within the plugin; letters, digits, `-`, `_`. */
+    id: string;
+    /** Label shown in Settings → Appearance and capability details. */
+    title: string;
+    /** Optional one-line description shown with the provider choice. */
+    description?: string;
+    component: ComponentType<ExperimentalSidebarNavigationProps>;
+}
 /**
  * Register this plugin as a viewer/editor for file extensions. By default,
  * matching files render the first applicable opener in deterministic slot
@@ -13274,6 +13676,8 @@ interface PluginAppSlots {
     experimental_newThreadPanelAction(registration: PluginNewThreadPanelActionRegistration): void;
     pendingInteraction(registration: PluginPendingInteractionRegistration): void;
     sidebarFooterAction(registration: PluginSidebarFooterActionRegistration): void;
+    /** Replace the bounded sidebar navigation controls. */
+    experimental_sidebarNavigation(registration: ExperimentalSidebarNavigationRegistration): void;
     /**
      * Replace the sidebar's thread list (see
      * {@link PluginThreadListRegistration}). Experimental: see
@@ -13570,6 +13974,51 @@ interface PluginComposerApi {
     insertMention(mention: PluginComposerMention): void;
     /** Focus the composer caret at the end of the draft. */
     focus(): void;
+    /**
+     * Submit this composer's draft through the composer's OWN submit pipeline,
+     * queued until `sendAt` instead of dispatched now.
+     *
+     * This is a real submission, not a plugin-issued send: the host builds the
+     * request exactly as pressing Enter would, so the draft's attachments and
+     * @-mentions, and — in the new-thread composer — the provider, model,
+     * reasoning level, service tier, permission mode and environment the user
+     * has selected on screen, all travel with it. A plugin cannot assemble that
+     * tuple itself, which is why sending from the backend instead would silently
+     * run the message with different settings than the ones in front of the user.
+     *
+     * In a thread composer the message is queued as a row instead of being
+     * sent or queued for the next idle moment. In the new-thread composer the
+     * thread is created `pending` and its first message becomes the queued row.
+     * Either way the resulting row is core's: the queued card above the
+     * composer, the countdown, Send now and Delete all work with no further
+     * plugin involvement.
+     *
+     * Resolves once the host has accepted the submission and cleared the draft.
+     * Rejects when the composer refused to submit — a scope with no submit
+     * pipeline (a queued-message editor, a side chat), an empty draft, or a
+     * composer that is not ready (still loading its execution defaults, missing
+     * an environment). The rejection's message is safe to show to the user.
+     * Failures of the underlying request are reported by bb's own submit error
+     * handling and restore the draft, exactly as an interactive failure does.
+     *
+     * Experimental: see docs/api_to_audit.md.
+     */
+    experimental_submit(options: ExperimentalComposerSubmitOptions): Promise<void>;
+}
+/**
+ * What `experimental_submit` does differently from pressing Enter.
+ *
+ * There is deliberately no zero-argument overload and no "submit now" arm: a
+ * plugin that wants a draft sent immediately is asking for the affordance the
+ * user already has, and handing plugins an unconditional "send this draft"
+ * button is a much larger surface than scheduling needs.
+ */
+interface ExperimentalComposerSubmitOptions {
+    /**
+     * Epoch ms the submission should dispatch at. Must be in the future; the
+     * host does not second-guess how far ahead it is.
+     */
+    sendAt: number;
 }
 /**
  * A consumer-supplied action on the messages of one `ThreadChat` instance,
@@ -13637,7 +14086,13 @@ interface ThreadChatProps {
      */
     messageActions?: readonly ThreadChatMessageAction[];
 }
-/** The controlled execution selection resolved by the picker. */
+/**
+ * The controlled execution selection resolved by the picker.
+ *
+ * Deliberately a single concrete shape, not a union: this value exists to be
+ * forwarded verbatim to `bb.sdk.threads.spawn`, so it must name a real
+ * provider and model.
+ */
 interface ExperimentalProviderModelPickerValue {
     providerId: string;
     model: string;
@@ -13724,6 +14179,14 @@ interface NewThreadRequest {
     executionInputSources: CreateExecutionInputSources;
     environment: CreateThreadEnvironmentArgs;
     input: PromptInput[];
+    /**
+     * Epoch ms the first turn should dispatch at. Present only when the
+     * submission came from `useComposer().experimental_submit` — a scheduled
+     * create — and absent otherwise, which is what makes an ordinary submission
+     * start work at once. Forward it to `threads.spawn` unchanged: the thread is
+     * created `pending` and its first message is queued as a row until then.
+     */
+    sendAt?: number;
 }
 /**
  * Props of the host-owned `experimental_NewThreadComposer` component — bb's
@@ -14974,6 +15437,26 @@ interface ThreadListArgs {
 interface ThreadSearchArgs extends ThreadSearchQuery {
     signal?: AbortSignal;
 }
+/**
+ * Counting is a server-side `SELECT count(*)`: a caller that only needs "how
+ * many threads are running on this host" must never page rows through
+ * `threads.list`, which would both cost memory and miscount past its limit.
+ *
+ * Every filter is genuinely absent by default. `parentThreadId` is
+ * three-valued: omitted does not filter on parentage at all, the
+ * `THREAD_COUNT_ROOT_PARENT` sentinel (`"none"`) counts root threads only, and
+ * any other value counts that parent's children. Archived and deleted threads
+ * are excluded by the route.
+ */
+interface ThreadCountArgs {
+    groupBy?: ThreadCountGroupBy;
+    hostId?: string;
+    parentThreadId?: string;
+    projectId?: string;
+    providerId?: string;
+    signal?: AbortSignal;
+    status?: ThreadStatus;
+}
 interface ThreadResolveMentionsArgs extends ResolveThreadMentionsRequest {
     signal?: AbortSignal;
 }
@@ -14983,6 +15466,30 @@ interface ThreadGetArgs {
     threadId: string;
 }
 type ThreadGetResult = ThreadResponse | ThreadWithIncludesResponse;
+type ThreadCountResult = ThreadCountResponse;
+/**
+ * The threads occupying capacity right now — canonical status `starting` or
+ * `active`, archived and deleted excluded, hidden included (a hidden thread
+ * burns a real slot). Each row is just `id` and `hostId` — the machine whose
+ * pool the thread occupies, from its environment or, before one is attached,
+ * from the start intent it was admitted with; null only when neither names
+ * one. Anything else a policy needs it fetches by id.
+ *
+ * **Exact inside the `message.dispatch` hook, a snapshot everywhere else.**
+ * Hook passes are serialized under one server-wide lock and a cleared first
+ * attempt commits its `pending -> starting` flip before that lock releases, so
+ * a handler reading this sees every admission granted ahead of it in the same
+ * burst — which is what makes "five quick creates against a limit of two" hold
+ * three of them instead of admitting all five. Read from a background service,
+ * a timer or a `turn.failed` listener it is an ordinary query racing with every
+ * concurrent dispatch, exactly like {@link ThreadsArea.count}.
+ *
+ * One boundary: a warm follow-up admitted on an already-live `idle` thread
+ * flips `idle -> active` inside the send transaction, just AFTER the lock
+ * releases. First-dispatch admissions are exact; a burst of follow-ups to
+ * distinct idle threads can momentarily under-report.
+ */
+type ThreadRunningResult = ThreadRunningResponse;
 type ThreadListResult = ThreadListResponse;
 type ThreadSearchResult = ThreadSearchResponse;
 type ThreadResolveMentionsResult = ResolveThreadMentionsResponse;
@@ -15007,6 +15514,7 @@ type ThreadDeleteResult = {
     ok: true;
 };
 type ThreadSendResult = SendMessageResponse;
+type ThreadRetryResult = RetryTurnResponse;
 type ThreadEditMessageResult = EditMessageResponse;
 type ThreadStopResult = {
     ok: true;
@@ -15033,6 +15541,7 @@ type ThreadQueuedMessageDeleteResult = {
 type ThreadQueuedMessageReorderResult = ThreadQueuedMessageListResponse;
 type ThreadQueuedMessageSendResult = SendQueuedMessageResponse;
 type ThreadQueuedMessageGroupBoundaryResult = ThreadQueuedMessageListResponse;
+type ThreadQueueListResult = ThreadQueuedMessageListResponse;
 type ThreadTabsResult = ThreadTabsResponse;
 type ThreadTabsUpdateResult = ThreadTabsResponse;
 type ThreadStorageFilesResult = ThreadStorageFileListResponse;
@@ -15071,6 +15580,22 @@ interface ThreadSendArgs extends SendMessageRequest {
 interface ThreadEditMessageArgs extends EditMessageRequest {
     threadId: string;
 }
+interface ThreadRetryArgs {
+    threadId: string;
+    /**
+     * The failed turn to re-submit. Omitted means the thread's most recent turn,
+     * which is the one whose failure put it in `error`; naming one asserts which
+     * failure you decided on and fails if the thread has moved on since.
+     */
+    turnRequestId?: string;
+    /**
+     * Epoch ms to retry at. Omitted attempts the retry now — it may still queue
+     * behind a busy thread or a plugin wait, like any other dispatch.
+     */
+    sendAt?: number;
+    /** Why the turn is being retried, shown verbatim on the queued row. */
+    reason?: string;
+}
 interface ThreadActionArgs {
     threadId: string;
 }
@@ -15104,6 +15629,17 @@ interface ThreadQueuedMessageReorderArgs extends ThreadQueuedMessageTargetArgs,
 interface ThreadQueuedMessageGroupBoundaryArgs extends SetQueuedMessageGroupBoundaryRequest {
     threadId: string;
 }
+/**
+ * Both filters are genuinely absent by default: no filter lists every live
+ * queued row in the workspace, which is what `bb thread queue list` with no
+ * thread and a limiter plugin's own bookkeeping ask for.
+ */
+interface ThreadQueueListArgs {
+    /** `plugin:<id>` — every row that plugin is holding the wait on. */
+    waitHolder?: QueuedMessageWaitHolder;
+    signal?: AbortSignal;
+    threadId?: string;
+}
 interface ThreadStorageFilesArgs extends ThreadStorageFilesQuery {
     signal?: AbortSignal;
     threadId: string;
@@ -15223,6 +15759,18 @@ interface ThreadTabsArea {
     get(args: ThreadStatusArgs): Promise<ThreadTabsResult>;
     update(args: ThreadTabsUpdateArgs): Promise<ThreadTabsUpdateResult>;
 }
+/**
+ * Queued rows across every thread.
+ *
+ * The per-thread list, send-now, edit, reorder and delete all live on
+ * `queuedMessages`, which is where a row's own operations belong. This area
+ * exists for the one question a thread-scoped list cannot answer: "what is
+ * queued right now, anywhere" — a workspace-wide pending view, or a plugin
+ * recovering the rows it is holding after a restart.
+ */
+interface ThreadQueueArea {
+    list(args?: ThreadQueueListArgs): Promise<ThreadQueueListResult>;
+}
 interface ThreadsArea {
     archive(args: ThreadActionArgs): Promise<ThreadArchiveResult>;
     archiveAll(args: ThreadActionArgs): Promise<ThreadArchiveAllResult>;
@@ -15231,14 +15779,19 @@ interface ThreadsArea {
     cancelPlan(args: ThreadActionArgs): Promise<ThreadBannerActionResult>;
     clearGoal(args: ThreadActionArgs): Promise<ThreadBannerActionResult>;
     conversationOutline(args: ThreadStatusArgs): Promise<ThreadConversationOutlineResult>;
+    count(args?: ThreadCountArgs): Promise<ThreadCountResult>;
     defaultExecutionOptions(args: ThreadStatusArgs): Promise<ThreadDefaultExecutionOptionsResult>;
     delete(args: ThreadDeleteArgs): Promise<ThreadDeleteResult>;
     editMessage(args: ThreadEditMessageArgs): Promise<ThreadEditMessageResult>;
     events: ThreadEventsArea;
     fork(args: ThreadForkArgs): Promise<ThreadForkResult>;
     get(args: ThreadGetArgs): Promise<ThreadGetResult>;
+    queue: ThreadQueueArea;
     interactions: ThreadInteractionsArea;
     list(args?: ThreadListArgs): Promise<ThreadListResult>;
+    listRunning(args?: {
+        signal?: AbortSignal;
+    }): Promise<ThreadRunningResult>;
     markRead(args: ThreadActionArgs): Promise<ThreadReadStateResult>;
     markUnread(args: ThreadActionArgs): Promise<ThreadReadStateResult>;
     open(args: ThreadOpenArgs): Promise<ThreadOpenResult>;
@@ -15249,6 +15802,12 @@ interface ThreadsArea {
     queuedMessages: ThreadQueuedMessagesArea;
     reorderPinned(args: ThreadPinOrderArgs): Promise<ThreadPinOrderResult>;
     resolveMentions(args: ThreadResolveMentionsArgs): Promise<ThreadResolveMentionsResult>;
+    /**
+     * Re-submit a failed turn. The retry is an ordinary dispatch attempt, so a
+     * `sendAt` in the future queues it on the clock and a `message.dispatch` hook
+     * can still hold it; the response says which of the two happened.
+     */
+    retry(args: ThreadRetryArgs): Promise<ThreadRetryResult>;
     search(args: ThreadSearchArgs): Promise<ThreadSearchResult>;
     send(args: ThreadSendArgs): Promise<ThreadSendResult>;
     spawn(args: ThreadSpawnArgs): Promise<ThreadSpawnResult>;
@@ -15499,9 +16058,66 @@ interface PluginStorage {
     migrate(db: Database.Database, statements: string[]): void;
 }
 /**
- * Thread lifecycle events a plugin can observe (design §4.5). Observe-only:
- * handlers run fire-and-forget after the transition is applied and can never
- * block or veto it. `thread` is the same public DTO GET /threads/:id serves.
+ * Why a turn failed, assembled by core from the failed turn's own records so a
+ * listener never has to replay the event log to find out.
+ *
+ * Ids and failure facts only. There is no thread DTO and no copy of the
+ * message that failed: a retry re-submits the turn BY REFERENCE
+ * (`bb.sdk.threads.retry`), so the id is the whole of what a policy needs, and
+ * anything else about the thread is one `bb.sdk.threads.get` away and fresher
+ * for being read when it is used.
+ */
+interface PluginTurnFailedEvent {
+    /** The thread the failed turn ran on. */
+    threadId: string;
+    /**
+     * The failed turn's `client/turn/requested` id — what
+     * `bb.sdk.threads.retry` takes as `turnRequestId`. On a retry's failure this
+     * is the RETRY's id; core walks back to the request the chain started from
+     * when it queues the next attempt.
+     */
+    requestId: string;
+    /** The provider turn, when the failure happened inside one. */
+    turnId: string | null;
+    /**
+     * The failure's structured classification: the provider's own report when
+     * the failure happened inside a turn, or the typed rejection code (a rate
+     * limit, an auth failure) when the provider refused the request at the
+     * door. Null when neither carried one, so a retry policy must handle null
+     * rather than assume.
+     */
+    errorInfo: ProviderErrorInfo | null;
+    /**
+     * Whether the provider accepted the turn's input before failing. True is a
+     * mid-stream failure — the input is already part of the provider's
+     * conversation, so core's retry continues it instead of re-sending the
+     * blocks. False is a request the provider never took, which a retry
+     * re-sends verbatim.
+     */
+    inputAccepted: boolean;
+    /**
+     * The most recent rate-limit snapshot this thread's provider reported, or
+     * null when the provider reports no windows.
+     */
+    rateLimits: ProviderRateLimitState | null;
+    /**
+     * Which attempt just failed: 1 is the original dispatch, 2 the first retry.
+     * A policy caps its own retries by comparing against this.
+     */
+    attemptNumber: number;
+}
+/**
+ * Lifecycle events a plugin can observe with `bb.events.on` (design §4.5).
+ *
+ * **Events are announcements core makes.** Something already happened; a
+ * handler is told about it and whatever it returns is IGNORED. Handlers run
+ * fire-and-forget after the change is applied and can never block or veto it.
+ * The surface that *can* is `bb.experimental_hooks`, where core asks a
+ * question and acts on the answer — the same split git draws between its
+ * post-commit and pre-commit hooks.
+ *
+ * `thread` is the same public DTO GET /threads/:id serves and `entry` is the
+ * queued row GET /threads/:id/queued-messages serves.
  */
 interface PluginThreadEventPayloads {
     /** Fired after a thread row is created. */
@@ -15532,9 +16148,252 @@ interface PluginThreadEventPayloads {
     "thread.deleted": {
         thread: ThreadResponse;
     };
+    /**
+     * Fired after a dispatch attempt is queued as a row — by a `message.dispatch`
+     * hook's `wait` decision, by a `sendAt` in the future, or by a core wait (the
+     * thread is busy, its turn is still starting, provisioning, or awaiting an
+     * interaction).
+     *
+     * Every listener sees every queued row, not just the ones it is holding: an
+     * observer that only wants its own filters on
+     * `entry.waitingOn?.kind === "plugin" && entry.waitingOn.pluginId === bb.pluginId`.
+     *
+     * A re-queue fires this again with the new wait, because a row that moved
+     * from one wait to another is news to whoever was waiting on the old one.
+     */
+    "message.queued": {
+        entry: ThreadQueuedMessage;
+    };
+    /**
+     * Fired after a queued row's waits all cleared and it dispatched. The turn
+     * it carried runs after this, so a handler must not assume it has started.
+     */
+    "message.dispatched": {
+        entry: ThreadQueuedMessage;
+    };
+    /**
+     * Fired after a turn failed and the thread has already landed in `error`.
+     *
+     * An announcement, not a question: the failure stands exactly as core
+     * applied it, and a listener that wants another attempt asks for one with
+     * `bb.sdk.threads.retry({ threadId, turnRequestId, sendAt })`. That retry is
+     * an ordinary dispatch attempt, so it still passes the `message.dispatch`
+     * hook — a retry coming back after a rate-limit window respects a limiter
+     * that is at capacity instead of jumping the queue.
+     */
+    "turn.failed": PluginTurnFailedEvent;
 }
 type PluginThreadEventName = keyof PluginThreadEventPayloads;
 type PluginThreadEventHandler<E extends PluginThreadEventName> = (payload: PluginThreadEventPayloads[E]) => void | Promise<void>;
+/**
+ * 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 PluginHooks {
+    /**
+     * Answer a hook.
+     *
+     * **Hooks are questions core asks.** Core stops at a checkpoint, hands the
+     * handler a context, and ACTS ON what it returns — the opposite of
+     * `bb.events`, whose handlers are told what already happened and whose
+     * return value is ignored. It is the same split git draws between its
+     * pre-commit and post-commit hooks, and the reason the two live in separate
+     * namespaces rather than behind one `on`.
+     *
+     * Handlers for a hook run as a deterministic chain in plugin install order,
+     * a `reject` short-circuits the pass, and `wait` decisions are COLLECTED
+     * across the whole pass rather than short-circuiting. The attempt proceeds
+     * only when a pass yields no waits. When several plugins wait, the FIRST owns
+     * the row's `waitingOn` and the rest have their reasons appended to it, so
+     * one decision produces one card rather than one per plugin; each of them
+     * answers again on the next attempt, so nothing is lost by not owning the
+     * row.
+     *
+     * Fail-closed: a handler that throws or exceeds the 10 second decision box
+     * FAILS THE ATTEMPT with this plugin named. Decide in milliseconds — if the
+     * answer needs real work, return `wait` with a `sendAt` and answer again on
+     * the re-attempt.
+     *
+     * The whole pass runs under one server-wide lock, so a counting handler never
+     * races another attempt. It also means a handler that blocks delays every
+     * other attempt, up to the box.
+     *
+     * Passes re-run on every drain, on restart and on retry. A handler must be
+     * idempotent for one logical dispatch.
+     *
+     * At most one handler per hook per plugin; registering a second replaces
+     * nothing and throws.
+     */
+    on<K extends PluginHookName>(hook: K, handler: PluginHookHandler<K>): void;
+    /**
+     * Ask core to re-attempt the messages queued behind plugin waits.
+     *
+     * **The pair to `on`.** `on` answers the question core asks; `recheck`
+     * asks core to ask it again. Core owns the re-draining and the clock — the
+     * `sendAt` due sweep is still core's — and a plugin owns every other
+     * condition its own waits depend on. When that condition changes, say so
+     * here and answer the hook again on the re-attempt; there is no way to
+     * release a specific row, and there does not need to be.
+     *
+     * The walk re-attempts every plugin-queued row IN QUEUE ORDER, each one
+     * claimed exactly once, running the full `message.dispatch` pass over it —
+     * every plugin's handler, not just the caller's. A row that is still blocked
+     * simply re-queues, which is what makes an unwarranted request safe: nobody
+     * has to work out whether their own condition was the last one the message
+     * was waiting on. The existing per-thread re-queue pacing bounds the churn,
+     * so a plugin that stays full is not re-asked in a loop.
+     *
+     * Bursts coalesce: several calls before the walk starts produce one walk.
+     *
+     * **Resolves when the walk is SCHEDULED, not when it finishes.** The walk is
+     * a background pass with no caller to report to — its failures land on the
+     * rows, exactly as the due sweep's do. Awaiting completion would also mean
+     * awaiting a full hook pass from inside whatever called this, which for a
+     * handler holding the evaluation lock could not complete. Fire and forget.
+     */
+    recheck(hook: PluginHookName): Promise<void>;
+}
 type PluginHttpAuthMode = "local" | "none" | "token";
 type PluginHttpHandler = (context: Context) => Response | Promise<Response>;
 interface PluginHttp {
@@ -16438,8 +17297,18 @@ interface BbPluginApi {
     readonly providers: PluginProviders;
     /** Host-rendered UI contributions (design §4.9). */
     readonly ui: PluginUi;
-    /** Additive plugin lifecycle listeners (design §4.5). */
+    /**
+     * Additive plugin lifecycle listeners (design §4.5). Announcements core
+     * makes: a handler's return value is ignored.
+     */
     readonly events: PluginEvents;
+    /**
+     * Questions core asks and acts on the answer to. Today: the dispatch
+     * checkpoint messages pass through on their way to a provider (a user's
+     * Send-now bypasses it by design), which a handler may let go, queue with a
+     * reason, or refuse.
+     */
+    readonly experimental_hooks: PluginHooks;
     /** Plugin-reported status (needs-configuration). */
     readonly status: PluginStatusApi;
     /** Read-only facts about the running server (loopback base URL). */
@@ -16469,4 +17338,4 @@ interface BbPluginApi {
 }
 
 export { PLUGIN_CLI_OUTPUT_MAX_BYTES, defineRpcContract, experimental_defineHostEntry };
-export type { BbContext, BbNavigate, BbPluginApi, CodeOverflowMode, ComposerCustomization, ComposerPlusMenuItem, ComposerRichTextSpec, ComposerStructuredDraft, ComposerView, DiffProps, DiffViewMode, ExperimentalAppPanel, ExperimentalAppPanelSurface, ExperimentalDiffFileContent, ExperimentalDiffFullFileContents, ExperimentalFileLinkProps, ExperimentalFileLocation, ExperimentalFileOpenOptions, ExperimentalFixedTabTargetContract, ExperimentalFixedTabTargetState, ExperimentalHostCallOptions, ExperimentalHostClient, ExperimentalHostEntry, ExperimentalHostPaths, ExperimentalHostRpcContext, ExperimentalHostRpcHandlers, ExperimentalHostSignalContract, ExperimentalHostSignalEvent, ExperimentalHostSignals, ExperimentalHostWatchChange, ExperimentalHostWatchChangeType, ExperimentalHostWatchEvent, ExperimentalHostWatchListener, ExperimentalHostWatchOptions, ExperimentalHostWatchSubscription, ExperimentalHostWorkerLease, ExperimentalLiveFileTarget, ExperimentalOpenFixedTabOptions, ExperimentalPermissionModePickerProps, ExperimentalPluginFixedTabReference, ExperimentalProviderModelPickerProps, ExperimentalProviderModelPickerRouting, ExperimentalProviderModelPickerValue, JsonValue, MarkdownProps, NewThreadComposerProps, NewThreadRequest, PluginAgentConfiguration, PluginAgentConfigurationContext, PluginAgentToolContentPart, PluginAgentToolContext, PluginAgentToolLabels, PluginAgentToolPresentation, PluginAgentToolRegistrationBase, PluginAgentToolResult, PluginAgentToolSelection, PluginAgents, PluginAiServiceDeclaration, PluginAiServiceKind, PluginAiServices, PluginAppBuilder, PluginAppComposer, PluginAppContentScripts, PluginAppDefinition, PluginAppSetup, PluginAppSlots, PluginBackground, PluginCli, PluginCliCommandInfo, PluginCliContext, PluginCliExecutionResult, PluginCliOutputLimitError, PluginCliRegistration, PluginCliResult, PluginCodeThemeData, PluginCodeThemeState, PluginCodeThemeTokenRule, PluginCommandPaletteActionContext, PluginCommandPaletteActionRegistration, PluginComposerApi, PluginComposerMention, PluginComposerScope, PluginComposerTextEffect, PluginComposerThreadRowStatus, PluginContentScriptContext, PluginContentScriptDisposer, PluginContentScriptRegistration, PluginDiffRendererProps, PluginDiffRendererRegistration, PluginEvents, PluginFileOpenerProps, PluginFileOpenerRegistration, PluginFileOpenerSource, PluginFixedTabDeclaration, PluginFixedTabRegistration, PluginHomepageSectionProps, PluginHomepageSectionRegistration, PluginHosts, PluginHttp, PluginHttpAuthMode, PluginHttpHandler, PluginInteractionCancelReason, PluginInteractionRequest, PluginInteractionResult, PluginKvStorage, PluginLogger, PluginMentionItem, PluginMentionProviderRegistration, PluginMentionSearchContext, PluginMentionTrigger, PluginMessageActionContext, PluginMessageActionRegistration, PluginMessageDirectiveMessage, PluginMessageDirectiveOpenWorkspaceFile, PluginMessageDirectiveProps, PluginMessageDirectiveRegistration, PluginNavPanelProps, PluginNavPanelRegistration, PluginNewThreadPanelActionContext, PluginNewThreadPanelActionRegistration, PluginNewThreadPanelProps, PluginPanelActionOpenOptions, PluginPendingInteractionProps, PluginPendingInteractionRegistration, PluginPendingInteractionView, PluginProviderCapabilities, PluginProviderComposerAction, PluginProviderDeclaration, PluginProviderExtensionKindDeclaration, PluginProviderFallbackModel, PluginProviderIconRegistration, PluginProviderMaintenance, PluginProviderModelCatalogScope, PluginProviderNativeRootEntry, PluginProviderNativeRoots, PluginProviderOptionDescriptor, PluginProviderOptionsContext, PluginProviderPermissionMode, PluginProviderReasoningLevel, PluginProviderStrings, PluginProviders, PluginProvidersState, PluginRealtime, PluginRealtimeConnectionState, PluginRpc, PluginRpcCallArgs, PluginRpcClient, PluginRpcContract, PluginRpcError, PluginRpcErrorCode, PluginRpcHandlers, PluginRpcIssuePathSegment, PluginRpcMethodContract, PluginRpcResult, PluginRpcValidationIssue, PluginSdkApp, PluginServerApi, PluginSettingDescriptor, PluginSettingDescriptors, PluginSettingValue, PluginSettings, PluginSettingsHandle, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsState, PluginSettingsValues, PluginSharedPortTunnelIdentity, PluginSidebarFooterActionContext, PluginSidebarFooterActionProps, PluginSidebarFooterActionRegistration, PluginSidebarProject, PluginSidebarPullRequest, PluginSidebarSplitPane, PluginSidebarThread, PluginSidebarThreadActions, PluginSidebarThreadActivity, PluginSidebarThreadIndicator, PluginSidebarThreadPullRequestState, PluginSidebarThreadSplit, PluginSidebarThreadsState, PluginSidebarWorkspaceKind, PluginSourceCodeRendererProps, PluginSourceCodeRendererRegistration, PluginStatusApi, PluginStorage, PluginTargetedPanelActionOpenOptions, PluginThreadEventHandler, PluginThreadEventName, PluginThreadEventPayloads, PluginThreadHeaderActionProps, PluginThreadHeaderActionRegistration, PluginThreadListProps, PluginThreadListRegistration, PluginThreadPanelActionContext, PluginThreadPanelActionRegistration, PluginThreadPanelProps, PluginTimelineRendererProps, PluginTimelineRendererRegistration, PluginTimelineRendererRow, PluginTimelineRowPresentation, PluginTimelineRowStatus, PluginUi, SourceCodeLineRange, SourceCodeProps, StandardSchemaV1, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue, StandardSchemaV1Result, ThreadChatMessageAction, ThreadChatMessageReference, ThreadChatProps, UrlLinkProps };
+export type { BbContext, BbNavigate, BbPluginApi, CodeOverflowMode, ComposerCustomization, ComposerPlusMenuItem, ComposerRichTextSpec, ComposerStructuredDraft, ComposerView, DiffProps, DiffViewMode, ExperimentalAppPanel, ExperimentalAppPanelSurface, ExperimentalComposerSubmitOptions, ExperimentalDiffFileContent, ExperimentalDiffFullFileContents, ExperimentalFileLinkProps, ExperimentalFileLocation, ExperimentalFileOpenOptions, ExperimentalFixedTabTargetContract, ExperimentalFixedTabTargetState, ExperimentalHostCallOptions, ExperimentalHostClient, ExperimentalHostEntry, ExperimentalHostPaths, ExperimentalHostRpcContext, ExperimentalHostRpcHandlers, ExperimentalHostSignalContract, ExperimentalHostSignalEvent, ExperimentalHostSignals, ExperimentalHostWatchChange, ExperimentalHostWatchChangeType, ExperimentalHostWatchEvent, ExperimentalHostWatchListener, ExperimentalHostWatchOptions, ExperimentalHostWatchSubscription, ExperimentalHostWorkerLease, ExperimentalLiveFileTarget, ExperimentalOpenFixedTabOptions, ExperimentalPermissionModePickerProps, ExperimentalPluginFixedTabReference, ExperimentalProviderModelPickerProps, ExperimentalProviderModelPickerRouting, ExperimentalProviderModelPickerValue, ExperimentalSidebarNavigationAction, ExperimentalSidebarNavigationActivationOptions, ExperimentalSidebarNavigationIcon, ExperimentalSidebarNavigationItem, ExperimentalSidebarNavigationProps, ExperimentalSidebarNavigationRegistration, ExperimentalSidebarNavigationShortcut, JsonValue, MarkdownProps, MessageDispatchHookContext, MessageDispatchHookDecision, NewThreadComposerProps, NewThreadRequest, PluginAgentConfiguration, PluginAgentConfigurationContext, PluginAgentToolContentPart, PluginAgentToolContext, PluginAgentToolLabels, PluginAgentToolPresentation, PluginAgentToolRegistrationBase, PluginAgentToolResult, PluginAgentToolSelection, PluginAgents, PluginAiServiceDeclaration, PluginAiServiceKind, PluginAiServices, PluginAppBuilder, PluginAppComposer, PluginAppContentScripts, PluginAppDefinition, PluginAppSetup, PluginAppSlots, PluginBackground, PluginCli, PluginCliCommandInfo, PluginCliContext, PluginCliExecutionResult, PluginCliOutputLimitError, PluginCliRegistration, PluginCliResult, PluginCodeThemeData, PluginCodeThemeState, PluginCodeThemeTokenRule, PluginCommandPaletteActionContext, PluginCommandPaletteActionRegistration, PluginComposerApi, PluginComposerMention, PluginComposerScope, PluginComposerTextEffect, PluginComposerThreadRowStatus, PluginContentScriptContext, PluginContentScriptDisposer, PluginContentScriptRegistration, PluginDiffRendererProps, PluginDiffRendererRegistration, PluginDispatchAttemptKind, PluginDispatchExecution, PluginDispatchExecutionSources, PluginDispatchInput, PluginEvents, PluginFileOpenerProps, PluginFileOpenerRegistration, PluginFileOpenerSource, PluginFixedTabDeclaration, PluginFixedTabRegistration, PluginHomepageSectionProps, PluginHomepageSectionRegistration, PluginHookHandler, PluginHookName, PluginHookSignatures, PluginHooks, PluginHosts, PluginHttp, PluginHttpAuthMode, PluginHttpHandler, PluginInteractionCancelReason, PluginInteractionRequest, PluginInteractionResult, PluginKvStorage, PluginLogger, PluginMentionItem, PluginMentionProviderRegistration, PluginMentionSearchContext, PluginMentionTrigger, PluginMessageActionContext, PluginMessageActionRegistration, PluginMessageDirectiveMessage, PluginMessageDirectiveOpenWorkspaceFile, PluginMessageDirectiveProps, PluginMessageDirectiveRegistration, PluginNavPanelProps, PluginNavPanelRegistration, PluginNewThreadPanelActionContext, PluginNewThreadPanelActionRegistration, PluginNewThreadPanelProps, PluginPanelActionOpenOptions, PluginPendingInteractionProps, PluginPendingInteractionRegistration, PluginPendingInteractionView, PluginProviderCapabilities, PluginProviderComposerAction, PluginProviderDeclaration, PluginProviderExtensionKindDeclaration, PluginProviderFallbackModel, PluginProviderIconRegistration, PluginProviderMaintenance, PluginProviderModelCatalogScope, PluginProviderNativeRootEntry, PluginProviderNativeRoots, PluginProviderOptionDescriptor, PluginProviderOptionsContext, PluginProviderPermissionMode, PluginProviderReasoningLevel, PluginProviderStrings, PluginProviders, PluginProvidersState, PluginRealtime, PluginRealtimeConnectionState, PluginRpc, PluginRpcCallArgs, PluginRpcClient, PluginRpcContract, PluginRpcError, PluginRpcErrorCode, PluginRpcHandlers, PluginRpcIssuePathSegment, PluginRpcMethodContract, PluginRpcResult, PluginRpcValidationIssue, PluginSdkApp, PluginServerApi, PluginSettingDescriptor, PluginSettingDescriptors, PluginSettingValue, PluginSettings, PluginSettingsHandle, PluginSettingsSectionProps, PluginSettingsSectionRegistration, PluginSettingsState, PluginSettingsValues, PluginSharedPortTunnelIdentity, PluginSidebarFooterActionContext, PluginSidebarFooterActionProps, PluginSidebarFooterActionRegistration, PluginSidebarProject, PluginSidebarPullRequest, PluginSidebarSplitPane, PluginSidebarThread, PluginSidebarThreadActions, PluginSidebarThreadActivity, PluginSidebarThreadIndicator, PluginSidebarThreadPullRequestState, PluginSidebarThreadSplit, PluginSidebarThreadsState, PluginSidebarWorkspaceKind, PluginSourceCodeRendererProps, PluginSourceCodeRendererRegistration, PluginStatusApi, PluginStorage, PluginTargetedPanelActionOpenOptions, PluginThreadEventHandler, PluginThreadEventName, PluginThreadEventPayloads, PluginThreadHeaderActionProps, PluginThreadHeaderActionRegistration, PluginThreadListProps, PluginThreadListRegistration, PluginThreadPanelActionContext, PluginThreadPanelActionRegistration, PluginThreadPanelProps, PluginTimelineRendererProps, PluginTimelineRendererRegistration, PluginTimelineRendererRow, PluginTimelineRowPresentation, PluginTimelineRowStatus, PluginTurnFailedEvent, PluginUi, SourceCodeLineRange, SourceCodeProps, StandardSchemaV1, StandardSchemaV1InferInput, StandardSchemaV1InferOutput, StandardSchemaV1Issue, StandardSchemaV1Result, ThreadChatMessageAction, ThreadChatMessageReference, ThreadChatProps, UrlLinkProps };