@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/plugins/defaults/memory/memory-retrospective-cursor-backfill.ts

@@ -1,126 +0,0 @@
-// ---------------------------------------------------------------------------
-// Memory retrospective: cursor timestamp backfill.
-// ---------------------------------------------------------------------------
-//
-// State rows written before `last_processed_created_at` existed carry an
-// id-only cursor, which stops bounding reads the moment its row is deleted
-// (see `memory-retrospective-state.ts`). This pass copies `createdAt` from
-// each such row's message while the message still exists. Rows whose message
-// is already gone stay NULL: nothing remains to recover, and they are counted
-// so the stall is visible in the log. Runs detached at daemon init (ahead of
-// any client regenerating a reply) and again at memory-worker startup;
-// idempotent, keyset-paginated by conversation id, and yielding between pages.
-
-import { and, asc, eq, gt, isNull, ne } from "drizzle-orm";
-
-import { messageCreatedAtByIds } from "../../../persistence/message-reads.js";
-import { memoryRetrospectiveState } from "../../../persistence/schema/index.js";
-import { withSqliteRetry } from "./host-utils.js";
-import { getLogger } from "./logging.js";
-import { memoryDbOrNull } from "./memory-db.js";
-import { ensureRetrospectiveCursorColumn } from "./memory-retrospective-state.js";
-
-const log = getLogger("memory-retrospective-cursor-backfill");
-
-const DEFAULT_PAGE_SIZE = 500;
-
-export interface CursorBackfillResult {
-  /** Rows with a cursor id but no timestamp. */
-  scanned: number;
-  /** Rows whose message still exists and received its `createdAt`. */
-  backfilled: number;
-  /** Rows whose cursor message no longer exists; left NULL. */
-  unrecoverable: number;
-}
-
-/**
- * Fill `last_processed_created_at` on every state row that has a cursor id
- * but no timestamp. Best-effort: a missing memory connection or column is a
- * no-op, and a row the job rewrites mid-pass is skipped by the update's
- * `IS NULL` guard rather than stomped. Pages by conversation id so a large
- * backlog never materializes at once or holds the event loop.
- */
-export async function backfillRetrospectiveCursorTimestamps(opts?: {
-  pageSize?: number;
-}): Promise<CursorBackfillResult> {
-  const pageSize = opts?.pageSize ?? DEFAULT_PAGE_SIZE;
-  const result: CursorBackfillResult = {
-    scanned: 0,
-    backfilled: 0,
-    unrecoverable: 0,
-  };
-  const context = "backfillRetrospectiveCursorTimestamps";
-  const mdb = memoryDbOrNull(context);
-  if (!mdb || !ensureRetrospectiveCursorColumn(context)) {
-    return result;
-  }
-
-  let afterConversationId = "";
-  for (;;) {
-    const page = mdb
-      .select({
-        conversationId: memoryRetrospectiveState.conversationId,
-        messageId: memoryRetrospectiveState.lastProcessedMessageId,
-      })
-      .from(memoryRetrospectiveState)
-      .where(
-        and(
-          isNull(memoryRetrospectiveState.lastProcessedCreatedAt),
-          ne(memoryRetrospectiveState.lastProcessedMessageId, ""),
-          gt(memoryRetrospectiveState.conversationId, afterConversationId),
-        ),
-      )
-      .orderBy(asc(memoryRetrospectiveState.conversationId))
-      .limit(pageSize)
-      .all();
-    if (page.length === 0) {
-      break;
-    }
-    afterConversationId = page[page.length - 1]!.conversationId;
-    result.scanned += page.length;
-
-    const createdAtById = messageCreatedAtByIds(
-      page.map((row) => row.messageId),
-    );
-    const recoverable = page.flatMap((row) => {
-      const createdAt = createdAtById.get(row.messageId);
-      return createdAt === undefined ? [] : [{ ...row, createdAt }];
-    });
-    result.unrecoverable += page.length - recoverable.length;
-
-    if (recoverable.length > 0) {
-      await withSqliteRetry(
-        () => {
-          mdb.transaction((tx) => {
-            for (const row of recoverable) {
-              tx.update(memoryRetrospectiveState)
-                .set({ lastProcessedCreatedAt: row.createdAt })
-                .where(
-                  and(
-                    eq(
-                      memoryRetrospectiveState.conversationId,
-                      row.conversationId,
-                    ),
-                    eq(
-                      memoryRetrospectiveState.lastProcessedMessageId,
-                      row.messageId,
-                    ),
-                    isNull(memoryRetrospectiveState.lastProcessedCreatedAt),
-                  ),
-                )
-                .run();
-            }
-          });
-        },
-        { op: context, context: { afterConversationId } },
-      );
-      result.backfilled += recoverable.length;
-    }
-    await Bun.sleep(0);
-  }
-
-  if (result.backfilled > 0 || result.unrecoverable > 0) {
-    log.info(result, "Retrospective cursor timestamps backfilled");
-  }
-  return result;
-}

