@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/conversation-speed-override.test.ts

@@ -294,7 +294,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // broadcastToAllClients
       undefined, // memoryPolicy
       undefined, // sharedCesClient
       "standard", // speedOverride
@@ -316,7 +315,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // broadcastToAllClients
       undefined, // memoryPolicy
       undefined, // sharedCesClient
       // no speedOverride — should fall back to global config "fast"
@@ -337,7 +335,6 @@ describe("per-conversation speed override", () => {
       4096,
       makeSendToClient(),
       "/tmp",
-      undefined, // broadcastToAllClients
       undefined, // memoryPolicy
       undefined, // sharedCesClient
       "fast", // speedOverride

package/src/__tests__/conversation-starter-routes.test.ts

@@ -281,7 +281,10 @@ describe("GET /v1/conversation-starters", () => {
       category: "productivity",
       createdAt: now - 1,
     });
-    setCheckpoint("conversation_starters:last_gen_at:default", String(now));
+    setCheckpoint(
+      "conversation_starters:last_gen_at:default",
+      String(now - 90_000),
+    );
     setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
     insertMemoryItem();
 
@@ -313,7 +316,10 @@ describe("GET /v1/conversation-starters", () => {
       category: "communication",
       createdAt: now - 1,
     });
-    setCheckpoint("conversation_starters:last_gen_at:default", String(now));
+    setCheckpoint(
+      "conversation_starters:last_gen_at:default",
+      String(now - 90_000),
+    );
     setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
     insertMemoryItem();
 
@@ -331,6 +337,77 @@ describe("GET /v1/conversation-starters", () => {
     expect(countStarterJobs()).toBe(1);
   });
 
+  test("does not re-enqueue for invalid items when within cooldown period", async () => {
+    const now = Date.now();
+    // Generation happened 30 seconds ago (within the 60s cooldown)
+    const recentGenAt = now - 30_000;
+    insertStarter({
+      label: "Let me check calendar",
+      prompt: "Let me check what Alice has today.",
+      category: "productivity",
+      createdAt: now,
+    });
+    insertStarter({
+      label: "Plan my morning",
+      prompt: "Can you help me plan my morning?",
+      category: "productivity",
+      createdAt: now - 1,
+    });
+    setCheckpoint(
+      "conversation_starters:last_gen_at:default",
+      String(recentGenAt),
+    );
+    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
+    insertMemoryItem();
+
+    const result = (await dispatch("conversation-starters")) as {
+      starters: unknown[];
+      total: number;
+      status: string;
+    };
+
+    // The invalid "assistant-voice" starter triggers invalidItemCount > 0,
+    // but the cooldown prevents re-enqueueing — status should be "ready".
+    expect(result.status).toBe("ready");
+    expect(result.total).toBe(1);
+    expect(countStarterJobs()).toBe(0);
+  });
+
+  test("re-enqueues for invalid items after cooldown expires", async () => {
+    const now = Date.now();
+    // Generation happened 90 seconds ago (past the 60s cooldown)
+    const oldGenAt = now - 90_000;
+    insertStarter({
+      label: "Let me check calendar",
+      prompt: "Let me check what Alice has today.",
+      category: "productivity",
+      createdAt: now,
+    });
+    insertStarter({
+      label: "Plan my morning",
+      prompt: "Can you help me plan my morning?",
+      category: "productivity",
+      createdAt: now - 1,
+    });
+    setCheckpoint(
+      "conversation_starters:last_gen_at:default",
+      String(oldGenAt),
+    );
+    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "1");
+    insertMemoryItem();
+
+    const result = (await dispatch("conversation-starters")) as {
+      starters: unknown[];
+      total: number;
+      status: string;
+    };
+
+    // Past the cooldown — should re-enqueue and return refreshing.
+    expect(result.status).toBe("refreshing");
+    expect(result.total).toBe(1);
+    expect(countStarterJobs()).toBe(1);
+  });
+
   test("returns empty status when no memory items exist", async () => {
     const result = (await dispatch("conversation-starters")) as {
       starters: unknown[];

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  createSurfaceMutex,
+  handleSurfaceAction,
+  type SurfaceConversationContext,
+  surfaceProxyResolver,
+} from "../daemon/conversation-surfaces.js";
+import type {
+  ServerMessage,
+  SurfaceData,
+  SurfaceType,
+  UiSurfaceShow,
+} from "../daemon/message-protocol.js";
+import type { UserMessageAttachment } from "../daemon/message-types/shared.js";
+
+interface ProcessMessageCall {
+  content: string;
+  attachments: UserMessageAttachment[];
+  requestId?: string;
+  activeSurfaceId?: string;
+  displayContent?: string;
+}
+
+function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext & {
+  processMessageCalls: ProcessMessageCall[];
+} {
+  const processMessageCalls: ProcessMessageCall[] = [];
+  return {
+    conversationId: "conv-1",
+    traceEmitter: { emit: () => {} },
+    sendToClient: (msg: ServerMessage) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map<
+      string,
+      {
+        surfaceType: SurfaceType;
+        data: SurfaceData;
+        title?: string;
+        actions?: Array<{
+          id: string;
+          label: string;
+          style?: string;
+          data?: Record<string, unknown>;
+        }>;
+      }
+    >(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
+    getQueueDepth: () => 0,
+    processMessage: async (
+      content: string,
+      attachments: UserMessageAttachment[],
+      _onEvent: (msg: ServerMessage) => void,
+      requestId?: string,
+      activeSurfaceId?: string,
+      _currentPage?: string,
+      _options?: { isInteractive?: boolean },
+      displayContent?: string,
+    ) => {
+      processMessageCalls.push({
+        content,
+        attachments,
+        requestId,
+        activeSurfaceId,
+        displayContent,
+      });
+      return "msg-1";
+    },
+    withSurface: createSurfaceMutex(),
+    processMessageCalls,
+  };
+}
+
+describe("surface action delivery to assistant", () => {
+  test("table action button click triggers processMessage with action content", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // Step 1: Show a table surface with actions
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "table",
+      title: "Newsletters",
+      data: {
+        columns: [
+          { id: "sender", label: "Sender" },
+          { id: "count", label: "Count" },
+        ],
+        rows: [
+          { id: "row-1", cells: { sender: "Newsletter A", count: "5" } },
+          { id: "row-2", cells: { sender: "Newsletter B", count: "3" } },
+        ],
+        selectionMode: "multiple",
+      },
+      actions: [
+        { id: "archive", label: "Archive", style: "primary" },
+        { id: "unsubscribe", label: "Unsubscribe", style: "destructive" },
+      ],
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    // Verify surface was shown and pending action was registered
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    expect(showMessage).toBeDefined();
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+    expect(ctx.surfaceState.has(surfaceId)).toBe(true);
+
+    // Step 2: Simulate user clicking "Archive" with selected rows
+    const actionData = {
+      selectedIds: ["row-1", "row-2"],
+    };
+
+    await handleSurfaceAction(ctx, surfaceId, "archive", actionData);
+
+    // Step 3: Verify processMessage was called
+    expect(ctx.processMessageCalls.length).toBe(1);
+    const call = ctx.processMessageCalls[0];
+    expect(call.content).toContain("[User action on table surface:");
+    expect(call.content).toContain("archive");
+    expect(call.content).toContain("selectedIds");
+    expect(call.content).toContain("row-1");
+    expect(call.content).toContain("row-2");
+    expect(call.activeSurfaceId).toBe(surfaceId);
+
+    // Verify pending action was cleared
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
+
+    // Verify the requestId was tracked as a surface action
+    expect(ctx.surfaceActionRequestIds.size).toBe(1);
+  });
+
+  test("table action without selection data still triggers processMessage", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // Show table surface
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "table",
+      title: "Emails",
+      data: {
+        columns: [{ id: "subject", label: "Subject" }],
+        rows: [{ id: "r1", cells: { subject: "Hello" } }],
+      },
+      actions: [{ id: "archive", label: "Archive" }],
+    });
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+
+    // Click action WITHOUT selection data (data is undefined)
+    await handleSurfaceAction(ctx, surfaceId, "archive", undefined);
+
+    // processMessage must still be called
+    expect(ctx.processMessageCalls.length).toBe(1);
+    expect(ctx.processMessageCalls[0].content).toContain(
+      "[User action on table surface:",
+    );
+  });
+
+  test("action on history-restored surface (no pending) still processes", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    // Simulate a history-restored surface: surfaceState exists, but
+    // pendingSurfaceActions does NOT have an entry.
+    ctx.surfaceState.set("hist-surface-1", {
+      surfaceType: "table",
+      data: {
+        columns: [{ id: "col", label: "Col" }],
+        rows: [],
+      } as unknown as SurfaceData,
+      title: "History Table",
+      actions: [{ id: "delete", label: "Delete" }],
+    });
+
+    // Click the action — should go through the history-restored path
+    await handleSurfaceAction(ctx, "hist-surface-1", "delete", {
+      selectedIds: ["row-1"],
+    });
+
+    // processMessage should still be called
+    expect(ctx.processMessageCalls.length).toBe(1);
+    expect(ctx.processMessageCalls[0].content).toContain(
+      "[User action on app:",
+    );
+  });
+});

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -0,0 +1,317 @@
+/**
+ * Tests for the surfaceProxyResolver's app_control_* dispatch branch.
+ *
+ * Mirrors the structure of cu-unified-flow.test.ts but exercises the
+ * sibling branch added for app-control: unavailability when no proxy is
+ * attached, end-to-end dispatch through HostAppControlProxy.request, and
+ * the local short-circuit for app_control_stop (no client round-trip).
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+let mockHasClient = true;
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_app_control" && mockHasClient
+        ? { id: "mock-client" }
+        : null,
+  },
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => undefined,
+  resolve: () => undefined,
+  get: () => undefined,
+  getByKind: () => [],
+  getByConversation: () => [],
+  removeByConversation: () => {},
+}));
+
+const { surfaceProxyResolver } =
+  await import("../daemon/conversation-surfaces.js");
+const { HostAppControlProxy, _resetActiveAppControlConversationId } =
+  await import("../daemon/host-app-control-proxy.js");
+type SurfaceConversationContext =
+  import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Build a minimal SurfaceConversationContext with an optional
+ * hostAppControlProxy. Only the fields required by the app-control routing
+ * path are populated.
+ */
+function buildMockContext(
+  hostAppControlProxy?: InstanceType<typeof HostAppControlProxy>,
+  conversationId = "test-session",
+  setHostAppControlProxy?: (
+    proxy: InstanceType<typeof HostAppControlProxy> | undefined,
+  ) => void,
+): SurfaceConversationContext {
+  return {
+    conversationId,
+    traceEmitter: { emit: () => {} },
+    sendToClient: () => {},
+    pendingSurfaceActions: new Map(),
+    lastSurfaceAction: new Map(),
+    surfaceState: new Map(),
+    surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
+    surfaceActionRequestIds: new Set(),
+    currentTurnSurfaces: [],
+    hostAppControlProxy,
+    setHostAppControlProxy,
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "r1" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "",
+    withSurface: async (_id, fn) => fn(),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("surfaceProxyResolver — app-control tool routing", () => {
+  beforeEach(() => {
+    sentMessages.length = 0;
+    mockHasClient = true;
+    _resetActiveAppControlConversationId();
+  });
+
+  afterEach(() => {
+    _resetActiveAppControlConversationId();
+  });
+
+  // -------------------------------------------------------------------------
+  // Unavailability
+  // -------------------------------------------------------------------------
+
+  describe("no app-control proxy attached", () => {
+    test("returns isError result when ctx.hostAppControlProxy is undefined", async () => {
+      const ctx = buildMockContext(/* no proxy */);
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("not available");
+      expect(result.content).toContain("app-control");
+      // No envelope dispatched.
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("returns isError when proxy exists but no client is connected", async () => {
+      mockHasClient = false;
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy);
+
+      const result = await surfaceProxyResolver(ctx, "app_control_observe", {
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("not available");
+      expect(sentMessages).toHaveLength(0);
+
+      proxy.dispose();
+    });
+
+    test("returns isError for app_control_stop when no proxy is attached", async () => {
+      const ctx = buildMockContext();
+
+      const result = await surfaceProxyResolver(ctx, "app_control_stop", {
+        tool: "stop",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("not available");
+      expect(sentMessages).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Dispatch through proxy.request
+  // -------------------------------------------------------------------------
+
+  describe("non-stop tools dispatch through proxy.request", () => {
+    test("app_control_observe routes through proxy and returns observation", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      // The proxy fired exactly one host_app_control_request envelope.
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_app_control_request");
+      expect(sent.toolName).toBe("app_control_observe");
+      expect(sent.conversationId).toBe("conv-1");
+      expect(sent.input).toEqual({
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      const requestId = sent.requestId as string;
+      proxy.resolve(requestId, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+        executionResult: "Window observed",
+      });
+
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+      expect(result.content).toContain("State: running");
+      expect(result.content).toContain("Window observed");
+
+      proxy.dispose();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Local short-circuit on app_control_stop
+  // -------------------------------------------------------------------------
+
+  describe("app_control_stop short-circuits locally", () => {
+    test("calls proxy.dispose() and returns a stopped summary without a client round-trip", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy);
+
+      let disposeCalls = 0;
+      const realDispose = proxy.dispose.bind(proxy);
+      proxy.dispose = () => {
+        disposeCalls++;
+        realDispose();
+      };
+
+      let requestCalls = 0;
+      const realRequest = proxy.request.bind(proxy);
+      proxy.request = (...args) => {
+        requestCalls++;
+        return realRequest(...args);
+      };
+
+      const result = await surfaceProxyResolver(ctx, "app_control_stop", {
+        tool: "stop",
+      });
+
+      expect(result.isError).toBe(false);
+      expect(result.content.toLowerCase()).toContain("stopped");
+      expect(disposeCalls).toBe(1);
+      expect(requestCalls).toBe(0);
+      // No envelope dispatched for the local short-circuit.
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("clears the conversation reference via setHostAppControlProxy(undefined) when the setter is provided", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+
+      // Capture how the resolver clears the proxy reference. The setter
+      // mirrors Conversation.setHostAppControlProxy: dispose the existing
+      // proxy when transitioning to undefined.
+      const setterCalls: Array<unknown> = [];
+      let attached: InstanceType<typeof HostAppControlProxy> | undefined =
+        proxy;
+      const setter = (
+        next: InstanceType<typeof HostAppControlProxy> | undefined,
+      ) => {
+        setterCalls.push(next);
+        if (attached && attached !== next) attached.dispose();
+        attached = next;
+      };
+
+      const ctx = buildMockContext(proxy, "conv-1", setter);
+
+      const result = await surfaceProxyResolver(ctx, "app_control_stop", {
+        tool: "stop",
+      });
+
+      expect(result.isError).toBe(false);
+      // The resolver invoked the setter with undefined exactly once.
+      expect(setterCalls).toEqual([undefined]);
+      expect(attached).toBeUndefined();
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Discriminator injection (Gap A)
+  // -------------------------------------------------------------------------
+
+  describe("tool discriminator injection", () => {
+    test("injects `tool` derived from toolName when the agent input omits it", async () => {
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+
+      // Agent inputs do not carry the discriminator — the resolver has to
+      // synthesize it from `toolName` ("app_control_observe" → "observe")
+      // before forwarding to the proxy / desktop client.
+      const resultPromise = surfaceProxyResolver(ctx, "app_control_observe", {
+        app: "com.example.editor",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.input).toEqual({
+        tool: "observe",
+        app: "com.example.editor",
+      });
+
+      const requestId = sent.requestId as string;
+      proxy.resolve(requestId, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      await resultPromise;
+
+      proxy.dispose();
+    });
+
+    test('injects `tool: "start"` so the singleton-lock guard fires', async () => {
+      // Establish a lock owned by conv-other.
+      const ownerProxy = new HostAppControlProxy("conv-other");
+      const ownerCtrl = new AbortController();
+      const ownerPromise = ownerProxy.request(
+        "app_control_start",
+        { tool: "start", app: "com.example.editor" },
+        "conv-other",
+        ownerCtrl.signal,
+      );
+      const ownerSent = sentMessages[0] as Record<string, unknown>;
+      ownerProxy.resolve(ownerSent.requestId as string, {
+        requestId: "ignored-by-proxy",
+        state: "running",
+      });
+      await ownerPromise;
+      sentMessages.length = 0;
+
+      // conv-1 attempts to start without a discriminator in its input. The
+      // resolver must inject `tool: "start"`, which causes the proxy's
+      // singleton-lock guard to fire and reject without dispatching.
+      const proxy = new HostAppControlProxy("conv-1");
+      const ctx = buildMockContext(proxy, "conv-1");
+      const result = await surfaceProxyResolver(ctx, "app_control_start", {
+        app: "com.example.editor",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("conv-other");
+      expect(sentMessages).toHaveLength(0); // No envelope dispatched.
+
+      proxy.dispose();
+      ownerProxy.dispose();
+    });
+  });
+});

package/src/__tests__/conversation-surfaces-standalone-payloads.test.ts

@@ -17,7 +17,14 @@
  * and dispatches them in ChatActionHandler → ChatViewModel+SurfaceHandling.
  */
 
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+let broadcastImpl: (msg: ServerMessage) => void = () => {};
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: ServerMessage) => broadcastImpl(msg),
+}));
 
 import {
   buildCompletionSummary,
@@ -25,7 +32,6 @@ import {
   showStandaloneSurface,
   type SurfaceConversationContext,
 } from "../daemon/conversation-surfaces.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
@@ -40,6 +46,7 @@ function createMockContext(
   enqueuedMessages: Array<{ content: string; requestId: string }>;
 } {
   const sentMessages: ServerMessage[] = [];
+  broadcastImpl = (msg: ServerMessage) => sentMessages.push(msg);
   const enqueuedMessages: Array<{ content: string; requestId: string }> = [];
 
   return {
@@ -54,7 +61,6 @@ function createMockContext(
       : undefined,
     traceEmitter: { emit: () => {} },
     sendToClient: (msg: ServerMessage) => sentMessages.push(msg),
-    broadcastToAllClients: (msg: ServerMessage) => sentMessages.push(msg),
     pendingSurfaceActions: new Map(),
     lastSurfaceAction: new Map(),
     surfaceState: new Map(),
@@ -67,8 +73,9 @@ function createMockContext(
     hasNoClient: overrides?.hasNoClient ?? false,
     isProcessing: () => false,
     enqueueMessage: (content, _attachments, _onEvent, requestId) => {
-      enqueuedMessages.push({ content, requestId });
-      return { queued: false, requestId };
+      const resolvedId = requestId ?? "mock-request-id";
+      enqueuedMessages.push({ content, requestId: resolvedId });
+      return { queued: false, requestId: resolvedId };
     },
     getQueueDepth: () => 0,
     processMessage: async () => "msg-id",