@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/__tests__/host-file-proxy.test.ts

@@ -746,9 +746,8 @@ describe("HostFileProxy", () => {
       expect(sentMessages).toHaveLength(0);
     });
 
-    test("untargeted request with no auto-resolve match still broadcasts (legacy path unchanged)", async () => {
+    test("rejects when the actor has no capable client", async () => {
       setup();
-      // No matching same-user clients available.
       mockClients = [
         {
           clientId: "client-A",
@@ -757,23 +756,18 @@ describe("HostFileProxy", () => {
         },
       ];
 
-      const resultPromise = proxy.request(
+      const result = await proxy.request(
         { operation: "read", path: "/tmp/test.txt" },
         "session-1",
         undefined,
         undefined,
-        "user-B", // No same-user match → no auto-resolve, broadcast untargeted.
+        "user-B",
       );
 
-      expect(sentMessages).toHaveLength(1);
-      const sent = sentMessages[0] as Record<string, unknown>;
-      expect(sent.targetClientId).toBeUndefined();
-      const requestId = sent.requestId as string;
-
-      proxy.resolve(requestId, { content: "ok", isError: false });
-      await resultPromise;
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
+      expect(sentMessages).toHaveLength(0);
     });
-
     test("auto-resolve picks the same-user client when there's exactly one", async () => {
       setup();
       mockClients = [
@@ -807,7 +801,7 @@ describe("HostFileProxy", () => {
       await resultPromise;
     });
 
-    test("auto-resolve falls through when no client matches the source user", async () => {
+    test("rejects when only a different user has a capable client", async () => {
       setup();
       mockClients = [
         {
@@ -817,7 +811,7 @@ describe("HostFileProxy", () => {
         },
       ];
 
-      const resultPromise = proxy.request(
+      const result = await proxy.request(
         { operation: "read", path: "/tmp/test.txt" },
         "session-1",
         undefined,
@@ -825,16 +819,10 @@ describe("HostFileProxy", () => {
         "user-C",
       );
 
-      // No same-user client → no auto-resolve, broadcast untargeted.
-      expect(sentMessages).toHaveLength(1);
-      const sent = sentMessages[0] as Record<string, unknown>;
-      expect(sent.targetClientId).toBeUndefined();
-      const requestId = sent.requestId as string;
-
-      proxy.resolve(requestId, { content: "ok", isError: false });
-      await resultPromise;
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
+      expect(sentMessages).toHaveLength(0);
     });
-
     test("legacy embedded targetClientId in input still goes through the same-user gate", async () => {
       setup();
       mockClients = [

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

@@ -812,7 +812,7 @@ describe("HostTransferProxy — targetClientId", () => {
       await resultPromise;
     });
 
-    test("requestToHost: auto-resolve falls through when no client matches the source user", async () => {
+    test("requestToHost: rejects when no client matches the source user", async () => {
       setup();
       mockClientRegistry.set("client-A", {
         clientId: "client-A",
@@ -824,7 +824,7 @@ describe("HostTransferProxy — targetClientId", () => {
       const srcPath = `/tmp/htp-auto-no-match-${Date.now()}.txt`;
       await globalThis.Bun.write(srcPath, "data");
 
-      const resultPromise = proxy.requestToHost(
+      const result = await proxy.requestToHost(
         {
           sourcePath: srcPath,
           destPath: "/host/dest.txt",
@@ -835,13 +835,9 @@ describe("HostTransferProxy — targetClientId", () => {
         "user-C",
       );
 
-      await waitForMessages(sentMessages, 1);
-      const sent = sentMessages[0] as Record<string, unknown>;
-      expect(sent.targetClientId).toBeUndefined();
-
-      const requestId = sent.requestId as string;
-      proxy.resolveTransferResult(requestId, { isError: false });
-      await resultPromise;
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
+      expect(sentMessages).toHaveLength(0);
     });
 
     test("requestToSandbox: targeted request from a different user is rejected", async () => {
@@ -897,6 +893,31 @@ describe("HostTransferProxy — targetClientId", () => {
       await resultPromise;
     });
 
+    test("requestToSandbox: rejects when no client matches the source user", async () => {
+      setup();
+      const a: MockClient = {
+        clientId: "client-A",
+        capabilities: ["host_file"],
+        actorPrincipalId: "user-A",
+      };
+      mockCapableClients = [a];
+      mockClientRegistry.set("client-A", a);
+
+      const result = await proxy.requestToSandbox(
+        {
+          sourcePath: "/host/source.txt",
+          destPath: "/sandbox/dest.txt",
+          conversationId: "conv-same-9-no-match",
+        },
+        undefined,
+        "user-C",
+      );
+
+      expect(result).toMatchObject({ isError: true });
+      expect(result.content).toContain("belongs to this user");
+      expect(sentMessages).toHaveLength(0);
+    });
+
     test("requestToSandbox: auto-resolve picks the same-user client when there's exactly one", async () => {
       setup();
       const a: MockClient = {

package/src/__tests__/list-messages-camera-frame.test.ts

@@ -0,0 +1,121 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setConfig } from "./helpers/set-config.js";
+
+setConfig("memory", { enabled: false });
+
+import {
+  type ConversationMessage,
+  ConversationMessageSchema,
+} from "../api/responses/conversation-message.js";
+import {
+  addMessage,
+  createConversation,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+await initializeDb();
+
+describe("handleListMessages camera-frame projection", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM message_attachments");
+    db.run("DELETE FROM attachments");
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+  });
+
+  test.each([
+    {
+      name: "an ambient keep",
+      metadata: { scripted: true, sightFrameAttachmentIds: ["att-keep"] },
+      cameraFrame: true,
+    },
+    {
+      name: "a spoken turn carrying a parked frame",
+      metadata: {
+        sightFrameAttachmentIds: ["att-parked"],
+        voiceSessionTurn: true,
+      },
+      cameraFrame: false,
+    },
+    {
+      name: "a shutter photo",
+      metadata: { livePhoto: true, voiceSessionTurn: true, scripted: false },
+      cameraFrame: false,
+    },
+    {
+      name: "a plain user row with literal camera-frame text",
+      metadata: undefined,
+      cameraFrame: false,
+    },
+    {
+      name: "a scripted row with no frame tag",
+      metadata: { scripted: true },
+      cameraFrame: false,
+    },
+    {
+      name: "a scripted row with an empty frame tag",
+      metadata: { scripted: true, sightFrameAttachmentIds: [] },
+      cameraFrame: false,
+    },
+    {
+      name: "a scripted row with invalid frame ids",
+      metadata: { scripted: true, sightFrameAttachmentIds: [""] },
+      cameraFrame: false,
+    },
+  ])("classifies $name from metadata", async ({ metadata, cameraFrame }) => {
+    const conv = createConversation();
+    const row = await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "(camera frame)" }]),
+      { metadata },
+    );
+
+    const response = (await handleListMessages({
+      queryParams: { conversationId: conv.id },
+    })) as { messages: ConversationMessage[] };
+
+    expect(response.messages).toHaveLength(1);
+    const projected = response.messages[0]!;
+    expect(projected.id).toBe(row.id);
+    expect(() => ConversationMessageSchema.parse(projected)).not.toThrow();
+    if (cameraFrame) {
+      expect(projected.cameraFrame).toBe(true);
+    } else {
+      expect(projected).not.toHaveProperty("cameraFrame");
+    }
+    expect(
+      ConversationMessageSchema.safeParse({ ...projected, cameraFrame: false })
+        .success,
+    ).toBe(false);
+  });
+
+  test.each(["not-json", "null", "", "{}"])(
+    "omits cameraFrame for unreadable or empty metadata %j",
+    async (metadata) => {
+      const conv = createConversation();
+      const row = await addMessage(
+        conv.id,
+        "user",
+        JSON.stringify([{ type: "text", text: "(camera frame)" }]),
+      );
+      getDb()
+        .$client.prepare("UPDATE messages SET metadata = ? WHERE id = ?")
+        .run(metadata, row.id);
+
+      const response = (await handleListMessages({
+        queryParams: { conversationId: conv.id },
+      })) as { messages: ConversationMessage[] };
+
+      expect(response.messages).toHaveLength(1);
+      const projected = response.messages[0]!;
+      expect(projected.id).toBe(row.id);
+      expect(projected).not.toHaveProperty("cameraFrame");
+      expect(() => ConversationMessageSchema.parse(projected)).not.toThrow();
+    },
+  );
+});

package/src/__tests__/llm-catalog-parity.test.ts

@@ -6,6 +6,7 @@ import {
   getCatalogProviderForModel,
   isModelInCatalog,
   PROVIDER_CATALOG,
+  supportsForcedToolChoiceWithThinking,
 } from "../providers/model-catalog.js";
 import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
 import { resolvePricing, resolvePricingForUsage } from "../util/pricing.js";
@@ -551,6 +552,30 @@ describe("LLM catalog parity: daemon vs client", () => {
     expect(getCatalogProviderForModel("unknown/model")).toBeUndefined();
   });
 
+  test("forced tool choice with thinking is scoped to OpenRouter Kimi K2.6", () => {
+    expect(
+      supportsForcedToolChoiceWithThinking("openrouter", "moonshotai/kimi-k2.6"),
+    ).toBe(false);
+    expect(
+      supportsForcedToolChoiceWithThinking(
+        "openrouter",
+        "moonshotai/kimi-k2.6-20260420",
+      ),
+    ).toBe(false);
+    expect(
+      supportsForcedToolChoiceWithThinking(
+        "vercel-ai-gateway",
+        "moonshotai/kimi-k2.6",
+      ),
+    ).toBe(true);
+    expect(
+      supportsForcedToolChoiceWithThinking("openrouter", "unknown/model"),
+    ).toBe(true);
+    expect(
+      supportsForcedToolChoiceWithThinking("unknown-provider", "unknown/model"),
+    ).toBe(true);
+  });
+
   test("Gemini 2.5 Pro catalog context matches provider limits", () => {
     const gemini = PROVIDER_CATALOG.find((entry) => entry.id === "gemini");
     expect(

package/src/__tests__/mcp-auth-routes.test.ts

@@ -24,15 +24,12 @@ mock.module("../mcp/mcp-auth-state.js", () => ({
   getMcpAuthState: mockGetMcpAuthState,
 }));
 
-import { setConfig } from "./helpers/set-config.js";
-
-// Seed the MCP server the routes look up via `loadRawConfig()` into the
-// workspace config for real.
-setConfig("mcp", {
-  servers: {
-    "my-server": {
-      transport: { type: "sse", url: "https://mcp.example.com" },
-    },
+import { setWorkspaceMcp } from "./helpers/set-workspace-mcp.js";
+
+// Seed the MCP server the routes look up via workspace mcp.json.
+setWorkspaceMcp({
+  "my-server": {
+    transport: { type: "sse", url: "https://mcp.example.com" },
   },
 });
 

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

@@ -1,4 +1,4 @@
-import { readFileSync, utimesSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -14,14 +14,6 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (value: string, maxLen = 500) => value.slice(0, maxLen),
 }));
 
-// The config routes under test read and write the workspace config.json via
-// the real loader (`loadRawConfig`/`saveRawConfig`). Tests seed the raw file
-// directly (the fixtures are raw-file shapes, including deliberately
-// malformed trees, so the whole file is replaced rather than composed via
-// `setConfig`) and detect commits by comparing the on-disk text against the
-// seeded snapshot — `saveRawConfig` pretty-prints, so any commit changes the
-// text.
-let rawConfig: Record<string, unknown> = {};
 let seededRawText = "";
 let mtimeSeq = 0;
 
@@ -29,19 +21,23 @@ function configJsonPath(): string {
   return join(process.env.VELLUM_WORKSPACE_DIR!, "config.json");
 }
 
-/** Write `raw` to the workspace config.json as the seeded pre-test state. */
+function mcpJsonPath(): string {
+  return join(process.env.VELLUM_WORKSPACE_DIR!, "mcp.json");
+}
+
 function seedRawConfig(raw: Record<string, unknown>): void {
-  rawConfig = raw;
   seededRawText = JSON.stringify(raw);
+  mkdirSync(process.env.VELLUM_WORKSPACE_DIR!, { recursive: true });
   writeFileSync(configJsonPath(), seededRawText);
-  // Distinct mtime per write so the loader's file-signature cache can never
-  // read two consecutive seeds as identical.
   mtimeSeq += 1;
   const stamp = new Date(Date.now() + mtimeSeq);
   utimesSync(configJsonPath(), stamp, stamp);
 }
 
-/** The raw config a route commit persisted, or null when nothing was saved. */
+function seedWorkspaceMcp(document: unknown): void {
+  writeFileSync(mcpJsonPath(), JSON.stringify(document, null, 2) + "\n");
+}
+
 function committedRaw(): Record<string, unknown> | null {
   const text = readFileSync(configJsonPath(), "utf8");
   if (text === seededRawText) {
@@ -119,11 +115,6 @@ const configGetRoute = findRoute("config_get");
 const configPatchRoute = findRoute("config_patch");
 const configSetRoute = findRoute("config_set");
 
-/**
- * Config responses inject the code-catalog default profiles into
- * `llm.profiles` (the effective wire view). These tests pin the MCP secret
- * boundary, so drop the injected block before whole-response comparisons.
- */
 function withoutWireProfiles(
   result: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -134,21 +125,18 @@ function withoutWireProfiles(
 describe("MCP config secret boundary", () => {
   beforeEach(() => {
     seedRawConfig({});
+    rmSync(mcpJsonPath(), { force: true });
   });
 
-  test("config_get omits legacy MCP transport headers from settings-read responses", () => {
-    seedRawConfig({
-      mcp: {
-        servers: {
-          remote: {
-            transport: {
-              type: "streamable-http",
-              url: "https://mcp.example.com",
-              headers: {
-                Authorization: "Bearer mcp-secret",
-                "X-API-Key": "mcp-api-secret",
-              },
-            },
+  test("config_get omits MCP headers from the mcp.json overlay", () => {
+    seedWorkspaceMcp({
+      mcpServers: {
+        remote: {
+          type: "streamable-http",
+          url: "https://mcp.example.com",
+          headers: {
+            Authorization: "Bearer mcp-secret",
+            "X-API-Key": "mcp-api-secret",
           },
         },
       },
@@ -167,64 +155,61 @@ describe("MCP config secret boundary", () => {
     });
   });
 
-  test("config_get omits headers inside malformed MCP server trees", () => {
+  test("config_get ignores leftover config.json mcp so its headers cannot leak", () => {
     seedRawConfig({
       mcp: {
-        servers: [
-          {
+        servers: {
+          remote: {
             transport: {
-              headers: { Authorization: "Bearer malformed-secret" },
+              type: "streamable-http",
+              url: "https://mcp.example.com",
+              headers: { Authorization: "Bearer leftover-secret" },
             },
           },
-        ],
+        },
       },
     });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(JSON.stringify(result)).not.toContain("malformed-secret");
-    expect(withoutWireProfiles(result)).toEqual({
-      mcp: {
-        servers: [
-          {
-            transport: {},
-          },
-        ],
-      },
-    });
+    expect(JSON.stringify(result)).not.toContain("leftover-secret");
+    expect(
+      (result.mcp as { servers: Record<string, unknown> }).servers,
+    ).toEqual({});
   });
 
   test("config_get preserves an MCP server named headers", () => {
-    seedRawConfig({
-      mcp: {
-        servers: {
-          headers: {
-            transport: {
-              type: "streamable-http",
-              url: "https://mcp.example.com",
-            },
-          },
+    seedWorkspaceMcp({
+      mcpServers: {
+        headers: {
+          type: "streamable-http",
+          url: "https://mcp.example.com",
         },
       },
     });
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result)).toEqual(rawConfig);
+    expect(withoutWireProfiles(result).mcp).toEqual({
+      servers: {
+        headers: {
+          transport: {
+            type: "streamable-http",
+            url: "https://mcp.example.com",
+          },
+        },
+      },
+    });
   });
 
   test("config_get preserves non-credential headers env vars", () => {
-    seedRawConfig({
-      mcp: {
-        servers: {
-          local: {
-            transport: {
-              type: "stdio",
-              command: "npx",
-              env: {
-                headers: "not-a-transport-header",
-              },
-            },
+    seedWorkspaceMcp({
+      mcpServers: {
+        local: {
+          type: "stdio",
+          command: "npx",
+          env: {
+            headers: "not-a-transport-header",
           },
         },
       },
@@ -232,7 +217,20 @@ describe("MCP config secret boundary", () => {
 
     const result = configGetRoute.handler({}) as Record<string, unknown>;
 
-    expect(withoutWireProfiles(result)).toEqual(rawConfig);
+    expect(withoutWireProfiles(result).mcp).toEqual({
+      servers: {
+        local: {
+          transport: {
+            type: "stdio",
+            command: "npx",
+            args: [],
+            env: {
+              headers: "not-a-transport-header",
+            },
+          },
+        },
+      },
+    });
   });
 
   test("config_patch rejects MCP transport headers so generic writes cannot reintroduce plaintext credentials", async () => {
@@ -256,7 +254,7 @@ describe("MCP config secret boundary", () => {
     expect(committedRaw()).toBeNull();
   });
 
-  test("config_patch allows an MCP server named headers when its value has no header credentials", async () => {
+  test("config_patch strips mcp so a full-config round trip cannot write it back", async () => {
     const result = await configPatchRoute.handler({
       body: {
         mcp: {
@@ -272,68 +270,25 @@ describe("MCP config secret boundary", () => {
       },
     });
 
-    expect(withoutWireProfiles(result as Record<string, unknown>)).toEqual({
-      mcp: {
-        servers: {
-          headers: {
-            transport: {
-              type: "streamable-http",
-              url: "https://mcp.example.com",
-            },
-          },
-        },
-      },
-    });
-  });
-
-  test("config_patch allows non-credential headers env vars", async () => {
-    const result = await configPatchRoute.handler({
-      body: {
-        mcp: {
-          servers: {
-            local: {
-              transport: {
-                type: "stdio",
-                command: "npx",
-                env: {
-                  headers: "not-a-transport-header",
-                },
-              },
-            },
-          },
-        },
-      },
-    });
-
-    expect(withoutWireProfiles(result as Record<string, unknown>)).toEqual({
-      mcp: {
-        servers: {
-          local: {
-            transport: {
-              type: "stdio",
-              command: "npx",
-              env: {
-                headers: "not-a-transport-header",
-              },
-            },
-          },
-        },
-      },
-    });
+    expect(committedRaw()?.mcp).toBeUndefined();
+    expect(
+      (result as { mcp: { servers: Record<string, unknown> } }).mcp.servers,
+    ).toEqual({});
   });
 
-  test("config_set rejects malformed MCP server trees containing headers", async () => {
+  test("config_set rejects MCP server writes", async () => {
     await expect(
       configSetRoute.handler({
         body: {
           path: "mcp.servers",
-          value: [
-            {
+          value: {
+            remote: {
               transport: {
-                headers: { Authorization: "Bearer malformed-secret" },
+                type: "streamable-http",
+                url: "https://mcp.example.com",
               },
             },
-          ],
+          },
         },
       }),
     ).rejects.toThrow(BadRequestError);
@@ -341,19 +296,6 @@ describe("MCP config secret boundary", () => {
   });
 
   test("config_set rejects direct MCP transport header paths", async () => {
-    seedRawConfig({
-      mcp: {
-        servers: {
-          remote: {
-            transport: {
-              type: "streamable-http",
-              url: "https://mcp.example.com",
-            },
-          },
-        },
-      },
-    });
-
     await expect(
       configSetRoute.handler({
         body: {

package/src/__tests__/mcp-health-check.test.ts

@@ -18,17 +18,14 @@ mock.module("../mcp/client.js", () => ({
   },
 }));
 
-import { setConfig } from "./helpers/set-config.js";
-
-// Seed the MCP server the list route reads via `loadRawConfig()` into the
-// workspace config for real.
-setConfig("mcp", {
-  servers: {
-    test: {
-      transport: {
-        type: "streamable-http",
-        url: "https://example.com/mcp",
-      },
+import { setWorkspaceMcp } from "./helpers/set-workspace-mcp.js";
+
+// Seed the MCP server the list route reads from workspace mcp.json.
+setWorkspaceMcp({
+  test: {
+    transport: {
+      type: "streamable-http",
+      url: "https://example.com/mcp",
     },
   },
 });