@vellumai/assistant 0.6.5 → 0.6.6

package/src/runtime/routes/playground/__tests__/reset-circuit.test.ts

@@ -0,0 +1,271 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks — must appear before any imports of the modules under test.
+// ---------------------------------------------------------------------------
+
+mock.module("../../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../../../../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: {
+      default: {
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 200_000,
+          compactThreshold: 0.8,
+        },
+      },
+    },
+  }),
+}));
+
+mock.module("../../../../context/token-estimator.js", () => ({
+  estimatePromptTokens: () => 1234,
+}));
+
+// ---------------------------------------------------------------------------
+// Imports under test — after mocks.
+// ---------------------------------------------------------------------------
+
+import type { Conversation } from "../../../../daemon/conversation.js";
+import type { ServerMessage } from "../../../../daemon/message-protocol.js";
+import type { RouteContext, RouteDefinition } from "../../../http-router.js";
+import type { PlaygroundRouteDeps } from "../deps.js";
+import { resetCircuitRouteDefinitions } from "../reset-circuit.js";
+
+// ---------------------------------------------------------------------------
+// Test helpers
+// ---------------------------------------------------------------------------
+
+interface FakeConversationState {
+  consecutiveCompactionFailures: number;
+  compactionCircuitOpenUntil: number | null;
+  contextCompactedMessageCount: number;
+  contextCompactedAt: number | null;
+}
+
+interface FakeConversation {
+  conversation: Conversation;
+  sent: ServerMessage[];
+  state: FakeConversationState;
+}
+
+function makeFakeConversation(
+  overrides: Partial<FakeConversationState> = {},
+): FakeConversation {
+  const state: FakeConversationState = {
+    consecutiveCompactionFailures: 0,
+    compactionCircuitOpenUntil: null,
+    contextCompactedMessageCount: 0,
+    contextCompactedAt: null,
+    ...overrides,
+  };
+  const sent: ServerMessage[] = [];
+  const fake = {
+    conversationId: "conv-abc",
+    get consecutiveCompactionFailures(): number {
+      return state.consecutiveCompactionFailures;
+    },
+    set consecutiveCompactionFailures(value: number) {
+      state.consecutiveCompactionFailures = value;
+    },
+    get compactionCircuitOpenUntil(): number | null {
+      return state.compactionCircuitOpenUntil;
+    },
+    set compactionCircuitOpenUntil(value: number | null) {
+      state.compactionCircuitOpenUntil = value;
+    },
+    get contextCompactedMessageCount(): number {
+      return state.contextCompactedMessageCount;
+    },
+    get contextCompactedAt(): number | null {
+      return state.contextCompactedAt;
+    },
+    getMessages: () => [],
+    sendToClient: (msg: ServerMessage) => {
+      sent.push(msg);
+    },
+  } as unknown as Conversation;
+
+  return { conversation: fake, sent, state };
+}
+
+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(conversationId: string): RouteContext {
+  const url = new URL(
+    `http://localhost/v1/conversations/${conversationId}/playground/reset-compaction-circuit`,
+  );
+  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: conversationId },
+  } as unknown as RouteContext;
+}
+
+function getHandler(deps: PlaygroundRouteDeps): RouteDefinition["handler"] {
+  const routes = resetCircuitRouteDefinitions(deps);
+  expect(routes).toHaveLength(1);
+  return routes[0].handler;
+}
+
+async function readJsonBody(response: Response): Promise<unknown> {
+  return response.json();
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("reset-circuit route — metadata", () => {
+  test("registers POST at conversations/:id/playground/reset-compaction-circuit", () => {
+    const routes = resetCircuitRouteDefinitions(makeDeps());
+    expect(routes).toHaveLength(1);
+    const route = routes[0];
+    expect(route.endpoint).toBe(
+      "conversations/:id/playground/reset-compaction-circuit",
+    );
+    expect(route.method).toBe("POST");
+    expect(route.policyKey).toBe("conversations/playground/reset-circuit");
+    expect(route.tags).toContain("playground");
+  });
+});
+
+describe("reset-circuit route — gating", () => {
+  let fake: FakeConversation;
+
+  beforeEach(() => {
+    fake = makeFakeConversation();
+  });
+
+  test("returns 404 with playground_disabled code when the playground flag is disabled", async () => {
+    const deps = makeDeps({
+      isPlaygroundEnabled: () => false,
+      getConversationById: async () => fake.conversation,
+    });
+    const handler = getHandler(deps);
+
+    const response = (await handler(makeRouteContext("conv-abc"))) as Response;
+
+    expect(response.status).toBe(404);
+    const body = (await readJsonBody(response)) 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");
+    // State must not be mutated and no event emitted on the disabled path.
+    expect(fake.state.consecutiveCompactionFailures).toBe(0);
+    expect(fake.state.compactionCircuitOpenUntil).toBeNull();
+    expect(fake.sent).toHaveLength(0);
+  });
+
+  test("returns 404 with conversation_not_found code when the conversation is missing", async () => {
+    const deps = makeDeps({
+      getConversationById: async () => undefined,
+    });
+    const handler = getHandler(deps);
+
+    const response = (await handler(
+      makeRouteContext("missing-id"),
+    )) as Response;
+
+    expect(response.status).toBe(404);
+    const body = (await readJsonBody(response)) as {
+      error: { code: string; message: string };
+    };
+    expect(body.error.code).toBe("conversation_not_found");
+    expect(body.error.message).toContain("missing-id");
+  });
+});
+
+describe("reset-circuit route — behavior", () => {
+  test("clears an open circuit and emits compaction_circuit_closed exactly once", async () => {
+    const future = Date.now() + 60 * 60 * 1000;
+    const fake = makeFakeConversation({
+      consecutiveCompactionFailures: 2,
+      compactionCircuitOpenUntil: future,
+    });
+    const deps = makeDeps({
+      getConversationById: async () => fake.conversation,
+    });
+    const handler = getHandler(deps);
+
+    const response = (await handler(makeRouteContext("conv-abc"))) as Response;
+
+    expect(response.status).toBe(200);
+    expect(fake.state.consecutiveCompactionFailures).toBe(0);
+    expect(fake.state.compactionCircuitOpenUntil).toBeNull();
+    expect(fake.sent).toHaveLength(1);
+    expect(fake.sent[0]).toEqual({
+      type: "compaction_circuit_closed",
+      conversationId: "conv-abc",
+    });
+
+    const body = (await readJsonBody(response)) as Record<string, unknown>;
+    expect(body.consecutiveCompactionFailures).toBe(0);
+    expect(body.compactionCircuitOpenUntil).toBeNull();
+    expect(body.isCircuitOpen).toBe(false);
+    expect(body.estimatedInputTokens).toBe(1234);
+    expect(body.maxInputTokens).toBe(200_000);
+    expect(body.compactThresholdRatio).toBe(0.8);
+    expect(body.thresholdTokens).toBe(160_000);
+    expect(body.messageCount).toBe(0);
+    expect(body.contextCompactedMessageCount).toBe(0);
+    expect(body.contextCompactedAt).toBeNull();
+    expect(body.isCompactionEnabled).toBe(true);
+  });
+
+  test("with the circuit already closed, zeroes the counter without emitting an event", async () => {
+    const fake = makeFakeConversation({
+      consecutiveCompactionFailures: 2,
+      compactionCircuitOpenUntil: null,
+    });
+    const deps = makeDeps({
+      getConversationById: async () => fake.conversation,
+    });
+    const handler = getHandler(deps);
+
+    const response = (await handler(makeRouteContext("conv-abc"))) as Response;
+
+    expect(response.status).toBe(200);
+    expect(fake.state.consecutiveCompactionFailures).toBe(0);
+    expect(fake.state.compactionCircuitOpenUntil).toBeNull();
+    // Do not emit compaction_circuit_closed when the breaker was already
+    // closed — the event is reserved for the open→closed transition so the
+    // Swift banner doesn't receive redundant "paused" dismissals.
+    expect(fake.sent).toHaveLength(0);
+
+    const body = (await readJsonBody(response)) as Record<string, unknown>;
+    expect(body.consecutiveCompactionFailures).toBe(0);
+    expect(body.compactionCircuitOpenUntil).toBeNull();
+    expect(body.isCircuitOpen).toBe(false);
+  });
+});

package/src/runtime/routes/playground/__tests__/seed-conversation.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test";
+
+import type { Conversation } from "../../../../daemon/conversation.js";
+import type { RouteDefinition } from "../../../http-router.js";
+import type { PlaygroundRouteDeps } from "../deps.js";
+import {
+  PLAYGROUND_TITLE_PREFIX,
+  seedConversationRouteDefinitions,
+} from "../seed-conversation.js";
+
+type AddMessageArgs = [
+  string,
+  "user" | "assistant",
+  string,
+  { skipIndexing?: boolean } | undefined,
+];
+
+interface Spy {
+  deps: PlaygroundRouteDeps;
+  createdTitles: string[];
+  addedMessages: AddMessageArgs[];
+}
+
+function makeDeps(overrides?: { enabled?: boolean }): Spy {
+  const createdTitles: string[] = [];
+  const addedMessages: AddMessageArgs[] = [];
+  let nextConvId = 0;
+  let nextMessageId = 0;
+
+  const deps: PlaygroundRouteDeps = {
+    getConversationById: async (
+      _id: string,
+    ): Promise<Conversation | undefined> => undefined,
+    isPlaygroundEnabled: () => overrides?.enabled ?? true,
+    listConversationsByTitlePrefix: () => [],
+    deleteConversationById: () => false,
+    createConversation: async (title) => {
+      createdTitles.push(title);
+      return { id: `conv-${++nextConvId}` };
+    },
+    addMessage: async (conversationId, role, contentJson, options) => {
+      addedMessages.push([conversationId, role, contentJson, options]);
+      return { id: `msg-${++nextMessageId}` };
+    },
+  };
+  return { deps, createdTitles, addedMessages };
+}
+
+function getSeedHandler(deps: PlaygroundRouteDeps): RouteDefinition["handler"] {
+  const routes = seedConversationRouteDefinitions(deps);
+  const route = routes.find(
+    (r) => r.endpoint === "playground/seed-conversation" && r.method === "POST",
+  );
+  if (!route) throw new Error("seed-conversation route not registered");
+  return route.handler;
+}
+
+function makeCtx(body: unknown) {
+  const url = new URL("http://localhost/v1/playground/seed-conversation");
+  return {
+    url,
+    req: new Request(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    }),
+    server: {} as ReturnType<typeof Bun.serve>,
+    authContext: {} as never,
+    params: {},
+  };
+}
+
+describe("POST /v1/playground/seed-conversation", () => {
+  test("returns 404 with playground_disabled code when the playground flag is disabled", async () => {
+    const { deps } = makeDeps({ enabled: false });
+    const handler = getSeedHandler(deps);
+
+    const res = await handler(makeCtx({ turns: 3 }));
+    expect(res.status).toBe(404);
+
+    const body = (await res.json()) as { error: { code: 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("seeds N turns as 2N messages and returns conversation id", async () => {
+    const spy = makeDeps();
+    const handler = getSeedHandler(spy.deps);
+
+    const res = await handler(makeCtx({ turns: 5, avgTokensPerTurn: 500 }));
+    expect(res.status).toBe(200);
+
+    const body = (await res.json()) as {
+      conversationId: string;
+      messagesInserted: number;
+      estimatedTokens: number;
+    };
+    expect(body.conversationId).toBe("conv-1");
+    expect(body.messagesInserted).toBe(10);
+    expect(spy.createdTitles).toHaveLength(1);
+    expect(spy.addedMessages).toHaveLength(10);
+
+    // Roles alternate user/assistant across the 10 inserted messages.
+    for (let i = 0; i < spy.addedMessages.length; i++) {
+      const [convId, role, contentJson, options] = spy.addedMessages[i];
+      expect(convId).toBe("conv-1");
+      expect(role).toBe(i % 2 === 0 ? "user" : "assistant");
+      // Content is a JSON-encoded array of blocks matching the in-memory
+      // Message[] shape the rest of the daemon expects.
+      const parsed = JSON.parse(contentJson) as Array<{
+        type: string;
+        text: string;
+      }>;
+      expect(parsed[0].type).toBe("text");
+      expect(parsed[0].text.length).toBeGreaterThan(0);
+      // Every seeded message must skip memory/vector indexing — the
+      // lorem-ipsum payload has no semantic value and embedding it would
+      // pollute the vector store.
+      expect(options?.skipIndexing).toBe(true);
+    }
+  });
+
+  test("returns a positive estimated token count", async () => {
+    const spy = makeDeps();
+    const handler = getSeedHandler(spy.deps);
+
+    const res = await handler(makeCtx({ turns: 5, avgTokensPerTurn: 500 }));
+    expect(res.status).toBe(200);
+
+    // We intentionally don't assert tight bounds: sibling playground tests
+    // call `mock.module(".../token-estimator.js", ...)` at module scope,
+    // and Bun persists that mock across files in the same test run. All we
+    // can safely assert is that some positive estimate was produced — the
+    // exact value is exercised by the estimator's own tests.
+    const body = (await res.json()) as { estimatedTokens: number };
+    expect(body.estimatedTokens).toBeGreaterThan(0);
+  });
+
+  test("rejects turns: 0", async () => {
+    const { deps } = makeDeps();
+    const handler = getSeedHandler(deps);
+    const res = await handler(makeCtx({ turns: 0 }));
+    expect(res.status).toBe(400);
+  });
+
+  test("rejects turns: 501 (above max)", async () => {
+    const { deps } = makeDeps();
+    const handler = getSeedHandler(deps);
+    const res = await handler(makeCtx({ turns: 501 }));
+    expect(res.status).toBe(400);
+  });
+
+  test("rejects negative avgTokensPerTurn", async () => {
+    const { deps } = makeDeps();
+    const handler = getSeedHandler(deps);
+    const res = await handler(makeCtx({ turns: 2, avgTokensPerTurn: -1 }));
+    expect(res.status).toBe(400);
+  });
+
+  test("prepends [Playground] prefix to a plain title", async () => {
+    const spy = makeDeps();
+    const handler = getSeedHandler(spy.deps);
+
+    const res = await handler(makeCtx({ turns: 1, title: "My test" }));
+    expect(res.status).toBe(200);
+    expect(spy.createdTitles[0]).toBe(`${PLAYGROUND_TITLE_PREFIX}My test`);
+  });
+
+  test("does not double up when the title already starts with the prefix", async () => {
+    const spy = makeDeps();
+    const handler = getSeedHandler(spy.deps);
+
+    const res = await handler(
+      makeCtx({
+        turns: 1,
+        title: `${PLAYGROUND_TITLE_PREFIX}existing`,
+      }),
+    );
+    expect(res.status).toBe(200);
+    expect(spy.createdTitles[0]).toBe(`${PLAYGROUND_TITLE_PREFIX}existing`);
+  });
+
+  test("falls back to an ISO timestamp title when none is supplied", async () => {
+    const spy = makeDeps();
+    const handler = getSeedHandler(spy.deps);
+
+    const res = await handler(makeCtx({ turns: 1 }));
+    expect(res.status).toBe(200);
+
+    const created = spy.createdTitles[0];
+    // Pattern: "[Playground] YYYY-MM-DDTHH:MM:SS"
+    expect(created).toMatch(
+      new RegExp(
+        `^${PLAYGROUND_TITLE_PREFIX.replace(
+          /[[\]]/g,
+          "\\$&",
+        )}\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}$`,
+      ),
+    );
+  });
+});