@vellumai/assistant 0.8.4 → 0.8.5

package/src/__tests__/gateway-flag-listener.test.ts

@@ -0,0 +1,237 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { createServer, type Server, type Socket } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach,beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Isolated temp directory for the IPC socket
+// ---------------------------------------------------------------------------
+const testRoot = mkdtempSync(join(tmpdir(), "flag-listener-test-"));
+const socketPath = join(testRoot, "gateway.sock");
+
+// ---------------------------------------------------------------------------
+// Mock socket-path resolution to use our test socket
+// ---------------------------------------------------------------------------
+mock.module("../ipc/socket-path.js", () => ({
+  resolveIpcSocketPath: (_name: string) => ({
+    path: socketPath,
+    source: "workspace" as const,
+  }),
+  getAssistantSocketPath: () => join(testRoot, "assistant.sock"),
+}));
+
+// ---------------------------------------------------------------------------
+// Track calls to refreshOverridesFromGateway
+// ---------------------------------------------------------------------------
+let refreshCallCount = 0;
+
+mock.module("../config/assistant-feature-flags.js", () => ({
+  refreshOverridesFromGateway: async () => {
+    refreshCallCount++;
+  },
+  initFeatureFlagOverrides: async () => {},
+  clearFeatureFlagOverridesCache: () => {},
+  isAssistantFeatureFlagEnabled: () => true,
+  _setOverridesForTesting: () => {},
+}));
+
+// ---------------------------------------------------------------------------
+// Track calls to publishSyncInvalidation so we can assert the listener
+// fans flag changes out onto the SSE hub.
+// ---------------------------------------------------------------------------
+let publishedTagSets: string[][] = [];
+
+mock.module("../runtime/sync/sync-publisher.js", () => ({
+  publishSyncInvalidation: async (tags: string[]) => {
+    publishedTagSets.push([...tags]);
+    return { type: "sync_changed", tags };
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Dynamic imports (after mock.module)
+// ---------------------------------------------------------------------------
+const { startGatewayFlagListener, stopGatewayFlagListener } = await import(
+  "../ipc/gateway-flag-listener.js"
+);
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createTestServer(): {
+  server: Server;
+  clients: Set<Socket>;
+  emit: (event: string, data?: unknown) => void;
+  waitForClient: () => Promise<Socket>;
+} {
+  const clients = new Set<Socket>();
+  const clientWaiters: Array<(socket: Socket) => void> = [];
+
+  const server = createServer((socket) => {
+    clients.add(socket);
+    socket.on("close", () => clients.delete(socket));
+    const waiter = clientWaiters.shift();
+    if (waiter) waiter(socket);
+  });
+
+  return {
+    server,
+    clients,
+    emit: (event: string, data?: unknown) => {
+      const payload = JSON.stringify({ event, data }) + "\n";
+      for (const client of clients) {
+        if (!client.destroyed) client.write(payload);
+      }
+    },
+    waitForClient: () =>
+      new Promise((resolve) => {
+        if (clients.size > 0) {
+          resolve(clients.values().next().value!);
+          return;
+        }
+        clientWaiters.push(resolve);
+      }),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("gateway-flag-listener", () => {
+  let testServer: ReturnType<typeof createTestServer>;
+
+  beforeEach(() => {
+    mkdirSync(testRoot, { recursive: true });
+    refreshCallCount = 0;
+    publishedTagSets = [];
+    testServer = createTestServer();
+  });
+
+  afterEach(async () => {
+    stopGatewayFlagListener();
+    await new Promise<void>((resolve) => {
+      for (const client of testServer.clients) {
+        if (!client.destroyed) client.destroy();
+      }
+      testServer.server.close(() => resolve());
+    });
+    try {
+      rmSync(socketPath, { force: true });
+    } catch {
+      // best effort
+    }
+  });
+
+  test("refreshes flag cache on connect and on feature_flags_changed event", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(1);
+
+    testServer.emit("feature_flags_changed");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(2);
+  });
+
+  test("broadcasts feature-flags sync_changed when flags change", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    // Connect refresh should not broadcast — only an actual change does.
+    expect(publishedTagSets.length).toBe(0);
+
+    testServer.emit("feature_flags_changed");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(publishedTagSets.length).toBe(1);
+    expect(publishedTagSets[0]).toEqual([
+      "feature-flags:client",
+      "feature-flags:assistant",
+    ]);
+  });
+
+  test("ignores non-flag events", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+    await new Promise((r) => setTimeout(r, 100));
+
+    const countAfterConnect = refreshCallCount;
+
+    testServer.emit("some_other_event");
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(refreshCallCount).toBe(countAfterConnect);
+  });
+
+  test("reconnects on disconnect and handles events on new connection", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    const firstClient = await testServer.waitForClient();
+
+    // Wait for the close event to propagate back to the server before
+    // setting up the next waitForClient — otherwise waitForClient might
+    // resolve with the old (now-destroyed) socket that is still in the set.
+    await new Promise<void>((resolve) => {
+      firstClient.on("close", resolve);
+      firstClient.destroy();
+    });
+
+    // Wait for reconnect (initial backoff is 1s)
+    const secondClient = await Promise.race([
+      testServer.waitForClient(),
+      new Promise<null>((r) => setTimeout(() => r(null), 3000)),
+    ]);
+
+    expect(secondClient).not.toBeNull();
+
+    await new Promise((r) => setTimeout(r, 100));
+    const countAfterReconnect = refreshCallCount;
+    expect(countAfterReconnect).toBeGreaterThan(0);
+
+    const payload =
+      JSON.stringify({ event: "feature_flags_changed" }) + "\n";
+    secondClient!.write(payload);
+    await new Promise((r) => setTimeout(r, 200));
+
+    expect(refreshCallCount).toBe(countAfterReconnect + 1);
+  });
+
+  test("stopGatewayFlagListener cleans up and does not reconnect", async () => {
+    await new Promise<void>((resolve) => {
+      testServer.server.listen(socketPath, resolve);
+    });
+
+    startGatewayFlagListener();
+    await testServer.waitForClient();
+
+    stopGatewayFlagListener();
+    await new Promise((r) => setTimeout(r, 50));
+
+    const initialClientCount = testServer.clients.size;
+
+    // Wait past reconnect backoff — should not reconnect
+    await new Promise((r) => setTimeout(r, 1500));
+
+    expect(testServer.clients.size).toBeLessThanOrEqual(initialClientCount);
+  });
+});

package/src/__tests__/gemini-provider.test.ts

@@ -75,6 +75,12 @@ mock.module("@google/genai", () => ({
     };
   },
   ApiError: FakeApiError,
+  ThinkingLevel: {
+    MINIMAL: "MINIMAL",
+    LOW: "LOW",
+    MEDIUM: "MEDIUM",
+    HIGH: "HIGH",
+  },
 }));
 
 // Import after mocking
