@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/__tests__/update-bulletin-job.test.ts

@@ -1,292 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { getWorkspacePromptPath } from "../util/platform.js";
-
-// ── fs.readFileSync override (for read-failure test) ─────────────────
-// We mock node:fs so we can inject a readFileSync that throws for the
-// workspace path. All other call sites fall through to the real fs.
-const realReadFileSync = readFileSync;
-const realExistsSync = existsSync;
-
-let readFileSyncOverride:
-  | ((path: Parameters<typeof readFileSync>[0]) => string | undefined)
-  | null = null;
-
-mock.module("node:fs", () => ({
-  existsSync: realExistsSync,
-  readFileSync: ((
-    path: Parameters<typeof readFileSync>[0],
-    opts?: Parameters<typeof readFileSync>[1],
-  ) => {
-    if (readFileSyncOverride) {
-      const override = readFileSyncOverride(path);
-      if (override !== undefined) return override;
-    }
-    return realReadFileSync(path, opts);
-  }) as typeof readFileSync,
-}));
-
-// ── In-memory checkpoint store ───────────────────────────────────────
-const store = new Map<string, string>();
-let setCheckpointCallCount = 0;
-
-mock.module("../memory/checkpoints.js", () => ({
-  getMemoryCheckpoint: (key: string) => store.get(key) ?? null,
-  setMemoryCheckpoint: (key: string, value: string) => {
-    setCheckpointCallCount += 1;
-    store.set(key, value);
-  },
-}));
-
-// ── Mutable config stub ──────────────────────────────────────────────
-const updatesConfig = { enabled: true };
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({ updates: updatesConfig }),
-}));
-
-// ── pre-first-message gate stub ──────────────────────────────────────
-// Default: gate open (user has interacted) so the existing happy/sad
-// paths exercise the bulletin logic. A dedicated test below flips this
-// to false to assert the gate trips.
-let preFirstMessageGateOpen = true;
-
-mock.module("../runtime/pre-first-message-gate.js", () => ({
-  hasReceivedUserMessage: () => preFirstMessageGateOpen,
-}));
-
-// ── runBackgroundJob mock ────────────────────────────────────────────
-let runBackgroundJobCalls = 0;
-let runBackgroundJobLastArgs: Record<string, unknown> | null = null;
-let runBackgroundJobShouldThrow = false;
-let runBackgroundJobOk = true;
-let runBackgroundJobErrorKind:
-  | "timeout"
-  | "model_provider"
-  | "exception"
-  | undefined = undefined;
-let runBackgroundJobErrorMessage: string | undefined = undefined;
-// A side-effect function invoked during the job. Lets tests simulate the
-// agent deleting UPDATES.md while the job is running.
-let runBackgroundJobSideEffect: (() => void) | null = null;
-
-mock.module("../runtime/background-job-runner.js", () => ({
-  runBackgroundJob: async (opts: Record<string, unknown>) => {
-    runBackgroundJobCalls += 1;
-    runBackgroundJobLastArgs = opts;
-    if (runBackgroundJobSideEffect) {
-      runBackgroundJobSideEffect();
-    }
-    if (runBackgroundJobShouldThrow) {
-      throw new Error("simulated runner failure");
-    }
-    if (runBackgroundJobOk) {
-      return {
-        conversationId: `conv-${runBackgroundJobCalls}`,
-        ok: true,
-      };
-    }
-    return {
-      conversationId: `conv-${runBackgroundJobCalls}`,
-      ok: false,
-      error: new Error(runBackgroundJobErrorMessage ?? "simulated failure"),
-      errorKind: runBackgroundJobErrorKind ?? "exception",
-    };
-  },
-}));
-
-const { runUpdateBulletinJobIfNeeded } =
-  await import("../prompts/update-bulletin-job.js");
-
-const HASH_CHECKPOINT_KEY = "updates:last_processed_hash";
-const EMPTY_HASH = "empty";
-
-function sha256(input: string): string {
-  return createHash("sha256").update(input).digest("hex");
-}
-
-const workspacePath = getWorkspacePromptPath("UPDATES.md");
-
-describe("runUpdateBulletinJobIfNeeded", () => {
-  beforeEach(() => {
-    store.clear();
-    setCheckpointCallCount = 0;
-    runBackgroundJobCalls = 0;
-    runBackgroundJobLastArgs = null;
-    runBackgroundJobShouldThrow = false;
-    runBackgroundJobOk = true;
-    runBackgroundJobErrorKind = undefined;
-    runBackgroundJobErrorMessage = undefined;
-    runBackgroundJobSideEffect = null;
-    readFileSyncOverride = null;
-    updatesConfig.enabled = true;
-    preFirstMessageGateOpen = true;
-    if (existsSync(workspacePath)) {
-      rmSync(workspacePath);
-    }
-  });
-
-  afterEach(() => {
-    if (existsSync(workspacePath)) {
-      rmSync(workspacePath);
-    }
-  });
-
-  test("config disabled — no job, no checkpoint change", async () => {
-    updatesConfig.enabled = false;
-    writeFileSync(workspacePath, "## Real content", "utf-8");
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(0);
-    expect(setCheckpointCallCount).toBe(0);
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
-  });
-
-  test("pre-first-message gate closed — no job, checkpoint left UNCHANGED so the job retries after the user interacts", async () => {
-    preFirstMessageGateOpen = false;
-    writeFileSync(workspacePath, "## Real content", "utf-8");
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(0);
-    expect(setCheckpointCallCount).toBe(0);
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
-  });
-
-  test("file missing, stored hash absent — no job; stored becomes 'empty'", async () => {
-    expect(existsSync(workspacePath)).toBe(false);
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(0);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
-  });
-
-  test("file missing, stored hash already 'empty' — no job; no checkpoint write", async () => {
-    store.set(HASH_CHECKPOINT_KEY, EMPTY_HASH);
-    setCheckpointCallCount = 0;
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(0);
-    expect(setCheckpointCallCount).toBe(0);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
-  });
-
-  test("file present but whitespace-only — treated as empty; stored hash 'empty'", async () => {
-    writeFileSync(workspacePath, "   \n\n\t\n", "utf-8");
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(0);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
-  });
-
-  test("file present, job ok=true, file unchanged — stored hash is sha256(trimmed); jobName/source are kebab-case", async () => {
-    const content = "## Release 1.2.3\n\nNew thing.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(1);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(sha256(content.trim()));
-    expect(runBackgroundJobLastArgs?.jobName).toBe("update-bulletin");
-    expect(runBackgroundJobLastArgs?.source).toBe("update-bulletin");
-    expect(runBackgroundJobLastArgs?.origin).toBe("updates_bulletin");
-    expect(runBackgroundJobLastArgs?.callSite).toBe("mainAgent");
-  });
-
-  test("file present, stored hash matches current — no job", async () => {
-    const content = "## Release 1.2.3\n\nSame content.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    store.set(HASH_CHECKPOINT_KEY, sha256(content.trim()));
-    setCheckpointCallCount = 0;
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(0);
-    expect(setCheckpointCallCount).toBe(0);
-  });
-
-  test("runBackgroundJob returns ok=false — checkpoint UNCHANGED so next startup retries", async () => {
-    const content = "## Release Q\n\nFailure scenario.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    runBackgroundJobOk = false;
-    runBackgroundJobErrorKind = "exception";
-    runBackgroundJobErrorMessage = "boom";
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(1);
-    // Critical: do NOT poison the checkpoint when the job fails.
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
-    expect(setCheckpointCallCount).toBe(0);
-  });
-
-  test("runBackgroundJob ok=true + agent deletes file mid-run — stored hash becomes 'empty'", async () => {
-    const content = "## Release X\n\nStuff to process.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-    runBackgroundJobSideEffect = () => {
-      rmSync(workspacePath);
-    };
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(1);
-    expect(existsSync(workspacePath)).toBe(false);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(EMPTY_HASH);
-  });
-
-  test("file present, stored hash differs — job invoked; stored hash updates", async () => {
-    const oldContent = "## Old";
-    const newContent = "## New content v2";
-    writeFileSync(workspacePath, newContent, "utf-8");
-    store.set(HASH_CHECKPOINT_KEY, sha256(oldContent));
-
-    await runUpdateBulletinJobIfNeeded();
-
-    expect(runBackgroundJobCalls).toBe(1);
-    expect(store.get(HASH_CHECKPOINT_KEY)).toBe(sha256(newContent.trim()));
-    expect(store.get(HASH_CHECKPOINT_KEY)).not.toBe(sha256(oldContent));
-  });
-
-  test("file present but readFileSync throws — checkpoint UNCHANGED; warn logged", async () => {
-    const content = "## Release U\n\nSimulated read failure.\n";
-    writeFileSync(workspacePath, content, "utf-8");
-
-    readFileSyncOverride = (path) => {
-      if (typeof path === "string" && path === workspacePath) {
-        throw new Error("EACCES simulated");
-      }
-      return undefined;
-    };
-
-    try {
-      await runUpdateBulletinJobIfNeeded();
-    } finally {
-      readFileSyncOverride = null;
-    }
-
-    expect(runBackgroundJobCalls).toBe(0);
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
-    expect(setCheckpointCallCount).toBe(0);
-  });
-
-  test("runBackgroundJob throws — function does not reject; warning logged", async () => {
-    const content = "## Release Z";
-    writeFileSync(workspacePath, content, "utf-8");
-    runBackgroundJobShouldThrow = true;
-
-    // Must not throw.
-    await expect(runUpdateBulletinJobIfNeeded()).resolves.toBeUndefined();
-
-    expect(runBackgroundJobCalls).toBe(1);
-    // Hash was never updated because the try/catch returned before the
-    // self-healing step.
-    expect(store.has(HASH_CHECKPOINT_KEY)).toBe(false);
-  });
-});

