@vellumai/assistant 0.6.5 → 0.6.6

package/src/runtime/routes/playground/__tests__/force-compact.test.ts

@@ -0,0 +1,284 @@
+import { describe, expect, test } from "bun:test";
+
+import type { ContextWindowResult } from "../../../../context/window-manager.js";
+import type { Conversation } from "../../../../daemon/conversation.js";
+import type { Message } from "../../../../providers/types.js";
+import type { RouteContext } from "../../../http-router.js";
+import type { PlaygroundRouteDeps } from "../deps.js";
+import { forceCompactRouteDefinitions } from "../force-compact.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface FakeConversationOptions {
+  messagesBefore?: Message[];
+  messagesAfter?: Message[];
+  result?: Partial<ContextWindowResult>;
+  processing?: boolean;
+}
+
+interface FakeConversation {
+  readonly conversation: Conversation;
+  readonly forceCompactCallCount: () => number;
+}
+
+function makeFakeConversation(
+  options: FakeConversationOptions = {},
+): FakeConversation {
+  const messagesBefore = options.messagesBefore ?? [];
+  const messagesAfter = options.messagesAfter ?? messagesBefore;
+  let calls = 0;
+  let returnedAfter = false;
+
+  const baseResult: ContextWindowResult = {
+    messages: messagesAfter,
+    compacted: true,
+    previousEstimatedInputTokens: 0,
+    estimatedInputTokens: 0,
+    maxInputTokens: 100_000,
+    thresholdTokens: 80_000,
+    compactedMessages: 0,
+    compactedPersistedMessages: 0,
+    summaryCalls: 0,
+    summaryInputTokens: 0,
+    summaryOutputTokens: 0,
+    summaryModel: "",
+    summaryText: "",
+    ...options.result,
+  };
+
+  const fake = {
+    processing: options.processing ?? false,
+    getMessages(): Message[] {
+      // First call returns the pre-compaction messages; subsequent calls
+      // return the post-compaction messages. This mirrors how the route
+      // reads the state twice (before/after `forceCompact()`).
+      if (!returnedAfter && calls === 0) return messagesBefore;
+      return messagesAfter;
+    },
+    async forceCompact(): Promise<ContextWindowResult> {
+      calls += 1;
+      returnedAfter = true;
+      return baseResult;
+    },
+  };
+
+  return {
+    conversation: fake as unknown as Conversation,
+    forceCompactCallCount: () => calls,
+  };
+}
+
+function makeDeps(
+  overrides: Partial<PlaygroundRouteDeps> = {},
+): PlaygroundRouteDeps {
+  return {
+    getConversationById: async () => undefined,
+    isPlaygroundEnabled: () => true,
+    listConversationsByTitlePrefix: () => [],
+    deleteConversationById: () => false,
+    createConversation: async () => ({ id: "conv-test" }),
+    addMessage: async () => ({ id: "msg-test" }),
+    ...overrides,
+  };
+}
+
+function makeRouteContext(id: string): RouteContext {
+  const url = new URL(
+    `http://localhost/v1/conversations/${id}/playground/compact`,
+  );
+  return {
+    req: new Request(url, { method: "POST" }),
+    url,
+    server: {} as RouteContext["server"],
+    authContext: {
+      subject: "test-user",
+      principalType: "local",
+      assistantId: "self",
+      scopeProfile: "local_v1",
+      scopes: new Set(["local.all" as const]),
+      policyEpoch: 0,
+    },
+    params: { id },
+  } as unknown as RouteContext;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("forceCompactRouteDefinitions", () => {
+  test("exposes a single POST route with the expected endpoint + policy key", () => {
+    const routes = forceCompactRouteDefinitions(makeDeps());
+    expect(routes).toHaveLength(1);
+    expect(routes[0].endpoint).toBe("conversations/:id/playground/compact");
+    expect(routes[0].method).toBe("POST");
+    expect(routes[0].policyKey).toBe("conversations/playground/compact");
+  });
+
+  test("returns 404 with playground_disabled code when the playground flag is disabled", async () => {
+    const deps = makeDeps({ isPlaygroundEnabled: () => false });
+    const [route] = forceCompactRouteDefinitions(deps);
+
+    const res = await route.handler(makeRouteContext("conv-abc"));
+    expect(res.status).toBe(404);
+
+    const body = (await res.json()) as {
+      error: { code: string; message: string };
+    };
+    // Distinct from `conversation_not_found` so the Swift client can
+    // surface the right toast text without sniffing the URL path.
+    expect(body.error.code).toBe("playground_disabled");
+  });
+
+  test("returns 404 with conversation_not_found code when the conversation is missing", async () => {
+    const deps = makeDeps({
+      isPlaygroundEnabled: () => true,
+      getConversationById: async () => undefined,
+    });
+    const [route] = forceCompactRouteDefinitions(deps);
+
+    const res = await route.handler(makeRouteContext("conv-missing"));
+    expect(res.status).toBe(404);
+
+    const body = (await res.json()) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.code).toBe("conversation_not_found");
+    expect(body.error.message).toContain("conv-missing");
+  });
+
+  test("forces compaction and returns before/after tokens + summary metadata", async () => {
+    const messagesBefore: Message[] = [
+      { role: "user", content: [{ type: "text", text: "hello world" }] },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "hi there from the assistant" }],
+      },
+    ];
+    const messagesAfter: Message[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: "hello" }],
+      },
+    ];
+
+    const fake = makeFakeConversation({
+      messagesBefore,
+      messagesAfter,
+      result: {
+        compacted: true,
+        summaryText: "one-line summary of the earlier turns",
+        compactedPersistedMessages: 7,
+        summaryFailed: false,
+      },
+    });
+
+    const deps = makeDeps({
+      isPlaygroundEnabled: () => true,
+      getConversationById: async () => fake.conversation,
+    });
+    const [route] = forceCompactRouteDefinitions(deps);
+
+    const res = await route.handler(makeRouteContext("conv-ok"));
+    expect(res.status).toBe(200);
+
+    const body = (await res.json()) as {
+      compacted: boolean;
+      previousTokens: number;
+      newTokens: number;
+      summaryText: string | null;
+      messagesRemoved: number;
+      summaryFailed: boolean | null;
+    };
+
+    expect(body.compacted).toBe(true);
+    expect(body.summaryText).toBe("one-line summary of the earlier turns");
+    expect(body.messagesRemoved).toBe(7);
+    expect(body.summaryFailed).toBe(false);
+    expect(body.previousTokens).toBeGreaterThan(0);
+    expect(body.newTokens).toBeGreaterThan(0);
+    // The post-compaction message set is strictly smaller, so the
+    // reported token count should fall.
+    expect(body.newTokens).toBeLessThan(body.previousTokens);
+
+    expect(fake.forceCompactCallCount()).toBe(1);
+  });
+
+  test("returns 409 and skips forceCompact when conversation is already processing", async () => {
+    // Simulate a turn (or a concurrent /compact) already in flight against
+    // this conversation. A second playground POST landing in this window
+    // would otherwise race with the first call: duplicate
+    // `contextCompactedMessageCount` increments, duplicate
+    // `context_compacted` SSE events, and double usage recording. Easy to
+    // trigger by double-clicking the playground "Force Compact" button.
+    const fake = makeFakeConversation({
+      messagesBefore: [
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ],
+      processing: true,
+    });
+
+    const deps = makeDeps({
+      isPlaygroundEnabled: () => true,
+      getConversationById: async () => fake.conversation,
+    });
+    const [route] = forceCompactRouteDefinitions(deps);
+
+    const res = await route.handler(makeRouteContext("conv-busy"));
+    expect(res.status).toBe(409);
+
+    const body = (await res.json()) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.code).toBe("CONFLICT");
+    expect(body.error.message).toContain("already in progress");
+
+    // Critical: we must NOT have invoked forceCompact a second time while
+    // an existing call was in flight.
+    expect(fake.forceCompactCallCount()).toBe(0);
+  });
+
+  test("defaults summaryText/summaryFailed to null when forceCompact omits them", async () => {
+    const fake = makeFakeConversation({
+      messagesBefore: [
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ],
+      messagesAfter: [
+        { role: "user", content: [{ type: "text", text: "hi" }] },
+      ],
+      result: {
+        compacted: false,
+        // Intentionally leave summaryText as "" and summaryFailed undefined
+        // so the route's ?? coalescing is exercised.
+        summaryText: "",
+        summaryFailed: undefined,
+        compactedPersistedMessages: 0,
+      },
+    });
+
+    const deps = makeDeps({
+      isPlaygroundEnabled: () => true,
+      getConversationById: async () => fake.conversation,
+    });
+    const [route] = forceCompactRouteDefinitions(deps);
+
+    const res = await route.handler(makeRouteContext("conv-noop"));
+    expect(res.status).toBe(200);
+
+    const body = (await res.json()) as {
+      compacted: boolean;
+      summaryText: string | null;
+      messagesRemoved: number;
+      summaryFailed: boolean | null;
+    };
+
+    expect(body.compacted).toBe(false);
+    // summaryText is "" (falsy) so `??` keeps it as "" — not null. We only
+    // substitute null when the field is nullish, matching the handler.
+    expect(body.summaryText).toBe("");
+    expect(body.summaryFailed).toBeNull();
+    expect(body.messagesRemoved).toBe(0);
+  });
+});

