@vellumai/plugin-api 0.10.11-dev.202607241836.91be689 → 0.10.11-dev.202607241933.decb522

package/index.d.ts

@@ -1,82 +1,6 @@
 /// <reference path="./app.d.ts" />
 import { z } from 'zod';
 
-declare type _AcpServerMessages = AcpSessionSpawnedEvent | AcpSessionUpdateEvent | AcpSessionCompletedEvent | AcpSessionErrorEvent | AcpSessionUsageEvent;
-
-declare type AcpSessionCompletedEvent = z.infer<typeof AcpSessionCompletedEventSchema>;
-
-declare const AcpSessionCompletedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"acp_session_completed">;
-    acpSessionId: z.ZodString;
-    stopReason: z.ZodEnum<{
-        cancelled: "cancelled";
-        end_turn: "end_turn";
-        max_tokens: "max_tokens";
-        max_turn_requests: "max_turn_requests";
-        refusal: "refusal";
-    }>;
-}, z.core.$strict>;
-
-declare type AcpSessionErrorEvent = z.infer<typeof AcpSessionErrorEventSchema>;
-
-declare const AcpSessionErrorEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"acp_session_error">;
-    acpSessionId: z.ZodString;
-    error: z.ZodString;
-}, z.core.$strict>;
-
-declare type AcpSessionSpawnedEvent = z.infer<typeof AcpSessionSpawnedEventSchema>;
-
-declare const AcpSessionSpawnedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"acp_session_spawned">;
-    acpSessionId: z.ZodString;
-    agent: z.ZodString;
-    parentConversationId: z.ZodString;
-    parentToolUseId: z.ZodOptional<z.ZodString>;
-    task: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
-declare type AcpSessionUpdateEvent = z.infer<typeof AcpSessionUpdateEventSchema>;
-
-declare const AcpSessionUpdateEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"acp_session_update">;
-    acpSessionId: z.ZodString;
-    updateType: z.ZodEnum<{
-        agent_message_chunk: "agent_message_chunk";
-        agent_thought_chunk: "agent_thought_chunk";
-        user_message_chunk: "user_message_chunk";
-        tool_call: "tool_call";
-        tool_call_update: "tool_call_update";
-        plan: "plan";
-    }>;
-    content: z.ZodOptional<z.ZodString>;
-    toolCallId: z.ZodOptional<z.ZodString>;
-    toolTitle: z.ZodOptional<z.ZodString>;
-    toolKind: z.ZodOptional<z.ZodString>;
-    toolStatus: z.ZodOptional<z.ZodString>;
-    rawInput: z.ZodOptional<z.ZodUnknown>;
-    rawOutput: z.ZodOptional<z.ZodUnknown>;
-    locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        line: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>>;
-    messageId: z.ZodOptional<z.ZodString>;
-    seq: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-
-declare type AcpSessionUsageEvent = z.infer<typeof AcpSessionUsageEventSchema>;
-
-declare const AcpSessionUsageEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"acp_session_usage">;
-    acpSessionId: z.ZodString;
-    usedTokens: z.ZodNumber;
-    contextSize: z.ZodNumber;
-    inputTokens: z.ZodOptional<z.ZodNumber>;
-    outputTokens: z.ZodOptional<z.ZodNumber>;
-    costAmount: z.ZodOptional<z.ZodNumber>;
-    costCurrency: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
 /**
  * Append a message to a conversation. This is the low-level insert: it
  * persists and indexes the row only — it does not project the message into
@@ -152,15 +76,6 @@ export declare type AgentLoopExitReason =
 /** An unhandled error ended the turn. */
 | "error";
 
-declare type AppFilesChangedEvent = z.infer<typeof AppFilesChangedEventSchema>;
-
-declare const AppFilesChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"app_files_changed">;
-    appId: z.ZodString;
-}, z.core.$strip>;
-
-declare type _AppsServerMessages = AppFilesChangedEvent;
-
 /**
  * How {@link listConversations} (and friends) treats archived rows.
  *
@@ -174,42 +89,6 @@ declare type _AppsServerMessages = AppFilesChangedEvent;
  */
 declare type ArchiveStatusFilter = "active" | "archived" | "all";
 
-declare type AssistantActivityStateEvent = z.infer<typeof AssistantActivityStateEventSchema>;
-
-declare const AssistantActivityStateEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"assistant_activity_state">;
-    conversationId: z.ZodString;
-    activityVersion: z.ZodNumber;
-    phase: z.ZodEnum<{
-        thinking: "thinking";
-        idle: "idle";
-        streaming: "streaming";
-        tool_running: "tool_running";
-        awaiting_confirmation: "awaiting_confirmation";
-    }>;
-    anchor: z.ZodEnum<{
-        assistant_turn: "assistant_turn";
-        user_turn: "user_turn";
-        global: "global";
-    }>;
-    reason: z.ZodEnum<{
-        thinking_delta: "thinking_delta";
-        generation_cancelled: "generation_cancelled";
-        message_dequeued: "message_dequeued";
-        first_text_delta: "first_text_delta";
-        tool_use_start: "tool_use_start";
-        preview_start: "preview_start";
-        tool_result_received: "tool_result_received";
-        confirmation_requested: "confirmation_requested";
-        confirmation_resolved: "confirmation_resolved";
-        context_compacting: "context_compacting";
-        message_complete: "message_complete";
-        error_terminal: "error_terminal";
-    }>;
-    requestId: z.ZodOptional<z.ZodString>;
-    statusText: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 declare type AssistantConfig = z.infer<typeof AssistantConfigSchema>;
 
 declare const AssistantConfigSchema: z.ZodObject<{
@@ -1252,314 +1131,1424 @@ declare const AssistantConfigSchema: z.ZodObject<{
     maxStepsPerSession: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 
-/** Daemon-side specialization of the generic event envelope. */
-export declare type AssistantEvent = BaseAssistantEvent<ServerMessage>;
-
-export declare type AssistantEventCallback = (event: AssistantEvent) => void | Promise<void>;
-
-/** Filter that determines which events a subscriber receives. */
-export declare type AssistantEventFilter = {
-    /** When set, restrict delivery to events for this conversation. */
-    conversationId?: string;
-};
-
 /**
- * Lightweight pub/sub hub for `AssistantEvent` messages.
- *
- * Filtering is applied at subscription level:
- *   - `conversationId`: scoped events match subscribers with same conversationId
- *     or no conversationId filter (broadcast to all).
- *   - `targetCapability` (on publish): targeted events only reach subscribers
- *     whose capabilities include the target. Untargeted events fan out to all.
- *
- * Client connections register as subscribers with metadata and are queryable
- * via `listClients()`, `getMostRecentClientByCapability()`, etc.
+ * Daemon-side event envelope: the canonical `AssistantEventEnvelope` wrapping
+ * an `AssistantEvent` message payload.
  */
-export declare class AssistantEventHub {
-    private readonly subscribers;
-    private readonly maxSubscribers;
-    /** Monotonic source for per-connection ids, scoped to this hub. */
-    private connectionCounter;
-    constructor(options?: {
-        maxSubscribers?: number;
-    });
-    /**
-     * Register a subscriber that will be called for each matching event.
-     *
-     * **Client deduplication:** When a client subscriber is registered with a
-     * `clientId` that already exists, all stale entries for that clientId are
-     * disposed first. This prevents subscriber stacking when clients reconnect
-     * (e.g. Chrome extension reload, SSE token refresh) before the old
-     * connection's abort signal fires.
-     *
-     * When the subscriber cap (`maxSubscribers`) has been reached, the **oldest**
-     * subscriber is evicted to make room: its `onEvict` callback is invoked (so
-     * it can close its SSE stream) and its entry is removed from the hub.
-     */
-    subscribe(subscriber: SubscriberInput): AssistantEventSubscription;
-    /**
-     * Publish an event to all matching subscribers.
-     *
-     * Matching rules:
-     * - if `excludeClientId` is set, the subscriber with that clientId is
-     *   skipped regardless of every other rule (self-echo suppression — the
-     *   client that originated the mutation does not receive its own
-     *   invalidation back through the hub).
-     * - if `targetClientId` is set, deliver only to the subscriber with that
-     *   clientId, bypassing the conversation-id filter entirely (the web-origin
-     *   event's conversationId differs from the macOS client's subscribed
-     *   conversation).
-     * - if `filter.conversationId` is set (and `targetClientId` is not), the
-     *   `event.conversationId` must equal it
-     * - if `targetCapability` is set, only subscribers whose capabilities include
-     *   it receive the event; untargeted events go to all
-     * - if `targetInterfaceId` is set, only client subscribers whose
-     *   `interfaceId` matches receive the event; process subscribers and
-     *   non-matching clients are skipped. Used to narrow legacy
-     *   broadcasts (e.g. `conversation_list_invalidated`) to a specific
-     *   client surface during a migration window.
-     *
-     * Fanout is isolated: a throwing or rejecting subscriber does not abort
-     * delivery to remaining subscribers.
-     */
-    publish(event: AssistantEvent, options?: {
-        targetCapability?: HostProxyCapability;
-        targetClientId?: string;
-        targetInterfaceId?: InterfaceId;
-        /**
-         * Skip the subscriber with this `clientId`. Used for self-echo
-         * suppression on `sync_changed`: the route handler echoes the
-         * originating tab's `X-Vellum-Client-Id` back on the event, and the
-         * hub uses it here to avoid re-delivering the invalidation to the
-         * tab that already mutated its own optimistic state.
-         */
-        excludeClientId?: string;
-    }): Promise<void>;
-    /**
-     * Return the active client subscriber with the given clientId, or
-     * `undefined` if no such subscriber exists.
-     */
-    getClientById(clientId: string): ClientEntry | undefined;
-    /**
-     * Return the verified actor principal id captured at SSE subscription time
-     * for the given client, or `undefined` if the client is unknown or
-     * connected without a principal (e.g. legacy/service tokens).
-     *
-     * Used by host proxies to bind cross-client targeted execution to the same
-     * authenticated user identity that opened the target client's SSE stream.
-     */
-    getActorPrincipalIdForClient(clientId: string): string | undefined;
-    /**
-     * Returns true when at least one active subscriber would receive the given
-     * event based on the same conversation matching rules as publish().
-     */
-    hasSubscribersForEvent(event: Pick<AssistantEvent, "conversationId">): boolean;
-    private clientEntries;
-    /**
-     * Return all active client subscribers, sorted by `lastActiveAt` descending.
-     */
-    listClients(): ClientEntry[];
-    /**
-     * Return all client subscribers that support the given capability,
-     * sorted by `lastActiveAt` descending.
-     */
-    listClientsByCapability(capability: HostProxyCapability): ClientEntry[];
-    /**
-     * Return the most recently active client that supports the given
-     * capability, or `undefined` if none exists.
-     */
-    getMostRecentClientByCapability(capability: HostProxyCapability): ClientEntry | undefined;
-    /**
-     * Return all client subscribers with the given interface type,
-     * sorted by `lastActiveAt` descending.
-     */
-    listClientsByInterface(interfaceId: InterfaceId): ClientEntry[];
-    /**
-     * Touch a client subscriber — update `lastActiveAt`. Used by heartbeat.
-     */
-    touchClient(clientId: string): void;
-    /**
-     * Force-disconnect a client by disposing all subscribers for the given
-     * `clientId`. Returns the number of disposed entries.
-     *
-     * Used by `assistant clients disconnect <clientId>` to forcibly remove
-     * stale or unwanted client connections.
-     */
-    disposeClient(clientId: string): number;
-    /** Number of currently active subscribers (useful for tests and caps). */
-    subscriberCount(): number;
-    /** Returns true if the hub can accept a subscriber without evicting anyone. */
-    hasCapacity(): boolean;
-}
-
-/** The plugin-facing event hub. See module docs. */
-export declare const assistantEventHub: PluginEventHub;
-
-/** Opaque handle returned by `subscribe`. Call `dispose()` to remove the subscription. */
-export declare interface AssistantEventSubscription {
-    dispose(): void;
-    /** True until `dispose()` has been called. */
-    readonly active: boolean;
-    /**
-     * Per-connection identifier, unique within the hub instance. Distinguishes
-     * connections that share a `clientId` (e.g. an old connection and the new
-     * one that replaced it on reconnect) so subscribe / dispose / shed log
-     * lines can be attributed to a specific connection.
-     */
-    readonly connectionId: string;
-}
-
-declare type AssistantStatusEvent = z.infer<typeof AssistantStatusEventSchema>;
-
-declare const AssistantStatusEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"assistant_status">;
-    version: z.ZodOptional<z.ZodString>;
-    keyFingerprint: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type AssistantTextDeltaEvent = z.infer<typeof AssistantTextDeltaEventSchema>;
-
-declare const AssistantTextDeltaEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"assistant_text_delta">;
-    text: z.ZodString;
-    messageId: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type AssistantThinkingDeltaEvent = z.infer<typeof AssistantThinkingDeltaEventSchema>;
-
-declare const AssistantThinkingDeltaEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"assistant_thinking_delta">;
-    thinking: z.ZodString;
-    messageId: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    timestampMs: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-
-declare type AssistantTurnStartEvent = z.infer<typeof AssistantTurnStartEventSchema>;
-
-declare const AssistantTurnStartEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"assistant_turn_start">;
-    messageId: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare interface AudioEmbeddingInput {
-    type: "audio";
-    data: Buffer;
-    mimeType: string;
-}
-
-declare type AvatarUpdatedEvent = z.infer<typeof AvatarUpdatedEventSchema>;
-
-declare const AvatarUpdatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"avatar_updated">;
-    avatarPath: z.ZodString;
-}, z.core.$strip>;
+export declare type AssistantEvent = AssistantEventEnvelope;
 
-declare type BackgroundToolCompletedEvent = z.infer<typeof BackgroundToolCompletedEventSchema>;
-
-declare const BackgroundToolCompletedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"background_tool_completed">;
-    id: z.ZodString;
-    conversationId: z.ZodString;
-    status: z.ZodEnum<{
-        cancelled: "cancelled";
-        completed: "completed";
-        failed: "failed";
-    }>;
-    exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    output: z.ZodOptional<z.ZodString>;
-    completedAt: z.ZodNumber;
-}, z.core.$strip>;
-
-declare type _BackgroundToolsServerMessages = BackgroundToolStartedEvent | BackgroundToolCompletedEvent;
-
-declare type BackgroundToolStartedEvent = z.infer<typeof BackgroundToolStartedEventSchema>;
-
-declare const BackgroundToolStartedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"background_tool_started">;
-    id: z.ZodString;
-    toolName: z.ZodString;
-    conversationId: z.ZodString;
-    command: z.ZodString;
-    startedAt: z.ZodNumber;
-}, z.core.$strip>;
-
-/**
- * Media payload for an image or file content block. One unified type covers
- * both blocks and both storage forms:
- *
- * - `base64` — the bytes travel inline with the block. This is the runtime
- *   shape the provider transforms consume and the shape produced for a live
- *   (in-flight) turn.
- * - `workspace_ref` — the bytes live somewhere in the workspace, not inline.
- *   This is the shape PERSISTED into `messages.content`, keeping large blobs
- *   out of the DB row and the lexical index. It is resolved back to inline
- *   bytes at the provider send boundary (`providers/media-resolve.ts`); any
- *   consumer that needs the raw bytes from stored content resolves it with
- *   `resolveMediaSourceData(source)`.
- *
- * `filename` is optional on both arms (present for file blocks and for
- * generated-media references). For references, `sizeBytes` (and, for images,
- * `width`/`height`) are captured at persist time so size-only consumers — the
- * per-turn token estimator especially — can cost the block without reading the
- * file back off disk.
- */
-declare interface Base64MediaSource {
-    type: "base64";
-    media_type: string;
-    data: string;
-    filename?: string;
-}
+export declare type AssistantEventCallback = (event: AssistantEvent) => void | Promise<void>;
 
