@vellumai/assistant 0.8.1 → 0.8.3

package/src/memory/onboarding-events-store.ts

@@ -0,0 +1,106 @@
+import { and, asc, eq, gt, or } from "drizzle-orm";
+import { v4 as uuid } from "uuid";
+
+import { getConfig } from "../config/loader.js";
+import { getDb } from "./db-connection.js";
+import { onboardingEvents } from "./schema.js";
+
+export interface OnboardingEvent {
+  id: string;
+  createdAt: number;
+  screen: string;
+  toolsJson: string | null;
+  tasksJson: string | null;
+  tone: string | null;
+  googleConnected: boolean | null;
+  googleScopesJson: string | null;
+  abVariant: string | null;
+}
+
+export interface RecordOnboardingEventParams {
+  screen: string;
+  tools?: string[];
+  tasks?: string[];
+  tone?: string;
+  googleConnected?: boolean;
+  googleScopes?: string[];
+  abVariant?: string;
+}
+
+/**
+ * Record an onboarding event (pre-chat selections and Google connect status).
+ * Returns null when usage data collection is disabled.
+ */
+export function recordOnboardingEvent(
+  params: RecordOnboardingEventParams,
+): OnboardingEvent | null {
+  if (!getConfig().collectUsageData) return null;
+  const db = getDb();
+  const event: OnboardingEvent = {
+    id: uuid(),
+    createdAt: Date.now(),
+    screen: params.screen,
+    toolsJson: params.tools ? JSON.stringify(params.tools) : null,
+    tasksJson: params.tasks ? JSON.stringify(params.tasks) : null,
+    tone: params.tone ?? null,
+    googleConnected: params.googleConnected ?? null,
+    googleScopesJson: params.googleScopes
+      ? JSON.stringify(params.googleScopes)
+      : null,
+    abVariant: params.abVariant ?? null,
+  };
+  db.insert(onboardingEvents)
+    .values({
+      id: event.id,
+      createdAt: event.createdAt,
+      screen: event.screen,
+      toolsJson: event.toolsJson,
+      tasksJson: event.tasksJson,
+      tone: event.tone,
+      googleConnected: event.googleConnected,
+      googleScopesJson: event.googleScopesJson,
+      abVariant: event.abVariant,
+    })
+    .run();
+  return event;
+}
+
+/**
+ * Query onboarding events that haven't been reported to telemetry yet.
+ * Uses a compound cursor (createdAt + id) for reliable watermarking.
+ */
+export function queryUnreportedOnboardingEvents(
+  afterCreatedAt: number,
+  afterId: string | undefined,
+  limit: number,
+): OnboardingEvent[] {
+  const db = getDb();
+  const rows = db
+    .select({
+      id: onboardingEvents.id,
+      createdAt: onboardingEvents.createdAt,
+      screen: onboardingEvents.screen,
+      toolsJson: onboardingEvents.toolsJson,
+      tasksJson: onboardingEvents.tasksJson,
+      tone: onboardingEvents.tone,
+      googleConnected: onboardingEvents.googleConnected,
+      googleScopesJson: onboardingEvents.googleScopesJson,
+      abVariant: onboardingEvents.abVariant,
+    })
+    .from(onboardingEvents)
+    .where(
+      afterId
+        ? or(
+            gt(onboardingEvents.createdAt, afterCreatedAt),
+            and(
+              eq(onboardingEvents.createdAt, afterCreatedAt),
+              gt(onboardingEvents.id, afterId),
+            ),
+          )
+        : gt(onboardingEvents.createdAt, afterCreatedAt),
+    )
+    .orderBy(asc(onboardingEvents.createdAt), asc(onboardingEvents.id))
+    .limit(limit)
+    .all();
+  return rows;
+}

package/src/memory/schema/a2a.ts

@@ -0,0 +1,15 @@
+import { integer, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const a2aTasks = sqliteTable("a2a_tasks", {
+  id: text("id").primaryKey(),
+  contextId: text("context_id"),
+  conversationId: text("conversation_id"),
+  state: text("state").notNull().default("submitted"),
+  statusMessage: text("status_message"),
+  requestMessageJson: text("request_message_json").notNull(),
+  artifactsJson: text("artifacts_json"),
+  pushUrl: text("push_url"),
+  senderAssistantId: text("sender_assistant_id").notNull(),
+  createdAt: integer("created_at").notNull(),
+  updatedAt: integer("updated_at").notNull(),
+});

package/src/memory/schema/bookmarks.ts

@@ -34,5 +34,3 @@ export const messageBookmarks = sqliteTable(
     index("message_bookmarks_created_at_idx").on(table.createdAt),
   ],
 );
