@vellumai/assistant 0.12.2 → 0.12.3-staging.2

package/src/messaging/providers/telegram-bot/send.ts

@@ -31,7 +31,9 @@ const TELEGRAM_MAX_MESSAGE_LEN = 4000;
 /** Telegram Bot API enforces a 1-64 byte limit on InlineKeyboardButton callback_data. */
 const TELEGRAM_MAX_CALLBACK_DATA_BYTES = 64;
 
-// Telegram Bot API sendDocument upload limit is 50 MB
+// Bot API limits for a multipart upload: 10 MB for a photo, 50 MB for any
+// other file (https://core.telegram.org/bots/api#sending-files).
+const TELEGRAM_MAX_PHOTO_BYTES = 10 * 1024 * 1024;
 const TELEGRAM_MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024;
 
 const TELEGRAM_IMAGE_MIME_PREFIXES = [
@@ -296,8 +298,9 @@ export type TelegramAttachmentResult = {
 };
 
 /**
- * Send attachments to a Telegram chat, using sendPhoto for images and
- * sendDocument for everything else.
+ * Send attachments to a Telegram chat, using sendPhoto for an image within
+ * the photo limit and sendDocument for everything else, so an image over it
+ * still arrives as a file.
  */
 export async function sendTelegramAttachments(
   chatId: string,
@@ -351,10 +354,10 @@ export async function sendTelegramAttachments(
         form.set("message_thread_id", String(threadFields.message_thread_id));
       }
 
-      const isImage = TELEGRAM_IMAGE_MIME_PREFIXES.some((p) =>
-        mimeType.startsWith(p),
-      );
-      if (isImage) {
+      const sendsAsPhoto =
+        TELEGRAM_IMAGE_MIME_PREFIXES.some((p) => mimeType.startsWith(p)) &&
+        content.length <= TELEGRAM_MAX_PHOTO_BYTES;
+      if (sendsAsPhoto) {
         form.set("photo", blob, filename);
         await callTelegramBotApiMultipart("sendPhoto", form);
       } else {

package/src/messaging/providers/telegram-bot/transport.ts

@@ -55,15 +55,6 @@ function draftText(text: string, plan: StreamPlan | undefined): string {
   return [body, planText].filter(Boolean).join("\n\n");
 }
 
-/**
- * Telegram's draft id is minted by the caller, unlike a stream id a platform
- * hands back, and only has to be non-zero and stable for the life of one
- * draft. The clock supplies that without any state to keep between calls.
- */
-function mintDraftId(): number {
-  return Date.now();
-}
-
 export const telegramTransport: ChannelTransport = {
   channel: "telegram",
 
@@ -166,7 +157,9 @@ export const telegramTransport: ChannelTransport = {
     if (op.action === "stop") {
       return { ok: true, ts: op.streamId };
     }
-    const draftId = op.action === "start" ? mintDraftId() : Number(op.streamId);
+    // Telegram mints draft ids on the caller. A non-zero clock tick is enough
+    // for the life of one draft.
+    const draftId = op.action === "start" ? Date.now() : Number(op.streamId);
     if (!Number.isFinite(draftId) || draftId === 0) {
       return { ok: false };
     }

package/src/messaging/providers/whatsapp/send.test.ts

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { ApprovalUIMetadata } from "@vellumai/gateway-client";
 
+import type { RuntimeAttachmentMetadata } from "../../../runtime/http-types.js";
 import type { CallbackContext } from "../channel-transport.js";
 
 // The Cloud API answers every accepted send with the id it assigned. The stubs
@@ -10,6 +11,19 @@ import type { CallbackContext } from "../channel-transport.js";
 let nextId = 1;
 let respondWithoutIds = false;
 const sent: Array<{ kind: "text" | "interactive"; body: string }> = [];
+// Each media upload and each media message the attachment sender posted.
+const uploads: Array<{ blob: Blob; filename: string; mimeType: string }> = [];
+const mediaMessages: Array<{
+  to: string;
+  mediaType: string;
+  mediaId: string;
+  filename?: string;
+}> = [];
+// Filenames whose upload the stubbed Cloud API rejects.
+const rejectUploadOf = new Set<string>();
+// Bytes the stubbed attachment store holds, keyed by attachment id.
+let storeContents: Record<string, Buffer> = {};
+const storeReads: string[] = [];
 
 function apiResult() {
   if (respondWithoutIds) {
@@ -31,19 +45,41 @@ mock.module("./api.js", () => ({
     sent.push({ kind: "interactive", body });
     return apiResult();
   },
-  sendWhatsAppMediaMessage: async () => apiResult(),
-  uploadWhatsAppMedia: async () => ({ id: "media-1" }),
+  sendWhatsAppMediaMessage: async (
+    to: string,
+    mediaType: string,
+    mediaId: string,
+    filename?: string,
+  ) => {
+    mediaMessages.push({ to, mediaType, mediaId, filename });
+    return apiResult();
+  },
+  uploadWhatsAppMedia: async (
+    blob: Blob,
+    filename: string,
+    mimeType: string,
+  ) => {
+    uploads.push({ blob, filename, mimeType });
+    if (rejectUploadOf.has(filename)) {
+      throw new Error("WhatsApp API error (400): invalid media");
+    }
+    return { id: `media-${uploads.length}` };
+  },
 }));
 
 mock.module("../../../persistence/attachments-store.js", () => ({
-  getAttachmentContent: async () => null,
+  getAttachmentContent: (attachmentId: string) => {
+    storeReads.push(attachmentId);
+    return storeContents[attachmentId] ?? null;
+  },
 }));
 
 mock.module("../../../util/logger.js", () => ({
   getLogger: () => ({ debug() {}, info() {}, warn() {}, error() {} }),
 }));
 
-const { sendWhatsAppReply } = await import("./send.js");
+const { sendWhatsAppAttachments, sendWhatsAppReply } =
+  await import("./send.js");
 const { whatsappTransport } = await import("./transport.js");
 
 const approval: ApprovalUIMetadata = {
@@ -59,6 +95,11 @@ beforeEach(() => {
   nextId = 1;
   respondWithoutIds = false;
   sent.length = 0;
+  uploads.length = 0;
+  mediaMessages.length = 0;
+  rejectUploadOf.clear();
+  storeContents = {};
+  storeReads.length = 0;
 });
 
 describe("sendWhatsAppReply acknowledged ids", () => {
@@ -137,3 +178,127 @@ describe("whatsappTransport.deliver", () => {
     expect(result).toEqual({ ok: true, messageIds: [] });
   });
 });
+
+describe("sendWhatsAppAttachments", () => {
+  // The sender's own cap on an outbound attachment.
+  const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+  const TO = "12125550100";
+
+  function attachment(
+    id: string,
+    filename: string,
+    mimeType: string,
+    sizeBytes = 3,
+  ): RuntimeAttachmentMetadata {
+    return { id, filename, mimeType, sizeBytes, kind: "file" };
+  }
+
+  const notices = () =>
+    sent.filter((s) => s.kind === "text").map((s) => s.body);
+
+  test("uploads the stored bytes and posts them as the matching media type", async () => {
+    storeContents = {
+      "att-1": Buffer.from("jpg"),
+      "att-2": Buffer.from("mp4"),
+      "att-3": Buffer.from("pdf"),
+    };
+
+    const result = await sendWhatsAppAttachments(TO, [
+      attachment("att-1", "photo.jpg", "image/jpeg"),
+      attachment("att-2", "clip.mp4", "video/mp4"),
+      attachment("att-3", "report.pdf", "application/pdf"),
+    ]);
+
+    expect(uploads.map((u) => [u.filename, u.mimeType, u.blob.type])).toEqual([
+      ["photo.jpg", "image/jpeg", "image/jpeg"],
+      ["clip.mp4", "video/mp4", "video/mp4"],
+      ["report.pdf", "application/pdf", "application/pdf"],
+    ]);
+    expect(await uploads[0]?.blob.text()).toBe("jpg");
+    // Each message references the id its own upload returned.
+    expect(mediaMessages).toEqual([
+      { to: TO, mediaType: "image", mediaId: "media-1", filename: "photo.jpg" },
+      { to: TO, mediaType: "video", mediaId: "media-2", filename: "clip.mp4" },
+      {
+        to: TO,
+        mediaType: "document",
+        mediaId: "media-3",
+        filename: "report.pdf",
+      },
+    ]);
+    expect(notices()).toEqual([]);
+    expect(result).toEqual({
+      allFailed: false,
+      failureCount: 0,
+      totalCount: 3,
+    });
+  });
+
+  test("skips an attachment whose declared size is over the cap without reading it", async () => {
+    storeContents = { "att-1": Buffer.from("mp4") };
+
+    const result = await sendWhatsAppAttachments(TO, [
+      attachment("att-1", "huge.mp4", "video/mp4", MAX_ATTACHMENT_BYTES + 1),
+    ]);
+
+    expect(storeReads).toEqual([]);
+    expect(uploads).toHaveLength(0);
+    expect(notices()).toEqual([
+      "1 attachment(s) could not be delivered: huge.mp4",
+    ]);
+    expect(result).toEqual({ allFailed: true, failureCount: 1, totalCount: 1 });
+  });
+
+  test("skips an attachment whose stored bytes are over the cap", async () => {
+    // The declared size understates what the store actually holds.
+    storeContents = { "att-1": Buffer.alloc(MAX_ATTACHMENT_BYTES + 1) };
+
+    const result = await sendWhatsAppAttachments(TO, [
+      attachment("att-1", "long.mp4", "video/mp4"),
+    ]);
+
+    expect(uploads).toHaveLength(0);
+    expect(notices()).toEqual([
+      "1 attachment(s) could not be delivered: long.mp4",
+    ]);
+    expect(result).toEqual({ allFailed: true, failureCount: 1, totalCount: 1 });
+  });
+
+  test("reports an attachment the store has no content for", async () => {
+    const result = await sendWhatsAppAttachments(TO, [
+      attachment("att-1", "missing.txt", "text/plain"),
+    ]);
+
+    expect(storeReads).toEqual(["att-1"]);
+    expect(uploads).toHaveLength(0);
+    expect(notices()).toEqual([
+      "1 attachment(s) could not be delivered: missing.txt",
+    ]);
+    expect(result).toEqual({ allFailed: true, failureCount: 1, totalCount: 1 });
+  });
+
+  test("keeps sending after one upload fails and names only the failure", async () => {
+    storeContents = {
+      "att-1": Buffer.from("a"),
+      "att-2": Buffer.from("b"),
+      "att-3": Buffer.from("c"),
+    };
+    rejectUploadOf.add("b.txt");
+
+    const result = await sendWhatsAppAttachments(TO, [
+      attachment("att-1", "a.txt", "text/plain"),
+      attachment("att-2", "b.txt", "text/plain"),
+      attachment("att-3", "c.txt", "text/plain"),
+    ]);
+
+    expect(mediaMessages.map((m) => m.filename)).toEqual(["a.txt", "c.txt"]);
+    expect(notices()).toEqual([
+      "1 attachment(s) could not be delivered: b.txt",
+    ]);
+    expect(result).toEqual({
+      allFailed: false,
+      failureCount: 1,
+      totalCount: 3,
+    });
+  });
+});

package/src/monitoring/__tests__/control.test.ts

@@ -167,19 +167,26 @@ describe("spawnMonitoringWorkerProcess", () => {
     }
   });
 
-  test("reuses an already-running monitor without spawning", async () => {
+  test("spawns when the PID file names an unrelated live process", async () => {
     writeFileSync(pidPath, String(process.pid));
     let spawned = false;
     const restore = stubBunSpawn(() => {
       spawned = true;
-      return { unref: () => {}, kill: () => {}, pid: 1, exited: neverExits() };
+      writeFileSync(pidPath, "4242");
+      return {
+        unref: () => {},
+        kill: () => {},
+        pid: 4242,
+        exited: neverExits(),
+      };
     });
     try {
       const result = await spawnMonitoringWorkerProcess({
-        pidWaitTimeoutMs: 100,
+        pidWaitTimeoutMs: 1_000,
+        pidPollIntervalMs: 10,
       });
-      expect(result).toEqual({ pid: process.pid, alreadyRunning: true });
-      expect(spawned).toBe(false);
+      expect(result).toEqual({ pid: 4242, alreadyRunning: false });
+      expect(spawned).toBe(true);
     } finally {
       restore();
     }
@@ -201,6 +208,11 @@ describe("probeMonitoringWorker", () => {
     }
   });
 
+  test("reports not_running when the PID file names a live process that is not this worker", () => {
+    writeFileSync(pidPath, String(process.pid));
+    expect(probeMonitoringWorker()).toEqual({ status: "not_running" });
+  });
+
   test("reports running (not throws) when the process exists but is not signalable (EPERM)", () => {
     writeFileSync(pidPath, "4321");
     const restore = stubProcessKill(new Set(), new Set([4321]));

package/src/monitoring/control.ts

@@ -19,15 +19,21 @@ import {
   type WorkerProcessStatus,
 } from "../util/worker-process.js";
 
+const MONITORING_WORKER_ENTRY = new URL("./worker.ts", import.meta.url);
+
 const log = getLogger("monitoring-control");
 
 /**
  * Read the PID file and report liveness. A missing or malformed file reports
- * not_running; a file pointing at a dead process is cleaned up and reported as
- * not_running.
+ * not_running; a file pointing at a dead process, or at a live process that
+ * is not this worker, is cleaned up and reported as not_running.
  */
 export function probeMonitoringWorker(): WorkerProcessStatus {
-  return probeWorkerPidFile(getMonitoringPidPath());
+  return probeWorkerPidFile(
+    getMonitoringPidPath(),
+    MONITORING_WORKER_ENTRY,
+    "monitoring",
+  );
 }
 
 export class MonitoringWorkerSpawnError extends WorkerProcessSpawnError {}
@@ -44,7 +50,7 @@ export async function spawnMonitoringWorkerProcess(
   try {
     return await spawnWorkerProcess({
       pidPath: getMonitoringPidPath(),
-      entry: new URL("./worker.ts", import.meta.url),
+      entry: MONITORING_WORKER_ENTRY,
       packagedEntry: "monitoring",
       workerLabel: "Resource monitor",
       options: opts,
@@ -63,7 +69,11 @@ export async function spawnMonitoringWorkerProcess(
  * (e.g. EPERM) — a not-running monitor is a no-op.
  */
 export function stopMonitoringWorkerProcess(): WorkerProcessStatus {
-  return stopWorkerProcess(getMonitoringPidPath());
+  return stopWorkerProcess(
+    getMonitoringPidPath(),
+    MONITORING_WORKER_ENTRY,
+    "monitoring",
+  );
 }
 
 /**

package/src/notifications/AGENTS.md

@@ -4,7 +4,7 @@ All notification producers **MUST** go through `emitNotificationSignal()` in `no
 
 Guardian-request cards (approvals, questions) ride this pipeline end to end -- the full lifecycle map is [docs/guardian-request-flow.md](../../docs/guardian-request-flow.md). Card actions (`actions[]`) are built **once, centrally** in the broadcaster's context resolvers (`resolveApprovalContext` / `resolveQuestionContext`); channel adapters render only. Adding buttons for a new request kind = a broadcaster context branch, never adapter parsing.
 
-When a notification flow creates a server-side conversation (e.g. guardian question conversations, task run conversations), the conversation and initial message **MUST** be persisted before the conversation-created event is emitted. This ensures the macOS/iOS client can immediately fetch the conversation contents when it receives the event.
+When a notification flow creates a server-side conversation (e.g. guardian question conversations, task run conversations), the conversation and initial message **MUST** be persisted before the conversation-created event is emitted. This ensures a client can immediately fetch the conversation contents when it receives the event.
 
 Guardian-request producers (access requests, tool approvals, tool-grant escalations, voice questions, trusted-contact confirmations) **MUST** record approval-card deliveries through `recordApprovalCardDelivery` / `recordGuardianRequestDeliveries` in `guardian-delivery-recorder.ts` -- never by calling the gateway client's `createGuardianRequestDelivery` directly. That sink is the single place the card-to-request addressing convention lives (conversation id for the in-app card; chat + channel-native `ts` for channel cards), so the path that writes a delivery row cannot drift from the paths that read it back to withdraw a card -- the drift that previously fanned this logic into four divergent copies. (Tests may seed delivery rows directly for fixtures.)