package/src/runtime/routes/playground/__tests__/guard.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../../../../daemon/conversation.js";
+import type { PlaygroundRouteDeps } from "../deps.js";
+import { assertPlaygroundEnabled } from "../guard.js";
+import { playgroundRouteDefinitions } from "../index.js";
+
+function makeDeps(enabled: boolean): PlaygroundRouteDeps {
+  return {
+    getConversationById: async (
+      _id: string,
+    ): Promise<Conversation | undefined> => undefined,
+    isPlaygroundEnabled: () => enabled,
+    listConversationsByTitlePrefix: () => [],
+    deleteConversationById: () => false,
+    createConversation: async (_title: string) => ({ id: "conv-test" }),
+    addMessage: async (
+      _conversationId: string,
+      _role: "user" | "assistant",
+      _contentJson: string,
+    ) => ({ id: "msg-test" }),
+  };
+}
+
+describe("assertPlaygroundEnabled", () => {
+  test("returns a 404 Response when the flag is disabled", async () => {
+    const result = assertPlaygroundEnabled(makeDeps(false));
+
+    expect(result).toBeInstanceOf(Response);
+    expect(result?.status).toBe(404);
+
+    const body = (await result?.json()) as {
+      error: { code: string; message: string };
+    };
+    // The body code must be `playground_disabled` (not the generic
+    // `NOT_FOUND`) so the Swift `CompactionPlaygroundClient` can route
+    // this to `.notAvailable` rather than `.notFound`. The two cases
+    // collide on conv-scoped routes because this guard runs *before*
+    // the conversation lookup — the URL alone cannot tell them apart.
+    expect(body.error.code).toBe("playground_disabled");
+    expect(body.error.message).toBe("Compaction playground is not enabled");
+  });
+
+  test("returns null when the flag is enabled", () => {
+    expect(assertPlaygroundEnabled(makeDeps(true))).toBeNull();
+  });
+});
+
+describe("playgroundRouteDefinitions", () => {
+  test("returns route definitions regardless of flag state (guard runs per-request)", () => {
+    // The flag check happens inside each route's handler via
+    // `assertPlaygroundEnabled`, not at registration time. The aggregator
+    // always returns every registered route; each handler returns 404 when
+    // the flag is disabled.
+    expect(playgroundRouteDefinitions(makeDeps(true)).length).toBeGreaterThan(
+      0,
+    );
+    expect(playgroundRouteDefinitions(makeDeps(false)).length).toBeGreaterThan(
+      0,
+    );
+  });
+
+  test("registers the inject-failures playground route", () => {
+    const routes = playgroundRouteDefinitions(makeDeps(true));
+    expect(
+      routes.some(
+        (r) =>
+          r.endpoint ===
+            "conversations/:id/playground/inject-compaction-failures" &&
+          r.method === "POST",
+      ),
+    ).toBe(true);
+  });
+
+  test("registers the seed-conversation endpoint", () => {
+    const routes = playgroundRouteDefinitions(makeDeps(true));
+    const endpoints = routes.map((r) => `${r.method} ${r.endpoint}`);
+    expect(endpoints).toContain("POST playground/seed-conversation");
+  });
+});

