@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/memory/delivery-channels.ts

@@ -40,75 +40,6 @@ function normalizePositiveIntegerIndexes(value: unknown): number[] {
   return [...new Set(indexes)].sort((a, b) => a - b);
 }
 
-// ── Pending verification reply helpers ───────────────────────────────
-//
-// When a guardian verification succeeds but the confirmation reply fails
-// to deliver, we persist the reply details on the inbound event so that
-// gateway retries (which arrive as duplicates) can re-attempt delivery.
-
-export interface PendingVerificationReply {
-  __pendingVerificationReply: true;
-  chatId: string;
-  text: string;
-  assistantId: string;
-}
-
-/**
- * Store a pending verification reply on an inbound event. Called when
- * `deliverChannelReply` fails after challenge consumption so the reply
- * can be retried on subsequent duplicate deliveries.
- */
-export function storePendingVerificationReply(
-  eventId: string,
-  reply: Omit<PendingVerificationReply, "__pendingVerificationReply">,
-): void {
-  const db = getDb();
-  const payload: PendingVerificationReply = {
-    __pendingVerificationReply: true,
-    ...reply,
-  };
-  db.update(channelInboundEvents)
-    .set({ rawPayload: JSON.stringify(payload), updatedAt: Date.now() })
-    .where(eq(channelInboundEvents.id, eventId))
-    .run();
-}
-
-/**
- * Retrieve a pending verification reply for a given event, if one exists.
- */
-export function getPendingVerificationReply(
-  eventId: string,
-): PendingVerificationReply | null {
-  const db = getDb();
-  const row = db
-    .select({ rawPayload: channelInboundEvents.rawPayload })
-    .from(channelInboundEvents)
-    .where(eq(channelInboundEvents.id, eventId))
-    .get();
-
-  if (!row?.rawPayload) return null;
-  try {
-    const parsed = JSON.parse(row.rawPayload);
-    if (parsed && parsed.__pendingVerificationReply === true) {
-      return parsed as PendingVerificationReply;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Clear a pending verification reply after successful delivery.
- */
-export function clearPendingVerificationReply(eventId: string): void {
-  const db = getDb();
-  db.update(channelInboundEvents)
-    .set({ rawPayload: null, updatedAt: Date.now() })
-    .where(eq(channelInboundEvents.id, eventId))
-    .run();
-}
-
 // ── Per-segment delivery progress ──────────────────────────────────
 //
 // When a split reply (multiple text segments from tool boundaries) fails

package/src/memory/graph/extraction-job.ts

@@ -9,7 +9,6 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
-import { maybeEnqueueConversationStartersJob } from "../conversation-starters-cadence.js";
 import { asString } from "../job-utils.js";
 import type { MemoryJob } from "../jobs-store.js";
 import { runGraphExtraction } from "./extraction.js";
@@ -65,20 +64,6 @@ export async function graphExtractJob(
       },
       "Graph extraction job complete",
     );
-
-    try {
-      maybeEnqueueConversationStartersJob(scopeId);
-    } catch (cadenceErr) {
-      log.warn(
-        {
-          err:
-            cadenceErr instanceof Error
-              ? cadenceErr.message
-              : String(cadenceErr),
-        },
-        "Conversation starters cadence check failed (non-fatal)",
-      );
-    }
   } catch (err) {
     log.error(
       { conversationId, err: err instanceof Error ? err.message : String(err) },

package/src/memory/guardian-action-store.ts

@@ -10,13 +10,10 @@
 import { and, desc, eq, inArray, lt } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
-import { getLogger } from "../util/logger.js";
 import { getDb } from "./db-connection.js";
 import { rawChanges } from "./raw-query.js";
 import { guardianActionDeliveries, guardianActionRequests } from "./schema.js";
 
-const log = getLogger("guardian-action-store");
-
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -45,6 +42,7 @@ export type FollowupState =
   | "completed"
   | "declined"
   | "failed";
+/** Follow-up action recorded on a request row (column retained). */
 export type FollowupAction = "call_back" | "decline";
 
 export interface GuardianActionRequest {
@@ -432,180 +430,6 @@ export function cancelGuardianActionRequest(id: string): void {
     .run();
 }
 
-// ---------------------------------------------------------------------------
-// Follow-up lifecycle helpers
-// ---------------------------------------------------------------------------
-
-/** Valid non-terminal followup_state transitions for progressFollowupState.
- * Terminal states (completed, declined, failed) are only reachable via
- * finalizeFollowup, which properly sets followupCompletedAt. */
-const FOLLOWUP_TRANSITIONS: Record<FollowupState, FollowupState[]> = {
-  none: [],
-  awaiting_guardian_choice: ["dispatching"],
-  dispatching: [],
-  completed: [],
-  declined: [],
-  failed: [],
-};
-
-/** Valid terminal transitions for finalizeFollowup. Maps from current
- * followup_state to the terminal states reachable from it. */
-const FOLLOWUP_FINALIZE_TRANSITIONS: Partial<
-  Record<FollowupState, FollowupState[]>
-> = {
-  awaiting_guardian_choice: ["declined"],
-  dispatching: ["completed", "failed"],
-};
-
-/**
- * Atomically set status='expired' and expired_reason on a pending request.
- * Returns the updated request on success, or null if the request was not
- * in 'pending' status (first-writer-wins).
- */
-export function markTimedOutWithReason(
-  id: string,
-  reason: ExpiredReason,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({ status: "expired", expiredReason: reason, updatedAt: now })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "pending"),
-      ),
-    )
-    .run();
-
-  if (rawChanges() === 0) return null;
-
-  // Also expire active deliveries
-  db.update(guardianActionDeliveries)
-    .set({ status: "expired", updatedAt: now })
-    .where(
-      and(
-        eq(guardianActionDeliveries.requestId, id),
-        inArray(guardianActionDeliveries.status, ["pending", "sent"]),
-      ),
-    )
-    .run();
-
-  return getGuardianActionRequest(id);
-}
-
-/**
- * Atomically transition an expired request into the follow-up flow.
- * Sets followup_state='awaiting_guardian_choice', records the late answer
- * text and timestamp. Only succeeds if status='expired' and followup_state='none'.
- * Returns the updated request on success, or null on conflict.
- */
-export function startFollowupFromExpiredRequest(
-  id: string,
-  lateAnswerText: string,
-): GuardianActionRequest | null {
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({
-      followupState: "awaiting_guardian_choice",
-      lateAnswerText,
-      lateAnsweredAt: now,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "expired"),
-        eq(guardianActionRequests.followupState, "none"),
-      ),
-    )
-    .run();
-
-  if (rawChanges() === 0) return null;
-  return getGuardianActionRequest(id);
-}
-
-/**
- * Atomically progress the followup_state. Validates that the transition
- * is allowed (see FOLLOWUP_TRANSITIONS). Optionally sets the followup_action.
- * Returns the updated request on success, or null if the transition was
- * invalid or the prior state didn't match.
- */
-export function progressFollowupState(
-  id: string,
-  newState: FollowupState,
-  action?: FollowupAction,
-): GuardianActionRequest | null {
-  const request = getGuardianActionRequest(id);
-  if (!request) return null;
-
-  const allowed = FOLLOWUP_TRANSITIONS[request.followupState];
-  if (!allowed.includes(newState)) return null;
-
-  const db = getDb();
-  const now = Date.now();
-
-  const updates: Record<string, unknown> = {
-    followupState: newState,
-    updatedAt: now,
-  };
-  if (action !== undefined) updates.followupAction = action;
-
-  db.update(guardianActionRequests)
-    .set(updates)
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "expired"),
-        eq(guardianActionRequests.followupState, request.followupState),
-      ),
-    )
-    .run();
-
-  if (rawChanges() === 0) return null;
-  return getGuardianActionRequest(id);
-}
-
-/**
- * Finalize a follow-up by setting the terminal followup_state and
- * recording followup_completed_at. Only succeeds from a non-terminal state
- * and only on expired requests.
- */
-export function finalizeFollowup(
-  id: string,
-  finalState: "completed" | "declined" | "failed",
-): GuardianActionRequest | null {
-  const request = getGuardianActionRequest(id);
-  if (!request) return null;
-
-  const allowed = FOLLOWUP_FINALIZE_TRANSITIONS[request.followupState];
-  if (!allowed?.includes(finalState)) return null;
-
-  const db = getDb();
-  const now = Date.now();
-
-  db.update(guardianActionRequests)
-    .set({
-      followupState: finalState,
-      followupCompletedAt: now,
-      updatedAt: now,
-    })
-    .where(
-      and(
-        eq(guardianActionRequests.id, id),
-        eq(guardianActionRequests.status, "expired"),
-        eq(guardianActionRequests.followupState, request.followupState),
-      ),
-    )
-    .run();
-
-  if (rawChanges() === 0) return null;
-  return getGuardianActionRequest(id);
-}
-
 // ---------------------------------------------------------------------------
 // Guardian Action Deliveries
 // ---------------------------------------------------------------------------
