@vellumai/assistant 0.8.11 → 0.8.12-staging.1

package/src/ipc/routes/trust-rules.test.ts

@@ -1,123 +1,117 @@
 /**
  * Unit tests for the trust rule IPC proxy routes.
- *
- * Covers:
- * - trust_rules_list: no params, tool filter, include_all, origin filter
- * - error path: non-OK gateway response surfaces body .error message
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// ---------------------------------------------------------------------------
-// Mocks — must be defined before importing the module under test
-// ---------------------------------------------------------------------------
-
-mock.module("../../config/env.js", () => ({
-  getGatewayInternalBaseUrl: () => "http://localhost:7822",
-}));
-
-type MockResponse = {
-  ok: boolean;
-  status: number;
-  json: () => Promise<unknown>;
+type IpcCall = {
+  method: string;
+  params?: Record<string, unknown>;
 };
 
-let mockFetchResponse: MockResponse = {
-  ok: true,
-  status: 200,
-  json: async () => ({ rules: [] }),
-};
-
-let capturedFetchCalls: Array<{ url: string; init?: RequestInit }> = [];
+let ipcCalls: IpcCall[] = [];
+let ipcResult: unknown = { rules: [] };
+let ipcError: Error | undefined;
 
-const mockFetch = mock(async (url: string, init?: RequestInit) => {
-  capturedFetchCalls.push({ url, init });
-  return mockFetchResponse;
-});
+const ipcCallPersistentMock = mock(
+  async (method: string, params?: Record<string, unknown>) => {
+    ipcCalls.push({ method, params });
+    if (ipcError) throw ipcError;
+    return ipcResult;
+  },
+);
 
-global.fetch = mockFetch as unknown as typeof fetch;
-
-// ---------------------------------------------------------------------------
-// Import module under test AFTER mocks are set up
-// ---------------------------------------------------------------------------
+mock.module("../gateway-client.js", () => ({
+  ipcCallPersistent: ipcCallPersistentMock,
+}));
 
 import { ROUTES as trustRuleRoutes } from "../../runtime/routes/trust-rules-routes.js";
 
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
 function findRoute(method: string) {
   const route = trustRuleRoutes.find((r) => r.operationId === method);
   if (!route) throw new Error(`Route not found: ${method}`);
   return route;
 }
 
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
 describe("trustRuleRoutes", () => {
   beforeEach(() => {
-    capturedFetchCalls = [];
-    mockFetchResponse = {
-      ok: true,
-      status: 200,
-      json: async () => ({ rules: [] }),
-    };
-    mockFetch.mockClear();
+    ipcCalls = [];
+    ipcResult = { rules: [] };
+    ipcError = undefined;
+    ipcCallPersistentMock.mockClear();
   });
 
   describe("trust_rules_list", () => {
-    test("no params → GET /v1/trust-rules (no query string)", async () => {
+    test("no params calls trust_rules_list with empty params", async () => {
       const route = findRoute("trust_rules_list");
       await route.handler({ body: {} });
 
-      expect(capturedFetchCalls).toHaveLength(1);
-      expect(capturedFetchCalls[0].url).toBe(
-        "http://localhost:7822/v1/trust-rules",
-      );
-      expect(capturedFetchCalls[0].init).toBeUndefined();
+      expect(ipcCalls).toEqual([{ method: "trust_rules_list", params: {} }]);
     });
 
-    test("{ tool: 'bash' } → appends ?tool=bash", async () => {
+    test("{ tool: 'bash' } is forwarded", async () => {
       const route = findRoute("trust_rules_list");
       await route.handler({ body: { tool: "bash" } });
 
-      expect(capturedFetchCalls[0].url).toBe(
-        "http://localhost:7822/v1/trust-rules?tool=bash",
-      );
+      expect(ipcCalls).toEqual([
+        { method: "trust_rules_list", params: { tool: "bash" } },
+      ]);
     });
 
-    test("{ include_all: true } → appends ?include_all=true", async () => {
+    test("{ include_all: true } is forwarded", async () => {
       const route = findRoute("trust_rules_list");
       await route.handler({ body: { include_all: true } });
 
-      expect(capturedFetchCalls[0].url).toBe(
-        "http://localhost:7822/v1/trust-rules?include_all=true",
-      );
+      expect(ipcCalls).toEqual([
+        { method: "trust_rules_list", params: { include_all: true } },
+      ]);
     });
 
-    test("{ origin: 'user_defined' } → appends ?origin=user_defined", async () => {
+    test("{ origin: 'user_defined' } is forwarded", async () => {
       const route = findRoute("trust_rules_list");
       await route.handler({ body: { origin: "user_defined" } });
 
-      expect(capturedFetchCalls[0].url).toBe(
-        "http://localhost:7822/v1/trust-rules?origin=user_defined",
-      );
+      expect(ipcCalls).toEqual([
+        {
+          method: "trust_rules_list",
+          params: { origin: "user_defined" },
+        },
+      ]);
+    });
+
+    test("returns the parsed gateway IPC response", async () => {
+      ipcResult = {
+        rules: [
+          {
+            id: "rule-123",
+            tool: "bash",
+            pattern: "echo hello",
+            risk: "low",
+            description: "Allow echo hello",
+            origin: "user_defined",
+            userModified: false,
+            deleted: false,
+            createdAt: "2026-01-01T00:00:00.000Z",
+            updatedAt: "2026-01-01T00:00:00.000Z",
+          },
+        ],
+      };
+
+      const route = findRoute("trust_rules_list");
+      const result = await route.handler({ body: {} });
+
+      expect(result).toEqual(ipcResult);
     });
   });
 
   describe("error path", () => {
-    test("non-OK response surfaces body .error message", async () => {
-      mockFetchResponse = {
-        ok: false,
-        status: 404,
-        json: async () => ({ error: "Not found" }),
-      };
+    test("gateway IPC error is propagated", async () => {
+      ipcError = new Error("Gateway IPC call timed out");
 
       const route = findRoute("trust_rules_list");
-      await expect(route.handler({ body: {} })).rejects.toThrow("Not found");
+      await expect(route.handler({ body: {} })).rejects.toThrow(
+        "Gateway IPC call timed out",
+      );
     });
   });
 });

package/src/media/image-credentials.ts

@@ -66,8 +66,8 @@ export async function resolveImageGenCredentials(opts: {
 function providerKeyHint(provider: ImageGenProvider): string {
   switch (provider) {
     case "gemini":
-      return "No Gemini API key configured. Please set your Gemini API key in Settings > Models & Services.";
+      return "No Gemini API key configured. Please set your Gemini API key in Settings → Models & Services.";
     case "openai":
-      return "No OpenAI API key configured. Please set your OpenAI API key in Settings > Models & Services.";
+      return "No OpenAI API key configured. Please set your OpenAI API key in Settings → Models & Services.";
   }
 }

package/src/memory/__tests__/compaction-log-store-clickhouse.test.ts

@@ -0,0 +1,432 @@
+/**
+ * Tests for the ClickHouse compaction log store.
+ *
+ * The store is exercised with an injected `fetchImpl` so the tests pin the
+ * wire shape: lazy CREATE TABLE on first write, INSERT statements via the
+ * `query` URL param with JSONEachRow bodies, the start/end row mappings
+ * (sentinels on the start row, full `ContextWindowResult` projection on the
+ * end row), and the read path that pairs rows back into per-attempt events.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { ContextWindowResult } from "../../plugins/defaults/compaction/window-manager.js";
+import {
+  ClickHouseCompactionLogStore,
+  type CompactionEndEvent,
+  type CompactionStartEvent,
+} from "../compaction-log-store-clickhouse.js";
+
+interface CapturedRequest {
+  url: URL;
+  body: string;
+}
+
+function createWriter(overrides?: {
+  fetchImpl?: (url: string, init?: RequestInit) => Promise<Response>;
+}): { writer: ClickHouseCompactionLogStore; requests: CapturedRequest[] } {
+  const requests: CapturedRequest[] = [];
+  const fetchImpl = (overrides?.fetchImpl ??
+    (async (url: string, init?: RequestInit) => {
+      requests.push({ url: new URL(url), body: String(init?.body ?? "") });
+      return new Response("", { status: 200 });
+    })) as typeof fetch;
+  const writer = new ClickHouseCompactionLogStore(
+    { database: "analytics", table: "compaction_logs", user: "writer" },
+    {
+      resolveUrl: async () => "http://clickhouse.example.com:8123",
+      resolvePassword: async () => "secret",
+      resolveAssistantId: async () => "assistant-123",
+      fetchImpl,
+    },
+  );
+  return { writer, requests };
+}
+
+const startEvent: CompactionStartEvent = {
+  type: "context_compacting",
+  compactionId: "comp-1",
+  requestId: "req-1",
+  trigger: "budget",
+  startedAt: 1000,
+  messages: [
+    { role: "user", content: [{ type: "text", text: "hi" }] },
+    { role: "assistant", content: [{ type: "text", text: "hello" }] },
+  ],
+};
+
+const result: ContextWindowResult = {
+  messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+  compacted: true,
+  previousEstimatedInputTokens: 900,
+  estimatedInputTokens: 300,
+  maxInputTokens: 1000,
+  thresholdTokens: 850,
+  compactedMessages: 10,
+  compactedPersistedMessages: 8,
+  preservedTailMessages: 2,
+  summaryCalls: 1,
+  summaryInputTokens: 880,
+  summaryOutputTokens: 120,
+  summaryModel: "test-model",
+  summaryText: "summary text",
+  reason: "auto",
+  exhausted: false,
+};
+
+const endEvent: CompactionEndEvent = {
+  type: "compaction_completed",
+  compactionId: "comp-1",
+  requestId: "req-1",
+  trigger: "budget",
+  startedAt: 1000,
+  finishedAt: 1500,
+  ...result,
+};
+
+describe("ClickHouseCompactionLogStore", () => {
+  test("first write creates the table then inserts", async () => {
+    const { writer, requests } = createWriter();
+
+    await writer.writeStart("conv-1", startEvent);
+
+    expect(requests.length).toBe(2);
+    expect(requests[0]!.body).toContain("CREATE TABLE IF NOT EXISTS");
+    expect(requests[0]!.body).toContain("`compaction_logs`");
+    expect(requests[0]!.url.searchParams.get("database")).toBe("analytics");
+
+    const insert = requests[1]!;
+    expect(insert.url.searchParams.get("query")).toBe(
+      "INSERT INTO `compaction_logs` FORMAT JSONEachRow",
+    );
+    const row = JSON.parse(insert.body) as Record<string, unknown>;
+    expect(row.assistant_id).toBe("assistant-123");
+    expect(row.conversation_id).toBe("conv-1");
+    expect(row.compaction_id).toBe("comp-1");
+    expect(row.request_id).toBe("req-1");
+    expect(row.phase).toBe("start");
+    expect(row.trigger).toBe("budget");
+    expect(row.started_at).toBe(1000);
+    expect(row.pre_message_count).toBe(2);
+    // End-only fields stay at their sentinels on the start row.
+    expect(row.finished_at).toBe(0);
+    expect(row.duration_ms).toBe(-1);
+    expect(row.estimated_input_tokens).toBe(-1);
+    expect(row.summary_model).toBe("");
+  });
+
+  test("table creation happens once across writes", async () => {
+    const { writer, requests } = createWriter();
+
+    await writer.writeStart("conv-1", startEvent);
+    await writer.writeEnd("conv-1", endEvent);
+
+    const ddl = requests.filter((r) => r.body.includes("CREATE TABLE"));
+    expect(ddl.length).toBe(1);
+    expect(requests.length).toBe(3);
+  });
+
+  test("end row projects the full ContextWindowResult", async () => {
+    const { writer, requests } = createWriter();
+
+    await writer.writeEnd("conv-1", endEvent);
+
+    const row = JSON.parse(requests[1]!.body) as Record<string, unknown>;
+    expect(row.phase).toBe("end");
+    expect(row.finished_at).toBe(1500);
+    expect(row.duration_ms).toBe(500);
+    expect(row.result_message_count).toBe(1);
+    expect(row.compacted).toBe(1);
+    expect(row.previous_estimated_input_tokens).toBe(900);
+    expect(row.estimated_input_tokens).toBe(300);
+    expect(row.max_input_tokens).toBe(1000);
+    expect(row.threshold_tokens).toBe(850);
+    expect(row.compacted_messages).toBe(10);
+    expect(row.compacted_persisted_messages).toBe(8);
+    expect(row.preserved_tail_messages).toBe(2);
+    expect(row.summary_calls).toBe(1);
+    expect(row.summary_input_tokens).toBe(880);
+    expect(row.summary_output_tokens).toBe(120);
+    expect(row.summary_model).toBe("test-model");
+    expect(row.summary_failed).toBe(-1);
+    expect(row.reason).toBe("auto");
+    expect(row.exhausted).toBe(0);
+    expect(row.summary_text).toBe("summary text");
+  });
+
+  test("end row maps explicit summaryFailed and omitted optionals", async () => {
+    const { writer, requests } = createWriter();
+
+    await writer.writeEnd("conv-1", {
+      ...endEvent,
+      compacted: false,
+      summaryFailed: true,
+      preservedTailMessages: undefined,
+      reason: undefined,
+      exhausted: true,
+    });
+
+    const row = JSON.parse(requests[1]!.body) as Record<string, unknown>;
+    expect(row.compacted).toBe(0);
+    expect(row.summary_failed).toBe(1);
+    expect(row.preserved_tail_messages).toBe(-1);
+    expect(row.reason).toBe("");
+    expect(row.exhausted).toBe(1);
+  });
+
+  test("failed table creation retries on the next write", async () => {
+    let calls = 0;
+    const requests: CapturedRequest[] = [];
+    const { writer } = createWriter({
+      fetchImpl: async (url: string, init?: RequestInit) => {
+        calls++;
+        requests.push({ url: new URL(url), body: String(init?.body ?? "") });
+        if (calls === 1) return new Response("boom", { status: 500 });
+        return new Response("", { status: 200 });
+      },
+    });
+
+    await expect(writer.writeStart("conv-1", startEvent)).rejects.toThrow(
+      "ClickHouse compaction-log request failed",
+    );
+
+    await writer.writeStart("conv-1", startEvent);
+    const ddl = requests.filter((r) => r.body.includes("CREATE TABLE"));
+    expect(ddl.length).toBe(2);
+  });
+
+  test("write failures surface the HTTP status and body", async () => {
+    let calls = 0;
+    const { writer } = createWriter({
+      fetchImpl: async () => {
+        calls++;
+        if (calls === 1) return new Response("", { status: 200 });
+        return new Response("table is read-only", { status: 403 });
+      },
+    });
+
+    await expect(writer.writeEnd("conv-1", endEvent)).rejects.toThrow(
+      /HTTP 403.*table is read-only/,
+    );
+  });
+
+  test("long summary text is truncated", async () => {
+    const { writer, requests } = createWriter();
+
+    await writer.writeEnd("conv-1", {
+      ...endEvent,
+      summaryText: "x".repeat(10_000),
+    });
+
+    const row = JSON.parse(requests[1]!.body) as Record<string, unknown>;
+    expect((row.summary_text as string).length).toBe(4000);
+  });
+});
+
+// ---------------------------------------------------------------------
+// Read path — getEventsBetween
+// ---------------------------------------------------------------------
+
+function startRow(overrides: Record<string, unknown> = {}) {
+  return {
+    compaction_id: "comp-1",
+    request_id: "req-1",
+    phase: "start",
+    trigger: "budget",
+    started_at: 1000,
+    finished_at: 0,
+    duration_ms: -1,
+    pre_message_count: 12,
+    result_message_count: -1,
+    compacted: 0,
+    previous_estimated_input_tokens: -1,
+    estimated_input_tokens: -1,
+    max_input_tokens: -1,
+    threshold_tokens: -1,
+    compacted_messages: -1,
+    compacted_persisted_messages: -1,
+    preserved_tail_messages: -1,
+    summary_calls: -1,
+    summary_input_tokens: -1,
+    summary_output_tokens: -1,
+    summary_model: "",
+    summary_failed: -1,
+    reason: "",
+    exhausted: 0,
+    injection_mode: "",
+    auto_compress_applied: 0,
+    summary_text: "",
+    ...overrides,
+  };
+}
+
+function endRow(overrides: Record<string, unknown> = {}) {
+  return startRow({
+    phase: "end",
+    finished_at: 1500,
+    duration_ms: 500,
+    pre_message_count: -1,
+    result_message_count: 4,
+    compacted: 1,
+    previous_estimated_input_tokens: 900,
+    estimated_input_tokens: 300,
+    max_input_tokens: 1000,
+    threshold_tokens: 850,
+    compacted_messages: 10,
+    compacted_persisted_messages: 8,
+    preserved_tail_messages: 2,
+    summary_calls: 1,
+    summary_input_tokens: 880,
+    summary_output_tokens: 120,
+    summary_model: "test-model",
+    summary_failed: 0,
+    reason: "auto",
+    summary_text: "summary text",
+    ...overrides,
+  });
+}
+
+function createReader(rows: Record<string, unknown>[]): {
+  writer: ClickHouseCompactionLogStore;
+  requests: CapturedRequest[];
+} {
+  const requests: CapturedRequest[] = [];
+  const { writer } = createWriter({
+    fetchImpl: async (url: string, init?: RequestInit) => {
+      requests.push({ url: new URL(url), body: String(init?.body ?? "") });
+      const body =
+        rows.length === 0
+          ? ""
+          : rows.map((r) => JSON.stringify(r)).join("\n") + "\n";
+      return new Response(body, { status: 200 });
+    },
+  });
+  return { writer, requests };
+}
+
+describe("ClickHouseCompactionLogStore — getEventsBetween", () => {
+  test("binds the window via param_ URL slots, never string interpolation", async () => {
+    const { writer, requests } = createReader([]);
+
+    await writer.getEventsBetween("conv-1", 1999, 9001);
+
+    expect(requests.length).toBe(1);
+    const req = requests[0]!;
+    expect(req.url.searchParams.get("database")).toBe("analytics");
+    expect(req.url.searchParams.get("param_assistant_id")).toBe(
+      "assistant-123",
+    );
+    expect(req.url.searchParams.get("param_conversation_id")).toBe("conv-1");
+    expect(req.url.searchParams.get("param_after_started_at")).toBe("1999");
+    expect(req.url.searchParams.get("param_before_started_at")).toBe("9001");
+    expect(req.body).toContain("{assistant_id:String}");
+    expect(req.body).toContain(
+      "started_at > fromUnixTimestamp64Milli({after_started_at:Int64})",
+    );
+    expect(req.body).toContain("LIMIT 1 BY compaction_id, phase");
+    expect(req.body).toContain("FORMAT JSONEachRow");
+  });
+
+  test("omits the floor predicate when afterStartedAt is null", async () => {
+    const { writer, requests } = createReader([]);
+
+    await writer.getEventsBetween("conv-1", null, 9001);
+
+    const req = requests[0]!;
+    expect(req.url.searchParams.get("param_after_started_at")).toBeNull();
+    expect(req.body).not.toContain("after_started_at");
+  });
+
+  test("pairs start and end rows into one completed event", async () => {
+    const { writer } = createReader([startRow(), endRow()]);
+
+    const events = await writer.getEventsBetween("conv-1", null, 9001);
+
+    expect(events).toHaveLength(1);
+    const event = events[0]!;
+    expect(event.compactionId).toBe("comp-1");
+    expect(event.completed).toBe(true);
+    expect(event.trigger).toBe("budget");
+    expect(event.startedAt).toBe(1000);
+    expect(event.finishedAt).toBe(1500);
+    expect(event.durationMs).toBe(500);
+    // Start-phase field comes from the start row even though the end
+    // row carries the -1 sentinel for it.
+    expect(event.preMessageCount).toBe(12);
+    expect(event.resultMessageCount).toBe(4);
+    expect(event.compacted).toBe(true);
+    expect(event.summaryInputTokens).toBe(880);
+    expect(event.summaryOutputTokens).toBe(120);
+    expect(event.summaryModel).toBe("test-model");
+    expect(event.summaryFailed).toBe(false);
+    expect(event.reason).toBe("auto");
+    expect(event.exhausted).toBe(false);
+    expect(event.summaryText).toBe("summary text");
+  });
+
+  test("start-only rows surface as incomplete events with null end fields", async () => {
+    const { writer } = createReader([startRow()]);
+
+    const events = await writer.getEventsBetween("conv-1", null, 9001);
+
+    expect(events).toHaveLength(1);
+    const event = events[0]!;
+    expect(event.completed).toBe(false);
+    expect(event.preMessageCount).toBe(12);
+    expect(event.finishedAt).toBeNull();
+    expect(event.durationMs).toBeNull();
+    expect(event.compacted).toBeNull();
+    expect(event.summaryModel).toBeNull();
+    expect(event.summaryFailed).toBeNull();
+    expect(event.summaryText).toBeNull();
+  });
+
+  test("maps sentinels back to null and coerces quoted Int64 values", async () => {
+    // ClickHouse may serialize Int64 columns as JSON strings.
+    const { writer } = createReader([
+      endRow({
+        compaction_id: "comp-2",
+        started_at: "2000",
+        duration_ms: "700",
+        preserved_tail_messages: -1,
+        summary_failed: -1,
+        reason: "",
+        summary_text: "",
+      }),
+    ]);
+
+    const events = await writer.getEventsBetween("conv-1", null, 9001);
+
+    const event = events[0]!;
+    expect(event.startedAt).toBe(2000);
+    expect(event.durationMs).toBe(700);
+    expect(event.preservedTailMessages).toBeNull();
+    expect(event.summaryFailed).toBeNull();
+    expect(event.reason).toBeNull();
+    expect(event.summaryText).toBeNull();
+    // End-only pair: start-phase field is unknown.
+    expect(event.preMessageCount).toBeNull();
+  });
+
+  test("sorts paired events by startedAt ascending", async () => {
+    const { writer } = createReader([
+      startRow({ compaction_id: "comp-late", started_at: 5000 }),
+      startRow({ compaction_id: "comp-early", started_at: 1000 }),
+      endRow({ compaction_id: "comp-late", started_at: 5000 }),
+    ]);
+
+    const events = await writer.getEventsBetween("conv-1", null, 9001);
+
+    expect(events.map((e) => e.compactionId)).toEqual([
+      "comp-early",
+      "comp-late",
+    ]);
+  });
+
+  test("empty response body yields an empty event list", async () => {
+    const { writer } = createReader([]);
+
+    const events = await writer.getEventsBetween("conv-1", null, 9001);
+
+    expect(events).toEqual([]);
+  });
+});