-
-export type MessageBookmarkRow = typeof messageBookmarks.$inferSelect;

package/src/memory/schema/calls.ts

@@ -78,6 +78,7 @@ export const externalConversationBindings = sqliteTable(
       .references(() => conversations.id, { onDelete: "cascade" }),
     sourceChannel: text("source_channel").notNull(),
     externalChatId: text("external_chat_id").notNull(),
+    externalThreadId: text("external_thread_id"),
     externalUserId: text("external_user_id"),
     displayName: text("display_name"),
     username: text("username"),

package/src/memory/schema/index.ts

@@ -1,3 +1,4 @@
+export * from "./a2a.js";
 export * from "./acp.js";
 export * from "./bookmarks.js";
 export * from "./calls.js";

package/src/memory/schema/inference.ts

@@ -17,12 +17,12 @@ export const providerConnections = sqliteTable(
     auth: text("auth").notNull(),
     status: text("status").notNull().default("active"),
     label: text("label"),
+    baseUrl: text("base_url"),
+    models: text("models"),
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
   },
-  (table) => [
-    index("idx_provider_connections_provider").on(table.provider),
-  ],
+  (table) => [index("idx_provider_connections_provider").on(table.provider)],
 );
 
 export type ProviderConnectionRow = typeof providerConnections.$inferSelect;

package/src/memory/schema/infrastructure.ts