package/src/config/schemas/updates.ts

@@ -1,14 +0,0 @@
-import { z } from "zod";
-
-export const UpdatesConfigSchema = z
-  .object({
-    enabled: z
-      .boolean({ error: "updates.enabled must be a boolean" })
-      .default(true)
-      .describe(
-        "Whether to dispatch a background conversation when <workspace>/UPDATES.md has unprocessed content. When false, release-update bulletins are written by migrations but never processed by the agent.",
-      ),
-  })
-  .describe("Release update bulletin configuration");
-
-export type UpdatesConfig = z.infer<typeof UpdatesConfigSchema>;

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

@@ -1,227 +0,0 @@
-/**
- * Tests for the ClickHouse compaction log writer.
- *
- * The writer 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, and the start/end row mappings
- * (sentinels on the start row, full `ContextWindowResult` projection on the
- * end row).
- */
-import { describe, expect, test } from "bun:test";
-
-import type { ContextWindowResult } from "../../plugins/defaults/compaction/window-manager.js";
-import {
-  ClickHouseCompactionLogWriter,
-  type CompactionEndEvent,
-  type CompactionStartEvent,
-} from "../compaction-log-writer-clickhouse.js";
-
-interface CapturedRequest {
-  url: URL;
-  body: string;
-}
-
-function createWriter(overrides?: {
-  fetchImpl?: (url: string, init?: RequestInit) => Promise<Response>;
-}): { writer: ClickHouseCompactionLogWriter; 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 ClickHouseCompactionLogWriter(
-    { 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: [],
-  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,
-  messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-};
-
-describe("ClickHouseCompactionLogWriter", () => {
-  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.basis_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,
-      result: {
-        ...result,
-        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 write 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,
-      result: { ...result, 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);
-  });
-});

package/src/memory/conversation-starters-cadence.ts

@@ -1,78 +0,0 @@
-/**
- * Cadence logic for conversation starters generation.
- *
- * Decides whether a new generation job should be enqueued based on how many
- * active memory items have accumulated since the last generation.
- */
-
-import { and, eq, inArray, sql } from "drizzle-orm";
-
-import { getLogger } from "../util/logger.js";
-import { getDb } from "./db-connection.js";
-import { enqueueMemoryJob, isMemoryEnabled } from "./jobs-store.js";
-import { rawGet } from "./raw-query.js";
-import { memoryCheckpoints, memoryJobs } from "./schema.js";
-
-const log = getLogger("conversation-starters-cadence");
-
-/**
- * Check whether enough new memory items have accumulated to justify
- * generating a fresh batch of conversation starters.
- */
-export function maybeEnqueueConversationStartersJob(scopeId: string): void {
-  if (!isMemoryEnabled()) return;
-
-  const db = getDb();
-
-  // Count total active memory items
-  const countRow = rawGet<{ c: number }>(
-    `SELECT COUNT(*) AS c FROM memory_graph_nodes WHERE fidelity != 'gone' AND scope_id = ?`,
-    scopeId,
-  );
-  const totalActive = countRow?.c ?? 0;
-  if (totalActive === 0) return;
-
-  // Read checkpoint: item count at last generation (scoped so each scope tracks independently)
-  const checkpointKey = `conversation_starters:item_count_at_last_gen:${scopeId}`;
-  const checkpoint = db
-    .select({ value: memoryCheckpoints.value })
-    .from(memoryCheckpoints)
-    .where(eq(memoryCheckpoints.key, checkpointKey))
-    .get();
-  const parsedLastCount = checkpoint ? parseInt(checkpoint.value, 10) : 0;
-  const lastCount = Number.isFinite(parsedLastCount) ? parsedLastCount : 0;
-
-  // Cadence formula
-  let threshold: number;
-  if (totalActive <= 10) {
-    threshold = 1;
-  } else if (totalActive <= 50) {
-    threshold = 5;
-  } else {
-    threshold = 10;
-  }
-
-  const checkpointAhead = totalActive < lastCount;
-  const delta = Math.max(0, totalActive - lastCount);
-  if (!checkpointAhead && delta < threshold) return;
-
-  // Dedup: don't enqueue if a pending/running job for this scope already exists
-  const existing = db
-    .select({ id: memoryJobs.id })
-    .from(memoryJobs)
-    .where(
-      and(
-        eq(memoryJobs.type, "generate_conversation_starters"),
-        inArray(memoryJobs.status, ["pending", "running"]),
-        sql`json_extract(${memoryJobs.payload}, '$.scopeId') = ${scopeId}`,
-      ),
-    )
-    .get();
-  if (existing) return;
-
-  enqueueMemoryJob("generate_conversation_starters", { scopeId });
-  log.info(
-    { totalActive, lastCount, delta, threshold, scopeId, checkpointAhead },
-    "Enqueued conversation starters generation job",
-  );
-}