@@ -640,205 +464,6 @@ export function createGuardianActionDelivery(params: {
   return rowToDelivery(row);
 }
 
-/**
- * Look up all pending deliveries by destination conversation ID.
- * Used for disambiguation when a reused vellum conversation has multiple active
- * guardian requests.
- */
-export function getPendingDeliveriesByConversation(
-  conversationId: string,
-): GuardianActionDelivery[] {
-  try {
-    const db = getDb();
-    const rows = db
-      .select({ delivery: guardianActionDeliveries })
-      .from(guardianActionDeliveries)
-      .innerJoin(
-        guardianActionRequests,
-        eq(guardianActionDeliveries.requestId, guardianActionRequests.id),
-      )
-      .where(
-        and(
-          eq(
-            guardianActionDeliveries.destinationConversationId,
-            conversationId,
-          ),
-          eq(guardianActionDeliveries.status, "sent"),
-          eq(guardianActionRequests.status, "pending"),
-        ),
-      )
-      .all();
-    return rows.map((r) => rowToDelivery(r.delivery));
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("no such table")) {
-      log.warn({ err }, "guardian tables not yet created");
-      return [];
-    }
-    throw err;
-  }
-}
-
-/**
- * Look up sent deliveries for expired requests eligible for follow-up.
- * Used by inbound message routing to match late guardian answers to expired requests.
- */
-export function getExpiredDeliveriesByDestination(
-  channel: string,
-  chatId: string,
-): GuardianActionDelivery[] {
-  try {
-    const db = getDb();
-
-    const rows = db
-      .select({
-        delivery: guardianActionDeliveries,
-      })
-      .from(guardianActionDeliveries)
-      .innerJoin(
-        guardianActionRequests,
-        eq(guardianActionDeliveries.requestId, guardianActionRequests.id),
-      )
-      .where(
-        and(
-          eq(guardianActionRequests.status, "expired"),
-          eq(guardianActionRequests.followupState, "none"),
-          eq(guardianActionDeliveries.destinationChannel, channel),
-          eq(guardianActionDeliveries.destinationChatId, chatId),
-          eq(guardianActionDeliveries.status, "expired"),
-        ),
-      )
-      .all();
-
-    return rows.map((r) => rowToDelivery(r.delivery));
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("no such table")) {
-      log.warn({ err }, "guardian tables not yet created");
-      return [];
-    }
-    throw err;
-  }
-}
-
-/**
- * Look up all expired deliveries by destination conversation ID.
- * Used for disambiguation when a reused vellum conversation has multiple expired
- * guardian requests eligible for follow-up.
- */
-export function getExpiredDeliveriesByConversation(
-  conversationId: string,
-): GuardianActionDelivery[] {
-  try {
-    const db = getDb();
-    const rows = db
-      .select({ delivery: guardianActionDeliveries })
-      .from(guardianActionDeliveries)
-      .innerJoin(
-        guardianActionRequests,
-        eq(guardianActionDeliveries.requestId, guardianActionRequests.id),
-      )
-      .where(
-        and(
-          eq(
-            guardianActionDeliveries.destinationConversationId,
-            conversationId,
-          ),
-          eq(guardianActionDeliveries.status, "expired"),
-          eq(guardianActionRequests.status, "expired"),
-          eq(guardianActionRequests.followupState, "none"),
-        ),
-      )
-      .all();
-    return rows.map((r) => rowToDelivery(r.delivery));
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("no such table")) {
-      log.warn({ err }, "guardian tables not yet created");
-      return [];
-    }
-    throw err;
-  }
-}
-
-/**
- * Look up deliveries for requests in `awaiting_guardian_choice` follow-up state.
- * Used by inbound message routing to intercept guardian follow-up replies
- * on channel paths (Telegram, WhatsApp).
- */
-export function getFollowupDeliveriesByDestination(
-  channel: string,
-  chatId: string,
-): GuardianActionDelivery[] {
-  try {
-    const db = getDb();
-
-    const rows = db
-      .select({
-        delivery: guardianActionDeliveries,
-      })
-      .from(guardianActionDeliveries)
-      .innerJoin(
-        guardianActionRequests,
-        eq(guardianActionDeliveries.requestId, guardianActionRequests.id),
-      )
-      .where(
-        and(
-          eq(guardianActionRequests.status, "expired"),
-          eq(guardianActionRequests.followupState, "awaiting_guardian_choice"),
-          eq(guardianActionDeliveries.destinationChannel, channel),
-          eq(guardianActionDeliveries.destinationChatId, chatId),
-          eq(guardianActionDeliveries.status, "expired"),
-        ),
-      )
-      .all();
-
-    return rows.map((r) => rowToDelivery(r.delivery));
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("no such table")) {
-      log.warn({ err }, "guardian tables not yet created");
-      return [];
-    }
-    throw err;
-  }
-}
-
-/**
- * Look up all deliveries for requests in `awaiting_guardian_choice` follow-up
- * state by destination conversation ID. Used for disambiguation when a reused
- * vellum conversation has multiple follow-up guardian requests.
- */
-export function getFollowupDeliveriesByConversation(
-  conversationId: string,
-): GuardianActionDelivery[] {
-  try {
-    const db = getDb();
-    const rows = db
-      .select({ delivery: guardianActionDeliveries })
-      .from(guardianActionDeliveries)
-      .innerJoin(
-        guardianActionRequests,
-        eq(guardianActionDeliveries.requestId, guardianActionRequests.id),
-      )
-      .where(
-        and(
-          eq(
-            guardianActionDeliveries.destinationConversationId,
-            conversationId,
-          ),
-          eq(guardianActionDeliveries.status, "expired"),
-          eq(guardianActionRequests.status, "expired"),
-          eq(guardianActionRequests.followupState, "awaiting_guardian_choice"),
-        ),
-      )
-      .all();
-    return rows.map((r) => rowToDelivery(r.delivery));
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("no such table")) {
-      log.warn({ err }, "guardian tables not yet created");
-      return [];
-    }
-    throw err;
-  }
-}
-
 export function updateDeliveryStatus(
   deliveryId: string,
   status: GuardianActionDeliveryStatus,

package/src/memory/llm-usage-store.ts

@@ -43,6 +43,7 @@ export function recordUsageEvent(
     createdAt: Date.now(),
     ...input,
     callSite: input.callSite ?? null,
+    llmCallCount: input.llmCallCount ?? 1,
     inferenceProfile: input.inferenceProfile ?? null,
     inferenceProfileSource: input.inferenceProfileSource ?? null,
     estimatedCostUsd: pricing.estimatedCostUsd,
@@ -69,7 +70,7 @@ export function recordUsageEvent(
       rawUsage: event.rawUsage === null ? null : JSON.stringify(event.rawUsage),
       estimatedCostUsd: event.estimatedCostUsd,
       pricingStatus: event.pricingStatus,
-      llmCallCount: event.llmCallCount ?? 1,
+      llmCallCount: event.llmCallCount,
       metadataJson: null,
       // Capture the assistant's version at RECORD time so a batch flush
       // days later doesn't mis-attribute this row to whatever version
@@ -105,6 +106,7 @@ function rowToUsageEvent(row: {
   rawUsage: string | null;
   estimatedCostUsd: number | null;
   pricingStatus: string;
+  llmCallCount: number | null;
   assistantVersion: string | null;
 }): UsageEvent {
   return {
@@ -127,6 +129,7 @@ function rowToUsageEvent(row: {
     rawUsage: parseRawUsage(row.rawUsage),
     estimatedCostUsd: row.estimatedCostUsd,
     pricingStatus: row.pricingStatus as "priced" | "unpriced",
+    llmCallCount: row.llmCallCount,
     assistantVersion: row.assistantVersion,
   };
 }
@@ -230,6 +233,7 @@ export function queryUnreportedUsageEvents(
       estimatedCostUsd: llmUsageEvents.estimatedCostUsd,
       pricingStatus: llmUsageEvents.pricingStatus,
       assistantVersion: llmUsageEvents.assistantVersion,
+      llmCallCount: llmUsageEvents.llmCallCount,
       conversationType: conversations.conversationType,
       // Null when conversationId is null (no parent conversation).
       // Otherwise the count of eligible user turns up to and including

package/src/memory/migrations/181-rename-thread-starters-checkpoints.ts

@@ -4,8 +4,8 @@ import { withCrashRecovery } from "./validate-migration-state.js";
 
 /**
  * Rename checkpoint keys from the old `thread_starters:` prefix to
- * `conversation_starters:` so that the renamed code paths in
- * `conversation-starters-cadence.ts` and `conversation-starters.ts`
+ * `conversation_starters:` so that the renamed code paths (see
+ * `conversation-starter-checkpoints.ts` and `conversation-starters.ts`)
  * find existing generation state and avoid unnecessary re-generation.
  *
  * This was originally appended to migration 174, but that migration