@vellumai/plugin-api 0.10.11-dev.202607231934.db954e6 → 0.10.11-dev.202607232029.2295f95

package/index.d.ts

@@ -671,6 +671,7 @@ declare const AssistantConfigSchema: z.ZodObject<{
             timeThresholdMs: z.ZodDefault<z.ZodNumber>;
             messageThreshold: z.ZodDefault<z.ZodNumber>;
             minCooldownMs: z.ZodDefault<z.ZodNumber>;
+            sweepIntervalMs: z.ZodDefault<z.ZodNumber>;
             keepSupersededRuns: z.ZodDefault<z.ZodBoolean>;
             matchConversationProfile: z.ZodDefault<z.ZodBoolean>;
             promptPath: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -1486,11 +1487,13 @@ export declare interface AssistantEventSubscription {
     readonly connectionId: string;
 }
 
-declare interface AssistantStatusMessage {
-    type: "assistant_status";
-    version?: string;
-    keyFingerprint?: 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>;
 
@@ -1525,12 +1528,6 @@ declare interface AudioEmbeddingInput {
     mimeType: string;
 }
 
-declare interface AuthResult {
-    type: "auth_result";
-    success: boolean;
-    message?: string;
-}
-
 declare type AvatarUpdatedEvent = z.infer<typeof AvatarUpdatedEventSchema>;
 
 declare const AvatarUpdatedEventSchema: z.ZodObject<{
@@ -2007,25 +2004,30 @@ declare const ConfirmationRequestEventSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 
-/**
- * Authoritative per-request confirmation state transition emitted by the daemon.
- *
- * The client must use this event (not local phrase inference) to update
- * confirmation bubble state.
- */
-declare interface ConfirmationStateChanged {
-    type: "confirmation_state_changed";
-    conversationId: string;
-    requestId: string;
-    state: "pending" | "approved" | "denied" | "timed_out" | "resolved_stale";
-    source: "button" | "inline_nl" | "auto_deny" | "timeout" | "system";
-    /** requestId of the user message that triggered this transition. */
-    causedByRequestId?: string;
-    /** Normalized user text for analytics/debug (e.g. "approve", "deny"). */
-    decisionText?: string;
-    /** The tool_use block ID this confirmation applies to, for disambiguating parallel tool calls. */
-    toolUseId?: string;
-}
+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 ConfirmationSurfaceData = z.infer<typeof ConfirmationSurfaceDataSchema>;
 
@@ -2060,42 +2062,24 @@ declare type _ContactsServerMessages = ContactsChangedEvent | ContactRequestEven
 
 export declare type ContentBlock = TextContent | ThinkingContent | RedactedThinkingContent | ImageContent | FileContent | ToolUseContent | ToolResultContent | ServerToolUseContent | WebSearchToolResultContent;
 
-/**
- * Emitted after a compaction turn completes (both auto-compaction and
- * `/compact`). Carries the fresh `estimatedInputTokens` so clients can refresh
- * the context-window indicator without waiting for the next `usage_update`.
- *
- * Scoped per-conversation — see `CompactionCircuitOpenEvent` doc for why.
- */
-declare interface ContextCompacted {
-    type: "context_compacted";
-    conversationId: string;
-    previousEstimatedInputTokens: number;
-    estimatedInputTokens: number;
-    maxInputTokens: number;
-    thresholdTokens: number;
-    compactedMessages: number;
-    summaryCalls: number;
-    summaryInputTokens: number;
-    summaryOutputTokens: number;
-    summaryModel: string;
-    /**
-     * Quality signals for the generated summary. Emitted for every
-     * compaction (including truncation-only paths where the summary text
-     * is unchanged from the prior pass). Consumers can use these to detect
-     * regressions without needing to read the summary text itself.
-     *
-     * - `summaryCharCount`: length of the produced summary text.
-     * - `summaryHeaderCount`: number of `## ` section headers in the summary.
-     * - `summaryHadMemoryEcho`: `true` if the summary contains any runtime
-     *   injection tag (e.g. `<memory`, `<turn_context>`, `<workspace>`). The
-     *   durable summary should be clean prose, so `true` flags an echoed or
-     *   invented tag worth investigating.
-     */
-    summaryCharCount?: number;
-    summaryHeaderCount?: number;
-    summaryHadMemoryEcho?: boolean;
-}
+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";
@@ -2167,19 +2151,15 @@ declare interface ConversationForkParent {
     title: string;
 }
 
-/**
- * Broadcast to clients when a conversation's inference-profile override
- * changes. `profile` is the profile name (a key in `llm.profiles`) or
- * `null` when the override is cleared and the conversation falls back to
- * the workspace `llm.activeProfile` resolution.
- */
-declare interface ConversationInferenceProfileUpdated {
-    type: "conversation_inference_profile_updated";
-    conversationId: string;
-    profile: string | null;
-    sessionId?: string | null;
-    expiresAt?: number | null;
-}
+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 interface ConversationInfo {
     type: "conversation_info";
@@ -2311,33 +2291,7 @@ export declare interface ConversationRow {
  */
 export declare type ConversationsClearedContext = BaseHookContext;
 
-declare interface ConversationsClearResponse {
-    type: "conversations_clear_response";
-    cleared: number;
-}
-
-declare interface ConversationSearchMatchingMessage {
-    messageId: string;
-    role: string;
-    /** Plain-text excerpt around the match, truncated to ~200 chars. */
-    excerpt: string;
-    createdAt: number;
-}
-
-declare interface ConversationSearchResponse {
-    type: "conversation_search_response";
-    query: string;
-    results: ConversationSearchResultItem[];
-}
-
-declare interface ConversationSearchResultItem {
-    conversationId: string;
-    conversationTitle: string | null;
-    conversationUpdatedAt: number;
-    matchingMessages: ConversationSearchMatchingMessage[];
-}
-
-declare type _ConversationsServerMessages = AuthResult | PongMessage | AssistantStatusMessage | GenerationCancelledEvent | GenerationHandoffEvent | ModelInfo | HistoryResponse | UndoComplete | UsageUpdateEvent | UsageProgressEvent | UsageResponse | ContextCompacted | CompactionCircuitOpenEvent | CompactionCircuitClosedEvent | ConversationErrorEvent | ConversationNoticeEvent | ConversationInfo | ConversationTitleUpdatedEvent | ConversationListResponse | ConversationsClearResponse | ConversationSearchResponse | MessageContentResponse | ConversationListInvalidatedEvent | ScheduleConversationCreated | OpenConversationEvent;
+declare type _ConversationsServerMessages = AssistantStatusEvent | GenerationCancelledEvent | GenerationHandoffEvent | ModelInfoEvent | HistoryResponse | UndoComplete | UsageUpdateEvent | UsageProgressEvent | UsageResponse | ContextCompactedEvent | CompactionCircuitOpenEvent | CompactionCircuitClosedEvent | ConversationErrorEvent | ConversationNoticeEvent | ConversationInfo | ConversationTitleUpdatedEvent | ConversationListResponse | ConversationListInvalidatedEvent | ScheduleConversationCreatedEvent | OpenConversationEvent;
 
 declare type ConversationTitleUpdatedEvent = z.infer<typeof ConversationTitleUpdatedEventSchema>;
 
@@ -3085,117 +3039,84 @@ export declare const HOOKS: {
  */
 declare const HOST_PROXY_CAPABILITIES: readonly ["host_bash", "host_file", "host_cu", "host_browser", "host_app_control", "host_ui_snapshot"];
 
-declare interface HostAppControlCancel {
-    type: "host_app_control_cancel";
-    requestId: string;
-    conversationId: string;
-}
-
-declare interface HostAppControlClickInput {
-    tool: "click";
-    app: string;
-    x: number;
-    y: number;
-    button?: "left" | "right" | "middle";
-    double?: boolean;
-}
-
-declare interface HostAppControlComboInput {
-    tool: "combo";
-    app: string;
-    /** Sequence of keys pressed simultaneously, e.g. ["cmd", "shift", "4"]. */
-    keys: string[];
-    /** Hold duration in milliseconds. */
-    duration_ms?: number;
-}
-
-declare interface HostAppControlDragInput {
-    tool: "drag";
-    app: string;
-    from_x: number;
-    from_y: number;
-    to_x: number;
-    to_y: number;
-    button?: "left" | "right" | "middle";
-}
-
-/** Inputs accepted by the nine app-control tool variants. */
-declare type HostAppControlInput = HostAppControlStartInput | HostAppControlObserveInput | HostAppControlPressInput | HostAppControlComboInput | HostAppControlSequenceInput | HostAppControlTypeInput | HostAppControlClickInput | HostAppControlDragInput | HostAppControlStopInput;
-
-declare interface HostAppControlObserveInput {
-    tool: "observe";
-    app: string;
-    /**
-     * Milliseconds to wait between receiving the request and capturing the
-     * window. Lets the target app process pending input and the WindowServer
-     * composite a fresh frame. When omitted, the client uses its default
-     * (~200ms, sized for emulator-class apps at 60fps). Pass `0` for static
-     * UIs to make `observe` snappier; raise it for slow-feedback apps.
-     */
-    settle_ms?: number;
-}
-
-declare interface HostAppControlPressInput {
-    tool: "press";
-    app: string;
-    /** Single key identifier, e.g. "return", "a", "f12". */
-    key: string;
-    /** Modifier list, e.g. ["cmd", "shift"]. */
-    modifiers?: string[];
-    /** Hold duration in milliseconds. */
-    duration_ms?: number;
-}
+declare type HostAppControlCancelEvent = z.infer<typeof HostAppControlCancelEventSchema>;
 
-declare interface HostAppControlRequest {
-    type: "host_app_control_request";
-    requestId: string;
-    conversationId: string;
-    toolName: string;
-    input: HostAppControlInput;
-}
-
-declare interface HostAppControlSequenceInput {
-    tool: "sequence";
-    app: string;
-    /** Ordered list of single-key presses to execute serially. */
-    steps: HostAppControlSequenceStep[];
-}
-
-/** A single step inside a sequence: one key press with optional modifiers, hold duration, and post-press gap. */
-declare interface HostAppControlSequenceStep {
-    /** Single key identifier, e.g. "right", "a", "return". */
-    key: string;
-    /** Modifier list, e.g. ["cmd", "shift"]. Omit for no modifiers. */
-    modifiers?: string[];
-    /** Hold duration for this key in milliseconds. */
-    duration_ms?: number;
-    /** Pause after this step before starting the next, in milliseconds. */
-    gap_ms?: number;
-}
-
-declare type _HostAppControlServerMessages = HostAppControlRequest | HostAppControlCancel;
+declare const HostAppControlCancelEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"host_app_control_cancel">;
+    requestId: z.ZodString;
+    conversationId: z.ZodString;
+}, z.core.$strip>;
 
-declare interface HostAppControlStartInput {
-    tool: "start";
-    /** Bundle ID (preferred) or process name. */
-    app: string;
-    /** Optional command-line arguments to launch the app with. */
-    args?: string[];
-}
+declare type HostAppControlRequestEvent = z.infer<typeof HostAppControlRequestEventSchema>;
 
-declare interface HostAppControlStopInput {
-    tool: "stop";
-    /** Optional — when omitted the proxy stops whichever app currently holds the session. */
-    app?: string;
-    /** Free-form reason, surfaced for logging. */
-    reason?: string;
-}
+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 interface HostAppControlTypeInput {
-    tool: "type";
-    app: string;
-    text: string;
-}
+declare type _HostAppControlServerMessages = HostAppControlRequestEvent | HostAppControlCancelEvent;
 
 declare type HostBashCancelEvent = z.infer<typeof HostBashCancelEventSchema>;
 
@@ -3221,26 +3142,26 @@ declare const HostBashRequestEventSchema: z.ZodObject<{
 
 declare type _HostBashServerMessages = HostBashRequestEvent | HostBashCancelEvent;
 
-declare interface HostBrowserCancelRequest {
-    type: "host_browser_cancel";
-    requestId: string;
-}
+declare type HostBrowserCancelEvent = z.infer<typeof HostBrowserCancelEventSchema>;
 
-declare interface HostBrowserRequest {
-    type: "host_browser_request";
-    requestId: string;
-    conversationId: string;
-    /** CDP method name, e.g. "Page.navigate", "Runtime.evaluate", "Accessibility.getFullAXTree". */
-    cdpMethod: string;
-    /** Opaque JSON params object forwarded verbatim to CDP. */
-    cdpParams?: Record<string, unknown>;
-    /** Optional CDP target/session ID; omitted = "most-recently-active tab". */
-    cdpSessionId?: string;
-    /** Client-side timeout hint; defaults to 30s in the proxy. */
-    timeout_seconds?: number;
-}
+declare const HostBrowserCancelEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"host_browser_cancel">;
+    requestId: z.ZodString;
+}, z.core.$strip>;
 
-declare type _HostBrowserServerMessages = HostBrowserRequest | HostBrowserCancelRequest;
+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>;
 
@@ -3266,85 +3187,83 @@ declare const HostCuRequestEventSchema: z.ZodObject<{
 
 declare type _HostCuServerMessages = HostCuRequestEvent | HostCuCancelEvent;
 
-declare interface HostFileCancelRequest {
-    type: "host_file_cancel";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-}
+declare type HostFileCancelEvent = z.infer<typeof HostFileCancelEventSchema>;
 
-declare interface HostFileEditRequest {
-    type: "host_file_request";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-    operation: "edit";
-    path: string;
-    old_string: string;
-    new_string: string;
-    replace_all?: boolean;
-}
+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>;
 
-declare interface HostFileReadRequest {
-    type: "host_file_request";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-    operation: "read";
-    path: string;
-    offset?: number;
-    limit?: number;
-}
+declare type HostFileRequestEvent = z.infer<typeof HostFileRequestEventSchema>;
 
-declare type HostFileRequest = HostFileReadRequest | HostFileWriteRequest | HostFileEditRequest;
+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 = HostFileRequest | HostFileCancelRequest;
-
-declare interface HostFileWriteRequest {
-    type: "host_file_request";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-    operation: "write";
-    path: string;
-    content: string;
-}
+declare type _HostFileServerMessages = HostFileRequestEvent | HostFileCancelEvent;
 
 declare type HostProxyCapability = (typeof HOST_PROXY_CAPABILITIES)[number];
 
-declare interface HostTransferCancelRequest {
-    type: "host_transfer_cancel";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-}
+declare type HostTransferCancelEvent = z.infer<typeof HostTransferCancelEventSchema>;
 
-declare type HostTransferRequest = HostTransferToHostRequest | HostTransferToSandboxRequest;
+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 _HostTransferServerMessages = HostTransferRequest | HostTransferCancelRequest;
+declare type HostTransferRequestEvent = z.infer<typeof HostTransferRequestEventSchema>;
 
-declare interface HostTransferToHostRequest {
-    type: "host_transfer_request";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-    direction: "to_host";
-    transferId: string;
-    destPath: string;
-    sizeBytes: number;
-    sha256: string;
-    overwrite: boolean;
-}
+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 interface HostTransferToSandboxRequest {
-    type: "host_transfer_request";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-    direction: "to_sandbox";
-    transferId: string;
-    sourcePath: string;
-}
+declare type _HostTransferServerMessages = HostTransferRequestEvent | HostTransferCancelEvent;
 
 declare type HostUiSnapshotCancelEvent = z.infer<typeof HostUiSnapshotCancelEventSchema>;
 
@@ -3950,18 +3869,6 @@ declare const MessageCompleteEventSchema: z.ZodObject<{
     attachmentWarnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 
-declare interface MessageContentResponse {
-    type: "message_content_response";
-    conversationId: string;
-    messageId: string;
-    text?: string;
-    toolCalls?: Array<{
-        name: string;
-        result?: string;
-        input?: Record<string, unknown>;
-    }>;
-}
-
 declare type MessageDequeuedEvent = z.infer<typeof MessageDequeuedEventSchema>;
 
 declare const MessageDequeuedEventSchema: z.ZodObject<{
@@ -4137,36 +4044,40 @@ declare interface MessageRow {
     finalized: number;
 }
 
-declare type _MessagesServerMessages = UserMessageEchoEvent | AssistantTurnStartEvent | AssistantTextDeltaEvent | AssistantThinkingDeltaEvent | ToolUseStartEvent | ToolUsePreviewStartEvent | ToolOutputChunkEvent | ToolInputDelta | ToolResultEvent | ConfirmationRequestEvent | SecretRequestEvent | QuestionRequestEvent | MessageCompleteEvent | ErrorEvent_2 | MessageQueuedEvent | MessageDequeuedEvent | MessageRequestCompleteEvent | MessageQueuedDeletedEvent | MessageSteered | SuggestionResponse | ConfirmationStateChanged | AssistantActivityStateEvent | ConversationInferenceProfileUpdated | InteractionResolvedEvent;
+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 interface MessageSteered {
-    type: "message_steered";
-    conversationId: string;
-    requestId: string;
-}
+declare type MessageSteeredEvent = z.infer<typeof MessageSteeredEventSchema>;
 
-declare interface ModelInfo {
-    type: "model_info";
-    conversationId?: string;
-    model: string;
-    provider: string;
-    configuredProviders?: string[];
-    availableModels?: Array<{
-        id: string;
-        displayName: string;
-    }>;
-    allProviders?: Array<{
-        id: string;
-        displayName: string;
-        models: Array<{
-            id: string;
-            displayName: string;
-        }>;
-        defaultModel: string;
-        apiKeyUrl?: string;
-        apiKeyPlaceholder?: string;
-    }>;
-}
+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
@@ -4376,10 +4287,6 @@ export declare interface PluginLogger {
     debug(obj: Record<string, unknown>, msg?: string): void;
 }
 
-declare interface PongMessage {
-    type: "pong";
-}
-
 /**
  * The full `post-compact` context a hook receives — the dispatching call
  * site's {@link PostCompactInputContext} plus the pipeline-stamped
@@ -5197,25 +5104,14 @@ export declare interface RunConversationTurnResult {
     queued?: boolean;
 }
 
-/**
- * Emitted when the compaction circuit breaker trips. After three consecutive
- * summary-LLM failures (with local fallback covering each), auto-compaction is
- * suspended until `openUntil` to avoid repeatedly hammering a broken provider.
- * User-initiated compaction (`/compact`, `force: true`) bypasses the breaker.
- *
- * `conversationId` scopes the event so clients can ignore breaker trips from
- * other conversations — `EventStreamClient` broadcasts every parsed server
- * message to all subscribers, so without this field a breaker trip in one
- * conversation would set the "auto-compaction paused" banner on every open
- * `ChatViewModel`.
- */
-/** Server push — broadcast when a schedule creates a conversation. */
-declare interface ScheduleConversationCreated {
-    type: "schedule_conversation_created";
-    conversationId: string;
-    scheduleJobId: string;
-    title: string;
-}
+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 interface SchedulesListResponse {
     type: "schedules_list_response";
@@ -5918,13 +5814,6 @@ declare type SubscriberInput = DistributiveOmit<SubscriberEntry, "active" | "con
     onEvict?: () => void;
 };
 
-declare interface SuggestionResponse {
-    type: "suggestion_response";
-    requestId: string;
-    suggestion: string | null;
-    source: "llm" | "none";
-}
-
 declare interface SurfaceAction {
     id: string;
     label: string;
@@ -6534,17 +6423,16 @@ export declare interface ToolExecutionResult {
     activityMetadata?: ToolActivityMetadata;
 }
 
-declare interface ToolInputDelta {
-    type: "tool_input_delta";
-    toolName: string;
-    content: string;
-    conversationId?: string;
-    /** The tool_use block ID for client-side correlation. */
-    toolUseId?: string;
-    /** Database ID of the assistant message that owns this tool_use block.
-     *  Same semantics as `AssistantTextDeltaEvent.messageId`. */
-    messageId?: string;
-}
+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 interface ToolInputSchema {
     type: "object";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/plugin-api",
-  "version": "0.10.11-dev.202607231934.db954e6",
+  "version": "0.10.11-dev.202607232029.2295f95",
   "description": "Public TypeScript authoring contract for Vellum assistant plugins.",
   "license": "MIT",
   "type": "module",