@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/notifications/conversation-pairing.ts

@@ -32,16 +32,12 @@
 import type { ConversationStrategy } from "../channels/config.js";
 import { getConversationStrategy } from "../channels/config.js";
 import { type ChannelId, isChannelId } from "../channels/types.js";
-import { isAssistantInitiatedThreadsEnabled } from "../config/assistant-initiated-threads-gate.js";
 import {
   addMessage,
   createConversation,
   getConversation,
 } from "../persistence/conversation-crud.js";
-import {
-  ASSISTANT_INITIATED_SOURCE,
-  type ConversationCreateType,
-} from "../persistence/conversation-types.js";
+import type { ConversationCreateType } from "../persistence/conversation-types.js";
 import {
   findInboundConversationId,
   resolveInboundConversation,
@@ -56,6 +52,10 @@ import {
 } from "../runtime/sync/resource-sync-events.js";
 import { getLogger } from "../util/logger.js";
 import { withSqliteRetry } from "../util/sqlite-retry.js";
+import {
+  type AssistantInitiatedThreadResolution,
+  resolveAssistantInitiatedThread,
+} from "./assistant-initiated-thread.js";
 import {
   hasPersistedCompletionResult,
   notificationConversationId,
@@ -103,6 +103,8 @@ export interface PairingOptions {
   conversationAction?: ConversationAction;
   /** Destination binding data for channel-scoped conversation continuation. */
   bindingContext?: DestinationBindingContext;
+  /** Reuse the resolution made before delivery policy selects channels. */
+  assistantInitiatedThread?: AssistantInitiatedThreadResolution;
 }
 
 /**
@@ -126,72 +128,9 @@ export interface PairingOptions {
  * The returned `conversationId` is that producing conversation, with
  * `createdNewConversation` false.
  *
- * Errors are caught and logged — this function never throws so the
+ * Errors are caught and logged; this function never throws so the
  * notification pipeline is not disrupted by pairing failures.
  */
-/**
- * The event the assistant emits when it has a thought worth the user's time
- * ("assistant.share" - the notifications skill's default), as opposed to a
- * transactional request or a system alert.
- */
-const ASSISTANT_SHARE_EVENT = "assistant.share";
-
-/**
- * Promote a background share into an assistant-initiated thread, under the
- * `assistant-initiated-threads` flag.
- *
- * The heartbeat's "have a thought, share it" path emits an assistant.share
- * signal from its own background conversation, and the passive-vellum rule
- * below would append the body there - a row the sidebar never shows. When the
- * section exists, that share is exactly what it is for, so the signal is
- * rewritten to materialize a fresh standard conversation stamped
- * {@link ASSISTANT_INITIATED_SOURCE}, which is the section's membership mark.
- *
- * Deliberately narrow, in every direction it can be:
- * - vellum channel only: other channels deliver the share as a native
- *   message and need no in-app thread;
- * - assistant.share only: transactional events keep their own pairing
- *   rules, and their threads stay out of the section by source;
- * - only when the producing conversation is a background/scheduled run (or
- *   nothing resolvable): a share emitted from inside a user-facing thread
- *   keeps the append, since the user is already looking at that thread;
- * - never over an explicit `conversationMetadata.source` or an existing
- *   `requiresConversation`: a producer that declared its own filing wins.
- *
- * Flag off, the signal passes through untouched and shares keep the passive
- * append: nothing changes for anyone outside the rollout.
- */
-function withAssistantInitiatedThread(
-  signal: NotificationSignal,
-  channel: NotificationChannel,
-): NotificationSignal {
-  if (
-    channel !== "vellum" ||
-    signal.sourceEventName !== ASSISTANT_SHARE_EVENT ||
-    signal.requiresConversation === true ||
-    signal.conversationMetadata?.source !== undefined ||
-    !isAssistantInitiatedThreadsEnabled()
-  ) {
-    return signal;
-  }
-  const producing = getConversation(signal.sourceContextId);
-  if (
-    producing &&
-    producing.conversationType !== "background" &&
-    producing.conversationType !== "scheduled"
-  ) {
-    return signal;
-  }
-  return {
-    ...signal,
-    requiresConversation: true,
-    conversationMetadata: {
-      ...signal.conversationMetadata,
-      source: ASSISTANT_INITIATED_SOURCE,
-    },
-  };
-}
-
 export async function pairDeliveryWithConversation(
   rawSignal: NotificationSignal,
   channel: NotificationChannel,
@@ -199,7 +138,13 @@ export async function pairDeliveryWithConversation(
   options?: PairingOptions,
 ): Promise<PairingResult> {
   try {
-    const signal = withAssistantInitiatedThread(rawSignal, channel);
+    const signal =
+      channel === "vellum"
+        ? (
+            options?.assistantInitiatedThread ??
+            resolveAssistantInitiatedThread(rawSignal)
+          ).vellumSignal
+        : rawSignal;
     const strategy = getConversationStrategy(channel as ChannelId);
 
     if (strategy === "not_deliverable" || strategy === "push_only") {

package/src/notifications/emit-signal.ts

@@ -27,6 +27,7 @@ import { VellumAdapter } from "./adapters/macos.js";
 import { PlatformPushAdapter } from "./adapters/platform.js";
 import { SlackAdapter } from "./adapters/slack.js";
 import { TelegramAdapter } from "./adapters/telegram.js";
+import { resolveAssistantInitiatedThread } from "./assistant-initiated-thread.js";
 import {
   type ConversationCreatedInfo,
   NotificationBroadcaster,
@@ -428,6 +429,8 @@ export async function emitNotificationSignal<TEventName extends string>(
       });
     }
 
+    const assistantInitiatedThread = resolveAssistantInitiatedThread(signal);
+
     // Step 2: Evaluate the signal through the decision engine
     const connectedChannels = await getConnectedChannels();
 
@@ -444,6 +447,9 @@ export async function emitNotificationSignal<TEventName extends string>(
     // steps (2.5a/2.5b/2.5c) so any of them replacing the decision triggers
     // the re-persist and the stored row matches what is dispatched.
     const prePolicyDecision = decision;
+    let platformConfigured: Promise<boolean> | undefined;
+    const platformIsConfigured = () =>
+      (platformConfigured ??= isPlatformClientConfigured());
 
     // Step 2.5a: High/critical urgency signals always get both the in-app
     // system notification (vellum) and the remote push (platform),
@@ -497,7 +503,7 @@ export async function emitNotificationSignal<TEventName extends string>(
       }
       if (
         !selectedChannels.includes("platform") &&
-        (await isPlatformClientConfigured())
+        (await platformIsConfigured())
       ) {
         selectedChannels.push("platform");
         forcedChannels.push("platform");
@@ -559,9 +565,30 @@ export async function emitNotificationSignal<TEventName extends string>(
       };
     }
 
+    let assistantInitiatedPlatformAdded = false;
+    if (
+      assistantInitiatedThread.isCandidate &&
+      decision.shouldNotify &&
+      decision.selectedChannels.includes("vellum") &&
+      !decision.selectedChannels.includes("platform") &&
+      !(
+        "quiet" in signal.contextPayload && signal.contextPayload.quiet === true
+      ) &&
+      signal.routingIntent !== "single_channel" &&
+      !exclusiveAllowlist &&
+      (await platformIsConfigured())
+    ) {
+      assistantInitiatedPlatformAdded = true;
+      decision = {
+        ...decision,
+        selectedChannels: [...decision.selectedChannels, "platform"],
+        reasoningSummary: `${decision.reasoningSummary} (platform added: assistant-initiated thread candidate)`,
+      };
+    }
+
     // Re-persist the decision if any policy step changed it (urgency channel
-    // forcing, routing intent enforcement, or the access-request vellum
-    // floor), so the stored decision row matches what is actually dispatched.
+    // forcing, routing intent enforcement, the access-request vellum floor,
+    // or the From me push default), so the audit matches the dispatch.
     if (decision !== prePolicyDecision && decision.persistedDecisionId) {
       try {
         updateDecision(decision.persistedDecisionId, {
@@ -634,6 +661,10 @@ export async function emitNotificationSignal<TEventName extends string>(
       {
         onConversationCreated: params.onConversationCreated,
         resultsSink: channelResults,
+        assistantInitiatedThread: {
+          resolution: assistantInitiatedThread,
+          platformAdded: assistantInitiatedPlatformAdded,
+        },
       },
     );
 

package/src/notifications/types.ts

@@ -65,6 +65,8 @@ export type NotificationReceiptClass = z.infer<
 
 export const DeliveryResultSchema = z.object({
   success: z.boolean(),
+  /** Delivery was intentionally suppressed before the provider accepted it. */
+  skipped: z.boolean().optional(),
   error: z.string().optional(),
   messageId: z.string().optional(),
   /** Set only by the platform push adapter: true when the platform accepted

package/src/oauth/connect-orchestrator.ts

@@ -147,7 +147,7 @@ export async function orchestrateOAuthConnect(
   }
 
   // Deserialize JSON fields from the DB row
-  const dbAuthorizeParams = safeJsonParse<Record<string, string> | undefined>(
+  const authorizeParams = safeJsonParse<Record<string, string> | undefined>(
     providerRow.authorizeParams,
     undefined,
   );
@@ -155,7 +155,6 @@ export async function orchestrateOAuthConnect(
   // Resolve all protocol-level config from the DB
   const authorizeUrl = providerRow.authorizeUrl;
   const tokenExchangeUrl = providerRow.tokenExchangeUrl;
-  const authorizeParams = dbAuthorizeParams;
   const userinfoUrl = providerRow.userinfoUrl ?? undefined;
   const tokenEndpointAuthMethod = providerRow.tokenEndpointAuthMethod as
     | TokenEndpointAuthMethod

package/src/persistence/__tests__/conversation-auto-archive.test.ts

@@ -0,0 +1,330 @@
+import {
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  setSystemTime,
+  test,
+} from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+mock.module("../../config/sidebar-done-gate.js", () => ({
+  isSidebarDoneEnabled: () => true,
+  SIDEBAR_DONE_FLAG_KEY: "sidebar-done",
+}));
+
+import {
+  archiveInactiveConversation,
+  listAutoArchiveCandidates,
+} from "../conversation-auto-archive.js";
+import {
+  archiveConversation,
+  resurfaceArchivedConversation,
+  unarchiveConversation,
+} from "../conversation-crud.js";
+import { ensureGroupMigration } from "../conversation-group-migration.js";
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { rawGet, rawRun } from "../raw-query.js";
+import {
+  acpSessionHistory,
+  conversationAssistantAttentionState,
+  conversationModeSessions,
+  conversations,
+  externalConversationBindings,
+  workflowRuns,
+} from "../schema/index.js";
+import { upsertSubagentRecord } from "../subagent-store.js";
+
+await initializeDb();
+ensureGroupMigration();
+const NOW = 1_800_000_000_000;
+const DAY = 86_400_000;
+const CUTOFF = NOW - 7 * DAY;
+const ID = "conv-123";
+
+function insert(
+  id = ID,
+  values: Partial<typeof conversations.$inferInsert> = {},
+) {
+  getDb()
+    .insert(conversations)
+    .values({
+      id,
+      createdAt: CUTOFF - DAY,
+      updatedAt: NOW,
+      lastMessageAt: CUTOFF,
+      ...values,
+    })
+    .run();
+}
+function change(values: Partial<typeof conversations.$inferInsert>) {
+  getDb()
+    .update(conversations)
+    .set(values)
+    .where(eq(conversations.id, ID))
+    .run();
+}
+function candidates(limit = 100) {
+  return listAutoArchiveCandidates({ cutoff: CUTOFF, limit });
+}
+function state() {
+  return getDb()
+    .select({
+      archivedAt: conversations.archivedAt,
+      lastReopenedAt: conversations.lastReopenedAt,
+    })
+    .from(conversations)
+    .where(eq(conversations.id, ID))
+    .get();
+}
+
+beforeEach(() => {
+  setSystemTime(NOW);
+  const db = getDb();
+  db.delete(conversationAssistantAttentionState).run();
+  db.delete(conversationModeSessions).run();
+  db.delete(externalConversationBindings).run();
+  db.delete(acpSessionHistory).run();
+  db.delete(workflowRuns).run();
+  rawRun("test:clearSubagents", "DELETE FROM subagents");
+  db.delete(conversations).run();
+  insert();
+});
+afterAll(() => setSystemTime());
+
+test("includes the exact cutoff, excludes newer activity, and ignores title/update timestamps", () => {
+  expect(candidates().map((row) => row.id)).toEqual([ID]);
+  change({ lastMessageAt: CUTOFF + 1 });
+  expect(candidates()).toEqual([]);
+  change({ lastMessageAt: null, createdAt: CUTOFF });
+  expect(candidates()).toHaveLength(1);
+});
+
+const exclusions: Array<[string, () => void]> = [
+  ["already Done", () => change({ archivedAt: NOW })],
+  ["processing", () => change({ processingStartedAt: NOW })],
+  ["background", () => change({ conversationType: "background" })],
+  ["scheduled", () => change({ conversationType: "scheduled" })],
+  ["private", () => change({ conversationType: "private" })],
+  ["system", () => change({ source: "system" })],
+  ["subagent", () => change({ source: "subagent" })],
+  ["spawned child", () => change({ parentConversationId: "conv-parent" })],
+  ["memory", () => change({ source: "memory_v2_consolidation" })],
+  ["schedule owner", () => change({ scheduleJobId: "schedule-123" })],
+  [
+    "pin",
+    () => {
+      rawRun(
+        "test:pin",
+        "UPDATE conversations SET group_id = 'system:pinned' WHERE id = ?",
+        ID,
+      );
+    },
+  ],
+  [
+    "background group",
+    () => {
+      rawRun(
+        "test:background",
+        "UPDATE conversations SET group_id = 'system:background' WHERE id = ?",
+        ID,
+      );
+    },
+  ],
+  ["external origin", () => change({ originChannel: "slack" })],
+  [
+    "external binding",
+    () => {
+      getDb()
+        .insert(externalConversationBindings)
+        .values({
+          conversationId: ID,
+          sourceChannel: "telegram",
+          externalChatId: "chat-123",
+          createdAt: NOW,
+          updatedAt: NOW,
+        })
+        .run();
+    },
+  ],
+  [
+    "unread",
+    () => {
+      getDb()
+        .insert(conversationAssistantAttentionState)
+        .values({
+          conversationId: ID,
+          latestAssistantMessageAt: CUTOFF,
+          lastSeenAssistantMessageAt: null,
+          createdAt: NOW,
+          updatedAt: NOW,
+        })
+        .run();
+    },
+  ],
+  [
+    "ACP run",
+    () => {
+      getDb()
+        .insert(acpSessionHistory)
+        .values({
+          id: "acp-123",
+          agentId: "agent-123",
+          acpSessionId: "session-123",
+          parentConversationId: ID,
+          status: "running",
+          startedAt: CUTOFF,
+        })
+        .run();
+    },
+  ],
+  [
+    "workflow run",
+    () => {
+      getDb()
+        .insert(workflowRuns)
+        .values({
+          id: "run-123",
+          scriptSource: "",
+          scriptHash: "hash-123",
+          status: "running",
+          conversationId: ID,
+        })
+        .run();
+    },
+  ],
+  [
+    "mode session",
+    () => {
+      getDb()
+        .insert(conversationModeSessions)
+        .values({
+          id: "mode-123",
+          conversationId: ID,
+          mode: "browser",
+          status: "active",
+          sourceStartedAt: CUTOFF,
+          lastActivityAt: CUTOFF,
+        })
+        .run();
+    },
+  ],
+  [
+    "subagent run",
+    () => {
+      upsertSubagentRecord({
+        id: "task-123",
+        parentConversationId: ID,
+        conversationId: "conv-child",
+        label: "Example task",
+        objective: "Example objective",
+        role: "builder",
+        isFork: false,
+        sendResultToUser: true,
+        parentToolUseId: null,
+        status: "running",
+        error: null,
+        createdAt: CUTOFF,
+        startedAt: CUTOFF,
+        completedAt: null,
+        inputTokens: 0,
+        outputTokens: 0,
+        estimatedCost: 0,
+      });
+    },
+  ],
+];
+
+describe.each(exclusions)("%s exclusion", (_name, exclude) => {
+  test("is filtered from candidates and rechecked after sampling", () => {
+    const sampled = candidates()[0]!;
+    exclude();
+    expect(candidates()).toEqual([]);
+    expect(archiveInactiveConversation(sampled, CUTOFF, NOW)).toBe(false);
+  });
+});
+
+test("native notification origins and read chats stay eligible", () => {
+  change({ originChannel: "notification:reminder" });
+  getDb()
+    .insert(conversationAssistantAttentionState)
+    .values({
+      conversationId: ID,
+      latestAssistantMessageAt: CUTOFF,
+      lastSeenAssistantMessageAt: CUTOFF,
+      createdAt: NOW,
+      updatedAt: NOW,
+    })
+    .run();
+  expect(candidates()).toHaveLength(1);
+});
+
+test("a sampled old message change cannot be overwritten even if it remains below the cutoff", () => {
+  const sampled = candidates()[0]!;
+  change({ lastMessageAt: CUTOFF - 1 });
+  expect(archiveInactiveConversation(sampled, CUTOFF, NOW)).toBe(false);
+});
+
+test("manual reopen receives a full interval and repeated unarchive does not extend it", () => {
+  archiveConversation(ID);
+  unarchiveConversation(ID);
+  expect(state()).toEqual({ archivedAt: null, lastReopenedAt: NOW });
+  expect(candidates()).toEqual([]);
+  setSystemTime(NOW + DAY);
+  unarchiveConversation(ID);
+  expect(state()?.lastReopenedAt).toBe(NOW);
+  expect(listAutoArchiveCandidates({ cutoff: NOW - 1, limit: 100 })).toEqual(
+    [],
+  );
+  expect(listAutoArchiveCandidates({ cutoff: NOW, limit: 100 })).toHaveLength(
+    1,
+  );
+});
+
+test("reopen after sampling prevents the conditional archive", () => {
+  const sampled = candidates()[0]!;
+  archiveConversation(ID);
+  unarchiveConversation(ID);
+  expect(archiveInactiveConversation(sampled, CUTOFF, NOW)).toBe(false);
+});
+
+test("archive is idempotent and new visible activity resurfaces it", () => {
+  const sampled = candidates()[0]!;
+  expect(archiveInactiveConversation(sampled, CUTOFF, NOW)).toBe(true);
+  expect(archiveInactiveConversation(sampled, CUTOFF, NOW + 1)).toBe(false);
+  expect(resurfaceArchivedConversation(ID, NOW + 1)).toBe(true);
+  expect(state()).toEqual({ archivedAt: null, lastReopenedAt: null });
+});
+
+test("keyset paging covers all rows while earlier pages are marked Done", () => {
+  for (let i = 0; i < 205; i++) {
+    insert(`conv-page-${String(i).padStart(3, "0")}`);
+  }
+  const visited: string[] = [];
+  let after: ReturnType<typeof candidates>[number] | undefined;
+  do {
+    const page = listAutoArchiveCandidates({
+      cutoff: CUTOFF,
+      limit: 100,
+      after,
+    });
+    if (page.length === 0) {
+      break;
+    }
+    for (const candidate of page) {
+      expect(archiveInactiveConversation(candidate, CUTOFF, NOW)).toBe(true);
+      visited.push(candidate.id);
+    }
+    after = page[page.length - 1];
+  } while (true);
+  expect(new Set(visited).size).toBe(206);
+  expect(
+    rawGet<{ count: number }>(
+      "test:doneCount",
+      "SELECT count(*) AS count FROM conversations WHERE archived_at IS NOT NULL",
+    )?.count,
+  ).toBe(206);
+});