@vellumai/assistant 0.12.4 → 0.12.5-dev.202609251017.e467a6c

package/src/__tests__/conversation-pairing.test.ts

@@ -927,6 +927,65 @@ describe("pairDeliveryWithConversation", () => {
     expect(messagesInvalidated).toEqual([]);
   });
 
+  test("explicit background result keeps its persisted result without another preview row", async () => {
+    mockExistingConversations["conv-user-chat"] = {
+      id: "conv-user-chat",
+      source: "user",
+      title: "An ordinary chat",
+    };
+    const result = await pairDeliveryWithConversation(
+      makeSignal({
+        requiresConversation: undefined,
+        sourceContextId: "task-1",
+        sourceEventName: "activity.complete",
+        contextPayload: {
+          completion: {
+            workId: "task-1",
+            conversationId: "conv-user-chat",
+            recipientPrincipalId: "principal-1",
+            owner: "parent_continuation",
+          },
+        },
+      }),
+      "vellum",
+      makeCopy({ body: "The report is ready." }),
+    );
+
+    expect(result.conversationId).toBe("conv-user-chat");
+    expect(result.messageId).toBeNull();
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+
+  test("a missing declared completion conversation does not fall back to unrelated source content", async () => {
+    mockExistingConversations["conv-source"] = {
+      id: "conv-source",
+      source: "user",
+      title: "Another chat",
+    };
+    const result = await pairDeliveryWithConversation(
+      makeSignal({
+        requiresConversation: undefined,
+        sourceContextId: "conv-source",
+        sourceEventName: "activity.complete",
+        contextPayload: {
+          completion: {
+            workId: "task-1",
+            conversationId: "conv-missing",
+            recipientPrincipalId: "principal-1",
+            owner: "parent_continuation",
+          },
+        },
+      }),
+      "vellum",
+      makeCopy({ body: "The report is ready." }),
+    );
+
+    expect(result.conversationId).toBeNull();
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+
   test("passive vellum signal appends the body to the producing conversation", async () => {
     mockExistingConversations["conv-producer"] = {
       id: "conv-producer",
@@ -996,6 +1055,12 @@ describe("pairDeliveryWithConversation", () => {
     expect(createConversationMock).not.toHaveBeenCalled();
     expect(addMessageMock).toHaveBeenCalledTimes(1);
     expect(messagesInvalidated).toContain("conv-foreground");
+    // The transcript is this notification's only home, so a chat marked Done
+    // comes back for it.
+    const options = addMessageMock.mock.calls[0]![3] as {
+      skipResurface?: boolean;
+    };
+    expect(options.skipResurface).toBe(false);
   });
 
   test("appended notification body skips indexing", async () => {
@@ -1017,8 +1082,12 @@ describe("pairDeliveryWithConversation", () => {
 
     const options = addMessageMock.mock.calls[0]![3] as {
       skipIndexing?: boolean;
+      skipResurface?: boolean;
     };
     expect(options.skipIndexing).toBe(true);
+    // The bell carries this one (async-background), so the append is
+    // bookkeeping and never resurfaces a chat the user marked Done.
+    expect(options.skipResurface).toBe(true);
   });
 
   test("passive vellum signal appends regardless of the producing conversation's source", async () => {

package/src/__tests__/conversation-queue.test.ts

@@ -46,6 +46,7 @@ const capturedPersistedSeqs: Array<{ id: string; seq: number }> = [];
  * tail message while its siblings succeed).
  */
 const addMessageShouldThrowForContent = new Set<string>();
+let beforeMessageInsert: ((requestId?: string) => Promise<void>) | undefined;
 
 mock.module("../prompts/system-prompt.js", () => ({
   buildSystemPrompt: () => "system prompt",
@@ -101,12 +102,20 @@ mock.module("../persistence/conversation-crud.js", () => ({
     totalEstimatedCost: 0,
   }),
   createConversation: () => ({ id: "conv-1" }),
-  addMessage: (
+  addMessage: async (
     _convId: string,
     role: string,
     content: string,
-    options?: { metadata?: Record<string, unknown> },
+    options?: {
+      id?: string;
+      metadata?: Record<string, unknown>;
+      insertPrecondition?: () => boolean;
+    },
   ) => {
+    await beforeMessageInsert?.(options?.id);
+    if (options?.insertPrecondition && !options.insertPrecondition()) {
+      throw new Error("Message insert cancelled");
+    }
     // Simulate a persist failure for tests that need to exercise the
     // tail-persist-failed path in drainBatch. Triggered by matching any
     // registered substring against the serialized content payload.
@@ -115,7 +124,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
         throw new Error(`Simulated addMessage failure for content: ${needle}`);
       }
     }
-    const id = `msg-${Date.now()}-${capturedAddMessages.length}`;
+    const id = options?.id ?? `msg-${Date.now()}-${capturedAddMessages.length}`;
     capturedAddMessages.push({
       id,
       role,
@@ -126,7 +135,8 @@ mock.module("../persistence/conversation-crud.js", () => ({
   },
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
-  getMessageById: () => null,
+  getMessageById: (id: string) =>
+    capturedAddMessages.find((message) => message.id === id) ?? null,
   getLastUserTimestampBefore: () => 0,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
   updateMessageContent: mock(() => {}),
@@ -481,10 +491,12 @@ async function resolveRun(index: number) {
 }
 
 beforeEach(() => {
+  capturedAddMessages.length = 0;
   turnCommitCalls.length = 0;
   turnCommitHangForever = false;
   linkAttachmentShouldThrow = false;
   addMessageShouldThrowForContent.clear();
+  beforeMessageInsert = undefined;
 });
 
 afterAll(() => {
@@ -1049,6 +1061,247 @@ describe("Conversation message queue", () => {
     expect(pendingRuns.length).toBe(3);
   });
 
+  for (const cronRunId of ["run-scheduled", null]) {
+    for (const batchSize of [1, 2]) {
+      for (const cancel of [
+        false,
+        "schedule",
+        "stop",
+        "signal",
+        "dispose",
+      ] as const) {
+        if (cronRunId === null && cancel === "schedule") {
+          continue;
+        }
+        for (const claimed of [false, true]) {
+          test(`queued dispatch stays tracked during persistence (owner=${cronRunId}, batch=${batchSize}, cancel=${cancel}, claimed=${claimed})`, async () => {
+            const conversation = makeConversation();
+            await conversation.loadFromDb();
+            const persistedBefore = capturedAddMessages.length;
+            const entered = Promise.withResolvers<void>();
+            const release = Promise.withResolvers<void>();
+            const acquire =
+              conversation.acquireProcessingFenced.bind(conversation);
+            conversation.acquireProcessingFenced = async () => {
+              const owner = claimed ? await acquire() : undefined;
+              entered.resolve();
+              await release.promise;
+              return owner === undefined ? acquire() : owner;
+            };
+            const events: AssistantEvent[] = [];
+            conversation.setProcessing(true);
+            for (let i = 0; i < batchSize; i++) {
+              conversation.enqueueMessage({
+                content: `Queued continuation ${i}`,
+                requestId: `queued-${i}`,
+                clientMessageId: `client-queued-${i}`,
+                cronRunId,
+                onEvent: (event) => events.push(event),
+              });
+            }
+            conversation.setProcessing(false);
+            const drain = conversation.drainQueue();
+            try {
+              await entered.promise;
+              expect(conversation.getQueueDepth()).toBe(0);
+              expect(conversation.isProcessing()).toBe(claimed);
+              expect(
+                conversation.pendingQueuedDispatches.get(cronRunId)?.size,
+              ).toBe(1);
+              expect(conversation.hasInFlightWork()).toBe(true);
+              if (cancel === "schedule") {
+                conversation.abortScheduledRun("run-scheduled");
+              } else if (cancel === "stop" || cancel === "signal") {
+                conversation.abort(
+                  createAbortReason(
+                    cancel === "stop" ? "user_cancel" : "signal_cancel",
+                    "test",
+                  ),
+                );
+              } else if (cancel === "dispose") {
+                conversation.dispose();
+              }
+            } finally {
+              release.resolve();
+              await drain;
+            }
+            expect(conversation.pendingQueuedDispatches.size).toBe(0);
+            const preserved =
+              cronRunId === null && (cancel === "stop" || cancel === "signal");
+            if (cancel && !preserved) {
+              expect(pendingRuns).toHaveLength(0);
+              expect(capturedAddMessages).toHaveLength(persistedBefore);
+              expect(conversation.isProcessing()).toBe(false);
+              expect(conversation.currentTurnCronRunId).toBeUndefined();
+              expect(conversation.getQueueDepth()).toBe(0);
+              expect(
+                events.filter((event) => event.type === "generation_cancelled"),
+              ).toHaveLength(batchSize);
+              for (let i = 0; i < batchSize; i++) {
+                const queueEvents = events.filter(
+                  (event) =>
+                    "requestId" in event && event.requestId === `queued-${i}`,
+                );
+                expect(queueEvents.map((event) => event.type)).toEqual(
+                  i === 0
+                    ? [
+                        "message_queued",
+                        "message_dequeued",
+                        "message_requeued",
+                        "message_queued_deleted",
+                      ]
+                    : ["message_queued", "message_queued_deleted"],
+                );
+                expect(queueEvents.at(-1)).toMatchObject({
+                  clientMessageId: `client-queued-${i}`,
+                });
+              }
+            } else {
+              await waitForPendingRun(1);
+              expect(conversation.currentTurnCronRunId).toBe(cronRunId);
+              expect(conversation.currentTurnWorkOrigins).toHaveLength(
+                batchSize,
+              );
+              if (preserved) {
+                expect(capturedAddMessages.length).toBe(
+                  persistedBefore + batchSize,
+                );
+                expect(
+                  events.filter((event) => event.type === "user_message_echo"),
+                ).toHaveLength(batchSize);
+                expect(
+                  events.some(
+                    (event) => event.type === "message_queued_deleted",
+                  ),
+                ).toBe(false);
+              }
+              await resolveRun(0);
+            }
+          });
+        }
+      }
+    }
+  }
+
+  for (const cancel of ["schedule", "dispose"] as const) {
+    test(`${cancel} cancels an unpersisted batch tail without deleting its persisted head`, async () => {
+      const conversation = makeConversation();
+      await conversation.loadFromDb();
+      const entered = Promise.withResolvers<void>();
+      const release = Promise.withResolvers<void>();
+      beforeMessageInsert = async (requestId) => {
+        if (requestId === "queued-tail") {
+          entered.resolve();
+          await release.promise;
+        }
+      };
+      const events: AssistantEvent[] = [];
+      conversation.setProcessing(true);
+      for (const requestId of ["queued-head", "queued-tail"]) {
+        conversation.enqueueMessage({
+          content: requestId,
+          requestId,
+          clientMessageId: `client-${requestId}`,
+          cronRunId: "run-scheduled",
+          onEvent: (event) => events.push(event),
+        });
+      }
+      conversation.setProcessing(false);
+      const drain = conversation.drainQueue();
+      try {
+        await entered.promise;
+        expect(
+          events.some(
+            (event) =>
+              event.type === "user_message_echo" &&
+              event.requestId === "queued-head",
+          ),
+        ).toBe(true);
+        if (cancel === "schedule") {
+          conversation.abortScheduledRun("run-scheduled");
+          conversation.abortScheduledRun("run-scheduled");
+        } else {
+          conversation.dispose();
+        }
+        expect(
+          events.filter((event) => event.type === "generation_cancelled"),
+        ).toHaveLength(2);
+      } finally {
+        release.resolve();
+        await drain;
+      }
+      expect(
+        events
+          .filter((event) => event.type === "message_queued_deleted")
+          .map((event) => event.requestId),
+      ).toEqual(["queued-tail"]);
+      expect(capturedAddMessages.map((message) => message.id)).toEqual([
+        "queued-head",
+      ]);
+      expect(conversation.getQueueDepth()).toBe(0);
+      expect(conversation.pendingQueuedDispatches.size).toBe(0);
+      if (pendingRuns.length > 0) {
+        await resolveRun(0);
+      }
+    });
+  }
+
+  for (const cancel of ["user_cancel", "signal_cancel"] as const) {
+    for (const batchSize of [1, 2]) {
+      test(`${cancel} preserves an accepted queued prompt after persistence (batch=${batchSize})`, async () => {
+        const conversation = makeConversation();
+        await conversation.loadFromDb();
+        const persistedBefore = capturedAddMessages.length;
+        const entered = Promise.withResolvers<void>();
+        const release = Promise.withResolvers<void>();
+        const persist = conversation.persistUserMessage.bind(conversation);
+        let paused = false;
+        conversation.persistUserMessage = async (options) => {
+          const result = await persist(options);
+          if (!paused) {
+            paused = true;
+            entered.resolve();
+            await release.promise;
+          }
+          return result;
+        };
+        const events: AssistantEvent[] = [];
+        conversation.setProcessing(true);
+        for (let i = 0; i < batchSize; i++) {
+          conversation.enqueueMessage({
+            content: `User prompt ${i}`,
+            requestId: `request-${i}`,
+            clientMessageId: `client-${i}`,
+            onEvent: (event) => events.push(event),
+          });
+        }
+        conversation.setProcessing(false);
+        const drain = conversation.drainQueue();
+        try {
+          await entered.promise;
+          expect(capturedAddMessages.length).toBe(persistedBefore + 1);
+          conversation.abort(createAbortReason(cancel, "test"));
+          expect(conversation.abortController?.signal.aborted).toBe(false);
+        } finally {
+          release.resolve();
+          await drain;
+        }
+        await waitForPendingRun(1);
+        expect(
+          events.filter((event) => event.type === "user_message_echo"),
+        ).toHaveLength(batchSize);
+        expect(
+          events.some((event) => event.type === "message_queued_deleted"),
+        ).toBe(false);
+        expect(capturedAddMessages.length).toBe(persistedBefore + batchSize);
+        expect(conversation.pendingQueuedDispatches.size).toBe(0);
+        conversation.abort(createAbortReason(cancel, "test:active-turn"));
+        expect(conversation.abortController?.signal.aborted).toBe(true);
+        await resolveRun(0);
+      });
+    }
+  }
+
   test("[experimental] batched siblings run under their firing's cron run id", async () => {
     // A batched drain runs after the enqueuing turn has ended, so the firing's
     // attribution has to travel on the queued messages. Without it the batch's

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -4088,6 +4088,33 @@ describe("Slack channel chronological rendering — multi-thread", () => {
     };
   }
 
+  test("fresh memory policy reaches injectors on initial assembly and re-entry", async () => {
+    const seen = { ctx: null as TurnContext | null, commits: 0 };
+    registerPluginInjectors(V3_PROBE_PLUGIN, [probeMemoryV3Injector(seen)]);
+    try {
+      setConversation(
+        FALLBACK_CONVERSATION_ID,
+        asConversation({
+          conversationId: FALLBACK_CONVERSATION_ID,
+          currentCallSite: "callAgent",
+          currentTurnSkipMemoryRetrieval: true,
+        }),
+      );
+      for (const isReInjection of [false, true]) {
+        await applyRuntimeInjections(
+          [{ role: "user", content: [{ type: "text", text: "circle that" }] }],
+          {
+            conversationId: FALLBACK_CONVERSATION_ID,
+            reinjection: isReInjection,
+          },
+        );
+        expect(seen.ctx?.skipMemoryRetrieval).toBe(true);
+      }
+    } finally {
+      unregisterPluginInjectors(V3_PROBE_PLUGIN);
+    }
+  });
+
   test("slack replacement is stated on the turn context and attaches the memory-v3 block in memory only: uncaptured, uncommitted", async () => {
     const seen = { ctx: null as TurnContext | null, commits: 0 };
     registerPluginInjectors(V3_PROBE_PLUGIN, [probeMemoryV3Injector(seen)]);

package/src/__tests__/emit-signal-routing-intent.test.ts

@@ -359,6 +359,68 @@ describe("access-request vellum floor", () => {
     );
   });
 
+  test("an all_channels access request the decision engine suppressed still fans out", async () => {
+    evaluateSignalMock.mockResolvedValue({
+      shouldNotify: false,
+      selectedChannels: [],
+      reasoningSummary: "LLM suppressed",
+      renderedCopy: {},
+      dedupeKey: "dedupe-ar-email",
+      confidence: 0.9,
+      fallbackUsed: false,
+      persistedDecisionId: "dec-ar-email",
+    });
+    // The real enforcement leaves a suppressed decision alone and replaces
+    // the selection with every connected channel otherwise.
+    enforceRoutingIntentMock.mockImplementation(
+      (
+        decision: { shouldNotify: boolean; selectedChannels: string[] },
+        intent: string | undefined,
+        connected: string[],
+      ) =>
+        intent === "all_channels" && decision.shouldNotify
+          ? { ...decision, selectedChannels: [...connected] }
+          : decision,
+    );
+
+    await emitNotificationSignal({
+      sourceEventName: "ingress.access_request",
+      sourceChannel: "email",
+      sourceContextId: "access-req-email-stranger",
+      requiresConversation: true,
+      routingIntent: "all_channels",
+      attentionHints: {
+        requiresAction: true,
+        urgency: "high",
+        isAsyncBackground: false,
+        visibleInSourceNow: false,
+      },
+      contextPayload: {
+        requestId: "req-email",
+        requestCode: "EM12CD",
+        sourceChannel: "email",
+        conversationExternalId: "<thread-1@example.com>",
+        actorExternalId: "stranger@example.com",
+        actorDisplayName: null,
+        actorUsername: null,
+        senderIdentifier: "stranger@example.com",
+        guardianBindingChannel: null,
+        guardianResolutionSource: "vellum-anchor",
+        previousMemberStatus: null,
+        messagePreview: null,
+      },
+    });
+
+    const enforced = enforceRoutingIntentMock.mock.calls[0][0] as {
+      shouldNotify: boolean;
+    };
+    expect(enforced.shouldNotify).toBe(true);
+    const dispatched = dispatchDecisionMock.mock.calls[0][1] as {
+      selectedChannels: string[];
+    };
+    expect(dispatched.selectedChannels).toContain("vellum");
+  });
+
   test("re-adds vellum when single_channel routing enforcement strips it", async () => {
     evaluateSignalMock.mockResolvedValue({
       shouldNotify: true,

package/src/__tests__/evict-conversations-for-reload.test.ts

@@ -49,6 +49,7 @@ function register(
     processing: boolean;
     queued: boolean;
     modeSessionWork?: boolean;
+    scheduledDispatch?: boolean;
     stale?: boolean;
   },
 ): FakeConversation {
@@ -57,6 +58,14 @@ function register(
     markedStale: false,
     conversationId: id,
     liveVoiceResidencyLeases: 0,
+    pendingQueuedDispatches: state.scheduledDispatch
+      ? new Map([
+          [
+            "run-scheduled",
+            new Set([{ controller: new AbortController(), messages: [] }]),
+          ],
+        ])
+      : new Map(),
     isProcessing: () => state.processing,
     hasQueuedMessages: () => state.queued,
     modeSessions: {
@@ -111,6 +120,18 @@ describe("evictConversationsForReload", () => {
     expect(abortedParents).toEqual([]);
   });
 
+  test("keeps a scheduled dispatch whose processing claim is pending", () => {
+    const pending = register("reload-scheduled", {
+      processing: false,
+      queued: false,
+      scheduledDispatch: true,
+    });
+    evictConversationsForReload();
+    expect(pending.disposed).toBe(false);
+    expect(pending.markedStale).toBe(true);
+    expect(abortedParents).toEqual([]);
+  });
+
   test("marks a mid-turn conversation stale instead of disposing it", () => {
     const busy = register("reload-busy", { processing: true, queued: false });
 

package/src/__tests__/gemini-provider.test.ts

@@ -1748,6 +1748,15 @@ describe("GeminiProvider", () => {
     }
   });
 
+  test("maps a free-tier daily-limit 402 body code to free_tier_daily_limit_reached", async () => {
+    expect(
+      await reasonForApiError(
+        402,
+        '{"code":"free_tier_daily_limit_reached","detail":"free usage"}',
+      ),
+    ).toBe("free_tier_daily_limit_reached");
+  });
+
   test("maps a daily-limit 402 body code to daily_limit_reached", async () => {
     expect(
       await reasonForApiError(

package/src/__tests__/host-cu-proxy.test.ts

@@ -1186,6 +1186,85 @@ describe("HostCuProxy", () => {
 
       expect(result.content).toContain("2560x1440 px");
       expect(result.content).toContain("1280x720 pt");
+      expect(result.content).toContain("x = round(image_x * 0.500000)");
+      expect(result.content).toContain("y = round(image_y * 0.500000)");
+    });
+
+    test("derives separate screen-point scales for a downscaled screenshot", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        screenshot: "base64data",
+        screenshotWidthPx: 835,
+        screenshotHeightPx: 540,
+        screenWidthPt: 1728,
+        screenHeightPt: 1117,
+      });
+
+      const xScale = Number(result.content.match(/image_x \* ([\d.]+)/)?.[1]);
+      const yScale = Number(result.content.match(/image_y \* ([\d.]+)/)?.[1]);
+      expect(Math.round(675 * xScale)).toBe(1397);
+      expect(Math.round(330 * yScale)).toBe(683);
+      expect(result.content).toContain("screen points, not screenshot pixels");
+    });
+
+    test.each([
+      { capture_window_id: 12 },
+      { captureWindowId: 12 },
+      { captureDisplayId: 2 },
+    ])(
+      "does not scale a scoped screenshot by desktop dimensions: %j",
+      (input) => {
+        setup();
+
+        const result = proxy.formatObservation(
+          {
+            screenshot: "base64data",
+            screenshotWidthPx: 800,
+            screenshotHeightPx: 600,
+            screenWidthPt: 1600,
+            screenHeightPt: 1200,
+          },
+          undefined,
+          false,
+          { toolName: "computer_use_observe", input },
+        );
+
+        expect(result.content).toContain("screenshot is capture-relative");
+        expect(result.content).not.toContain("round(image_");
+      },
+    );
+
+    test.each([undefined, 0, -1, Number.NaN, Number.POSITIVE_INFINITY])(
+      "does not invent a mapping for an unavailable or invalid dimension: %s",
+      (screenWidthPt) => {
+        setup();
+
+        const result = proxy.formatObservation({
+          screenshot: "base64data",
+          screenshotWidthPx: 800,
+          screenshotHeightPx: 600,
+          screenWidthPt,
+          screenHeightPt: 1200,
+        });
+
+        expect(result.content).toContain("coordinate mapping is unavailable");
+        expect(result.content).not.toContain("round(image_");
+      },
+    );
+
+    test("omits coordinate guidance when no screenshot accompanies dimensions", () => {
+      setup();
+
+      const result = proxy.formatObservation({
+        axTree: "Button [1]",
+        screenshotWidthPx: 800,
+        screenshotHeightPx: 600,
+        screenWidthPt: 1600,
+        screenHeightPt: 1200,
+      });
+
+      expect(result.content).not.toContain("coordinate");
     });
 
     test("escapes </ax-tree> in AX tree content", () => {