@@ -137,6 +137,7 @@ export const llmRequestLogs = sqliteTable(
     requestPayload: text("request_payload").notNull(),
     responsePayload: text("response_payload").notNull(),
     createdAt: integer("created_at").notNull(),
+    agentLoopExitReason: text("agent_loop_exit_reason"),
   },
   (table) => [
     index("idx_llm_request_logs_message_id").on(table.messageId),
@@ -232,6 +233,18 @@ export const lifecycleEvents = sqliteTable("lifecycle_events", {
   createdAt: integer("created_at").notNull(),
 });
 
+export const onboardingEvents = sqliteTable("onboarding_events", {
+  id: text("id").primaryKey(),
+  createdAt: integer("created_at").notNull(),
+  screen: text("screen").notNull(),
+  toolsJson: text("tools_json"),
+  tasksJson: text("tasks_json"),
+  tone: text("tone"),
+  googleConnected: integer("google_connected", { mode: "boolean" }),
+  googleScopesJson: text("google_scopes_json"),
+  abVariant: text("ab_variant"),
+});
+
 export const traceEvents = sqliteTable(
   "trace_events",
   {

package/src/memory/turn-events-store.ts

@@ -1,16 +1,102 @@
 import { and, asc, eq, gt, or, sql } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
-import { messages } from "./schema.js";
+import { conversations, messages } from "./schema.js";
 
 export interface TurnEvent {
   id: string;
   createdAt: number;
+  /**
+   * Parent conversation id. Lets downstream analytics group turns by
+   * conversation (e.g. avg turns per conversation).
+   */
+  conversationId: string;
+  /**
+   * Conversation type of the parent conversation. Used downstream to
+   * distinguish user-initiated turns (`"standard"`) from system-generated
+   * prompts in `"background"` / `"scheduled"` conversations so analytics
+   * (e.g. DAU) can exclude the latter.
+   */
+  conversationType: string;
+  /**
+   * 1-indexed position of this user turn within the parent conversation,
+   * counting only real user turns (tool-result rows persisted with
+   * role="user" are excluded — same filter as the eligibility predicate
+   * below). The first user turn in a conversation is `1`.
+   *
+   * Computed via correlated subquery on the same filtered set used for
+   * eligibility; this scales with batch size (≤ BATCH_SIZE turns per
+   * flush) and uses the `idx_messages_conversation_id` index for the
+   * partition lookup.
+   */
+  turnIndex: number;
+  /**
+   * Canonical `InterfaceId` enum value identifying the UI surface the user
+   * was interacting from at message-creation time (`"macos"`, `"ios"`,
+   * `"cli"`, `"web"`, `"chrome-extension"`, `"slack"`, `"telegram"`,
+   * `"whatsapp"`, `"email"`, `"phone"`). Sourced from
+   * `messages.metadata.userMessageInterface` (stamped on insert by every
+   * `persistUserMessage` path that flows through `TurnChannelContext`).
+   *
+   * Null when the metadata didn't carry the field — historical rows
+   * predating the threading, or system-initiated turns with no inbound
+   * client context. Downstream analytics should treat null as
+   * `"unknown"`.
+   */
+  interfaceId: string | null;
+  /**
+   * Canonical `ChannelId` enum value identifying the messaging fabric the
+   * user message arrived on (`"vellum"` for in-app messaging from
+   * macos/ios/web/cli; `"slack"`/`"telegram"`/`"whatsapp"`/`"email"`/
+   * `"phone"` for channel-based interfaces). Sourced from
+   * `messages.metadata.userMessageChannel`.
+   *
+   * The 7th `ChannelId` value (`"platform"`) is APNs-push outbound-only
+   * and should never appear on a user-message row.
+   */
+  channelId: string | null;
+  /**
+   * Flexible client metadata stashed under `messages.metadata.client` by
+   * the HTTP header middleware. Carries optional `browserFamily`,
+   * `browserVersion`, `os`, `interfaceVersion` (and is extensible without
+   * a migration since it lives inside the JSON column). Null when no
+   * client headers were attached.
+   *
+   * Returned as raw JSON text — the reporter parses + re-shapes for the
+   * wire format.
+   */
+  clientMetadata: string | null;
+}
+
+/**
+ * SQL fragment that excludes tool-result rows persisted with role="user".
+ * Kept as a single source of truth so the eligibility predicate and the
+ * correlated `turn_index` count stay in lockstep — otherwise the index
+ * can drift from the visible turn stream and break "first turn" /
+ * "turns per conversation" math.
+ *
+ * `<alias>` is interpolated as the SQL identifier for the table whose
+ * `content` column should be filtered (e.g. `messages` for the outer
+ * query, `m2` for the correlated subquery).
+ */
+function realUserTurnContentFilter(alias: string): ReturnType<typeof sql> {
+  return sql.raw(
+    `${alias}.content NOT LIKE '%"type":"tool\\_result"%' ESCAPE '\\' ` +
+      `AND ${alias}.content NOT LIKE '%"type":"web\\_search\\_tool\\_result"%' ESCAPE '\\'`,
+  );
 }
 
 /**
  * Query user messages (turns) that haven't been reported to telemetry yet.
  * Uses a compound cursor (createdAt + id) for reliable watermarking.
+ *
+ * Joins to `conversations` so each turn carries its `conversationType`.
+ * The inner join is safe because `messages.conversationId` has a
+ * not-null FK to `conversations.id` (cascade on delete): every message
+ * row has a matching conversation row.
+ *
+ * `turnIndex` is computed via a correlated subquery counting the real
+ * user turns in the same conversation up to and including this row.
  */
 export function queryUnreportedTurnEvents(
   afterCreatedAt: number,
@@ -19,8 +105,47 @@ export function queryUnreportedTurnEvents(
 ): TurnEvent[] {
   const db = getDb();
   const rows = db
-    .select({ id: messages.id, createdAt: messages.createdAt })
+    .select({
+      id: messages.id,
+      createdAt: messages.createdAt,
+      conversationId: messages.conversationId,
+      conversationType: conversations.conversationType,
+      // 1-indexed turn position within the parent conversation. Counts
+      // only real user turns (same filter applied to the outer query).
+      // `(created_at, id)` lex-comparison matches the watermark cursor
+      // ordering so ties on `created_at` are broken deterministically.
+      turnIndex: sql<number>`(
+        SELECT COUNT(*) FROM messages AS m2
+        WHERE m2.conversation_id = ${messages.conversationId}
+          AND m2.role = 'user'
+          AND ${realUserTurnContentFilter("m2")}
+          AND (m2.created_at < ${messages.createdAt}
+               OR (m2.created_at = ${messages.createdAt}
+                   AND m2.id <= ${messages.id}))
+      )`.as("turn_index"),
+      // Client attribution: extract from `messages.metadata` JSON.
+      // `userMessageInterface` and `userMessageChannel` are stamped on
+      // insert by every `persistUserMessage` path that flows through
+      // `TurnChannelContext`. `client` is the flexible namespace for
+      // browser/os/version metadata attached by HTTP header middleware.
+      // `json_extract` returns SQL NULL when the JSON path is absent —
+      // exactly the null semantics we want on the wire.
+      interfaceId: sql<
+        string | null
+      >`json_extract(${messages.metadata}, '$.userMessageInterface')`.as(
+        "interface_id",
+      ),
+      channelId: sql<
+        string | null
+      >`json_extract(${messages.metadata}, '$.userMessageChannel')`.as(
+        "channel_id",
+      ),
+      clientMetadata: sql<
+        string | null
+      >`json_extract(${messages.metadata}, '$.client')`.as("client_metadata"),
+    })
     .from(messages)
+    .innerJoin(conversations, eq(messages.conversationId, conversations.id))
     .where(
       and(
         eq(messages.role, "user"),

package/src/memory/v2/__tests__/activation-store.test.ts

@@ -7,7 +7,7 @@ import { type DrizzleDb, getSqliteFrom } from "../../db-connection.js";
 import { migrateActivationState } from "../../migrations/232-activation-state.js";
 import * as schema from "../../schema.js";
 import {
-  evictCompactedTurns,
+  clearEverInjected,
   forkActivationState,
   hydrate,
   save,
@@ -146,23 +146,37 @@ describe("activation-store", () => {
     });
   });
 
-  describe("evictCompactedTurns", () => {
-    test("drops entries with turn <= upToTurn and preserves the rest", () => {
+  describe("clearEverInjected", () => {
+    test("empties the everInjected list", () => {
       const state = buildState({
         everInjected: [
           { slug: "slug-a", turn: 1 },
           { slug: "slug-b", turn: 2 },
           { slug: "slug-c", turn: 3 },
-          { slug: "slug-d", turn: 5 },
         ],
       });
 
-      const result = evictCompactedTurns(state, 2);
+      const result = clearEverInjected(state);
 
-      expect(result.everInjected).toEqual([
-        { slug: "slug-c", turn: 3 },
-        { slug: "slug-d", turn: 5 },
-      ]);
+      expect(result.everInjected).toEqual([]);
+    });
+
+    test("clears entries even when their turn exceeds currentTurn — the SIGKILL drift case", () => {
+      // Regression: under turn-bounded eviction, entries with turn >
+      // currentTurn survived forever. A non-graceful shutdown can persist
+      // everInjected entries with high turn values, then a restart restores
+      // the tracker from an older snapshot with a lower currentTurn.
+      const state = buildState({
+        currentTurn: 5,
+        everInjected: [
+          { slug: "slug-a", turn: 10 },
+          { slug: "slug-b", turn: 20 },
+        ],
+      });
+
+      const result = clearEverInjected(state);
+
+      expect(result.everInjected).toEqual([]);
     });
 
     test("returns a new object — does not mutate the input", () => {
@@ -170,7 +184,7 @@ describe("activation-store", () => {
         everInjected: [{ slug: "slug-a", turn: 1 }],
       });
 
-      const result = evictCompactedTurns(state, 1);
+      const result = clearEverInjected(state);
 
       expect(result.everInjected).toEqual([]);
       expect(state.everInjected).toEqual([{ slug: "slug-a", turn: 1 }]);
@@ -179,24 +193,12 @@ describe("activation-store", () => {
 
     test("preserves every other field on the state", () => {
       const state = buildState();
-      const result = evictCompactedTurns(state, 0);
+      const result = clearEverInjected(state);
 
       expect(result.messageId).toBe(state.messageId);
       expect(result.state).toEqual(state.state);
       expect(result.currentTurn).toBe(state.currentTurn);
       expect(result.updatedAt).toBe(state.updatedAt);
     });
-
-    test("evicts everything when upToTurn covers the entire list", () => {
-      const state = buildState({
-        everInjected: [
-          { slug: "slug-a", turn: 1 },
-          { slug: "slug-b", turn: 2 },
-        ],
-      });
-
-      const result = evictCompactedTurns(state, 5);
-      expect(result.everInjected).toEqual([]);
-    });
   });
 });

package/src/memory/v2/__tests__/activation.test.ts

@@ -52,9 +52,7 @@ mock.module("../../qdrant-client.js", () => ({
 
 const state = {
   embedCalls: [] as Array<{ inputs: unknown[] }>,
-  sparseCalls: [] as string[],
   embedReturn: [[0.1, 0.2, 0.3]] as number[][],
-  sparseReturn: { indices: [1, 2, 3], values: [0.5, 0.5, 0.5] },
   /**
    * Programmable Qdrant query response queues — one per channel. Each test
    * stages whatever ordered hits it needs and lets `simBatch` /
@@ -87,10 +85,6 @@ mock.module("../../embedding-backend.js", () => ({
       vectors: state.embedReturn,
     };
   },
-  generateSparseEmbedding: (text: string) => {
-    state.sparseCalls.push(text);
-    return state.sparseReturn;
-  },
 }));
 
 class MockQdrantClient {
@@ -176,9 +170,7 @@ const { _resetMemoryV2QdrantForTests } = await import("../qdrant.js");
 
 function resetState(): void {
   state.embedCalls.length = 0;
-  state.sparseCalls.length = 0;
   state.embedReturn = [[0.1, 0.2, 0.3]];
-  state.sparseReturn = { indices: [1, 2, 3], values: [0.5, 0.5, 0.5] };
   state.queryResponses.dense.length = 0;
   state.queryResponses.sparse.length = 0;
   state.queryCalls.length = 0;