@vellumai/assistant 0.7.2 → 0.7.3

package/src/__tests__/injector-disk-pressure.test.ts

@@ -0,0 +1,224 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import {
+  applyRuntimeInjections,
+  stripInjectionsForCompaction,
+} from "../daemon/conversation-runtime-assembly.js";
+import {
+  DEFAULT_INJECTOR_ORDER,
+  defaultInjectorsPlugin,
+  DISK_PRESSURE_WARNING_PROMPT,
+} from "../plugins/defaults/injectors.js";
+import {
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import type { Injector, TurnContext } from "../plugins/types.js";
+import type { Message } from "../providers/types.js";
+
+function findInjector(name: string): Injector {
+  const injector = defaultInjectorsPlugin.injectors?.find(
+    (candidate) => candidate.name === name,
+  );
+  if (!injector) {
+    throw new Error(`injector '${name}' not registered`);
+  }
+  return injector;
+}
+
+function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
+  return {
+    requestId: "req-test",
+    conversationId: "conv-test",
+    turnIndex: 0,
+    trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    ...overrides,
+  };
+}
+
+function tailTexts(messages: Message[]): string[] {
+  const tail = messages[messages.length - 1];
+  if (!tail || tail.role !== "user") return [];
+  return tail.content
+    .filter((block): block is { type: "text"; text: string } => {
+      return block.type === "text";
+    })
+    .map((block) => block.text);
+}
+
+const diskPressureInjector = findInjector("disk-pressure-warning");
+const cleanupContext = { cleanupModeActive: true };
+
+describe("disk-pressure-warning injector", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultInjectorsPlugin);
+    _setOverridesForTesting({ "safe-storage-limits": true });
+  });
+
+  test("emits the exact cleanup prompt while safe storage limits are enabled", async () => {
+    const block = await diskPressureInjector.produce(
+      makeContext({
+        injectionInputs: { diskPressureContext: cleanupContext },
+      }),
+    );
+
+    expect(block).toEqual({
+      id: "disk-pressure-warning",
+      text: DISK_PRESSURE_WARNING_PROMPT,
+      placement: "prepend-user-tail",
+    });
+    expect(diskPressureInjector.order).toBe(
+      DEFAULT_INJECTOR_ORDER.diskPressureWarning,
+    );
+    expect(DISK_PRESSURE_WARNING_PROMPT).toBe(`<disk_pressure_warning>
+Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is at least 95% full.
+
+In your first paragraph, warn the user that storage is critically low and that normal work is suspended until space is freed.
+
+Then help the user clean up storage. Prefer safe inspection steps first, such as checking available space and finding large directories. Ask before deleting files or caches unless the user has already clearly approved the specific cleanup action.
+
+Do not work on unrelated tasks until disk usage drops below the critical threshold or the user explicitly overrides the lock. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
+</disk_pressure_warning>`);
+  });
+
+  test("omits the prompt when cleanup context is null or inactive", async () => {
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({ injectionInputs: { diskPressureContext: null } }),
+      ),
+    ).resolves.toBeNull();
+
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({
+          injectionInputs: {
+            diskPressureContext: { cleanupModeActive: false },
+          },
+        }),
+      ),
+    ).resolves.toBeNull();
+  });
+
+  test("omits the prompt when safe storage limits are disabled", async () => {
+    _setOverridesForTesting({ "safe-storage-limits": false });
+
+    await expect(
+      diskPressureInjector.produce(
+        makeContext({
+          injectionInputs: { diskPressureContext: cleanupContext },
+        }),
+      ),
+    ).resolves.toBeNull();
+  });
+
+  test("prepends ahead of workspace and unified turn context in full mode", async () => {
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "clean up space" }] },
+    ];
+    const workspace = "<workspace>\nRoot: /workspace\n</workspace>";
+    const turnContext = "<turn_context>\ninterface: macos\n</turn_context>";
+
+    const result = await applyRuntimeInjections(runMessages, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+      workspaceTopLevelContext: workspace,
+      unifiedTurnContext: turnContext,
+    });
+
+    expect(tailTexts(result.messages).slice(0, 4)).toEqual([
+      DISK_PRESSURE_WARNING_PROMPT,
+      workspace,
+      turnContext,
+      "clean up space",
+    ]);
+    expect(
+      result.blocks.injectorChainBlock?.startsWith(
+        DISK_PRESSURE_WARNING_PROMPT,
+      ),
+    ).toBe(true);
+  });
+
+  test("survives minimal mode as safety-critical context", async () => {
+    const result = await applyRuntimeInjections(
+      [{ role: "user", content: [{ type: "text", text: "status" }] }],
+      {
+        turnContext: makeContext(),
+        mode: "minimal",
+        diskPressureContext: cleanupContext,
+        workspaceTopLevelContext: "<workspace>...</workspace>",
+        unifiedTurnContext: "<turn_context>...</turn_context>",
+      },
+    );
+
+    expect(tailTexts(result.messages)).toEqual([
+      DISK_PRESSURE_WARNING_PROMPT,
+      "<turn_context>...</turn_context>",
+      "status",
+    ]);
+  });
+
+  test("applies after Slack chronological transcript replacement", async () => {
+    const originalRun: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "latest raw user text" }],
+      },
+    ];
+    const slackTranscript: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "[12:00 user]: earlier" }],
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "[12:01 @assistant]: cleanup?" }],
+      },
+    ];
+
+    const result = await applyRuntimeInjections(originalRun, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+      channelCapabilities: {
+        channel: "slack",
+        dashboardCapable: false,
+        supportsDynamicUi: false,
+        supportsVoiceInput: false,
+        chatType: "channel",
+      },
+      slackChronologicalMessages: slackTranscript,
+    });
+
+    expect(result.messages).toHaveLength(2);
+    const texts = tailTexts(result.messages);
+    expect(texts[0]).toBe(DISK_PRESSURE_WARNING_PROMPT);
+    expect(
+      texts.some((text) => text.startsWith("<channel_capabilities>")),
+    ).toBe(true);
+    expect(texts[texts.length - 1]).toBe("[12:01 @assistant]: cleanup?");
+  });
+
+  test("compaction strip plus re-apply does not duplicate the warning", async () => {
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "find large files" }] },
+    ];
+
+    const first = await applyRuntimeInjections(runMessages, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+    });
+    const stripped = stripInjectionsForCompaction(first.messages);
+    expect(tailTexts(stripped)).toEqual(["find large files"]);
+
+    const second = await applyRuntimeInjections(stripped, {
+      turnContext: makeContext(),
+      diskPressureContext: cleanupContext,
+    });
+    expect(
+      tailTexts(second.messages).filter(
+        (text) => text === DISK_PRESSURE_WARNING_PROMPT,
+      ),
+    ).toHaveLength(1);
+  });
+});

