@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/runtime/routes/conversation-list-routes.ts

@@ -13,6 +13,7 @@
 import { z } from "zod";
 
 import { CHANNEL_IDS } from "../../channels/types.js";
+import { isAssistantInitiatedThreadsEnabled } from "../../config/assistant-initiated-threads-gate.js";
 import { channelBindingSchema } from "../../messaging/channel-binding-schema.js";
 import {
   type Confidence,
@@ -35,7 +36,10 @@ import {
   listConversations,
   listPinnedConversations,
 } from "../../persistence/conversation-queries.js";
-import type { ConversationType } from "../../persistence/conversation-types.js";
+import {
+  ASSISTANT_INITIATED_GROUP_ID,
+  type ConversationType,
+} from "../../persistence/conversation-types.js";
 import { getBindingsForConversations } from "../../persistence/external-conversation-store.js";
 import { listGroups } from "../../persistence/group-crud.js";
 import { UserError } from "../../util/errors.js";
@@ -170,9 +174,16 @@ const sectionCountFields = {
  * `chats` is the ungrouped-native bucket. In a view without channel sections
  * the Chats card holds every ungrouped row: the buckets are disjoint, so
  * that reading is `chats` plus the sum of `channel` entries.
+ *
+ * `assistant` is emitted only under the `assistant-initiated-threads` flag,
+ * and while it is emitted its rows are withheld from `chats`, so the
+ * disjointness above holds in both states. A client that does not know the
+ * kind ignores it, which is the same thing an older client does with a
+ * `channel` section for a channel it has no label for.
  */
 const conversationSectionSchema = z.discriminatedUnion("kind", [
   z.object({ kind: z.literal("pinned"), ...sectionCountFields }),
+  z.object({ kind: z.literal("assistant"), ...sectionCountFields }),
   z.object({
     kind: z.literal("group"),
     groupId: z.string(),
@@ -274,6 +285,23 @@ function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
       ? true
       : undefined;
 
+  /* The list half of the section split. A read already scoped to the
+     assistant section obviously keeps its rows; every other standard-listing
+     read withholds them, so they appear in their own section and nowhere
+     else. Confined to `standard`: the background and scheduled buckets are
+     back-compat umbrellas addressed by conversation type, and narrowing them
+     by source would drop rows their callers still page through. Confined to
+     active reads too: the Archive view asks `archiveStatus=archived` with no
+     `groupId`, and the section only ever lists active rows, so withholding
+     there would leave an archived section thread visible nowhere. */
+  const excludeAssistantInitiated =
+    isAssistantInitiatedThreadsEnabled() &&
+    conversationType === "standard" &&
+    archiveStatus === "active" &&
+    groupId !== ASSISTANT_INITIATED_GROUP_ID
+      ? (true as const)
+      : undefined;
+
   const filter: ConversationListFilter = {
     conversationType,
     archiveStatus,
@@ -281,6 +309,7 @@ function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
     groupId,
     needsAttention,
     foregroundOnly,
+    excludeAssistantInitiated,
   };
   let rows = listConversations({ ...filter, limit, offset });
   const totalCount = countConversations(filter);
@@ -371,10 +400,22 @@ function handleGetUnreadConversationCount() {
  * dangling id is a transient state around group deletion, not a section.
  */
 function handleGetConversationSections() {
-  const counts = countConversationSections();
+  const splitAssistantInitiated = isAssistantInitiatedThreadsEnabled();
+  const counts = countConversationSections({ splitAssistantInitiated });
   const groupsById = new Map(listGroups().map((g) => [g.id, g]));
   const sections: Array<z.infer<typeof conversationSectionSchema>> = [];
 
+  /* Unlike every other section this one renders at zero, the way Chats does:
+     it is where the assistant's own threads accumulate, and a user who has
+     none yet is exactly who the section's empty state is written for. */
+  if (counts.assistantInitiated) {
+    sections.push({
+      kind: "assistant",
+      total: counts.assistantInitiated.total,
+      unread: counts.assistantInitiated.unread,
+    });
+  }
+
   for (const row of counts.groups) {
     if (row.groupId === "system:pinned") {
       sections.push({ kind: "pinned", total: row.total, unread: row.unread });
@@ -655,7 +696,7 @@ export const ROUTES: RouteDefinition[] = [
     },
     summary: "Sidebar section index",
     description:
-      "One row per renderable sidebar section (Pinned, each non-empty custom group, each origin channel with unassigned conversations, Chats) with total and unread counts and no conversation rows. Lets a client know which sections exist, and what their badges say, without fetching any conversation list. Totals follow the standard listing visibility; unread applies the same rules as GET /v1/conversations/unread-count scoped to the section. Chats is always present, even at zero: it is the leftover bucket and renders regardless.",
+      "One row per renderable sidebar section (Pinned, each non-empty custom group, each origin channel with unassigned conversations, Chats) with total and unread counts and no conversation rows. Lets a client know which sections exist, and what their badges say, without fetching any conversation list. Totals follow the standard listing visibility; unread applies the same rules as GET /v1/conversations/unread-count scoped to the section. Chats is always present, even at zero: it is the leftover bucket and renders regardless. Under the `assistant-initiated-threads` flag an `assistant` section is also present at every count — the threads the assistant started on its own, selectable as a list via `groupId=system:assistant` — and its rows are withheld from Chats so the buckets stay disjoint. With the flag off no `assistant` row is emitted and those conversations are counted in Chats as before.",
     tags: ["conversations"],
     responseBody: conversationSectionsResponseSchema,
     handler: handleGetConversationSections,

package/src/runtime/routes/conversation-management-routes.ts

@@ -107,7 +107,8 @@ const createConversationTypeSchema = z.enum([
   "background",
 ] as const satisfies readonly NonScheduledConversationType[]);
 
-function resolveOrThrow(rawId: string): string {
+/** The conversation an id or key names, or a 404 naming what the caller asked for. */
+export function resolveOrThrow(rawId: string): string {
   const id = resolveConversationId(rawId);
   if (!id) {
     throw new NotFoundError(`Conversation ${rawId} not found`);

package/src/runtime/routes/conversation-routes.ts

@@ -8,6 +8,7 @@ import {
   type ClientMetadataField,
   sanitizeClientMetadataValue,
 } from "@vellumai/service-contracts/client-metadata";
+import { pickReactionEmojiFields } from "@vellumai/service-contracts/reactions";
 import { v7 as uuidv7 } from "uuid";
 import { z } from "zod";
 
@@ -49,7 +50,10 @@ import {
 } from "../../conversations/message-consolidation.js";
 import { createApprovalConversationGenerator } from "../../daemon/approval-generators.js";
 import type { Conversation } from "../../daemon/conversation.js";
-import { persistQueuedMessageBody } from "../../daemon/conversation-messaging.js";
+import {
+  isConversationBusyError,
+  persistQueuedMessageBody,
+} from "../../daemon/conversation-messaging.js";
 import {
   buildModelInfoEvent,
   formatCleanResult,
@@ -599,7 +603,6 @@ async function tryConsumeGuardianReply(params: {
 
   const routerResult = await routeGuardianReply({
     messageText: trimmedContent,
-    channel: sourceChannel,
     actor: {
       actorPrincipalId: verifiedActorPrincipalId,
       actorExternalUserId: verifiedActorExternalUserId,
@@ -1002,6 +1005,7 @@ export async function handleListMessages({
     let noResponse: boolean | undefined;
     let reaction: ConversationMessage["reaction"];
     let providerError: ConversationMessage["providerError"];
+    let deletedAt: number | undefined;
     if (msg.metadata) {
       try {
         const meta = JSON.parse(msg.metadata) as Record<string, unknown>;
@@ -1016,21 +1020,34 @@ export async function handleListMessages({
         if (isNoResponseMetadata(meta)) {
           noResponse = true;
         }
-        // A reaction row, either direction, projects its structured fact so
-        // clients never render the stored "[reaction]" sentinel.
-        if (msg.metadata.includes("reaction")) {
-          const reactionMeta = readProviderMetadata(msg.metadata);
-          if (reactionMeta?.eventKind === "reaction" && reactionMeta.reaction) {
+        // Channel facts live in the row's provider envelope. A reaction row,
+        // either direction, projects its structured fact so clients never
+        // render the stored "[reaction]" sentinel; a row deleted on its
+        // channel projects the deletion so clients render a tombstone over
+        // the content the row keeps for audit. The substring guard keeps the
+        // envelope parse off rows that can carry neither fact: both
+        // envelopes spell these keys literally.
+        if (
+          msg.metadata.includes("reaction") ||
+          msg.metadata.includes("deletedAt")
+        ) {
+          const providerMeta = readProviderMetadata(msg.metadata);
+          if (providerMeta?.eventKind === "reaction" && providerMeta.reaction) {
+            const r = providerMeta.reaction;
             reaction = {
-              emoji: reactionMeta.reaction.emoji,
-              op: reactionMeta.reaction.op,
-              targetMessageId: reactionMeta.reaction.targetMessageId,
-              ...(reactionMeta.reaction.actorDisplayName
-                ? { actorDisplayName: reactionMeta.reaction.actorDisplayName }
+              emoji: r.emoji,
+              ...pickReactionEmojiFields(r),
+              op: r.op,
+              targetMessageId: r.targetMessageId,
+              ...(r.actorDisplayName
+                ? { actorDisplayName: r.actorDisplayName }
                 : {}),
               ...(msg.role === "assistant" ? { selfAuthored: true } : {}),
             };
           }
+          if (providerMeta?.deletedAt !== undefined) {
+            deletedAt = providerMeta.deletedAt;
+          }
         }
         // Daemon-persisted provider-failure notices carry the classified
         // error code/category so clients can render a themed card instead
@@ -1088,6 +1105,7 @@ export async function handleListMessages({
       reaction,
       providerError,
       slackMessage,
+      deletedAt,
       clientMessageId: msg.clientMessageId ?? undefined,
     };
   });
@@ -1298,6 +1316,7 @@ export async function handleListMessages({
         ...(m.reaction ? { reaction: m.reaction } : {}),
         ...(m.providerError ? { providerError: m.providerError } : {}),
         ...(m.slackMessage ? { slackMessage: m.slackMessage } : {}),
+        ...(m.deletedAt !== undefined ? { deletedAt: m.deletedAt } : {}),
       };
     }),
   );
@@ -2043,23 +2062,15 @@ export async function handleSendMessage(
     ? buildSelfIntroMessage(body.onboarding ?? undefined)
     : undefined;
 
-  let effectiveContent: string | undefined;
-  if (isScanPath) {
-    const scanVariant = websiteUrl
-      ? ("website" as const)
-      : ("content-source" as const);
-    effectiveContent = buildScanFirstMessage(scanUrl, scanVariant);
-    // Fall through to normal inference path below
-  } else if (selfIntroGreetingEnabled && body.onboarding?.initialMessage) {
-    effectiveContent = body.onboarding.initialMessage;
-  } else if (isWakeUp && selfIntro) {
-    // Rewrite to the self-introduction and fall through to real inference
-    // (mirrors the scan path above).
-    effectiveContent = selfIntro;
-  } else if (isWakeUp) {
-    const cannedGreeting = getCannedFirstGreeting(body.onboarding ?? undefined);
-
-    conversation.setProcessing(true);
+  /**
+   * Answer a first wake-up with the canned greeting, under a claim the caller
+   * already holds. Its own function so the branch below can decline the claim
+   * and fall through to the ordinary path instead.
+   */
+  const serveCannedFirstGreeting = async (
+    cannedGreeting: string,
+    greetingOwner: number,
+  ) => {
     let cleanupDeferred = false;
     try {
       const rawContent = content ?? "";
@@ -2122,6 +2133,7 @@ export async function handleSendMessage(
 
       scheduleCannedReplyRelease({
         conversation,
+        owner: greetingOwner,
         origin: "canned_greeting",
         emit: () => {
           broadcastMessage({
@@ -2159,11 +2171,41 @@ export async function handleSendMessage(
       cleanupDeferred = true;
       return response;
     } finally {
-      if (!cleanupDeferred && conversation.isProcessing()) {
-        conversation.setProcessing(false);
+      if (!cleanupDeferred && conversation.releaseProcessing(greetingOwner)) {
         void conversation.kickDrainQueue("loop_complete", "send_error_path");
       }
     }
+  };
+
+  let effectiveContent: string | undefined;
+  if (isScanPath) {
+    const scanVariant = websiteUrl
+      ? ("website" as const)
+      : ("content-source" as const);
+    effectiveContent = buildScanFirstMessage(scanUrl, scanVariant);
+    // Fall through to normal inference path below
+  } else if (selfIntroGreetingEnabled && body.onboarding?.initialMessage) {
+    effectiveContent = body.onboarding.initialMessage;
+  } else if (isWakeUp && selfIntro) {
+    // Rewrite to the self-introduction and fall through to real inference
+    // (mirrors the scan path above).
+    effectiveContent = selfIntro;
+  } else if (isWakeUp) {
+    const cannedGreeting = getCannedFirstGreeting(body.onboarding ?? undefined);
+
+    // Taken rather than set. The idle read behind this branch is several
+    // awaits old, so a hold taken since belongs to a real turn, and greeting
+    // over it would run two operations into one history. Declining and
+    // falling through is what the sibling branches above already do, and the
+    // gate below turns that into the queued answer a busy conversation owes.
+    const greetingOwner = await conversation.acquireProcessingFenced();
+    if (greetingOwner !== null) {
+      return serveCannedFirstGreeting(cannedGreeting, greetingOwner);
+    }
+    log.info(
+      { conversationId: mapping.conversationId },
+      "Canned first greeting yielded: the conversation is already held",
+    );
   }
 
   if (isFirstOnboarding) {
@@ -2236,11 +2278,23 @@ export async function handleSendMessage(
     );
   }
 
-  if (conversation.isProcessing()) {
+  /**
+   * Put the message on the conversation's queue and answer with the
+   * accepted-and-queued shape.
+   *
+   * Reached from the check just below, and again from every point past it that
+   * finds the conversation busy after all. That check and the acquire which
+   * actually starts a turn are separated by guardian cleanup, history scoping
+   * and slash resolution, so anything taking the flag inside those awaits
+   * leaves a send that has to queue rather than fail. Answering the same way
+   * from both means a client cannot tell which side of the awaits the
+   * conversation went busy on.
+   */
+  const queueSend = async (content: string) => {
     // Queue the message so it's processed when the current turn completes
     const requestId = uuidv7();
     const enqueueResult = conversation.enqueueMessage({
-      content: contentAfterScan,
+      content,
       attachments,
       onEvent: broadcastMessage,
       requestId,
@@ -2325,6 +2379,10 @@ export async function handleSendMessage(
       conversationId: mapping.conversationId,
       requestId,
     };
+  };
+
+  if (conversation.isProcessing()) {
+    return queueSend(contentAfterScan);
   }
 
   // Auto-deny pending confirmations for idle conversations. The legacy
@@ -2405,7 +2463,10 @@ export async function handleSendMessage(
   const slashResult = await resolveSlash(rawContent, slashContext);
 
   if (slashResult.kind === "unknown") {
-    conversation.setProcessing(true);
+    const slashOwner = await conversation.acquireProcessingFenced();
+    if (slashOwner === null) {
+      return queueSend(rawContent);
+    }
     let cleanupDeferred = false;
     try {
       const slashMeta = {
@@ -2470,6 +2531,7 @@ export async function handleSendMessage(
       const message = slashResult.message;
       scheduleCannedReplyRelease({
         conversation,
+        owner: slashOwner,
         origin: "slash_command",
         emit: () => {
           broadcastMessage({
@@ -2503,15 +2565,17 @@ export async function handleSendMessage(
     } finally {
       // No-op for the slash-command early-return path (handled inside
       // setTimeout above), but still needed for error paths.
-      if (!cleanupDeferred && conversation.isProcessing()) {
-        conversation.setProcessing(false);
+      if (!cleanupDeferred && conversation.releaseProcessing(slashOwner)) {
         void conversation.kickDrainQueue("loop_complete", "send_error_path");
       }
     }
   }
 
   if (slashResult.kind === "compact") {
-    conversation.setProcessing(true);
+    const compactOwner = await conversation.acquireProcessingFenced();
+    if (compactOwner === null) {
+      return queueSend(rawContent);
+    }
     const slashMeta = {
       userMessageChannel: sourceChannel,
       assistantMessageChannel: sourceChannel,
@@ -2532,12 +2596,12 @@ export async function handleSendMessage(
       // The fire-and-forget compaction below owns clearing `processing`, but a
       // throw from this initial persist never reaches it — reset here so the
       // conversation isn't stranded in queued mode.
-      conversation.setProcessing(false);
+      conversation.releaseProcessing(compactOwner);
       void conversation.kickDrainQueue("loop_complete", "compact_command");
       throw err;
     }
     if (persisted.deduplicated) {
-      conversation.setProcessing(false);
+      conversation.releaseProcessing(compactOwner);
       void conversation.kickDrainQueue("loop_complete", "compact_dedup");
       return {
         accepted: true,
@@ -2589,7 +2653,7 @@ export async function handleSendMessage(
           retryable: true,
         });
       } finally {
-        conversation.setProcessing(false);
+        conversation.releaseProcessing(compactOwner);
         void conversation.kickDrainQueue("loop_complete", "compact_command");
       }
     })();
@@ -2602,7 +2666,10 @@ export async function handleSendMessage(
   }
 
   if (slashResult.kind === "clean") {
-    conversation.setProcessing(true);
+    const cleanOwner = await conversation.acquireProcessingFenced();
+    if (cleanOwner === null) {
+      return queueSend(rawContent);
+    }
     const conversationId = mapping.conversationId;
     // Outer try/finally guarantees the processing flag is cleared (and the
     // queue drained) on every failure path — including a throw from the
@@ -2668,7 +2735,7 @@ export async function handleSendMessage(
         conversationId,
       };
     } finally {
-      conversation.setProcessing(false);
+      conversation.releaseProcessing(cleanOwner);
       void conversation.kickDrainQueue("loop_complete", "clean_command");
     }
   }
@@ -2676,23 +2743,35 @@ export async function handleSendMessage(
   const resolvedContent = slashResult.content;
 
   const requestId = uuidv7();
-  const persistResult = await conversation.persistUserMessage({
-    content: resolvedContent,
-    attachments,
-    requestId,
-    metadata: withClientMetadata(
-      body.automated === true || body.hidden === true
-        ? {
-            ...(body.automated === true ? { automated: true } : {}),
-            ...(body.hidden === true ? { hidden: true } : {}),
-          }
-        : undefined,
-      clientMetadata,
-    ),
-    scripted: body.scripted,
-    clientMessageId,
-    ...(clientOs ? { requestClientOs: clientOs } : {}),
-  });
+  let persistResult: Awaited<
+    ReturnType<typeof conversation.persistUserMessage>
+  >;
+  try {
+    persistResult = await conversation.persistUserMessage({
+      content: resolvedContent,
+      attachments,
+      requestId,
+      metadata: withClientMetadata(
+        body.automated === true || body.hidden === true
+          ? {
+              ...(body.automated === true ? { automated: true } : {}),
+              ...(body.hidden === true ? { hidden: true } : {}),
+            }
+          : undefined,
+        clientMetadata,
+      ),
+      scripted: body.scripted,
+      clientMessageId,
+      ...(clientOs ? { requestClientOs: clientOs } : {}),
+    });
+  } catch (err) {
+    if (isConversationBusyError(err)) {
+      // The flag went to someone else inside the awaits above. This is the
+      // same message the check at the top would have queued, so queue it.
+      return queueSend(resolvedContent);
+    }
+    throw err;
+  }
 
   const messageId = persistResult.id;