@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/queued-message-cancel-and-steer.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Queue-cancellation and steer-recovery contracts on the shared handlers.
+ *
+ * `deleteQueuedMessage` closes out the queued row on the sender's event sink,
+ * pairing that terminal event with the same visibility predicate the enqueue
+ * ack used.
+ *
+ * `steerToMessage` promotes a queued message and then aborts the in-flight
+ * turn. When the flag is latched with no live controller there is nothing to
+ * abort and no agent-loop release coming, so the handler force-clears and
+ * drains itself instead of leaving the promoted message at the head of a queue
+ * that never runs.
+ */
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { AssistantEvent } from "../api/index.js";
+
+const broadcasts: AssistantEvent[] = [];
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: AssistantEvent) => {
+    broadcasts.push(msg);
+  },
+}));
+
+import type { Conversation } from "../daemon/conversation.js";
+import type { QueuedMessage } from "../daemon/conversation-queue-manager.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import {
+  deleteQueuedMessage,
+  steerToMessage,
+} from "../daemon/handlers/conversations.js";
+
+const CONV = "queued-cancel-conv";
+
+/**
+ * Register a conversation holding one queued message, and hand back the events
+ * the handler delivered to that message's sender sink.
+ */
+function registerWithQueuedMessage(
+  queued: Partial<QueuedMessage> | undefined,
+): AssistantEvent[] {
+  const sent: AssistantEvent[] = [];
+  const item = queued
+    ? { ...queued, onEvent: (msg: AssistantEvent) => sent.push(msg) }
+    : undefined;
+  const fake = {
+    conversationId: CONV,
+    isProcessing: () => false,
+    queue: {
+      findByRequestId: (requestId: string) =>
+        item?.requestId === requestId ? item : undefined,
+    },
+    removeQueuedMessage: () => item,
+  };
+  setConversation(CONV, fake as unknown as Conversation);
+  return sent;
+}
+
+interface LatchedTurn {
+  cleared: () => boolean;
+  drainReasons: string[];
+  pendingSteerRepair: () => boolean;
+}
+
+/**
+ * Register a conversation whose processing flag is latched with no live
+ * controller: the shape a turn leaves behind when it tore its controller down
+ * (or died) without any release running.
+ */
+function registerLatchedTurn(): LatchedTurn {
+  let processing = true;
+  const drainReasons: string[] = [];
+  const fake = {
+    conversationId: CONV,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
+    abortController: null,
+    queue: {
+      findByRequestId: (requestId: string) => ({ requestId }),
+      promoteToHead: (requestId: string) => ({ requestId }),
+    },
+    pendingSteerRepair: false,
+    kickDrainQueue: (reason: string) => {
+      drainReasons.push(reason);
+      return Promise.resolve();
+    },
+    denyAllPendingConfirmations: () => {},
+  };
+  setConversation(CONV, fake as unknown as Conversation);
+  return {
+    cleared: () => !processing,
+    drainReasons,
+    pendingSteerRepair: () => fake.pendingSteerRepair,
+  };
+}
+
+describe("deleteQueuedMessage", () => {
+  afterEach(() => {
+    broadcasts.length = 0;
+    deleteConversation(CONV);
+  });
+
+  test("closes out the queued row so clients retire the pending indicator", () => {
+    const sent = registerWithQueuedMessage({
+      requestId: "req-1",
+      clientMessageId: "client-1",
+      metadata: {},
+    });
+
+    expect(deleteQueuedMessage(CONV, "req-1")).toEqual({ removed: true });
+    expect(sent).toEqual([
+      {
+        type: "message_queued_deleted",
+        conversationId: CONV,
+        requestId: "req-1",
+        clientMessageId: "client-1",
+      },
+    ]);
+  });
+
+  test("omits clientMessageId when the sender minted none", () => {
+    const sent = registerWithQueuedMessage({
+      requestId: "req-2",
+      metadata: {},
+    });
+
+    expect(deleteQueuedMessage(CONV, "req-2")).toEqual({ removed: true });
+    expect(sent).toEqual([
+      {
+        type: "message_queued_deleted",
+        conversationId: CONV,
+        requestId: "req-2",
+      },
+    ]);
+  });
+
+  test("stays silent for an echo-suppressed entry", () => {
+    // A daemon-injected notification never produced a `message_queued` ack, so
+    // a delete event would be an unpaired retire for a row no client renders.
+    const sent = registerWithQueuedMessage({
+      requestId: "req-3",
+      metadata: {
+        subagentNotification: { subagentId: "child-1", label: "research" },
+      },
+    });
+
+    expect(deleteQueuedMessage(CONV, "req-3")).toEqual({ removed: true });
+    expect(sent).toEqual([]);
+  });
+
+  test("stays silent when nothing matched the request id", () => {
+    const sent = registerWithQueuedMessage(undefined);
+
+    expect(deleteQueuedMessage(CONV, "req-missing")).toEqual({
+      removed: false,
+      reason: "message_not_found",
+    });
+    expect(sent).toEqual([]);
+    expect(broadcasts).toEqual([]);
+  });
+});
+
+describe("steerToMessage with a latched processing flag", () => {
+  afterEach(() => {
+    broadcasts.length = 0;
+    deleteConversation(CONV);
+  });
+
+  test("force-clears and drains when no live controller can be aborted", () => {
+    const turn = registerLatchedTurn();
+
+    expect(steerToMessage(CONV, "req-steer")).toEqual({ steered: true });
+
+    // Without the force-clear the promoted message would sit behind a flag
+    // nothing is going to release.
+    expect(turn.cleared()).toBe(true);
+    expect(turn.drainReasons).toEqual(["loop_complete"]);
+    // The drain consumes the repair flag, so it must survive the force-clear.
+    expect(turn.pendingSteerRepair()).toBe(true);
+    expect(broadcasts).toEqual([
+      { type: "message_steered", conversationId: CONV, requestId: "req-steer" },
+    ]);
+  });
+});