package/src/runtime/routes/playground/__tests__/inject-failures.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Tests for the inject-compaction-failures playground endpoint.
+ *
+ * This endpoint is dev-only (gated by the `compaction-playground` feature
+ * flag) and directly mutates `consecutiveCompactionFailures` and/or
+ * `compactionCircuitOpenUntil` on a live `Conversation`. It is used by the
+ * macOS playground UI and integration tests to drive the circuit breaker
+ * into interesting states without having to wait for three real summary
+ * LLM failures.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../../../../daemon/conversation.js";
+import type { ServerMessage } from "../../../../daemon/message-protocol.js";
+import type { RouteContext } from "../../../http-router.js";
+import type { PlaygroundRouteDeps } from "../deps.js";
+import { injectFailuresRouteDefinitions } from "../inject-failures.js";
+
+interface MockConversation {
+  readonly conversationId: string;
+  consecutiveCompactionFailures: number;
+  compactionCircuitOpenUntil: number | null;
+  contextCompactedMessageCount: number;
+  contextCompactedAt: number | null;
+  sentMessages: ServerMessage[];
+  sendToClient: (msg: ServerMessage) => void;
+  getMessages: () => unknown[];
+}
+
+function makeConversation(id = "conv-playground-test"): MockConversation {
+  const sentMessages: ServerMessage[] = [];
+  return {
+    conversationId: id,
+    consecutiveCompactionFailures: 0,
+    compactionCircuitOpenUntil: null,
+    contextCompactedMessageCount: 0,
+    contextCompactedAt: null,
+    sentMessages,
+    sendToClient: (msg) => sentMessages.push(msg),
+    getMessages: () => [],
+  };
+}
+
+function makeDeps(
+  opts: {
+    enabled?: boolean;
+    conversation?: MockConversation | undefined;
+  } = {},
+): PlaygroundRouteDeps {
+  const enabled = opts.enabled ?? true;
+  const conversation = opts.conversation;
+  return {
+    isPlaygroundEnabled: () => enabled,
+    getConversationById: async (id) => {
+      if (!conversation) return undefined;
+      if (conversation.conversationId !== id) return undefined;
+      return conversation as unknown as Conversation;
+    },
+    listConversationsByTitlePrefix: () => [],
+    deleteConversationById: () => false,
+    createConversation: async () => ({ id: "conv-test" }),
+    addMessage: async () => ({ id: "msg-test" }),
+  };
+}
+
+function getInjectRoute(deps: PlaygroundRouteDeps) {
+  const routes = injectFailuresRouteDefinitions(deps);
+  const route = routes.find(
+    (r) =>
+      r.endpoint ===
+        "conversations/:id/playground/inject-compaction-failures" &&
+      r.method === "POST",
+  );
+  if (!route) {
+    throw new Error("inject-failures route not registered");
+  }
+  return route;
+}
+
+async function invoke(
+  route: ReturnType<typeof getInjectRoute>,
+  conversationId: string,
+  body: unknown,
+): Promise<Response> {
+  const url = `http://localhost/v1/conversations/${conversationId}/playground/inject-compaction-failures`;
+  const req = new Request(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  return Promise.resolve(
+    route.handler({
+      req,
+      url: new URL(url),
+      params: { id: conversationId },
+    } as unknown as RouteContext),
+  );
+}
+
+describe("POST /v1/conversations/:id/playground/inject-compaction-failures", () => {
+  test("returns 404 with playground_disabled code when the compaction-playground flag is disabled", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps({ enabled: false, conversation });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, conversation.conversationId, {});
+    expect(res.status).toBe(404);
+
+    const body = (await res.json()) as {
+      error: { code: string; message: string };
+    };
+    // Distinct from `conversation_not_found` so the Swift client can
+    // surface the right toast text without sniffing the URL path.
+    expect(body.error.code).toBe("playground_disabled");
+
+    // Flag-gated — the handler must not mutate conversation state or emit
+    // events when the playground is disabled.
+    expect(conversation.sentMessages).toHaveLength(0);
+  });
+
+  test("returns 404 with conversation_not_found code when the conversation is missing", async () => {
+    const deps = makeDeps({ enabled: true, conversation: undefined });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, "missing-conv-id", {});
+    expect(res.status).toBe(404);
+
+    const body = (await res.json()) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.code).toBe("conversation_not_found");
+    expect(body.error.message).toContain("missing-conv-id");
+  });
+
+  test("mutates both fields and emits compaction_circuit_open when both provided", async () => {
+    const conversation = makeConversation("conv-open");
+    const deps = makeDeps({ enabled: true, conversation });
+    const route = getInjectRoute(deps);
+
+    const beforeNow = Date.now();
+    const res = await invoke(route, conversation.conversationId, {
+      consecutiveFailures: 3,
+      circuitOpenForMs: 60_000,
+    });
+    const afterNow = Date.now();
+    expect(res.status).toBe(200);
+
+    expect(conversation.consecutiveCompactionFailures).toBe(3);
+    expect(conversation.compactionCircuitOpenUntil).not.toBeNull();
+    const openUntil = conversation.compactionCircuitOpenUntil!;
+    expect(openUntil).toBeGreaterThanOrEqual(beforeNow + 60_000);
+    expect(openUntil).toBeLessThanOrEqual(afterNow + 60_000);
+
+    // Exactly one event emitted with the expected shape.
+    expect(conversation.sentMessages).toHaveLength(1);
+    expect(conversation.sentMessages[0]).toEqual({
+      type: "compaction_circuit_open",
+      conversationId: conversation.conversationId,
+      reason: "3_consecutive_failures",
+      openUntil,
+    });
+  });
+
+  test("clears the circuit and emits compaction_circuit_closed on circuitOpenForMs: 0", async () => {
+    const conversation = makeConversation("conv-close");
+    // Start with an open breaker so the endpoint can clear it.
+    conversation.compactionCircuitOpenUntil = Date.now() + 10_000;
+    conversation.consecutiveCompactionFailures = 3;
+
+    const deps = makeDeps({ enabled: true, conversation });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, conversation.conversationId, {
+      circuitOpenForMs: 0,
+    });
+    expect(res.status).toBe(200);
+
+    expect(conversation.compactionCircuitOpenUntil).toBeNull();
+    // consecutiveFailures was not specified in the body, so it must be
+    // unchanged (the endpoint only mutates fields that are explicitly set).
+    expect(conversation.consecutiveCompactionFailures).toBe(3);
+
+    expect(conversation.sentMessages).toHaveLength(1);
+    expect(conversation.sentMessages[0]).toEqual({
+      type: "compaction_circuit_closed",
+      conversationId: conversation.conversationId,
+    });
+  });
+
+  test("is a no-op on the event channel when circuitOpenForMs: 0 but the breaker is already closed", async () => {
+    const conversation = makeConversation("conv-already-closed");
+    // Breaker is already closed before the request.
+    expect(conversation.compactionCircuitOpenUntil).toBeNull();
+
+    const deps = makeDeps({ enabled: true, conversation });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, conversation.conversationId, {
+      circuitOpenForMs: 0,
+    });
+    expect(res.status).toBe(200);
+
+    // Still null after the request.
+    expect(conversation.compactionCircuitOpenUntil).toBeNull();
+    // Critically: no `compaction_circuit_closed` event is emitted, since
+    // there was no open→closed transition. Clients must not see a spurious
+    // close event.
+    expect(conversation.sentMessages).toHaveLength(0);
+
+    // Response body still reflects the expected shape.
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.compactionCircuitOpenUntil).toBeNull();
+    expect(body.isCircuitOpen).toBe(false);
+  });
+
+  test("rejects out-of-range consecutiveFailures with 400", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps({ enabled: true, conversation });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, conversation.conversationId, {
+      consecutiveFailures: 99, // above max (10)
+    });
+    expect(res.status).toBe(400);
+
+    // No mutation, no event.
+    expect(conversation.consecutiveCompactionFailures).toBe(0);
+    expect(conversation.sentMessages).toHaveLength(0);
+  });
+
+  test("rejects out-of-range circuitOpenForMs with 400", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps({ enabled: true, conversation });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, conversation.conversationId, {
+      circuitOpenForMs: 25 * 60 * 60 * 1000, // 25h, above the 24h cap
+    });
+    expect(res.status).toBe(400);
+
+    expect(conversation.compactionCircuitOpenUntil).toBeNull();
+    expect(conversation.sentMessages).toHaveLength(0);
+  });
+
+  test("rejects negative consecutiveFailures with 400", async () => {
+    const conversation = makeConversation();
+    const deps = makeDeps({ enabled: true, conversation });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, conversation.conversationId, {
+      consecutiveFailures: -1,
+    });
+    expect(res.status).toBe(400);
+    expect(conversation.consecutiveCompactionFailures).toBe(0);
+  });
+
+  test("response body includes the full CompactionStateResponse shape", async () => {
+    const conversation = makeConversation("conv-shape");
+    const deps = makeDeps({ enabled: true, conversation });
+    const route = getInjectRoute(deps);
+
+    const res = await invoke(route, conversation.conversationId, {
+      consecutiveFailures: 2,
+    });
+    expect(res.status).toBe(200);
+
+    const body = (await res.json()) as Record<string, unknown>;
+    const requiredKeys = [
+      "estimatedInputTokens",
+      "maxInputTokens",
+      "compactThresholdRatio",
+      "thresholdTokens",
+      "messageCount",
+      "contextCompactedMessageCount",
+      "contextCompactedAt",
+      "consecutiveCompactionFailures",
+      "compactionCircuitOpenUntil",
+      "isCircuitOpen",
+      "isCompactionEnabled",
+    ];
+    for (const key of requiredKeys) {
+      expect(body).toHaveProperty(key);
+    }
+    expect(body.consecutiveCompactionFailures).toBe(2);
+    expect(body.isCircuitOpen).toBe(false);
+    expect(body.compactionCircuitOpenUntil).toBeNull();
+    expect(typeof body.estimatedInputTokens).toBe("number");
+    expect(typeof body.maxInputTokens).toBe("number");
+    expect(typeof body.compactThresholdRatio).toBe("number");
+    expect(typeof body.thresholdTokens).toBe("number");
+    expect(typeof body.messageCount).toBe("number");
+    expect(typeof body.isCompactionEnabled).toBe("boolean");
+  });
+});