@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/messaging/providers/__tests__/proactive-address.test.ts

@@ -1,95 +0,0 @@
-import { describe, expect, test } from "bun:test";
-// The addressing capability resolves a named chat into exactly what each
-// transport's own operations read: the callback URL `channelForCallback`
-// resolves and the params `deliver` consumes. Resolution is local, so these
-// assertions make no platform call; the tests import the transports'
-// modules, which pull in their provider-API senders, so the senders'
-// credential lookups are stubbed to keep the import inert.
-import { mock } from "bun:test";
-
-const actualSecureKeys = await import("../../../security/secure-keys.js");
-mock.module("../../../security/secure-keys.js", () => ({
-  ...actualSecureKeys,
-  getSecureKeyAsync: async () => null,
-  getSecureKeyResultAsync: async () => ({ value: null }),
-}));
-
-const { channelForCallback } = await import("../callback-routing.js");
-const { discordTransport } = await import("../discord/transport.js");
-const { slackTransport } = await import("../slack/transport.js");
-const { telegramTransport } = await import("../telegram-bot/transport.js");
-const { whatsappTransport } = await import("../whatsapp/transport.js");
-
-describe("addressFor resolves to the channel's own routing state", () => {
-  test("slack: a chat, optionally under a thread", () => {
-    const room = slackTransport.addressFor!({ kind: "chat", chatId: "C123" });
-    expect(room).toEqual({
-      ctx: { callbackUrl: "/deliver/slack", params: {} },
-      chatId: "C123",
-    });
-    const thread = slackTransport.addressFor!({
-      kind: "chat",
-      chatId: "C123",
-      threadId: "1690000000.000001",
-    });
-    expect(thread).toEqual({
-      ctx: {
-        callbackUrl: "/deliver/slack?threadTs=1690000000.000001",
-        params: { threadTs: "1690000000.000001" },
-      },
-      chatId: "C123",
-      threadId: "1690000000.000001",
-    });
-    expect(channelForCallback(thread!.ctx.callbackUrl)).toBe("slack");
-  });
-
-  test("telegram: a chat with a topic; binds on send", () => {
-    expect(
-      telegramTransport.addressFor!({
-        kind: "chat",
-        chatId: "123",
-        threadId: "42",
-      }),
-    ).toEqual({
-      ctx: {
-        callbackUrl: "/deliver/telegram?threadId=42",
-        params: { threadId: "42" },
-      },
-      chatId: "123",
-      threadId: "42",
-    });
-    expect(telegramTransport.bindsChatOnProactiveSend).toBe(true);
-  });
-
-  test("discord: a chat with a thread, which is its own channel", () => {
-    const thread = discordTransport.addressFor!({
-      kind: "chat",
-      chatId: "C1",
-      threadId: "T1",
-    });
-    expect(thread).toEqual({
-      ctx: {
-        callbackUrl: "/deliver/discord?threadId=T1",
-        params: { threadId: "T1" },
-      },
-      chatId: "C1",
-      threadId: "T1",
-    });
-    expect(channelForCallback(thread!.ctx.callbackUrl)).toBe("discord");
-    expect(discordTransport.bindsChatOnProactiveSend).toBeUndefined();
-  });
-
-  test("whatsapp: the number is the chat; no threads; binds on send", () => {
-    expect(
-      whatsappTransport.addressFor!({
-        kind: "chat",
-        chatId: "12125550100",
-        threadId: "ignored",
-      }),
-    ).toEqual({
-      ctx: { callbackUrl: "/deliver/whatsapp", params: {} },
-      chatId: "12125550100",
-    });
-    expect(whatsappTransport.bindsChatOnProactiveSend).toBe(true);
-  });
-});

package/src/persistence/conversation-title-placeholders.ts

@@ -1,23 +0,0 @@
-import { isMessageKey } from "../i18n/index.js";
-
-const REPLACEABLE_PATTERNS = [
-  /^Runtime:\s/,
-  /^New Conversation$/,
-  /^Untitled$/,
-  /^Untitled Conversation$/,
-  /^Generating title\.\.\.$/,
-];
-
-/**
- * Check whether a title is a system-generated placeholder that can be
- * replaced or omitted without discarding user-provided copy.
- */
-export function isReplaceableTitle(title: string | null): boolean {
-  if (title == null || title.trim() === "") {
-    return true;
-  }
-  if (isMessageKey(title.trim())) {
-    return true;
-  }
-  return REPLACEABLE_PATTERNS.some((pattern) => pattern.test(title));
-}

package/src/persistence/message-cursor.ts

