@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/runtime/guardian-reply-router.ts

@@ -13,8 +13,8 @@
  * validation, expiry checks, the atomic gateway CAS+outcome commit,
  * kind-specific resolver dispatch, and grant minting.
  *
- * Routing reads (code lookup, pending discovery, reaction addressing) use the
- * degrading gateway-client variants: an unreachable gateway resolves to "no
+ * Routing reads (code lookup, pending discovery) use the degrading
+ * gateway-client variants: an unreachable gateway resolves to "no
  * pending requests", so the message falls through to the normal pipeline
  * instead of failing the inbound turn — decisions themselves still fail
  * loudly inside the primitive.
@@ -23,7 +23,6 @@
  * to allow for incremental migration and independent testability.
  */
 
-import type { InboundReactionPayload } from "@vellumai/gateway-client";
 import { isGuardianRequestExpired } from "@vellumai/gateway-client";
 
 import {
@@ -38,7 +37,6 @@ import type {
 import {
   getGuardianRequestByCodeOrNull,
   getGuardianRequestOrNull,
-  getPendingRequestByDestinationMessageOrNull,
   type GuardianRequestWire,
   listGuardianRequestsOrEmpty,
 } from "../channels/gateway-guardian-requests.js";
@@ -62,7 +60,6 @@ import type {
   ApprovalConversationGenerator,
 } from "./http-types.js";
 import * as pendingInteractions from "./pending-interactions.js";
-import { reactionDecisionForEmoji } from "./routes/channel-route-shared.js";
 
 const log = getLogger("guardian-reply-router");
 
@@ -94,29 +91,16 @@ export type GuardianPendingScope =
 export interface GuardianReplyContext {
   /** The raw message text (trimmed). */
   messageText: string;
-  /** Source channel (telegram, whatsapp, etc.). */
-  channel: string;
   /** Actor identity context for the sender. */
   actor: ActorContext;
   /**
    * Conversation the message arrived in (may be the guardian's own). Only the
-   * text and NL paths read it; reactions and `apr:` callbacks resolve their
-   * target by card address or embedded request id and may pass none.
+   * text and NL paths read it; `apr:` callbacks resolve their target by the
+   * embedded request id and may pass none.
    */
   conversationId?: string;
   /** Callback data from button presses (e.g. `apr:<requestId>:<action>`). */
   callbackData?: string;
-  /**
-   * Structured reaction payload when the inbound event is a reaction; the
-   * reaction branch keys on it and reads nothing off callbackData.
-   */
-  reaction?: InboundReactionPayload;
-  /**
-   * For emoji-reaction decisions: the
-   * channel-native id (e.g. Slack `ts`) of the message the reaction was
-   * attached to. Used to recover the target request from its delivery record.
-   */
-  reactedMessageTs?: string;
   /**
    * How to scope this guardian's pending requests (see {@link
    * GuardianPendingScope}). Omitted is equivalent to
@@ -357,69 +341,14 @@ export async function routeGuardianReply(
 ): Promise<GuardianReplyResult> {
   const {
     messageText,
-    channel,
     actor,
     conversationId,
     callbackData,
-    reactedMessageTs,
     approvalConversationGenerator,
     channelDeliveryContext,
     emissionContext,
   } = ctx;
 
-  // ── 0. Reaction decisions (emoji on a delivered approval card) ──
-  // A reaction carries an emoji plus the message it is attached to. Map the
-  // emoji to an action and recover the target request from that card's
-  // delivery record. Addressing by the reacted message disambiguates precisely
-  // even when several cards are pending in the same chat, so — unlike the
-  // text/NL paths — no clarification prompt is ever needed. `reaction_removed`
-  // never expresses intent and is filtered out before reaching the router.
-  if (ctx.reaction?.op === "added") {
-    const decision = reactionDecisionForEmoji(ctx.reaction.emoji);
-    const guardianChatId = channelDeliveryContext?.guardianChatId;
-    if (!decision || !reactedMessageTs || !guardianChatId) {
-      // Unknown emoji, or missing addressing context — not an actionable
-      // approval reaction. Leave it for the caller to persist as a transcript
-      // signal (it must not trigger an agent turn).
-      return notConsumed();
-    }
-    // A delivery row keys its card by the destination the adapter delivered
-    // to, and channels address that destination in one of two modalities: a
-    // chat (the conversation the reaction arrives from) or a person (the
-    // guardian's own user id, which person-addressed adapters store so a
-    // stale room id can never become a delivery target). The reactor on an
-    // approval card is the person it was delivered to, so their id is the
-    // second probe; identity validation in applyGuardianDecision still
-    // guards the decision itself.
-    const request =
-      (await getPendingRequestByDestinationMessageOrNull(
-        channel,
-        guardianChatId,
-        reactedMessageTs,
-      )) ??
-      (actor.actorExternalUserId
-        ? await getPendingRequestByDestinationMessageOrNull(
-            channel,
-            actor.actorExternalUserId,
-            reactedMessageTs,
-          )
-        : null);
-    if (!request) {
-      // The reacted message is not a known pending approval card (a stray
-      // reaction, or one whose request was already resolved). Never approve
-      // off an unrecognized message.
-      return notConsumed();
-    }
-    return applyDecision(
-      request.id,
-      decision.action,
-      actor,
-      undefined,
-      channelDeliveryContext,
-      emissionContext,
-    );
-  }
-
   const pendingScope: GuardianPendingScope = ctx.pendingScope ?? {
     mode: "identity-fallback",
   };

package/src/runtime/http-router.ts

@@ -202,7 +202,7 @@ function compileRoute(def: HTTPRouteDefinition): CompiledRoute {
         const typePattern = PARAM_TYPE_PATTERNS[paramTypeMap.get(name) ?? ""];
         return typePattern ? `(${typePattern})` : "([^/]+)";
       }
-      return escapeRegex(segment);
+      return RegExp.escape(segment);
     })
     .join("\\/");
 
@@ -210,7 +210,3 @@ function compileRoute(def: HTTPRouteDefinition): CompiledRoute {
 
   return { def, regex, paramNames };
 }
-
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/src/runtime/question-request-guardian-bridge.ts

@@ -4,9 +4,8 @@
  *
  * Mirrors `confirmation-request-guardian-bridge.ts` for the question kind:
  * emits the notification signal (the broadcaster renders the options as card
- * actions — see `resolveQuestionOptionsContext`) and records the resulting
- * card deliveries so reply routing can address taps and reactions back to the
- * request.
+ * actions — see `resolveQuestionContext`) and records the resulting
+ * card deliveries so reply routing can address taps back to the request.
  *
  * Unlike the confirmation bridge — which escalates a NON-guardian's request TO
  * the guardian — the caller (`question-guardian-request.ts`) has already

package/src/runtime/routes/__tests__/conversation-list-assistant-section.test.ts

@@ -0,0 +1,359 @@
+/**
+ * The `assistant-initiated-threads` split: the threads the assistant started
+ * on its own (`source = 'assistant_initiated'`, opt-in at creation) become
+ * their own sidebar section instead of sitting in Chats.
+ *
+ * The flag is the whole point of these tests. It is a read-side gate over rows
+ * that exist either way, so the off arm must be byte-identical to the behavior
+ * that shipped before the section existed — that is what makes the feature
+ * reversible without a migration. Both arms are asserted for every claim.
+ *
+ * The gate module is mocked rather than the flag registry: the registry
+ * resolves through workspace override files, and a test that wrote those would
+ * be asserting the resolver's behavior rather than this route's.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Avoid spinning up the real event hub for the pinned/groups branches.
+mock.module("../../assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => () => {},
+  },
+  broadcastMessage: () => {},
+}));
+
+let flagEnabled = false;
+mock.module("../../../config/assistant-initiated-threads-gate.js", () => ({
+  isAssistantInitiatedThreadsEnabled: () => flagEnabled,
+}));
+
+import { projectAssistantMessage } from "../../../persistence/conversation-attention-store.js";
+import { createConversation } from "../../../persistence/conversation-crud.js";
+import { getDb } from "../../../persistence/db-connection.js";
+import { initializeDb } from "../../../persistence/db-init.js";
+import { createGroup } from "../../../persistence/group-crud.js";
+import { rawRun } from "../../../persistence/raw-query.js";
+import { conversations } from "../../../persistence/schema/index.js";
+import { ROUTES as CONVERSATION_LIST_ROUTES } from "../conversation-list-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+await initializeDb();
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function findHandler(routes: RouteDefinition[], operationId: string) {
+  const route = routes.find((r) => r.operationId === operationId);
+  if (!route) {
+    throw new Error(`Route ${operationId} not found`);
+  }
+  return route.handler;
+}
+
+const sectionsHandler = findHandler(
+  CONVERSATION_LIST_ROUTES,
+  "getConversationSections",
+);
+const listHandler = findHandler(CONVERSATION_LIST_ROUTES, "listConversations");
+
+interface SectionRow {
+  kind: "pinned" | "group" | "channel" | "chats" | "assistant";
+  channelId?: string;
+  groupId?: string;
+  total: number;
+  unread: number;
+}
+
+function invokeSections(): SectionRow[] {
+  return (sectionsHandler({}) as { sections: SectionRow[] }).sections;
+}
+
+interface ListResponse {
+  conversations: Array<{ id: string; title: string }>;
+}
+
+function invokeList(queryParams: Record<string, string> = {}): ListResponse {
+  return listHandler({ queryParams }) as ListResponse;
+}
+
+function titlesFrom(response: ListResponse): string[] {
+  return response.conversations.map((c) => c.title).sort();
+}
+
+/**
+ * A thread a producer opted into the assistant-initiated section: a
+ * standard-type conversation, filed nowhere, stamped
+ * `source: 'assistant_initiated'` at creation (ASSISTANT_INITIATED_SOURCE).
+ */
+function seedAssistantInitiated(title: string): string {
+  return createConversation({ title, source: "assistant_initiated" }).id;
+}
+
+/**
+ * A transactional notification trail - what the guardian request flows and
+ * channel deliveries materialize (`source: 'notification'`, see
+ * `notifications/conversation-pairing.ts`). Never a member of the section:
+ * these belong to the bell and to Chats.
+ */
+function seedNotificationTrail(title: string): string {
+  return createConversation({ title, source: "notification" }).id;
+}
+
+function seedUnseen(conversationId: string): void {
+  projectAssistantMessage({
+    conversationId,
+    messageId: `msg-${conversationId}`,
+    messageAt: Date.now(),
+  });
+}
+
+function stampChannel(conversationId: string, channel: string): void {
+  rawRun(
+    "test:stampChannel",
+    "UPDATE conversations SET origin_channel = ? WHERE id = ?",
+    channel,
+    conversationId,
+  );
+}
+
+function pin(conversationId: string): void {
+  rawRun(
+    "test:pinConversation",
+    "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned' WHERE id = ?",
+    conversationId,
+  );
+}
+
+function fileIntoGroup(conversationId: string, groupId: string): void {
+  rawRun(
+    "test:fileIntoGroup",
+    "UPDATE conversations SET group_id = ? WHERE id = ?",
+    groupId,
+    conversationId,
+  );
+}
+
+beforeEach(() => {
+  flagEnabled = false;
+  getDb().delete(conversations).run();
+});
+
+// ---------------------------------------------------------------------------
+// Flag off — the shipped behavior, unchanged
+// ---------------------------------------------------------------------------
+
+describe("assistant-initiated threads — flag off", () => {
+  test("emits no assistant section, and the threads stay counted in Chats", () => {
+    seedAssistantInitiated("overnight-realization");
+    createConversation({ title: "user-thread" });
+
+    const sections = invokeSections();
+
+    expect(sections.some((s) => s.kind === "assistant")).toBe(false);
+    expect(sections).toContainEqual({ kind: "chats", total: 2, unread: 0 });
+  });
+
+  test("the threads stay listed in the standard list", () => {
+    seedAssistantInitiated("overnight-realization");
+    createConversation({ title: "user-thread" });
+
+    expect(titlesFrom(invokeList())).toEqual([
+      "overnight-realization",
+      "user-thread",
+    ]);
+  });
+
+  test("their unread still counts toward Chats", () => {
+    seedUnseen(seedAssistantInitiated("noticed-something"));
+    createConversation({ title: "user-thread" });
+
+    expect(invokeSections()).toContainEqual({
+      kind: "chats",
+      total: 2,
+      unread: 1,
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Flag on — the split
+// ---------------------------------------------------------------------------
+
+describe("assistant-initiated threads — flag on", () => {
+  beforeEach(() => {
+    flagEnabled = true;
+  });
+
+  test("the threads move out of Chats into their own section", () => {
+    seedAssistantInitiated("overnight-realization");
+    seedAssistantInitiated("noticed-something");
+    createConversation({ title: "user-thread" });
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({ kind: "assistant", total: 2, unread: 0 });
+    expect(sections).toContainEqual({ kind: "chats", total: 1, unread: 0 });
+  });
+
+  test("the section renders at zero, the way Chats does", () => {
+    createConversation({ title: "user-thread" });
+
+    expect(invokeSections()).toContainEqual({
+      kind: "assistant",
+      total: 0,
+      unread: 0,
+    });
+  });
+
+  test("unread follows the section, and is not double-counted in Chats", () => {
+    seedUnseen(seedAssistantInitiated("noticed-something"));
+    seedAssistantInitiated("read-already");
+    seedUnseen(createConversation({ title: "user-thread" }).id);
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({ kind: "assistant", total: 2, unread: 1 });
+    expect(sections).toContainEqual({ kind: "chats", total: 1, unread: 1 });
+  });
+
+  test("the split leaves channel sections alone", () => {
+    seedAssistantInitiated("overnight-realization");
+    stampChannel(createConversation({ title: "slack-thread" }).id, "slack");
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({ kind: "assistant", total: 1, unread: 0 });
+    expect(sections).toContainEqual({
+      kind: "channel",
+      channelId: "slack",
+      total: 1,
+      unread: 0,
+    });
+  });
+
+  test("groupId=system:assistant lists exactly those threads", () => {
+    seedAssistantInitiated("overnight-realization");
+    seedAssistantInitiated("noticed-something");
+    createConversation({ title: "user-thread" });
+
+    expect(titlesFrom(invokeList({ groupId: "system:assistant" }))).toEqual([
+      "noticed-something",
+      "overnight-realization",
+    ]);
+  });
+
+  test("the standard list withholds them, and keeps every NULL-source row", () => {
+    // The regression this guards: `NOT (source = '...')` is NULL for the
+    // NULL-source rows that make up most of the list, so a naive negation
+    // would return an empty list rather than one section fewer.
+    seedAssistantInitiated("overnight-realization");
+    createConversation({ title: "user-thread" });
+    createConversation({ title: "another-user-thread" });
+
+    expect(titlesFrom(invokeList())).toEqual([
+      "another-user-thread",
+      "user-thread",
+    ]);
+  });
+
+  test("a list already scoped to the section is not narrowed to nothing", () => {
+    // `groupId=system:assistant` selects on the same column the exclusion
+    // negates, so applying both would return an empty page for the one caller
+    // that actually wants these rows.
+    seedAssistantInitiated("overnight-realization");
+
+    expect(titlesFrom(invokeList({ groupId: "system:assistant" }))).toEqual([
+      "overnight-realization",
+    ]);
+  });
+
+  test("a pinned thread belongs to Pinned, not to both", () => {
+    // Section membership is single-valued everywhere else in the sidebar, and
+    // this section is carved out of the same ungrouped set Chats is, so
+    // pinning has to move a thread rather than duplicate it.
+    pin(seedAssistantInitiated("pinned-realization"));
+    seedAssistantInitiated("ordinary-realization");
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({ kind: "assistant", total: 1, unread: 0 });
+    expect(sections).toContainEqual({ kind: "pinned", total: 1, unread: 0 });
+    expect(titlesFrom(invokeList({ groupId: "system:assistant" }))).toEqual([
+      "ordinary-realization",
+    ]);
+  });
+
+  test("transactional notification trails are not members, and stay in Chats", () => {
+    // The membership source is opt-in precisely so the flag turning on cannot
+    // sweep the historical guardian-request and channel-delivery trails
+    // (`source = 'notification'`) into the section: only threads written for
+    // the section, from the moment producers start stamping its source, are
+    // members.
+    seedNotificationTrail("approve-this-call");
+    seedAssistantInitiated("overnight-realization");
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({ kind: "assistant", total: 1, unread: 0 });
+    expect(sections).toContainEqual({ kind: "chats", total: 1, unread: 0 });
+    expect(titlesFrom(invokeList())).toEqual(["approve-this-call"]);
+    expect(titlesFrom(invokeList({ groupId: "system:assistant" }))).toEqual([
+      "overnight-realization",
+    ]);
+  });
+
+  test("a thread filed into a custom group leaves the section and stays listable", () => {
+    // The exclusion is the complement of the section, so a thread that moved
+    // out of the section must not stay excluded from the list of the group it
+    // moved into — otherwise filing one makes it unreachable.
+    const group = createGroup("Reading List");
+    const filed = seedAssistantInitiated("filed-realization");
+    fileIntoGroup(filed, group.id);
+
+    expect(invokeSections()).toContainEqual({
+      kind: "assistant",
+      total: 0,
+      unread: 0,
+    });
+    expect(titlesFrom(invokeList({ groupId: group.id }))).toEqual([
+      "filed-realization",
+    ]);
+  });
+
+  test("the Archive view keeps archived section threads", () => {
+    // Archive asks archiveStatus=archived with no groupId, and the section
+    // only ever lists active rows, so the split's exclusion must not reach
+    // archived reads or an archived section thread is visible nowhere.
+    const archived = seedAssistantInitiated("archived-realization");
+    rawRun(
+      "test:archive",
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      archived,
+    );
+
+    expect(titlesFrom(invokeList({ archiveStatus: "archived" }))).toEqual([
+      "archived-realization",
+    ]);
+  });
+
+  test("the background umbrella is left unnarrowed", () => {
+    // A background row carrying the section's own source is addressed by
+    // conversation type, and narrowing that bucket by source would drop rows
+    // its callers still page through.
+    const background = createConversation({
+      title: "background-realization",
+      conversationType: "background",
+      source: "assistant_initiated",
+    });
+
+    expect(
+      invokeList({ conversationType: "background" }).conversations.map(
+        (c) => c.id,
+      ),
+    ).toContain(background.id);
+  });
+});

package/src/runtime/routes/__tests__/dictation-command-mode.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Command mode of `POST /v1/dictation`: selected text with the words spoken
+ * over it. The model is asked, through one forced tool call, whether the
+ * words wanted the selection changed or asked about it, and the route answers
+ * `command` with the edit or `question` with the words as they were.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+type ToolInput = { kind?: string; text?: string };
+let nextToolInput: ToolInput | null = null;
+let forcedTool: string | undefined;
+
+mock.module("../../../providers/provider-send-message.js", () => ({
+  getConfiguredProvider: async () => ({
+    sendMessage: async (
+      _messages: unknown,
+      options: { config?: { tool_choice?: { name?: string } } },
+    ) => {
+      forcedTool = options.config?.tool_choice?.name;
+      return {
+        content: nextToolInput
+          ? [
+              {
+                type: "tool_use",
+                id: "tool-1",
+                name: "transform_selection",
+                input: nextToolInput,
+              },
+            ]
+          : [{ type: "text", text: "Sure, here it is." }],
+      };
+    },
+  }),
+  extractToolUse: (response: { content: Array<{ type: string }> }) =>
+    response.content.find((block) => block.type === "tool_use"),
+  userMessage: (text: string) => ({ role: "user", content: text }),
+  createTimeout: () => ({ signal: undefined, cleanup: () => undefined }),
+}));
+
+mock.module("../../../daemon/dictation-profile-store.js", () => ({
+  resolveProfile: () => ({
+    profile: { id: "default", stylePrompt: "", dictionary: [], snippets: [] },
+    source: "default",
+  }),
+}));
+
+mock.module("../../../daemon/dictation-text-processing.js", () => ({
+  applyDictionary: (text: string) => text,
+  expandSnippets: (text: string) => text,
+}));
+
+const { ROUTES } = await import("../diagnostics-routes.js");
+const route = ROUTES.find((r) => r.operationId === "dictation_post")!;
+
+const SELECTION = "Please send me the files.";
+
+async function speakOverSelection(transcription: string) {
+  return (await route.handler({
+    body: {
+      transcription,
+      context: {
+        bundleIdentifier: "com.example.mail",
+        appName: "Example Mail",
+        windowTitle: "New Message",
+        selectedText: SELECTION,
+        cursorInTextField: true,
+      },
+    },
+  } as unknown as Parameters<typeof route.handler>[0])) as {
+    text: string;
+    mode: string;
+  };
+}
+
+afterEach(() => {
+  nextToolInput = null;
+  forcedTool = undefined;
+});
+
+describe("dictation command mode", () => {
+  test("answers an instruction with the edit", async () => {
+    nextToolInput = { kind: "edit", text: "Could you send the files over?" };
+
+    const result = await speakOverSelection("make this friendlier");
+
+    expect(forcedTool).toBe("transform_selection");
+    expect(result).toMatchObject({
+      mode: "command",
+      text: "Could you send the files over?",
+    });
+  });
+
+  test("answers a question with the words as they were", async () => {
+    nextToolInput = { kind: "answer", text: "" };
+
+    const result = await speakOverSelection("what does this mean");
+
+    expect(result).toMatchObject({
+      mode: "question",
+      text: "what does this mean",
+    });
+  });
+
+  test("an edit with nothing in it is a question", async () => {
+    nextToolInput = { kind: "edit", text: "  " };
+
+    const result = await speakOverSelection("is this right");
+
+    expect(result.mode).toBe("question");
+  });
+
+  test("a model that answers in prose hands the selection back unchanged", async () => {
+    nextToolInput = null;
+
+    const result = await speakOverSelection("make this friendlier");
+
+    expect(result).toMatchObject({ mode: "command", text: SELECTION });
+  });
+});