-/**
- * A single assistant event wrapping an outbound message payload.
- *
- * Generic over the payload type. The `TMessage` default of `unknown` keeps
- * the envelope nameable without a type argument when the caller does not
- * care about message narrowing.
- */
-declare interface BaseAssistantEvent<TMessage = unknown> {
-    /** Globally unique event identifier (UUID). */
-    id: string;
-    /** Resolved conversation id when available. */
-    conversationId?: string;
-    /**
-     * Monotonic per-conversation sequence number. Assigned by the daemon at
-     * publish time for conversation-scoped events; absent for unscoped
-     * broadcasts. Clients track the highest observed `seq` per conversation
-     * and pass it back on reconnect to request replay of missed events.
-     */
-    seq?: number;
-    /** ISO-8601 timestamp of when the event was emitted. */
-    emittedAt: string;
-    /** Outbound message payload. */
-    message: TMessage;
-}
+declare type AssistantEventEnvelope = z.infer<typeof AssistantEventEnvelopeSchema>;
 
 /**
- * Capabilities shared by every chain-hook context (`user-prompt-submit`,
- * `post-compact`, `post-tool-use`, `stop`, `pre-model-call`,
- * `post-model-call`).
+ * SSE wire envelope wrapping every outbound event from the daemon.
  *
- * Both are stamped onto each hook's draft by the pipeline (`runHook`) before
- * the hook runs, bound to that hook's identity — dispatching call sites
- * construct the `XInputContext` shapes and never supply these.
+ * Transport-level metadata (`id`, `seq`, `emittedAt`, `conversationId`)
+ * surrounds the semantic event payload in `message`.
  */