package/src/__tests__/queued-message-steer-actor-scoping.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Authorization for steering to a queued message.
+ *
+ * Steering aborts the in-flight generation and promotes the named queued
+ * message to the head of the queue, so it is scoped to the actor principal
+ * that enqueued the message the same way deletion is: every subscriber sees
+ * every `message_queued` ack, so requestIds are not secrets and cannot stand
+ * in for authorization. The caller identity is normalized exactly as the send
+ * path normalizes it before recording `sourceActorPrincipalId`.
+ */
+import { afterEach, describe, expect, test } from "bun:test";
+
+import {
+  MessageQueue,
+  type QueuedMessage,
+} from "../daemon/conversation-queue-manager.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { ROUTES } from "../runtime/routes/conversation-query-routes.js";
+
+const steerRoute = ROUTES.find(
+  (route) => route.operationId === "messages_queued_steer",
+)!;
+
+const registered: string[] = [];
+
+interface QueuedFixture {
+  requestId: string;
+  sourceActorPrincipalId?: string;
+}
+
+/**
+ * Register a live, mid-turn conversation holding `items`. The steer path
+ * reads the in-memory registry and touches no persistence, so a queue-only
+ * stand-in exercises the real code.
+ */
+function seedProcessingConversation(
+  conversationId: string,
+  items: QueuedFixture[],
+): { queue: MessageQueue; aborted: () => boolean } {
+  const queue = new MessageQueue();
+  for (const item of items) {
+    queue.push({
+      content: `content for ${item.requestId}`,
+      attachments: [],
+      requestId: item.requestId,
+      onEvent: () => {},
+      sentAt: Date.now(),
+      sourceActorPrincipalId: item.sourceActorPrincipalId,
+    } as QueuedMessage);
+  }
+  const abortController = new AbortController();
+  const conversation = {
+    conversationId,
+    queue,
+    isProcessing: () => true,
+    pendingSteerRepair: false,
+    abortController,
+    denyAllPendingConfirmations: () => {},
+  };
+  setConversation(conversationId, conversation as never);
+  registered.push(conversationId);
+  return { queue, aborted: () => abortController.signal.aborted };
+}
+
+function dispatchSteer(args: {
+  conversationId: string;
+  requestId: string;
+  actorPrincipalId?: string;
+}) {
+  return Promise.resolve(
+    steerRoute.handler({
+      pathParams: { id: args.requestId },
+      queryParams: { conversationId: args.conversationId },
+      headers:
+        args.actorPrincipalId !== undefined
+          ? { "x-vellum-actor-principal-id": args.actorPrincipalId }
+          : {},
+    }),
+  );
+}
+
+afterEach(() => {
+  for (const conversationId of registered.splice(0)) {
+    deleteConversation(conversationId);
+  }
+  delete process.env.DISABLE_HTTP_AUTH;
+});
+
+describe("queued message steer: actor scoping", () => {
+  test("a different actor principal cannot steer to someone else's queued message", async () => {
+    const { queue, aborted } = seedProcessingConversation("conv-steer-1", [
+      { requestId: "r-head", sourceActorPrincipalId: "actor-owner" },
+      { requestId: "r-target", sourceActorPrincipalId: "actor-owner" },
+    ]);
+
+    await expect(
+      dispatchSteer({
+        conversationId: "conv-steer-1",
+        requestId: "r-target",
+        actorPrincipalId: "actor-bystander",
+      }),
+    ).rejects.toThrow("sent by a different user");
+
+    // The queue order is untouched and the live generation kept running.
+    expect(queue.peek(0)?.requestId).toBe("r-head");
+    expect(aborted()).toBe(false);
+  });
+
+  test("the enqueuing actor principal can steer to its own queued message", async () => {
+    const { queue, aborted } = seedProcessingConversation("conv-steer-2", [
+      { requestId: "r-head", sourceActorPrincipalId: "actor-owner" },
+      { requestId: "r-target", sourceActorPrincipalId: "actor-owner" },
+    ]);
+
+    expect(
+      await dispatchSteer({
+        conversationId: "conv-steer-2",
+        requestId: "r-target",
+        actorPrincipalId: "actor-owner",
+      }),
+    ).toEqual({
+      ok: true,
+      conversationId: "conv-steer-2",
+      requestId: "r-target",
+    });
+
+    expect(queue.peek(0)?.requestId).toBe("r-target");
+    expect(aborted()).toBe(true);
+  });
+
+  test("a caller with no actor principal is the guardian by construction", async () => {
+    const { queue } = seedProcessingConversation("conv-steer-3", [
+      { requestId: "r-head", sourceActorPrincipalId: "actor-owner" },
+      { requestId: "r-target", sourceActorPrincipalId: "actor-owner" },
+    ]);
+
+    // Local/IPC and service principals carry no actorPrincipalId; the CLI
+    // must keep being able to steer.
+    await dispatchSteer({
+      conversationId: "conv-steer-3",
+      requestId: "r-target",
+    });
+
+    expect(queue.peek(0)?.requestId).toBe("r-target");
+  });
+
+  test("a daemon-internal enqueue with no recorded requester stays steerable", async () => {
+    const { queue } = seedProcessingConversation("conv-steer-4", [
+      { requestId: "r-head" },
+      { requestId: "r-target" },
+    ]);
+
+    await dispatchSteer({
+      conversationId: "conv-steer-4",
+      requestId: "r-target",
+      actorPrincipalId: "actor-anyone",
+    });
+
+    expect(queue.peek(0)?.requestId).toBe("r-target");
+  });
+});