package/src/plugins/defaults/memory/memory-retrospective-cursor-preserve.ts

@@ -1,79 +0,0 @@
-// ---------------------------------------------------------------------------
-// Memory retrospective: keep the cursor's timestamp when its row is deleted.
-// ---------------------------------------------------------------------------
-//
-// The cursor normally sits on the latest assistant reply, and the retry route
-// deletes exactly that row when the user regenerates it. A cursor written
-// before the timestamp column existed carries only the id, so once the row is
-// gone nothing can place it. The `message-deleted` hook delivers each deleted
-// row's `(createdAt, id)` here: when the conversation's cursor is among the
-// rows and has no timestamp yet, the row's `createdAt` is recorded. The
-// timestamps travel in the call, so the write does not need the rows to
-// still exist.
-
-import { and, eq, isNull } from "drizzle-orm";
-
-import { memoryRetrospectiveState } from "../../../persistence/schema/index.js";
-import { withSqliteRetry } from "./host-utils.js";
-import { getLogger } from "./logging.js";
-import { memoryDbOrNull } from "./memory-db.js";
-import { ensureRetrospectiveCursorColumn } from "./memory-retrospective-state.js";
-
-const log = getLogger("memory-retrospective-cursor-preserve");
-
-/**
- * Record `createdAt` on the conversation's retrospective cursor when it points
- * at one of `rows` and has no timestamp yet. Best-effort: an unavailable
- * memory connection or column is a no-op, and a cursor the job has moved
- * since the caller read it is skipped by the `IS NULL` guard.
- */
-export async function preserveRetrospectiveCursorTimestamps(
-  conversationId: string,
-  rows: ReadonlyArray<{ id: string; createdAt: number }>,
-): Promise<void> {
-  if (rows.length === 0) {
-    return;
-  }
-  const context = "preserveRetrospectiveCursorTimestamps";
-  try {
-    const mdb = memoryDbOrNull(context);
-    if (!mdb || !ensureRetrospectiveCursorColumn(context)) {
-      return;
-    }
-    const state = mdb
-      .select({
-        messageId: memoryRetrospectiveState.lastProcessedMessageId,
-        createdAt: memoryRetrospectiveState.lastProcessedCreatedAt,
-      })
-      .from(memoryRetrospectiveState)
-      .where(eq(memoryRetrospectiveState.conversationId, conversationId))
-      .get();
-    if (!state || state.createdAt !== null) {
-      return;
-    }
-    const row = rows.find((candidate) => candidate.id === state.messageId);
-    if (!row) {
-      return;
-    }
-    await withSqliteRetry(
-      () =>
-        mdb
-          .update(memoryRetrospectiveState)
-          .set({ lastProcessedCreatedAt: row.createdAt })
-          .where(
-            and(
-              eq(memoryRetrospectiveState.conversationId, conversationId),
-              eq(memoryRetrospectiveState.lastProcessedMessageId, row.id),
-              isNull(memoryRetrospectiveState.lastProcessedCreatedAt),
-            ),
-          )
-          .run(),
-      { op: context, context: { conversationId } },
-    );
-  } catch (err) {
-    log.warn(
-      { err, conversationId },
-      "could not preserve the retrospective cursor timestamp before its row was deleted",
-    );
-  }
-}

package/src/plugins/defaults/memory/memory-retrospective-cursor.ts

@@ -1,28 +0,0 @@
-// ---------------------------------------------------------------------------
-// Memory retrospective: the cursor a state row hands to the messages-after
-// reads.
-// ---------------------------------------------------------------------------
-
-import type { MessageCursor } from "../../../persistence/message-cursor.js";
-
-/**
- * The `(createdAt, id)` cursor a retrospective state row carries, or null
- * when nothing has been processed yet (no row, or the `""` sentinel left by
- * failure-only attempts). The timestamp lets the reads keep their bound after
- * the cursor's row is deleted, which is what a regenerated reply does to the
- * latest assistant message the cursor usually sits on.
- */
-export function retrospectiveCursor(
-  state: {
-    lastProcessedMessageId: string;
-    lastProcessedCreatedAt?: number | null;
-  } | null,
-): MessageCursor | null {
-  if (!state || state.lastProcessedMessageId === "") {
-    return null;
-  }
-  return {
-    id: state.lastProcessedMessageId,
-    createdAt: state.lastProcessedCreatedAt ?? null,
-  };
-}