@@ -223,6 +229,78 @@ describe("GeminiProvider", () => {
     expect(config.systemInstruction).toBe("You are a helpful assistant.");
   });
 
+  // -----------------------------------------------------------------------
+  // Thinking config
+  // -----------------------------------------------------------------------
+  test("omits thinkingConfig when no thinking config is supplied", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toBeUndefined();
+  });
+
+  test("maps wire { type: 'adaptive', level, streamThinking } to Gemini thinkingConfig", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      {
+        config: {
+          thinking: {
+            type: "adaptive",
+            level: "high",
+            streamThinking: false,
+          },
+        },
+      },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "HIGH",
+      includeThoughts: false,
+    });
+  });
+
+  test("maps wire { type: 'disabled' } to MINIMAL thinking level", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { thinking: { type: "disabled" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    expect(config.thinkingConfig).toEqual({
+      thinkingLevel: "MINIMAL",
+      includeThoughts: false,
+    });
+  });
+
+  test("omits thinkingConfig when wire shape is adaptive with no extras", async () => {
+    fakeChunks = [textChunk("OK"), finishChunk("STOP", 10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { thinking: { type: "adaptive" } } },
+    );
+
+    const config = lastStreamParams!.config as Record<string, unknown>;
+    // No level/streamThinking → omit so Google's per-model default applies
+    // (Gemini 3.x defaults to "medium" with dynamic thinking).
+    expect(config.thinkingConfig).toBeUndefined();
+  });
+
   // -----------------------------------------------------------------------
   // Tool definitions
   // -----------------------------------------------------------------------

package/src/__tests__/guardian-dispatch.test.ts

@@ -56,7 +56,6 @@ mock.module("../notifications/emit-signal.js", () => ({
     }
     return mockEmitResult;
   },
-  registerBroadcastFn: () => {},
 }));
 
 import {

package/src/__tests__/guardian-outbound-http.test.ts

@@ -280,11 +280,13 @@ describe("startOutbound", () => {
     expect(voiceCallInitCalls.length).toBe(1);
   });
 
-  test("unsupported channel returns unsupported_channel", async () => {
-    // Cast to bypass type checking for test purposes
-    const result = await startOutbound({ channel: "email" as never });
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("unsupported_channel");
+  test("email channel creates outbound session", async () => {
+    const result = await startOutbound({
+      channel: "email",
+      destination: "user@example.com",
+    });
+    expect(result.success).toBe(true);
+    expect(result.channel).toBe("email");
   });
 });
 

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -193,6 +193,6 @@ describe("handleConfirmationResponse canonical status sync", () => {
     // Canonical status sync is now handled inside Conversation.handleConfirmationResponse,
     // which this test mocks out — so the handler itself no longer calls resolveCanonicalGuardianRequest.
     expect(resolveCanonicalGuardianRequestMock).not.toHaveBeenCalled();
-    expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow");
+    expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow", "approved");
   });
 });

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

