@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -48,8 +48,6 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: false,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
   permissions: {},
 };
@@ -69,7 +67,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -126,10 +123,6 @@ mock.module("../tools/shared/filesystem/path-policy.js", () => ({
   hostPolicy: () => ({ ok: false }),
 }));
 
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: () => ({ command: "", sandboxed: false }),
-}));
-
 import { initializeDb } from "../memory/db-init.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
 import { ToolExecutor } from "../tools/executor.js";
@@ -172,8 +165,7 @@ describe("platform-hosted bash auto-approval", () => {
     riskOverride = "medium";
   });
 
-  afterEach(() => {
-  });
+  afterEach(() => {});
 
   test("bash auto-approved in platform-hosted mode", async () => {
     checkResultOverride = { decision: "prompt", reason: "Needs approval" };
@@ -242,19 +234,21 @@ describe("platform-hosted bash auto-approval", () => {
     await executor.execute(
       "bash",
       { command: "echo hello" },
-      makeContext({ isPlatformHosted: false, trustClass: "guardian", requireFreshApproval: true }),
+      makeContext({
+        isPlatformHosted: false,
+        trustClass: "guardian",
+        requireFreshApproval: true,
+      }),
     );
 
     expect(promptCalled).toBe(true);
   });
 
-  test("bash NOT auto-approved for non-guardian actors via platform path (sandbox bash is allowed)", async () => {
+  test("bash NOT auto-approved for non-guardian actors via platform path (trusted_contact requires grant)", async () => {
     checkResultOverride = { decision: "prompt", reason: "Needs approval" };
 
-    const platformAutoApproveCalled = false;
     const trackingPrompter = {
       prompt: async () => {
-        // If this is called, we know the platform auto-approve did NOT fire
         return { decision: "allow" as const };
       },
       resolveConfirmation: () => {},
@@ -266,14 +260,17 @@ describe("platform-hosted bash auto-approval", () => {
     const result = await executor.execute(
       "bash",
       { command: "echo hello" },
-      makeContext({ isPlatformHosted: true, trustClass: "trusted_contact", requireFreshApproval: true }),
+      makeContext({
+        isPlatformHosted: true,
+        trustClass: "trusted_contact",
+        requireFreshApproval: true,
+      }),
     );
 
-    // With requireFreshApproval, trusted_contact+bash goes through check()
-    // which returns "prompt" and then the interactive prompter is called.
-    // The platform auto-approve path (guardian-only) is NOT taken.
-    expect(result.isError).toBe(false);
-    void platformAutoApproveCalled; // suppress unused warning
+    // trusted_contact now requires a guardian-scoped grant for side-effect
+    // tools. Without a grant, the pre-execution gate denies the invocation
+    // before the permission checker or prompter is reached.
+    expect(result.isError).toBe(true);
   });
 
   test("bash NOT auto-approved when requireFreshApproval is set", async () => {
@@ -311,7 +308,11 @@ describe("platform-hosted bash auto-approval", () => {
     const result = await executor.execute(
       "bash",
       { command: "rm -rf /" },
-      makeContext({ isPlatformHosted: true, trustClass: "guardian", requireFreshApproval: true }),
+      makeContext({
+        isPlatformHosted: true,
+        trustClass: "guardian",
+        requireFreshApproval: true,
+      }),
     );
 
     expect(result.isError).toBe(true);
@@ -362,7 +363,11 @@ describe("platform-hosted bash auto-approval", () => {
     await executor.execute(
       "file_write",
       { path: "/tmp/test.txt", content: "hello" },
-      makeContext({ isPlatformHosted: true, trustClass: "guardian", requireFreshApproval: true }),
+      makeContext({
+        isPlatformHosted: true,
+        trustClass: "guardian",
+        requireFreshApproval: true,
+      }),
     );
 
     expect(promptCalled).toBe(true);

package/src/__tests__/prechat-onboarding-contract.test.ts

@@ -47,7 +47,6 @@ mock.module("../config/loader.js", () => ({
   }),
   loadConfig: () => mockLoadedConfig,
   loadRawConfig: () => ({}),
-  saveConfig: () => {},
   saveRawConfig: () => {},
   invalidateConfigCache: () => {},
   getNestedValue: () => undefined,
@@ -101,7 +100,7 @@ describe("pre-chat onboarding contract", () => {
       const context = {
         tools: ["slack", "linear"],
         tasks: ["code-building", "writing"],
-        tone: "balanced",
+        tone: "grounded",
         userName: "Alex",
         assistantName: "Pax",
       };
@@ -128,7 +127,7 @@ describe("pre-chat onboarding contract", () => {
       const context: OnboardingContext = {
         tools: ["figma"],
         tasks: ["design"],
-        tone: "casual",
+        tone: "energetic",
       };
 
       expect(context.userName).toBeUndefined();
@@ -146,7 +145,7 @@ describe("pre-chat onboarding contract", () => {
       const context = {
         tools: ["slack", "linear"],
         tasks: ["code-building"],
-        tone: "professional",
+        tone: "warm",
         userName: "Alex",
         assistantName: "Nova",
       };
@@ -163,13 +162,16 @@ describe("pre-chat onboarding contract", () => {
       expect(dynamic).toContain('"linear"');
       expect(dynamic).toContain('"tasks"');
       expect(dynamic).toContain('"code-building"');
-      expect(dynamic).toContain('"tone": "professional"');
+      expect(dynamic).toContain('"tone": "warm"');
       expect(dynamic).toContain('"userName": "Alex"');
       expect(dynamic).toContain('"assistantName": "Nova"');
       expect(dynamic).toContain("```json");
       expect(dynamic).toContain(
         "Use this to personalize your opener and skip redundant discovery.",
       );
+      expect(dynamic).toContain(
+        "If `assistantName` is present, it is the name the user chose for you; preserve it in IDENTITY.md.",
+      );
     });
 
     test("does NOT inject onboarding context when BOOTSTRAP.md does not exist", () => {
@@ -177,7 +179,7 @@ describe("pre-chat onboarding contract", () => {
       const context = {
         tools: ["slack"],
         tasks: ["writing"],
-        tone: "casual",
+        tone: "poetic",
         userName: "Alex",
       };
 
@@ -198,7 +200,7 @@ describe("pre-chat onboarding contract", () => {
       const context = {
         tools: ["figma"],
         tasks: ["design"],
-        tone: "balanced",
+        tone: "grounded",
       };
 
       const result = buildSystemPrompt({
@@ -226,6 +228,30 @@ describe("pre-chat onboarding contract", () => {
       expect(dynamic).not.toContain("## Pre-chat Onboarding Context");
     });
 
+    test("accepts all four personality tones", () => {
+      writeFileSync(
+        join(TEST_DIR, "BOOTSTRAP.md"),
+        "# Bootstrap\n\nOnboarding.",
+      );
+
+      const tones = ["grounded", "warm", "energetic", "poetic"] as const;
+
+      for (const tone of tones) {
+        const context = {
+          tools: ["slack"],
+          tasks: ["writing"],
+          tone,
+          userName: "Alex",
+        };
+
+        const result = buildSystemPrompt({ onboardingContext: context });
+        const dynamic = dynamicBlock(result);
+
+        expect(dynamic).toContain("## Pre-chat Onboarding Context");
+        expect(dynamic).toContain(`"tone": "${tone}"`);
+      }
+    });
+
     test("serializes onboarding context as pretty-printed JSON", () => {
       writeFileSync(
         join(TEST_DIR, "BOOTSTRAP.md"),
@@ -235,7 +261,7 @@ describe("pre-chat onboarding contract", () => {
       const context = {
         tools: ["notion"],
         tasks: ["project-management"],
-        tone: "balanced",
+        tone: "warm",
         userName: "Jane",
         assistantName: "Kit",
       };

package/src/__tests__/pricing.test.ts

@@ -57,6 +57,56 @@ describe("resolvePricing", () => {
   });
 
   describe("OpenAI models", () => {
+    test("prices GPT-5.4 Mini at current API rates", () => {
+      const result = resolvePricingForUsage("openai", "gpt-5.4-mini", {
+        directInputTokens: 1_000_000,
+        outputTokens: 1_000_000,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: 1_000_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBe(0.75 + 4.5 + 0.075);
+    });
+
+    test("uses OpenAI long-context tiers above 272k prompt tokens", () => {
+      const cases = [
+        ["gpt-5.5", 10 + 45 + 1],
+        ["gpt-5.5-pro", 60 + 270 + 60],
+        ["gpt-5.4", 5 + 22.5 + 0.5],
+      ] as const;
+
+      for (const [model, expectedCost] of cases) {
+        const result = resolvePricingForUsage("openai", model, {
+          directInputTokens: 272_001,
+          outputTokens: 1_000_000,
+          cacheCreationInputTokens: 727_999,
+          cacheReadInputTokens: 1_000_000,
+          anthropicCacheCreation: null,
+        });
+
+        expect(result.pricingStatus).toBe("priced");
+        expect(result.estimatedCostUsd).toBeCloseTo(expectedCost, 10);
+      }
+    });
+
+    test("uses OpenAI short-context tiers through 272k prompt tokens", () => {
+      const result = resolvePricingForUsage("openai", "gpt-5.4", {
+        directInputTokens: 272_000,
+        outputTokens: 1_000_000,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: 0,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBeCloseTo(
+        (272_000 / 1_000_000) * 2.5 + 15,
+        10,
+      );
+    });
+
     test("returns priced for gpt-4o", () => {
       const result = resolvePricing("openai", "gpt-4o", 1_000_000, 1_000_000);
       expect(result.pricingStatus).toBe("priced");
@@ -166,15 +216,29 @@ describe("resolvePricing", () => {
       expect(result.estimatedCostUsd).toBe(0.25 + 1.5);
     });
 
-    test("returns priced for gemini-2.5-pro", () => {
+    test("prices gemini-2.5-pro at the low-context tier through 200k input tokens", () => {
       const result = resolvePricing(
         "gemini",
         "gemini-2.5-pro",
+        200_000,
         1_000_000,
+      );
+      expect(result.pricingStatus).toBe("priced");
+      expect(result.estimatedCostUsd).toBe(0.25 + 10);
+    });
+
+    test("prices gemini-2.5-pro at the high-context tier above 200k input tokens", () => {
+      const result = resolvePricing(
+        "gemini",
+        "gemini-2.5-pro",
+        200_001,
         1_000_000,
       );
       expect(result.pricingStatus).toBe("priced");
-      expect(result.estimatedCostUsd).toBe(1.25 + 10);
+      expect(result.estimatedCostUsd).toBeCloseTo(
+        (200_001 / 1_000_000) * 2.5 + 15,
+        10,
+      );
     });
 
     test("returns priced for gemini-2.5-flash", () => {
@@ -296,7 +360,7 @@ describe("resolvePricing", () => {
         1_000_000,
       );
       expect(result.pricingStatus).toBe("priced");
-      expect(result.estimatedCostUsd).toBe(1.25 + 10);
+      expect(result.estimatedCostUsd).toBe(2.5 + 15);
     });
   });
 
@@ -427,7 +491,7 @@ describe("resolvePricingForUsage", () => {
       ["gemini-3.1-flash-lite-preview", 0.025],
       ["gemini-2.5-flash", 0.03],
       ["gemini-2.5-flash-lite", 0.01],
-      ["gemini-2.5-pro", 0.3125],
+      ["gemini-2.5-pro", 0.625],
     ] as const;
 
     for (const [model, expectedCost] of cases) {

package/src/__tests__/process-message-background-slack.test.ts

@@ -0,0 +1,333 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentsByIds: () => [],
+  getSourcePathsForAttachments: () => new Map<string, string>(),
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  createCanonicalGuardianRequest: () => ({
+    id: "canonical-id",
+    requestCode: "ABC123",
+  }),
+  generateCanonicalRequestCode: () => "ABC123",
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: async () => ({ id: "message-id" }),
+  getConversation: () => null,
+  provenanceFromTrustContext: () => ({}),
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+}));
+
+mock.module("../memory/conversation-disk-view.js", () => ({
+  updateMetaFile: () => {},
+}));
+
+mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
+  bridgeConfirmationRequestToGuardian: () => {},
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  register: () => {},
+  resolve: () => {},
+}));
+
+mock.module("../security/secret-scanner.js", () => ({
+  redactSecrets: (value: string) => value,
+}));
+
+mock.module("../tools/tool-input-summary.js", () => ({
+  summarizeToolInput: () => "",
+}));
+
+mock.module("../daemon/conversation-runtime-assembly.js", () => ({
+  resolveChannelCapabilities: () => ({
+    channel: "slack",
+    dashboardCapable: false,
+    supportsDynamicUi: false,
+    supportsVoiceInput: false,
+    chatType: "channel",
+  }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        contextWindow: { maxInputTokens: 100000 },
+      },
+    },
+  }),
+}));
+
+type Deferred<T> = {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (err: unknown) => void;
+};
+type PersistUserMessageMock = ReturnType<
+  typeof mock<
+    (
+      content: string,
+      attachments: unknown[],
+      requestId?: string,
+      metadata?: Record<string, unknown>,
+    ) => Promise<string>
+  >
+>;
+type RunAgentLoopMock = ReturnType<
+  typeof mock<(...args: unknown[]) => Promise<void>>
+>;
+type NoticeMock = ReturnType<typeof mock<(notice: string | undefined) => void>>;
+interface TestConversation {
+  conversationId: string;
+  trustContext: unknown;
+  authContext: unknown;
+  assistantId: string | undefined;
+  taskRunId: string | undefined;
+  isProcessing: () => boolean;
+  setAssistantId: (assistantId: string) => void;
+  setTrustContext: (ctx: unknown) => void;
+  setAuthContext: (ctx: unknown) => void;
+  ensureActorScopedHistory: () => Promise<void>;
+  setChannelCapabilities: () => void;
+  setHostCuProxy: () => void;
+  setHostAppControlProxy: () => void;
+  addPreactivatedSkillId: () => void;
+  setCommandIntent: () => void;
+  setTurnChannelContext: (ctx: TurnChannelContext) => void;
+  getTurnChannelContext: () => TurnChannelContext | null;
+  setTurnInterfaceContext: (ctx: TurnInterfaceContext) => void;
+  getTurnInterfaceContext: () => TurnInterfaceContext | null;
+  getMessages: () => unknown[];
+  usageStats: {
+    inputTokens: number;
+    outputTokens: number;
+    estimatedCost: number;
+  };
+  persistUserMessage: PersistUserMessageMock;
+  setSlackRuntimeContextNotice: NoticeMock;
+  runAgentLoop: RunAgentLoopMock;
+  updateClient: (sender: (...args: unknown[]) => void) => void;
+  getCurrentSender: () => ((...args: unknown[]) => void) | undefined;
+  __loopDeferred: Deferred<void>;
+  __noticeCalls: Array<string | undefined>;
+  __loopNotices: Array<string | undefined>;
+  __clientSenders: Array<((...args: unknown[]) => void) | undefined>;
+}
+
+let activeConversation: TestConversation;
+const mergeConversationOptionsMock = mock(() => {});
+
+mock.module("../daemon/conversation-store.js", () => ({
+  getOrCreateConversation: async () => activeConversation,
+  mergeConversationOptions: mergeConversationOptionsMock,
+}));
+
+import type {
+  TurnChannelContext,
+  TurnInterfaceContext,
+} from "../channels/types.js";
+import {
+  processMessage,
+  processMessageInBackground,
+} from "../daemon/process-message.js";
+
+function createDeferred<T = void>(): Deferred<T> {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (err: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+async function waitForRunAgentLoopCall(): Promise<void> {
+  for (let i = 0; i < 10; i++) {
+    if (activeConversation.runAgentLoop.mock.calls.length > 0) return;
+    await Promise.resolve();
+  }
+}
+
+function makeConversation(): TestConversation {
+  let turnChannelContext: TurnChannelContext | null = null;
+  let turnInterfaceContext: TurnInterfaceContext | null = null;
+  let slackNotice: string | undefined;
+  let currentSender: ((...args: unknown[]) => void) | undefined;
+  const noticeCalls: Array<string | undefined> = [];
+  const loopDeferred = createDeferred<void>();
+  const loopNotices: Array<string | undefined> = [];
+  const clientSenders: Array<((...args: unknown[]) => void) | undefined> = [];
+  const messages: unknown[] = [];
+
+  const conversation: TestConversation = {
+    conversationId: "conv-background-slack",
+    trustContext: undefined,
+    authContext: undefined,
+    assistantId: undefined,
+    taskRunId: undefined,
+    isProcessing: () => false,
+    setAssistantId: (assistantId: string) => {
+      conversation.assistantId = assistantId;
+    },
+    setTrustContext: (ctx: unknown) => {
+      conversation.trustContext = ctx;
+    },
+    setAuthContext: (ctx: unknown) => {
+      conversation.authContext = ctx;
+    },
+    ensureActorScopedHistory: async () => {},
+    setChannelCapabilities: () => {},
+    setHostCuProxy: () => {},
+    setHostAppControlProxy: () => {},
+    addPreactivatedSkillId: () => {},
+    setCommandIntent: () => {},
+    setTurnChannelContext: (ctx: TurnChannelContext) => {
+      turnChannelContext = ctx;
+    },
+    getTurnChannelContext: () => turnChannelContext,
+    setTurnInterfaceContext: (ctx: TurnInterfaceContext) => {
+      turnInterfaceContext = ctx;
+    },
+    getTurnInterfaceContext: () => turnInterfaceContext,
+    getMessages: () => messages,
+    usageStats: {
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCost: 0,
+    },
+    persistUserMessage: mock(
+      async (
+        _content: string,
+        _attachments: unknown[],
+        _requestId?: string,
+        _metadata?: Record<string, unknown>,
+      ) => "persisted-user-message-id",
+    ),
+    setSlackRuntimeContextNotice: mock((notice: string | undefined) => {
+      slackNotice = notice;
+      noticeCalls.push(notice);
+    }),
+    runAgentLoop: mock(async (..._args: unknown[]) => {
+      loopNotices.push(slackNotice);
+      await loopDeferred.promise;
+    }),
+    updateClient: (sender: (...args: unknown[]) => void) => {
+      currentSender = sender;
+      clientSenders.push(sender);
+    },
+    getCurrentSender: () => currentSender,
+    __loopDeferred: loopDeferred,
+    __noticeCalls: noticeCalls,
+    __loopNotices: loopNotices,
+    __clientSenders: clientSenders,
+  };
+
+  return conversation;
+}
+
+describe("processMessageInBackground Slack option propagation", () => {
+  beforeEach(() => {
+    activeConversation = makeConversation();
+    mergeConversationOptionsMock.mockClear();
+  });
+
+  test("passes Slack inbound metadata to persistence and exposes the runtime notice during the loop", async () => {
+    const slackInbound = {
+      channelId: "C0123CHANNEL",
+      channelTs: "1700000001.111111",
+      threadTs: "1700000000.000001",
+      displayName: "Alice",
+    };
+    const notice =
+      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
+
+    const result = await processMessageInBackground(
+      "conv-background-slack",
+      "Reply from Slack",
+      undefined,
+      {
+        slackInbound,
+        slackRuntimeContextNotice: notice,
+      },
+      "slack",
+      "slack",
+    );
+
+    expect(result).toEqual({ messageId: "persisted-user-message-id" });
+    expect(activeConversation.persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(activeConversation.persistUserMessage.mock.calls[0][3]).toEqual({
+      slackInbound,
+    });
+    expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
+    expect(activeConversation.__loopNotices).toEqual([notice]);
+
+    activeConversation.__loopDeferred.resolve();
+    await activeConversation.__loopDeferred.promise;
+    await Promise.resolve();
+
+    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
+  });
+
+  test("clears the Slack runtime notice after normal message processing", async () => {
+    const notice =
+      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
+
+    const processing = processMessage(
+      "conv-background-slack",
+      "Reply from Slack",
+      undefined,
+      {
+        slackRuntimeContextNotice: notice,
+        isInteractive: true,
+      },
+      "slack",
+      "slack",
+    );
+
+    await waitForRunAgentLoopCall();
+
+    expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
+    expect(activeConversation.__loopNotices).toEqual([notice]);
+
+    activeConversation.__loopDeferred.resolve();
+    await expect(processing).resolves.toEqual({
+      messageId: "persisted-user-message-id",
+    });
+
+    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
+    expect(activeConversation.__clientSenders).toHaveLength(2);
+  });
+
+  test("leaves non-Slack background persistence metadata absent", async () => {
+    await processMessageInBackground(
+      "conv-background-slack",
+      "Regular background wake",
+      undefined,
+      undefined,
+      "vellum",
+      "web",
+    );
+
+    expect(activeConversation.persistUserMessage).toHaveBeenCalledTimes(1);
+    expect(
+      activeConversation.persistUserMessage.mock.calls[0][3],
+    ).toBeUndefined();
+    expect(activeConversation.runAgentLoop.mock.calls[0][3]).toEqual({
+      isInteractive: false,
+      isUserMessage: true,
+    });
+
+    activeConversation.__loopDeferred.resolve();
+  });
+});

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -46,7 +46,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => currentConfig,
   loadConfig: () => currentConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,