@vellumai/assistant 0.7.0 → 0.7.1

package/src/daemon/host-browser-proxy.ts

@@ -1,5 +1,7 @@
 import { v4 as uuid } from "uuid";
 
+import { buildAssistantEvent } from "../runtime/assistant-event.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
@@ -28,25 +30,57 @@ interface PendingRequest {
 }
 
 export class HostBrowserProxy {
+  private static _instance: HostBrowserProxy | null = null;
+
+  /**
+   * Lazily-initialized singleton. Always creates the instance on first
+   * access — availability of an actual extension connection is checked
+   * at send time, not at construction time.
+   */
+  static get instance(): HostBrowserProxy {
+    if (!HostBrowserProxy._instance) {
+      log.info("Creating singleton HostBrowserProxy");
+      HostBrowserProxy._instance = new HostBrowserProxy();
+    }
+    return HostBrowserProxy._instance;
+  }
+
+  /** Dispose the singleton. Called during graceful shutdown. */
+  static disposeInstance(): void {
+    if (HostBrowserProxy._instance) {
+      HostBrowserProxy._instance.dispose();
+      HostBrowserProxy._instance = null;
+    }
+  }
+
+  /** For tests. */
+  static reset(): void {
+    HostBrowserProxy._instance = null;
+  }
+
   private pending = new Map<string, PendingRequest>();
-  private sendToClient: (msg: ServerMessage) => void;
-  private onInternalResolve?: (requestId: string) => void;
-  private clientConnected = false;
-
-  constructor(
-    sendToClient: (msg: ServerMessage) => void,
-    onInternalResolve?: (requestId: string) => void,
-  ) {
-    this.sendToClient = sendToClient;
-    this.onInternalResolve = onInternalResolve;
+
+  /**
+   * Whether a client with `host_browser` capability is connected.
+   */
+  isAvailable(): boolean {
+    return (
+      assistantEventHub.getMostRecentClientByCapability("host_browser") != null
+    );
   }
 
-  updateSender(
-    sendToClient: (msg: ServerMessage) => void,
-    clientConnected: boolean,
-  ): void {
-    this.sendToClient = sendToClient;
-    this.clientConnected = clientConnected;
+  /**
+   * Publish a ServerMessage through the assistant event hub, targeted at
+   * subscribers with the `host_browser` capability.
+   */
+  private send(msg: ServerMessage): void {
+    void assistantEventHub
+      .publish(buildAssistantEvent(msg), {
+        targetCapability: "host_browser",
+      })
+      .catch((err) => {
+        log.warn({ err }, "failed to publish host_browser event to hub");
+      });
   }
 
   request(
@@ -71,7 +105,6 @@ export class HostBrowserProxy {
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
         log.warn(
           { requestId, cdpMethod: input.cdpMethod },
           "Host browser proxy request timed out",
@@ -91,9 +124,8 @@ export class HostBrowserProxy {
             // Abort fired — nothing to detach, but call the no-op for symmetry
             // so callers can rely on detachAbort being idempotent.
             detachAbort();
-            this.onInternalResolve?.(requestId);
             try {
-              this.sendToClient({
+              this.send({
                 type: "host_browser_cancel",
                 requestId,
               } as ServerMessage);
@@ -110,7 +142,19 @@ export class HostBrowserProxy {
       this.pending.set(requestId, { resolve, reject, timer, detachAbort });
 
       try {
-        this.sendToClient({
+        if (!this.isAvailable()) {
+          clearTimeout(timer);
+          this.pending.delete(requestId);
+          detachAbort();
+          reject(
+            new Error(
+              "host_browser send failed: no active extension connection",
+            ),
+          );
+          return;
+        }
+
+        this.send({
           ...input,
           type: "host_browser_request",
           requestId,
@@ -123,7 +167,6 @@ export class HostBrowserProxy {
         clearTimeout(timer);
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
         log.warn(
           { requestId, cdpMethod: input.cdpMethod, err },
           "Host browser proxy send failed",
@@ -163,17 +206,12 @@ export class HostBrowserProxy {
     return this.pending.has(requestId);
   }
 
-  isAvailable(): boolean {
-    return this.clientConnected;
-  }
-
   dispose(): void {
     for (const [requestId, entry] of this.pending) {
       clearTimeout(entry.timer);
       entry.detachAbort();
-      this.onInternalResolve?.(requestId);
       try {
-        this.sendToClient({
+        this.send({
           type: "host_browser_cancel",
           requestId,
         } as ServerMessage);

package/src/daemon/host-cu-proxy.ts

@@ -5,6 +5,10 @@
  * managed assistant, following the same request/resolve pattern as
  * HostBashProxy. Also owns CU-specific state tracking (step counting,
  * loop detection, observation formatting) for the unified agent loop.
+ *
+ * Unlike HostBashProxy/HostFileProxy/HostTransferProxy, this is NOT a
+ * singleton — each conversation gets its own instance because CU state
+ * (step count, AX tree history, loop detection) is per-conversation.
  */
 
 import { v4 as uuid } from "uuid";
@@ -12,6 +16,11 @@ import { v4 as uuid } from "uuid";
 import { escapeAxTreeContent } from "../agent/loop.js";
 import { loadConfig } from "../config/loader.js";
 import type { ContentBlock } from "../providers/types.js";
+import {
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
@@ -57,6 +66,7 @@ interface PendingRequest {
   resolve: (result: ToolExecutionResult) => void;
   reject: (err: Error) => void;
   timer: ReturnType<typeof setTimeout>;
+  conversationId: string;
   /** Detach the abort listener from the caller's signal. No-op when no signal was passed. */
   detachAbort: () => void;
 }
@@ -67,9 +77,6 @@ interface PendingRequest {
 
 export class HostCuProxy {
   private pending = new Map<string, PendingRequest>();
-  private sendToClient: (msg: ServerMessage) => void;
-  private onInternalResolve?: (requestId: string) => void;
-  private clientConnected = false;
 
   // CU state tracking (per-conversation)
   private _stepCount = 0;
@@ -78,13 +85,7 @@ export class HostCuProxy {
   private _consecutiveUnchangedSteps = 0;
   private _actionHistory: ActionRecord[] = [];
 
-  constructor(
-    sendToClient: (msg: ServerMessage) => void,
-    onInternalResolve?: (requestId: string) => void,
-    maxSteps = loadConfig().maxStepsPerSession,
-  ) {
-    this.sendToClient = sendToClient;
-    this.onInternalResolve = onInternalResolve;
+  constructor(maxSteps = loadConfig().maxStepsPerSession) {
     this._maxSteps = maxSteps;
   }
 
@@ -113,15 +114,24 @@ export class HostCuProxy {
   }
 
   // ---------------------------------------------------------------------------
-  // Sender management
+  // Availability
   // ---------------------------------------------------------------------------
 
-  updateSender(
-    sendToClient: (msg: ServerMessage) => void,
-    clientConnected: boolean,
-  ): void {
-    this.sendToClient = sendToClient;
-    this.clientConnected = clientConnected;
+  /**
+   * Whether a client with `host_cu` capability is connected.
+   */
+  isAvailable(): boolean {
+    return (
+      assistantEventHub.getMostRecentClientByCapability("host_cu") != null
+    );
+  }
+
+  // ---------------------------------------------------------------------------
+  // Send helper
+  // ---------------------------------------------------------------------------
+
+  private send(msg: ServerMessage): void {
+    broadcastMessage(msg, undefined, { targetCapability: "host_cu" });
   }
 
   // ---------------------------------------------------------------------------
@@ -154,14 +164,12 @@ export class HostCuProxy {
     const requestId = uuid();
 
     return new Promise<ToolExecutionResult>((resolve, reject) => {
-      // Declared up-front so onAbort (defined before detachAbort is assigned)
-      // can close over a stable reference once it's wired below.
       let detachAbort: () => void = () => {};
 
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn({ requestId, toolName }, "Host CU proxy request timed out");
         resolve({
           content: "Host CU proxy timed out waiting for client response",
@@ -174,15 +182,14 @@ export class HostCuProxy {
           if (this.pending.has(requestId)) {
             clearTimeout(timer);
             this.pending.delete(requestId);
-            // Abort fired — nothing to detach, but call the no-op for symmetry
-            // so callers can rely on detachAbort being idempotent.
             detachAbort();
-            this.onInternalResolve?.(requestId);
+            pendingInteractions.resolve(requestId);
             try {
-              this.sendToClient({
+              this.send({
                 type: "host_cu_cancel",
                 requestId,
-              } as ServerMessage);
+                conversationId,
+              });
             } catch {
               // Best-effort cancel notification — connection may already be closed.
             }
@@ -193,10 +200,10 @@ export class HostCuProxy {
         detachAbort = () => signal.removeEventListener("abort", onAbort);
       }
 
-      this.pending.set(requestId, { resolve, reject, timer, detachAbort });
+      this.pending.set(requestId, { resolve, reject, timer, conversationId, detachAbort });
 
       try {
-        this.sendToClient({
+        this.send({
           type: "host_cu_request",
           requestId,
           conversationId,
@@ -204,15 +211,12 @@ export class HostCuProxy {
           input,
           stepNumber,
           reasoning,
-        } as ServerMessage);
+        });
       } catch (err) {
-        // Sender threw synchronously (e.g. client transport error during
-        // event emission). Clean up pending state and timer so we don't
-        // leak an in-flight entry that nothing will ever resolve.
         clearTimeout(timer);
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn({ requestId, toolName, err }, "Host CU proxy send failed");
         reject(err instanceof Error ? err : new Error(String(err)));
       }
@@ -243,10 +247,6 @@ export class HostCuProxy {
     return this.pending.has(requestId);
   }
 
-  isAvailable(): boolean {
-    return this.clientConnected;
-  }
-
   // ---------------------------------------------------------------------------
   // CU state management
   // ---------------------------------------------------------------------------
@@ -413,12 +413,13 @@ export class HostCuProxy {
     for (const [requestId, entry] of this.pending) {
       clearTimeout(entry.timer);
       entry.detachAbort();
-      this.onInternalResolve?.(requestId);
+      pendingInteractions.resolve(requestId);
       try {
-        this.sendToClient({
+        this.send({
           type: "host_cu_cancel",
           requestId,
-        } as ServerMessage);
+          conversationId: entry.conversationId,
+        });
       } catch {
         // Best-effort cancel notification — connection may already be closed.
       }

package/src/daemon/host-file-proxy.ts

@@ -1,5 +1,10 @@
 import { v4 as uuid } from "uuid";
 
+import {
+  assistantEventHub,
+  broadcastMessage,
+} from "../runtime/assistant-event-hub.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { readImageBase64 } from "../tools/shared/filesystem/image-read.js";
 import type { ToolExecutionResult } from "../tools/types.js";
 import { AssistantError, ErrorCode } from "../util/errors.js";
@@ -26,30 +31,54 @@ interface PendingRequest {
   timer: ReturnType<typeof setTimeout>;
   operation: HostFileInput["operation"];
   path: string;
+  conversationId: string;
   /** Detach the abort listener from the caller's signal. No-op when no signal was passed. */
   detachAbort: () => void;
 }
 
 export class HostFileProxy {
+  private static _instance: HostFileProxy | null = null;
+
+  /**
+   * Lazily-initialized singleton. Availability of an actual desktop
+   * connection is checked at send time via the assistant event hub,
+   * not at construction time.
+   */
+  static get instance(): HostFileProxy {
+    if (!HostFileProxy._instance) {
+      log.info("Creating singleton HostFileProxy");
+      HostFileProxy._instance = new HostFileProxy();
+    }
+    return HostFileProxy._instance;
+  }
+
+  /** Dispose the singleton. Called during graceful shutdown. */
+  static disposeInstance(): void {
+    if (HostFileProxy._instance) {
+      HostFileProxy._instance.dispose();
+      HostFileProxy._instance = null;
+    }
+  }
+
+  /** For tests. */
+  static reset(): void {
+    HostFileProxy._instance = null;
+  }
+
   private pending = new Map<string, PendingRequest>();
-  private sendToClient: (msg: ServerMessage) => void;
-  private onInternalResolve?: (requestId: string) => void;
-  private clientConnected = false;
-
-  constructor(
-    sendToClient: (msg: ServerMessage) => void,
-    onInternalResolve?: (requestId: string) => void,
-  ) {
-    this.sendToClient = sendToClient;
-    this.onInternalResolve = onInternalResolve;
+
+  /**
+   * Whether a client with `host_file` capability is connected.
+   * Note: host_file covers both file operations and transfers.
+   */
+  isAvailable(): boolean {
+    return (
+      assistantEventHub.getMostRecentClientByCapability("host_file") != null
+    );
   }
 
-  updateSender(
-    sendToClient: (msg: ServerMessage) => void,
-    clientConnected: boolean,
-  ): void {
-    this.sendToClient = sendToClient;
-    this.clientConnected = clientConnected;
+  private send(msg: ServerMessage): void {
+    broadcastMessage(msg, undefined, { targetCapability: "host_file" });
   }
 
   request(
@@ -67,14 +96,12 @@ export class HostFileProxy {
       // File operations should be fast — 30 second timeout.
       const timeoutSec = 30;
 
-      // Declared up-front so onAbort (defined before detachAbort is assigned)
-      // can close over a stable reference once it's wired below.
       let detachAbort: () => void = () => {};
 
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, operation: input.operation },
           "Host file proxy request timed out",
@@ -90,15 +117,14 @@ export class HostFileProxy {
           if (this.pending.has(requestId)) {
             clearTimeout(timer);
             this.pending.delete(requestId);
-            // Abort fired — nothing to detach, but call the no-op for symmetry
-            // so callers can rely on detachAbort being idempotent.
             detachAbort();
-            this.onInternalResolve?.(requestId);
+            pendingInteractions.resolve(requestId);
             try {
-              this.sendToClient({
+              this.send({
                 type: "host_file_cancel",
                 requestId,
-              } as ServerMessage);
+                conversationId,
+              });
             } catch {
               // Best-effort cancel notification — connection may already be closed.
             }
@@ -115,24 +141,22 @@ export class HostFileProxy {
         timer,
         operation: input.operation,
         path: input.path,
+        conversationId,
         detachAbort,
       });
 
       try {
-        this.sendToClient({
+        this.send({
           ...input,
           type: "host_file_request",
           requestId,
           conversationId,
-        } as ServerMessage);
+        });
       } catch (err) {
-        // Sender threw synchronously (e.g. client transport error during
-        // event emission). Clean up pending state and timer so we don't
-        // leak an in-flight entry that nothing will ever resolve.
         clearTimeout(timer);
         this.pending.delete(requestId);
         detachAbort();
-        this.onInternalResolve?.(requestId);
+        pendingInteractions.resolve(requestId);
         log.warn(
           { requestId, operation: input.operation, err },
           "Host file proxy send failed",
@@ -170,20 +194,17 @@ export class HostFileProxy {
     return this.pending.has(requestId);
   }
 
-  isAvailable(): boolean {
-    return this.clientConnected;
-  }
-
   dispose(): void {
     for (const [requestId, entry] of this.pending) {
       clearTimeout(entry.timer);
       entry.detachAbort();
-      this.onInternalResolve?.(requestId);
+      pendingInteractions.resolve(requestId);
       try {
-        this.sendToClient({
+        this.send({
           type: "host_file_cancel",
           requestId,
-        } as ServerMessage);
+          conversationId: entry.conversationId,
+        });
       } catch {
         // Best-effort cancel notification — connection may already be closed.
       }