@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -1,6 +1,5 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import {
   applyRuntimeInjections,
   stripInjectionsForCompaction,
@@ -54,10 +53,9 @@ 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 () => {
+  test("emits the exact cleanup prompt during disk pressure cleanup mode", async () => {
     const block = await diskPressureInjector.produce(
       makeContext({
         injectionInputs: { diskPressureContext: cleanupContext },
@@ -73,13 +71,13 @@ describe("disk-pressure-warning injector", () => {
       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.
+Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is critically 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.
+Do not work on unrelated tasks until enough space is freed to clear the lock or the user explicitly overrides it. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
 </disk_pressure_warning>`);
   });
 
@@ -101,18 +99,6 @@ Do not work on unrelated tasks until disk usage drops below the critical thresho
     ).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" }] },

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -69,10 +69,10 @@ mockIpcResponse("get_global_thresholds", {
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import { check, generateAllowlistOptions } from "../permissions/checker.js";
 import { clearRiskCache } from "../permissions/checker.js";
 import { _clearGlobalCacheForTesting } from "../permissions/gateway-threshold-reader.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────
 
@@ -115,7 +115,7 @@ describe("inline-command skill_load permissions", () => {
   beforeEach(() => {
     clearRiskCache();
     _clearGlobalCacheForTesting();
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
     mockIpcResponse("get_global_thresholds", {
       interactive: "low",
       autonomous: "medium",
@@ -135,7 +135,7 @@ describe("inline-command skill_load permissions", () => {
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   // ── Default behavior ─────────────────────────────────────────────────
@@ -197,7 +197,7 @@ describe("inline-command skill_load permissions", () => {
       writeDynamicSkill("dynamic-flag-off", "Dynamic Flag Off Skill");
 
       // Disable the feature flag
-      _setOverridesForTesting({
+      setOverridesForTesting({
         "inline-skill-commands": false,
       });
 

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -26,12 +26,14 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import {
+  _setPaginationScanCapForTesting,
   addMessage,
   createConversation,
   getMessages,
 } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import { messages } from "../memory/schema.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 
 initializeDb();
@@ -177,6 +179,84 @@ describe("handleListMessages metadata.hidden filtering", () => {
     expect(older.hasMore).toBe(true);
   });
 
+  test("pagination keeps hasMore + a cursor when a >cap hidden block truncates the scan", () => {
+    // Exercise cap-truncation with a small cap + a few hundred rows rather than
+    // >10k: the large seed made the post-test resetTables DELETE slow enough to
+    // time out the next test's beforeEach under parallel CI load.
+    // SCAN_CAP must span a couple of PAGINATION_CHUNK_MIN (50) chunks so the cap
+    // (not DB exhaustion) stops the loop, and HIDDEN_COUNT sits just past it so
+    // the newest cap-worth of rows are all hidden.
+    const SCAN_CAP = 100;
+    _setPaginationScanCapForTesting(SCAN_CAP);
+    try {
+      const conv = createConversation();
+      const db = getDb();
+      const HIDDEN_COUNT = SCAN_CAP + 20; // > scan cap
+      const VISIBLE_COUNT = 2;
+      let createdAt = 0;
+      // Older visible rows first (lowest createdAt), then the hidden block.
+      db.transaction((tx) => {
+        for (let i = 0; i < VISIBLE_COUNT; i++) {
+          createdAt += 1;
+          tx.insert(messages)
+            .values({
+              id: `visible-${i}`,
+              conversationId: conv.id,
+              role: "user",
+              content: JSON.stringify([{ type: "text", text: `visible ${i}` }]),
+              createdAt,
+            })
+            .run();
+        }
+        for (let i = 0; i < HIDDEN_COUNT; i++) {
+          createdAt += 1;
+          tx.insert(messages)
+            .values({
+              id: `hidden-${i}`,
+              conversationId: conv.id,
+              role: "assistant",
+              content: JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
+              createdAt,
+              metadata: JSON.stringify({ hidden: true }),
+            })
+            .run();
+        }
+      });
+
+      const latest = handleListMessages({
+        queryParams: { conversationId: conv.id, page: "latest", limit: "2" },
+      }) as {
+        messages: MessagePayload[];
+        hasMore: boolean;
+        oldestTimestamp: number | null;
+      };
+
+      // Page is empty (the cap was consumed entirely by hidden rows) but the
+      // client must still be told to keep paginating and given a cursor.
+      expect(latest.messages).toHaveLength(0);
+      expect(latest.hasMore).toBe(true);
+      expect(latest.oldestTimestamp).not.toBeNull();
+
+      // Resuming from the surfaced cursor drains the remaining hidden rows and
+      // surfaces the visible ones below the cap.
+      const older = handleListMessages({
+        queryParams: {
+          conversationId: conv.id,
+          beforeTimestamp: String(latest.oldestTimestamp),
+          limit: "2",
+        },
+      }) as { messages: MessagePayload[]; hasMore: boolean };
+
+      expect(older.messages.map((m) => m.content)).toEqual([
+        "visible 0",
+        "visible 1",
+      ]);
+      expect(older.hasMore).toBe(false);
+    } finally {
+      _setPaginationScanCapForTesting(undefined);
+    }
+  });
+
   test("pagination drains DB when every row in a page is hidden", async () => {
     const conv = createConversation();
     // 5 hidden rows then 2 visible older rows. With limit=2, the naive

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-context-normalization.test.ts

@@ -1732,6 +1732,48 @@ describe("normalizeLlmContextPayloads", () => {
     ]);
   });
 
+  test("counts Codex Responses native web_search request tools", () => {
+    const normalized = normalizeLlmContextPayloads({
+      createdAt: 1_742_400_000_032,
+      requestPayload: {
+        model: "gpt-5.4",
+        instructions: "Search the web when needed.",
+        input: [
+          {
+            role: "user",
+            content: [{ type: "input_text", text: "What is the weather?" }],
+            type: "message",
+          },
+        ],
+        tools: [{ type: "web_search", external_web_access: false }],
+      },
+      responsePayload: {
+        model: "gpt-5.4",
+        output: [
+          {
+            type: "message",
+            role: "assistant",
+            content: [
+              { type: "output_text", text: "It is sunny in Boston today." },
+            ],
+          },
+        ],
+        usage: { input_tokens: 30, output_tokens: 15 },
+        status: "completed",
+      },
+    });
+
+    expect(normalized.summary?.requestToolCount).toBe(1);
+    expect(normalized.requestSections).toContainEqual({
+      kind: "tool_definitions",
+      label: "Available tools",
+      data: {
+        tools: [{ type: "web_search", external_web_access: false }],
+      },
+      language: "json",
+    });
+  });
+
   test("normalizes Responses API response with only web_search_call (no message)", () => {
     const normalized = normalizeLlmContextPayloads({
       createdAt: 1_742_400_000_031,

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();
+  });
+});

package/src/__tests__/llm-request-log-source-clickhouse.test.ts

@@ -84,6 +84,7 @@ const SAMPLE_ROW = {
   // ClickHouse emits Int64 as a quoted string under JSONEachRow by default.
   created_at: "1778465138786",
   agent_loop_exit_reason: "no_tool_calls",
+  call_site: "mainAgent",
 };
 
 describe("ClickHouseLlmRequestLogSource", () => {
@@ -104,6 +105,7 @@ describe("ClickHouseLlmRequestLogSource", () => {
       responsePayload: '{"bar":2}',
       createdAt: 1778465138786,
       agentLoopExitReason: "no_tool_calls",
+      callSite: "mainAgent",
     });
   });
 
@@ -164,6 +166,30 @@ describe("ClickHouseLlmRequestLogSource", () => {
     expect(rows).toEqual([]);
   });
 
+  test("getRequestLogsByConversationId binds conversation id via parameterized placeholder", async () => {
+    // Regression guard: the conversation id flows from user-controlled
+    // input (conversationKey → conversations.id), so it must travel as a
+    // typed parameter, never as an inline string literal.
+    const recorder: FakeFetchCall[] = [];
+    const malicious = "conv-1' OR 1=1 --";
+    const src = makeSource({
+      body: JSON.stringify(SAMPLE_ROW) + "\n",
+      recorder,
+    });
+    const rows = await src.getRequestLogsByConversationId(malicious);
+    expect(rows).toHaveLength(1);
+    expect(recorder).toHaveLength(1);
+    const call = recorder[0]!;
+    const parsed = new URL(call.url);
+    expect(parsed.searchParams.get("param_assistant_id")).toBe(
+      "asst-fixture-001",
+    );
+    expect(parsed.searchParams.get("param_conversation_id")).toBe(malicious);
+    const body = String(call.init?.body ?? "");
+    expect(body).toContain("conversation_id = {conversation_id:String}");
+    expect(body).not.toContain(`'${malicious}'`);
+  });
+
   test("getRequestLogsByMessageId binds message ids via parameterized placeholders", async () => {
     // Regression for ATL-537. `getAssistantMessageIdsInTurn` returns the
     // caller-supplied id straight through when the message lookup misses,