@vellumai/assistant 0.11.2 → 0.11.3-staging.2

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

@@ -709,7 +709,7 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain("signed in as a different user");
       expect(sentMessages).toHaveLength(0);
     });
 
@@ -738,7 +738,7 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain("no authenticated actor");
       expect(sentMessages).toHaveLength(0);
     });
 
@@ -767,7 +767,9 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain(
+        "registered without an authenticated user",
+      );
       expect(sentMessages).toHaveLength(0);
     });
 
@@ -863,7 +865,7 @@ describe("HostTransferProxy — targetClientId", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(result.content).toContain("does not match");
+      expect(result.content).toContain("signed in as a different user");
       expect(sentMessages).toHaveLength(0);
     });
 

package/src/__tests__/http-conversation-lineage.test.ts

@@ -13,7 +13,7 @@ mock.module("../config/env.js", () => ({
 }));
 
 import {
-  batchSetDisplayOrders,
+  batchSetConversationPlacement,
   createConversation,
   updateConversationTitle,
 } from "../persistence/conversation-crud.js";
@@ -100,9 +100,7 @@ describe("conversation lineage in HTTP reads", () => {
 
   test("GET /v1/conversations/:id includes pin metadata when present", async () => {
     const conversation = createConversation("Pinned conversation");
-    batchSetDisplayOrders([
-      { id: conversation.id, displayOrder: 7, isPinned: true },
-    ]);
+    batchSetConversationPlacement([{ id: conversation.id, isPinned: true }]);
     await startServer();
 
     const response = await fetch(url(`/conversations/${conversation.id}`));
@@ -115,7 +113,6 @@ describe("conversation lineage in HTTP reads", () => {
     expect(body.conversation).toMatchObject({
       id: conversation.id,
       title: conversation.title ?? "Untitled",
-      displayOrder: 7,
       isPinned: true,
     });
   });

package/src/__tests__/http-user-message-parity.test.ts

@@ -650,6 +650,50 @@ describe("HTTP POST /v1/messages client metadata headers", () => {
     ];
     expect(persistOptions.metadata).toBeUndefined();
   });
+
+  // Persistence merges the row's `client.os` from two sources and only one of
+  // them is this row's own: the request. Threading the body's `clientOs` is
+  // what lets it tell a reported OS apart from the one a transport-less turn
+  // inherits off the live conversation.
+  test("threads the body clientOs as this row's own OS evidence", async () => {
+    const persistUserMessage = mock(
+      async (_options: { requestClientOs?: string }) => ({
+        id: "persisted-msg-id",
+        deduplicated: false,
+      }),
+    );
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage("hello", conversation, {
+      clientOs: "macos",
+    });
+
+    expect(res.status).toBe(202);
+    const [persistOptions] = persistUserMessage.mock.calls[0] as unknown as [
+      { requestClientOs?: string },
+    ];
+    expect(persistOptions.requestClientOs).toBe("macos");
+  });
+
+  test("omits the OS evidence when the body reports no clientOs", async () => {
+    const persistUserMessage = mock(
+      async (_options: { requestClientOs?: string }) => ({
+        id: "persisted-msg-id",
+        deduplicated: false,
+      }),
+    );
+    const runAgentLoop = mock(async () => undefined);
+    const conversation = makeConversation({ persistUserMessage, runAgentLoop });
+
+    const res = await sendMessage("hello", conversation);
+
+    expect(res.status).toBe(202);
+    const [persistOptions] = persistUserMessage.mock.calls[0] as unknown as [
+      { requestClientOs?: string },
+    ];
+    expect(persistOptions.requestClientOs).toBeUndefined();
+  });
 });
 
 // ============================================================================

package/src/__tests__/identity-routes.test.ts

@@ -151,7 +151,7 @@ afterEach(() => {
 describe("identity routes — health endpoint", () => {
   describe("backward compatibility (profiler disabled)", () => {
     test("/v1/health returns expected shape without profiler key when env vars are absent", async () => {
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       expect(res.status).toBe(200);
 
       const body = (await res.json()) as Record<string, unknown>;
@@ -179,7 +179,7 @@ describe("identity routes — health endpoint", () => {
 
     test("/v1/healthz returns the same shape as /v1/health", async () => {
       // Both endpoints call handleDetailedHealth, so the shape must match
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
 
       expect(body.status).toBe("healthy");
@@ -188,7 +188,7 @@ describe("identity routes — health endpoint", () => {
     });
 
     test("includes ces.connected=false when no CES client is registered", async () => {
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
 
       expect(body.ces).toBeDefined();
@@ -197,7 +197,7 @@ describe("identity routes — health endpoint", () => {
 
     test("detailed health reports MIGRATING while DB migrations are running", async () => {
       setDbMigrating();
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       expect(res.status).toBe(200);
 
       const body = (await res.json()) as Record<string, unknown>;
@@ -229,7 +229,7 @@ describe("identity routes — health endpoint", () => {
         close: () => {},
       } as unknown as import("../credential-execution/client.js").CesClient;
       setCesClient(mockClient);
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
 
       expect(body.ces).toBeDefined();
@@ -242,7 +242,7 @@ describe("identity routes — health endpoint", () => {
         close: () => {},
       } as unknown as import("../credential-execution/client.js").CesClient;
       setCesClient(mockClient);
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
 
       expect(body.ces).toBeDefined();
@@ -258,7 +258,7 @@ describe("identity routes — health endpoint", () => {
       });
       ensureProfilerRunDir("run-health-test-1");
 
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
 
       expect(body.profiler).toBeDefined();
@@ -278,7 +278,7 @@ describe("identity routes — health endpoint", () => {
       });
       ensureProfilerRunDir("run-budget-test");
 
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
       const profiler = body.profiler as Record<string, unknown>;
       const budget = profiler.budget as Record<string, unknown>;
@@ -301,7 +301,7 @@ describe("identity routes — health endpoint", () => {
       // Non-artifact file should not count
       writeArtifactFile("run-artifact-count", "log.txt", 512);
 
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
       const profiler = body.profiler as Record<string, unknown>;
 
@@ -316,7 +316,7 @@ describe("identity routes — health endpoint", () => {
       // Write a file larger than the budget
       writeArtifactFile("run-over-budget", "big.cpuprofile", 5000);
 
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
       const profiler = body.profiler as Record<string, unknown>;
       const budget = profiler.budget as Record<string, unknown>;
@@ -334,7 +334,7 @@ describe("identity routes — health endpoint", () => {
       });
       ensureProfilerRunDir("run-no-completed");
 
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
       const profiler = body.profiler as Record<string, unknown>;
 
@@ -361,7 +361,7 @@ describe("identity routes — health endpoint", () => {
       writeArtifactFile(completedId, "profile.cpuprofile", 3072);
       writeArtifactFile(completedId, "summary.md", 256);
 
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
       const profiler = body.profiler as Record<string, unknown>;
       const last = profiler.lastCompletedRun as Record<string, unknown>;
@@ -398,7 +398,7 @@ describe("identity routes — health endpoint", () => {
       });
       writeArtifactFile("newer-completed", "new.heapsnapshot", 1024);
 
-      const res = handleDetailedHealth();
+      const res = await handleDetailedHealth();
       const body = (await res.json()) as Record<string, unknown>;
       const profiler = body.profiler as Record<string, unknown>;
       const last = profiler.lastCompletedRun as Record<string, unknown>;

package/src/__tests__/image-conversion.test.ts

@@ -132,17 +132,17 @@ describe("sniffImageMimeType", () => {
 });
 
 describe("normalizeImageBytes passthrough", () => {
-  test("non-HEIF bytes pass through untouched", () => {
-    const result = normalizeImageBytes("image/png", PNG_1PX_BYTES);
+  test("non-HEIF bytes pass through untouched", async () => {
+    const result = await normalizeImageBytes("image/png", PNG_1PX_BYTES);
     expect(result.converted).toBe(false);
     expect(result.mimeType).toBe("image/png");
     expect(result.bytes).toBe(PNG_1PX_BYTES);
   });
 
-  test("HEIF header with undecodable payload passes through", () => {
+  test("HEIF header with undecodable payload passes through", async () => {
     // sips fails (or is absent off-macOS) → the original bytes are kept.
     const fake = fakeHeifHeaderBytes();
-    const result = normalizeImageBytes("image/heic", fake);
+    const result = await normalizeImageBytes("image/heic", fake);
     expect(result.converted).toBe(false);
     expect(result.mimeType).toBe("image/heic");
     expect(result.bytes).toBe(fake);
@@ -150,35 +150,35 @@ describe("normalizeImageBytes passthrough", () => {
 });
 
 describe("normalizeImageBase64 passthrough", () => {
-  test("non-HEIF payloads skip conversion", () => {
+  test("non-HEIF payloads skip conversion", async () => {
     const b64 = PNG_1PX_BYTES.toString("base64");
-    const result = normalizeImageBase64("image/png", b64);
+    const result = await normalizeImageBase64("image/png", b64);
     expect(result.converted).toBe(false);
     expect(result.dataBase64).toBe(b64);
   });
 });
 
 describe("declared-MIME correction from sniffed bytes", () => {
-  test("normalizeImageBytes relabels a mislabeled image, bytes untouched", () => {
+  test("normalizeImageBytes relabels a mislabeled image, bytes untouched", async () => {
     // A JPEG renamed to .png arrives declared as image/png; providers reject
     // the mismatch, so the sniffed format wins.
-    const result = normalizeImageBytes("image/png", JPEG_HEADER_BYTES);
+    const result = await normalizeImageBytes("image/png", JPEG_HEADER_BYTES);
     expect(result.converted).toBe(false);
     expect(result.mimeType).toBe("image/jpeg");
     expect(result.bytes).toBe(JPEG_HEADER_BYTES);
   });
 
-  test("normalizeImageBase64 relabels a mislabeled image, payload untouched", () => {
+  test("normalizeImageBase64 relabels a mislabeled image, payload untouched", async () => {
     const b64 = PNG_1PX_BYTES.toString("base64");
-    const result = normalizeImageBase64("image/jpeg", b64);
+    const result = await normalizeImageBase64("image/jpeg", b64);
     expect(result.converted).toBe(false);
     expect(result.mimeType).toBe("image/png");
     expect(result.dataBase64).toBe(b64);
   });
 
-  test("unrecognized bytes keep the declared MIME", () => {
+  test("unrecognized bytes keep the declared MIME", async () => {
     const bytes = Buffer.from("plain text content");
-    const result = normalizeImageBytes("text/plain", bytes);
+    const result = await normalizeImageBytes("text/plain", bytes);
     expect(result.mimeType).toBe("text/plain");
     expect(result.bytes).toBe(bytes);
   });
@@ -201,17 +201,17 @@ describe.skipIf(process.platform !== "darwin")(
       expect(isHeifImage(heicBytes)).toBe(true);
     });
 
-    test("convertImageToJpeg produces JPEG bytes", () => {
-      const converted = convertImageToJpeg(heicBytes);
+    test("convertImageToJpeg produces JPEG bytes", async () => {
+      const converted = await convertImageToJpeg(heicBytes);
       expect(converted).not.toBeNull();
       expect(startsWithJpegMagic(converted!)).toBe(true);
     });
 
-    test("conversion options produce distinct outputs (cache key isolation)", () => {
+    test("conversion options produce distinct outputs (cache key isolation)", async () => {
       // A hash-only cache key would make the second call return the first
       // call's cached full-resolution output.
-      const fullRes = convertImageToJpeg(heicBytes, { quality: 90 });
-      const downscaled = convertImageToJpeg(heicBytes, {
+      const fullRes = await convertImageToJpeg(heicBytes, { quality: 90 });
+      const downscaled = await convertImageToJpeg(heicBytes, {
         maxDimensionPx: 16,
         quality: 90,
       });
@@ -220,31 +220,34 @@ describe.skipIf(process.platform !== "darwin")(
       expect(fullRes!.equals(downscaled!)).toBe(false);
     });
 
-    test("repeated conversion is stable (cache round-trip)", () => {
-      const first = convertImageToJpeg(heicBytes, { quality: 90 });
-      const second = convertImageToJpeg(heicBytes, { quality: 90 });
+    test("repeated conversion is stable (cache round-trip)", async () => {
+      const first = await convertImageToJpeg(heicBytes, { quality: 90 });
+      const second = await convertImageToJpeg(heicBytes, { quality: 90 });
       expect(first).not.toBeNull();
       expect(second).not.toBeNull();
       expect(first!.equals(second!)).toBe(true);
     });
 
-    test("normalizeImageBytes converts to a JPEG master", () => {
-      const result = normalizeImageBytes("image/heic", heicBytes);
+    test("normalizeImageBytes converts to a JPEG master", async () => {
+      const result = await normalizeImageBytes("image/heic", heicBytes);
       expect(result.converted).toBe(true);
       expect(result.mimeType).toBe("image/jpeg");
       expect(startsWithJpegMagic(result.bytes)).toBe(true);
     });
 
-    test("normalizeImageBytes converts even when the declared mime is wrong", () => {
+    test("normalizeImageBytes converts even when the declared mime is wrong", async () => {
       // Chromium reports empty file.type for .heic; clients coerce it to
       // application/octet-stream. Detection is content-based.
-      const result = normalizeImageBytes("application/octet-stream", heicBytes);
+      const result = await normalizeImageBytes(
+        "application/octet-stream",
+        heicBytes,
+      );
       expect(result.converted).toBe(true);
       expect(result.mimeType).toBe("image/jpeg");
     });
 
-    test("normalizeImageBase64 converts and re-encodes", () => {
-      const result = normalizeImageBase64(
+    test("normalizeImageBase64 converts and re-encodes", async () => {
+      const result = await normalizeImageBase64(
         "image/heic",
         heicBytes.toString("base64"),
       );

package/src/__tests__/image-source-path-reinject.test.ts

@@ -233,7 +233,7 @@ describe("reinjectAttachmentPathAnnotations", () => {
     );
   });
 
-  test("rebuilds the exact annotation block enrichMessageWithSourcePaths appends", () => {
+  test("rebuilds the exact annotation block enrichMessageWithSourcePaths appends", async () => {
     // Prefix-cache parity tripwire: the block appended at persist time (from
     // live attachment inputs) and the block rebuilt on history reload (from
     // persisted metadata) must be byte-identical.
@@ -253,7 +253,7 @@ describe("reinjectAttachmentPathAnnotations", () => {
       },
     ];
     const enriched = enrichMessageWithSourcePaths(
-      createUserMessage("compare", attachments),
+      await createUserMessage("compare", attachments),
       attachments,
     );
     const liveBlock = enriched.content.at(-1) as {

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -24,6 +24,30 @@ mock.module("../runtime/assistant-event.js", () => ({
   buildAssistantEvent: (event: unknown) => event,
 }));
 
+// The default profiles used below (`balanced`, `cost-optimized`) route through
+// the Vellum-managed connection, and the handler's availability guard judges
+// that route for real. Stand in for a signed-in platform session so the pin
+// path under test is the healthy one; `managedProxyEnabled` is flipped by the
+// guard test.
+let managedProxyEnabled = true;
+mock.module("../providers/platform-proxy/context.js", () => ({
+  resolveManagedProxyContext: async () => ({
+    enabled: managedProxyEnabled,
+    platformBaseUrl: "https://platform.example",
+    assistantApiKey: managedProxyEnabled ? "key" : "",
+  }),
+}));
+
+// Vault stand-in: tests that exercise BYOK availability drop the credential
+// they need into this map and clean it up after.
+const storedKeys: Record<string, string> = {};
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyResultAsync: async (key: string) => ({
+    value: storedKeys[key],
+    unreachable: false,
+  }),
+}));
+
 // The handler reads the real config: the "balanced" and "cost-optimized"
 // profiles used below are code-default catalog entries that always resolve,
 // and llm.profileSession's schema defaults (1800/43200) are what the TTL
@@ -44,9 +68,24 @@ import {
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { providerConnections } from "../persistence/schema/inference.js";
+import { setConfig } from "./helpers/set-config.js";
 
 await initializeDb();
 
+// The Vellum-managed connection row the default profiles resolve to.
+getDb()
+  .insert(providerConnections)
+  .values({
+    name: "vellum",
+    provider: "vellum",
+    auth: JSON.stringify({ type: "platform" }),
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  })
+  .onConflictDoNothing()
+  .run();
+
 import {
   closeInferenceProfileSession,
   listInferenceProfileSessionsWithRemaining,
@@ -344,6 +383,62 @@ describe("setInferenceProfileSession", () => {
     );
   });
 
+  test("open with an unavailable profile — refuses the pin and names the fix", async () => {
+    const conv = createConversation("sess-handler-unavailable-profile");
+    managedProxyEnabled = false;
+    try {
+      const promise = setInferenceProfileSession({
+        conversationId: conv.id,
+        profile: "balanced",
+        ttlSeconds: 300,
+      });
+      await expect(promise).rejects.toThrow(/Not signed in to Vellum/);
+      await expect(promise).rejects.toThrow(
+        /assistant inference send --profile balanced "Reply with OK"/,
+      );
+      // Nothing was pinned.
+      expect(getConversation(conv.id)?.inferenceProfile).toBeNull();
+    } finally {
+      managedProxyEnabled = true;
+    }
+  });
+
+  test("BYOK default provider — pins a managed preset without a Vellum sign-in", async () => {
+    const conv = createConversation("sess-handler-byok-preset");
+    // Signed out of Vellum, but llm.defaultProvider points the managed
+    // presets at the user's own anthropic connection — the pin must judge
+    // that body, not the Vellum column.
+    managedProxyEnabled = false;
+    storedKeys["credential/anthropic/api_key"] = "test-key";
+    getDb()
+      .insert(providerConnections)
+      .values({
+        name: "anthropic-personal",
+        provider: "anthropic",
+        auth: JSON.stringify({
+          type: "api_key",
+          credential: "credential/anthropic/api_key",
+        }),
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      })
+      .onConflictDoNothing()
+      .run();
+    setConfig("llm", { defaultProvider: { provider: "anthropic" } });
+    try {
+      const result = await setInferenceProfileSession({
+        conversationId: conv.id,
+        profile: "balanced",
+        ttlSeconds: 300,
+      });
+      expect(result.profile).toBe("balanced");
+    } finally {
+      managedProxyEnabled = true;
+      delete storedKeys["credential/anthropic/api_key"];
+      setConfig("llm", {});
+    }
+  });
+
   test("open with ttlSeconds=null — expiresAt=null, sessionId=null, profile kept", async () => {
     const conv = createConversation("sess-handler-null-ttl");
 

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -16,6 +16,17 @@ mock.module("../runtime/assistant-event.js", () => ({
   buildAssistantEvent: (event: unknown) => event,
 }));
 
+// "balanced"/"cost-optimized" route through the Vellum-managed connection, and
+// the open handler's availability guard judges that route for real. Stand in
+// for a signed-in platform session so these tests exercise the healthy path.
+mock.module("../providers/platform-proxy/context.js", () => ({
+  resolveManagedProxyContext: async () => ({
+    enabled: true,
+    platformBaseUrl: "https://platform.example",
+    assistantApiKey: "key",
+  }),
+}));
+
 // The handler resolves "balanced"/"cost-optimized" through the code-defined
 // default profile catalog and reads `llm.profileSession` schema defaults
 // (1800/43200), so real config with no seeding covers these tests.
@@ -23,11 +34,25 @@ mock.module("../runtime/assistant-event.js", () => ({
 import { createConversation } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { providerConnections } from "../persistence/schema/inference.js";
 import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
 await initializeDb();
 
+// The Vellum-managed connection row the default profiles resolve to.
+getDb()
+  .insert(providerConnections)
+  .values({
+    name: "vellum",
+    provider: "vellum",
+    auth: JSON.stringify({ type: "platform" }),
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  })
+  .onConflictDoNothing()
+  .run();
+
 const openRoute = ROUTES.find(
   (r) => r.operationId === "inference_profile_open",
 )!;

package/src/__tests__/introduction-card-resolver.test.ts

@@ -182,7 +182,12 @@ describe("introduction card decisions", () => {
       expectedExternalUserId: "U-REQUESTER",
       expectedChatId: "C-CHAT",
       identityBindingStatus: "bound",
-      destinationAddress: "C-CHAT",
+      // The person, not the room. Slack delivers to a user id, and the room
+      // may hold an audience the code was never meant for. `expectedChatId`
+      // still carries the room because that is where the conversation is;
+      // with both identity fields set the consume path requires the user
+      // match, so the room is not a credential.
+      destinationAddress: "U-REQUESTER",
       verificationPurpose: "trusted_contact",
     });
     expect(outcomesOfType("activate_member")).toHaveLength(0);