@vellumai/assistant 0.11.10 → 0.11.11-staging.1

package/src/__tests__/host-transfer-routes-targeted.test.ts

@@ -35,6 +35,7 @@ mock.module("../runtime/pending-interactions.js", () => ({
 
 // Per-test controls for the proxy stub
 let stubTargetClientId: string | null = null;
+let stubTargetActorPrincipalId: string | undefined;
 const getTransferContentCalls: string[] = [];
 const receiveTransferContentCalls: string[] = [];
 const resolveTransferResultCalls: string[] = [];
@@ -50,6 +51,9 @@ mock.module("../daemon/host-transfer-proxy.js", () => ({
           return stubTargetClientId;
         },
         getTargetActorPrincipalIdForTransfer(_transferId: string) {
+          if (stubTargetActorPrincipalId !== undefined) {
+            return stubTargetActorPrincipalId;
+          }
           return stubTargetClientId
             ? clientActors.get(stubTargetClientId)
             : undefined;
@@ -139,6 +143,7 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
   beforeEach(() => {
     pendingStore.clear();
     stubTargetClientId = null;
+    stubTargetActorPrincipalId = undefined;
     getTransferContentCalls.length = 0;
     clientActors.clear();
   });
@@ -236,6 +241,30 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
       expect(result).toBeInstanceOf(Uint8Array);
       expect(getTransferContentCalls).toContain(TEST_TRANSFER_ID);
     });
+
+    test("rejects a different actor when the transfer recorded a source actor", () => {
+      stubTargetClientId = null;
+      stubTargetActorPrincipalId = "principal-owner";
+      expect(() =>
+        handleTransferContentGet({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: { "x-vellum-actor-principal-id": "principal-attacker" },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(getTransferContentCalls).toHaveLength(0);
+    });
+
+    test("accepts the recorded source actor on an untargeted transfer", async () => {
+      stubTargetClientId = null;
+      stubTargetActorPrincipalId = "principal-owner";
+      const result = await handleTransferContentGet({
+        pathParams: { transferId: TEST_TRANSFER_ID },
+        headers: { "x-vellum-actor-principal-id": "principal-owner" },
+      });
+
+      expect(result).toBeInstanceOf(Uint8Array);
+      expect(getTransferContentCalls).toContain(TEST_TRANSFER_ID);
+    });
   });
 
   // ── 5. Same-user actor binding (defense-in-depth) ─────────────────────────
@@ -289,6 +318,7 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
   beforeEach(() => {
     pendingStore.clear();
     stubTargetClientId = null;
+    stubTargetActorPrincipalId = undefined;
     receiveTransferContentCalls.length = 0;
     clientActors.clear();
   });
@@ -408,6 +438,38 @@ describe("handleTransferContentPut — Phase 3 targetClientId guard", () => {
       expect(result).toEqual({ accepted: true });
       expect(receiveTransferContentCalls).toContain(TEST_TRANSFER_ID);
     });
+
+    test("rejects a different actor when the transfer recorded a source actor", async () => {
+      stubTargetClientId = null;
+      stubTargetActorPrincipalId = "principal-owner";
+      await expect(
+        handleTransferContentPut({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: {
+            "x-vellum-actor-principal-id": "principal-attacker",
+            "x-transfer-sha256": "abc",
+          },
+          rawBody: new Uint8Array(Buffer.from("data")),
+        }),
+      ).rejects.toBeInstanceOf(ForbiddenError);
+      expect(receiveTransferContentCalls).toHaveLength(0);
+    });
+
+    test("accepts the recorded source actor on an untargeted transfer", async () => {
+      stubTargetClientId = null;
+      stubTargetActorPrincipalId = "principal-owner";
+      const result = await handleTransferContentPut({
+        pathParams: { transferId: TEST_TRANSFER_ID },
+        headers: {
+          "x-vellum-actor-principal-id": "principal-owner",
+          "x-transfer-sha256": "abc",
+        },
+        rawBody: new Uint8Array(Buffer.from("data")),
+      });
+
+      expect(result).toEqual({ accepted: true });
+      expect(receiveTransferContentCalls).toContain(TEST_TRANSFER_ID);
+    });
   });
 
   // ── 5. Same-user actor binding (defense-in-depth) ─────────────────────────
@@ -469,6 +531,7 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
   beforeEach(() => {
     pendingStore.clear();
     stubTargetClientId = null;
+    stubTargetActorPrincipalId = undefined;
     resolveTransferResultCalls.length = 0;
     clientActors.clear();
   });
@@ -599,6 +662,29 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
 
       expect(result).toEqual({ accepted: true });
     });
+
+    test("rejects a different actor when the pending request recorded a source actor", () => {
+      registerPending({ targetActorPrincipalId: "principal-owner" });
+      expect(() =>
+        handleTransferResult({
+          body: resultBody(),
+          headers: { "x-vellum-actor-principal-id": "principal-attacker" },
+        }),
+      ).toThrow(ForbiddenError);
+      expect(resolveTransferResultCalls).toHaveLength(0);
+      expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
+    });
+
+    test("accepts the recorded source actor on an untargeted pending request", async () => {
+      registerPending({ targetActorPrincipalId: "principal-owner" });
+      const result = await handleTransferResult({
+        body: resultBody(),
+        headers: { "x-vellum-actor-principal-id": "principal-owner" },
+      });
+
+      expect(result).toEqual({ accepted: true });
+      expect(resolveTransferResultCalls).toContain(TEST_REQUEST_ID);
+    });
   });
 
   // ── 5. Same-user actor binding (defense-in-depth) ─────────────────────────

