@vellumai/assistant 0.8.11 → 0.8.12-staging.1

package/src/runtime/routes/__tests__/gateway-log-routes.test.ts

@@ -1,69 +1,44 @@
 /**
- * Unit tests for the gateway_logs_tail IPC route handler.
- *
- * Covers:
- * - Happy path: all params → correct URL with querystring
- * - All params absent → URL with no querystring
- * - Only n provided → querystring has only n
- * - Gateway returns 500 with error body → Error thrown with error message
- * - level: "INVALID" → ZodError (no gateway call)
- * - n: 0 → ZodError (min 1 violation)
- * - n: 1001 → ZodError (max 1000 violation)
- * - module: "" → accepted (empty string passes zod string validation)
+ * Unit tests for the gateway_logs_tail route handler.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { ZodError } from "zod";
 
-// ---------------------------------------------------------------------------
-// Mocks — must be defined before importing the module under test
-// ---------------------------------------------------------------------------
-
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../../../config/env.js", () => ({
-  getGatewayInternalBaseUrl: () => "http://localhost:9999",
+type IpcCall = {
+  method: string;
+  params?: Record<string, unknown>;
+};
+
+let ipcCalls: IpcCall[] = [];
+let ipcResult: unknown = { lines: [], truncated: false };
+let ipcError: Error | undefined;
+
+const ipcCallPersistentMock = mock(
+  async (method: string, params?: Record<string, unknown>) => {
+    ipcCalls.push({ method, params });
+    if (ipcError) throw ipcError;
+    return ipcResult;
+  },
+);
+
+mock.module("../../../ipc/gateway-client.js", () => ({
+  ipcCallPersistent: ipcCallPersistentMock,
 }));
 
-// ---------------------------------------------------------------------------
-// Import the module under test AFTER mocks are set up
-// ---------------------------------------------------------------------------
-
 import { ROUTES } from "../gateway-log-routes.js";
 
 const gatewayLogsTailRoute = ROUTES.find(
   (r) => r.operationId === "gateway_logs_tail",
 )!;
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeFetchMock(
-  status: number,
-  body: unknown,
-): ReturnType<typeof mock> {
-  return mock(async () => ({
-    ok: status >= 200 && status < 300,
-    status,
-    json: async () => body,
-  }));
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
 describe("gateway_logs_tail route", () => {
   beforeEach(() => {
-    // Reset global fetch to avoid cross-test contamination
-    globalThis.fetch = undefined as unknown as typeof fetch;
+    ipcCalls = [];
+    ipcResult = { lines: [], truncated: false };
+    ipcError = undefined;
+    ipcCallPersistentMock.mockClear();
   });
 
   test("route is registered with correct operationId, method, and endpoint", () => {
@@ -73,170 +48,107 @@ describe("gateway_logs_tail route", () => {
     expect(gatewayLogsTailRoute.endpoint).toBe("gateway/logs/tail");
   });
 
-  describe("happy path — all params provided via body", () => {
-    test("calls gateway with correct URL including all query params", async () => {
-      const mockFetch = makeFetchMock(200, { entries: [] });
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
-
-      await gatewayLogsTailRoute.handler({
-        body: { n: 5, level: "warn", module: "mcp" },
-      });
-
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
-      expect(calledUrl).toBe(
-        "http://localhost:9999/v1/logs/tail?n=5&level=warn&module=mcp",
-      );
+  test("calls gateway IPC with all typed params from body", async () => {
+    await gatewayLogsTailRoute.handler({
+      body: { n: 5, level: "warn", module: "mcp" },
     });
 
-    test("returns the parsed response body", async () => {
-      const responseBody = { entries: [{ msg: "hello", level: 40 }] };
-      globalThis.fetch = makeFetchMock(200, responseBody) as unknown as typeof fetch;
-
-      const result = await gatewayLogsTailRoute.handler({
-        body: { n: 5, level: "warn", module: "mcp" },
-      });
-
-      expect(result).toEqual(responseBody);
-    });
+    expect(ipcCalls).toEqual([
+      {
+        method: "gateway_logs_tail",
+        params: { n: 5, level: "warn", module: "mcp" },
+      },
+    ]);
   });
 
-  describe("all params absent", () => {
-    test("calls gateway URL with no querystring when body is empty", async () => {
-      const mockFetch = makeFetchMock(200, { entries: [] });
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
+  test("returns the parsed IPC response body", async () => {
+    ipcResult = {
+      lines: [{ msg: "hello", level: 40 }],
+      truncated: false,
+    };
 
-      await gatewayLogsTailRoute.handler({ body: {} });
-
-      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
-      expect(calledUrl).toBe("http://localhost:9999/v1/logs/tail");
+    const result = await gatewayLogsTailRoute.handler({
+      body: { n: 5, level: "warn", module: "mcp" },
     });
 
-    test("calls gateway URL with no querystring when no args provided", async () => {
-      const mockFetch = makeFetchMock(200, { entries: [] });
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
-
-      await gatewayLogsTailRoute.handler({});
-
-      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
-      expect(calledUrl).toBe("http://localhost:9999/v1/logs/tail");
-    });
+    expect(result).toEqual(ipcResult);
   });
 
-  describe("only n provided", () => {
-    test("querystring contains only n — no spurious level or module keys", async () => {
-      const mockFetch = makeFetchMock(200, { entries: [] });
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
+  test("calls gateway IPC with empty params when no filters are provided", async () => {
+    await gatewayLogsTailRoute.handler({});
 
-      await gatewayLogsTailRoute.handler({ body: { n: 5 } });
-
-      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
-      expect(calledUrl).toBe("http://localhost:9999/v1/logs/tail?n=5");
-      expect(calledUrl).not.toContain("level");
-      expect(calledUrl).not.toContain("module");
-    });
+    expect(ipcCalls).toEqual([{ method: "gateway_logs_tail", params: {} }]);
   });
 
-  describe("gateway error handling", () => {
-    test("gateway 500 with { error: 'disk error' } throws Error with that message", async () => {
-      globalThis.fetch = makeFetchMock(500, {
-        error: "disk error",
-      }) as unknown as typeof fetch;
+  test("sends only n when only n is provided", async () => {
+    await gatewayLogsTailRoute.handler({ body: { n: 5 } });
 
-      await expect(
-        gatewayLogsTailRoute.handler({ body: {} }),
-      ).rejects.toThrow("disk error");
-    });
-
-    test("gateway 500 with non-string error falls back to generic message", async () => {
-      globalThis.fetch = makeFetchMock(500, {
-        error: { nested: true },
-      }) as unknown as typeof fetch;
-
-      await expect(
-        gatewayLogsTailRoute.handler({ body: {} }),
-      ).rejects.toThrow("Gateway request failed (500)");
-    });
-
-    test("gateway 500 with unparseable JSON falls back to generic message", async () => {
-      globalThis.fetch = mock(async () => ({
-        ok: false,
-        status: 500,
-        json: async () => {
-          throw new SyntaxError("Unexpected token");
-        },
-      })) as unknown as typeof fetch;
-
-      await expect(
-        gatewayLogsTailRoute.handler({ body: {} }),
-      ).rejects.toThrow("Gateway request failed (500)");
-    });
+    expect(ipcCalls).toEqual([
+      { method: "gateway_logs_tail", params: { n: 5 } },
+    ]);
   });
 
-  describe("zod validation", () => {
-    test("level: 'INVALID' is rejected with ZodError before calling gateway", async () => {
-      const mockFetch = makeFetchMock(200, {});
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
+  test("propagates gateway IPC errors", async () => {
+    ipcError = new Error("Gateway IPC socket disconnected");
 
-      await expect(
-        gatewayLogsTailRoute.handler({
-          body: { level: "INVALID" },
-        }),
-      ).rejects.toBeInstanceOf(ZodError);
+    await expect(gatewayLogsTailRoute.handler({ body: {} })).rejects.toThrow(
+      "Gateway IPC socket disconnected",
+    );
+  });
 
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
+  test("rejects malformed gateway IPC responses", async () => {
+    ipcResult = { entries: [] };
 
-    test("n: 0 is rejected with ZodError (min 1 violation)", async () => {
-      const mockFetch = makeFetchMock(200, {});
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
+    await expect(
+      gatewayLogsTailRoute.handler({ body: {} }),
+    ).rejects.toBeInstanceOf(ZodError);
+  });
 
-      await expect(
-        gatewayLogsTailRoute.handler({ body: { n: 0 } }),
-      ).rejects.toBeInstanceOf(ZodError);
+  test("level: 'INVALID' is rejected before calling gateway IPC", async () => {
+    await expect(
+      gatewayLogsTailRoute.handler({
+        body: { level: "INVALID" },
+      }),
+    ).rejects.toBeInstanceOf(ZodError);
 
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
+    expect(ipcCalls).toEqual([]);
+  });
 
-    test("n: 1001 is rejected with ZodError (max 1000 violation)", async () => {
-      const mockFetch = makeFetchMock(200, {});
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
+  test("n: 0 is rejected before calling gateway IPC", async () => {
+    await expect(
+      gatewayLogsTailRoute.handler({ body: { n: 0 } }),
+    ).rejects.toBeInstanceOf(ZodError);
 
-      await expect(
-        gatewayLogsTailRoute.handler({ body: { n: 1001 } }),
-      ).rejects.toBeInstanceOf(ZodError);
+    expect(ipcCalls).toEqual([]);
+  });
 
-      expect(mockFetch).not.toHaveBeenCalled();
-    });
+  test("n: 1001 is rejected before calling gateway IPC", async () => {
+    await expect(
+      gatewayLogsTailRoute.handler({ body: { n: 1001 } }),
+    ).rejects.toBeInstanceOf(ZodError);
 
-    test("module: '' is accepted (empty string passes zod string validation)", async () => {
-      const mockFetch = makeFetchMock(200, { entries: [] });
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
+    expect(ipcCalls).toEqual([]);
+  });
 
-      await expect(
-        gatewayLogsTailRoute.handler({ body: { module: "" } }),
-      ).resolves.toBeDefined();
+  test("module: '' is accepted", async () => {
+    await gatewayLogsTailRoute.handler({ body: { module: "" } });
 
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
+    expect(ipcCalls).toEqual([
+      { method: "gateway_logs_tail", params: { module: "" } },
+    ]);
   });
 
-  describe("queryParams source (HTTP GET path)", () => {
-    test("uses queryParams when provided (HTTP GET path) — string params", async () => {
-      const mockFetch = makeFetchMock(200, { entries: [] });
-      globalThis.fetch = mockFetch as unknown as typeof fetch;
-
-      // When queryParams has values, those take precedence over body.
-      // Only string-valued params (level, module) are valid from the HTTP layer;
-      // n is numeric and must come via IPC body.
-      await gatewayLogsTailRoute.handler({
-        queryParams: { level: "info", module: "cors" },
-        body: {},
-      });
-
-      const calledUrl = (mockFetch.mock.calls[0] as [string])[0];
-      expect(calledUrl).toContain("level=info");
-      expect(calledUrl).toContain("module=cors");
+  test("uses queryParams when provided and coerces n", async () => {
+    await gatewayLogsTailRoute.handler({
+      queryParams: { n: "7", level: "info", module: "cors" },
+      body: { n: 1, level: "error" },
     });
+
+    expect(ipcCalls).toEqual([
+      {
+        method: "gateway_logs_tail",
+        params: { n: 7, level: "info", module: "cors" },
+      },
+    ]);
   });
 });

package/src/runtime/routes/__tests__/home-feed-routes.test.ts

@@ -65,6 +65,14 @@ mock.module("../../../memory/conversation-crud.js", () => ({
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
+// Stub the home-content revalidation coordinator: the GET handler fires
+// it fire-and-forget, and the real module would reach into the LLM
+// provider layer and checkpoint store.
+const revalidateSpy = mock<() => void>(() => {});
+mock.module("../../../home/home-content-refresh.js", () => ({
+  revalidateHomeContentInBackground: revalidateSpy,
+}));
+
 // Dynamic imports so module mocks are wired before evaluation.
 const {
   computeGreeting,
@@ -333,6 +341,15 @@ describe("handleGetHomeFeed", () => {
     expect(res.status).toBe(400);
   });
 
+  test("triggers fire-and-forget home content revalidation", async () => {
+    revalidateSpy.mockClear();
+    const res = await handleGetHomeFeed(
+      new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),
+    );
+    expect(res.status).toBe(200);
+    expect(revalidateSpy).toHaveBeenCalledTimes(1);
+  });
+
   test("empty feed returns empty items and zero newCount", async () => {
     const res = await handleGetHomeFeed(
       new Request("http://localhost/v1/home/feed?timeAwaySeconds=0"),

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -643,6 +643,7 @@ function pluginDetails(overrides: Partial<PluginDetails> = {}): PluginDetails {
     },
     readme: overrides.readme ?? null,
     ref: overrides.ref ?? "main",
+    artifact: overrides.artifact ?? null,
   };
 }
 

package/src/runtime/routes/__tests__/task-routes.test.ts

@@ -206,6 +206,8 @@ mock.module("../../../util/platform.js", () => {
     getPlatformName: () => "linux",
     normalizeAssistantId: (id: string) => id,
     getDataDir: stub,
+    getConfigQuarantineNoticePath: () =>
+      "/mock/workspace/data/config-quarantine-notice.json",
     getEmbeddingModelsDir: stub,
     getSandboxRootDir: stub,
     getSandboxWorkingDir: stub,
@@ -414,9 +416,7 @@ describe("task_delete route", () => {
 
   test("throws Zod validation error for empty task_ids array", async () => {
     const route = findRoute("task_delete");
-    await expect(
-      route.handler({ body: { task_ids: [] } }),
-    ).rejects.toThrow();
+    await expect(route.handler({ body: { task_ids: [] } })).rejects.toThrow();
 
     expect(mockTaskDeleteCalls).toHaveLength(0);
   });

package/src/runtime/routes/btw-routes.ts

@@ -14,7 +14,6 @@
 
 import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { readNowScratchpad } from "../../daemon/now-scratchpad.js";
@@ -34,9 +33,6 @@ const IDENTITY_INTRO_KEY = "identity-intro";
 
 /** Conversation key used by the client for empty-state greeting generation. */
 const GREETING_KEY = "greeting";