package/src/__tests__/resolve-trust-class.test.ts

@@ -78,6 +78,26 @@ describe("mapChatTypeToConversationType", () => {
   test("maps DM-shaped chat types to dm", () => {
     expect(mapChatTypeToConversationType("im")).toBe("dm"); // Slack DM
     expect(mapChatTypeToConversationType("private")).toBe("dm"); // Telegram DM
+    expect(mapChatTypeToConversationType("dm")).toBe("dm"); // Discord DM
+  });
+
+  test("every DM-capable channel's own word for a DM lands on the axis", () => {
+    // A missing arm is silent rather than loud: the permission cell stays
+    // settable, because the adapter validates against the channel registry,
+    // and simply never matches. The guardian sets a rule for DMs on that
+    // channel and it does nothing. Stated as a sweep so adding a DM-capable
+    // channel without its arm fails here.
+    const dmChatTypeByChannel = {
+      slack: "im",
+      telegram: "private",
+      whatsapp: "private",
+      discord: "dm",
+    };
+    for (const [channel, chatType] of Object.entries(dmChatTypeByChannel)) {
+      expect(`${channel}:${mapChatTypeToConversationType(chatType)}`).toBe(
+        `${channel}:dm`,
+      );
+    }
   });
 
   test("maps closed-group chat types to private", () => {

package/src/__tests__/run-conversation-turn-persistence.test.ts

@@ -52,7 +52,7 @@ mock.module("../daemon/conversation-store.js", () => ({
             | "background",
         });
       } else {
-        ensureConversationExists(conversationId);
+        ensureConversationExists(conversationId, "vellum");
       }
     }
     return {

package/src/__tests__/run-due-schedules.test.ts

@@ -5,6 +5,8 @@
  * sequences.
  */
 
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../background-wake/publisher.js", () => ({
@@ -58,8 +60,11 @@ import { initializeDb } from "../persistence/db-init.js";
 import {
   createSchedule,
   deferClaimedSchedule,
+  upsertDeclaredSchedule,
 } from "../schedule/schedule-store.js";
 import { runDueSchedulesOnce } from "../schedule/scheduler.js";
+import { getWorkspacePluginsDir } from "../util/platform.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 await initializeDb();
 
@@ -217,3 +222,172 @@ describe("runDueSchedulesOnce (the schedule worker's tick)", () => {
     expect(row.next_run_at).toBeGreaterThan(Date.now());
   });
 });
+
+describe("fire-time source-availability gate", () => {
+  const PLUGIN_NAME = "example-plugin";
+  const SCHEDULE_NAME = "daily-digest";
+  const SOURCE_KEY = `plugin:${PLUGIN_NAME}/${SCHEDULE_NAME}`;
+  const pluginDir = join(getWorkspacePluginsDir(), PLUGIN_NAME);
+  const declarationDir = join(pluginDir, "schedules", SCHEDULE_NAME);
+  const manifest = join(pluginDir, "package.json");
+  // The marker lives outside the plugin directory so the uninstall case still
+  // proves the script never ran: a `touch` into a deleted tree would fail on
+  // its own and hide a guard that let the row through.
+  const marker = join(getWorkspacePluginsDir(), "ran.txt");
+
+  // The gate probes the declaration's on-disk presence and its plugin's
+  // manifest, so the healthy fixture is a full plugin: a valid package.json
+  // and a schedules/<name>/ declaration directory.
+  beforeEach(() => {
+    rmSync(pluginDir, { recursive: true, force: true });
+    rmSync(marker, { force: true });
+    mkdirSync(declarationDir, { recursive: true });
+    writeFileSync(
+      join(declarationDir, "config.json"),
+      JSON.stringify({ expression: "* * * * *" }),
+    );
+    writeFileSync(join(declarationDir, "index.sh"), "#!/bin/sh\ntrue\n");
+    writeFileSync(
+      manifest,
+      JSON.stringify({ name: PLUGIN_NAME, version: "1.0.0" }),
+    );
+    // The feature ships off, so the healthy-plugin cases below need it on.
+    setOverridesForTesting({ "plugin-schedules": true });
+  });
+
+  function skipRunsFor(jobId: string): Array<{
+    status: string;
+    error: string | null;
+  }> {
+    return rawDb()
+      .query("SELECT status, error FROM cron_runs WHERE job_id = ?")
+      .all(jobId) as Array<{ status: string; error: string | null }>;
+  }
+
+  /** A due plugin-sourced script row whose script leaves a marker when it runs. */
+  async function seedDueSourcedScript() {
+    const job = await upsertDeclaredSchedule(SOURCE_KEY, {
+      name: "Daily digest",
+      syntax: "cron",
+      expression: "* * * * *",
+      timezone: null,
+      message: "",
+      script: `touch ${marker}`,
+      mode: "script",
+      inferenceProfile: null,
+      timeoutMs: null,
+      enabled: true,
+      definitionHash: "hash-1",
+    });
+    rawDb().run("UPDATE cron_jobs SET next_run_at = ? WHERE id = ?", [
+      Date.now() - 1000,
+      job.id,
+    ]);
+    return job;
+  }
+
+  test("does not execute a due sourced row whose plugin is disabled", async () => {
+    const job = await seedDueSourcedScript();
+    writeFileSync(join(pluginDir, ".disabled"), "");
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.claimed).toBe(1);
+    expect(result.skipped).toBe(1);
+    expect(result.completed).toBe(0);
+    expect(existsSync(marker)).toBe(false);
+    // The skip is recorded so it stays visible in the schedule's run history.
+    const runs = skipRunsFor(job.id);
+    expect(runs).toHaveLength(1);
+    expect(runs[0].status).toBe("error");
+    expect(runs[0].error).toContain("no longer declares this schedule");
+  });
+
+  test("does not execute a due sourced row whose plugin directory is gone", async () => {
+    const job = await seedDueSourcedScript();
+    // A local CLI uninstall removes the directory outright, with no daemon
+    // call to disarm the row first.
+    rmSync(pluginDir, { recursive: true, force: true });
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.claimed).toBe(1);
+    expect(result.skipped).toBe(1);
+    expect(result.completed).toBe(0);
+    expect(existsSync(marker)).toBe(false);
+    expect(skipRunsFor(job.id)).toHaveLength(1);
+  });
+
+  test("does not execute a due sourced row whose manifest no longer parses", async () => {
+    const job = await seedDueSourcedScript();
+    writeFileSync(manifest, "{ broken");
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.claimed).toBe(1);
+    expect(result.skipped).toBe(1);
+    expect(result.completed).toBe(0);
+    expect(existsSync(marker)).toBe(false);
+    expect(skipRunsFor(job.id)).toHaveLength(1);
+  });
+
+  test("does not execute a due sourced row whose declaration is gone", async () => {
+    const job = await seedDueSourcedScript();
+    rmSync(declarationDir, { recursive: true, force: true });
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.skipped).toBe(1);
+    expect(existsSync(marker)).toBe(false);
+    expect(skipRunsFor(job.id)).toHaveLength(1);
+  });
+
+  test("does not execute a due sourced row while the feature flag is off", async () => {
+    const job = await seedDueSourcedScript();
+    setOverridesForTesting({ "plugin-schedules": false });
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.claimed).toBe(1);
+    expect(result.skipped).toBe(1);
+    expect(result.completed).toBe(0);
+    expect(existsSync(marker)).toBe(false);
+    const runs = skipRunsFor(job.id);
+    expect(runs).toHaveLength(1);
+    expect(runs[0].status).toBe("error");
+    expect(runs[0].error).toContain("no longer declares this schedule");
+  });
+
+  test("a skip spends no retry budget and keeps the row on its normal cadence", async () => {
+    const job = await seedDueSourcedScript();
+    // A non-zero starting budget proves the counter is left alone rather than
+    // merely still reading zero.
+    rawDb().run("UPDATE cron_jobs SET retry_count = 2 WHERE id = ?", [job.id]);
+    writeFileSync(join(pluginDir, ".disabled"), "");
+
+    await runDueSchedulesOnce();
+
+    const row = rawDb()
+      .query("SELECT retry_count, next_run_at FROM cron_jobs WHERE id = ?")
+      .get(job.id) as { retry_count: number; next_run_at: number };
+    expect(row.retry_count).toBe(2);
+    // The next occurrence of `* * * * *` is at most a minute out. A retry at
+    // this budget would have pushed it minutes further on backoff.
+    expect(row.next_run_at).toBeGreaterThan(Date.now());
+    expect(row.next_run_at).toBeLessThanOrEqual(Date.now() + 61_000);
+  });
+
+  test("executes a due sourced row whose plugin is enabled", async () => {
+    const job = await seedDueSourcedScript();
+
+    const result = await runDueSchedulesOnce();
+
+    expect(result.completed).toBe(1);
+    expect(existsSync(marker)).toBe(true);
+    const runs = rawDb()
+      .query("SELECT status FROM cron_runs WHERE job_id = ?")
+      .all(job.id) as Array<{ status: string }>;
+    expect(runs).toHaveLength(1);
+    expect(runs[0].status).toBe("ok");
+  });
+});

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -97,7 +97,7 @@ describe("Runtime attachment metadata", () => {
     );
 
     // Upload and link an attachment using "self" as the assistantId
-    const stored = uploadAttachment("chart.png", "image/png", "iVBORw==");
+    const stored = await uploadAttachment("chart.png", "image/png", "iVBORw==");
     linkAttachmentToMessage(assistantMsg.id, stored.id, 0);
 
     const res = await fetch(
@@ -162,7 +162,7 @@ describe("Runtime attachment metadata", () => {
   });
 
   test("GET /attachments/:id returns attachment with payload", async () => {
-    const stored = uploadAttachment(
+    const stored = await uploadAttachment(
       "report.pdf",
       "application/pdf",
       "JVBERA==",
@@ -191,7 +191,11 @@ describe("Runtime attachment metadata", () => {
   });
 
   test('GET /attachments/:id returns attachment stored under "self"', async () => {
-    const stored = uploadAttachment("shared.txt", "text/plain", "c2hhcmVk");
+    const stored = await uploadAttachment(
+      "shared.txt",
+      "text/plain",
+      "c2hhcmVk",
+    );
 
     const res = await fetch(
       `http://127.0.0.1:${port}/v1/attachments/${stored.id}`,
@@ -303,12 +307,16 @@ describe("WhatsApp channel ingress attachment resolution", () => {
   test("inbound handler accepts request with valid gateway-uploaded attachment IDs", async () => {
     // Simulate what the gateway does: upload attachments then forward the
     // inbound event with attachmentIds. The handler must resolve them.
-    const img = uploadAttachment(
+    const img = await uploadAttachment(
       "whatsapp-photo.jpg",
       "image/jpeg",
       "/9j/4AAQ",
     );
-    const doc = uploadAttachment("receipt.pdf", "application/pdf", "JVBERi0x");
+    const doc = await uploadAttachment(
+      "receipt.pdf",
+      "application/pdf",
+      "JVBERi0x",
+    );
 
     const res = await fetch(
       `http://127.0.0.1:${ingressPort}/v1/channels/inbound`,
@@ -329,7 +337,7 @@ describe("WhatsApp channel ingress attachment resolution", () => {
   test("inbound handler rejects request when some attachment IDs are missing", async () => {
     // When the gateway fails to upload one attachment, the handler detects
     // the missing ID and returns a 400.
-    const valid = uploadAttachment("ok.jpg", "image/jpeg", "base64ok");
+    const valid = await uploadAttachment("ok.jpg", "image/jpeg", "base64ok");
 
     const res = await fetch(
       `http://127.0.0.1:${ingressPort}/v1/channels/inbound`,
@@ -355,7 +363,7 @@ describe("WhatsApp channel ingress attachment resolution", () => {
 
   test("inbound handler accepts attachment-only message with no text content", async () => {
     // WhatsApp allows sending images/documents without caption text.
-    const img = uploadAttachment("photo.jpg", "image/jpeg", "/9j/4AAQ");
+    const img = await uploadAttachment("photo.jpg", "image/jpeg", "/9j/4AAQ");
 
     const res = await fetch(
       `http://127.0.0.1:${ingressPort}/v1/channels/inbound`,