@vellumai/assistant 0.8.1 → 0.8.2

package/src/runtime/routes/acp-routes-list.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Tests for the GET /v1/acp/sessions list handler — specifically the SQL
+ * pad amount applied to acp_session_history when in-memory sessions are
+ * also present. We mock the DB layer so the limit value passed to the
+ * query builder can be asserted directly.
+ *
+ * Regression for codex P2 feedback on PR #29993: padding by the global
+ * inMemory.length over-fetched when many unrelated sessions were live
+ * but only one conversation was being queried.
+ */
+
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+import type { AcpSessionState } from "../../acp/index.js";
+
+const inMemoryStates = new Map<string, AcpSessionState>();
+
+mock.module("../../acp/index.js", () => ({
+  getAcpSessionManager: () => ({
+    getStatus: (id?: string) => {
+      if (id === undefined) return Array.from(inMemoryStates.values());
+      const state = inMemoryStates.get(id);
+      if (!state) throw new Error(`ACP session "${id}" not found`);
+      return state;
+    },
+  }),
+}));
+
+// Spy on the drizzle limit() call to assert the exact value the handler
+// passes to SQL. The stub mirrors only the chained methods used by
+// listMergedSessions; calls fall through to a final `.all()` returning [].
+const capturedLimits: number[] = [];
+
+mock.module("../../memory/db-connection.js", () => {
+  const builder: any = {};
+  builder.select = () => builder;
+  builder.from = () => builder;
+  builder.where = () => builder;
+  builder.orderBy = () => builder;
+  builder.limit = (n: number) => {
+    capturedLimits.push(n);
+    return builder;
+  };
+  builder.all = () => [];
+  return {
+    getDb: () => builder,
+  };
+});
+
+const { ROUTES } = await import("./acp-routes.js");
+
+function getListHandler() {
+  const route = ROUTES.find(
+    (r: { endpoint: string; method: string }) =>
+      r.endpoint === "acp/sessions" && r.method === "GET",
+  );
+  if (!route) throw new Error("GET acp/sessions route not registered");
+  return route.handler;
+}
+
+function makeInMemoryState(
+  id: string,
+  parentConversationId: string,
+): AcpSessionState {
+  return {
+    id,
+    agentId: "claude",
+    acpSessionId: `proto-${id}`,
+    parentConversationId,
+    status: "running",
+    startedAt: 1_700_000_000_000,
+  };
+}
+
+afterAll(() => {
+  inMemoryStates.clear();
+  capturedLimits.length = 0;
+});
+
+describe("GET /v1/acp/sessions — SQL pad amount", () => {
+  test("pads SQL limit by the conversation-filtered in-memory count, not the global one", async () => {
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+
+    // Many in-memory sessions for an unrelated conversation, plus one
+    // that matches the target conversation.
+    for (let i = 0; i < 25; i++) {
+      inMemoryStates.set(
+        `other-${i}`,
+        makeInMemoryState(`other-${i}`, "conv-other"),
+      );
+    }
+    inMemoryStates.set(
+      "target-mem",
+      makeInMemoryState("target-mem", "conv-target"),
+    );
+
+    const handler = getListHandler();
+    await handler({
+      queryParams: { conversationId: "conv-target", limit: "10" },
+    });
+
+    expect(capturedLimits).toHaveLength(1);
+    // pad = filtered in-memory count (1), not global (26).
+    expect(capturedLimits[0]).toBe(11);
+  });
+
+  test("pads by zero when no in-memory sessions match the target conversation", async () => {
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+
+    for (let i = 0; i < 10; i++) {
+      inMemoryStates.set(
+        `other-${i}`,
+        makeInMemoryState(`other-${i}`, "conv-other"),
+      );
+    }
+
+    const handler = getListHandler();
+    await handler({
+      queryParams: { conversationId: "conv-target", limit: "5" },
+    });
+
+    expect(capturedLimits).toEqual([5]);
+  });
+
+  test("pads by the full in-memory count when no conversation filter is supplied", async () => {
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+
+    for (let i = 0; i < 4; i++) {
+      inMemoryStates.set(
+        `sess-${i}`,
+        makeInMemoryState(`sess-${i}`, `conv-${i}`),
+      );
+    }
+
+    const handler = getListHandler();
+    await handler({ queryParams: { limit: "20" } });
+
+    expect(capturedLimits).toEqual([24]);
+  });
+});

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