-declare interface BaseHookContext {
-    /**
-     * Logger bound to the emitting hook — pre-tagged with the hook name and
-     * owning plugin (plus `conversationId` / `requestId` when the dispatching
-     * context carries them), so hook log lines are attributed without manual
-     * tagging.
-     */
-    readonly logger: PluginLogger;
-    /**
-     * Per-hook `hook_event` emitter, bound to this hook's owner — see
-     * {@link HookBroadcast}.
-     */
-    readonly broadcast: HookBroadcast;
+declare const AssistantEventEnvelopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    conversationId: z.ZodOptional<z.ZodString>;
+    seq: z.ZodOptional<z.ZodNumber>;
+    emittedAt: z.ZodString;
+    message: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"acp_session_completed">;
+        acpSessionId: z.ZodString;
+        stopReason: z.ZodEnum<{
+            cancelled: "cancelled";
+            end_turn: "end_turn";
+            max_tokens: "max_tokens";
+            max_turn_requests: "max_turn_requests";
+            refusal: "refusal";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"acp_session_error">;
+        acpSessionId: z.ZodString;
+        error: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"acp_session_spawned">;
+        acpSessionId: z.ZodString;
+        agent: z.ZodString;
+        parentConversationId: z.ZodString;
+        parentToolUseId: z.ZodOptional<z.ZodString>;
+        task: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"acp_session_update">;
+        acpSessionId: z.ZodString;
+        updateType: z.ZodEnum<{
+            agent_message_chunk: "agent_message_chunk";
+            agent_thought_chunk: "agent_thought_chunk";
+            user_message_chunk: "user_message_chunk";
+            tool_call: "tool_call";
+            tool_call_update: "tool_call_update";
+            plan: "plan";
+        }>;
+        content: z.ZodOptional<z.ZodString>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        toolTitle: z.ZodOptional<z.ZodString>;
+        toolKind: z.ZodOptional<z.ZodString>;
+        toolStatus: z.ZodOptional<z.ZodString>;
+        rawInput: z.ZodOptional<z.ZodUnknown>;
+        rawOutput: z.ZodOptional<z.ZodUnknown>;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        messageId: z.ZodOptional<z.ZodString>;
+        seq: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"acp_session_usage">;
+        acpSessionId: z.ZodString;
+        usedTokens: z.ZodNumber;
+        contextSize: z.ZodNumber;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        costAmount: z.ZodOptional<z.ZodNumber>;
+        costCurrency: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"app_files_changed">;
+        appId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_activity_state">;
+        conversationId: z.ZodString;
+        activityVersion: z.ZodNumber;
+        phase: z.ZodEnum<{
+            thinking: "thinking";
+            idle: "idle";
+            streaming: "streaming";
+            tool_running: "tool_running";
+            awaiting_confirmation: "awaiting_confirmation";
+        }>;
+        anchor: z.ZodEnum<{
+            assistant_turn: "assistant_turn";
+            user_turn: "user_turn";
+            global: "global";
+        }>;
+        reason: z.ZodEnum<{
+            thinking_delta: "thinking_delta";
+            message_dequeued: "message_dequeued";
+            first_text_delta: "first_text_delta";
+            tool_use_start: "tool_use_start";
+            preview_start: "preview_start";
+            tool_result_received: "tool_result_received";
+            confirmation_requested: "confirmation_requested";
+            confirmation_resolved: "confirmation_resolved";
+            context_compacting: "context_compacting";
+            message_complete: "message_complete";
+            generation_cancelled: "generation_cancelled";
+            error_terminal: "error_terminal";
+        }>;
+        requestId: z.ZodOptional<z.ZodString>;
+        statusText: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_status">;
+        version: z.ZodOptional<z.ZodString>;
+        keyFingerprint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_text_delta">;
+        text: z.ZodString;
+        messageId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_thinking_delta">;
+        thinking: z.ZodString;
+        messageId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        timestampMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"assistant_turn_start">;
+        messageId: z.ZodString;
+        conversationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"avatar_updated">;
+        avatarPath: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"background_tool_completed">;
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+        }>;
+        exitCode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        output: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"background_tool_started">;
+        id: z.ZodString;
+        toolName: z.ZodString;
+        conversationId: z.ZodString;
+        command: z.ZodString;
+        startedAt: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"bookmark.created">;
+        bookmark: z.ZodObject<{
+            id: z.ZodString;
+            messageId: z.ZodString;
+            conversationId: z.ZodString;
+            conversationTitle: z.ZodNullable<z.ZodString>;
+            messagePreview: z.ZodString;
+            messageRole: z.ZodString;
+            messageCreatedAt: z.ZodNumber;
+            createdAt: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"bookmark.deleted">;
+        messageId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"client_settings_update">;
+        key: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"compaction_circuit_closed">;
+        conversationId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"compaction_circuit_open">;
+        conversationId: z.ZodString;
+        reason: z.ZodLiteral<"3_consecutive_failures">;
+        openUntil: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"config_changed">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"confirmation_request">;
+        requestId: z.ZodString;
+        toolName: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        riskLevel: z.ZodString;
+        riskReason: z.ZodOptional<z.ZodString>;
+        isContainerized: z.ZodOptional<z.ZodBoolean>;
+        executionTarget: z.ZodOptional<z.ZodEnum<{
+            sandbox: "sandbox";
+            host: "host";
+        }>>;
+        allowlistOptions: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+            pattern: z.ZodString;
+        }, z.core.$strip>>;
+        scopeOptions: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            scope: z.ZodString;
+        }, z.core.$strip>>;
+        directoryScopeOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            scope: z.ZodString;
+        }, z.core.$strip>>>;
+        diff: z.ZodOptional<z.ZodObject<{
+            filePath: z.ZodString;
+            oldContent: z.ZodString;
+            newContent: z.ZodString;
+            isNewFile: z.ZodBoolean;
+        }, z.core.$strip>>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        persistentDecisionsAllowed: z.ZodOptional<z.ZodBoolean>;
+        toolUseId: z.ZodOptional<z.ZodString>;
+        acpToolKind: z.ZodOptional<z.ZodString>;
+        acpOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            optionId: z.ZodString;
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                allow_once: "allow_once";
+                allow_always: "allow_always";
+                reject_once: "reject_once";
+                reject_always: "reject_always";
+            }>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"confirmation_state_changed">;
+        conversationId: z.ZodString;
+        requestId: z.ZodString;
+        state: z.ZodEnum<{
+            timed_out: "timed_out";
+            pending: "pending";
+            approved: "approved";
+            denied: "denied";
+            resolved_stale: "resolved_stale";
+        }>;
+        source: z.ZodEnum<{
+            button: "button";
+            inline_nl: "inline_nl";
+            auto_deny: "auto_deny";
+            timeout: "timeout";
+            system: "system";
+        }>;
+        causedByRequestId: z.ZodOptional<z.ZodString>;
+        decisionText: z.ZodOptional<z.ZodString>;
+        toolUseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"contact_request">;
+        requestId: z.ZodString;
+        channel: z.ZodOptional<z.ZodString>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"contacts_changed">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"context_compacted">;
+        conversationId: z.ZodString;
+        previousEstimatedInputTokens: z.ZodNumber;
+        estimatedInputTokens: z.ZodNumber;
+        maxInputTokens: z.ZodNumber;
+        thresholdTokens: z.ZodNumber;
+        compactedMessages: z.ZodNumber;
+        summaryCalls: z.ZodNumber;
+        summaryInputTokens: z.ZodNumber;
+        summaryOutputTokens: z.ZodNumber;
+        summaryModel: z.ZodString;
+        summaryCharCount: z.ZodOptional<z.ZodNumber>;
+        summaryHeaderCount: z.ZodOptional<z.ZodNumber>;
+        summaryHadMemoryEcho: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"conversation_error">;
+        conversationId: z.ZodString;
+        code: z.ZodEnum<{
+            PROVIDER_NETWORK: "PROVIDER_NETWORK";
+            PROVIDER_RATE_LIMIT: "PROVIDER_RATE_LIMIT";
+            MANAGED_USAGE_LIMIT: "MANAGED_USAGE_LIMIT";
+            PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED";
+            PROVIDER_API: "PROVIDER_API";
+            IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE";
+            PROVIDER_BILLING: "PROVIDER_BILLING";
+            PROVIDER_ORDERING: "PROVIDER_ORDERING";
+            PROVIDER_WEB_SEARCH: "PROVIDER_WEB_SEARCH";
+            PROVIDER_NOT_CONFIGURED: "PROVIDER_NOT_CONFIGURED";
+            PROVIDER_INVALID_KEY: "PROVIDER_INVALID_KEY";
+            MANAGED_KEY_INVALID: "MANAGED_KEY_INVALID";
+            CONTEXT_TOO_LARGE: "CONTEXT_TOO_LARGE";
+            BUDGET_YIELD_UNRECOVERED: "BUDGET_YIELD_UNRECOVERED";
+            MAX_TOKENS_REACHED: "MAX_TOKENS_REACHED";
+            CONVERSATION_ABORTED: "CONVERSATION_ABORTED";
+            CONVERSATION_PROCESSING_FAILED: "CONVERSATION_PROCESSING_FAILED";
+            DISK_SPACE_CRITICAL: "DISK_SPACE_CRITICAL";
+            UNKNOWN: "UNKNOWN";
+        }>;
+        userMessage: z.ZodString;
+        retryable: z.ZodBoolean;
+        debugDetails: z.ZodOptional<z.ZodString>;
+        errorCategory: z.ZodOptional<z.ZodString>;
+        connectionName: z.ZodOptional<z.ZodString>;
+        profileName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"conversation_inference_profile_updated">;
+        conversationId: z.ZodString;
+        profile: z.ZodNullable<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        expiresAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"conversation_list_invalidated">;
+        reason: z.ZodEnum<{
+            created: "created";
+            renamed: "renamed";
+            deleted: "deleted";
+            reordered: "reordered";
+            seen_changed: "seen_changed";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"conversation_notice">;
+        conversationId: z.ZodString;
+        source: z.ZodEnum<{
+            memory_v3: "memory_v3";
+        }>;
+        code: z.ZodEnum<{
+            PROVIDER_NETWORK: "PROVIDER_NETWORK";
+            PROVIDER_RATE_LIMIT: "PROVIDER_RATE_LIMIT";
+            MANAGED_USAGE_LIMIT: "MANAGED_USAGE_LIMIT";
+            PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED";
+            PROVIDER_API: "PROVIDER_API";
+            IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE";
+            PROVIDER_BILLING: "PROVIDER_BILLING";
+            PROVIDER_ORDERING: "PROVIDER_ORDERING";
+            PROVIDER_WEB_SEARCH: "PROVIDER_WEB_SEARCH";
+            PROVIDER_NOT_CONFIGURED: "PROVIDER_NOT_CONFIGURED";
+            PROVIDER_INVALID_KEY: "PROVIDER_INVALID_KEY";
+            MANAGED_KEY_INVALID: "MANAGED_KEY_INVALID";
+            CONTEXT_TOO_LARGE: "CONTEXT_TOO_LARGE";
+            BUDGET_YIELD_UNRECOVERED: "BUDGET_YIELD_UNRECOVERED";
+            MAX_TOKENS_REACHED: "MAX_TOKENS_REACHED";
+            CONVERSATION_ABORTED: "CONVERSATION_ABORTED";
+            CONVERSATION_PROCESSING_FAILED: "CONVERSATION_PROCESSING_FAILED";
+            DISK_SPACE_CRITICAL: "DISK_SPACE_CRITICAL";
+            UNKNOWN: "UNKNOWN";
+        }>;
+        userMessage: z.ZodString;
+        errorCategory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"conversation_title_updated">;
+        conversationId: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"disk_pressure_status_changed">;
+        status: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            state: z.ZodEnum<{
+                unknown: "unknown";
+                disabled: "disabled";
+                critical: "critical";
+                ok: "ok";
+                warning: "warning";
+            }>;
+            locked: z.ZodBoolean;
+            acknowledged: z.ZodBoolean;
+            overrideActive: z.ZodBoolean;
+            effectivelyLocked: z.ZodBoolean;
+            lockId: z.ZodNullable<z.ZodString>;
+            usagePercent: z.ZodNullable<z.ZodNumber>;
+            thresholdPercent: z.ZodNumber;
+            path: z.ZodNullable<z.ZodString>;
+            lastCheckedAt: z.ZodNullable<z.ZodString>;
+            blockedCapabilities: z.ZodArray<z.ZodEnum<{
+                "agent-turns": "agent-turns";
+                "background-work": "background-work";
+                "remote-ingress": "remote-ingress";
+            }>>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document_comment_created">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        comment: z.ZodObject<{
+            id: z.ZodString;
+            surfaceId: z.ZodString;
+            author: z.ZodString;
+            content: z.ZodString;
+            anchorStart: z.ZodOptional<z.ZodNumber>;
+            anchorEnd: z.ZodOptional<z.ZodNumber>;
+            anchorText: z.ZodOptional<z.ZodString>;
+            parentCommentId: z.ZodOptional<z.ZodString>;
+            status: z.ZodString;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document_comment_deleted">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        commentId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document_comment_reopened">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        commentId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document_comment_resolved">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        commentId: z.ZodString;
+        resolvedBy: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document_editor_show">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        title: z.ZodString;
+        initialContent: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"document_editor_update">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        markdown: z.ZodString;
+        mode: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"error">;
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        errorCategory: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"generation_cancelled">;
+        conversationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"generation_handoff">;
+        conversationId: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+        queuedCount: z.ZodNumber;
+        messageId: z.ZodOptional<z.ZodString>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            filename: z.ZodString;
+            mimeType: z.ZodString;
+            data: z.ZodString;
+            sourceType: z.ZodOptional<z.ZodEnum<{
+                host_file: "host_file";
+                sandbox_file: "sandbox_file";
+                tool_block: "tool_block";
+            }>>;
+            sizeBytes: z.ZodOptional<z.ZodNumber>;
+            thumbnailData: z.ZodOptional<z.ZodString>;
+            fileBacked: z.ZodOptional<z.ZodBoolean>;
+            filePath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        attachmentWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"heartbeat_alert">;
+        title: z.ZodString;
+        body: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"heartbeat_conversation_created">;
+        conversationId: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"home_feed_updated">;
+        updatedAt: z.ZodString;
+        newItemCount: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"hook_event">;
+        conversationId: z.ZodOptional<z.ZodString>;
+        hookName: z.ZodString;
+        owner: z.ZodObject<{
+            kind: z.ZodEnum<{
+                plugin: "plugin";
+                workspace: "workspace";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        detail: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_app_control_cancel">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_app_control_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        toolName: z.ZodString;
+        input: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            tool: z.ZodLiteral<"start">;
+            app: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"observe">;
+            app: z.ZodString;
+            settle_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"press">;
+            app: z.ZodString;
+            key: z.ZodString;
+            modifiers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            duration_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"combo">;
+            app: z.ZodString;
+            keys: z.ZodArray<z.ZodString>;
+            duration_ms: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"sequence">;
+            app: z.ZodString;
+            steps: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                modifiers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                duration_ms: z.ZodOptional<z.ZodNumber>;
+                gap_ms: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"type">;
+            app: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"click">;
+            app: z.ZodString;
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            button: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+                middle: "middle";
+            }>>;
+            double: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"drag">;
+            app: z.ZodString;
+            from_x: z.ZodNumber;
+            from_y: z.ZodNumber;
+            to_x: z.ZodNumber;
+            to_y: z.ZodNumber;
+            button: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+                middle: "middle";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            tool: z.ZodLiteral<"stop">;
+            app: z.ZodOptional<z.ZodString>;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "tool">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_bash_cancel">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_bash_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        command: z.ZodString;
+        working_dir: z.ZodOptional<z.ZodString>;
+        timeout_seconds: z.ZodOptional<z.ZodNumber>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        targetClientId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_browser_cancel">;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_browser_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        cdpMethod: z.ZodString;
+        cdpParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        cdpSessionId: z.ZodOptional<z.ZodString>;
+        timeout_seconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_cu_cancel">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_cu_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+        toolName: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        stepNumber: z.ZodNumber;
+        reasoning: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_file_cancel">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"host_file_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+        operation: z.ZodLiteral<"read">;
+        path: z.ZodString;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_file_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+        operation: z.ZodLiteral<"write">;
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_file_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+        operation: z.ZodLiteral<"edit">;
+        path: z.ZodString;
+        old_string: z.ZodString;
+        new_string: z.ZodString;
+        replace_all: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "operation">, z.ZodObject<{
+        type: z.ZodLiteral<"host_transfer_cancel">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"host_transfer_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+        direction: z.ZodLiteral<"to_host">;
+        transferId: z.ZodString;
+        destPath: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        sha256: z.ZodString;
+        overwrite: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_transfer_request">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        targetClientId: z.ZodOptional<z.ZodString>;
+        direction: z.ZodLiteral<"to_sandbox">;
+        transferId: z.ZodString;
+        sourcePath: z.ZodString;
+    }, z.core.$strip>], "direction">, z.ZodObject<{
+        type: z.ZodLiteral<"host_ui_snapshot_cancel">;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"host_ui_snapshot_request">;
+        requestId: z.ZodString;
+        view: z.ZodEnum<{
+            sampler: "sampler";
+            chat: "chat";
+        }>;
+        tokens: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"identity_changed">;
+        name: z.ZodString;
+        role: z.ZodString;
+        personality: z.ZodString;
+        emoji: z.ZodString;
+        home: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"interaction_resolved">;
+        requestId: z.ZodString;
+        conversationId: z.ZodString;
+        state: z.ZodEnum<{
+            cancelled: "cancelled";
+            superseded: "superseded";
+            approved: "approved";
+            rejected: "rejected";
+            answered: "answered";
+        }>;
+        kind: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"memory_recalled">;
+        provider: z.ZodString;
+        model: z.ZodString;
+        degradation: z.ZodOptional<z.ZodObject<{
+            semanticUnavailable: z.ZodBoolean;
+            reason: z.ZodString;
+            fallbackSources: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        semanticHits: z.ZodNumber;
+        tier1Count: z.ZodNumber;
+        tier2Count: z.ZodNumber;
+        hybridSearchLatencyMs: z.ZodNumber;
+        sparseVectorUsed: z.ZodBoolean;
+        mergedCount: z.ZodNumber;
+        selectedCount: z.ZodNumber;
+        injectedTokens: z.ZodNumber;
+        latencyMs: z.ZodNumber;
+        topCandidates: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodString;
+            kind: z.ZodString;
+            finalScore: z.ZodNumber;
+            semantic: z.ZodNumber;
+            recency: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"memory_status">;
+        enabled: z.ZodBoolean;
+        degraded: z.ZodBoolean;
+        degradation: z.ZodOptional<z.ZodObject<{
+            semanticUnavailable: z.ZodBoolean;
+            reason: z.ZodString;
+            fallbackSources: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        reason: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"message_complete">;
+        messageId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodEnum<{
+            main: "main";
+            aux: "aux";
+        }>>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            filename: z.ZodString;
+            mimeType: z.ZodString;
+            data: z.ZodString;
+            sourceType: z.ZodOptional<z.ZodEnum<{
+                host_file: "host_file";
+                sandbox_file: "sandbox_file";
+                tool_block: "tool_block";
+            }>>;
+            sizeBytes: z.ZodOptional<z.ZodNumber>;
+            thumbnailData: z.ZodOptional<z.ZodString>;
+            fileBacked: z.ZodOptional<z.ZodBoolean>;
+            filePath: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        attachmentWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"message_dequeued">;
+        conversationId: z.ZodString;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"message_queued">;
+        conversationId: z.ZodString;
+        requestId: z.ZodString;
+        position: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"message_queued_deleted">;
+        conversationId: z.ZodString;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"message_request_complete">;
+        conversationId: z.ZodString;
+        requestId: z.ZodString;
+        runStillActive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"message_steered">;
+        conversationId: z.ZodString;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"model_info">;
+        conversationId: z.ZodOptional<z.ZodString>;
+        model: z.ZodString;
+        provider: z.ZodString;
+        configuredProviders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        availableModels: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            displayName: z.ZodString;
+        }, z.core.$strip>>>;
+        allProviders: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            displayName: z.ZodString;
+            models: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                displayName: z.ZodString;
+            }, z.core.$strip>>;
+            defaultModel: z.ZodString;
+            apiKeyUrl: z.ZodOptional<z.ZodString>;
+            apiKeyPlaceholder: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"navigate_settings">;
+        tab: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"notification_conversation_created">;
+        conversationId: z.ZodString;
+        title: z.ZodString;
+        sourceEventName: z.ZodString;
+        targetGuardianPrincipalId: z.ZodOptional<z.ZodString>;
+        groupId: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        silent: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"notification_intent">;
+        sourceEventName: z.ZodString;
+        title: z.ZodString;
+        body: z.ZodString;
+        deliveryId: z.ZodOptional<z.ZodString>;
+        deepLinkMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        targetGuardianPrincipalId: z.ZodOptional<z.ZodString>;
+        silent: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"oauth_connect_result">;
+        success: z.ZodBoolean;
+        service: z.ZodOptional<z.ZodString>;
+        grantedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        accountInfo: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"open_conversation">;
+        conversationId: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        anchorMessageId: z.ZodOptional<z.ZodString>;
+        focus: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"open_panel">;
+        panelType: z.ZodString;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        surfaceId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"open_url">;
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"platform_disconnected">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"question_request">;
+        requestId: z.ZodString;
+        questions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            question: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            freeTextPlaceholder: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        question: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        freeTextPlaceholder: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        toolUseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"recording_pause">;
+        recordingId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"recording_resume">;
+        recordingId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"recording_start">;
+        recordingId: z.ZodString;
+        attachToConversationId: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{
+            captureScope: z.ZodOptional<z.ZodEnum<{
+                display: "display";
+                window: "window";
+            }>>;
+            displayId: z.ZodOptional<z.ZodString>;
+            windowId: z.ZodOptional<z.ZodNumber>;
+            includeAudio: z.ZodOptional<z.ZodBoolean>;
+            includeMicrophone: z.ZodOptional<z.ZodBoolean>;
+            promptForSource: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        operationToken: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"recording_stop">;
+        recordingId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"relationship_state_updated">;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"schedule_conversation_created">;
+        conversationId: z.ZodString;
+        scheduleJobId: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"secret_request">;
+        requestId: z.ZodString;
+        service: z.ZodString;
+        field: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        placeholder: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        purpose: z.ZodOptional<z.ZodString>;
+        allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowOneTimeSend: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"service_group_update_complete">;
+        installedVersion: z.ZodString;
+        success: z.ZodBoolean;
+        rolledBackToVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"service_group_update_progress">;
+        statusMessage: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"service_group_update_starting">;
+        targetVersion: z.ZodString;
+        expectedDowntimeSeconds: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"show_platform_login">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"skills_state_changed">;
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            enabled: "enabled";
+            disabled: "disabled";
+            installed: "installed";
+            uninstalled: "uninstalled";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sounds_config_updated">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"subagent_event">;
+        conversationId: z.ZodString;
+        subagentId: z.ZodString;
+        event: z.ZodObject<{
+            type: z.ZodString;
+            content: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            result: z.ZodOptional<z.ZodString>;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            toolName: z.ZodOptional<z.ZodString>;
+            isError: z.ZodOptional<z.ZodBoolean>;
+            toolUseId: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"subagent_spawned">;
+        subagentId: z.ZodString;
+        parentConversationId: z.ZodString;
+        label: z.ZodString;
+        objective: z.ZodString;
+        isFork: z.ZodOptional<z.ZodBoolean>;
+        parentToolUseId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"subagent_status_changed">;
+        subagentId: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            pending: "pending";
+            running: "running";
+            awaiting_input: "awaiting_input";
+            aborted: "aborted";
+            interrupted: "interrupted";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        usage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            estimatedCost: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"sync_changed">;
+        tags: z.ZodArray<z.ZodString>;
+        originClientId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_input_delta">;
+        toolName: z.ZodString;
+        content: z.ZodString;
+        conversationId: z.ZodOptional<z.ZodString>;
+        toolUseId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_output_chunk">;
+        chunk: z.ZodString;
+        conversationId: z.ZodOptional<z.ZodString>;
+        toolUseId: z.ZodOptional<z.ZodString>;
+        subType: z.ZodOptional<z.ZodEnum<{
+            status: "status";
+            tool_start: "tool_start";
+            tool_complete: "tool_complete";
+        }>>;
+        subToolName: z.ZodOptional<z.ZodString>;
+        subToolInput: z.ZodOptional<z.ZodString>;
+        subToolIsError: z.ZodOptional<z.ZodBoolean>;
+        subToolId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        toolName: z.ZodString;
+        result: z.ZodString;
+        isError: z.ZodOptional<z.ZodBoolean>;
+        diff: z.ZodOptional<z.ZodObject<{
+            filePath: z.ZodString;
+            oldContent: z.ZodString;
+            newContent: z.ZodString;
+            isNewFile: z.ZodBoolean;
+        }, z.core.$strip>>;
+        status: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        imageData: z.ZodOptional<z.ZodString>;
+        imageDataList: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        toolUseId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        riskLevel: z.ZodOptional<z.ZodString>;
+        riskReason: z.ZodOptional<z.ZodString>;
+        matchedTrustRuleId: z.ZodOptional<z.ZodString>;
+        isContainerized: z.ZodOptional<z.ZodBoolean>;
+        riskScopeOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>>>;
+        riskAllowlistOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+            pattern: z.ZodString;
+        }, z.core.$strip>>>;
+        riskDirectoryScopeOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            scope: z.ZodString;
+        }, z.core.$strip>>>;
+        approvalMode: z.ZodOptional<z.ZodString>;
+        approvalReason: z.ZodOptional<z.ZodString>;
+        riskThreshold: z.ZodOptional<z.ZodString>;
+        activityMetadata: z.ZodOptional<z.ZodObject<{
+            webSearch: z.ZodOptional<z.ZodObject<{
+                query: z.ZodString;
+                provider: z.ZodEnum<{
+                    "anthropic-native": "anthropic-native";
+                    brave: "brave";
+                    perplexity: "perplexity";
+                    tavily: "tavily";
+                    firecrawl: "firecrawl";
+                }>;
+                resultCount: z.ZodNumber;
+                durationMs: z.ZodNumber;
+                results: z.ZodArray<z.ZodObject<{
+                    rank: z.ZodNumber;
+                    title: z.ZodString;
+                    url: z.ZodString;
+                    domain: z.ZodString;
+                    faviconUrl: z.ZodOptional<z.ZodString>;
+                    snippet: z.ZodOptional<z.ZodString>;
+                    age: z.ZodOptional<z.ZodString>;
+                    score: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                errorMessage: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            webFetch: z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+                finalUrl: z.ZodString;
+                provider: z.ZodOptional<z.ZodEnum<{
+                    default: "default";
+                    firecrawl: "firecrawl";
+                }>>;
+                status: z.ZodNumber;
+                contentType: z.ZodOptional<z.ZodString>;
+                byteCount: z.ZodNumber;
+                charCount: z.ZodNumber;
+                truncated: z.ZodBoolean;
+                title: z.ZodOptional<z.ZodString>;
+                domain: z.ZodString;
+                faviconUrl: z.ZodOptional<z.ZodString>;
+                redirectCount: z.ZodNumber;
+                durationMs: z.ZodNumber;
+                errorMessage: z.ZodOptional<z.ZodString>;
+                mayRequireJavaScript: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        errorCode: z.ZodOptional<z.ZodString>;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use_preview_start">;
+        toolUseId: z.ZodString;
+        toolName: z.ZodString;
+        conversationId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        previewStartedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use_start">;
+        toolName: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        toolUseId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        previewStartedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ui_surface_complete">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        summary: z.ZodString;
+        submittedData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ui_surface_dismiss">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ui_surface_show">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        surfaceType: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            style: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                secondary: "secondary";
+                destructive: "destructive";
+            }>>;
+            data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        display: z.ZodOptional<z.ZodEnum<{
+            inline: "inline";
+            panel: "panel";
+        }>>;
+        messageId: z.ZodOptional<z.ZodString>;
+        persistent: z.ZodOptional<z.ZodBoolean>;
+        toolCallId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ui_surface_undo_result">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        success: z.ZodBoolean;
+        remainingUndos: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"ui_surface_update">;
+        conversationId: z.ZodString;
+        surfaceId: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"usage_progress">;
+        conversationId: z.ZodString;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        estimatedCost: z.ZodNumber;
+        model: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"usage_update">;
+        conversationId: z.ZodString;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+        totalInputTokens: z.ZodNumber;
+        totalOutputTokens: z.ZodNumber;
+        estimatedCost: z.ZodNumber;
+        model: z.ZodString;
+        contextWindowTokens: z.ZodOptional<z.ZodNumber>;
+        contextWindowMaxTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"user_message_echo">;
+        text: z.ZodString;
+        conversationId: z.ZodOptional<z.ZodString>;
+        messageId: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+        clientMessageId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow_completed">;
+        runId: z.ZodString;
+        conversationId: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            running: "running";
+            aborted: "aborted";
+            interrupted: "interrupted";
+            cap_exceeded: "cap_exceeded";
+        }>;
+        agentsSpawned: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow_leaf_finished">;
+        runId: z.ZodString;
+        conversationId: z.ZodString;
+        seq: z.ZodNumber;
+        status: z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+        }>;
+        label: z.ZodOptional<z.ZodString>;
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        resultSummary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow_leaf_started">;
+        runId: z.ZodString;
+        conversationId: z.ZodString;
+        seq: z.ZodNumber;
+        label: z.ZodOptional<z.ZodString>;
+        phase: z.ZodOptional<z.ZodString>;
+        promptSummary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow_progress">;
+        runId: z.ZodString;
+        conversationId: z.ZodOptional<z.ZodString>;
+        agentsSpawned: z.ZodNumber;
+        phase: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow_started">;
+        runId: z.ZodString;
+        conversationId: z.ZodString;
+        toolUseId: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "type">;
+}, z.core.$strip>;
+
+/** Filter that determines which events a subscriber receives. */
+export declare type AssistantEventFilter = {
+    /** When set, restrict delivery to events for this conversation. */
+    conversationId?: string;
+};
+
+/**
+ * Lightweight pub/sub hub for `AssistantEvent` messages.
+ *
+ * Filtering is applied at subscription level:
+ *   - `conversationId`: scoped events match subscribers with same conversationId
+ *     or no conversationId filter (broadcast to all).
+ *   - `targetCapability` (on publish): targeted events only reach subscribers
+ *     whose capabilities include the target. Untargeted events fan out to all.
+ *
+ * Client connections register as subscribers with metadata and are queryable
+ * via `listClients()`, `getMostRecentClientByCapability()`, etc.
+ */
+export declare class AssistantEventHub {
+    private readonly subscribers;
+    private readonly maxSubscribers;
+    /** Monotonic source for per-connection ids, scoped to this hub. */
+    private connectionCounter;
+    constructor(options?: {
+        maxSubscribers?: number;
+    });
+    /**
+     * Register a subscriber that will be called for each matching event.
+     *
+     * **Client deduplication:** When a client subscriber is registered with a
+     * `clientId` that already exists, all stale entries for that clientId are
+     * disposed first. This prevents subscriber stacking when clients reconnect
+     * (e.g. Chrome extension reload, SSE token refresh) before the old
+     * connection's abort signal fires.
+     *
+     * When the subscriber cap (`maxSubscribers`) has been reached, the **oldest**
+     * subscriber is evicted to make room: its `onEvict` callback is invoked (so
+     * it can close its SSE stream) and its entry is removed from the hub.
+     */
+    subscribe(subscriber: SubscriberInput): AssistantEventSubscription;
+    /**
+     * Publish an event to all matching subscribers.
+     *
+     * Matching rules:
+     * - if `excludeClientId` is set, the subscriber with that clientId is
+     *   skipped regardless of every other rule (self-echo suppression — the
+     *   client that originated the mutation does not receive its own
+     *   invalidation back through the hub).
+     * - if `targetClientId` is set, deliver only to the subscriber with that
+     *   clientId, bypassing the conversation-id filter entirely (the web-origin
+     *   event's conversationId differs from the macOS client's subscribed
+     *   conversation).
+     * - if `filter.conversationId` is set (and `targetClientId` is not), the
+     *   `event.conversationId` must equal it
+     * - if `targetCapability` is set, only subscribers whose capabilities include
+     *   it receive the event; untargeted events go to all
+     * - if `targetInterfaceId` is set, only client subscribers whose
+     *   `interfaceId` matches receive the event; process subscribers and
+     *   non-matching clients are skipped. Used to narrow legacy
+     *   broadcasts (e.g. `conversation_list_invalidated`) to a specific
+     *   client surface during a migration window.
+     *
+     * Fanout is isolated: a throwing or rejecting subscriber does not abort
+     * delivery to remaining subscribers.
+     */
+    publish(event: AssistantEvent, options?: {
+        targetCapability?: HostProxyCapability;
+        targetClientId?: string;
+        targetInterfaceId?: InterfaceId;
+        /**
+         * Skip the subscriber with this `clientId`. Used for self-echo
+         * suppression on `sync_changed`: the route handler echoes the
+         * originating tab's `X-Vellum-Client-Id` back on the event, and the
+         * hub uses it here to avoid re-delivering the invalidation to the
+         * tab that already mutated its own optimistic state.
+         */
+        excludeClientId?: string;
+    }): Promise<void>;
+    /**
+     * Return the active client subscriber with the given clientId, or
+     * `undefined` if no such subscriber exists.
+     */
+    getClientById(clientId: string): ClientEntry | undefined;
+    /**
+     * Return the verified actor principal id captured at SSE subscription time
+     * for the given client, or `undefined` if the client is unknown or
+     * connected without a principal (e.g. legacy/service tokens).
+     *
+     * Used by host proxies to bind cross-client targeted execution to the same
+     * authenticated user identity that opened the target client's SSE stream.
+     */
+    getActorPrincipalIdForClient(clientId: string): string | undefined;
+    /**
+     * Returns true when at least one active subscriber would receive the given
+     * event based on the same conversation matching rules as publish().
+     */
+    hasSubscribersForEvent(event: Pick<AssistantEvent, "conversationId">): boolean;
+    private clientEntries;
+    /**
+     * Return all active client subscribers, sorted by `lastActiveAt` descending.
+     */
+    listClients(): ClientEntry[];
+    /**
+     * Return all client subscribers that support the given capability,
+     * sorted by `lastActiveAt` descending.
+     */
+    listClientsByCapability(capability: HostProxyCapability): ClientEntry[];
+    /**
+     * Return the most recently active client that supports the given
+     * capability, or `undefined` if none exists.
+     */
+    getMostRecentClientByCapability(capability: HostProxyCapability): ClientEntry | undefined;
+    /**
+     * Return all client subscribers with the given interface type,
+     * sorted by `lastActiveAt` descending.
+     */
+    listClientsByInterface(interfaceId: InterfaceId): ClientEntry[];
+    /**
+     * Touch a client subscriber — update `lastActiveAt`. Used by heartbeat.
+     */
+    touchClient(clientId: string): void;
+    /**
+     * Force-disconnect a client by disposing all subscribers for the given
+     * `clientId`. Returns the number of disposed entries.
+     *
+     * Used by `assistant clients disconnect <clientId>` to forcibly remove
+     * stale or unwanted client connections.
+     */
+    disposeClient(clientId: string): number;
+    /** Number of currently active subscribers (useful for tests and caps). */
+    subscriberCount(): number;
+    /** Returns true if the hub can accept a subscriber without evicting anyone. */
+    hasCapacity(): boolean;
+}
+
+/** The plugin-facing event hub. See module docs. */
+export declare const assistantEventHub: PluginEventHub;
+
+/** Opaque handle returned by `subscribe`. Call `dispose()` to remove the subscription. */
+export declare interface AssistantEventSubscription {
+    dispose(): void;
+    /** True until `dispose()` has been called. */
+    readonly active: boolean;
+    /**
+     * Per-connection identifier, unique within the hub instance. Distinguishes
+     * connections that share a `clientId` (e.g. an old connection and the new
+     * one that replaced it on reconnect) so subscribe / dispose / shed log
+     * lines can be attributed to a specific connection.
+     */
+    readonly connectionId: string;
+}
+
+declare interface AudioEmbeddingInput {
+    type: "audio";
+    data: Buffer;
+    mimeType: string;
+}
+
+/**
+ * Media payload for an image or file content block. One unified type covers
+ * both blocks and both storage forms:
+ *
+ * - `base64` — the bytes travel inline with the block. This is the runtime
+ *   shape the provider transforms consume and the shape produced for a live
+ *   (in-flight) turn.
+ * - `workspace_ref` — the bytes live somewhere in the workspace, not inline.
+ *   This is the shape PERSISTED into `messages.content`, keeping large blobs
+ *   out of the DB row and the lexical index. It is resolved back to inline
+ *   bytes at the provider send boundary (`providers/media-resolve.ts`); any
+ *   consumer that needs the raw bytes from stored content resolves it with
+ *   `resolveMediaSourceData(source)`.
+ *
+ * `filename` is optional on both arms (present for file blocks and for
+ * generated-media references). For references, `sizeBytes` (and, for images,
+ * `width`/`height`) are captured at persist time so size-only consumers — the
+ * per-turn token estimator especially — can cost the block without reading the
+ * file back off disk.
+ */
+declare interface Base64MediaSource {
+    type: "base64";
+    media_type: string;
+    data: string;
+    filename?: string;
+}
+
+/**
+ * Capabilities shared by every chain-hook context (`user-prompt-submit`,
+ * `post-compact`, `post-tool-use`, `stop`, `pre-model-call`,
+ * `post-model-call`).
+ *
+ * Both are stamped onto each hook's draft by the pipeline (`runHook`) before
+ * the hook runs, bound to that hook's identity — dispatching call sites
+ * construct the `XInputContext` shapes and never supply these.
+ */
+declare interface BaseHookContext {
+    /**
+     * Logger bound to the emitting hook — pre-tagged with the hook name and
+     * owning plugin (plus `conversationId` / `requestId` when the dispatching
+     * context carries them), so hook log lines are attributed without manual
+     * tagging.
+     */
+    readonly logger: PluginLogger;
+    /**
+     * Per-hook `hook_event` emitter, bound to this hook's owner — see
+     * {@link HookBroadcast}.
+     */
+    readonly broadcast: HookBroadcast;
 }
 
 declare interface BaseSubscriberEntry {
@@ -1578,31 +2567,6 @@ declare interface BaseSubscriberEntry {
     connectionId: string;
 }
 
-declare type BookmarkCreatedEvent = z.infer<typeof BookmarkCreatedEventSchema>;
-
-declare const BookmarkCreatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"bookmark.created">;
-    bookmark: z.ZodObject<{
-        id: z.ZodString;
-        messageId: z.ZodString;
-        conversationId: z.ZodString;
-        conversationTitle: z.ZodNullable<z.ZodString>;
-        messagePreview: z.ZodString;
-        messageRole: z.ZodString;
-        messageCreatedAt: z.ZodNumber;
-        createdAt: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-
-declare type BookmarkDeletedEvent = z.infer<typeof BookmarkDeletedEventSchema>;
-
-declare const BookmarkDeletedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"bookmark.deleted">;
-    messageId: z.ZodString;
-}, z.core.$strip>;
-
-declare type _BookmarksServerMessages = BookmarkCreatedEvent | BookmarkDeletedEvent;
-
 /**
  * Build a model-facing excerpt of stored message content around a query,
  * preserving external-content envelopes so third-party boundaries stay
@@ -1610,68 +2574,6 @@ declare type _BookmarksServerMessages = BookmarkCreatedEvent | BookmarkDeletedEv
  */
 export declare function buildMessageExcerpt(rawContent: string, query: string): Promise<string>;
 
-/**
- * Canonical channel-id vocabulary shared between the assistant daemon and the
- * gateway.
- *
- * A "channel" is an external messaging surface an actor can reach the
- * assistant through (Slack, Telegram, WhatsApp, phone, …) plus a couple of
- * internal ids (`vellum` for native app conversations, `platform` for the
- * internal control plane). This is the single source of truth for that set:
- * the assistant adopts it wholesale as its `ChannelId`, and the gateway
- * asserts its own (narrower) inbound list is a subset of it so the two sides
- * cannot silently drift.
- *
- * Both packages depend on `@vellumai/service-contracts`, so hoisting the set
- * here (rather than maintaining a copy on each side) means adding or renaming
- * a channel happens in exactly one place.
- *
- * Note that a consumer may legitimately handle only a *subset* of these — the
- * gateway, for example, never ingresses `platform`. Use a local list guarded
- * by `satisfies readonly ChannelId[]` for those cases rather than redefining
- * the union.
- */
-declare const CHANNEL_IDS: readonly ["telegram", "phone", "vellum", "whatsapp", "slack", "email", "platform", "a2a"];
-
-declare type ChannelId = (typeof CHANNEL_IDS)[number];
-
-declare interface ChannelVerificationSessionResponse {
-    type: "channel_verification_session_response";
-    success: boolean;
-    secret?: string;
-    instruction?: string;
-    /** Present when action is 'status'. */
-    bound?: boolean;
-    guardianExternalUserId?: string;
-    /** The channel this status pertains to (e.g. "telegram", "phone"). Present when action is 'status'. */
-    channel?: ChannelId;
-    /** The assistant ID scoped to this status. Present when action is 'status'. */
-    assistantId?: string;
-    /** The delivery chat ID for the guardian (e.g. Telegram chat ID). Present when action is 'status' and bound is true. */
-    guardianDeliveryChatId?: string;
-    /** Optional channel username/handle for the bound guardian (for UI display). */
-    guardianUsername?: string;
-    /** Optional display name for the bound guardian (for UI display). */
-    guardianDisplayName?: string;
-    /** Whether a pending verification challenge exists for this (assistantId, channel). Used by relay setup to detect active voice verification sessions. */
-    hasPendingChallenge?: boolean;
-    error?: string;
-    /** Human-readable error detail (e.g. for already_bound failures). */
-    message?: string;
-    /** Conversation ID for outbound verification flows. */
-    verificationSessionId?: string;
-    /** Epoch ms when the verification session expires. */
-    expiresAt?: number;
-    /** Epoch ms after which a resend is allowed. */
-    nextResendAt?: number;
-    /** Number of sends for this session. */
-    sendCount?: number;
-    /** Telegram deep-link URL for bootstrap (M3 placeholder). */
-    telegramBootstrapUrl?: string;
-    /** True when the outbound session is still in pending_bootstrap state (Telegram handle flow). Prevents the client from clearing the bootstrap URL during status polling. */
-    pendingBootstrap?: boolean;
-}
-
 export declare const CLI_COMMAND_HELP: readonly CliCommandHelp[];
 
 declare interface CliArgumentHelp {
@@ -1729,14 +2631,6 @@ declare interface ClientEntry extends BaseSubscriberEntry {
     actorPrincipalId?: string;
 }
 
-declare type ClientSettingsUpdateEvent = z.infer<typeof ClientSettingsUpdateEventSchema>;
-
-declare const ClientSettingsUpdateEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"client_settings_update">;
-    key: z.ZodString;
-    value: z.ZodString;
-}, z.core.$strip>;
-
 declare interface CliOptionHelp {
     /** Commander flag spec, e.g. `"--path <file>"` or `"-l, --limit <n>"`. */
     flags: string;
@@ -1770,147 +2664,10 @@ declare interface CliSubcommandHelp {
     subcommands?: CliSubcommandHelp[];
 }
 
-declare type CompactionCircuitClosedEvent = z.infer<typeof CompactionCircuitClosedEventSchema>;
-
-declare const CompactionCircuitClosedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"compaction_circuit_closed">;
-    conversationId: z.ZodString;
-}, z.core.$strip>;
-
-declare type CompactionCircuitOpenEvent = z.infer<typeof CompactionCircuitOpenEventSchema>;
-
-declare const CompactionCircuitOpenEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"compaction_circuit_open">;
-    conversationId: z.ZodString;
-    reason: z.ZodLiteral<"3_consecutive_failures">;
-    openUntil: z.ZodNumber;
-}, z.core.$strip>;
-
-declare type _ComputerUseServerMessages = RecordingStartEvent | RecordingStopEvent | RecordingPauseEvent | RecordingResumeEvent;
-
-declare type ConfigChangedEvent = z.infer<typeof ConfigChangedEventSchema>;
-
-declare const ConfigChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"config_changed">;
-}, z.core.$strip>;
-
 declare type ConfiguredProviderOptions = Pick<ResolveCallSiteOpts, "overrideProfile" | "forceOverrideProfile" | "selectionSeed">;
 
