@vellumai/assistant 0.8.4 → 0.8.6

package/src/home/__tests__/suggested-prompts.test.ts

@@ -1,22 +1,12 @@
-import { describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 // ─── Mocks ─────────────────────────────────────────────────────────────
 
-let mockConnectedProviders = new Set<string>();
-
-mock.module("../../oauth/oauth-store.js", () => ({
-  listProviders: () => [
-    { provider: "google" },
-    { provider: "slack" },
-    { provider: "notion" },
-    { provider: "linear" },
-    { provider: "github" },
-  ],
-}));
+const mockIntegrationSummary = "Gmail ✓ | Slack ✓ | Twilio ✗ | Telegram ✗";
+let mockSidechainText = "";
 
 mock.module("../../schedule/integration-status.js", () => ({
-  isOAuthProviderConnected: async (provider: string) =>
-    mockConnectedProviders.has(provider),
+  formatIntegrationSummary: async () => mockIntegrationSummary,
 }));
 
 mock.module("../../util/logger.js", () => ({
@@ -31,7 +21,7 @@ mock.module("../../config/loader.js", () => ({
 }));
 
 mock.module("../../config/llm-resolver.js", () => ({
-  resolveCallSiteConfig: () => ({ provider: "mock" }),
+  resolveCallSiteConfig: () => ({ provider: "mock", maxTokens: 256 }),
 }));
 
 mock.module("../../providers/provider-send-message.js", () => ({
@@ -51,70 +41,76 @@ mock.module("../../prompts/system-prompt.js", () => ({
 }));
 
 mock.module("../../runtime/btw-sidechain.js", () => ({
-  runBtwSidechain: async () => ({ text: "" }),
+  runBtwSidechain: async () => ({ text: mockSidechainText }),
 }));
 
-const { getSuggestedPrompts } = await import("../suggested-prompts.js");
+mock.module("../../runtime/assistant-event.js", () => ({
+  buildAssistantEvent: (e: unknown) => e,
+}));
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: { publish: async () => {} },
+}));
+
+const {
+  getSuggestedPrompts,
+  refreshAssistantSuggestedPrompts,
+  invalidateAssistantSuggestedPromptsCache,
+} = await import("../suggested-prompts.js");
 
 // ─── Tests ─────────────────────────────────────────────────────────────
 
 describe("getSuggestedPrompts", () => {
-  test("shows 'Connect X' prompts when providers are disconnected", async () => {
-    mockConnectedProviders = new Set();
+  afterEach(() => {
+    invalidateAssistantSuggestedPromptsCache();
+    mockSidechainText = "";
+  });
 
+  test("returns empty array before cache is populated", async () => {
     const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
-
-    expect(ids).toContain("connect-google");
-    expect(ids).toContain("connect-slack");
-    expect(prompts.find((p) => p.id === "connect-google")!.label).toBe(
-      "Connect Gmail",
-    );
+    expect(prompts).toEqual([]);
   });
 
-  test("shows email management prompts when Google is connected", async () => {
-    mockConnectedProviders = new Set(["google"]);
+  test("returns LLM-generated prompts after refresh", async () => {
+    mockSidechainText = JSON.stringify([
+      { label: "Triage my inbox", prompt: "Help me triage my inbox" },
+      { label: "Check meetings", prompt: "What meetings do I have today?" },
+    ]);
 
+    await refreshAssistantSuggestedPrompts();
     const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
-
-    // Should NOT show "Connect Gmail"
-    expect(ids).not.toContain("connect-google");
-
-    // Should show management prompts
-    expect(ids).toContain("manage-google-triage-my-inbox");
-    expect(ids).toContain("manage-google-summarize-today's-emails");
-
-    const triage = prompts.find(
-      (p) => p.id === "manage-google-triage-my-inbox",
-    );
-    expect(triage).toBeDefined();
-    expect(triage!.label).toBe("Triage my inbox");
-    expect(triage!.icon).toBe("mail");
-    expect(triage!.source).toBe("deterministic");
+
+    expect(prompts).toHaveLength(2);
+    expect(prompts[0]!.label).toBe("Triage my inbox");
+    expect(prompts[0]!.source).toBe("assistant");
+    expect(prompts[1]!.label).toBe("Check meetings");
   });
 
-  test("still shows Connect prompts for disconnected providers alongside management prompts", async () => {
-    mockConnectedProviders = new Set(["google"]);
+  test("invalidation clears the cache", async () => {
+    mockSidechainText = JSON.stringify([
+      { label: "Do stuff", prompt: "Do stuff for me" },
+    ]);
 
-    const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
+    await refreshAssistantSuggestedPrompts();
+    expect(await getSuggestedPrompts()).toHaveLength(1);
 
-    // Gmail management prompts
-    expect(ids).toContain("manage-google-triage-my-inbox");
-    // Slack still disconnected
-    expect(ids).toContain("connect-slack");
+    invalidateAssistantSuggestedPromptsCache();
+    expect(await getSuggestedPrompts()).toEqual([]);
   });
 
-  test("providers without connectedPrompts show nothing when connected", async () => {
-    mockConnectedProviders = new Set(["slack"]);
+  test("handles empty LLM response gracefully", async () => {
+    mockSidechainText = "";
 
+    await refreshAssistantSuggestedPrompts();
     const prompts = await getSuggestedPrompts();
-    const ids = prompts.map((p) => p.id);
+    expect(prompts).toEqual([]);
+  });
+
+  test("handles malformed LLM response gracefully", async () => {
+    mockSidechainText = "not valid json at all";
 
-    // No connect prompt since connected
-    expect(ids).not.toContain("connect-slack");
-    // No management prompts since Slack doesn't define any
-    expect(ids.filter((id) => id.startsWith("manage-slack"))).toHaveLength(0);
+    await refreshAssistantSuggestedPrompts();
+    const prompts = await getSuggestedPrompts();
+    expect(prompts).toEqual([]);
   });
 });

package/src/home/feed-writer.ts

@@ -44,6 +44,7 @@ import { getDataDir } from "../util/platform.js";
 import {
   type FeedItem,
   type FeedItemStatus,
+  type FeedItemUrgency,
   type HomeFeedFile,
   parseFeedFile,
 } from "./feed-types.js";
@@ -155,6 +156,72 @@ export async function patchFeedItemStatus(
   return resultPromise;
 }
 
+/**
+ * Patch the user-editable copy fields on a single feed item by id.
+ *
+ * Returns the updated `FeedItem`, or `null` if no item with the given
+ * id exists. Used by the `assistant notifications edit` flow. Patches
+ * are applied inside the same coalescing queue as appends and status
+ * patches so overlapping writes don't race.
+ *
+ * Only fields explicitly present on `patch` are touched. Pass an empty
+ * object and the call is a no-op that returns the existing item (or
+ * `null` if the id isn't on disk).
+ */
+export interface FeedItemContentPatch {
+  title?: string;
+  summary?: string;
+  urgency?: FeedItemUrgency;
+  status?: FeedItemStatus;
+}
+
+export async function patchFeedItemContent(
+  id: string,
+  patch: FeedItemContentPatch,
+): Promise<FeedItem | null> {
+  let resolveResult!: (value: FeedItem | null) => void;
+  const resultPromise = new Promise<FeedItem | null>((resolve) => {
+    resolveResult = resolve;
+  });
+  pendingContentPatches.push({ id, patch, resolve: resolveResult });
+  void scheduleWrite();
+  return resultPromise;
+}
+
+/**
+ * Remove the `conversationId` field from all feed items that reference
+ * the given conversation. Returns the number of items modified.
+ *
+ * This is the daemon-side cleanup path invoked when a conversation is
+ * deleted — it prevents "Go to Thread" buttons from linking to a
+ * conversation that no longer exists. Goes through the same coalescing
+ * queue as appends and patches so there are no file-I/O races.
+ */
+export async function stripConversationIds(
+  conversationId: string,
+): Promise<number> {
+  let resolveResult!: (count: number) => void;
+  const resultPromise = new Promise<number>((resolve) => {
+    resolveResult = resolve;
+  });
+  pendingStrips.push({ conversationId, resolve: resolveResult });
+  void scheduleWrite();
+  return resultPromise;
+}
+
+/**
+ * Remove the `conversationId` field from ALL feed items that have one.
+ * Returns the number of items modified.
+ *
+ * Used by the clear-all-conversations flow to bulk-invalidate every
+ * "Go to Thread" link at once. Uses the same coalescing queue with a
+ * `"*"` sentinel that the strip loop in `runWrite` treats as "match
+ * all items with a conversationId".
+ */
+export async function clearAllConversationIds(): Promise<number> {
+  return stripConversationIds("*");
+}
+
 // ─── Internal: coalescing queue ────────────────────────────────────────
 
 /**
@@ -168,6 +235,15 @@ const pendingPatches: Array<{
   status: FeedItemStatus;
   resolve: (value: FeedItem | null) => void;
 }> = [];
+const pendingContentPatches: Array<{
+  id: string;
+  patch: FeedItemContentPatch;
+  resolve: (value: FeedItem | null) => void;
+}> = [];
+const pendingStrips: Array<{
+  conversationId: string;
+  resolve: (count: number) => void;
+}> = [];
 
 let writeInFlight: Promise<void> | null = null;
 let writeDirty = false;
@@ -206,6 +282,11 @@ function scheduleWrite(): Promise<void> {
 async function runWrite(): Promise<void> {
   const appendsToApply = pendingAppends.splice(0, pendingAppends.length);
   const patchesToApply = pendingPatches.splice(0, pendingPatches.length);
+  const contentPatchesToApply = pendingContentPatches.splice(
+    0,
+    pendingContentPatches.length,
+  );
+  const stripsToApply = pendingStrips.splice(0, pendingStrips.length);
 
   const current = readHomeFeed();
   let items = current.items.slice();
@@ -233,6 +314,57 @@ async function runWrite(): Promise<void> {
     patchResults.push({ resolve: patch.resolve, value: updated });
   }
 
+  const contentPatchResults: Array<{
+    resolve: (v: FeedItem | null) => void;
+    value: FeedItem | null;
+  }> = [];
+  for (const { id, patch, resolve } of contentPatchesToApply) {
+    const idx = items.findIndex((i) => i.id === id);
+    if (idx === -1) {
+      contentPatchResults.push({ resolve, value: null });
+      continue;
+    }
+    const existing = items[idx]!;
+    const updated: FeedItem = { ...existing };
+    if (patch.title !== undefined) {
+      const trimmed = patch.title.trim();
+      if (trimmed.length === 0) {
+        delete updated.title;
+      } else {
+        updated.title = trimmed;
+      }
+    }
+    if (patch.summary !== undefined) {
+      updated.summary = patch.summary;
+    }
+    if (patch.urgency !== undefined) {
+      updated.urgency = patch.urgency;
+    }
+    if (patch.status !== undefined) {
+      updated.status = patch.status;
+    }
+    items[idx] = updated;
+    contentPatchResults.push({ resolve, value: updated });
+  }
+
+  // Strip conversationId from matching items.
+  const stripResults: Array<{
+    resolve: (count: number) => void;
+    count: number;
+  }> = [];
+  for (const strip of stripsToApply) {
+    let count = 0;
+    for (let i = 0; i < items.length; i++) {
+      const matchAll = strip.conversationId === "*";
+      const matchOne = items[i]!.conversationId === strip.conversationId;
+      if (matchAll ? items[i]!.conversationId != null : matchOne) {
+        items[i] = { ...items[i]!, conversationId: undefined };
+        count++;
+      }
+    }
+    stripResults.push({ resolve: strip.resolve, count });
+  }
+
   items.sort(compareFeedItems);
 
   const updatedAt = new Date().toISOString();
@@ -258,17 +390,24 @@ async function runWrite(): Promise<void> {
     publishHomeFeedUpdated(updatedAt, newItemCount);
   }
 
-  // Resolve pending patch promises AFTER we've emitted the SSE event
-  // so callers awaiting `patchFeedItemStatus` observe a fully
-  // consistent world: the on-disk file, the SSE event, and the
-  // returned `FeedItem` all reflect the same write.
+  // Resolve pending patch and strip promises AFTER we've emitted the
+  // SSE event so callers awaiting `patchFeedItemStatus` or
+  // `stripConversationIds` observe a fully consistent world: the
+  // on-disk file, the SSE event, and the returned value all reflect
+  // the same write.
   //
-  // If the write failed, resolve all patch promises with `null` — the
-  // state was not persisted, and callers (e.g. HTTP route handlers)
-  // must not report success when the underlying write failed.
+  // If the write failed, resolve patch promises with `null` and strip
+  // promises with `0` — the state was not persisted, and callers must
+  // not report success when the underlying write failed.
   for (const { resolve, value } of patchResults) {
     resolve(wrote ? value : null);
   }
+  for (const { resolve, value } of contentPatchResults) {
+    resolve(wrote ? value : null);
+  }
+  for (const { resolve, count } of stripResults) {
+    resolve(wrote ? count : 0);
+  }
 }
 
 /**

package/src/home/home-greeting.ts

@@ -13,7 +13,6 @@
 
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
-import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import { runBtwSidechain } from "../runtime/btw-sidechain.js";
@@ -56,17 +55,9 @@ export async function refreshPersonalizedGreeting(): Promise<void> {
       return;
     }
 
-    const { userPersona, userSlug, channelPersona } = resolvePersonaContext(
-      undefined,
-      undefined,
-    );
-
     const systemPrompt = buildSystemPrompt({
       excludeBootstrap: true,
       excludeCustomPrefix: true,
-      userPersona,
-      channelPersona,
-      userSlug,
     });
 
     const result = await runBtwSidechain({

package/src/home/suggested-prompts.ts

@@ -2,88 +2,25 @@
  * Suggested prompt producer for the Home feed.
  *
  * Returns an array of `SuggestedPrompt` items shown at the top of the
- * Home page as conversation starters (e.g. "Connect Gmail", "Add Slack").
- *
- * Two sources of prompts:
- *   - **Deterministic** — derived from missing OAuth connections.
- *     Computed inline (read-only, safe for GET).
- *   - **Assistant-generated** — contextual suggestions from the LLM
- *     based on what's relevant to the user. Read from an in-memory
- *     cache in the GET path; generation runs in the background via
- *     `refreshAssistantSuggestedPrompts`.
+ * Home page as conversation starters. All prompts are generated by the
+ * assistant based on the user's connected services and context —
+ * read from an in-memory cache in the GET path; generation runs in
+ * the background via `refreshAssistantSuggestedPrompts`.
  */
 
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
-import { listProviders } from "../oauth/oauth-store.js";
-import { resolvePersonaContext } from "../prompts/persona-resolver.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import { getConfiguredProvider } from "../providers/provider-send-message.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { runBtwSidechain } from "../runtime/btw-sidechain.js";
-import { isOAuthProviderConnected } from "../schedule/integration-status.js";
+import { formatIntegrationSummary } from "../schedule/integration-status.js";
 import { getLogger } from "../util/logger.js";
 import type { SuggestedPrompt } from "./feed-types.js";
 
 const log = getLogger("suggested-prompts");
 
-/**
- * Map of provider keys to their suggested-prompt metadata. Only providers
- * listed here produce deterministic "Connect X" prompts when disconnected.
- * The icon values are VIcon case names rendered by the macOS client.
- */
-interface PromptEntry {
-  label: string;
-  prompt: string;
-  icon: string;
-}
-
-const CONNECT_PROMPT_META: Record<
-  string,
-  PromptEntry & { connectedPrompts?: PromptEntry[] }
-> = {
-  google: {
-    label: "Connect Gmail",
-    prompt: "Help me connect my Gmail account",
-    icon: "mail",
-    connectedPrompts: [
-      {
-        label: "Triage my inbox",
-        prompt:
-          "Help me triage my inbox — summarize what's unread and flag anything that needs a reply",
-        icon: "mail",
-      },
-      {
-        label: "Summarize today's emails",
-        prompt:
-          "Summarize the emails I received today and highlight anything important",
-        icon: "mail",
-      },
-    ],
-  },
-  slack: {
-    label: "Connect Slack",
-    prompt: "Help me connect my Slack workspace",
-    icon: "hash",
-  },
-  notion: {
-    label: "Connect Notion",
-    prompt: "Help me connect my Notion workspace",
-    icon: "fileText",
-  },
-  linear: {
-    label: "Connect Linear",
-    prompt: "Help me connect my Linear workspace",
-    icon: "clipboardList",
-  },
-  github: {
-    label: "Connect GitHub",
-    prompt: "Help me connect my GitHub account",
-    icon: "terminal",
-  },
-};
-
 const LLM_SUGGESTIONS_TIMEOUT_MS = 5_000;
 const LLM_CACHE_TTL_MS = 30 * 60 * 1000; // 30 minutes
 
@@ -95,37 +32,23 @@ let cachedLLMPrompts: SuggestedPrompt[] = [];
 let cachedLLMPromptsAt = 0;
 
 /**
- * Produce suggested prompts from both deterministic and cached LLM sources.
- * Deterministic prompts always come first; cached LLM-generated prompts are
- * appended when available. No LLM calls happen in this path — safe for GET.
+ * Return cached assistant-generated prompts. No LLM calls happen in
+ * this path — safe for GET. Returns an empty array until the first
+ * background refresh populates the cache.
  */
 export async function getSuggestedPrompts(): Promise<SuggestedPrompt[]> {
-  const prompts: SuggestedPrompt[] = [];
-
-  let deterministicPrompts: SuggestedPrompt[] = [];
-  try {
-    deterministicPrompts = await getDeterministicPrompts();
-    prompts.push(...deterministicPrompts);
-  } catch (err) {
-    log.warn({ err }, "Failed to compute deterministic suggested prompts");
-  }
-
   if (Date.now() - cachedLLMPromptsAt < LLM_CACHE_TTL_MS) {
-    prompts.push(...cachedLLMPrompts);
+    return [...cachedLLMPrompts];
   }
-
-  return prompts;
+  return [];
 }
 
 /**
- * Drops the in-memory LLM suggestion cache so the next call to
- * `getSuggestedPrompts()` returns only the fresh deterministic list (and
- * a follow-up background refresh repopulates the LLM half).
+ * Drops the in-memory suggestion cache so the next background refresh
+ * regenerates prompts with current integration state.
  *
- * Called from OAuth connect/disconnect paths so a freshly-connected
- * provider stops surfacing as a "Connect X" pill within one reload — the
- * 30-minute TTL would otherwise pin a stale suggestion until the next
- * periodic refresh.
+ * Called from OAuth connect/disconnect paths so suggestions reflect the
+ * new state within one reload instead of waiting for the 30-minute TTL.
  */
 export function invalidateAssistantSuggestedPromptsCache(): void {
   cachedLLMPrompts = [];
@@ -157,8 +80,7 @@ export async function refreshAssistantSuggestedPrompts(): Promise<void> {
   }
 
   try {
-    const deterministicPrompts = await getDeterministicPrompts();
-    const llmPrompts = await generateAssistantPrompts(deterministicPrompts);
+    const llmPrompts = await generateAssistantPrompts();
     cachedLLMPrompts = llmPrompts;
     cachedLLMPromptsAt = Date.now();
   } catch (err) {
@@ -166,49 +88,6 @@ export async function refreshAssistantSuggestedPrompts(): Promise<void> {
   }
 }
 
-/**
- * Check which well-known OAuth providers are not connected and return
- * a "Connect X" prompt for each. For connected providers that have
- * `connectedPrompts`, return those instead so users discover ongoing
- * management capabilities.
- */
-async function getDeterministicPrompts(): Promise<SuggestedPrompt[]> {
-  const providers = listProviders();
-  const prompts: SuggestedPrompt[] = [];
-
-  for (const provider of providers) {
-    const meta = CONNECT_PROMPT_META[provider.provider];
-    if (!meta) continue;
-
-    const connected = await isOAuthProviderConnected(provider.provider);
-
-    if (!connected) {
-      prompts.push({
-        id: `connect-${provider.provider}`,
-        label: meta.label,
-        icon: meta.icon,
-        prompt: meta.prompt,
-        source: "deterministic",
-      });
-      continue;
-    }
-
-    if (meta.connectedPrompts) {
-      for (const cp of meta.connectedPrompts) {
-        prompts.push({
-          id: `manage-${provider.provider}-${cp.label.toLowerCase().replace(/\s+/g, "-")}`,
-          label: cp.label,
-          icon: cp.icon,
-          prompt: cp.prompt,
-          source: "deterministic",
-        });
-      }
-    }
-  }
-
-  return prompts;
-}
-
 // ---------------------------------------------------------------------------
 // LLM-generated suggestions
 // ---------------------------------------------------------------------------
@@ -221,11 +100,9 @@ interface LLMSuggestion {
 /**
  * Ask the LLM to generate contextual conversation-starter suggestions
  * based on the assistant's persona and the user's connected services.
- * Returns an empty array on failure so deterministic prompts still show.
+ * Returns an empty array on failure.
  */
-async function generateAssistantPrompts(
-  deterministicPrompts: SuggestedPrompt[],
-): Promise<SuggestedPrompt[]> {
+async function generateAssistantPrompts(): Promise<SuggestedPrompt[]> {
   const config = getConfig();
   const resolved = resolveCallSiteConfig("homeSuggestedPrompts", config.llm);
 
@@ -234,30 +111,26 @@ async function generateAssistantPrompts(
     return [];
   }
 
-  const { userPersona, userSlug, channelPersona } = resolvePersonaContext(
-    undefined,
-    undefined,
-  );
-
   const systemPrompt = buildSystemPrompt({
     excludeBootstrap: true,
     excludeCustomPrefix: true,
-    userPersona,
-    channelPersona,
-    userSlug,
   });
 
-  const existingLabels = deterministicPrompts.map((p) => p.label).join(", ");
-  const contextNote = existingLabels
-    ? `The user already has these suggestions: ${existingLabels}. Do NOT duplicate them.`
-    : "";
+  let integrationContext = "";
+  try {
+    integrationContext = `\nConnected integrations: ${await formatIntegrationSummary()}`;
+  } catch {
+    // Best-effort — continue without integration info
+  }
 
   const result = await runBtwSidechain({
     content:
       "Suggest 2-3 short, actionable conversation starters for the home page. " +
       "Each should be something specific and helpful you can do for the user right now. " +
-      `${contextNote} ` +
-      'Return ONLY a JSON array of objects with "label" (max 5 words) and "prompt" (the full message to send). ' +
+      "Focus on things the user's connected services enable — don't suggest connecting services they already have. " +
+      "You may suggest connecting a service only if it's not yet connected and would be genuinely useful." +
+      integrationContext +
+      ' Return ONLY a JSON array of objects with "label" (max 5 words) and "prompt" (the full message to send). ' +
       "No markdown fences, no explanation.",
     provider,
     systemPrompt,

package/src/ipc/__tests__/cli-ipc.test.ts

@@ -37,6 +37,7 @@ mock.module("../../runtime/agent-wake.js", () => ({
 
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversation: (id: string) => ({ id, createdAt: Date.now() }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // ---------------------------------------------------------------------------

package/src/ipc/gateway-client.test.ts

@@ -108,7 +108,10 @@ describe("ipcGetFeatureFlags", () => {
   });
 
   test("returns empty record when IPC returns undefined", async () => {
-    // No mock configured — ipcCall returns undefined
+    // Explicitly suppress the mock's default `get_feature_flags` sentinel
+    // (which exists to short-circuit `initFeatureFlagOverrides()`'s retry
+    // loop) so this test exercises the underlying-undefined path.
+    mockGatewayIpc(null, { results: { get_feature_flags: undefined } });
     const flags = await ipcGetFeatureFlags();
     expect(flags).toEqual({});
   });