@@ -373,11 +373,13 @@ function listMergedSessions(opts: {
     : baseQuery;
   // Fetch only enough rows to fill the requested page after merging with
   // in-memory sessions. In-memory entries take precedence on id collision,
-  // so we pad by inMemory.length to guarantee we still surface `limit`
-  // distinct rows even when every in-memory session shadows a DB row.
+  // so we pad by the count that survived the conversation filter to
+  // guarantee we still surface `limit` distinct rows even when every
+  // in-memory session shadows a DB row — without over-fetching when many
+  // unrelated sessions are in memory.
   const historyRows = filtered
     .orderBy(desc(acpSessionHistory.startedAt))
-    .limit(opts.limit + inMemory.length)
+    .limit(opts.limit + merged.size)
     .all();
 
   for (const row of historyRows) {

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

@@ -12,7 +12,7 @@ import {
   getPlatformOrganizationId,
   getPlatformUserId,
 } from "../../config/env.js";
-import { resolveManagedProxyContext } from "../../providers/managed-proxy/context.js";
+import { resolveManagedProxyContext } from "../../providers/platform-proxy/context.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 interface AuthInfoResult {

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

@@ -79,9 +79,11 @@ function handleCreateBookmark({
     );
   }
 
-  const summary = createBookmark(getDb(), { messageId, conversationId });
-  publishBookmarkCreated(summary);
-  return summary;
+  const result = createBookmark(getDb(), { messageId });
+  if (result.inserted) {
+    publishBookmarkCreated(result.bookmark);
+  }
+  return result.bookmark;
 }
 
 function handleDeleteBookmarkByMessage({ pathParams = {} }: RouteHandlerArgs): {

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

@@ -16,6 +16,7 @@ import { existsSync, readFileSync } from "node:fs";
 
 import { z } from "zod";
 
+import { getConfig } from "../../config/loader.js";
 import { readNowScratchpad } from "../../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { buildToolDefinitions } from "../../daemon/conversation-tool-setup.js";
@@ -92,7 +93,10 @@ async function handleBtw({
 
   // ----- Greeting context enrichment -----
   let effectiveContent = trimmedContent;
-  if (conversationKey === GREETING_KEY) {
+  if (
+    conversationKey === GREETING_KEY &&
+    getConfig().memory.retrieval.scratchpadInjection.enabled
+  ) {
     const now = readNowScratchpad();
     if (now) {
       effectiveContent = `${trimmedContent}\n\n<context>\n${now}\n</context>`;

package/src/runtime/routes/channel-availability-routes.ts

@@ -0,0 +1,121 @@
+/**
+ * Route handler for channel availability.
+ *
+ * GET /v1/channels/available — return the channels this assistant can
+ * surface to clients (Contacts / GuardianChannels views, etc.) along with
+ * their display metadata (label, subtitle, icon, verification capability,
+ * setup-message copy). Today this is a fixed base list plus `email` when
+ * an inbox is registered; eventually the list will be driven by
+ * plugins/skills the assistant has loaded. Clients should treat the
+ * response as authoritative and stop carrying their own per-channel
+ * switches.
+ *
+ * Distinct from `/v1/channels/readiness` (which answers "is this channel
+ * configured and working?"). Availability answers "could this channel be
+ * surfaced for setup/verification at all?".
+ */
+
+import { z } from "zod";
+
+import {
+  CHANNEL_IDS,
+  CHANNEL_METADATA,
+  type ChannelId,
+  type ChannelInfo,
+} from "../../channels/types.js";
+import { VellumPlatformClient } from "../../platform/client.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+// Base list every assistant currently surfaces. Order is the display
+// order clients should render. Keep stable — clients sort by index.
+const BASE_AVAILABLE_CHANNELS: readonly ChannelId[] = [
+  "slack",
+  "telegram",
+  "phone",
+] as const;
+
+interface EmailAddressListResponse {
+  count?: number;
+  results?: Array<{ id: string; address: string }>;
+}
+
+/**
+ * Best-effort check that an inbox address is registered for this
+ * assistant. A platform fetch failure is treated as "no inbox" — we
+ * prefer to under-report than block the entire Contacts page when the
+ * platform is briefly unreachable.
+ */
+async function hasRegisteredInbox(): Promise<boolean> {
+  const client = await VellumPlatformClient.create();
+  if (!client?.platformAssistantId) {
+    return false;
+  }
+
+  try {
+    const response = await client.fetch(
+      `/v1/assistants/${client.platformAssistantId}/email-addresses/`,
+    );
+    if (!response.ok) {
+      return false;
+    }
+    const data = (await response.json()) as EmailAddressListResponse;
+    if (typeof data.count === "number") {
+      return data.count > 0;
+    }
+    return Array.isArray(data.results) && data.results.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function handleGetChannelAvailability(
+  _args: RouteHandlerArgs,
+): Promise<{ channels: ChannelInfo[] }> {
+  const ids: ChannelId[] = [...BASE_AVAILABLE_CHANNELS];
+  if (await hasRegisteredInbox()) {
+    ids.push("email");
+  }
+  // CHANNEL_METADATA is `Partial<Record<ChannelId, ChannelInfo>>` because
+  // unsurfaced channels deliberately have no metadata. `ids` only ever
+  // contains channels that BASE_AVAILABLE_CHANNELS / the email branch
+  // explicitly chose, so the lookup is always defined — filter to satisfy
+  // the type system without a non-null assertion.
+  const channels = ids
+    .map((id) => CHANNEL_METADATA[id])
+    .filter((info): info is ChannelInfo => info !== undefined);
+  return { channels };
+}
+
+const channelInfoSchema = z.object({
+  id: z.enum(CHANNEL_IDS),
+  label: z.string(),
+  subtitle: z.string(),
+  icon: z.string(),
+  supportsVerification: z.boolean(),
+  setupMessages: z.object({
+    guardian: z.string(),
+    contact: z.string(),
+  }),
+});
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "channels_available_get",
+    endpoint: "channels/available",
+    method: "GET",
+    summary: "Get available channels",
+    description:
+      "Return the channels this assistant can surface to clients, with " +
+      "display metadata (label, icon, verification capability, setup " +
+      "copy). Today this is a fixed base list plus `email` when an inbox " +
+      "is registered; will become plugin/skill-driven in future.",
+    tags: ["channels"],
+    requirePolicyEnforcement: true,
+    handler: handleGetChannelAvailability,
+    responseBody: z.object({
+      channels: z
+        .array(channelInfoSchema)
+        .describe("Available channels in display order"),
+    }),
+  },
+];

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

@@ -6,15 +6,18 @@
  * used by the macOS / web clients.
  */
 
+import { v4 as uuid } from "uuid";
 import { z } from "zod";
 
 import { clearAllConversations as clearAllActive } from "../../daemon/handlers/conversations.js";
 import { formatJson, formatMarkdown } from "../../export/formatter.js";
 import {
+  addMessage,
   createConversation,
   getConversation,
   getMessages,
 } from "../../memory/conversation-crud.js";
+import { setConversationKey } from "../../memory/conversation-key-store.js";
 import { listConversations } from "../../memory/conversation-queries.js";
 import { getLogger } from "../../util/logger.js";
 import { BadRequestError, NotFoundError } from "./errors.js";
@@ -45,12 +48,43 @@ function handleListCli({ body = {} }: RouteHandlerArgs) {
 // create (CLI)
 // ---------------------------------------------------------------------------
 
-function handleCreateCli({ body = {} }: RouteHandlerArgs) {
+const seededConversationMessageSchema = z.object({
+  role: z.enum(["user", "assistant"]),
+  content: z.string(),
+});
+
+type SeededConversationMessage = z.infer<
+  typeof seededConversationMessageSchema
+>;
+
+function textContentJson(text: string): string {
+  return JSON.stringify([{ type: "text", text }]);
+}
+
+async function handleCreateCli({ body = {} }: RouteHandlerArgs) {
   const title = body.title as string | undefined;
+  const messages =
+    (body.messages as SeededConversationMessage[] | undefined) ?? [];
+
   const conversation = createConversation(title);
+  const conversationKey = uuid();
+  setConversationKey(conversationKey, conversation.id);
+
+  for (const message of messages) {
+    await addMessage(
+      conversation.id,
+      message.role,
+      textContentJson(message.content),
+      undefined,
+      { skipIndexing: true },
+    );
+  }
+
   return {
     id: conversation.id,
     title: conversation.title ?? "New Conversation",
+    conversationKey,
+    messagesInserted: messages.length,
   };
 }
 
@@ -109,7 +143,10 @@ function handleExportCli({ body = {} }: RouteHandlerArgs) {
 async function handleClearCli(_args: RouteHandlerArgs) {
   // Tear down in-memory conversation state before DB clear.
   const cleared = clearAllActive();
-  log.info({ cleared }, "CLI conversations clear: active conversations torn down");
+  log.info(
+    { cleared },
+    "CLI conversations clear: active conversations torn down",
+  );
   return { cleared };
 }
 
@@ -146,14 +183,18 @@ export const ROUTES: RouteDefinition[] = [
     endpoint: "conversations/cli/create",
     method: "POST",
     summary: "Create a conversation (CLI)",
-    description: "Create a new conversation with an optional title.",
+    description:
+      "Create a new conversation with an optional title and seeded messages.",
     tags: ["conversations"],
     requestBody: z.object({
       title: z.string().optional(),
+      messages: z.array(seededConversationMessageSchema).optional(),
     }),
     responseBody: z.object({
       id: z.string(),
       title: z.string(),
+      conversationKey: z.string(),
+      messagesInserted: z.number().int().nonnegative(),
     }),
     handler: handleCreateCli,
   },

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

@@ -28,12 +28,11 @@ import { getBindingsForConversations } from "../../memory/external-conversation-
 import { listGroups } from "../../memory/group-crud.js";
 import { UserError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
-import { buildAssistantEvent } from "../assistant-event.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
 import {
   buildConversationDetailResponse,
   serializeConversationSummary,
 } from "../services/conversation-serializer.js";
+import { publishConversationListAndMetadataChanged } from "../sync/resource-sync-events.js";
 import {
   BadRequestError,
   InternalError,
@@ -54,22 +53,6 @@ function resolveOrThrow(rawId: string): string {
   return id;
 }
 
-function publishListInvalidated(): void {
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "conversation_list_invalidated",
-        reason: "seen_changed",
-      }),
-    )
-    .catch((err) => {
-      log.warn(
-        { err },
-        "Failed to publish conversation_list_invalidated (seen_changed)",
-      );
-    });
-}
-
 // ---------------------------------------------------------------------------
 // Handlers
 // ---------------------------------------------------------------------------
@@ -159,7 +142,7 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
     });
 
     if (wasUnseen) {
-      publishListInvalidated();
+      publishConversationListAndMetadataChanged("seen_changed", conversationId);
     }
 
     return { ok: true };
@@ -179,7 +162,7 @@ function handleMarkUnread({ body = {} }: RouteHandlerArgs) {
   try {
     const changed = markConversationUnread(conversationId);
     if (changed) {
-      publishListInvalidated();
+      publishConversationListAndMetadataChanged("seen_changed", conversationId);
     }
     return { ok: true };
   } catch (err) {

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

@@ -27,7 +27,6 @@ import {
   switchConversation,
   undoLastMessage,
 } from "../../daemon/handlers/conversations.js";
-import type { ConversationListInvalidatedReason } from "../../daemon/message-types/conversations.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
 import {
   archiveConversation,
@@ -49,9 +48,12 @@ import { enqueueMemoryJob } from "../../memory/jobs-store.js";
 import { deleteSchedule } from "../../schedule/schedule-store.js";
 import { UserError } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
-import { buildAssistantEvent } from "../assistant-event.js";
-import { assistantEventHub } from "../assistant-event-hub.js";
 import { buildConversationDetailResponse } from "../services/conversation-serializer.js";
+import {
+  publishConversationListAndMetadataChanged,
+  publishConversationListChanged,
+  publishConversationTitleChanged,
+} from "../sync/resource-sync-events.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import { setInferenceProfileSession } from "./inference-profile-session-handler.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
@@ -68,24 +70,6 @@ function resolveOrThrow(rawId: string): string {
   return id;
 }
 
-function publishListInvalidated(
-  reason: ConversationListInvalidatedReason,
-): void {
-  assistantEventHub
-    .publish(
-      buildAssistantEvent({
-        type: "conversation_list_invalidated",
-        reason,
-      }),
-    )
-    .catch((err) => {
-      log.warn(
-        { err },
-        `Failed to publish conversation_list_invalidated (${reason})`,
-      );
-    });
-}
-
 function cancelScheduleIfLast(conversationId: string): void {
   const conv = getConversation(conversationId);
   if (
@@ -108,6 +92,7 @@ function handleCreateConversation({ body = {} }: RouteHandlerArgs) {
   });
   if (result.created) {
     updateConversationTitle(result.conversationId, "New Conversation");
+    publishConversationListAndMetadataChanged("created", result.conversationId);
   }
   log.info(
     {
@@ -151,6 +136,7 @@ async function handleForkConversation({ body = {} }: RouteHandlerArgs) {
         `Forked conversation ${forkedConversation.id} could not be loaded`,
       );
     }
+    publishConversationListAndMetadataChanged("created", forkedConversation.id);
     return { conversation: detail.conversation };
   } catch (err) {
     if (err instanceof UserError) {
@@ -217,25 +203,7 @@ function handleRenameConversation({
   }
   updateConversationTitle(pathParams.id!, name, 0);
 
-  assistantEventHub
-    .publish(
-      buildAssistantEvent(
-        {
-          type: "conversation_title_updated",
-          conversationId: pathParams.id!,
-          title: name,
-        },
-        pathParams.id!,
-      ),
-    )
-    .catch((err) => {
-      log.warn(
-        { err, conversationId: pathParams.id },
-        "Failed to publish conversation_title_updated",
-      );
-    });
-
-  publishListInvalidated("renamed");
+  publishConversationTitleChanged(pathParams.id!, name);
 
   return { ok: true };
 }
@@ -249,6 +217,7 @@ function handleClearAllConversations({ headers = {} }: RouteHandlerArgs) {
     );
   }
   clearAllConversations();
+  publishConversationListChanged("deleted");
   return undefined;
 }
 
@@ -279,6 +248,7 @@ function handleWipeConversation({ pathParams = {} }: RouteHandlerArgs) {
     },
     "Wiped conversation and reverted memory changes",
   );
+  publishConversationListAndMetadataChanged("deleted", resolvedId);
   return {
     wiped: true,
     unsupersededItems: 0,
@@ -308,7 +278,7 @@ function handleDeleteConversation({ pathParams = {} }: RouteHandlerArgs) {
   }
   log.info({ conversationId: resolvedId }, "Deleted conversation");
 
-  publishListInvalidated("deleted");
+  publishConversationListAndMetadataChanged("deleted", resolvedId);
 
   return undefined;
 }
@@ -319,6 +289,7 @@ function handleArchiveConversation({ pathParams = {} }: RouteHandlerArgs) {
   if (!archived) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }
+  publishConversationListAndMetadataChanged("reordered", resolvedId);
   return { ok: true, conversationId: resolvedId };
 }
 
@@ -328,6 +299,7 @@ function handleUnarchiveConversation({ pathParams = {} }: RouteHandlerArgs) {
   if (!unarchived) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }
+  publishConversationListAndMetadataChanged("reordered", resolvedId);
   return { ok: true, conversationId: resolvedId };
 }
 
@@ -387,7 +359,10 @@ function handleReorderConversations({ body = {} }: RouteHandlerArgs) {
       groupId: u.groupId,
     })),
   );
-  publishListInvalidated("reordered");
+  publishConversationListAndMetadataChanged(
+    "reordered",
+    updates.map((u) => u.conversationId),
+  );
   return { ok: true };
 }