@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/memory/migrations/__tests__/209-strip-thinking-from-consolidated.test.ts

@@ -0,0 +1,224 @@
+/**
+ * Tests for migration 209 — stripping thinking / redacted_thinking blocks from
+ * persisted assistant messages.
+ *
+ * The migration rewrites content entirely inside SQLite (JSON1), dispatched a
+ * rowid window at a time through `runAsyncSqlite`. These tests drive the step
+ * directly against a real DB and assert the at-rest content, idempotency,
+ * scoping (assistant rows only), tolerance of malformed content, and that the
+ * persisted rowid watermark is honored for resume.
+ */
+import { describe, expect, test } from "bun:test";
+
+const { getDb, getSqlite } = await import("../../db-connection.js");
+const { initializeDb } = await import("../../db-init.js");
+const { migrateStripThinkingFromConsolidated } =
+  await import("../209-strip-thinking-from-consolidated.js");
+
+await initializeDb();
+
+const CONV = "conv-209";
+getSqlite()
+  .query(
+    `INSERT OR IGNORE INTO conversations (id, created_at, updated_at) VALUES (?, ?, ?)`,
+  )
+  .run(CONV, Date.now(), Date.now());
+
+let seq = 0;
+function insert(role: string, content: string): { id: string; rowid: number } {
+  const id = `m209-${seq++}`;
+  getSqlite()
+    .query(
+      `INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)`,
+    )
+    .run(id, CONV, role, content, Date.now());
+  const rowid = (
+    getSqlite()
+      .query(`SELECT rowid AS r FROM messages WHERE id = ?`)
+      .get(id) as { r: number }
+  ).r;
+  return { id, rowid };
+}
+
+function content(id: string): string {
+  return (
+    getSqlite().query(`SELECT content FROM messages WHERE id = ?`).get(id) as {
+      content: string;
+    }
+  ).content;
+}
+
+function blocks(id: string): Array<Record<string, unknown>> {
+  return JSON.parse(content(id));
+}
+
+describe("migration 209 — strip thinking from consolidated assistant messages", () => {
+  test("strips thinking blocks but keeps text and tool_use, preserving order", async () => {
+    const { id } = insert(
+      "assistant",
+      JSON.stringify([
+        { type: "thinking", thinking: "secret", signature: "sig" },
+        { type: "text", text: "hello" },
+        { type: "tool_use", id: "t1", name: "x", input: { a: 1 } },
+      ]),
+    );
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    expect(blocks(id)).toEqual([
+      { type: "text", text: "hello" },
+      { type: "tool_use", id: "t1", name: "x", input: { a: 1 } },
+    ]);
+  });
+
+  test("strips redacted_thinking blocks", async () => {
+    const { id } = insert(
+      "assistant",
+      JSON.stringify([
+        { type: "redacted_thinking", data: "blob" },
+        { type: "text", text: "world" },
+      ]),
+    );
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    expect(blocks(id)).toEqual([{ type: "text", text: "world" }]);
+  });
+
+  test("all-thinking message becomes the null-byte placeholder sentinel", async () => {
+    const { id } = insert(
+      "assistant",
+      JSON.stringify([
+        { type: "thinking", thinking: "a", signature: "s1" },
+        { type: "redacted_thinking", data: "b" },
+      ]),
+    );
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    const result = blocks(id);
+    expect(result).toHaveLength(1);
+    expect(result[0].type).toBe("text");
+    expect(result[0].text).toBe("\x00__PLACEHOLDER__[internal blocks omitted]");
+    // The leading byte must be a literal NUL, produced by SQLite's char(0).
+    expect((result[0].text as string).charCodeAt(0)).toBe(0);
+  });
+
+  test("preserves blocks with a missing/null type", async () => {
+    const { id } = insert(
+      "assistant",
+      JSON.stringify([
+        { type: "thinking", thinking: "x", signature: "s" },
+        { foo: "bar" },
+        { type: "text", text: "kept" },
+      ]),
+    );
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    expect(blocks(id)).toEqual([
+      { foo: "bar" },
+      { type: "text", text: "kept" },
+    ]);
+  });
+
+  test("leaves thinking-free assistant messages untouched", async () => {
+    const original = JSON.stringify([
+      { type: "text", text: "I was thinking about lunch" },
+    ]);
+    const { id } = insert("assistant", original);
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    // Substring 'thinking' appears in the text but no block is of thinking type.
+    expect(content(id)).toBe(original);
+  });
+
+  test("does not touch non-assistant roles", async () => {
+    const original = JSON.stringify([
+      { type: "thinking", thinking: "x", signature: "s" },
+      { type: "text", text: "u" },
+    ]);
+    const { id } = insert("user", original);
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    expect(content(id)).toBe(original);
+  });
+
+  test("tolerates non-array and invalid JSON content", async () => {
+    const obj = insert(
+      "assistant",
+      JSON.stringify({ type: "thinking", thinking: "x" }),
+    );
+    const invalid = insert("assistant", "{not json with thinking");
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    expect(content(obj.id)).toBe(
+      JSON.stringify({ type: "thinking", thinking: "x" }),
+    );
+    expect(content(invalid.id)).toBe("{not json with thinking");
+  });
+
+  test("is idempotent across repeated runs", async () => {
+    const { id } = insert(
+      "assistant",
+      JSON.stringify([
+        { type: "thinking", thinking: "x", signature: "s" },
+        { type: "text", text: "stable" },
+      ]),
+    );
+
+    await migrateStripThinkingFromConsolidated(getDb());
+    const once = content(id);
+    await migrateStripThinkingFromConsolidated(getDb());
+    const twice = content(id);
+
+    expect(twice).toBe(once);
+    expect(blocks(id)).toEqual([{ type: "text", text: "stable" }]);
+  });
+
+  test("honors the persisted rowid watermark and resumes above it", async () => {
+    const below = insert(
+      "assistant",
+      JSON.stringify([
+        { type: "thinking", thinking: "x", signature: "s" },
+        { type: "text", text: "below" },
+      ]),
+    );
+    const above = insert(
+      "assistant",
+      JSON.stringify([
+        { type: "thinking", thinking: "y", signature: "s" },
+        { type: "text", text: "above" },
+      ]),
+    );
+
+    // Pretend a prior run already swept through `below`'s rowid: the sweep must
+    // resume strictly above it, leaving `below` untouched and cleaning `above`.
+    getSqlite()
+      .query(
+        `INSERT OR REPLACE INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
+      )
+      .run(
+        "migration_209_strip_thinking_watermark",
+        String(below.rowid),
+        Date.now(),
+      );
+
+    await migrateStripThinkingFromConsolidated(getDb());
+
+    expect(blocks(below.id)).toEqual([
+      { type: "thinking", thinking: "x", signature: "s" },
+      { type: "text", text: "below" },
+    ]);
+    expect(blocks(above.id)).toEqual([{ type: "text", text: "above" }]);
+
+    // The watermark is cleared once the sweep reaches the end of the table.
+    const wm = getSqlite()
+      .query(`SELECT value FROM memory_checkpoints WHERE key = ?`)
+      .get("migration_209_strip_thinking_watermark");
+    expect(wm).toBeNull();
+  });
+});

package/src/memory/migrations/__tests__/297-move-llm-request-logs.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Tests for migration 297 — housing `llm_request_logs` in the dedicated
+ * `logs` database connection.
+ *
+ * Covers:
+ *   1. End state after a full initializeDb(): the table lives in the logs
+ *      connection, not `main`, and the Drizzle store round-trips against it.
+ *   2. The relocation itself: rows in a `main.llm_request_logs` are copied into
+ *      the logs connection and the main-DB copy is dropped, with indexes built
+ *      in the logs connection.
+ *   3. A legacy base-only `main` table (predating the newer columns) is copied
+ *      without error, NULL-filling the absent columns.
+ *
+ * The step is idempotent and not checkpoint-gated, so each test can drive it
+ * directly without clearing any checkpoint.
+ */
+import { describe, expect, test } from "bun:test";
+
+const { getDb, getSqlite, getLogsSqlite } =
+  await import("../../db-connection.js");
+const { initializeDb } = await import("../../db-init.js");
+const { migrateMoveLlmRequestLogsToLogsDb } =
+  await import("../297-move-llm-request-logs-to-logs-db.js");
+const { recordRequestLog, getRequestLogById } =
+  await import("../../llm-request-log-store.js");
+
+await initializeDb();
+
+function existsInMain(name: string): boolean {
+  return (
+    getSqlite()
+      .query(
+        `SELECT name FROM main.sqlite_master WHERE type='table' AND name = ?`,
+      )
+      .get(name) != null
+  );
+}
+
+function existsInLogs(name: string): boolean {
+  return (
+    getLogsSqlite()!
+      .query(`SELECT name FROM sqlite_master WHERE type='table' AND name = ?`)
+      .get(name) != null
+  );
+}
+
+function stagingExists(table: string): boolean {
+  return existsInMain(`${table}__relocating`);
+}
+
+describe("migration 297 — llm_request_logs lives in the logs database", () => {
+  test("after init, the table is in logs and not in main", () => {
+    expect(existsInLogs("llm_request_logs")).toBe(true);
+    expect(existsInMain("llm_request_logs")).toBe(false);
+  });
+
+  test("the store round-trips against the relocated table", () => {
+    const id = recordRequestLog(
+      "conv-297",
+      JSON.stringify({ req: 1 }),
+      JSON.stringify({ res: 1 }),
+      "msg-297",
+      "anthropic",
+      "mainAgent",
+    );
+    const row = getRequestLogById(id);
+    expect(row?.conversationId).toBe("conv-297");
+    expect(row?.messageId).toBe("msg-297");
+    expect(row?.provider).toBe("anthropic");
+    expect(row?.callSite).toBe("mainAgent");
+
+    // The written row physically lives in the logs database.
+    const inLogs = getLogsSqlite()!
+      .query<
+        { c: number },
+        [string]
+      >(`SELECT COUNT(*) AS c FROM llm_request_logs WHERE id = ?`)
+      .get(id);
+    expect(inLogs?.c).toBe(1);
+  });
+
+  test("relocates rows from a main-DB table and drops it", async () => {
+    const sqlite = getSqlite();
+    const logs = getLogsSqlite()!;
+
+    // Simulate a populated pre-relocation main-DB table alongside the logs copy.
+    logs.exec(`DROP TABLE IF EXISTS llm_request_logs`);
+    sqlite.exec(`DROP TABLE IF EXISTS main.llm_request_logs__relocating`);
+    sqlite.exec(`
+      CREATE TABLE main.llm_request_logs (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        message_id TEXT,
+        provider TEXT,
+        request_payload TEXT NOT NULL,
+        response_payload TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        agent_loop_exit_reason TEXT,
+        call_site TEXT
+      )
+    `);
+    sqlite.exec(
+      `INSERT INTO main.llm_request_logs (id, conversation_id, request_payload, response_payload, created_at, provider) VALUES ('legacy-1', 'conv-legacy', '{}', '{}', 123, 'openai')`,
+    );
+
+    // The migration stages the populated table aside and drains it inline,
+    // copying the rows into logs and dropping the staging table before it
+    // resolves.
+    await migrateMoveLlmRequestLogsToLogsDb(getDb());
+
+    expect(existsInLogs("llm_request_logs")).toBe(true);
+    expect(existsInMain("llm_request_logs")).toBe(false);
+    expect(stagingExists("llm_request_logs")).toBe(false);
+    const moved = logs
+      .query<
+        { conversation_id: string; provider: string },
+        []
+      >(`SELECT conversation_id, provider FROM llm_request_logs WHERE id = 'legacy-1'`)
+      .get();
+    expect(moved?.conversation_id).toBe("conv-legacy");
+    expect(moved?.provider).toBe("openai");
+
+    // Indexes were created in the logs database.
+    const indexes = logs
+      .query<{ name: string }, []>(
+        `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='llm_request_logs'`,
+      )
+      .all()
+      .map((r) => r.name);
+    expect(indexes).toContain("idx_llm_request_logs_message_id");
+    expect(indexes).toContain("idx_llm_request_logs_created_at");
+    expect(indexes).toContain("idx_llm_request_logs_conv_created");
+  });
+
+  test("copies a legacy base-only table, NULL-filling newer columns", async () => {
+    const sqlite = getSqlite();
+    const logs = getLogsSqlite()!;
+
+    // A workspace upgrading from a build that predates the
+    // message_id/provider/agent_loop_exit_reason/call_site columns: the main
+    // table has only the original base columns.
+    logs.exec(`DROP TABLE IF EXISTS llm_request_logs`);
+    sqlite.exec(`DROP TABLE IF EXISTS main.llm_request_logs__relocating`);
+    sqlite.exec(`
+      CREATE TABLE main.llm_request_logs (
+        id TEXT PRIMARY KEY,
+        conversation_id TEXT NOT NULL,
+        request_payload TEXT NOT NULL,
+        response_payload TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `);
+    sqlite.exec(
+      `INSERT INTO main.llm_request_logs (id, conversation_id, request_payload, response_payload, created_at) VALUES ('base-1', 'conv-base', '{}', '{}', 7)`,
+    );
+
+    // Must not throw on the absent columns: the drain NULL-fills them.
+    await migrateMoveLlmRequestLogsToLogsDb(getDb());
+
+    expect(existsInLogs("llm_request_logs")).toBe(true);
+    expect(existsInMain("llm_request_logs")).toBe(false);
+    const moved = logs
+      .query<
+        {
+          conversation_id: string;
+          message_id: string | null;
+          provider: string | null;
+          call_site: string | null;
+        },
+        []
+      >(
+        `SELECT conversation_id, message_id, provider, call_site FROM llm_request_logs WHERE id = 'base-1'`,
+      )
+      .get();
+    expect(moved?.conversation_id).toBe("conv-base");
+    expect(moved?.message_id).toBeNull();
+    expect(moved?.provider).toBeNull();
+    expect(moved?.call_site).toBeNull();
+  });
+});