package/src/__tests__/llm-schema.test.ts

@@ -358,4 +358,36 @@ describe("LLMSchema", () => {
     });
     expect(result.success).toBe(true);
   });
+
+  test("a mix profile with inputModalities is rejected", () => {
+    const result = LLMSchema.safeParse({
+      profiles: {
+        combo: {
+          mix: [
+            { profile: "fast", weight: 1 },
+            { profile: "slow", weight: 1 },
+          ],
+          inputModalities: { image: { enabled: true, supported: true } },
+        },
+        fast: { provider: "anthropic", model: "claude-haiku-4-5" },
+        slow: { provider: "anthropic", model: "claude-opus-4-6" },
+      },
+    });
+    expect(result.success).toBe(false);
+  });
+
+  test("a custom profile may persist inputModalities", () => {
+    const parsed = LLMSchema.parse({
+      profiles: {
+        gateway: {
+          provider: "openai-compatible",
+          model: "qwen2.5-vl",
+          inputModalities: { image: { enabled: true, supported: true } },
+        },
+      },
+    });
+    expect(parsed.profiles.gateway?.inputModalities).toEqual({
+      image: { enabled: true, supported: true },
+    });
+  });
 });

package/src/__tests__/mcp-config-secret-boundary.test.ts

@@ -82,6 +82,8 @@ mock.module("../persistence/embeddings/embedding-backend.js", () => ({
     vectors: [],
   }),
   geminiCacheExtras: () => [],
+  customCacheExtras: () => [],
+  durableEmbeddingCacheExtras: () => [],
   generateSparseEmbedding: () => ({ indices: [], values: [] }),
   getMemoryBackendStatus: async () => ({
     enabled: false,

package/src/__tests__/memory-config-file-parity.test.ts

@@ -101,6 +101,24 @@ describe("memory config file parity", () => {
     expect(memory.embeddings.provider).toBe("openai");
   });
 
+  test("custom embedding endpoint knobs are visible and identical", () => {
+    writeConfig({
+      memory: {
+        embeddings: {
+          provider: "custom",
+          baseUrl: "http://127.0.0.1:4000/v1",
+          customModel: "text-embedding-3-small",
+          customDimensions: 1024,
+        },
+      },
+    });
+    const memory = expectParity();
+    expect(memory.embeddings.provider).toBe("custom");
+    expect(memory.embeddings.baseUrl).toBe("http://127.0.0.1:4000/v1");
+    expect(memory.embeddings.customModel).toBe("text-embedding-3-small");
+    expect(memory.embeddings.customDimensions).toBe(1024);
+  });
+
   test("cross-field invariant: segmentation overlap >= target falls back like the loader", () => {
     writeConfig({
       memory: {

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -202,6 +202,21 @@ beforeEach(() => {
 });
 
 describe("user-prompt-submit hook (memory retrieval)", () => {
+  test("does not run on a memory-retrospective wake", async () => {
+    const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
+      makeFakeGraphMemory();
+    const conversation = installConversation(memory, { trusted: true });
+    conversation.currentCallSite = "memoryRetrospective";
+    const ctx = makeHookCtx({ conversationId: "conv-retro" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(recordPkbQueryVectorsMock).not.toHaveBeenCalled();
+    expect(applyRuntimeInjectionsMock).not.toHaveBeenCalled();
+    expect(updateMessageMetadataMock).not.toHaveBeenCalled();
+  });
+
   test("voice front door skips serial legacy retrieval", async () => {
     const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
       makeFakeGraphMemory();

package/src/__tests__/messaging-send-tool.test.ts

@@ -44,14 +44,17 @@ const telegramProvider = makeProvider("telegram", "Telegram");
 const outlookProvider = makeProvider("outlook", "Outlook");
 let provider: MessagingProvider = phoneProvider;
 
+let connection: OAuthConnection | undefined = undefined;
+
 mock.module("../config/bundled-skills/messaging/tools/shared.js", () => ({
   resolveProvider: () => provider,
-  getProviderConnection: () => undefined,
+  getProviderConnection: () => connection,
   ok: (content: string) => ({ content, isError: false }),
   err: (content: string) => ({ content, isError: true }),
   extractHeader: () => "",
   parseAddressList: () => [],
   extractEmail: (a: string) => a.toLowerCase(),
+  isMailboxAddress: (value: string) => value.includes("@"),
 }));
 
 // ── Sent-post record dependency mocks ──
@@ -75,6 +78,38 @@ const recordDeliveredChannelPostMock = mock(
   async (_post: Record<string, unknown>) => ({ messageId: "row-1" }),
 );
 
+const mockOutlookCreateDraft = mock(
+  async (_conn: OAuthConnection, _draft: Record<string, unknown>) => ({
+    id: "outlook-draft-1",
+    conversationId: "conv-draft",
+    subject: "Docs",
+    webLink: "https://outlook.office.com/mail/drafts/id/outlook-draft-1",
+  }),
+);
+
+const mockOutlookCreateReplyDraft = mock(
+  async (_conn: OAuthConnection, _messageId: string, _comment?: string) => ({
+    id: "outlook-reply-draft-1",
+    conversationId: "conv-reply",
+    subject: "Re: Hello",
+    webLink: "https://outlook.office.com/mail/drafts/id/outlook-reply-draft-1",
+  }),
+);
+
+mock.module("../messaging/providers/outlook/client.js", () => ({
+  createDraft: mockOutlookCreateDraft,
+  createReplyDraft: mockOutlookCreateReplyDraft,
+  toOutlookFileAttachments: (
+    attachments: Array<{ filename: string; mimeType: string; data: Buffer }>,
+  ) =>
+    attachments.map((att) => ({
+      "@odata.type": "#microsoft.graph.fileAttachment",
+      name: att.filename,
+      contentType: att.mimeType,
+      contentBytes: att.data.toString("base64"),
+    })),
+}));
+
 mock.module("../persistence/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
   isConversationProcessing: () => false,
@@ -99,7 +134,10 @@ import { run } from "../config/bundled-skills/messaging/tools/messaging-send.js"
 describe("messaging-send tool", () => {
   beforeEach(() => {
     provider = phoneProvider;
+    connection = undefined;
     sendMessageMock.mockClear();
+    mockOutlookCreateDraft.mockClear();
+    mockOutlookCreateReplyDraft.mockClear();
     getConversationMock.mockClear();
     syncMessageToDiskMock.mockClear();
     resolveProactiveHomeConversationMock.mockClear();
@@ -195,11 +233,15 @@ describe("messaging-send tool", () => {
     expect(sendMessageMock).not.toHaveBeenCalled();
   });
 
-  test("reads and forwards attachments to attachment-capable non-Gmail providers", async () => {
+  test("reads and forwards attachments onto an Outlook draft", async () => {
     const dir = mkdtempSync(join(tmpdir(), "msg-send-att-"));
     const filePath = join(dir, "report.pdf");
     writeFileSync(filePath, "pdf-bytes");
     provider = outlookProvider;
+    connection = {
+      id: "outlook-conn-1",
+      provider: "outlook",
+    } as OAuthConnection;
 
     try {
       const result = await run(
@@ -219,17 +261,21 @@ describe("messaging-send tool", () => {
       );
 
       expect(result.isError).toBe(false);
-      const options = sendMessageMock.mock.calls[0][3] as {
-        attachments?: Array<{
-          filename: string;
-          mimeType: string;
-          data: Buffer;
-        }>;
-      };
-      expect(options.attachments).toHaveLength(1);
-      expect(options.attachments?.[0]?.filename).toBe("report.pdf");
-      expect(options.attachments?.[0]?.mimeType).toBe("application/pdf");
-      expect(options.attachments?.[0]?.data.toString()).toBe("pdf-bytes");
+      expect(result.content).toContain("Outlook draft created");
+      expect(result.content).toContain("Draft ID: outlook-draft-1");
+      expect(sendMessageMock).not.toHaveBeenCalled();
+      expect(mockOutlookCreateDraft).toHaveBeenCalledTimes(1);
+      expect(mockOutlookCreateDraft).toHaveBeenCalledWith(
+        connection,
+        expect.objectContaining({
+          subject: "Docs",
+          body: { contentType: "text", content: "see attached" },
+          toRecipients: [
+            { emailAddress: { address: "user@example.com" } },
+          ],
+          attachments: [expect.objectContaining({ name: "report.pdf" })],
+        }),
+      );
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -305,6 +351,10 @@ describe("messaging-send tool", () => {
 
   test("records nothing for a provider that is not a channel", async () => {
     provider = outlookProvider;
+    connection = {
+      id: "outlook-conn-1",
+      provider: "outlook",
+    } as OAuthConnection;
 
     await run(
       {
@@ -324,6 +374,102 @@ describe("messaging-send tool", () => {
     expect(recordDeliveredChannelPostMock).not.toHaveBeenCalled();
   });
 
+  test("creates an Outlook draft without a To address when conversation_id is not an email", async () => {
+    provider = outlookProvider;
+    connection = {
+      id: "outlook-conn-1",
+      provider: "outlook",
+    } as OAuthConnection;
+
+    const result = await run(
+      {
+        platform: "outlook",
+        conversation_id: "drafts",
+        text: "Hey team, here is the update.",
+        subject: "Team update",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-1",
+        assistantId: "ast-alpha",
+        trustClass: "guardian" as const,
+      },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Outlook draft created");
+    expect(result.content).toContain("No recipient set");
+    expect(result.content).toContain("Open it:");
+    expect(sendMessageMock).not.toHaveBeenCalled();
+    expect(mockOutlookCreateDraft).toHaveBeenCalledWith(
+      connection,
+      expect.objectContaining({
+        subject: "Team update",
+        body: {
+          contentType: "text",
+          content: "Hey team, here is the update.",
+        },
+      }),
+    );
+    const draftArg = mockOutlookCreateDraft.mock.calls[0][1];
+    expect(draftArg.toRecipients).toBeUndefined();
+  });
+
+  test("creates an Outlook reply draft instead of sending when in_reply_to is set", async () => {
+    provider = outlookProvider;
+    connection = {
+      id: "outlook-conn-1",
+      provider: "outlook",
+    } as OAuthConnection;
+
+    const result = await run(
+      {
+        platform: "outlook",
+        conversation_id: "user@example.com",
+        text: "Thanks, that works.",
+        in_reply_to: "AAMk-original",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-1",
+        assistantId: "ast-alpha",
+        trustClass: "guardian" as const,
+      },
+    );
+
+    expect(result.isError).toBe(false);
+    expect(mockOutlookCreateReplyDraft).toHaveBeenCalledWith(
+      connection,
+      "AAMk-original",
+      "Thanks, that works.",
+    );
+    expect(sendMessageMock).not.toHaveBeenCalled();
+    expect(result.content).toContain("outlook-reply-draft-1");
+  });
+
+  test("errors when Outlook is not connected", async () => {
+    provider = outlookProvider;
+    connection = undefined;
+
+    const result = await run(
+      {
+        platform: "outlook",
+        conversation_id: "user@example.com",
+        text: "hello",
+      },
+      {
+        workingDir: "/tmp",
+        conversationId: "conv-1",
+        assistantId: "ast-alpha",
+        trustClass: "guardian" as const,
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("OAuth connection");
+    expect(mockOutlookCreateDraft).not.toHaveBeenCalled();
+  });
+
   test("a record failure does not fail the send", async () => {
     provider = telegramProvider;
     getConversationMock.mockImplementation(() => ({

package/src/__tests__/messaging-shared.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+
+import { isMailboxAddress } from "../config/bundled-skills/messaging/tools/shared.js";
+
+describe("isMailboxAddress", () => {
+  test("accepts a bare email", () => {
+    expect(isMailboxAddress("user@example.com")).toBe(true);
+  });
+
+  test("accepts a display-name address", () => {
+    expect(isMailboxAddress("Alice <alice@example.org>")).toBe(true);
+  });
+
+  test("rejects placeholders used when the recipient is unknown", () => {
+    expect(isMailboxAddress("drafts")).toBe(false);
+    expect(isMailboxAddress("outlook")).toBe(false);
+    expect(isMailboxAddress("")).toBe(false);
+  });
+});