@@ -1,78 +0,0 @@
-// ---------------------------------------------------------------------------
-// Message cursors: the "(createdAt, id) after which" reference behind the
-// messages-after reads, resilient to the referenced row being deleted.
-// ---------------------------------------------------------------------------
-//
-// A bare message id bounds a read only while its row exists. A regenerated
-// reply (the conversation retry route discards the latest assistant turn) or a
-// retried turn deletes the row, and a caller holding just the id can no longer
-// say where it sat. A `MessageCursor` carries the row's `createdAt` alongside
-// its id, so the `(createdAt, id)` bound is reconstructible from the cursor
-// alone. The live row stays authoritative whenever it exists.
-
-import { eq } from "drizzle-orm";
-
-import type { LineageBound } from "./conversation-lineage.js";
-import { getDb } from "./db-connection.js";
-import { messages } from "./schema/index.js";
-
-export { messagesAfterBoundFilter } from "./conversation-lineage.js";
-
-/**
- * A `(createdAt, id)` message reference. `createdAt` is null when the holder
- * never recorded it; such a cursor bounds a read only while its row exists.
- */
-export interface MessageCursor {
-  readonly id: string;
-  readonly createdAt: number | null;
-}
-
-/**
- * Accepted "after" references: a message id, a {@link MessageCursor}, or
- * null. `null`, `""`, and a cursor whose id is `""` all mean "no lower bound".
- */
-export type MessagesAfterRef = string | MessageCursor | null;
-
-/** Where a messages-after read starts. */
-export type MessagesAfterBound =
-  /** No lower bound: every row the conversation owns. */
-  | { kind: "all" }
-  /** Rows strictly after `bound` in `(createdAt, id)` order. */
-  | { kind: "after"; bound: LineageBound }
-  /**
-   * The referenced row is gone and the reference carried no timestamp, so
-   * the read has no defensible starting point. Readers return nothing.
-   */
-  | { kind: "vanished" };
-
-/** The `(createdAt, id)` bound of a single message, or null when it is gone. */
-export function loadMessageBound(messageId: string): LineageBound | null {
-  const row = getDb()
-    .select({ createdAt: messages.createdAt, id: messages.id })
-    .from(messages)
-    .where(eq(messages.id, messageId))
-    .get();
-  return row ?? null;
-}
-
-/**
- * Resolve an "after" reference to the bound a read filters on. A live row
- * wins; a cursor whose row is gone falls back to the `createdAt` it carries,
- * paired with its id so same-millisecond neighbours keep their order.
- */
-export function resolveMessagesAfterBound(
-  after: MessagesAfterRef,
-): MessagesAfterBound {
-  const id = typeof after === "string" ? after : (after?.id ?? "");
-  if (id === "") {
-    return { kind: "all" };
-  }
-  const live = loadMessageBound(id);
-  if (live) {
-    return { kind: "after", bound: live };
-  }
-  if (typeof after === "object" && after !== null && after.createdAt !== null) {
-    return { kind: "after", bound: { createdAt: after.createdAt, id } };
-  }
-  return { kind: "vanished" };
-}

package/src/persistence/migrations/__tests__/157-invite-contact-id.test.ts

