@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/__tests__/media-stream-server-integration.test.ts

@@ -385,7 +385,13 @@ mock.module("../runtime/access-request-helper.js", () => ({
 // Gateway guardian-request client polled by the guardian wait controller.
 let mockGuardianRequest: { status: string } | null = null;
 const mockGetGuardianRequest = jest.fn(async () => mockGuardianRequest);
+// Spread the actual module so transitive importers of names this
+// factory does not stub keep resolving (a partial factory breaks at
+// import time when the graph gains a new named import).
+const actualGatewayGuardianRequests =
+  await import("../channels/gateway-guardian-requests.js");
 mock.module("../channels/gateway-guardian-requests.js", () => ({
+  ...actualGatewayGuardianRequests,
   getGuardianRequestOrNull: mockGetGuardianRequest,
 }));
 

package/src/__tests__/non-member-access-request.test.ts

@@ -318,6 +318,18 @@ describe("non-member access request notification", () => {
       kind: "access_request",
     });
     expect(pending.length).toBe(1);
+
+    // A pending row past its deadline never dedupes: it can sit pending
+    // until the sweep expires it, it is already undecidable, and absorbing
+    // the fresh attempt would silently drop the new guardian notification.
+    pending[0].expiresAt = Date.now() - 1000;
+    const req3 = buildInboundRequest({
+      externalMessageId: `msg-third-${Date.now()}`,
+      content: "Still hoping to get access.",
+    });
+    await handleChannelInbound(req3, undefined, TEST_BEARER_TOKEN);
+
+    expect(emitSignalCalls.length).toBe(2);
   });
 
   // A bare guardian deny (a `denied` request with no durable contact seeded)

package/src/__tests__/notification-discord-adapter.test.ts

@@ -10,20 +10,44 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const dmOpens: string[] = [];
-const sendCalls: Array<{ channelId: string; text: string }> = [];
+const sendCalls: Array<{
+  channelId: string;
+  text: string;
+  approval?: { requestId: string } | undefined;
+}> = [];
 const editCalls: Array<{ channelId: string; messageId: string; text: string }> =
   [];
 
+// Spread the actual module: the real send.js is imported below for its
+// error class and transitively needs api.js's other named exports.
+const actualApi = await import("../messaging/providers/discord/api.js");
 mock.module("../messaging/providers/discord/api.js", () => ({
+  ...actualApi,
   openDiscordDmChannel: async (userId: string) => {
     dmOpens.push(userId);
     return `dm-for-${userId}`;
   },
 }));
 
+const actualSend = await import("../messaging/providers/discord/send.js");
 mock.module("../messaging/providers/discord/send.js", () => ({
-  sendDiscordReply: async (target: { channelId: string }, text: string) => {
-    sendCalls.push({ channelId: target.channelId, text });
+  DiscordPartialSendError: actualSend.DiscordPartialSendError,
+  sendDiscordReply: async (
+    target: { channelId: string },
+    text: string,
+    approval?: { requestId: string },
+  ) => {
+    if (approval && failRichSends) {
+      throw failRichSends === "partial"
+        ? new actualSend.DiscordPartialSendError(
+            new Error("final chunk rejected"),
+            2,
+            "tail of the card",
+            "1500",
+          )
+        : new Error("simulated component rejection");
+    }
+    sendCalls.push({ channelId: target.channelId, text, approval });
     return { lastMessageId: String(2000 + sendCalls.length) };
   },
   editDiscordMessage: async (
@@ -68,10 +92,13 @@ function makeDestination(
   };
 }
 
+let failRichSends: boolean | "partial" = false;
+
 beforeEach(() => {
   dmOpens.length = 0;
   sendCalls.length = 0;
   editCalls.length = 0;
+  failRichSends = false;
 });
 
 describe("DiscordAdapter.send", () => {
@@ -87,7 +114,51 @@ describe("DiscordAdapter.send", () => {
     expect(sendCalls[0].text).toContain("Your task finished.");
   });
 
-  test("approval notifications carry the typed-command instructions", async () => {
+  test("approval notifications deliver with component buttons", async () => {
+    const adapter = new DiscordAdapter();
+    const result = await adapter.send(
+      makePayload({
+        approvalContext: {
+          requestId: "req-1",
+          actions: [{ id: "approve_once", label: "Approve once" }],
+          plainTextFallback: 'Reply "approve" or "reject" to decide.',
+        },
+      }),
+      makeDestination(),
+    );
+
+    expect(result.success).toBe(true);
+    expect(sendCalls).toHaveLength(1);
+    expect(sendCalls[0].approval?.requestId).toBe("req-1");
+    // The rich card carries no typed-command tail; buttons are the controls.
+    expect(sendCalls[0].text).not.toContain("Reply");
+  });
+
+  test("a mid-card failure completes the card instead of replaying it", async () => {
+    failRichSends = "partial";
+    const adapter = new DiscordAdapter();
+    const result = await adapter.send(
+      makePayload({
+        approvalContext: {
+          requestId: "req-1",
+          actions: [{ id: "approve_once", label: "Approve once" }],
+          plainTextFallback: 'Reply "approve" or "reject" to decide.',
+        },
+      }),
+      makeDestination(),
+    );
+
+    expect(result.success).toBe(true);
+    expect(sendCalls).toHaveLength(1);
+    // Only the undelivered remainder goes out, with the typed instructions;
+    // the delivered chunks are never sent twice.
+    expect(sendCalls[0].approval).toBeUndefined();
+    expect(sendCalls[0].text).toContain("tail of the card");
+    expect(sendCalls[0].text).toContain('Reply "approve" or "reject"');
+  });
+
+  test("a failed rich delivery falls back to the typed-command card", async () => {
+    failRichSends = true;
     const adapter = new DiscordAdapter();
     const result = await adapter.send(
       makePayload({
@@ -102,6 +173,7 @@ describe("DiscordAdapter.send", () => {
 
     expect(result.success).toBe(true);
     expect(sendCalls).toHaveLength(1);
+    expect(sendCalls[0].approval).toBeUndefined();
     expect(sendCalls[0].text).toContain(
       'Reply "approve" or "reject" to decide.',
     );

package/src/__tests__/oauth-commands-routes.test.ts

@@ -717,6 +717,27 @@ describe("POST oauth/request", () => {
     expect(req.body).toEqual({ title: "Sheet" });
   });
 
+  test("decodes a base64 request body into a Buffer", async () => {
+    const binary = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0xff, 0x00]);
+
+    await getRoute("POST", "oauth/request").handler(
+      makeArgs({
+        body: {
+          provider: "google",
+          url: "https://api.google.com/upload/drive/v3/files",
+          method: "POST",
+          headers: { "Content-Type": "application/pdf" },
+          parsed_data: binary.toString("base64"),
+          body_encoding: "base64",
+        },
+      }),
+    );
+
+    const req = mockResolveRequests[0] as { body: unknown };
+    expect(Buffer.isBuffer(req.body)).toBe(true);
+    expect(Buffer.from(req.body as Uint8Array).equals(binary)).toBe(true);
+  });
+
   test("base64-encodes binary response bodies for the JSON envelope", async () => {
     const binary = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0xff, 0x00]);
     mockResolveResponse = {

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

@@ -2051,3 +2051,66 @@ describe("FireworksProvider reasoning_effort ceiling", () => {
     expect(lastCreateParams!.reasoning_effort).toBe("max");
   });
 });
+
+// GLM 5.3 accepts only low|high|max and 4xxes on the in-between tiers, so
+// the catalog's `supportedEfforts` snaps them down (see
+// snapReasoningEffortToSupported).
+describe("FireworksProvider sparse reasoning_effort support (GLM 5.3)", () => {
+  beforeEach(() => {
+    fakeChunks = [];
+    lastCreateParams = null;
+  });
+
+  const send = async (
+    model: string,
+    effort: "none" | "low" | "medium" | "high" | "xhigh" | "max",
+  ) => {
+    const fw = new FireworksProvider("fw-key", model);
+    await fw.sendMessage([userMsg("hi")], {
+      systemPrompt: "system",
+      config: { effort },
+    });
+    return lastCreateParams!.reasoning_effort;
+  };
+
+  test('GLM 5.3 snaps "medium" down to "low"', async () => {
+    expect(await send("accounts/fireworks/models/glm-5p3", "medium")).toBe(
+      "low",
+    );
+  });
+
+  test('GLM 5.3 snaps "xhigh" down to "high"', async () => {
+    expect(await send("accounts/fireworks/models/glm-5p3", "xhigh")).toBe(
+      "high",
+    );
+  });
+
+  test("GLM 5.3 forwards supported values verbatim", async () => {
+    expect(await send("accounts/fireworks/models/glm-5p3", "low")).toBe("low");
+    expect(await send("accounts/fireworks/models/glm-5p3", "high")).toBe(
+      "high",
+    );
+    expect(await send("accounts/fireworks/models/glm-5p3", "max")).toBe("max");
+  });
+
+  test('GLM 5.3 Flash snaps "medium"/"xhigh" the same way', async () => {
+    expect(
+      await send("accounts/fireworks/models/glm-5p3-flash", "medium"),
+    ).toBe("low");
+    expect(await send("accounts/fireworks/models/glm-5p3-flash", "xhigh")).toBe(
+      "high",
+    );
+  });
+
+  test('effort: "none" is not snapped (opt-out keeps its own handling)', async () => {
+    expect(await send("accounts/fireworks/models/glm-5p3", "none")).toBe(
+      "none",
+    );
+  });
+
+  test("models without supportedEfforts are unaffected", async () => {
+    expect(
+      await send("accounts/fireworks/models/deepseek-v4-pro", "medium"),
+    ).toBe("medium");
+  });
+});

package/src/__tests__/outbound-slack-persistence.test.ts

@@ -185,7 +185,7 @@ import { setConfig } from "./helpers/set-config.js";
 function makeDeps(
   conversationId: string,
   overrides: {
-    assistantMessageChannel?: "slack" | "vellum" | "telegram";
+    assistantMessageChannel?: "slack" | "vellum" | "telegram" | "discord";
     requesterChatId?: string;
     requesterTimezoneLabel?: string;
     clientTimezone?: string;
@@ -518,7 +518,119 @@ describe("outbound assistant Slack metadata persistence", () => {
 
     const persisted = lastAssistantPersisted();
     expect(persisted.metadata).toBeDefined();
-    // Non-Slack channels must leave the existing metadata shape untouched.
+    // Non-Slack channels must leave the existing metadata shape untouched,
+    // and a vellum turn is not a provider message, so it gets no neutral
+    // envelope either.
     expect(persisted.metadata?.slackMeta).toBeUndefined();
+    expect(persisted.metadata?.providerMeta).toBeUndefined();
+  });
+
+  test("stamps a partial neutral envelope on non-Slack channel replies", async () => {
+    const conversationId = "conv-discord-stamp";
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "discord",
+      requesterChatId: "9990001112223334445",
+    });
+    await handleLlmCallStarted(state, deps);
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("discord reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    const providerMetaRaw = persisted.metadata?.providerMeta;
+    expect(typeof providerMetaRaw).toBe("string");
+    const providerMeta = JSON.parse(providerMetaRaw as string) as Record<
+      string,
+      unknown
+    >;
+    expect(providerMeta.source).toBe("discord");
+    expect(providerMeta.conversationExternalId).toBe("9990001112223334445");
+    expect(providerMeta.eventKind).toBe("message");
+    // Persistence runs BEFORE the transport posts the message, so the
+    // provider-assigned id is not yet known; the post-send reconciliation in
+    // `deliverReplyViaCallback` fills `messageId` once the transport returns
+    // it. `threadId` is never stamped: a value there asserts a thread exists.
+    expect(providerMeta.messageId).toBeUndefined();
+    expect(providerMeta.threadId).toBeUndefined();
+    expect(persisted.metadata?.slackMeta).toBeUndefined();
+  });
+
+  test("post-send reconciliation patches messageId into the neutral envelope", async () => {
+    const conversationId = "conv-discord-reconcile";
+    const chatId = "9990001112223334445";
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "discord",
+      requesterChatId: chatId,
+    });
+    await handleLlmCallStarted(state, deps);
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("discord reconciliation reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    nextDeliveryTs = "1234567890123456789";
+    await deliverReplyViaCallback(
+      conversationId,
+      chatId,
+      "http://gateway/deliver/discord",
+      "assistant-1",
+      { messageId: persisted.id },
+    );
+
+    const row = persistedRows.find(
+      (candidate) => candidate.id === persisted.id,
+    );
+    expect(typeof row?.metadata).toBe("string");
+    const envelope = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const reconciled = JSON.parse(envelope.providerMeta as string) as Record<
+      string,
+      unknown
+    >;
+    expect(reconciled.messageId).toBe("1234567890123456789");
+    expect(reconciled.source).toBe("discord");
+    expect(reconciled.conversationExternalId).toBe(chatId);
+
+    // A later report with a NEW id is another post of the same reply (a
+    // split at a tool boundary): it lands in additionalMessageIds and the
+    // first id keeps naming the row.
+    nextDeliveryTs = "8888888888888888888";
+    await deliverReplyViaCallback(
+      conversationId,
+      chatId,
+      "http://gateway/deliver/discord",
+      "assistant-1",
+      { messageId: persisted.id },
+    );
+    const rowAfter = persistedRows.find(
+      (candidate) => candidate.id === persisted.id,
+    );
+    const metaAfter = JSON.parse(
+      JSON.parse(rowAfter!.metadata!).providerMeta as string,
+    ) as Record<string, unknown>;
+    expect(metaAfter.messageId).toBe("1234567890123456789");
+    expect(metaAfter.additionalMessageIds).toEqual(["8888888888888888888"]);
+
+    // A redelivery reporting an already-recorded id changes nothing.
+    nextDeliveryTs = "8888888888888888888";
+    await deliverReplyViaCallback(
+      conversationId,
+      chatId,
+      "http://gateway/deliver/discord",
+      "assistant-1",
+      { messageId: persisted.id },
+    );
+    const rowRedelivered = persistedRows.find(
+      (candidate) => candidate.id === persisted.id,
+    );
+    const metaRedelivered = JSON.parse(
+      JSON.parse(rowRedelivered!.metadata!).providerMeta as string,
+    ) as Record<string, unknown>;
+    expect(metaRedelivered.additionalMessageIds).toEqual([
+      "8888888888888888888",
+    ]);
   });
 });

package/src/__tests__/persist-unsendable-image-downscale.test.ts

@@ -33,6 +33,7 @@ mock.module("../agent/image-optimize.js", () => ({
   }),
 }));
 
+import { uploadAttachment } from "../persistence/attachments-store.js";
 import {
   addMessage,
   createConversation,
@@ -40,7 +41,10 @@ import {
 } from "../persistence/conversation-crud.js";
 import { getDb, getMemorySqlite } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
-import { persistUnsendableImageDowngrades } from "../plugins/defaults/image-recovery/recover.js";
+import {
+  persistUnsendableImageDowngrades,
+  unsendableImageReplacement,
+} from "../plugins/defaults/image-recovery/recover.js";
 import { base64Source } from "../providers/media-resolve.js";
 import type { ContentBlock } from "../providers/types.js";
 
@@ -147,6 +151,64 @@ describe("persistUnsendableImageDowngrades (downscalable host)", () => {
     ).toBe(SHRUNK_DATA);
   });
 
+  /** The resize replaces the block's whole source, so a reference-backed image
+   *  loses `source.attachmentId` along with the reference. The id has to be
+   *  derived from either shape and re-stamped, or the durable rewrite untags a
+   *  camera frame permanently. */
+  test("a resized workspace_ref keeps its attachment id on the rebuilt block", async () => {
+    const stored = await uploadAttachment(
+      "frame.png",
+      "image/png",
+      oversizedPngBase64(),
+    );
+    const referenceBlock = {
+      type: "image",
+      source: {
+        type: "workspace_ref",
+        media_type: "image/png",
+        attachmentId: stored.id,
+        sizeBytes: 128,
+        // Persisted references carry the dimension hints the provider caps are
+        // judged against (see `attachmentsToReferenceBlocks`).
+        width: 12000,
+        height: 9000,
+      },
+    } as Extract<ContentBlock, { type: "image" }>;
+
+    const replacement = await unsendableImageReplacement(referenceBlock);
+
+    // The source was flattened to the shrunk inline bytes...
+    expect(replacement).toMatchObject({
+      type: "image",
+      source: { type: "base64", data: SHRUNK_DATA },
+    });
+    // ...and the link to the attachment row survived the flattening.
+    expect((replacement as { _attachmentId?: string })._attachmentId).toBe(
+      stored.id,
+    );
+  });
+
+  /** An inline resize input carries its id on the top-level field instead. */
+  test("a resized inline block keeps its top-level attachment id", async () => {
+    const inlineBlock = {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: "image/png",
+        data: oversizedPngBase64(),
+      },
+      _attachmentId: "att-inline-1",
+    } as Extract<ContentBlock, { type: "image" }>;
+
+    const replacement = await unsendableImageReplacement(inlineBlock);
+
+    expect(replacement).toMatchObject({
+      type: "image",
+      source: { type: "base64", data: SHRUNK_DATA },
+      _attachmentId: "att-inline-1",
+    });
+  });
+
   /** Re-running is a no-op: the downscaled payload is within limits. */
   test("is idempotent after a downscale rewrite", async () => {
     // GIVEN a conversation whose oversized screenshot was already downscaled

package/src/__tests__/persist-unsendable-image.test.ts

@@ -392,6 +392,25 @@ describe("unsendableImageReplacement", () => {
     });
   });
 
+  /** Relabeling rebuilds the block, and the rebuilt form is written back to
+   *  the stored row. Losing the internal attachment id there would untag a
+   *  camera frame for good, so the relabel carries it across. */
+  test("relabeling preserves the internal attachment id", async () => {
+    const pngData = makePngBase64(1024, 768);
+    const mislabeled = {
+      ...(imageBlock(pngData, "image/jpeg") as Extract<
+        ContentBlock,
+        { type: "image" }
+      >),
+      _attachmentId: "att-frame-1",
+    };
+    const replacement = await unsendableImageReplacement(mislabeled);
+    expect(replacement).toMatchObject({
+      type: "image",
+      _attachmentId: "att-frame-1",
+    });
+  });
+
   /** Relabeling a persisted (workspace_ref) image keeps the reference shape —
    *  inlining it would bake the full payload into the stored message row. */
   test("relabels a mislabeled workspace_ref without inlining the payload", async () => {

package/src/__tests__/plugin-app-serve-routes.test.ts

@@ -271,10 +271,10 @@ describe("multi-file plugin apps compile on open", () => {
     expect(result.html).toContain("Compiled Board");
     expect(result.html).not.toContain("not been compiled");
     expect(result.origin).toBe("plugin:acme");
-    // The daemon must not write dist/ into the read-only plugin tree — that is
+    // The daemon must not write dist/ into the read-only plugin tree. That is
     // the monitor's job. The on-open build happened in a throwaway temp dir.
     expect(existsSync(join(appDir, "dist"))).toBe(false);
-  });
+  }, 15_000);
 
   test("apps_open on a malformed plugin app (no src/, no dist/) serves the fallback, not a 500", async () => {
     // An app dir with neither a root index.html nor src/ nor dist/ is

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -86,6 +86,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../../../messaging/providers/slack/message-metadata.js",
     "../../../../../persistence/auto-analysis-constants.js",
     "../../../../../persistence/checkpoints.js",
+    "../../../../../persistence/conversation-types.js",
     "../../../../../persistence/db-connection.js",
     "../../../../../persistence/embeddings/embed.js",
     "../../../../../persistence/embeddings/embedding-backend.js",

package/src/__tests__/process-message-background-slack.test.ts

@@ -2,7 +2,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 mock.module("../persistence/attachments-store.js", () => ({
   getAttachmentsByIds: () => [],
-  getSourcePathsForAttachments: () => new Map<string, string>(),
+  resolveAttachmentsForPersist: () => [],
 }));
 
 mock.module("../channels/gateway-guardian-requests.js", () => ({

package/src/__tests__/process-message-display-content.test.ts

@@ -27,7 +27,7 @@ let validateShouldFail = false;
 
 mock.module("../persistence/attachments-store.js", () => ({
   getAttachmentsByIds: () => [],
-  getSourcePathsForAttachments: () => new Map<string, string>(),
+  resolveAttachmentsForPersist: () => [],
   attachmentExists: () => false,
   linkAttachmentToMessage: () => "att-stored",
   scopeAttachmentToMessageConversation: () => null,

package/src/__tests__/processing-flag-persist-failure.test.ts

@@ -97,11 +97,6 @@ mock.module("../persistence/attachments-store.js", () => ({
   linkAttachmentToMessage: () => {},
 }));
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => null,
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 mock.module("../memory/query-builder.js", () => ({
   buildMemoryQuery: () => "",
 }));

package/src/__tests__/prompt-cache-cross-turn-stability.test.ts

@@ -165,23 +165,6 @@ mock.module("../persistence/attachments-store.js", () => ({
   uploadAttachment: () => ({ id: "att-1" }),
   linkAttachmentToMessage: () => {},
 }));
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    reason: null,
-    provider: "mock",
-    model: "mock",
-    injectedText: "",
-    semanticHits: 0,
-    mergedCount: 0,
-    selectedCount: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-    topCandidates: [],
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
 mock.module("../memory/query-builder.js", () => ({
   buildMemoryQuery: () => "",
 }));

package/src/__tests__/qdrant-manager.test.ts

@@ -109,6 +109,12 @@ describe("QdrantManager", () => {
     });
   });
 
+  test("falls back to the x64 zip release on Windows arm64", () => {
+    expect(resolveQdrantReleaseAsset("win32", "arm64")).toEqual(
+      resolveQdrantReleaseAsset("win32", "x64"),
+    );
+  });
+
   // ── getUrl ───────────────────────────────────────────────────
 
   describe("getUrl", () => {