@vellumai/plugin-api 0.10.11-dev.202607231902.0887e08 → 0.10.11-dev.202607231953.b64451d

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>>;
@@ -3085,117 +3086,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 const HostAppControlCancelEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"host_app_control_cancel">;
+    requestId: z.ZodString;
+    conversationId: z.ZodString;
+}, z.core.$strip>;
 
-declare type _HostAppControlServerMessages = HostAppControlRequest | HostAppControlCancel;
+declare type HostAppControlRequestEvent = z.infer<typeof HostAppControlRequestEventSchema>;
 
-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 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 +3189,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 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 = HostBrowserRequest | HostBrowserCancelRequest;
+declare type _HostBrowserServerMessages = HostBrowserRequestEvent | HostBrowserCancelEvent;
 
 declare type HostCuCancelEvent = z.infer<typeof HostCuCancelEventSchema>;
 
@@ -3266,108 +3234,104 @@ declare const HostCuRequestEventSchema: z.ZodObject<{
 
 declare type _HostCuServerMessages = HostCuRequestEvent | HostCuCancelEvent;
 
-declare interface HostFileCancelRequest {
-    type: "host_file_cancel";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-}
-
-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 type HostFileCancelEvent = z.infer<typeof HostFileCancelEventSchema>;
 
-declare interface HostFileReadRequest {
-    type: "host_file_request";
-    requestId: string;
-    conversationId: string;
-    targetClientId?: string;
-    operation: "read";
-    path: string;
-    offset?: number;
-    limit?: number;
-}
+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 type HostFileRequest = HostFileReadRequest | HostFileWriteRequest | HostFileEditRequest;
+declare type HostFileRequestEvent = z.infer<typeof HostFileRequestEventSchema>;
 
-declare type _HostFileServerMessages = HostFileRequest | HostFileCancelRequest;
+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 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 interface HostUiSnapshotCancelMessage {
-    type: "host_ui_snapshot_cancel";
-    requestId: string;
-}
+declare type HostUiSnapshotCancelEvent = z.infer<typeof HostUiSnapshotCancelEventSchema>;
 
-declare interface HostUiSnapshotRequestMessage {
-    type: "host_ui_snapshot_request";
-    requestId: string;
-    view: HostUiSnapshotView;
-    /**
-     * Validated workspace-theme tokens to apply on the stage. The daemon reads
-     * them from ui/theme.json at request time so the capture reflects the
-     * current file even before connected clients refetch. Absent when no valid
-     * theme exists — the stage renders the built-in base theme.
-     */
-    tokens?: Record<string, string>;
-}
+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 type _HostUiSnapshotServerMessages = HostUiSnapshotRequestMessage | HostUiSnapshotCancelMessage;
+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>;
 
-/** Staged compositions the web client can render for capture. */
-declare type HostUiSnapshotView = "sampler" | "chat";
+declare type _HostUiSnapshotServerMessages = HostUiSnapshotRequestEvent | HostUiSnapshotCancelEvent;
 
 declare type IdentityChangedEvent = z.infer<typeof IdentityChangedEventSchema>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/plugin-api",
-  "version": "0.10.11-dev.202607231902.0887e08",
+  "version": "0.10.11-dev.202607231953.b64451d",
   "description": "Public TypeScript authoring contract for Vellum assistant plugins.",
   "license": "MIT",
   "type": "module",