@vellumai/assistant 0.5.12 → 0.5.14

package/src/__tests__/conversation-speed-override.test.ts

@@ -0,0 +1,326 @@
+/**
+ * Tests for per-conversation speed override.
+ *
+ * Verifies that the Conversation constructor resolves speed from the
+ * per-conversation speedOverride parameter first, falling back to the
+ * global config speed setting.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import type {
+  AgentEvent,
+  AgentLoopConfig,
+  CheckpointDecision,
+  CheckpointInfo,
+} from "../agent/loop.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { Message, ProviderResponse } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// Mocks — must precede Conversation import
+// ---------------------------------------------------------------------------
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../memory/guardian-action-store.js", () => ({
+  getGuardianActionRequest: () => null,
+  resolveGuardianActionRequest: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: () => {},
+}));
+
+// Controllable config mock — speed and feature flag behavior are test-specific.
+let mockConfigSpeed: "standard" | "fast" = "fast";
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    provider: "mock-provider",
+    maxTokens: 4096,
+    thinking: false,
+    speed: mockConfigSpeed,
+    effort: "high",
+    contextWindow: {
+      maxInputTokens: 100000,
+      thresholdTokens: 80000,
+      preserveRecentMessages: 6,
+      summaryModel: "mock-model",
+      maxSummaryTokens: 512,
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    timeouts: { permissionTimeoutSec: 1 },
+    skills: { entries: {}, allowBundled: true },
+    permissions: { mode: "workspace" },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+// Feature flag mock — fast-mode enabled for all tests in this file.
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) => {
+    if (key === "fast-mode") return true;
+    return true;
+  },
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../config/skills.js", () => ({
+  loadSkillCatalog: () => [],
+  loadSkillBySelector: () => ({ skill: null }),
+  ensureSkillIcon: async () => null,
+}));
+
+mock.module("../config/skill-state.js", () => ({
+  resolveSkillStates: () => [],
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  addRule: () => {},
+  findHighestPriorityRule: () => null,
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationType: () => "default",
+  setConversationOriginChannelIfUnset: () => {},
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => [],
+  getConversation: () => ({
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  }),
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: () => ({ id: `msg-${Date.now()}` }),
+  updateConversationUsage: () => {},
+  updateConversationTitle: () => {},
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  uploadAttachment: () => ({ id: `att-${Date.now()}` }),
+  linkAttachmentToMessage: () => {},
+}));
+
+mock.module("../memory/retriever.js", () => ({
+  buildMemoryRecall: async () => ({
+    enabled: false,
+    degraded: false,
+    injectedText: "",
+    semanticHits: 0,
+    injectedTokens: 0,
+    latencyMs: 0,
+  }),
+  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
+}));
+
+mock.module("../context/window-manager.js", () => ({
+  ContextWindowManager: class {
+    constructor() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../memory/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "mock-id", createdAt: Date.now() }),
+  listUsageEvents: () => [],
+}));
+
+// Capture AgentLoop constructor config for assertions.
+let lastAgentLoopConfig: Partial<AgentLoopConfig> | undefined;
+
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    constructor(
+      _provider: unknown,
+      _systemPrompt: string,
+      config?: Partial<AgentLoopConfig>,
+    ) {
+      lastAgentLoopConfig = config;
+    }
+    getToolTokenBudget() {
+      return 0;
+    }
+    async run(
+      _messages: Message[],
+      _onEvent: (event: AgentEvent) => void,
+      _signal?: AbortSignal,
+      _requestId?: string,
+      _onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+    ): Promise<Message[]> {
+      return [];
+    }
+  },
+}));
+
+mock.module("../memory/canonical-guardian-store.js", () => ({
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
+  createCanonicalGuardianRequest: () => ({
+    id: "mock-cg-id",
+    code: "MOCK",
+    status: "pending",
+  }),
+  getCanonicalGuardianRequest: () => null,
+  getCanonicalGuardianRequestByCode: () => null,
+  updateCanonicalGuardianRequest: () => {},
+  resolveCanonicalGuardianRequest: () => {},
+  createCanonicalGuardianDelivery: () => ({ id: "mock-cgd-id" }),
+  listCanonicalGuardianDeliveries: () => [],
+  listPendingCanonicalGuardianRequestsByDestinationChat: () => [],
+  updateCanonicalGuardianDelivery: () => {},
+  generateCanonicalRequestCode: () => "MOCK-CODE",
+}));
+
+// ---------------------------------------------------------------------------
+// Import Conversation AFTER mocks
+// ---------------------------------------------------------------------------
+
+import { Conversation } from "../daemon/conversation.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeProvider() {
+  return {
+    name: "mock",
+    async sendMessage(): Promise<ProviderResponse> {
+      return {
+        content: [],
+        model: "mock",
+        usage: { inputTokens: 0, outputTokens: 0 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+function makeSendToClient(): (msg: ServerMessage) => void {
+  return () => {};
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("per-conversation speed override", () => {
+  test("speedOverride 'standard' prevents fast mode even when global config is 'fast'", () => {
+    mockConfigSpeed = "fast";
+    lastAgentLoopConfig = undefined;
+
+    new Conversation(
+      "conv-speed-override-1",
+      makeProvider(),
+      "system prompt",
+      4096,
+      makeSendToClient(),
+      "/tmp",
+      undefined, // broadcastToAllClients
+      undefined, // memoryPolicy
+      undefined, // sharedCesClient
+      "standard", // speedOverride
+    );
+
+    expect(lastAgentLoopConfig).toBeDefined();
+    // When speedOverride is "standard", the AgentLoop should NOT receive speed: "fast"
+    expect(lastAgentLoopConfig!.speed).toBeUndefined();
+  });
+
+  test("no speedOverride uses global config speed", () => {
+    mockConfigSpeed = "fast";
+    lastAgentLoopConfig = undefined;
+
+    new Conversation(
+      "conv-speed-global-1",
+      makeProvider(),
+      "system prompt",
+      4096,
+      makeSendToClient(),
+      "/tmp",
+      undefined, // broadcastToAllClients
+      undefined, // memoryPolicy
+      undefined, // sharedCesClient
+      // no speedOverride — should fall back to global config "fast"
+    );
+
+    expect(lastAgentLoopConfig).toBeDefined();
+    expect(lastAgentLoopConfig!.speed).toBe("fast");
+  });
+
+  test("speedOverride 'fast' enables fast mode even when global config is 'standard'", () => {
+    mockConfigSpeed = "standard";
+    lastAgentLoopConfig = undefined;
+
+    new Conversation(
+      "conv-speed-override-fast-1",
+      makeProvider(),
+      "system prompt",
+      4096,
+      makeSendToClient(),
+      "/tmp",
+      undefined, // broadcastToAllClients
+      undefined, // memoryPolicy
+      undefined, // sharedCesClient
+      "fast", // speedOverride
+    );
+
+    expect(lastAgentLoopConfig).toBeDefined();
+    expect(lastAgentLoopConfig!.speed).toBe("fast");
+  });
+});

package/src/__tests__/conversation-starter-routes.test.ts

@@ -1,25 +1,7 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { v4 as uuid } from "uuid";
 
-const testDir = mkdtempSync(
-  join(tmpdir(), "conversation-starter-routes-test-"),
-);
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -37,11 +19,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 const routes = conversationStarterRouteDefinitions();

package/src/__tests__/conversation-store.test.ts

@@ -1,21 +1,5 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "conv-store-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -47,11 +31,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 describe("deleteLastExchange", () => {

package/src/__tests__/conversation-unread-route.test.ts

@@ -1,24 +1,5 @@
-import { mkdtempSync, realpathSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = realpathSync(
-  mkdtempSync(join(tmpdir(), "conversation-unread-route-test-")),
-);
-
-mock.module("../util/platform.js", () => ({
-  getRootDir: () => testDir,
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -64,11 +45,6 @@ describe("POST /v1/conversations/unread", () => {
 
   afterAll(async () => {
     await server?.stop();
-    try {
-      rmSync(testDir, { recursive: true, force: true });
-    } catch {
-      /* best effort */
-    }
   });
 
   async function startServer(): Promise<void> {

package/src/__tests__/conversation-usage.test.ts

@@ -1,10 +1,5 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "session-usage-test-"));
-
 const updateConversationUsageCalls: Array<{
   conversationId: string;
   inputTokens: number;
@@ -12,17 +7,6 @@ const updateConversationUsageCalls: Array<{
   estimatedCost: number;
 }> = [];
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -62,11 +46,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 describe("recordUsage", () => {
@@ -76,6 +55,62 @@ describe("recordUsage", () => {
     updateConversationUsageCalls.length = 0;
   });
 
+  test("applies fast mode pricing when any response has speed: fast", () => {
+    const usageStats = {
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCost: 0,
+    };
+
+    // First response is standard, second is fast — should detect fast
+    const rawResponses = [
+      { usage: { speed: "standard" } },
+      { usage: { speed: "fast" } },
+    ];
+
+    recordUsage(
+      {
+        conversationId: "conv-speed-1",
+        providerName: "anthropic",
+        usageStats,
+      },
+      1_000_000,
+      1_000_000,
+      "claude-opus-4-6",
+      () => {},
+      "main_agent",
+      "req-speed-1",
+      0,
+      0,
+      rawResponses,
+    );
+
+    const events = listUsageEvents();
+    expect(events).toHaveLength(1);
+
+    // With fast mode, pricing should use the 6x multiplier
+    const fastUsage: PricingUsage = {
+      directInputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+      cacheCreationInputTokens: 0,
+      cacheReadInputTokens: 0,
+      anthropicCacheCreation: null,
+      speed: "fast",
+    };
+    const expectedPricing = resolvePricingForUsageWithOverrides(
+      "anthropic",
+      "claude-opus-4-6",
+      fastUsage,
+      [],
+    );
+
+    expect(events[0].estimatedCostUsd).toBe(
+      expectedPricing.estimatedCostUsd ?? null,
+    );
+    // Sanity: fast should be 6x standard ($30 * 6 = $180)
+    expect(expectedPricing.estimatedCostUsd).toBe(180);
+  });
+
   test("stores direct input separately from Anthropic cache usage while keeping live totals combined", () => {
     const usageStats = {
       inputTokens: 0,

package/src/__tests__/conversation-wipe.test.ts

@@ -1,21 +1,5 @@
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-const testDir = mkdtempSync(join(tmpdir(), "conv-wipe-test-"));
-
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => testDir,
-  isMacOS: () => process.platform === "darwin",
-  isLinux: () => process.platform === "linux",
-  isWindows: () => process.platform === "win32",
-  getPidPath: () => join(testDir, "test.pid"),
-  getDbPath: () => join(testDir, "test.db"),
-  getLogPath: () => join(testDir, "test.log"),
-  ensureDataDir: () => {},
-}));
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -39,11 +23,6 @@ initializeDb();
 
 afterAll(() => {
   resetDb();
-  try {
-    rmSync(testDir, { recursive: true });
-  } catch {
-    /* best effort */
-  }
 });
 
 describe("wipeConversation", () => {

package/src/__tests__/conversation-workspace-cache-state.test.ts

@@ -16,10 +16,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: () => {},

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -21,10 +21,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../memory/guardian-action-store.js", () => ({
   getGuardianActionRequest: () => null,
   resolveGuardianActionRequest: () => {},

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -18,10 +18,6 @@ mock.module("../util/logger.js", () => ({
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
 }));
 
-mock.module("../util/platform.js", () => ({
-  getDataDir: () => "/tmp",
-}));
-
 mock.module("../memory/guardian-action-store.js", () => ({
   getGuardianActionRequest: () => null,
   resolveGuardianActionRequest: () => {},

package/src/__tests__/credential-execution-shell-lockdown.test.ts

@@ -10,10 +10,11 @@
  * - CLI commands deny raw secret/token reveal when VELLUM_UNTRUSTED_SHELL=1.
  */
 
+import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import { isUntrustedTrustClass } from "../runtime/actor-trust-resolver.js";
-import { getRootDir } from "../util/platform.js";
+import { getProtectedDir, getWorkspaceDir } from "../util/platform.js";
 
 // ---------------------------------------------------------------------------
 // Trust class categorization (foundational for lockdown decisions)
@@ -120,10 +121,12 @@ describe("CES shell lockdown activation", () => {
 
 describe("CES protected paths for sandbox deny-read", () => {
   test("protected paths include the protected dir and db dir", () => {
-    // The buildCesProtectedPaths function constructs paths from getRootDir().
-    // We verify the pattern: paths should end with /protected and /workspace/data/db.
-    const root = getRootDir();
-    const expectedPaths = [`${root}/protected`, `${root}/workspace/data/db`];
+    // The buildCesProtectedPaths function constructs paths from getProtectedDir()
+    // and getWorkspaceDir(). We verify the pattern: paths should be absolute and clean.
+    const expectedPaths = [
+      getProtectedDir(),
+      join(getWorkspaceDir(), "data", "db"),
+    ];
 
     // Each expected path should be a valid absolute path pattern
     for (const p of expectedPaths) {