package/src/plugins/defaults/memory/skill-md-mtime-poll.ts

@@ -1,9 +0,0 @@
-/**
- * Plugin-local re-export of the workspace SKILL.md mtime poll so hook files
- * under `hooks/` do not grow a new escaping specifier. The daemon module is
- * already a memory-plugin baseline import from `startup.ts` / `worker.ts`.
- */
-export {
-  startWorkspaceSkillMdMtimePoll,
-  stopWorkspaceSkillMdMtimePoll,
-} from "../../../daemon/skill-memory-refresh.js";

package/src/providers/gemini-thought-signature.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
-  isGemini3Model,
-  unsignedThoughtSignatureFallback,
-} from "./gemini-thought-signature.js";
-
-describe("isGemini3Model", () => {
-  test("matches native Gemini 3 ids", () => {
-    expect(isGemini3Model("gemini-3.7-flash")).toBe(true);
-    expect(isGemini3Model("models/gemini-3.1-pro-preview")).toBe(true);
-  });
-
-  test("matches OpenAI-compatible catalog prefixes", () => {
-    expect(isGemini3Model("google/gemini-3.7-flash")).toBe(true);
-  });
-
-  test("does not match Gemini 2.5 or unrelated ids", () => {
-    expect(isGemini3Model("gemini-2.5-flash")).toBe(false);
-    expect(isGemini3Model("gpt-5.2")).toBe(false);
-  });
-});
-
-describe("unsignedThoughtSignatureFallback", () => {
-  test("stamps the dummy on the first unsigned Gemini 3 call", () => {
-    expect(
-      unsignedThoughtSignatureFallback([undefined, undefined], {
-        model: "gemini-3.7-flash",
-      }),
-    ).toEqual({
-      index: 0,
-      signature: GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
-    });
-  });
-
-  test("does not stamp when any call already has a signature", () => {
-    expect(
-      unsignedThoughtSignatureFallback(["signed-thought-1", undefined], {
-        model: "gemini-3.7-flash",
-      }),
-    ).toBeUndefined();
-  });
-
-  test("does not stamp for non-Gemini-3 models when a model id is provided", () => {
-    expect(
-      unsignedThoughtSignatureFallback([undefined], { model: "gpt-5.2" }),
-    ).toBeUndefined();
-  });
-
-  test("stamps unsigned calls when no model gate is supplied", () => {
-    expect(unsignedThoughtSignatureFallback([undefined])).toEqual({
-      index: 0,
-      signature: GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
-    });
-  });
-
-  test("does not stamp an empty function-call list", () => {
-    expect(
-      unsignedThoughtSignatureFallback([], { model: "gemini-3.7-flash" }),
-    ).toBeUndefined();
-  });
-});

package/src/providers/gemini-thought-signature.ts

@@ -1,44 +0,0 @@
-/**
- * Gemini 3.x requires a thought signature on the first function-call part of
- * each step. When history has no captured signature (unsigned tool_use from an
- * earlier provider, or a client-injected call), Google documents these dummy
- * values to skip validation.
- */
-export const GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE =
-  "context_engineering_is_the_way_to_go";
-
-/**
- * True for Gemini 3.x model ids, including the native `models/` prefix and
- * OpenAI-compatible catalog prefixes such as `google/gemini-3.7-flash`.
- */
-export function isGemini3Model(model: string): boolean {
-  if (model.startsWith("gemini-3") || model.startsWith("models/gemini-3")) {
-    return true;
-  }
-  return /\/gemini-3/.test(model);
-}
-
-/**
- * Decide whether unsigned function-call history should receive Google's
- * documented dummy thought signature. Returns the first call's index when
- * every call is unsigned. Pass `model` to restrict this to Gemini 3.x;
- * omit it for retry backfills that already observed a thought-signature 4xx.
- */
-export function unsignedThoughtSignatureFallback(
-  signatures: ReadonlyArray<string | undefined | null>,
-  options?: { model?: string },
-): { index: 0; signature: string } | undefined {
-  if (options?.model !== undefined && !isGemini3Model(options.model)) {
-    return undefined;
-  }
-  if (signatures.length === 0) {
-    return undefined;
-  }
-  if (signatures.some((signature) => Boolean(signature))) {
-    return undefined;
-  }
-  return {
-    index: 0,
-    signature: GEMINI_3_UNSIGNED_TOOL_CALL_THOUGHT_SIGNATURE,
-  };
-}