@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Route-level coverage for plugin-declared MCP servers appearing in
+ * `internal_mcp_list` (what `assistant mcp list` renders).
+ *
+ * The unit tests in `plugins/__tests__/mcp-servers.test.ts` cover reading
+ * `mcp.json`. This file covers the merge, and two properties that a
+ * refactor could quietly break:
+ *
+ * 1. A workspace entry of the same id wins. Getting precedence backwards
+ *    would let a plugin redirect a server the user configured by hand.
+ * 2. A plugin server is never health-checked. `McpClient.connect` resolves
+ *    `mcp:<serverId>:headers` and `mcp:<serverId>:tokens` from the
+ *    credential store, and a plugin controls both its server key and its
+ *    URL, so probing one would send a workspace credential to an endpoint
+ *    the plugin chose whenever an id happens to match a stored key.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, jest, mock, test } from "bun:test";
+
+const mockConnect = jest.fn();
+const mockDisconnect = jest.fn();
+/** Server ids the route actually constructed an MCP client for. */
+const connectedServerIds: string[] = [];
+
+mock.module("../mcp/client.js", () => ({
+  McpClient: class {
+    constructor(serverId: string) {
+      connectedServerIds.push(serverId);
+    }
+    get isConnected() {
+      return true;
+    }
+    get lastError() {
+      return null;
+    }
+    connect = mockConnect;
+    disconnect = mockDisconnect;
+  },
+}));
+
+mock.module("../mcp/mcp-auth-orchestrator.js", () => ({
+  orchestrateMcpOAuthConnect: async () => ({
+    auth_url: "",
+    already_authenticated: false,
+  }),
+}));
+
+mock.module("../mcp/mcp-auth-state.js", () => ({
+  getMcpAuthState: () => null,
+}));
+
+mock.module("../mcp/mcp-oauth-provider.js", () => ({
+  // Stand in for a credential store that holds tokens for every id, which
+  // is the condition under which a leak would be observable.
+  hasMcpOAuthTokens: async () => true,
+  deleteMcpOAuthCredentials: async () => ({ ok: true, failedKeys: [] }),
+}));
+
+mock.module("../mcp/mcp-header-store.js", () => ({
+  getMcpHeaders: async () => ({ Authorization: "Bearer workspace-secret" }),
+  setMcpHeaders: async () => {},
+  deleteMcpHeaders: async () => true,
+}));
+
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
+}));
+
+import { setConfig } from "./helpers/set-config.js";
+
+setConfig("mcp", {
+  servers: {
+    "from-workspace": {
+      transport: { type: "streamable-http", url: "https://config.example/mcp" },
+      enabled: true,
+      defaultRiskLevel: "high",
+      maxTools: 20,
+    },
+    // Deliberately shares an id with the `shadowed` plugin below.
+    shadowed: {
+      transport: { type: "streamable-http", url: "https://wins.example/mcp" },
+      enabled: true,
+      defaultRiskLevel: "low",
+      maxTools: 20,
+    },
+  },
+});
+
+const { getWorkspacePluginsDir } = await import("../util/platform.js");
+const { ROUTES } = await import("../runtime/routes/mcp-auth-routes.js");
+
+const listHandler = ROUTES.find(
+  (r: { operationId: string }) => r.operationId === "internal_mcp_list",
+)!.handler;
+
+interface ListedServer {
+  id: string;
+  status: string;
+  source?: "workspace" | "plugin";
+  pluginName?: string;
+  defaultRiskLevel: string;
+  hasOAuth: boolean;
+  hasStaticAuth: boolean;
+  authType: string;
+  transport: { type: string; url?: string };
+}
+
+function writePlugin(name: string, mcpJson: unknown): void {
+  const dir = join(getWorkspacePluginsDir(), name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "package.json"),
+    JSON.stringify({ name, version: "1.0.0" }),
+  );
+  writeFileSync(join(dir, "mcp.json"), JSON.stringify(mcpJson));
+}
+
+function unabyssManifest(): unknown {
+  return {
+    mcpServers: {
+      unabyss: { type: "streamable-http", url: "https://mcp.unabyss.com" },
+    },
+  };
+}
+
+async function listServers(): Promise<ListedServer[]> {
+  const result = (await listHandler({})) as { servers: ListedServer[] };
+  return result.servers;
+}
+
+describe("internal_mcp_list, plugin-declared servers", () => {
+  beforeEach(() => {
+    mockConnect.mockReset();
+    mockDisconnect.mockReset();
+    connectedServerIds.length = 0;
+    rmSync(getWorkspacePluginsDir(), { recursive: true, force: true });
+    mkdirSync(getWorkspacePluginsDir(), { recursive: true });
+  });
+
+  test("a plugin's mcp.json server appears alongside workspace servers", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const ids = (await listServers()).map((s) => s.id);
+    expect(ids).toContain("from-workspace");
+    expect(ids).toContain("unabyss");
+  });
+
+  test("plugin servers are labelled with their origin, workspace servers are not", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const servers = await listServers();
+    const plugin = servers.find((s) => s.id === "unabyss")!;
+    const workspace = servers.find((s) => s.id === "from-workspace")!;
+
+    expect(plugin.source).toEqual("plugin");
+    expect(plugin.pluginName).toEqual("unabyss");
+    expect(workspace.source).toEqual("workspace");
+    expect(workspace.pluginName).toBeUndefined();
+  });
+
+  test("a workspace server of the same id wins over the plugin's", async () => {
+    writePlugin("shadowed", {
+      mcpServers: {
+        shadowed: { type: "streamable-http", url: "https://loses.example/mcp" },
+      },
+    });
+
+    const matches = (await listServers()).filter((s) => s.id === "shadowed");
+
+    expect(matches).toHaveLength(1);
+    expect(matches[0].source).toEqual("workspace");
+    expect(matches[0].transport.url).toEqual("https://wins.example/mcp");
+  });
+
+  test("plugin servers are not health-checked, so no credential can reach them", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const servers = await listServers();
+
+    expect(servers.find((s) => s.id === "unabyss")!.status).toEqual("declared");
+    // The credential mocks above return a token and an Authorization header
+    // for every id. Constructing a client for the plugin server is what
+    // would ship them to the plugin-declared URL.
+    expect(connectedServerIds).toContain("from-workspace");
+    expect(connectedServerIds).not.toContain("unabyss");
+  });
+
+  test("plugin servers report no assistant-owned auth even when the store has some", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
+    expect(plugin.hasOAuth).toBe(false);
+    expect(plugin.hasStaticAuth).toBe(false);
+    expect(plugin.authType).toEqual("none");
+  });
+
+  test("workspace servers keep reporting their auth state", async () => {
+    const workspace = (await listServers()).find(
+      (s) => s.id === "from-workspace",
+    )!;
+    expect(workspace.hasOAuth).toBe(true);
+    expect(workspace.hasStaticAuth).toBe(true);
+  });
+
+  test("plugin servers default to low risk", async () => {
+    writePlugin("unabyss", unabyssManifest());
+
+    const servers = await listServers();
+    expect(servers.find((s) => s.id === "unabyss")!.defaultRiskLevel).toEqual(
+      "low",
+    );
+  });
+
+  test("a directory with no valid package.json is not advertised", async () => {
+    // The runtime loader would never load it, and its stdio command must
+    // not be reachable through the listing.
+    const dir = join(getWorkspacePluginsDir(), "no-manifest");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "mcp.json"),
+      JSON.stringify({
+        mcpServers: { evil: { type: "stdio", command: "touch" } },
+      }),
+    );
+
+    const ids = (await listServers()).map((s) => s.id);
+    expect(ids).not.toContain("no-manifest__evil");
+    expect(ids).toContain("from-workspace");
+  });
+
+  test("a malformed plugin manifest does not remove workspace servers", async () => {
+    const dir = join(getWorkspacePluginsDir(), "broken");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({ name: "broken", version: "1.0.0" }),
+    );
+    writeFileSync(join(dir, "mcp.json"), "{ not json");
+
+    const ids = (await listServers()).map((s) => s.id);
+    expect(ids).toContain("from-workspace");
+  });
+
+  test("no plugins installed leaves the listing unchanged", async () => {
+    const servers = await listServers();
+    expect(servers.every((s) => s.source === "workspace")).toBe(true);
+  });
+});