-const EMPTY_STATE_DYNAMIC_GREETINGS_FLAG =
-  "empty-state-dynamic-greetings" as const;
-const STATIC_EMPTY_STATE_GREETING = "What are we working on?";
 
 // ---------------------------------------------------------------------------
 // SSE helpers
@@ -68,16 +64,6 @@ async function handleBtw({
 
   const trimmedContent = content.trim();
 
-  if (
-    conversationKey === GREETING_KEY &&
-    !isAssistantFeatureFlagEnabled(
-      EMPTY_STATE_DYNAMIC_GREETINGS_FLAG,
-      getConfig(),
-    )
-  ) {
-    return streamText(STATIC_EMPTY_STATE_GREETING);
-  }
-
   // ----- Cached identity intro fast-path -----
   if (conversationKey === IDENTITY_INTRO_KEY) {
     const fastText = getCachedIntro()?.greetings[0];

package/src/runtime/routes/conversation-compaction-routes.ts

@@ -34,30 +34,37 @@
  * which has no compaction immediately before it but had several
  * earlier in the same turn. The turn is the right unit of analysis.
  *
- * # Data model decision (in progress)
+ * # Data sources
  *
- * Today the trail is projected from `llm_request_logs` rows alone — no
- * `compaction_logs` table exists yet (#32055 remains a draft). This MVP
- * route exists precisely to test whether the projected shape is enough.
- * If real-world use surfaces UX needs that aren't in `llm_request_logs`
- * (most likely: per-event duration, structured before/after counts,
- * trigger reason), that becomes the concrete justification for the new
- * table. Until then, missing fields surface as `null` and the Compaction
- * tab renders `"Unavailable"` for them.
+ * When `compactionLogs.destination = "clickhouse"` is configured, the
+ * trail is served from the first-class compaction log: the agent loop's
+ * start/end event pairs written by
+ * `memory/compaction-log-store-clickhouse.ts`. Those rows carry real
+ * durations, summary-model token totals, and trigger reasons — none of
+ * which exist on `llm_request_logs`.
  *
- * In particular, `durationMs` is always `null` for now — the column
- * doesn't exist on `llm_request_logs` and we deliberately ship the route
- * without it to surface the gap in the UI.
+ * The legacy projection over `llm_request_logs` rows with
+ * `call_site = "compactionAgent"` remains as the fallback: it serves
+ * turns that predate the compaction log (the table is append-only from
+ * the moment the destination is configured), assistants that never opt
+ * in, and reads where the ClickHouse query fails. On the legacy path
+ * `durationMs` is always `null` — the column doesn't exist on
+ * `llm_request_logs`.
  */
 
 import { z } from "zod";
 
+import {
+  type CompactionLogEvent,
+  getCompactionLogStore,
+} from "../../memory/compaction-log-store-clickhouse.js";
 import {
   getConversation,
   getTurnTimeBounds,
 } from "../../memory/conversation-crud.js";
 import { getLlmRequestLogSource } from "../../memory/llm-request-log-source.js";
 import type { LogRow } from "../../memory/llm-request-log-store.js";
+import { getLogger } from "../../util/logger.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
 import {
@@ -66,6 +73,8 @@ import {
 } from "./llm-context-normalization.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
+const log = getLogger("conversation-compaction-routes");
+
 /**
  * Wire shape for a single compaction event. Mirrors the React Query
  * response type at
@@ -81,12 +90,9 @@ export interface CompactionTrailEvent {
   inputTokens: number | null;
   outputTokens: number | null;
   /**
-   * Per-call wall-clock latency, in milliseconds. **Always `null` for
-   * now** — `llm_request_logs` doesn't carry a duration column. Surfacing
-   * the gap in the UI is intentional: if engineers consistently miss
-   * having latency here, that's a concrete signal to extend the row
-   * (either as a column on `llm_request_logs` or on a dedicated
-   * `compaction_logs` table per the open data-model decision).
+   * Per-attempt wall-clock latency, in milliseconds. Populated from the
+   * compaction log when configured; always `null` on the legacy
+   * `llm_request_logs` path, which has no duration column.
    */
   durationMs: number | null;
   responsePreview: string | null;
@@ -172,6 +178,33 @@ export function projectLogRowToCompactionTrailEvent(
   };
 }
 
+/**
+ * Project a paired compaction-log event into the trail wire shape. Token
+ * counts are the summarizer's own usage (what the compaction itself cost),
+ * matching what the legacy path derived from the compaction agent's
+ * request/response payloads.
+ *
+ * Exported only for unit tests; the route handler is the sole production
+ * caller.
+ */
+export function projectCompactionLogEventToTrailEvent(
+  event: CompactionLogEvent,
+): CompactionTrailEvent {
+  return {
+    id: event.compactionId,
+    createdAt: event.startedAt,
+    model: event.summaryModel,
+    provider: null,
+    inputTokens: event.summaryInputTokens,
+    outputTokens: event.summaryOutputTokens,
+    durationMs: event.durationMs,
+    responsePreview: event.summaryText,
+    requestMessageCount: event.preMessageCount,
+    stopReason: event.reason,
+    estimatedCostUsd: null,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Handler
 // ---------------------------------------------------------------------------
@@ -232,6 +265,40 @@ async function handleGetCompactionTrail({
     turnBounds !== null ? turnBounds.startTime - 1 : null;
   const beforeCreatedAt: number =
     turnBounds !== null ? turnBounds.endTime + 1 : selectedCall.createdAt;
+  // Prefer the first-class compaction log when the assistant has opted
+  // in. Zero rows means the turn predates the log (it is append-only from
+  // the moment the destination is configured), so fall through to the
+  // legacy projection rather than returning an empty trail; same for a
+  // failed ClickHouse read. Writes are best-effort and the start/end rows
+  // land independently, so an event without its end row (no `finishedAt`)
+  // means the end write failed or is lagging — in that case the legacy
+  // projection may still have the summarizer call details, so fall back
+  // rather than serve a trail with null model/tokens/duration.
+  const compactionStore = getCompactionLogStore();
+  if (compactionStore) {
+    try {
+      const events = await compactionStore.getEventsBetween(
+        conversationId,
+        afterCreatedAt,
+        beforeCreatedAt,
+      );
+      if (
+        events.length > 0 &&
+        events.every((event) => event.finishedAt !== null)
+      ) {
+        return {
+          conversationId,
+          events: events.map(projectCompactionLogEventToTrailEvent),
+        };
+      }
+    } catch (err) {
+      log.warn(
+        { err, conversationId, callId },
+        "Compaction log read failed; falling back to llm_request_logs projection",
+      );
+    }
+  }
+
   const logs = await source.getCompactionLogsBetween(
     conversationId,
     afterCreatedAt,
@@ -259,7 +326,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Get the compaction trail leading up to an LLM call",
     description:
-      "Return the chronological list of compaction events that ran in the same agent turn as the call identified by `callId`. Turn bounds are walked from the `messages` table (real user messages — tool-result user messages are not boundaries). Projected from `llm_request_logs` rows where `call_site = \"compactionAgent\"`. When the conversation has no other messages around the selected call, every compaction strictly before the call's `createdAt` is in scope. Drives the Inspector's Compaction tab.",
+      'Return the chronological list of compaction events that ran in the same agent turn as the call identified by `callId`. Turn bounds are walked from the `messages` table (real user messages — tool-result user messages are not boundaries). Served from the first-class compaction log when `compactionLogs.destination = "clickhouse"` is configured, falling back to the legacy projection over `llm_request_logs` rows where `call_site = "compactionAgent"`. When the conversation has no other messages around the selected call, every compaction strictly before the call\'s `createdAt` is in scope. Drives the Inspector\'s Compaction tab.',
     tags: ["conversations"],
     pathParams: [
       {