@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/__tests__/conversation-surfaces-activation-emit.test.ts

@@ -2,14 +2,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { ServerMessage } from "../daemon/message-protocol.js";
 
-// Silence the logger.
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Analytics consent is granted so recordActivationEvent writes rows.
 let shareAnalytics = true;
 

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -16,7 +16,7 @@ let getMessagesImpl: (conversationId: string) => Array<{
   id: string;
   conversationId: string;
   role: string;
-  content: string;
+  content: unknown;
   createdAt: number;
   metadata: string | null;
 }> = () => [];
@@ -87,7 +87,9 @@ function seedRows(rows: Array<{ id: string; content: unknown }>): void {
       conversationId: "conv-persist-1",
       role: "assistant",
       content:
-        typeof r.content === "string" ? r.content : JSON.stringify(r.content),
+        typeof r.content === "string"
+          ? [{ type: "text", text: r.content }]
+          : r.content,
       createdAt: 0,
       metadata: null,
     }));

package/src/__tests__/conversation-title-service.test.ts

@@ -90,13 +90,6 @@ mock.module("../providers/provider-send-message.js", () => ({
       .join(" "),
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 const mockPublishConversationTitleChanged = mock(
   (_conversationId: string, _title: string) => {},
 );

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -128,7 +128,6 @@ const noopPrompter = {
 const noopSecretPrompter = {
   prompt: mock(async () => ({ cancelled: true })),
 } as unknown as SecretPrompter;
-const noopLifecycleHandler = mock(() => {});
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -156,7 +155,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_refresh", { app_id: "app-1" });
@@ -175,7 +173,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_refresh", { app_id: "app-42" });
@@ -193,7 +190,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_refresh", { app_id: "app-publish" });
@@ -218,7 +214,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_refresh", { app_id: "app-err" });
@@ -237,7 +232,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_refresh", {});
@@ -262,7 +256,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_update", { app_id: "app-7" });
@@ -288,7 +281,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_update", { app_id: "app-err" });
@@ -307,7 +299,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_update", {});
@@ -332,7 +323,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_create", { name: "My App", html: "<h1>hi</h1>" });
@@ -357,7 +347,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("skill_execute", {
@@ -386,7 +375,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("skill_execute", {
@@ -421,7 +409,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("skill_execute", {
@@ -444,7 +431,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_create", { name: "Bad", html: "" });
@@ -474,7 +460,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_create", { name: "Busted", html: "" });
@@ -502,7 +487,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_delete", { app_id: "del-app-1" });
@@ -520,7 +504,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       await toolFn("app_delete", { app_id: "del-err" });
@@ -545,7 +528,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       // Simulate calling app_refresh by name (as the agent loop does)
@@ -579,7 +561,6 @@ describe("session-tool-setup app refresh side effects", () => {
         noopPrompter,
         noopSecretPrompter,
         ctx,
-        noopLifecycleHandler,
       );
 
       for (const toolName of [

package/src/__tests__/conversation-tool-setup-attribution.test.ts

@@ -38,7 +38,9 @@ const baseConfig = {
 };
 
 function mockGetConfig() {
-  if (configThrows) throw new Error("config unavailable");
+  if (configThrows) {
+    throw new Error("config unavailable");
+  }
   return { ...baseConfig, llm: mockLlmConfig };
 }
 
@@ -163,13 +165,7 @@ const noopSecretPrompter = {
 } as unknown as SecretPrompter;
 
 function makeToolFn(executor: ToolExecutor, ctx: ToolSetupContext) {
-  return createToolExecutor(
-    executor,
-    noopPrompter,
-    noopSecretPrompter,
-    ctx,
-    () => {},
-  );
+  return createToolExecutor(executor, noopPrompter, noopSecretPrompter, ctx);
 }
 
 // The module mock outlives this file when multiple test files share a

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

@@ -1,12 +1,5 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   hasUngatedHttpAuthDisabled: () => false,

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

@@ -1,4 +1,13 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
+
+// Legacy-shaped fixtures (llm.default-centric resolution): pinned to the
+// flag-off cascade. Override-or-default (flag-on) semantics are pinned by
+// llm-resolver-override-or-default.test.ts and its companion suites.
+beforeAll(() => {
+  setOverridesForTesting({ "override-or-default-resolution": false });
+});
 
 const updateConversationUsageCalls: Array<{
   conversationId: string;
@@ -9,13 +18,6 @@ const updateConversationUsageCalls: Array<{
 
 let mockLlmConfig = createMockLlmConfig();
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     llm: mockLlmConfig,

package/src/__tests__/conversation-wait-for-idle.test.ts

@@ -0,0 +1,391 @@
+/**
+ * Tests for `Conversation.waitForIdle` — the event-driven replacement for the
+ * voice bridge's 50 ms processing-lock poll.
+ *
+ * Contract: resolves `true` as soon as `processing` is false (synchronous
+ * fast path included), `false` on timeout, rejects on signal abort, and is
+ * notified from the committed `setProcessing(false)` transition — a clear
+ * whose persisted write throws (and therefore reverts) must NOT release
+ * waiters.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } 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
+// ---------------------------------------------------------------------------
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: async () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "high" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    timeouts: { permissionTimeoutSec: 1 },
+    skills: { entries: {}, allowBundled: true },
+    permissions: { mode: "workspace" },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: () => 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: () => {},
+}));
+
+// Controllable persisted-write behavior: `setProcessing` reverts its
+// in-memory flag when this throws, and waiters must not observe that
+// aborted clear as a release.
+let failNextProcessingWrite = false;
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {
+    if (failNextProcessingWrite) {
+      failNextProcessingWrite = false;
+      throw new Error("database is locked (SQLITE_BUSY)");
+    }
+  },
+  isConversationProcessing: () => false,
+  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: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../persistence/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+mock.module("../persistence/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("../plugins/defaults/compaction/window-manager.js", () => ({
+  ContextWindowManager: class {
+    estimateInputTokens() {
+      return 0;
+    }
+    get tokenCountInputs() {
+      return { systemPrompt: "", tools: undefined };
+    }
+    constructor() {}
+    updateConfig() {}
+    shouldCompact() {
+      return { needed: false, estimatedTokens: 0 };
+    }
+    async maybeCompact() {
+      return { compacted: false };
+    }
+    resetOverflowRecovery() {}
+  },
+  createContextSummaryMessage: () => ({
+    role: "user",
+    content: [{ type: "text", text: "summary" }],
+  }),
+  getSummaryFromContextMessage: () => null,
+}));
+
+mock.module("../persistence/llm-usage-store.js", () => ({
+  recordUsageEvent: () => ({ id: "mock-id", createdAt: Date.now() }),
+  listUsageEvents: () => [],
+}));
+
+mock.module("../agent/loop.js", () => ({
+  AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
+    constructor() {}
+    getToolTokenBudget() {
+      return 0;
+    }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
+    async run(_options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      return [];
+    }
+  },
+}));
+
+mock.module("../contacts/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",
+      };
+    },
+  };
+}
+
+let conversationSeq = 0;
+
+function makeConversation(): Conversation {
+  conversationSeq += 1;
+  return new Conversation(
+    `conv-wait-for-idle-${conversationSeq}`,
+    makeProvider(),
+    "system prompt",
+    (_msg: ServerMessage) => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+}
+
+/** Track a promise's settlement without awaiting it. */
+function observe<T>(promise: Promise<T>) {
+  const state = { settled: false, value: undefined as T | undefined };
+  void promise.then((value) => {
+    state.settled = true;
+    state.value = value;
+  });
+  return state;
+}
+
+const flushMicrotasks = async () => {
+  for (let i = 0; i < 5; i++) {
+    await Promise.resolve();
+  }
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Conversation.waitForIdle", () => {
+  test("resolves true synchronously-fast when the conversation is already idle", async () => {
+    const conversation = makeConversation();
+    // Long timeout: if the fast path were missing, resolution would require
+    // a lock release that never comes and the test would time out.
+    await expect(conversation.waitForIdle({ timeoutMs: 60_000 })).resolves.toBe(
+      true,
+    );
+  });
+
+  test("resolves true when setProcessing(false) fires, with no timer advance", async () => {
+    const conversation = makeConversation();
+    conversation.setProcessing(true);
+
+    const waiter = observe(conversation.waitForIdle({ timeoutMs: 60_000 }));
+    await flushMicrotasks();
+    expect(waiter.settled).toBe(false);
+
+    conversation.setProcessing(false);
+    await flushMicrotasks();
+    // Only microtasks were flushed — resolution came from the release
+    // notification, not from any timer.
+    expect(waiter.settled).toBe(true);
+    expect(waiter.value).toBe(true);
+  });
+
+  test("resolves false on timeout while the lock is held", async () => {
+    const conversation = makeConversation();
+    conversation.setProcessing(true);
+
+    await expect(conversation.waitForIdle({ timeoutMs: 10 })).resolves.toBe(
+      false,
+    );
+
+    // A release after the timeout must not throw against the expired waiter.
+    conversation.setProcessing(false);
+  });
+
+  test("rejects when the signal aborts mid-wait", async () => {
+    const conversation = makeConversation();
+    conversation.setProcessing(true);
+    const controller = new AbortController();
+
+    const wait = conversation.waitForIdle({
+      timeoutMs: 60_000,
+      signal: controller.signal,
+    });
+    controller.abort();
+    await expect(wait).rejects.toBeDefined();
+
+    conversation.setProcessing(false);
+  });
+
+  test("rejects immediately for an already-aborted signal", async () => {
+    const conversation = makeConversation();
+    conversation.setProcessing(true);
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      conversation.waitForIdle({
+        timeoutMs: 60_000,
+        signal: controller.signal,
+      }),
+    ).rejects.toBeDefined();
+
+    conversation.setProcessing(false);
+  });
+
+  test("two concurrent waiters both resolve on a single release", async () => {
+    const conversation = makeConversation();
+    conversation.setProcessing(true);
+
+    const first = observe(conversation.waitForIdle({ timeoutMs: 60_000 }));
+    const second = observe(conversation.waitForIdle({ timeoutMs: 60_000 }));
+    await flushMicrotasks();
+    expect(first.settled).toBe(false);
+    expect(second.settled).toBe(false);
+
+    conversation.setProcessing(false);
+    await flushMicrotasks();
+    expect(first.value).toBe(true);
+    expect(second.value).toBe(true);
+  });
+
+  test("a clear whose persisted write throws does not release waiters", async () => {
+    const conversation = makeConversation();
+    conversation.setProcessing(true);
+
+    const waiter = observe(conversation.waitForIdle({ timeoutMs: 60_000 }));
+
+    failNextProcessingWrite = true;
+    expect(() => conversation.setProcessing(false)).toThrow(
+      "database is locked",
+    );
+    await flushMicrotasks();
+    // The write failed, so the flag reverted to processing — the waiter must
+    // still be pending.
+    expect(conversation.isProcessing()).toBe(true);
+    expect(waiter.settled).toBe(false);
+
+    // The retried clear commits and releases the waiter.
+    conversation.setProcessing(false);
+    await flushMicrotasks();
+    expect(waiter.value).toBe(true);
+  });
+});

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

@@ -12,11 +12,6 @@ import type { Message, ProviderResponse } from "../providers/types.js";
 // Mock dependencies — follows conversation-profile-injection.test.ts pattern
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -16,11 +16,6 @@ let scanCallCount = 0;
 // Mocks
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

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

@@ -14,11 +14,6 @@ let agentLoopScript: (onEvent: (event: AgentEvent) => void) => void = () => {};
 // Mocks
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},