package/src/__tests__/managed-profile-guard.test.ts

@@ -125,6 +125,16 @@ describe("PUT /v1/config/llm/profiles/:name — managed profile guard", () => {
     ).toThrow(BadRequestError);
   });
 
+  test("allows edits to custom-balanced (user-owned)", () => {
+    savedRaw = null;
+    const result = replaceRoute.handler({
+      pathParams: { name: "custom-balanced" },
+      body: { provider: "openai", model: "gpt-4o" },
+    });
+    expect(result).toEqual({ ok: true });
+    expect(savedRaw).not.toBeNull();
+  });
+
   test("allows edits to a user-defined profile", () => {
     savedRaw = null;
     const result = replaceRoute.handler({
@@ -165,6 +175,14 @@ describe("PATCH /v1/config — managed profile deletion guard", () => {
     ).rejects.toThrow(BadRequestError);
   });
 
+  test("allows deletion of custom-balanced via null (user-owned)", async () => {
+    savedRaw = null;
+    const result = await patchRoute.handler({
+      body: { llm: { profiles: { "custom-balanced": null } } },
+    });
+    expect(result).toEqual({ ok: true });
+  });
+
   test("allows deletion of a user-defined profile via null", async () => {
     savedRaw = null;
     const result = await patchRoute.handler({

package/src/__tests__/mcp-abort-signal.test.ts

@@ -122,6 +122,136 @@ describe("MCP AbortSignal threading", () => {
   });
 
   describe("createMcpTool execute", () => {
+    test("keeps safe MCP tool names unchanged", () => {
+      const fakeManager = { callTool: jest.fn() } as any;
+
+      const tool = createMcpTool(
+        {
+          name: "my-tool",
+          description: "A test tool",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "test-server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(tool.name).toBe("mcp__test-server__my-tool");
+      expect(tool.getDefinition().name).toBe("mcp__test-server__my-tool");
+    });
+
+    test("keeps MCP tool names with trailing whitespace distinct", () => {
+      const fakeManager = { callTool: jest.fn() } as any;
+
+      const plain = createMcpTool(
+        {
+          name: "deploy",
+          description: "Deploy",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "test-server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+      const padded = createMcpTool(
+        {
+          name: "deploy ",
+          description: "Deploy padded",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "test-server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(plain.name).toBe("mcp__test-server__deploy");
+      expect(padded.name).toMatch(/^mcp__test-server__deploy__[a-f0-9]{12}$/);
+      expect(padded.name).not.toBe(plain.name);
+    });
+
+    test("exposes provider-safe MCP names while preserving raw execution names", async () => {
+      const callToolSpy = jest.fn().mockResolvedValue({
+        content: "tool result",
+        isError: false,
+      });
+      const fakeManager = { callTool: callToolSpy } as any;
+
+      const tool = createMcpTool(
+        {
+          name: "create link",
+          description: "Create a Stripe Link CLI resource",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "stripe.link-cli",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(tool.name).toMatch(/^[a-zA-Z0-9_-]{1,64}$/);
+      expect(tool.name.startsWith("mcp__stripe_link-cli__create_link__")).toBe(
+        true,
+      );
+      expect(tool.getDefinition().name).toBe(tool.name);
+
+      await tool.execute(
+        { someArg: "value" },
+        {
+          workingDir: "/tmp",
+          conversationId: "conv-1",
+          trustClass: "guardian",
+        },
+      );
+
+      expect(callToolSpy).toHaveBeenCalledWith(
+        "stripe.link-cli",
+        "create link",
+        { someArg: "value" },
+        undefined,
+      );
+    });
+
+    test("caps long MCP names at the provider limit", () => {
+      const fakeManager = { callTool: jest.fn() } as any;
+      const tool = createMcpTool(
+        {
+          name: "x".repeat(180),
+          description: "A test tool",
+          inputSchema: { type: "object", properties: {} },
+        },
+        "server",
+        {
+          transport: { type: "stdio", command: "echo", args: [] },
+          enabled: true,
+          defaultRiskLevel: "high",
+          maxTools: 100,
+        },
+        fakeManager,
+      );
+
+      expect(tool.name).toHaveLength(64);
+      expect(tool.name).toMatch(/^[a-zA-Z0-9_-]{1,64}$/);
+    });
+
     test("threads context.signal through manager.callTool", async () => {
       const callToolSpy = jest.fn().mockResolvedValue({
         content: "tool result",

package/src/__tests__/memory-admin-recall.test.ts

@@ -15,7 +15,6 @@ interface CapturedSearch {
 
 const capturedSearches: CapturedSearch[] = [];
 const getConfiguredProviderCalls: string[] = [];
-const scopeByConversation = new Map<string, string | undefined>();
 const testConfig = {} as AssistantConfig;
 
 mock.module("../config/loader.js", () => ({
@@ -56,13 +55,11 @@ mock.module("../memory/embedding-backend.js", () => ({
 
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: "msg-1" }),
-  createConversation: () => ({ id: "conv-1", memoryScopeId: "default" }),
+  createConversation: () => ({ id: "conv-1" }),
   deleteConversation: () => true,
   getAssistantMessageIdsInTurn: () => [],
   getConversation: () => null,
   getConversationHostAccess: () => false,
-  getConversationMemoryScopeId: (conversationId: string) =>
-    scopeByConversation.get(conversationId),
   getConversationOverrideProfile: () => undefined,
   getConversationSource: () => null,
   getMessageById: () => null,
@@ -165,12 +162,9 @@ describe("memory admin recall", () => {
   beforeEach(() => {
     capturedSearches.length = 0;
     getConfiguredProviderCalls.length = 0;
-    scopeByConversation.clear();
   });
 
-  test("uses the conversation memory scope and safe admin sources", async () => {
-    scopeByConversation.set("conv-admin", "scope-admin");
-
+  test("uses safe admin sources", async () => {
     const result = await queryMemory("launch notes", "conv-admin");
 
     expect(capturedSearches).toHaveLength(1);
@@ -180,7 +174,6 @@ describe("memory admin recall", () => {
     });
     expect(capturedSearches[0].context).toMatchObject({
       workingDir: getWorkspaceDir(),
-      memoryScopeId: "scope-admin",
       conversationId: "conv-admin",
       config: testConfig,
     });
@@ -202,13 +195,12 @@ describe("memory admin recall", () => {
     });
   });
 
-  test("falls back to default scope without invoking a provider", async () => {
+  test("does not invoke a provider for deterministic recall", async () => {
     await queryMemory("offline recall", "missing-conversation");
 
     expect(capturedSearches).toHaveLength(1);
     expect(capturedSearches[0].context).toMatchObject({
       workingDir: getWorkspaceDir(),
-      memoryScopeId: "default",
       conversationId: "missing-conversation",
     });
     expect(capturedSearches[0].input.sources).toEqual([

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

@@ -158,6 +158,27 @@ describe("runDefaultMemoryRetrieval", () => {
     expect(result.nowContent).toBe("now-default");
   });
 
+  test("propagates errors from prepareMemory rather than swallowing them", async () => {
+    // Memory is critical — failures must surface to the caller (the agent
+    // loop) rather than silently degrading to an empty memory block.
+    const failingPrepare = mock(
+      (
+        _msgs: Message[],
+        _cfg: AssistantConfig,
+        _signal: AbortSignal,
+        _onEvent: (msg: ServerMessage) => void,
+      ) => Promise.reject(new Error("retrieval failed")),
+    );
+    const graphMemory = {
+      prepareMemory: failingPrepare,
+    } as unknown as ConversationGraphMemory;
+    const deps = makeDeps({ graphMemory, isTrustedActor: true });
+
+    await expect(
+      runDefaultMemoryRetrieval(makeMemoryArgs(), deps),
+    ).rejects.toThrow("retrieval failed");
+  });
+
   test("passes through null PKB and NOW when the files are absent", async () => {
     readPkbContextMock.mockImplementation(() => null);
     readNowContextMock.mockImplementation(() => null);
@@ -314,7 +335,7 @@ describe("memoryRetrieval pipeline — default vs custom plugin", () => {
         (innerArgs: MemoryArgs) => runDefaultMemoryRetrieval(innerArgs, deps),
         args,
         makeTurnCtx(),
-        30, // tiny budget — real production path uses 5_000ms
+        30, // tiny pipeline budget to keep the test fast
       );
     } catch (err) {
       caught = err;

package/src/__tests__/normalize-onboarding.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  normalizeOnboardingContext,
+  normalizeTasks,
+  normalizeTools,
+  TASK_DISPLAY_LABELS,
+  TOOL_DISPLAY_NAMES,
+} from "../prompts/normalize-onboarding.js";
+import type { OnboardingContext } from "../types/onboarding-context.js";
+
+describe("normalizeTools", () => {
+  test("known tool IDs produce display labels", () => {
+    expect(normalizeTools(["github"])).toEqual(["GitHub"]);
+    expect(normalizeTools(["google-calendar"])).toEqual(["Google Calendar"]);
+    expect(normalizeTools(["slack"])).toEqual(["Slack"]);
+    expect(normalizeTools(["notion"])).toEqual(["Notion"]);
+    expect(normalizeTools(["linear"])).toEqual(["Linear"]);
+    expect(normalizeTools(["gmail"])).toEqual(["Gmail"]);
+    expect(normalizeTools(["google-drive"])).toEqual(["Google Drive"]);
+    expect(normalizeTools(["figma"])).toEqual(["Figma"]);
+    expect(normalizeTools(["jira"])).toEqual(["Jira"]);
+    expect(normalizeTools(["outlook"])).toEqual(["Outlook"]);
+    expect(normalizeTools(["excel"])).toEqual(["Excel"]);
+    expect(normalizeTools(["apple-notes"])).toEqual(["Apple Notes"]);
+  });
+
+  test("all known tool IDs from the client onboarding UI are mapped", () => {
+    const clientToolIds = [
+      "gmail",
+      "outlook",
+      "google-calendar",
+      "slack",
+      "notion",
+      "linear",
+      "jira",
+      "github",
+      "figma",
+      "google-drive",
+      "excel",
+      "apple-notes",
+    ];
+    expect(Object.keys(TOOL_DISPLAY_NAMES)).toEqual(
+      expect.arrayContaining(clientToolIds),
+    );
+    expect(Object.keys(TOOL_DISPLAY_NAMES)).toHaveLength(clientToolIds.length);
+  });
+
+  test("unknown/custom tool IDs pass through with first-letter capitalization", () => {
+    expect(normalizeTools(["trello"])).toEqual(["Trello"]);
+    expect(normalizeTools(["asana"])).toEqual(["Asana"]);
+  });
+
+  test("mixed known and unknown IDs normalize correctly", () => {
+    expect(normalizeTools(["github", "trello", "slack"])).toEqual([
+      "GitHub",
+      "Trello",
+      "Slack",
+    ]);
+  });
+
+  test("empty array produces empty array", () => {
+    expect(normalizeTools([])).toEqual([]);
+  });
+});
+
+describe("normalizeTasks", () => {
+  test("known task IDs produce plain-language labels", () => {
+    expect(normalizeTasks(["code-building"])).toEqual([
+      "builds code, apps, or tools",
+    ]);
+    expect(normalizeTasks(["writing"])).toEqual([
+      "writes docs, emails, or content",
+    ]);
+    expect(normalizeTasks(["research"])).toEqual([
+      "does research and analysis",
+    ]);
+    expect(normalizeTasks(["project-management"])).toEqual([
+      "plans and coordinates work",
+    ]);
+    expect(normalizeTasks(["scheduling"])).toEqual([
+      "handles meetings, calendar, and logistics",
+    ]);
+    expect(normalizeTasks(["personal"])).toEqual(["handles life admin"]);
+  });
+
+  test("all six known task IDs are mapped", () => {
+    const knownIds = [
+      "code-building",
+      "writing",
+      "research",
+      "project-management",
+      "scheduling",
+      "personal",
+    ];
+    expect(Object.keys(TASK_DISPLAY_LABELS)).toEqual(
+      expect.arrayContaining(knownIds),
+    );
+    expect(Object.keys(TASK_DISPLAY_LABELS)).toHaveLength(knownIds.length);
+  });
+
+  test("unknown/custom task IDs pass through unchanged", () => {
+    expect(normalizeTasks(["data-entry"])).toEqual(["data-entry"]);
+    expect(normalizeTasks(["custom-workflow"])).toEqual(["custom-workflow"]);
+  });
+
+  test("mixed known and unknown IDs normalize correctly", () => {
+    expect(normalizeTasks(["writing", "data-entry", "research"])).toEqual([
+      "writes docs, emails, or content",
+      "data-entry",
+      "does research and analysis",
+    ]);
+  });
+
+  test("empty array produces empty array", () => {
+    expect(normalizeTasks([])).toEqual([]);
+  });
+});
+
+describe("normalizeOnboardingContext", () => {
+  test("maps userName to preferredName", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      userName: "Alice",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.preferredName).toBe("Alice");
+  });
+
+  test("absent userName yields undefined preferredName", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "professional",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.preferredName).toBeUndefined();
+  });
+
+  test("tone passes through", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "casual",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.tone).toBe("casual");
+  });
+
+  test("assistantName passes through", () => {
+    const ctx: OnboardingContext = {
+      tools: [],
+      tasks: [],
+      tone: "friendly",
+      assistantName: "Jarvis",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result.assistantName).toBe("Jarvis");
+  });
+
+  test("normalizes tools and tasks together", () => {
+    const ctx: OnboardingContext = {
+      tools: ["github", "trello"],
+      tasks: ["code-building", "data-entry"],
+      tone: "professional",
+      userName: "Bob",
+      assistantName: "Friday",
+    };
+    const result = normalizeOnboardingContext(ctx);
+    expect(result).toEqual({
+      preferredName: "Bob",
+      commonWork: ["builds code, apps, or tools", "data-entry"],
+      dailyTools: ["GitHub", "Trello"],
+      tone: "professional",
+      assistantName: "Friday",
+    });
+  });
+});