-declare type ConfirmationRequestEvent = z.infer<typeof ConfirmationRequestEventSchema>;
-
-declare const ConfirmationRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"confirmation_request">;
-    requestId: z.ZodString;
-    toolName: z.ZodString;
-    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    riskLevel: z.ZodString;
-    riskReason: z.ZodOptional<z.ZodString>;
-    isContainerized: z.ZodOptional<z.ZodBoolean>;
-    executionTarget: z.ZodOptional<z.ZodEnum<{
-        sandbox: "sandbox";
-        host: "host";
-    }>>;
-    allowlistOptions: z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        description: z.ZodString;
-        pattern: z.ZodString;
-    }, z.core.$strip>>;
-    scopeOptions: z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        scope: z.ZodString;
-    }, z.core.$strip>>;
-    directoryScopeOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        scope: z.ZodString;
-    }, z.core.$strip>>>;
-    diff: z.ZodOptional<z.ZodObject<{
-        filePath: z.ZodString;
-        oldContent: z.ZodString;
-        newContent: z.ZodString;
-        isNewFile: z.ZodBoolean;
-    }, z.core.$strip>>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    persistentDecisionsAllowed: z.ZodOptional<z.ZodBoolean>;
-    toolUseId: z.ZodOptional<z.ZodString>;
-    acpToolKind: z.ZodOptional<z.ZodString>;
-    acpOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        optionId: z.ZodString;
-        name: z.ZodString;
-        kind: z.ZodEnum<{
-            allow_once: "allow_once";
-            allow_always: "allow_always";
-            reject_once: "reject_once";
-            reject_always: "reject_always";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-
-declare type ConfirmationStateChangedEvent = z.infer<typeof ConfirmationStateChangedEventSchema>;
-
-declare const ConfirmationStateChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"confirmation_state_changed">;
-    conversationId: z.ZodString;
-    requestId: z.ZodString;
-    state: z.ZodEnum<{
-        timed_out: "timed_out";
-        pending: "pending";
-        approved: "approved";
-        denied: "denied";
-        resolved_stale: "resolved_stale";
-    }>;
-    source: z.ZodEnum<{
-        button: "button";
-        inline_nl: "inline_nl";
-        auto_deny: "auto_deny";
-        timeout: "timeout";
-        system: "system";
-    }>;
-    causedByRequestId: z.ZodOptional<z.ZodString>;
-    decisionText: z.ZodOptional<z.ZodString>;
-    toolUseId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type ContactRequestEvent = z.infer<typeof ContactRequestEventSchema>;
-
-declare const ContactRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"contact_request">;
-    requestId: z.ZodString;
-    channel: z.ZodOptional<z.ZodString>;
-    placeholder: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type ContactsChangedEvent = z.infer<typeof ContactsChangedEventSchema>;
-
-declare const ContactsChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"contacts_changed">;
-}, z.core.$strip>;
-
-declare type _ContactsServerMessages = ContactsChangedEvent | ContactRequestEvent;
-
 export declare type ContentBlock = TextContent | ThinkingContent | RedactedThinkingContent | ImageContent | FileContent | ToolUseContent | ToolResultContent | ServerToolUseContent | WebSearchToolResultContent;
 