package/src/__tests__/media-generate-image.test.ts

@@ -1,6 +1,14 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { readFileSync } from "fs";
+import {
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "fs";
+import { tmpdir } from "os";
 import { dirname, join } from "path";
 
 import { __resetRegistryForTesting, getTool } from "../tools/registry.js";
@@ -97,8 +105,23 @@ import { run } from "../config/bundled-skills/image-studio/tools/media-generate-
 // Clean up after this file to prevent contamination of later test files.
 afterAll(() => {
   __resetRegistryForTesting();
+  for (const dir of tempWorkingDirs) {
+    rmSync(dir, { recursive: true, force: true });
+  }
 });
 
+const tempWorkingDirs: string[] = [];
+
+/** Build a ToolContext with a fresh temp working directory. */
+function makeContext(): ToolContext {
+  const workingDir = mkdtempSync(join(tmpdir(), "media-gen-test-"));
+  tempWorkingDirs.push(workingDir);
+  return {
+    conversationId: "conv-123",
+    workingDir,
+  } as unknown as ToolContext;
+}
+
 const CONFIG_DIR = join(
   dirname(import.meta.dirname!),
   "config",
@@ -128,12 +151,10 @@ beforeEach(() => {
     platformBaseUrl: "",
     assistantApiKey: "",
   };
+  fakeContext = makeContext();
 });
 
-const fakeContext = {
-  conversationId: "conv-123",
-  workingDir: "/tmp",
-} as unknown as ToolContext;
+let fakeContext: ToolContext;
 
 describe("image-studio skill script wrapper", () => {
   test("exports a run function without registering media_generate_image in the tool registry", async () => {
@@ -431,28 +452,117 @@ describe("image-studio skill script wrapper", () => {
   });
 
   test("reads source images from file paths on disk", async () => {
-    // Write a temp image file inside the workspace (fakeContext.workingDir = /tmp)
-    const tmpPath = join("/tmp", "test-source-image.png");
+    // Write a temp image file inside the workspace
+    const tmpPath = join(fakeContext.workingDir, "test-source-image.png");
     const pngBytes = Buffer.from(
       "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==",
       "base64",
     );
     await Bun.write(tmpPath, pngBytes);
 
-    try {
-      const result = await run(
-        { prompt: "edit this", mode: "edit", source_paths: [tmpPath] },
-        fakeContext,
-      );
-
-      expect(result.isError).toBe(false);
-      expect(result.content).toContain("Generated 1 image");
-    } finally {
-      const { unlink } = await import("fs/promises");
-      if (await Bun.file(tmpPath).exists()) {
-        await unlink(tmpPath);
-      }
-    }
+    const result = await run(
+      { prompt: "edit this", mode: "edit", source_paths: [tmpPath] },
+      fakeContext,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Generated 1 image");
+  });
+
+  test("saves the image into media/generated and returns the embed instruction", async () => {
+    const result = await run({ prompt: "a sunset" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Saved to media/generated/a-sunset.png");
+    expect(result.content).toContain(
+      "![description](vellum://workspace/media/generated/a-sunset.png)",
+    );
+    const saved = Bun.file(
+      join(fakeContext.workingDir, "media/generated/a-sunset.png"),
+    );
+    expect(await saved.exists()).toBe(true);
+    const bytes = Buffer.from(await saved.arrayBuffer());
+    expect(bytes.equals(Buffer.from("generated-data", "base64"))).toBe(true);
+  });
+
+  test("uses the image title for the filename when present", async () => {
+    mockGenerateResult = {
+      images: [
+        {
+          mimeType: "image/png",
+          dataBase64: "img1",
+          title: "Twilight Gremlin!",
+        } as never,
+      ],
+      text: "",
+      resolvedModel: "gemini-3.1-flash-image-preview",
+    };
+
+    const result = await run({ prompt: "a pond creature" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain(
+      "Saved to media/generated/twilight-gremlin.png",
+    );
+  });
+
+  test("gives each variant a distinct filename", async () => {
+    mockGenerateResult = {
+      images: [
+        { mimeType: "image/png", dataBase64: "img1" },
+        { mimeType: "image/png", dataBase64: "img2" },
+      ],
+      text: undefined as unknown as string,
+      resolvedModel: "gemini-3.1-flash-image-preview",
+    };
+
+    const result = await run({ prompt: "a robot", variants: 2 }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("- media/generated/a-robot.png");
+    expect(result.content).toContain("- media/generated/a-robot-2.png");
+    expect(
+      await Bun.file(
+        join(fakeContext.workingDir, "media/generated/a-robot-2.png"),
+      ).exists(),
+    ).toBe(true);
+  });
+
+  test("suffixes the filename when a previous generation already used it", async () => {
+    const first = await run({ prompt: "a fox" }, fakeContext);
+    expect(first.content).toContain("Saved to media/generated/a-fox.png");
+
+    const second = await run({ prompt: "a fox" }, fakeContext);
+    expect(second.content).toContain("Saved to media/generated/a-fox-2.png");
+  });
+
+  test("refuses to write through a symlink that escapes the workspace", async () => {
+    const outside = mkdtempSync(join(tmpdir(), "media-gen-outside-"));
+    tempWorkingDirs.push(outside);
+    symlinkSync(outside, join(fakeContext.workingDir, "media"));
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Could not save to the workspace");
+    expect(result.content).not.toContain("vellum://workspace/");
+    expect(readdirSync(outside)).toEqual([]);
+  });
+
+  test("falls back to inline-only when the workspace write fails", async () => {
+    // Occupy the media path with a regular file so the directory creation
+    // under it fails.
+    writeFileSync(join(fakeContext.workingDir, "media"), "not a directory");
+
+    const result = await run({ prompt: "a cat" }, fakeContext);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Could not save to the workspace");
+    expect(result.content).toContain(
+      "will be attached to your reply automatically",
+    );
+    expect(result.content).not.toContain("vellum://workspace/");
+    expect(result.contentBlocks).toHaveLength(1);
   });
 
   test("returns error when all source_paths are invalid", async () => {

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

@@ -64,15 +64,21 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: broadcastMessageMock,
 }));
 
-import type { UserPromptSubmitContext } from "@vellumai/plugin-api";
+import {
+  type UserPromptSubmitContext,
+  VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+} from "@vellumai/plugin-api";
 
 import type { AssistantEvent } from "../api/index.js";
+import { ESCALATION_CONTINUATION_CONTENT } from "../calls/voice-triage-escalate.js";
 import type { AssistantConfig } from "../config/schema.js";
 import type { Conversation } from "../daemon/conversation.js";
 import type { QdrantSparseVector } from "../persistence/embeddings/qdrant-client.js";
 import type { ConversationGraphMemory } from "../plugins/defaults/memory/graph/conversation-graph-memory.js";
 import userPromptSubmitMemoryRetrieval from "../plugins/defaults/memory/hooks/user-prompt-submit.js";
 import type { Message } from "../providers/types.js";
+import { asConversation } from "./helpers/mock-conversation.js";
+import { setConfig } from "./helpers/set-config.js";
 
 /** Canonical metrics payload the graph retriever attaches to a real hit. */
 function makeMetrics() {
@@ -172,15 +178,16 @@ function installConversation(
   graphMemory: ConversationGraphMemory,
   opts?: {
     trusted?: boolean;
-    signal?: AbortSignal;
+    abortController?: AbortController;
   },
-): void {
+): Conversation {
   currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
-  currentConversation = {
+  currentConversation = asConversation({
     graphMemory,
     trustContext: undefined,
-    abortController: { signal: opts?.signal ?? new AbortController().signal },
-  } as unknown as Conversation;
+    abortController: opts?.abortController ?? new AbortController(),
+  });
+  return currentConversation;
 }
 
 beforeEach(() => {
@@ -191,9 +198,95 @@ beforeEach(() => {
   broadcastMessageMock.mockReset();
   currentConversation = undefined;
   currentTrustClass = "guardian";
+  setConfig("memory", { enabled: true, v3: { live: false } });
 });
 
 describe("user-prompt-submit hook (memory retrieval)", () => {
+  test("voice front door skips serial legacy retrieval", async () => {
+    const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
+      makeFakeGraphMemory();
+    const conversation = installConversation(memory, { trusted: true });
+    conversation.currentCallSite = "voiceFrontDoor";
+    const ctx = makeHookCtx({ conversationId: "conv-voice" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(recordPkbQueryVectorsMock).toHaveBeenCalledWith(
+      undefined,
+      undefined,
+    );
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("voice escalation continuation routes legacy retrieval on the preceding user message", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    installConversation(memory, { trusted: true });
+    const latestMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<info>\ncarried context\n</info>" },
+          {
+            type: "text",
+            text: "<turn_context>\nturn context\n</turn_context>",
+          },
+          { type: "text", text: "What is my preferred editor?" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Let me check that." }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "Continue the answer." }],
+      },
+    ];
+    const ctx = makeHookCtx({
+      latestMessages,
+      isHiddenPrompt: true,
+      prompt: ESCALATION_CONTINUATION_CONTENT,
+      messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+    expect(prepareMemoryMock.mock.calls[0]?.[0]).toBe(latestMessages);
+    expect(prepareMemoryMock.mock.calls[0]?.[4]).toEqual([
+      {
+        role: "user",
+        content: [{ type: "text", text: "What is my preferred editor?" }],
+      },
+    ]);
+  });
+
+  test("generic hidden prompts route legacy retrieval on their own content", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    installConversation(memory, { trusted: true });
+    const latestMessages: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "Visible caller message" }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "Hidden prompt content" }],
+      },
+    ];
+    const ctx = makeHookCtx({
+      latestMessages,
+      isHiddenPrompt: true,
+      prompt: "Hidden prompt content",
+    });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    expect(prepareMemoryMock).toHaveBeenCalledTimes(1);
+    expect(prepareMemoryMock.mock.calls[0]?.[4]).toBe(latestMessages);
+  });
+
   test("adopts the injected run messages when the actor is trusted", async () => {
     const injected: Message[] = [
       { role: "user", content: [{ type: "text", text: "injected" }] },
@@ -492,7 +585,7 @@ describe("user-prompt-submit hook (memory retrieval)", () => {
     const controller = new AbortController();
     installConversation(graphMemory, {
       trusted: true,
-      signal: controller.signal,
+      abortController: controller,
     });
     const ctx = makeHookCtx();