@@ -91,6 +91,10 @@ mock.module("../notifications/emit-signal.js", () => ({
 mock.module("../prompts/persona-resolver.js", () => ({
   GUARDIAN_PERSONA_TEMPLATE: "# User Profile\n",
   resolveGuardianPersona: () => "# User Profile\n",
+  // buildSystemPrompt now uses resolveUserSlug (for ctx) instead of
+  // resolvePersonaContext — give the mock a noop so the import
+  // doesn't fail.
+  resolveUserSlug: () => null,
 }));
 
 mock.module("../memory/conversation-title-service.js", () => ({

package/src/__tests__/heartbeat-service.test.ts

@@ -112,6 +112,10 @@ let mockGuardianPersona: string | null = null;
 mock.module("../prompts/persona-resolver.js", () => ({
   GUARDIAN_PERSONA_TEMPLATE,
   resolveGuardianPersona: () => mockGuardianPersona,
+  // buildSystemPrompt now uses resolveUserSlug (for ctx) instead of
+  // resolvePersonaContext — give the mock a noop so the import
+  // doesn't fail.
+  resolveUserSlug: () => null,
 }));
 
 // Mock conversation store

package/src/__tests__/host-shell-tool.test.ts

@@ -264,7 +264,7 @@ describe("host_bash — baseline: no sandbox isolation", () => {
 // These tests lock that boundary so any accidental addition is caught.
 
 describe("host_bash — regression: no proxied-mode additions", () => {
-  const definition = hostShellTool.getDefinition();
+  const definition = hostShellTool;
   const schemaProps = (definition.input_schema as Record<string, unknown>)
     .properties as Record<string, unknown>;
 

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -47,9 +47,9 @@ describe("initFeatureFlagOverrides", () => {
     // through the backoff schedule.
     await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
-    // Without gateway data or file, undeclared flags default to true
+    // Without gateway data or file, undeclared flags default to false
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(false);
   });
 
   it("respects false values from gateway IPC", async () => {
@@ -72,10 +72,9 @@ describe("initFeatureFlagOverrides", () => {
     // through the production backoff schedule.
     await initFeatureFlagOverrides({ retryBackoffsMs: [] });
 
-    // Undeclared flags without overrides default to true (not false from
-    // a cached empty map)
+    // Undeclared flags without overrides default to false.
     const config = {} as any;
-    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("foo-enabled", config)).toBe(false);
   });
 
   it("retries empty gateway responses and picks up flags once they become available", async () => {
@@ -111,6 +110,6 @@ describe("initFeatureFlagOverrides", () => {
     // first-call must still be true (from the cached first fetch)
     expect(isAssistantFeatureFlagEnabled("first-call", config)).toBe(true);
     // second-call should not be in the cache since init was a no-op
-    expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(true); // defaults to true (undeclared)
+    expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(false);
   });
 });

package/src/__tests__/list-messages-tool-merge.test.ts

@@ -175,15 +175,13 @@ describe("handleListMessages tool_result merging", () => {
     expect(body.messages[2].content).toBe("how are you?");
   });
 
-  test("tool_result at start of array (no preceding assistant) is dropped", async () => {
+  test("orphan tool_result at pagination boundary is suppressed entirely", async () => {
     const conv = createConversation();
-    // Orphan tool_result with no preceding assistant. Without the parent
-    // tool_use we can't tell the user what tool ran, so the result is
-    // meaningless — renderHistoryContent drops it rather than synthesizing
-    // a phantom "unknown" tool call. See shared.ts comment.
-    // The user message itself is preserved at the pagination boundary
-    // (mergeToolResultsIntoAssistantMessages keeps it to avoid data loss
-    // in case the matching tool_use lives on the previous page).
+    // Orphan tool_result with no preceding assistant in this page. The
+    // matching tool_use lives on the previous page, so renderHistoryContent
+    // would silently drop the orphan downstream and leave a blank user
+    // bubble. The merger now suppresses the user row outright at the
+    // boundary to prevent that blank bubble from reaching the client.
     await addMessage(
       conv.id,
       "user",
@@ -204,13 +202,74 @@ describe("handleListMessages tool_result merging", () => {
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
-    // Both messages exist — user message preserved at pagination boundary,
-    // but the orphan tool_result is dropped (no phantom toolCalls)
+    // User row dropped entirely; only the assistant survives.
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].role).toBe("assistant");
+    expect(body.messages[0].content).toBe("response");
+  });
+
+  test("mixed content at pagination boundary keeps real user text", async () => {
+    const conv = createConversation();
+    // Row has both real user text AND an orphan tool_result. The orphan
+    // gets stripped (it'd be dropped by renderHistoryContent anyway), but
+    // the user text is preserved.
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        {
+          type: "tool_result",
+          tool_use_id: "tu_orphan",
+          content: "stale result",
+        },
+        { type: "text", text: "what about this?" },
+      ]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "answering" }]),
+    );
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as { messages: MessagePayload[] };
+
     expect(body.messages).toHaveLength(2);
     expect(body.messages[0].role).toBe("user");
+    expect(body.messages[0].content).toBe("what about this?");
     expect(body.messages[0].toolCalls).toBeUndefined();
     expect(body.messages[1].role).toBe("assistant");
-    expect(body.messages[1].content).toBe("response");
+    expect(body.messages[1].content).toBe("answering");
+  });
+
+  test("orphan tool_result + system_notice at boundary is suppressed", async () => {
+    const conv = createConversation();
+    // System notices ride alongside tool_results in the agent loop. At a
+    // boundary they shouldn't keep the row alive on their own — the row
+    // is still semantically tool-result-only from the user's perspective.
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        {
+          type: "tool_result",
+          tool_use_id: "tu_orphan",
+          content: "stale",
+        },
+        { type: "text", text: "<system_notice>internal</system_notice>" },
+      ]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "ok" }]),
+    );
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].role).toBe("assistant");
   });
 
   test("multi-turn: each tool_result merges into correct assistant", async () => {

package/src/__tests__/llm-request-log-call-site.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Tests for the `call_site` column on `llm_request_logs`. The column is
+ * stamped by `recordRequestLog` at insertion time and surfaces in
+ * `LogRow.callSite`. Historical rows (pre-migration 264) stay NULL —
+ * "we don't know" rather than guessing `mainAgent`.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { getDb, getSqliteFrom } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import {
+  getRequestLogById,
+  recordRequestLog,
+} from "../memory/llm-request-log-store.js";
+import { migrateLlmRequestLogCallSite } from "../memory/migrations/264-llm-request-log-call-site.js";
+import { llmRequestLogs } from "../memory/schema.js";
+
+initializeDb();
+
+function resetLogs(): void {
+  const db = getDb();
+  db.delete(llmRequestLogs).run();
+}
+
+describe("recordRequestLog call_site stamping", () => {
+  beforeEach(resetLogs);
+
+  test("stamps callSite when provided", () => {
+    const id = recordRequestLog(
+      "conv-1",
+      '{"req":1}',
+      '{"res":1}',
+      undefined,
+      "anthropic",
+      "mainAgent",
+    );
+    const row = getRequestLogById(id);
+    expect(row).not.toBeNull();
+    expect(row!.callSite).toBe("mainAgent");
+  });
+
+  test("leaves callSite NULL when omitted (backward compat)", () => {
+    const id = recordRequestLog("conv-1", '{"req":1}', '{"res":1}');
+    const row = getRequestLogById(id);
+    expect(row).not.toBeNull();
+    expect(row!.callSite).toBeNull();
+  });
+
+  test("supports the compactionAgent value", () => {
+    const id = recordRequestLog(
+      "conv-1",
+      '{"req":1}',
+      '{"res":1}',
+      undefined,
+      "anthropic",
+      "compactionAgent",
+    );
+    expect(getRequestLogById(id)?.callSite).toBe("compactionAgent");
+  });
+
+  test("two rows in the same conversation can carry different callSites", () => {
+    const mainId = recordRequestLog(
+      "conv-1",
+      '{"req":1}',
+      '{"res":1}',
+      undefined,
+      "anthropic",
+      "mainAgent",
+    );
+    const compactId = recordRequestLog(
+      "conv-1",
+      '{"req":2}',
+      '{"res":2}',
+      undefined,
+      "anthropic",
+      "compactionAgent",
+    );
+    expect(getRequestLogById(mainId)?.callSite).toBe("mainAgent");
+    expect(getRequestLogById(compactId)?.callSite).toBe("compactionAgent");
+  });
+});
+
+describe("migrateLlmRequestLogCallSite", () => {
+  test("adds the call_site column when missing", () => {
+    const db = getDb();
+    const raw = getSqliteFrom(db);
+
+    // Drop the column if present (simulate pre-264 state). SQLite supports
+    // `DROP COLUMN` since 3.35 (June 2021) — bun-sqlite ships well past that.
+    const before = raw
+      .query(`PRAGMA table_info(llm_request_logs)`)
+      .all() as Array<{ name: string }>;
+    if (before.some((c) => c.name === "call_site")) {
+      raw.exec(`ALTER TABLE llm_request_logs DROP COLUMN call_site`);
+    }
+
+    const without = raw
+      .query(`PRAGMA table_info(llm_request_logs)`)
+      .all() as Array<{ name: string }>;
+    expect(without.some((c) => c.name === "call_site")).toBe(false);
+
+    migrateLlmRequestLogCallSite(db);
+
+    const after = raw
+      .query(`PRAGMA table_info(llm_request_logs)`)
+      .all() as Array<{ name: string }>;
+    expect(after.some((c) => c.name === "call_site")).toBe(true);
+  });
+
+  test("is idempotent — second run is a no-op", () => {
+    const db = getDb();
+    // First run (column may or may not exist depending on test order; either
+    // path is fine for the idempotency contract).
+    migrateLlmRequestLogCallSite(db);
+    // Second run must not throw.
+    expect(() => migrateLlmRequestLogCallSite(db)).not.toThrow();
+  });
+});