-declare type ContextCompactedEvent = z.infer<typeof ContextCompactedEventSchema>;
-
-declare const ContextCompactedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"context_compacted">;
-    conversationId: z.ZodString;
-    previousEstimatedInputTokens: z.ZodNumber;
-    estimatedInputTokens: z.ZodNumber;
-    maxInputTokens: z.ZodNumber;
-    thresholdTokens: z.ZodNumber;
-    compactedMessages: z.ZodNumber;
-    summaryCalls: z.ZodNumber;
-    summaryInputTokens: z.ZodNumber;
-    summaryOutputTokens: z.ZodNumber;
-    summaryModel: z.ZodString;
-    summaryCharCount: z.ZodOptional<z.ZodNumber>;
-    summaryHeaderCount: z.ZodOptional<z.ZodNumber>;
-    summaryHadMemoryEcho: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-
 /** How a conversation was created / its execution mode. */
 declare type ConversationCreateType = "standard" | "background" | "scheduled";
 
@@ -1941,96 +2698,6 @@ declare interface ConversationDeletedInputContext {
     readonly conversationId: string;
 }
 
-declare type ConversationErrorEvent = z.infer<typeof ConversationErrorEventSchema>;
-
-declare const ConversationErrorEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"conversation_error">;
-    conversationId: z.ZodString;
-    code: z.ZodEnum<{
-        PROVIDER_NETWORK: "PROVIDER_NETWORK";
-        PROVIDER_RATE_LIMIT: "PROVIDER_RATE_LIMIT";
-        MANAGED_USAGE_LIMIT: "MANAGED_USAGE_LIMIT";
-        PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED";
-        PROVIDER_API: "PROVIDER_API";
-        IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE";
-        PROVIDER_BILLING: "PROVIDER_BILLING";
-        PROVIDER_ORDERING: "PROVIDER_ORDERING";
-        PROVIDER_WEB_SEARCH: "PROVIDER_WEB_SEARCH";
-        PROVIDER_NOT_CONFIGURED: "PROVIDER_NOT_CONFIGURED";
-        PROVIDER_INVALID_KEY: "PROVIDER_INVALID_KEY";
-        MANAGED_KEY_INVALID: "MANAGED_KEY_INVALID";
-        CONTEXT_TOO_LARGE: "CONTEXT_TOO_LARGE";
-        BUDGET_YIELD_UNRECOVERED: "BUDGET_YIELD_UNRECOVERED";
-        MAX_TOKENS_REACHED: "MAX_TOKENS_REACHED";
-        CONVERSATION_ABORTED: "CONVERSATION_ABORTED";
-        CONVERSATION_PROCESSING_FAILED: "CONVERSATION_PROCESSING_FAILED";
-        DISK_SPACE_CRITICAL: "DISK_SPACE_CRITICAL";
-        UNKNOWN: "UNKNOWN";
-    }>;
-    userMessage: z.ZodString;
-    retryable: z.ZodBoolean;
-    debugDetails: z.ZodOptional<z.ZodString>;
-    errorCategory: z.ZodOptional<z.ZodString>;
-    connectionName: z.ZodOptional<z.ZodString>;
-    profileName: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type ConversationInferenceProfileUpdatedEvent = z.infer<typeof ConversationInferenceProfileUpdatedEventSchema>;
-
-declare const ConversationInferenceProfileUpdatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"conversation_inference_profile_updated">;
-    conversationId: z.ZodString;
-    profile: z.ZodNullable<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-}, z.core.$strip>;
-
-declare type ConversationListInvalidatedEvent = z.infer<typeof ConversationListInvalidatedEventSchema>;
-
-declare const ConversationListInvalidatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"conversation_list_invalidated">;
-    reason: z.ZodEnum<{
-        created: "created";
-        renamed: "renamed";
-        deleted: "deleted";
-        reordered: "reordered";
-        seen_changed: "seen_changed";
-    }>;
-}, z.core.$strip>;
-
-declare type ConversationNoticeEvent = z.infer<typeof ConversationNoticeEventSchema>;
-
-declare const ConversationNoticeEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"conversation_notice">;
-    conversationId: z.ZodString;
-    source: z.ZodEnum<{
-        memory_v3: "memory_v3";
-    }>;
-    code: z.ZodEnum<{
-        PROVIDER_NETWORK: "PROVIDER_NETWORK";
-        PROVIDER_RATE_LIMIT: "PROVIDER_RATE_LIMIT";
-        MANAGED_USAGE_LIMIT: "MANAGED_USAGE_LIMIT";
-        PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED";
-        PROVIDER_API: "PROVIDER_API";
-        IMAGE_TOO_LARGE: "IMAGE_TOO_LARGE";
-        PROVIDER_BILLING: "PROVIDER_BILLING";
-        PROVIDER_ORDERING: "PROVIDER_ORDERING";
-        PROVIDER_WEB_SEARCH: "PROVIDER_WEB_SEARCH";
-        PROVIDER_NOT_CONFIGURED: "PROVIDER_NOT_CONFIGURED";
-        PROVIDER_INVALID_KEY: "PROVIDER_INVALID_KEY";
-        MANAGED_KEY_INVALID: "MANAGED_KEY_INVALID";
-        CONTEXT_TOO_LARGE: "CONTEXT_TOO_LARGE";
-        BUDGET_YIELD_UNRECOVERED: "BUDGET_YIELD_UNRECOVERED";
-        MAX_TOKENS_REACHED: "MAX_TOKENS_REACHED";
-        CONVERSATION_ABORTED: "CONVERSATION_ABORTED";
-        CONVERSATION_PROCESSING_FAILED: "CONVERSATION_PROCESSING_FAILED";
-        DISK_SPACE_CRITICAL: "DISK_SPACE_CRITICAL";
-        UNKNOWN: "UNKNOWN";
-    }>;
-    userMessage: z.ZodString;
-    errorCategory: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 export declare interface ConversationRow {
     id: string;
     title: string | null;
@@ -2075,16 +2742,6 @@ export declare interface ConversationRow {
  */
 export declare type ConversationsClearedContext = BaseHookContext;
 
-declare type _ConversationsServerMessages = AssistantStatusEvent | GenerationCancelledEvent | GenerationHandoffEvent | ModelInfoEvent | UsageUpdateEvent | UsageProgressEvent | ContextCompactedEvent | CompactionCircuitOpenEvent | CompactionCircuitClosedEvent | ConversationErrorEvent | ConversationNoticeEvent | ConversationTitleUpdatedEvent | ConversationListInvalidatedEvent | ScheduleConversationCreatedEvent | OpenConversationEvent;
-
-declare type ConversationTitleUpdatedEvent = z.infer<typeof ConversationTitleUpdatedEventSchema>;
-
-declare const ConversationTitleUpdatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"conversation_title_updated">;
-    conversationId: z.ZodString;
-    title: z.ZodString;
-}, z.core.$strip>;
-
 /** Read-side alias of {@link ConversationCreateType}. */
 declare type ConversationType = ConversationCreateType;
 
@@ -2137,113 +2794,9 @@ declare interface DiffInfo {
     isNewFile: boolean;
 }
 
-declare type DiskPressureStatusChangedEvent = z.infer<typeof DiskPressureStatusChangedEventSchema>;
-
-declare const DiskPressureStatusChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"disk_pressure_status_changed">;
-    status: z.ZodObject<{
-        enabled: z.ZodBoolean;
-        state: z.ZodEnum<{
-            unknown: "unknown";
-            disabled: "disabled";
-            critical: "critical";
-            warning: "warning";
-            ok: "ok";
-        }>;
-        locked: z.ZodBoolean;
-        acknowledged: z.ZodBoolean;
-        overrideActive: z.ZodBoolean;
-        effectivelyLocked: z.ZodBoolean;
-        lockId: z.ZodNullable<z.ZodString>;
-        usagePercent: z.ZodNullable<z.ZodNumber>;
-        thresholdPercent: z.ZodNumber;
-        path: z.ZodNullable<z.ZodString>;
-        lastCheckedAt: z.ZodNullable<z.ZodString>;
-        blockedCapabilities: z.ZodArray<z.ZodEnum<{
-            "agent-turns": "agent-turns";
-            "background-work": "background-work";
-            "remote-ingress": "remote-ingress";
-        }>>;
-        error: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-
 /** Distributive Omit that preserves union discrimination. */
 declare type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 
-declare type DocumentCommentCreatedEvent = z.infer<typeof DocumentCommentCreatedEventSchema>;
-
-declare const DocumentCommentCreatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"document_comment_created">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    comment: z.ZodObject<{
-        id: z.ZodString;
-        surfaceId: z.ZodString;
-        author: z.ZodString;
-        content: z.ZodString;
-        anchorStart: z.ZodOptional<z.ZodNumber>;
-        anchorEnd: z.ZodOptional<z.ZodNumber>;
-        anchorText: z.ZodOptional<z.ZodString>;
-        parentCommentId: z.ZodOptional<z.ZodString>;
-        status: z.ZodString;
-        createdAt: z.ZodNumber;
-        updatedAt: z.ZodNumber;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-
-declare type DocumentCommentDeletedEvent = z.infer<typeof DocumentCommentDeletedEventSchema>;
-
-declare const DocumentCommentDeletedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"document_comment_deleted">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    commentId: z.ZodString;
-}, z.core.$strip>;
-
-declare type DocumentCommentReopenedEvent = z.infer<typeof DocumentCommentReopenedEventSchema>;
-
-declare const DocumentCommentReopenedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"document_comment_reopened">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    commentId: z.ZodString;
-}, z.core.$strip>;
-
-declare type DocumentCommentResolvedEvent = z.infer<typeof DocumentCommentResolvedEventSchema>;
-
-declare const DocumentCommentResolvedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"document_comment_resolved">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    commentId: z.ZodString;
-    resolvedBy: z.ZodString;
-}, z.core.$strip>;
-
-declare type _DocumentCommentsServerMessages = DocumentCommentCreatedEvent | DocumentCommentResolvedEvent | DocumentCommentReopenedEvent | DocumentCommentDeletedEvent;
-
-declare type DocumentEditorShowEvent = z.infer<typeof DocumentEditorShowEventSchema>;
-
-declare const DocumentEditorShowEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"document_editor_show">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    title: z.ZodString;
-    initialContent: z.ZodString;
-}, z.core.$strip>;
-
-declare type DocumentEditorUpdateEvent = z.infer<typeof DocumentEditorUpdateEventSchema>;
-
-declare const DocumentEditorUpdateEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"document_editor_update">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    markdown: z.ZodString;
-    mode: z.ZodString;
-}, z.core.$strip>;
-
-declare type _DocumentsServerMessages = DocumentEditorShowEvent | DocumentEditorUpdateEvent;
-
 /**
  * Whether the given model or profile can process image input.
  *
@@ -2275,18 +2828,6 @@ declare type EmbeddingInput = string | MultimodalEmbeddingInput;
  */
 declare type EmbeddingTargetType = Parameters<embedAndUpsert_2>[1];
 