@@ -1,149 +0,0 @@
-import { Database } from "bun:sqlite";
-import { describe, expect, test } from "bun:test";
-
-import { drizzle } from "drizzle-orm/bun-sqlite";
-
-import { getSqliteFrom } from "../../db-connection.js";
-import * as schema from "../../schema.js";
-import { migrateInviteContactId } from "../157-invite-contact-id.js";
-import { tableExists, tableHasColumn } from "../schema-introspection.js";
-
-function createTestDb() {
-  const sqlite = new Database(":memory:");
-  sqlite.exec("PRAGMA journal_mode=WAL");
-  return drizzle(sqlite, { schema });
-}
-
-function columnNotNull(raw: Database, name: string): boolean {
-  const cols = raw.query(`PRAGMA table_info(assistant_ingress_invites)`).all() as Array<{
-    name: string;
-    notnull: number;
-  }>;
-  return cols.some((c) => c.name === name && c.notnull === 1);
-}
-
-describe("migrateInviteContactId", () => {
-  test("rebuilds a legacy created_by_session_id table with NOT NULL contact_id", () => {
-    const db = createTestDb();
-    const raw = getSqliteFrom(db);
-    raw.exec(/*sql*/ `
-      CREATE TABLE assistant_ingress_invites (
-        id TEXT PRIMARY KEY,
-        source_channel TEXT NOT NULL,
-        token_hash TEXT NOT NULL,
-        created_by_session_id TEXT,
-        note TEXT,
-        max_uses INTEGER NOT NULL DEFAULT 1,
-        use_count INTEGER NOT NULL DEFAULT 0,
-        expires_at INTEGER NOT NULL,
-        status TEXT NOT NULL DEFAULT 'active',
-        redeemed_by_external_user_id TEXT,
-        redeemed_by_external_chat_id TEXT,
-        redeemed_at INTEGER,
-        expected_external_user_id TEXT,
-        voice_code_hash TEXT,
-        voice_code_digits INTEGER,
-        invite_code_hash TEXT,
-        friend_name TEXT,
-        guardian_name TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
-    raw.run(
-      `INSERT INTO assistant_ingress_invites
-         (id, source_channel, token_hash, created_by_session_id, max_uses, use_count,
-          expires_at, status, created_at, updated_at)
-       VALUES ('inv-keep', 'slack', 'hash-keep', 'conv-1', 1, 0, 9, 'active', 1, 1)`,
-    );
-    raw.exec(
-      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
-    );
-    raw.run(
-      `UPDATE assistant_ingress_invites SET contact_id = 'contact-keep' WHERE id = 'inv-keep'`,
-    );
-    raw.run(
-      `INSERT INTO assistant_ingress_invites
-         (id, source_channel, token_hash, max_uses, use_count, expires_at, status,
-          created_at, updated_at)
-       VALUES ('inv-drop', 'slack', 'hash-drop', 1, 0, 9, 'active', 1, 1)`,
-    );
-
-    migrateInviteContactId(db);
-
-    expect(tableHasColumn(db, "assistant_ingress_invites", "contact_id")).toBe(
-      true,
-    );
-    expect(columnNotNull(raw, "contact_id")).toBe(true);
-    expect(
-      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
-    ).toBe(true);
-    const rows = raw
-      .query(`SELECT id, contact_id FROM assistant_ingress_invites ORDER BY id`)
-      .all() as Array<{ id: string; contact_id: string }>;
-    expect(rows).toEqual([{ id: "inv-keep", contact_id: "contact-keep" }]);
-  });
-
-  test("rebuilds after created_by_session_id was renamed to source_conversation_id", () => {
-    const db = createTestDb();
-    const raw = getSqliteFrom(db);
-    raw.exec(/*sql*/ `
-      CREATE TABLE assistant_ingress_invites (
-        id TEXT PRIMARY KEY,
-        source_channel TEXT NOT NULL,
-        token_hash TEXT NOT NULL,
-        source_conversation_id TEXT,
-        note TEXT,
-        max_uses INTEGER NOT NULL DEFAULT 1,
-        use_count INTEGER NOT NULL DEFAULT 0,
-        expires_at INTEGER NOT NULL,
-        status TEXT NOT NULL DEFAULT 'active',
-        redeemed_by_external_user_id TEXT,
-        redeemed_by_external_chat_id TEXT,
-        redeemed_at INTEGER,
-        expected_external_user_id TEXT,
-        voice_code_hash TEXT,
-        voice_code_digits INTEGER,
-        invite_code_hash TEXT,
-        friend_name TEXT,
-        guardian_name TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
-    `);
-    raw.exec(
-      `ALTER TABLE assistant_ingress_invites ADD COLUMN contact_id TEXT`,
-    );
-    raw.run(
-      `INSERT INTO assistant_ingress_invites
-         (id, source_channel, token_hash, source_conversation_id, contact_id,
-          max_uses, use_count, expires_at, status, created_at, updated_at)
-       VALUES ('inv-1', 'slack', 'hash-1', 'conv-9', 'contact-1', 1, 0, 9, 'active', 1, 1)`,
-    );
-
-    migrateInviteContactId(db);
-
-    expect(columnNotNull(raw, "contact_id")).toBe(true);
-    expect(
-      tableHasColumn(db, "assistant_ingress_invites", "source_conversation_id"),
-    ).toBe(true);
-    expect(
-      tableHasColumn(db, "assistant_ingress_invites", "created_by_session_id"),
-    ).toBe(false);
-    const row = raw
-      .query(
-        `SELECT source_conversation_id, contact_id FROM assistant_ingress_invites WHERE id = 'inv-1'`,
-      )
-      .get() as { source_conversation_id: string; contact_id: string };
-    expect(row).toEqual({
-      source_conversation_id: "conv-9",
-      contact_id: "contact-1",
-    });
-  });
-
-  test("is a no-op when the table does not exist", () => {
-    const db = createTestDb();
-    migrateInviteContactId(db);
-    expect(tableExists(db, "assistant_ingress_invites")).toBe(false);
-  });
-});

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

@@ -1,118 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { setConfig } from "../../../../__tests__/helpers/set-config.js";
-
-// Disable memory so persistence writes don't index into the real memory
-// pipeline (both flags default true under the real loader).
-setConfig("memory", { enabled: false, v2: { enabled: false } });
-
-import { createConversation } from "../../../../persistence/conversation-crud.js";
-import {
-  getDb,
-  getMemorySqlite,
-} from "../../../../persistence/db-connection.js";
-import { initializeDb } from "../../../../persistence/db-init.js";
-import { messages } from "../../../../persistence/schema/index.js";
-import { backfillRetrospectiveCursorTimestamps } from "../memory-retrospective-cursor-backfill.js";
-import {
-  ensureRetrospectiveCursorColumn,
-  getRetrospectiveState,
-} from "../memory-retrospective-state.js";
-
-await initializeDb();
-
-function resetTables(): void {
-  const db = getDb();
-  db.run(`DELETE FROM messages`);
-  db.run(`DELETE FROM conversations`);
-  getMemorySqlite()!.exec(`DELETE FROM memory_retrospective_state`);
-}
-
-/** A state row as written before the timestamp column existed. */
-function insertLegacyState(conversationId: string, messageId: string): void {
-  ensureRetrospectiveCursorColumn("test");
-  getMemorySqlite()!
-    .query(
-      `INSERT INTO memory_retrospective_state
-         (conversation_id, last_processed_message_id, last_run_at, remembered_log, last_processed_created_at)
-       VALUES (?, ?, 1, NULL, NULL)`,
-    )
-    .run(conversationId, messageId);
-}
-
-function insertMessage(
-  conversationId: string,
-  id: string,
-  createdAt: number,
-): void {
-  getDb()
-    .insert(messages)
-    .values({
-      id,
-      conversationId,
-      role: "user",
-      content: "[]",
-      createdAt,
-      metadata: null,
-    })
-    .run();
-}
-
-describe("backfillRetrospectiveCursorTimestamps", () => {
-  beforeEach(() => {
-    resetTables();
-  });
-
-  test("fills the timestamp from the cursor's message, leaves vanished cursors NULL, and is idempotent", async () => {
-    createConversation({ id: "conv-a" });
-    createConversation({ id: "conv-b" });
-    createConversation({ id: "conv-c" });
-    insertMessage("conv-a", "a-m1", 1_000);
-    insertLegacyState("conv-a", "a-m1");
-    // Cursor row already deleted: nothing left to recover.
-    insertLegacyState("conv-b", "gone");
-    // The failure-only sentinel is never a cursor, so it is never scanned.
-    insertLegacyState("conv-c", "");
-
-    const first = await backfillRetrospectiveCursorTimestamps();
-
-    expect(first).toEqual({ scanned: 2, backfilled: 1, unrecoverable: 1 });
-    expect(getRetrospectiveState("conv-a")?.lastProcessedCreatedAt).toBe(1_000);
-    expect(getRetrospectiveState("conv-b")?.lastProcessedCreatedAt).toBeNull();
-    expect(getRetrospectiveState("conv-c")?.lastProcessedCreatedAt).toBeNull();
-
-    const second = await backfillRetrospectiveCursorTimestamps();
-
-    expect(second).toEqual({ scanned: 1, backfilled: 0, unrecoverable: 1 });
-  });
-
-  test("pages through the backlog by conversation id, advancing past unrecoverable rows", async () => {
-    for (const id of ["conv-1", "conv-2", "conv-3", "conv-4", "conv-5"]) {
-      createConversation({ id });
-    }
-    insertMessage("conv-1", "m-1", 1_000);
-    insertLegacyState("conv-1", "m-1");
-    insertLegacyState("conv-2", "gone-2");
-    insertMessage("conv-3", "m-3", 3_000);
-    insertLegacyState("conv-3", "m-3");
-    insertLegacyState("conv-4", "gone-4");
-    insertMessage("conv-5", "m-5", 5_000);
-    insertLegacyState("conv-5", "m-5");
-
-    const result = await backfillRetrospectiveCursorTimestamps({ pageSize: 2 });
-
-    expect(result).toEqual({ scanned: 5, backfilled: 3, unrecoverable: 2 });
-    expect(getRetrospectiveState("conv-1")?.lastProcessedCreatedAt).toBe(1_000);
-    expect(getRetrospectiveState("conv-3")?.lastProcessedCreatedAt).toBe(3_000);
-    expect(getRetrospectiveState("conv-5")?.lastProcessedCreatedAt).toBe(5_000);
-    expect(getRetrospectiveState("conv-4")?.lastProcessedCreatedAt).toBeNull();
-  });
-
-  test("a table with nothing to fill is a clean no-op", async () => {
-    expect(await backfillRetrospectiveCursorTimestamps()).toEqual({
-      scanned: 0,
-      backfilled: 0,
-      unrecoverable: 0,
-    });
-  });
-});

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

@@ -1,83 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { setConfig } from "../../../../__tests__/helpers/set-config.js";
-
-// Disable memory so persistence writes don't index into the real memory
-// pipeline (both flags default true under the real loader).
-setConfig("memory", { enabled: false, v2: { enabled: false } });
-
-import { getMemorySqlite } from "../../../../persistence/db-connection.js";
-import { initializeDb } from "../../../../persistence/db-init.js";
-import { preserveRetrospectiveCursorTimestamps } from "../memory-retrospective-cursor-preserve.js";
-import {
-  ensureRetrospectiveCursorColumn,
-  getRetrospectiveState,
-  upsertRetrospectiveState,
-} from "../memory-retrospective-state.js";
-
-await initializeDb();
-
-/** A state row as written before the timestamp column existed. */
-function insertLegacyState(conversationId: string, messageId: string): void {
-  ensureRetrospectiveCursorColumn("test");
-  getMemorySqlite()!
-    .query(
-      `INSERT INTO memory_retrospective_state
-         (conversation_id, last_processed_message_id, last_run_at, remembered_log, last_processed_created_at)
-       VALUES (?, ?, 1, NULL, NULL)`,
-    )
-    .run(conversationId, messageId);
-}
-
-describe("preserveRetrospectiveCursorTimestamps", () => {
-  beforeEach(() => {
-    getMemorySqlite()!.exec(`DELETE FROM memory_retrospective_state`);
-  });
-
-  test("records the timestamp of a legacy cursor whose row is about to be deleted", async () => {
-    insertLegacyState("conv-a", "reply-1");
-
-    await preserveRetrospectiveCursorTimestamps("conv-a", [
-      { id: "tool-1", createdAt: 1_500 },
-      { id: "reply-1", createdAt: 2_000 },
-    ]);
-
-    expect(getRetrospectiveState("conv-a")?.lastProcessedCreatedAt).toBe(2_000);
-  });
-
-  test("leaves a cursor that already has a timestamp, points elsewhere, or does not exist untouched", async () => {
-    await upsertRetrospectiveState({
-      conversationId: "conv-stamped",
-      lastProcessedMessageId: "reply-1",
-      lastProcessedCreatedAt: 1_000,
-      lastRunAt: 1,
-    });
-    insertLegacyState("conv-elsewhere", "older-reply");
-
-    await preserveRetrospectiveCursorTimestamps("conv-stamped", [
-      { id: "reply-1", createdAt: 9_999 },
-    ]);
-    await preserveRetrospectiveCursorTimestamps("conv-elsewhere", [
-      { id: "reply-1", createdAt: 9_999 },
-    ]);
-    await preserveRetrospectiveCursorTimestamps("conv-missing", [
-      { id: "reply-1", createdAt: 9_999 },
-    ]);
-
-    expect(getRetrospectiveState("conv-stamped")?.lastProcessedCreatedAt).toBe(
-      1_000,
-    );
-    expect(
-      getRetrospectiveState("conv-elsewhere")?.lastProcessedCreatedAt,
-    ).toBeNull();
-    expect(getRetrospectiveState("conv-missing")).toBeNull();
-  });
-
-  test("an empty row list is a no-op", async () => {
-    insertLegacyState("conv-a", "reply-1");
-
-    await preserveRetrospectiveCursorTimestamps("conv-a", []);
-
-    expect(getRetrospectiveState("conv-a")?.lastProcessedCreatedAt).toBeNull();
-  });
-});

package/src/plugins/defaults/memory/hooks/message-deleted.ts

@@ -1,21 +0,0 @@
-/**
- * Default `memory` message-deleted hook.
- *
- * Stamps the conversation's retrospective cursor with the deleted row's
- * `createdAt` when the cursor points at that row and was written without a
- * timestamp (by a build before the column existed). The cursor usually sits
- * on the latest assistant reply, which is exactly the row a regenerate
- * deletes, and once the row is gone only the timestamp can place it.
- */
-
-import type { HookFunction, MessageDeletedContext } from "@vellumai/plugin-api";
-
-import { preserveRetrospectiveCursorTimestamps } from "../memory-retrospective-cursor-preserve.js";
-
-const messageDeleted: HookFunction<MessageDeletedContext> = async (ctx) => {
-  await preserveRetrospectiveCursorTimestamps(ctx.conversationId, [
-    { id: ctx.messageId, createdAt: ctx.createdAt },
-  ]);
-};
-
-export default messageDeleted;