@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -175,6 +175,26 @@ function seedRequestLog(
     .run();
 }
 
+function seedRequestLogWithSections(messageId: string, id: string): void {
+  getDb()
+    .insert(llmRequestLogs)
+    .values({
+      id,
+      conversationId: "conv-1",
+      messageId,
+      provider: "openai",
+      requestPayload: JSON.stringify({
+        model: "gpt-4.1",
+        messages: [{ role: "user", content: "hello" }],
+      }),
+      responsePayload: JSON.stringify({
+        choices: [{ message: { content: "hi" } }],
+      }),
+      createdAt: 1_700_000_000_000,
+    })
+    .run();
+}
+
 function seedConversationKey(
   conversationKey: string,
   conversationId: string,
@@ -274,6 +294,118 @@ describe("GET /v1/conversations/llm-context", () => {
   });
 });
 
+describe("llm-context view=summary", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  function seedConversationWithLog(): void {
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      source: "user",
+      conversationType: "standard",
+    });
+    seedConversationKey("conv-key", "conv-1");
+    seedRequestLogWithSections("msg-1", "log-a");
+  }
+
+  test("conversation endpoint omits sections in summary view but keeps summary fields", async () => {
+    seedConversationWithLog();
+
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "conv-key",
+      view: "summary",
+    })) as {
+      logs: Array<Record<string, unknown>>;
+    };
+
+    expect(body.logs).toHaveLength(1);
+    const log = body.logs[0]!;
+    expect(log.requestSections).toBeUndefined();
+    expect(log.responseSections).toBeUndefined();
+    expect(log.id).toBe("log-a");
+    expect(log.summary).toBeDefined();
+  });
+
+  test("conversation endpoint includes sections by default", async () => {
+    seedConversationWithLog();
+
+    const body = (await dispatchConversationLlmContext({
+      conversationKey: "conv-key",
+    })) as {
+      logs: Array<Record<string, unknown>>;
+    };
+
+    expect(Array.isArray(body.logs[0]!.requestSections)).toBe(true);
+    expect(Array.isArray(body.logs[0]!.responseSections)).toBe(true);
+  });
+
+  test("message endpoint omits sections in summary view", async () => {
+    seedConversationWithLog();
+
+    const body = (await llmContextRoute.handler({
+      pathParams: { id: "msg-1" },
+      queryParams: { view: "summary" },
+    })) as {
+      logs: Array<Record<string, unknown>>;
+    };
+
+    expect(body.logs).toHaveLength(1);
+    expect(body.logs[0]!.requestSections).toBeUndefined();
+    expect(body.logs[0]!.responseSections).toBeUndefined();
+    expect(body.logs[0]!.summary).toBeDefined();
+  });
+
+  test("rejects unknown view values", async () => {
+    seedConversationWithLog();
+
+    expect(
+      dispatchConversationLlmContext({
+        conversationKey: "conv-key",
+        view: "compact",
+      }),
+    ).rejects.toThrow("Invalid view parameter");
+  });
+});
+
+describe("GET /v1/llm-request-logs/:id/context", () => {
+  const logContextRoute = ROUTES.find(
+    (r) => r.operationId === "llm_request_logs_context_get",
+  )!;
+
+  beforeEach(() => {
+    clearTables();
+  });
+
+  test("returns the normalized entry with sections for a single log", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      source: "user",
+      conversationType: "standard",
+    });
+    seedRequestLogWithSections("msg-1", "log-detail");
+
+    const body = (await logContextRoute.handler({
+      pathParams: { id: "log-detail" },
+    })) as Record<string, unknown>;
+
+    expect(body.id).toBe("log-detail");
+    expect(body.requestPayload).toBeNull();
+    expect(body.responsePayload).toBeNull();
+    expect(body.summary).toBeDefined();
+    expect(Array.isArray(body.requestSections)).toBe(true);
+    expect(Array.isArray(body.responseSections)).toBe(true);
+  });
+
+  test("throws NotFound for a missing log id", async () => {
+    expect(
+      logContextRoute.handler({ pathParams: { id: "log-missing" } }),
+    ).rejects.toThrow("log not found");
+  });
+});
+
 describe("GET /v1/messages/:id/llm-context — memoryV2Activation", () => {
   beforeEach(() => {
     clearTables();

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"),