-declare type ErrorEvent_2 = z.infer<typeof ErrorEventSchema>;
-
-declare const ErrorEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"error">;
-    message: z.ZodString;
-    code: z.ZodOptional<z.ZodString>;
-    category: z.ZodOptional<z.ZodString>;
-    errorCategory: z.ZodOptional<z.ZodString>;
-    requestId: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 export declare function extractTextFromStoredMessageContent(raw: string | ContentBlock[]): string;
 
 export declare interface FileContent {
@@ -2304,39 +2845,6 @@ export declare interface FileContent {
     _attachmentId?: string;
 }
 
-declare type GenerationCancelledEvent = z.infer<typeof GenerationCancelledEventSchema>;
-
-declare const GenerationCancelledEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"generation_cancelled">;
-    conversationId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type GenerationHandoffEvent = z.infer<typeof GenerationHandoffEventSchema>;
-
-declare const GenerationHandoffEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"generation_handoff">;
-    conversationId: z.ZodOptional<z.ZodString>;
-    requestId: z.ZodOptional<z.ZodString>;
-    queuedCount: z.ZodNumber;
-    messageId: z.ZodOptional<z.ZodString>;
-    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        filename: z.ZodString;
-        mimeType: z.ZodString;
-        data: z.ZodString;
-        sourceType: z.ZodOptional<z.ZodEnum<{
-            host_file: "host_file";
-            sandbox_file: "sandbox_file";
-            tool_block: "tool_block";
-        }>>;
-        sizeBytes: z.ZodOptional<z.ZodNumber>;
-        thumbnailData: z.ZodOptional<z.ZodString>;
-        fileBacked: z.ZodOptional<z.ZodBoolean>;
-        filePath: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    attachmentWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-
 /** Read the assistant's name from IDENTITY.md for personalized responses. */
 export declare function getAssistantName(): string | null;
 
@@ -2408,32 +2916,6 @@ declare interface GraphNodeSweepResult {
 /** Whether the text tokenizes to at least one lexical search token. */
 export declare function hasLexicalTokens(text: string): Promise<boolean>;
 
-declare type HeartbeatAlertEvent = z.infer<typeof HeartbeatAlertEventSchema>;
-
-declare const HeartbeatAlertEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"heartbeat_alert">;
-    title: z.ZodString;
-    body: z.ZodString;
-}, z.core.$strip>;
-
-declare type HeartbeatConversationCreatedEvent = z.infer<typeof HeartbeatConversationCreatedEventSchema>;
-
-declare const HeartbeatConversationCreatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"heartbeat_conversation_created">;
-    conversationId: z.ZodString;
-    title: z.ZodString;
-}, z.core.$strip>;
-
-declare type HomeFeedUpdatedEvent = z.infer<typeof HomeFeedUpdatedEventSchema>;
-
-declare const HomeFeedUpdatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"home_feed_updated">;
-    updatedAt: z.ZodString;
-    newItemCount: z.ZodNumber;
-}, z.core.$strip>;
-
-declare type _HomeServerMessages = RelationshipStateUpdatedEvent | HomeFeedUpdatedEvent;
-
 /**
  * Emit a `hook_event` to any UI watching the conversation the hook runs in —
  * e.g. progress while the hook does work the user can feel (memory
@@ -2448,22 +2930,6 @@ declare type _HomeServerMessages = RelationshipStateUpdatedEvent | HomeFeedUpdat
  */
 export declare type HookBroadcast = (detail: Record<string, unknown>) => void;
 
-declare type HookEvent = z.infer<typeof HookEventSchema>;
-
-declare const HookEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"hook_event">;
-    conversationId: z.ZodOptional<z.ZodString>;
-    hookName: z.ZodString;
-    owner: z.ZodObject<{
-        kind: z.ZodEnum<{
-            plugin: "plugin";
-            workspace: "workspace";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strip>;
-    detail: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>;
-
 /**
  * A plugin lifecycle hook. Receives a per-lifecycle context shape and may
  * either mutate `ctx` in place (returning `void`) or return a *partial*
@@ -2524,280 +2990,24 @@ export declare const HOOKS: {
     /** Fires once per run when the loop has committed to ending — the definitive terminal hook for teardown. Cannot continue the loop; reports how the turn ended via `exitReason`. */
     readonly STOP: "stop";
     /** Fires at every model-call outcome (finalized reply or provider rejection), before the message is persisted/streamed-final. A hook may transform the content and owns the continue/retry decision. */
-    readonly POST_MODEL_CALL: "post-model-call";
-    /** Fires after the loop successfully compacts a conversation mid-turn. */
-    readonly POST_COMPACT: "post-compact";
-    /** Fires once per deleted conversation, after its rows are removed. Fire-and-forget cleanup signal — hooks run async with no ordering guarantee relative to the caller. */
-    readonly CONVERSATION_DELETED: "conversation-deleted";
-    /** Fires once when every conversation is wiped at once (the clear-all reset), after the main tables are cleared. Carries no `conversationId`; cleanup hooks wipe their own per-conversation state wholesale. */
-    readonly CONVERSATIONS_CLEARED: "conversations-cleared";
-};
-
-/**
- * Host proxy capabilities that an interface can support. The macOS client
- * supports all of them; the chrome-extension interface only supports
- * host_browser (via the Chrome DevTools Protocol proxy).
- */
-declare const HOST_PROXY_CAPABILITIES: readonly ["host_bash", "host_file", "host_cu", "host_browser", "host_app_control", "host_ui_snapshot"];
-
-declare type HostAppControlCancelEvent = z.infer<typeof HostAppControlCancelEventSchema>;
-
-declare const HostAppControlCancelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_app_control_cancel">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-}, z.core.$strip>;
-
-declare type HostAppControlRequestEvent = z.infer<typeof HostAppControlRequestEventSchema>;
-
-declare const HostAppControlRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_app_control_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    toolName: z.ZodString;
-    input: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        tool: z.ZodLiteral<"start">;
-        app: z.ZodString;
-        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"observe">;
-        app: z.ZodString;
-        settle_ms: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"press">;
-        app: z.ZodString;
-        key: z.ZodString;
-        modifiers: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        duration_ms: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"combo">;
-        app: z.ZodString;
-        keys: z.ZodArray<z.ZodString>;
-        duration_ms: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"sequence">;
-        app: z.ZodString;
-        steps: z.ZodArray<z.ZodObject<{
-            key: z.ZodString;
-            modifiers: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            duration_ms: z.ZodOptional<z.ZodNumber>;
-            gap_ms: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"type">;
-        app: z.ZodString;
-        text: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"click">;
-        app: z.ZodString;
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-        button: z.ZodOptional<z.ZodEnum<{
-            left: "left";
-            right: "right";
-            middle: "middle";
-        }>>;
-        double: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"drag">;
-        app: z.ZodString;
-        from_x: z.ZodNumber;
-        from_y: z.ZodNumber;
-        to_x: z.ZodNumber;
-        to_y: z.ZodNumber;
-        button: z.ZodOptional<z.ZodEnum<{
-            left: "left";
-            right: "right";
-            middle: "middle";
-        }>>;
-    }, z.core.$strip>, z.ZodObject<{
-        tool: z.ZodLiteral<"stop">;
-        app: z.ZodOptional<z.ZodString>;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>], "tool">;
-}, z.core.$strip>;
-
-declare type _HostAppControlServerMessages = HostAppControlRequestEvent | HostAppControlCancelEvent;
-
-declare type HostBashCancelEvent = z.infer<typeof HostBashCancelEventSchema>;
-
-declare const HostBashCancelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_bash_cancel">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type HostBashRequestEvent = z.infer<typeof HostBashRequestEventSchema>;
-
-declare const HostBashRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_bash_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    command: z.ZodString;
-    working_dir: z.ZodOptional<z.ZodString>;
-    timeout_seconds: z.ZodOptional<z.ZodNumber>;
-    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    targetClientId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type _HostBashServerMessages = HostBashRequestEvent | HostBashCancelEvent;
-
-declare type HostBrowserCancelEvent = z.infer<typeof HostBrowserCancelEventSchema>;
-
-declare const HostBrowserCancelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_browser_cancel">;
-    requestId: z.ZodString;
-}, z.core.$strip>;
-
-declare type HostBrowserRequestEvent = z.infer<typeof HostBrowserRequestEventSchema>;
-
-declare const HostBrowserRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_browser_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    cdpMethod: z.ZodString;
-    cdpParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    cdpSessionId: z.ZodOptional<z.ZodString>;
-    timeout_seconds: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-
-declare type _HostBrowserServerMessages = HostBrowserRequestEvent | HostBrowserCancelEvent;
-
-declare type HostCuCancelEvent = z.infer<typeof HostCuCancelEventSchema>;
-
-declare const HostCuCancelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_cu_cancel">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type HostCuRequestEvent = z.infer<typeof HostCuRequestEventSchema>;
-
-declare const HostCuRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_cu_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-    toolName: z.ZodString;
-    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    stepNumber: z.ZodNumber;
-    reasoning: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type _HostCuServerMessages = HostCuRequestEvent | HostCuCancelEvent;
-
-declare type HostFileCancelEvent = z.infer<typeof HostFileCancelEventSchema>;
-
-declare const HostFileCancelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_file_cancel">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+    readonly POST_MODEL_CALL: "post-model-call";
+    /** Fires after the loop successfully compacts a conversation mid-turn. */
+    readonly POST_COMPACT: "post-compact";
+    /** Fires once per deleted conversation, after its rows are removed. Fire-and-forget cleanup signal — hooks run async with no ordering guarantee relative to the caller. */
+    readonly CONVERSATION_DELETED: "conversation-deleted";
+    /** Fires once when every conversation is wiped at once (the clear-all reset), after the main tables are cleared. Carries no `conversationId`; cleanup hooks wipe their own per-conversation state wholesale. */
+    readonly CONVERSATIONS_CLEARED: "conversations-cleared";
+};
 
-declare type HostFileRequestEvent = z.infer<typeof HostFileRequestEventSchema>;
-
-declare const HostFileRequestEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"host_file_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-    operation: z.ZodLiteral<"read">;
-    path: z.ZodString;
-    offset: z.ZodOptional<z.ZodNumber>;
-    limit: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"host_file_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-    operation: z.ZodLiteral<"write">;
-    path: z.ZodString;
-    content: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"host_file_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-    operation: z.ZodLiteral<"edit">;
-    path: z.ZodString;
-    old_string: z.ZodString;
-    new_string: z.ZodString;
-    replace_all: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>], "operation">;
-
-declare type _HostFileServerMessages = HostFileRequestEvent | HostFileCancelEvent;
+/**
+ * Host proxy capabilities that an interface can support. The macOS client
+ * supports all of them; the chrome-extension interface only supports
+ * host_browser (via the Chrome DevTools Protocol proxy).
+ */
+declare const HOST_PROXY_CAPABILITIES: readonly ["host_bash", "host_file", "host_cu", "host_browser", "host_app_control", "host_ui_snapshot"];
 
 declare type HostProxyCapability = (typeof HOST_PROXY_CAPABILITIES)[number];
 
-declare type HostTransferCancelEvent = z.infer<typeof HostTransferCancelEventSchema>;
-
-declare const HostTransferCancelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_transfer_cancel">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type HostTransferRequestEvent = z.infer<typeof HostTransferRequestEventSchema>;
-
-declare const HostTransferRequestEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"host_transfer_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-    direction: z.ZodLiteral<"to_host">;
-    transferId: z.ZodString;
-    destPath: z.ZodString;
-    sizeBytes: z.ZodNumber;
-    sha256: z.ZodString;
-    overwrite: z.ZodBoolean;
-}, z.core.$strip>, z.ZodObject<{
-    type: z.ZodLiteral<"host_transfer_request">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    targetClientId: z.ZodOptional<z.ZodString>;
-    direction: z.ZodLiteral<"to_sandbox">;
-    transferId: z.ZodString;
-    sourcePath: z.ZodString;
-}, z.core.$strip>], "direction">;
-
-declare type _HostTransferServerMessages = HostTransferRequestEvent | HostTransferCancelEvent;
-
-declare type HostUiSnapshotCancelEvent = z.infer<typeof HostUiSnapshotCancelEventSchema>;
-
-declare const HostUiSnapshotCancelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_ui_snapshot_cancel">;
-    requestId: z.ZodString;
-}, z.core.$strip>;
-
-declare type HostUiSnapshotRequestEvent = z.infer<typeof HostUiSnapshotRequestEventSchema>;
-
-declare const HostUiSnapshotRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"host_ui_snapshot_request">;
-    requestId: z.ZodString;
-    view: z.ZodEnum<{
-        sampler: "sampler";
-        chat: "chat";
-    }>;
-    tokens: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>;
-
-declare type _HostUiSnapshotServerMessages = HostUiSnapshotRequestEvent | HostUiSnapshotCancelEvent;
-
-declare type IdentityChangedEvent = z.infer<typeof IdentityChangedEventSchema>;
-
-declare const IdentityChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"identity_changed">;
-    name: z.ZodString;
-    role: z.ZodString;
-    personality: z.ZodString;
-    emoji: z.ZodString;
-    home: z.ZodString;
-}, z.core.$strip>;
-
 export declare interface ImageContent {
     type: "image";
     source: MediaSource_2;
@@ -2852,24 +3062,6 @@ declare interface InsertedMessage {
     deduplicated: boolean;
 }
 
-declare type _IntegrationsServerMessages = ChannelVerificationSessionResponse | OAuthConnectResultEvent | OpenUrlEvent | OpenPanelEvent | NavigateSettingsEvent | ShowPlatformLoginEvent | PlatformDisconnectedEvent;
-
-declare type InteractionResolvedEvent = z.infer<typeof InteractionResolvedEventSchema>;
-
-declare const InteractionResolvedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"interaction_resolved">;
-    requestId: z.ZodString;
-    conversationId: z.ZodString;
-    state: z.ZodEnum<{
-        cancelled: "cancelled";
-        superseded: "superseded";
-        approved: "approved";
-        rejected: "rejected";
-        answered: "answered";
-    }>;
-    kind: z.ZodString;
-}, z.core.$strip>;
-
 declare const INTERFACE_IDS: readonly ["macos", "ios", "cli", "telegram", "phone", "web", "whatsapp", "slack", "email", "chrome-extension", "a2a", "route"];
 
 declare type InterfaceId = (typeof INTERFACE_IDS)[number];
@@ -3219,95 +3411,11 @@ declare const LLMCallSiteEnum: z.ZodEnum<{
 
 declare type MediaSource_2 = Base64MediaSource | WorkspaceRefMediaSource;
 
-declare type MemoryRecalledEvent = z.infer<typeof MemoryRecalledEventSchema>;
-
-declare const MemoryRecalledEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"memory_recalled">;
-    provider: z.ZodString;
-    model: z.ZodString;
-    degradation: z.ZodOptional<z.ZodObject<{
-        semanticUnavailable: z.ZodBoolean;
-        reason: z.ZodString;
-        fallbackSources: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
-    semanticHits: z.ZodNumber;
-    tier1Count: z.ZodNumber;
-    tier2Count: z.ZodNumber;
-    hybridSearchLatencyMs: z.ZodNumber;
-    sparseVectorUsed: z.ZodBoolean;
-    mergedCount: z.ZodNumber;
-    selectedCount: z.ZodNumber;
-    injectedTokens: z.ZodNumber;
-    latencyMs: z.ZodNumber;
-    topCandidates: z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        type: z.ZodString;
-        kind: z.ZodString;
-        finalScore: z.ZodNumber;
-        semantic: z.ZodNumber;
-        recency: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-
-declare type _MemoryServerMessages = MemoryRecalledEvent | MemoryStatusEvent;
-
-declare type MemoryStatusEvent = z.infer<typeof MemoryStatusEventSchema>;
-
-declare const MemoryStatusEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"memory_status">;
-    enabled: z.ZodBoolean;
-    degraded: z.ZodBoolean;
-    degradation: z.ZodOptional<z.ZodObject<{
-        semanticUnavailable: z.ZodBoolean;
-        reason: z.ZodString;
-        fallbackSources: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
-    reason: z.ZodOptional<z.ZodString>;
-    provider: z.ZodOptional<z.ZodString>;
-    model: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 export declare interface Message {
     role: "user" | "assistant";
     content: ContentBlock[];
 }
 
-declare type MessageCompleteEvent = z.infer<typeof MessageCompleteEventSchema>;
-
-declare const MessageCompleteEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"message_complete">;
-    messageId: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    source: z.ZodOptional<z.ZodEnum<{
-        main: "main";
-        aux: "aux";
-    }>>;
-    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        filename: z.ZodString;
-        mimeType: z.ZodString;
-        data: z.ZodString;
-        sourceType: z.ZodOptional<z.ZodEnum<{
-            host_file: "host_file";
-            sandbox_file: "sandbox_file";
-            tool_block: "tool_block";
-        }>>;
-        sizeBytes: z.ZodOptional<z.ZodNumber>;
-        thumbnailData: z.ZodOptional<z.ZodString>;
-        fileBacked: z.ZodOptional<z.ZodBoolean>;
-        filePath: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    attachmentWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-
-declare type MessageDequeuedEvent = z.infer<typeof MessageDequeuedEventSchema>;
-
-declare const MessageDequeuedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"message_dequeued">;
-    conversationId: z.ZodString;
-    requestId: z.ZodString;
-}, z.core.$strip>;
-
 declare type MessageLexicalSearchResult = Awaited<ReturnType<searchMessageIdsLexical_2>>[number];
 
 declare interface MessageLexicalSearchResult_2 {
@@ -3428,32 +3536,6 @@ declare const messageMetadataSchema: z.ZodObject<{
     nonInteractiveContextBlock: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 
-declare type MessageQueuedDeletedEvent = z.infer<typeof MessageQueuedDeletedEventSchema>;
-
-declare const MessageQueuedDeletedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"message_queued_deleted">;
-    conversationId: z.ZodString;
-    requestId: z.ZodString;
-}, z.core.$strip>;
-
-declare type MessageQueuedEvent = z.infer<typeof MessageQueuedEventSchema>;
-
-declare const MessageQueuedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"message_queued">;
-    conversationId: z.ZodString;
-    requestId: z.ZodString;
-    position: z.ZodNumber;
-}, z.core.$strip>;
-
-declare type MessageRequestCompleteEvent = z.infer<typeof MessageRequestCompleteEventSchema>;
-
-declare const MessageRequestCompleteEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"message_request_complete">;
-    conversationId: z.ZodString;
-    requestId: z.ZodString;
-    runStillActive: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-
 /** Allowed values for the `role` column on `messages`. */
 declare type MessageRole = "user" | "assistant" | "system";
 
@@ -3475,41 +3557,6 @@ declare interface MessageRow {
     finalized: number;
 }
 
-declare type _MessagesServerMessages = UserMessageEchoEvent | AssistantTurnStartEvent | AssistantTextDeltaEvent | AssistantThinkingDeltaEvent | ToolUseStartEvent | ToolUsePreviewStartEvent | ToolOutputChunkEvent | ToolInputDeltaEvent | ToolResultEvent | ConfirmationRequestEvent | SecretRequestEvent | QuestionRequestEvent | MessageCompleteEvent | ErrorEvent_2 | MessageQueuedEvent | MessageDequeuedEvent | MessageRequestCompleteEvent | MessageQueuedDeletedEvent | MessageSteeredEvent | ConfirmationStateChangedEvent | AssistantActivityStateEvent | ConversationInferenceProfileUpdatedEvent | InteractionResolvedEvent;
-
-declare type MessageSteeredEvent = z.infer<typeof MessageSteeredEventSchema>;
-
-declare const MessageSteeredEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"message_steered">;
-    conversationId: z.ZodString;
-    requestId: z.ZodString;
-}, z.core.$strip>;
-
-declare type ModelInfoEvent = z.infer<typeof ModelInfoEventSchema>;
-
-declare const ModelInfoEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"model_info">;
-    conversationId: z.ZodOptional<z.ZodString>;
-    model: z.ZodString;
-    provider: z.ZodString;
-    configuredProviders: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    availableModels: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        displayName: z.ZodString;
-    }, z.core.$strip>>>;
-    allProviders: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        displayName: z.ZodString;
-        models: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            displayName: z.ZodString;
-        }, z.core.$strip>>;
-        defaultModel: z.ZodString;
-        apiKeyUrl: z.ZodOptional<z.ZodString>;
-        apiKeyPlaceholder: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-
 /**
  * A workspace inference profile a plugin can route to. Returned by
  * {@link getModelProfiles}; {@link key} is the value a `pre-model-call` hook
@@ -3539,72 +3586,6 @@ export declare interface ModelProfileInfo {
 
 declare type MultimodalEmbeddingInput = TextEmbeddingInput | ImageEmbeddingInput | AudioEmbeddingInput | VideoEmbeddingInput;
 
-declare type NavigateSettingsEvent = z.infer<typeof NavigateSettingsEventSchema>;
-
-declare const NavigateSettingsEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"navigate_settings">;
-    tab: z.ZodString;
-}, z.core.$strip>;
-
-declare type NotificationConversationCreatedEvent = z.infer<typeof NotificationConversationCreatedEventSchema>;
-
-declare const NotificationConversationCreatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"notification_conversation_created">;
-    conversationId: z.ZodString;
-    title: z.ZodString;
-    sourceEventName: z.ZodString;
-    targetGuardianPrincipalId: z.ZodOptional<z.ZodString>;
-    groupId: z.ZodOptional<z.ZodString>;
-    source: z.ZodOptional<z.ZodString>;
-    silent: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-
-declare type NotificationIntentEvent = z.infer<typeof NotificationIntentEventSchema>;
-
-declare const NotificationIntentEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"notification_intent">;
-    sourceEventName: z.ZodString;
-    title: z.ZodString;
-    body: z.ZodString;
-    deliveryId: z.ZodOptional<z.ZodString>;
-    deepLinkMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    targetGuardianPrincipalId: z.ZodOptional<z.ZodString>;
-    silent: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-
-declare type _NotificationsServerMessages = NotificationIntentEvent | NotificationConversationCreatedEvent;
-
-declare type OAuthConnectResultEvent = z.infer<typeof OAuthConnectResultEventSchema>;
-
-declare const OAuthConnectResultEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"oauth_connect_result">;
-    success: z.ZodBoolean;
-    service: z.ZodOptional<z.ZodString>;
-    grantedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    accountInfo: z.ZodOptional<z.ZodString>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type OpenConversationEvent = z.infer<typeof OpenConversationEventSchema>;
-
-declare const OpenConversationEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"open_conversation">;
-    conversationId: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    anchorMessageId: z.ZodOptional<z.ZodString>;
-    focus: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-
-declare type OpenPanelEvent = z.infer<typeof OpenPanelEventSchema>;
-
-declare const OpenPanelEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"open_panel">;
-    panelType: z.ZodString;
-    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    surfaceId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 /**
  * Open a streaming transcription session against the configured STT provider
  * (`services.stt.provider`).
@@ -3626,15 +3607,6 @@ declare const OpenPanelEventSchema: z.ZodObject<{
  */
 export declare function openTranscriptionSession(): Promise<StreamingTranscriber | null>;
 
-declare type OpenUrlEvent = z.infer<typeof OpenUrlEventSchema>;
-
-declare const OpenUrlEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"open_url">;
-    url: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 /** Parse a stored message-metadata JSON string; undefined when absent/invalid. */
 export declare function parseMessageMetadata(metadataJson: string | null): Promise<MessageMetadata>;
 
@@ -3648,12 +3620,6 @@ export declare function parseMessageMetadata(metadataJson: string | null): Promi
  */
 declare function parseMessageMetadata_2(metadataJson: string | null): MessageMetadata_2 | undefined;
 
-declare type PlatformDisconnectedEvent = z.infer<typeof PlatformDisconnectedEventSchema>;
-
-declare const PlatformDisconnectedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"platform_disconnected">;
-}, z.core.$strip>;
-
 /**
  * The subset of {@link AssistantEventHub} workspace plugins may use. Picking
  * method signatures off the class keeps the facade in sync with the hub while
@@ -4166,75 +4132,6 @@ export declare function quarantineRefusedExchanges(messages: Message[]): {
     droppedExchanges: number;
 };
 
-declare type QuestionRequestEvent = z.infer<typeof QuestionRequestEventSchema>;
-
-declare const QuestionRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"question_request">;
-    requestId: z.ZodString;
-    questions: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        question: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        options: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            label: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        freeTextPlaceholder: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    question: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    options: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    freeTextPlaceholder: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    toolUseId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type RecordingPauseEvent = z.infer<typeof RecordingPauseEventSchema>;
-
-declare const RecordingPauseEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"recording_pause">;
-    recordingId: z.ZodString;
-}, z.core.$strip>;
-
-declare type RecordingResumeEvent = z.infer<typeof RecordingResumeEventSchema>;
-
-declare const RecordingResumeEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"recording_resume">;
-    recordingId: z.ZodString;
-}, z.core.$strip>;
-
-declare type RecordingStartEvent = z.infer<typeof RecordingStartEventSchema>;
-
-declare const RecordingStartEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"recording_start">;
-    recordingId: z.ZodString;
-    attachToConversationId: z.ZodOptional<z.ZodString>;
-    options: z.ZodOptional<z.ZodObject<{
-        captureScope: z.ZodOptional<z.ZodEnum<{
-            display: "display";
-            window: "window";
-        }>>;
-        displayId: z.ZodOptional<z.ZodString>;
-        windowId: z.ZodOptional<z.ZodNumber>;
-        includeAudio: z.ZodOptional<z.ZodBoolean>;
-        includeMicrophone: z.ZodOptional<z.ZodBoolean>;
-        promptForSource: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    operationToken: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type RecordingStopEvent = z.infer<typeof RecordingStopEventSchema>;
-
-declare const RecordingStopEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"recording_stop">;
-    recordingId: z.ZodString;
-}, z.core.$strip>;
-
 export declare interface RedactedThinkingContent {
     type: "redacted_thinking";
     data: string;
@@ -4253,13 +4150,6 @@ export declare interface RedactedThinkingContent {
  */
 export declare const REFUSAL_FALLBACK_TEXT = "Sorry \u2014 I wasn't able to generate a response to that. Please try rephrasing or asking in a different way.";
 
-declare type RelationshipStateUpdatedEvent = z.infer<typeof RelationshipStateUpdatedEventSchema>;
-
-declare const RelationshipStateUpdatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"relationship_state_updated">;
-    updatedAt: z.ZodString;
-}, z.core.$strip>;
-
 declare type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
 
 /**
@@ -4499,17 +4389,6 @@ export declare interface RunConversationTurnResult {
     queued?: boolean;
 }
 
-declare type ScheduleConversationCreatedEvent = z.infer<typeof ScheduleConversationCreatedEventSchema>;
-
-declare const ScheduleConversationCreatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"schedule_conversation_created">;
-    conversationId: z.ZodString;
-    scheduleJobId: z.ZodString;
-    title: z.ZodString;
-}, z.core.$strip>;
-
-declare type _SchedulesServerMessages = HeartbeatAlertEvent | HeartbeatConversationCreatedEvent;
-
 /** Sparse lexical search over stored message text; ranked message-id hits. */
 export declare function searchMessageIdsLexical(query: string, limit: number, opts?: {
     conversationId?: string;
@@ -4574,23 +4453,6 @@ declare interface SecretPromptResult {
     collectionExpiresAt?: number;
 }
 
-declare type SecretRequestEvent = z.infer<typeof SecretRequestEventSchema>;
-
-declare const SecretRequestEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"secret_request">;
-    requestId: z.ZodString;
-    service: z.ZodString;
-    field: z.ZodString;
-    label: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    placeholder: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    purpose: z.ZodOptional<z.ZodString>;
-    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    allowOneTimeSend: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-
 /** Whether the active embedding backend handles multimodal inputs. */
 export declare function selectedBackendSupportsMultimodal(): Promise<boolean>;
 
@@ -4712,8 +4574,6 @@ declare interface SensitiveOutputBinding {
 
 declare type SensitiveOutputKind = "invite_code";
 
-declare type ServerMessage = _ConversationsServerMessages | _MessagesServerMessages | _SurfacesServerMessages | _SkillsServerMessages | _AppsServerMessages | _IntegrationsServerMessages | _ComputerUseServerMessages | _ContactsServerMessages | _SubagentsServerMessages | _DocumentsServerMessages | _DocumentCommentsServerMessages | _SyncInvalidationServerMessages | _HomeServerMessages | _HostAppControlServerMessages | _HostBashServerMessages | _HostBrowserServerMessages | _HostCuServerMessages | _HostFileServerMessages | _HostTransferServerMessages | _HostUiSnapshotServerMessages | _MemoryServerMessages | _WorkspaceServerMessages | _SchedulesServerMessages | _SettingsServerMessages | _NotificationsServerMessages | _UpgradesServerMessages | _AcpServerMessages | _BackgroundToolsServerMessages | _BookmarksServerMessages | _WorkflowsServerMessages | DiskPressureStatusChangedEvent | HookEvent | SubagentEventEvent;
-
 export declare interface ServerToolUseContent {
     type: "server_tool_use";
     id: string;
@@ -4721,38 +4581,6 @@ export declare interface ServerToolUseContent {
     input: Record<string, unknown>;
 }
 
-declare type ServiceGroupUpdateCompleteEvent = z.infer<typeof ServiceGroupUpdateCompleteEventSchema>;
-
-declare const ServiceGroupUpdateCompleteEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"service_group_update_complete">;
-    installedVersion: z.ZodString;
-    success: z.ZodBoolean;
-    rolledBackToVersion: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type ServiceGroupUpdateProgressEvent = z.infer<typeof ServiceGroupUpdateProgressEventSchema>;
-
-declare const ServiceGroupUpdateProgressEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"service_group_update_progress">;
-    statusMessage: z.ZodString;
-}, z.core.$strip>;
-
-declare type ServiceGroupUpdateStartingEvent = z.infer<typeof ServiceGroupUpdateStartingEventSchema>;
-
-declare const ServiceGroupUpdateStartingEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"service_group_update_starting">;
-    targetVersion: z.ZodString;
-    expectedDowntimeSeconds: z.ZodNumber;
-}, z.core.$strip>;
-
-declare type _SettingsServerMessages = ClientSettingsUpdateEvent | AvatarUpdatedEvent | ConfigChangedEvent | SoundsConfigUpdatedEvent;
-
-declare type ShowPlatformLoginEvent = z.infer<typeof ShowPlatformLoginEventSchema>;
-
-declare const ShowPlatformLoginEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"show_platform_login">;
-}, z.core.$strip>;
-
 /**
  * Context passed to the `shutdown` hook. Kept intentionally narrower than
  * {@link InitContext} — teardown paths only need to know which assistant
@@ -4823,27 +4651,6 @@ declare interface SkillInstallMeta {
  */
 declare type SkillSource = "bundled" | "managed" | "workspace" | "extra" | "plugin";
 
-declare type _SkillsServerMessages = SkillStateChangedEvent;
-
-declare type SkillStateChangedEvent = z.infer<typeof SkillStateChangedEventSchema>;
-
-declare const SkillStateChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"skills_state_changed">;
-    name: z.ZodString;
-    state: z.ZodEnum<{
-        enabled: "enabled";
-        disabled: "disabled";
-        installed: "installed";
-        uninstalled: "uninstalled";
-    }>;
-}, z.core.$strip>;
-
-declare type SoundsConfigUpdatedEvent = z.infer<typeof SoundsConfigUpdatedEventSchema>;
-
-declare const SoundsConfigUpdatedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"sounds_config_updated">;
-}, z.core.$strip>;
-
 /**
  * The full `stop` context a hook receives — the dispatching call site's
  * {@link StopInputContext} plus the pipeline-stamped {@link BaseHookContext}
@@ -5075,60 +4882,6 @@ export declare interface SttStreamServerPartialEvent {
     readonly confidence?: number;
 }
 
-declare type SubagentEventEvent = z.infer<typeof SubagentEventEventSchema>;
-
-declare const SubagentEventEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"subagent_event">;
-    conversationId: z.ZodString;
-    subagentId: z.ZodString;
-    event: z.ZodObject<{
-        type: z.ZodString;
-        content: z.ZodOptional<z.ZodString>;
-        text: z.ZodOptional<z.ZodString>;
-        result: z.ZodOptional<z.ZodString>;
-        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        toolName: z.ZodOptional<z.ZodString>;
-        isError: z.ZodOptional<z.ZodBoolean>;
-        toolUseId: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>;
-}, z.core.$strict>;
-
-declare type SubagentSpawnedEvent = z.infer<typeof SubagentSpawnedEventSchema>;
-
-declare const SubagentSpawnedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"subagent_spawned">;
-    subagentId: z.ZodString;
-    parentConversationId: z.ZodString;
-    label: z.ZodString;
-    objective: z.ZodString;
-    isFork: z.ZodOptional<z.ZodBoolean>;
-    parentToolUseId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
-declare type _SubagentsServerMessages = SubagentSpawnedEvent | SubagentStatusChangedEvent;
-
-declare type SubagentStatusChangedEvent = z.infer<typeof SubagentStatusChangedEventSchema>;
-
-declare const SubagentStatusChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"subagent_status_changed">;
-    subagentId: z.ZodString;
-    status: z.ZodEnum<{
-        completed: "completed";
-        failed: "failed";
-        running: "running";
-        pending: "pending";
-        awaiting_input: "awaiting_input";
-        aborted: "aborted";
-        interrupted: "interrupted";
-    }>;
-    error: z.ZodOptional<z.ZodString>;
-    usage: z.ZodOptional<z.ZodObject<{
-        inputTokens: z.ZodNumber;
-        outputTokens: z.ZodNumber;
-        estimatedCost: z.ZodNumber;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-
 declare type SubscriberEntry = ClientEntry | ProcessEntry;
 
 /** Input shape for `subscribe()` — hub fills `active`, `connectedAt`, `lastActiveAt`, `connectionId` and defaults `filter`/`onEvict`. */
@@ -5137,8 +4890,6 @@ declare type SubscriberInput = DistributiveOmit<SubscriberEntry, "active" | "con
     onEvict?: () => void;
 };
 
-declare type _SurfacesServerMessages = UISurfaceShowEvent | UISurfaceUpdateEvent | UISurfaceDismissEvent | UISurfaceCompleteEvent | UISurfaceUndoResultEvent;
-
 /**
  * Delete `graph_node` Qdrant points whose backing `memory_graph_nodes` row no
  * longer exists.
@@ -5167,16 +4918,6 @@ declare type _SurfacesServerMessages = UISurfaceShowEvent | UISurfaceUpdateEvent
  */
 export declare function sweepOrphanedGraphNodePoints(qdrant: GraphNodeSweepClient): Promise<GraphNodeSweepResult>;
 
-declare type SyncChangedEvent = z.infer<typeof SyncChangedEventSchema>;
-
-declare const SyncChangedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"sync_changed">;
-    tags: z.ZodArray<z.ZodString>;
-    originClientId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type _SyncInvalidationServerMessages = SyncChangedEvent;
-
 /** Re-sync one persisted message into the conversation's disk view. */
 export declare function syncMessageToDisk(conversationId: string, messageId: string, createdAtMs: number): Promise<void>;
 
@@ -5650,36 +5391,6 @@ export declare interface ToolExecutionResult {
     activityMetadata?: ToolActivityMetadata;
 }
 
-declare type ToolInputDeltaEvent = z.infer<typeof ToolInputDeltaEventSchema>;
-
-declare const ToolInputDeltaEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool_input_delta">;
-    toolName: z.ZodString;
-    content: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-    toolUseId: z.ZodOptional<z.ZodString>;
-    messageId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type ToolOutputChunkEvent = z.infer<typeof ToolOutputChunkEventSchema>;
-
-declare const ToolOutputChunkEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool_output_chunk">;
-    chunk: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-    toolUseId: z.ZodOptional<z.ZodString>;
-    subType: z.ZodOptional<z.ZodEnum<{
-        status: "status";
-        tool_start: "tool_start";
-        tool_complete: "tool_complete";
-    }>>;
-    subToolName: z.ZodOptional<z.ZodString>;
-    subToolInput: z.ZodOptional<z.ZodString>;
-    subToolIsError: z.ZodOptional<z.ZodBoolean>;
-    subToolId: z.ZodOptional<z.ZodString>;
-    messageId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
 export declare interface ToolResultContent {
     type: "tool_result";
     tool_use_id: string;
@@ -5689,94 +5400,6 @@ export declare interface ToolResultContent {
     contentBlocks?: ContentBlock[];
 }
 
-declare type ToolResultEvent = z.infer<typeof ToolResultEventSchema>;
-
-declare const ToolResultEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool_result">;
-    toolName: z.ZodString;
-    result: z.ZodString;
-    isError: z.ZodOptional<z.ZodBoolean>;
-    diff: z.ZodOptional<z.ZodObject<{
-        filePath: z.ZodString;
-        oldContent: z.ZodString;
-        newContent: z.ZodString;
-        isNewFile: z.ZodBoolean;
-    }, z.core.$strip>>;
-    status: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    imageData: z.ZodOptional<z.ZodString>;
-    imageDataList: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    toolUseId: z.ZodOptional<z.ZodString>;
-    messageId: z.ZodOptional<z.ZodString>;
-    riskLevel: z.ZodOptional<z.ZodString>;
-    riskReason: z.ZodOptional<z.ZodString>;
-    matchedTrustRuleId: z.ZodOptional<z.ZodString>;
-    isContainerized: z.ZodOptional<z.ZodBoolean>;
-    riskScopeOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        pattern: z.ZodString;
-        label: z.ZodString;
-    }, z.core.$strip>>>;
-    riskAllowlistOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        description: z.ZodString;
-        pattern: z.ZodString;
-    }, z.core.$strip>>>;
-    riskDirectoryScopeOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        scope: z.ZodString;
-    }, z.core.$strip>>>;
-    approvalMode: z.ZodOptional<z.ZodString>;
-    approvalReason: z.ZodOptional<z.ZodString>;
-    riskThreshold: z.ZodOptional<z.ZodString>;
-    activityMetadata: z.ZodOptional<z.ZodObject<{
-        webSearch: z.ZodOptional<z.ZodObject<{
-            query: z.ZodString;
-            provider: z.ZodEnum<{
-                "anthropic-native": "anthropic-native";
-                brave: "brave";
-                perplexity: "perplexity";
-                tavily: "tavily";
-                firecrawl: "firecrawl";
-            }>;
-            resultCount: z.ZodNumber;
-            durationMs: z.ZodNumber;
-            results: z.ZodArray<z.ZodObject<{
-                rank: z.ZodNumber;
-                title: z.ZodString;
-                url: z.ZodString;
-                domain: z.ZodString;
-                faviconUrl: z.ZodOptional<z.ZodString>;
-                snippet: z.ZodOptional<z.ZodString>;
-                age: z.ZodOptional<z.ZodString>;
-                score: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            errorMessage: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        webFetch: z.ZodOptional<z.ZodObject<{
-            url: z.ZodString;
-            finalUrl: z.ZodString;
-            provider: z.ZodOptional<z.ZodEnum<{
-                default: "default";
-                firecrawl: "firecrawl";
-            }>>;
-            status: z.ZodNumber;
-            contentType: z.ZodOptional<z.ZodString>;
-            byteCount: z.ZodNumber;
-            charCount: z.ZodNumber;
-            truncated: z.ZodBoolean;
-            title: z.ZodOptional<z.ZodString>;
-            domain: z.ZodString;
-            faviconUrl: z.ZodOptional<z.ZodString>;
-            redirectCount: z.ZodNumber;
-            durationMs: z.ZodNumber;
-            errorMessage: z.ZodOptional<z.ZodString>;
-            mayRequireJavaScript: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    errorCode: z.ZodOptional<z.ZodString>;
-    completedAt: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-
 export declare interface ToolUseContent {
     type: "tool_use";
     id: string;
@@ -5789,30 +5412,6 @@ export declare interface ToolUseContent {
     };
 }
 
-declare type ToolUsePreviewStartEvent = z.infer<typeof ToolUsePreviewStartEventSchema>;
-
-declare const ToolUsePreviewStartEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool_use_preview_start">;
-    toolUseId: z.ZodString;
-    toolName: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-    messageId: z.ZodOptional<z.ZodString>;
-    previewStartedAt: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-
-declare type ToolUseStartEvent = z.infer<typeof ToolUseStartEventSchema>;
-
-declare const ToolUseStartEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"tool_use_start">;
-    toolName: z.ZodString;
-    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    toolUseId: z.ZodOptional<z.ZodString>;
-    messageId: z.ZodOptional<z.ZodString>;
-    conversationId: z.ZodOptional<z.ZodString>;
-    startedAt: z.ZodOptional<z.ZodNumber>;
-    previewStartedAt: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-
 declare type TrustClass = z.infer<typeof trustClassSchema>;
 
 declare const trustClassSchema: z.ZodEnum<{
@@ -5847,76 +5446,9 @@ declare type TtsUseCase =
 /** In-app message playback — buffer-oriented, higher quality acceptable. */
 | "message-playback";
 
-declare type UISurfaceCompleteEvent = z.infer<typeof UISurfaceCompleteEventSchema>;
-
-declare const UISurfaceCompleteEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ui_surface_complete">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    summary: z.ZodString;
-    submittedData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-
-declare type UISurfaceDismissEvent = z.infer<typeof UISurfaceDismissEventSchema>;
-
-declare const UISurfaceDismissEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ui_surface_dismiss">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-}, z.core.$strip>;
-
-declare type UISurfaceShowEvent = z.infer<typeof UISurfaceShowEventSchema>;
-
-declare const UISurfaceShowEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ui_surface_show">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    surfaceType: z.ZodString;
-    title: z.ZodOptional<z.ZodString>;
-    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        style: z.ZodOptional<z.ZodEnum<{
-            primary: "primary";
-            secondary: "secondary";
-            destructive: "destructive";
-        }>>;
-        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>>;
-    display: z.ZodOptional<z.ZodEnum<{
-        inline: "inline";
-        panel: "panel";
-    }>>;
-    messageId: z.ZodOptional<z.ZodString>;
-    persistent: z.ZodOptional<z.ZodBoolean>;
-    toolCallId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-
-declare type UISurfaceUndoResultEvent = z.infer<typeof UISurfaceUndoResultEventSchema>;
-
-declare const UISurfaceUndoResultEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ui_surface_undo_result">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    success: z.ZodBoolean;
-    remainingUndos: z.ZodNumber;
-}, z.core.$strip>;
-
-declare type UISurfaceUpdateEvent = z.infer<typeof UISurfaceUpdateEventSchema>;
-
-declare const UISurfaceUpdateEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"ui_surface_update">;
-    conversationId: z.ZodString;
-    surfaceId: z.ZodString;
-    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>;
-
 /** Merge the given keys into a message's metadata JSON. */
 export declare function updateMessageMetadata(messageId: string, updates: Record<string, unknown>): Promise<void>;
 
-declare type _UpgradesServerMessages = ServiceGroupUpdateStartingEvent | ServiceGroupUpdateProgressEvent | ServiceGroupUpdateCompleteEvent;
-
 declare type UsageAttributionProfileSource = "call_site" | "conversation" | "active" | "default" | "unknown";
 
 declare interface UsageAttributionSnapshot {
@@ -5936,45 +5468,6 @@ declare interface UsageAttributionSnapshot {
     resolvedMixArm: string | null;
 }
 
-declare type UsageProgressEvent = z.infer<typeof UsageProgressEventSchema>;
-
-declare const UsageProgressEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"usage_progress">;
-    conversationId: z.ZodString;
-    inputTokens: z.ZodNumber;
-    outputTokens: z.ZodNumber;
-    estimatedCost: z.ZodNumber;
-    model: z.ZodString;
-}, z.core.$strip>;
-
-declare type UsageUpdateEvent = z.infer<typeof UsageUpdateEventSchema>;
-
-declare const UsageUpdateEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"usage_update">;
-    conversationId: z.ZodString;
-    inputTokens: z.ZodNumber;
-    outputTokens: z.ZodNumber;
-    cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
-    cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
-    totalInputTokens: z.ZodNumber;
-    totalOutputTokens: z.ZodNumber;
-    estimatedCost: z.ZodNumber;
-    model: z.ZodString;
-    contextWindowTokens: z.ZodOptional<z.ZodNumber>;
-    contextWindowMaxTokens: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-
-declare type UserMessageEchoEvent = z.infer<typeof UserMessageEchoEventSchema>;
-
-declare const UserMessageEchoEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"user_message_echo">;
-    text: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-    messageId: z.ZodOptional<z.ZodString>;
-    requestId: z.ZodOptional<z.ZodString>;
-    clientMessageId: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
 /**
  * The full `user-prompt-submit` context a hook receives — the dispatching
  * call site's {@link UserPromptSubmitInputContext} plus the pipeline-stamped
@@ -6139,79 +5632,6 @@ export declare interface WebSearchToolResultContent {
     content: unknown;
 }
 
-declare type WorkflowCompletedEvent = z.infer<typeof WorkflowCompletedEventSchema>;
-
-declare const WorkflowCompletedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"workflow_completed">;
-    runId: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-    status: z.ZodEnum<{
-        completed: "completed";
-        failed: "failed";
-        running: "running";
-        aborted: "aborted";
-        interrupted: "interrupted";
-        cap_exceeded: "cap_exceeded";
-    }>;
-    agentsSpawned: z.ZodNumber;
-    inputTokens: z.ZodNumber;
-    outputTokens: z.ZodNumber;
-    summary: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
-declare type WorkflowLeafFinishedEvent = z.infer<typeof WorkflowLeafFinishedEventSchema>;
-
-declare const WorkflowLeafFinishedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"workflow_leaf_finished">;
-    runId: z.ZodString;
-    conversationId: z.ZodString;
-    seq: z.ZodNumber;
-    status: z.ZodEnum<{
-        completed: "completed";
-        failed: "failed";
-    }>;
-    label: z.ZodOptional<z.ZodString>;
-    inputTokens: z.ZodOptional<z.ZodNumber>;
-    outputTokens: z.ZodOptional<z.ZodNumber>;
-    resultSummary: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
-declare type WorkflowLeafStartedEvent = z.infer<typeof WorkflowLeafStartedEventSchema>;
-
-declare const WorkflowLeafStartedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"workflow_leaf_started">;
-    runId: z.ZodString;
-    conversationId: z.ZodString;
-    seq: z.ZodNumber;
-    label: z.ZodOptional<z.ZodString>;
-    phase: z.ZodOptional<z.ZodString>;
-    promptSummary: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
-declare type WorkflowProgressEvent = z.infer<typeof WorkflowProgressEventSchema>;
-
-declare const WorkflowProgressEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"workflow_progress">;
-    runId: z.ZodString;
-    conversationId: z.ZodOptional<z.ZodString>;
-    agentsSpawned: z.ZodNumber;
-    phase: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
-declare type _WorkflowsServerMessages = WorkflowProgressEvent | WorkflowCompletedEvent | WorkflowStartedEvent | WorkflowLeafStartedEvent | WorkflowLeafFinishedEvent;
-
-declare type WorkflowStartedEvent = z.infer<typeof WorkflowStartedEventSchema>;
-
-declare const WorkflowStartedEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"workflow_started">;
-    runId: z.ZodString;
-    conversationId: z.ZodString;
-    toolUseId: z.ZodOptional<z.ZodString>;
-    label: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-
 /**
  * A reference to bytes stored in the workspace rather than inlined. The bytes
  * live in the workspace attachment store, addressed by `attachmentId`, and are
@@ -6237,6 +5657,4 @@ declare interface WorkspaceRefMediaSource {
     height?: number;
 }
 
-declare type _WorkspaceServerMessages = IdentityChangedEvent;
-
 export { }