@vellumai/assistant 0.8.5 → 0.8.7

package/src/home/suggested-prompts.ts

@@ -2,87 +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 { 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
 
@@ -94,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 = [];
@@ -156,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) {
@@ -165,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
 // ---------------------------------------------------------------------------
@@ -220,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);
 
@@ -238,17 +116,21 @@ async function generateAssistantPrompts(
     excludeCustomPrefix: true,
   });
 
-  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/__tests__/email-ipc.test.ts

@@ -16,15 +16,6 @@ import { afterEach, beforeEach, expect, mock, test } from "bun:test";
 import { runAssistantCommandFull } from "../../cli/__tests__/run-assistant-command.js";
 import { AssistantIpcServer } from "../assistant-server.js";
 
-// ---------------------------------------------------------------------------
-// Enable the email-channel feature flag so the email command is registered
-// in the CLI program (defaultEnabled is false in the registry).
-// ---------------------------------------------------------------------------
-
-mock.module("../../email/feature-gate.js", () => ({
-  isEmailEnabled: () => true,
-}));
-
 // ---------------------------------------------------------------------------
 // Mock state — set up a controllable VellumPlatformClient at module boundary
 // ---------------------------------------------------------------------------

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({});
   });

package/src/ipc/routes/__tests__/route-adapter.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Tests for `routeDefinitionsToIpcMethods`: filtering eligibility,
+ * meta-route emission, and — critically — policy serialization.
+ *
+ * Policy serialization is what the gateway IPC proxy depends on to
+ * enforce scope/principal checks without maintaining its own table
+ * (ATL-315). If the daemon's resolution drifts from what the HTTP path
+ * actually enforces, IPC and HTTP diverge silently.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { z } from "zod";
+
+import type { RouteDefinition } from "../../../runtime/routes/types.js";
+import { routeDefinitionsToIpcMethods } from "../route-adapter.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function noopHandler() {
+  return {};
+}
+
+function defineRoute(overrides: Partial<RouteDefinition>): RouteDefinition {
+  return {
+    operationId: "test_route",
+    endpoint: "test",
+    method: "GET",
+    handler: noopHandler,
+    policy: null,
+    ...overrides,
+  };
+}
+
+interface SchemaEntry {
+  operationId: string;
+  endpoint: string;
+  method: string;
+  policy: {
+    requiredScopes: string[];
+    allowedPrincipalTypes: string[];
+  } | null;
+}
+
+async function getSchema(routes: RouteDefinition[]): Promise<SchemaEntry[]> {
+  const ipcMethods = routeDefinitionsToIpcMethods(routes);
+  const meta = ipcMethods.find((r) => r.operationId === "get_route_schema");
+  expect(meta).toBeDefined();
+  const result = await meta!.handler({});
+  return result as SchemaEntry[];
+}
+
+// ---------------------------------------------------------------------------
+// Eligibility filter
+// ---------------------------------------------------------------------------
+
+describe("routeDefinitionsToIpcMethods — eligibility", () => {
+  test("excludes routes that requireGuardian", () => {
+    const routes: RouteDefinition[] = [
+      defineRoute({ operationId: "ok", endpoint: "ok" }),
+      defineRoute({
+        operationId: "guarded",
+        endpoint: "guarded",
+        requireGuardian: true,
+      }),
+    ];
+    const result = routeDefinitionsToIpcMethods(routes);
+    const ids = result
+      .map((r) => r.operationId)
+      .filter((id) => id !== "get_route_schema");
+    expect(ids).toEqual(["ok"]);
+  });
+
+  test("excludes routes that are public", () => {
+    const routes: RouteDefinition[] = [
+      defineRoute({ operationId: "ok", endpoint: "ok" }),
+      defineRoute({
+        operationId: "pub",
+        endpoint: "pub",
+        isPublic: true,
+      }),
+    ];
+    const result = routeDefinitionsToIpcMethods(routes);
+    const ids = result
+      .map((r) => r.operationId)
+      .filter((id) => id !== "get_route_schema");
+    expect(ids).toEqual(["ok"]);
+  });
+
+  test("appends the get_route_schema meta-route", () => {
+    const routes: RouteDefinition[] = [defineRoute({})];
+    const result = routeDefinitionsToIpcMethods(routes);
+    expect(
+      result.find((r) => r.operationId === "get_route_schema"),
+    ).toBeDefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Schema serialization
+// ---------------------------------------------------------------------------
+
+describe("routeDefinitionsToIpcMethods — schema shape", () => {
+  test("schema entry has operationId / endpoint / method / policy fields", async () => {
+    const routes: RouteDefinition[] = [
+      defineRoute({ operationId: "a", endpoint: "a", method: "POST" }),
+    ];
+    const schema = await getSchema(routes);
+    expect(schema).toHaveLength(1);
+    expect(schema[0]).toEqual({
+      operationId: "a",
+      endpoint: "a",
+      method: "POST",
+      policy: null,
+    });
+  });
+
+  test("schema validates against the wire-shape Zod schema (gateway contract)", async () => {
+    // The gateway's `route-schema-cache.ts` parses the schema with this
+    // exact shape (Zod). If the daemon ever drifts (e.g. drops `policy`),
+    // this test fails — preventing the silent fail-open class of bug
+    // ATL-315 set out to fix.
+    const entrySchema = z.object({
+      operationId: z.string(),
+      endpoint: z.string(),
+      method: z.string(),
+      policy: z
+        .object({
+          requiredScopes: z.array(z.string()),
+          allowedPrincipalTypes: z.array(z.string()),
+        })
+        .nullable(),
+    });
+
+    const routes: RouteDefinition[] = [
+      defineRoute({ operationId: "a", endpoint: "a/:id" }),
+      defineRoute({ operationId: "b", endpoint: "b", method: "POST" }),
+    ];
+    const schema = await getSchema(routes);
+    for (const entry of schema) {
+      const parsed = entrySchema.safeParse(entry);
+      expect(parsed.success).toBe(true);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Policy resolution — the load-bearing piece
+// ---------------------------------------------------------------------------
+
+describe("routeDefinitionsToIpcMethods — policy serialization", () => {
+  test("routes with policy: null ship policy: null", async () => {
+    // Unprotected route (e.g. health endpoint) carries policy: null
+    // and the adapter passes it through unchanged.
+    const routes: RouteDefinition[] = [
+      defineRoute({
+        operationId: "z",
+        endpoint: "unprotected_endpoint",
+        policy: null,
+      }),
+    ];
+    const schema = await getSchema(routes);
+    expect(schema[0].policy).toBeNull();
+  });
+
+  test("routes with declared policy ship it verbatim", async () => {
+    // The adapter is now a straight pass-through: whatever policy the
+    // RouteDefinition declares, the wire schema reflects.
+    const routes: RouteDefinition[] = [
+      defineRoute({
+        operationId: "m_get",
+        endpoint: "messages",
+        method: "GET",
+        policy: {
+          requiredScopes: ["chat.read"],
+          allowedPrincipalTypes: [
+            "actor",
+            "svc_gateway",
+            "svc_daemon",
+            "local",
+          ],
+        },
+      }),
+      defineRoute({
+        operationId: "m_post",
+        endpoint: "messages",
+        method: "POST",
+        policy: {
+          requiredScopes: ["chat.write"],
+          allowedPrincipalTypes: [
+            "actor",
+            "svc_gateway",
+            "svc_daemon",
+            "local",
+          ],
+        },
+      }),
+    ];
+    const schema = await getSchema(routes);
+    expect(schema[0].policy?.requiredScopes).toEqual(["chat.read"]);
+    expect(schema[1].policy?.requiredScopes).toEqual(["chat.write"]);
+  });
+
+  test("schema is a structural pass-through (no derivation, no lookup)", async () => {
+    // Sibling routes with the same endpoint+different policy don't
+    // collide — each route's own .policy is used verbatim, exactly
+    // the property-on-entity guarantee ATL-315's followup buys us.
+    const routes: RouteDefinition[] = [
+      defineRoute({
+        operationId: "plugins_install",
+        endpoint: "plugins/:name",
+        method: "POST",
+        policy: {
+          requiredScopes: ["settings.write"],
+          allowedPrincipalTypes: [
+            "actor",
+            "svc_gateway",
+            "svc_daemon",
+            "local",
+          ],
+        },
+      }),
+      defineRoute({
+        operationId: "plugins_uninstall",
+        endpoint: "plugins/:name",
+        method: "DELETE",
+        policy: {
+          requiredScopes: ["settings.write"],
+          allowedPrincipalTypes: [
+            "actor",
+            "svc_gateway",
+            "svc_daemon",
+            "local",
+          ],
+        },
+      }),
+    ];
+    const schema = await getSchema(routes);
+    expect(schema[0].policy?.requiredScopes).toEqual(["settings.write"]);
+    expect(schema[1].policy?.requiredScopes).toEqual(["settings.write"]);
+  });
+});

package/src/ipc/routes/route-adapter.ts

@@ -1,6 +1,11 @@
 /**
  * Filters the ROUTES array down to IPC-eligible routes and appends the
  * meta-route used by the gateway for IPC proxy discovery.
+ *
+ * The schema includes each route's policy verbatim — the gateway's
+ * IPC proxy enforces equivalent scope/principal checks without
+ * maintaining a parallel table. The policy is a property of each
+ * RouteDefinition; no lookup or derivation happens here.
  */
 
 import type { RouteDefinition } from "../../runtime/routes/types.js";
@@ -9,6 +14,41 @@ function isIpcEligible(r: RouteDefinition): boolean {
   return !r.requireGuardian && !r.isPublic;
 }
 
+/**
+ * Wire-shape entry returned by `get_route_schema`. Matches the gateway's
+ * `RouteSchemaEntry` (see `gateway/src/ipc/route-schema-cache.ts`).
+ *
+ * `policy: null` means the daemon has explicitly registered the route as
+ * unprotected (e.g. health, debug). The gateway respects that and
+ * skips enforcement. `policy: { ... }` carries the same scopes /
+ * principal types the daemon's HTTP path enforces via `enforcePolicy()`.
+ */
+interface IpcRouteSchemaEntry {
+  operationId: string;
+  endpoint: string;
+  method: string;
+  policy: {
+    requiredScopes: string[];
+    allowedPrincipalTypes: string[];
+  } | null;
+}
+
+function toSchemaEntry(r: RouteDefinition): IpcRouteSchemaEntry {
+  return {
+    operationId: r.operationId,
+    endpoint: r.endpoint,
+    method: r.method,
+    policy: r.policy
+      ? {
+          // Spread into mutable string[] for serialization — the wire
+          // shape doesn't carry the `Scope` / `PrincipalType` narrowing.
+          requiredScopes: [...r.policy.requiredScopes],
+          allowedPrincipalTypes: [...r.policy.allowedPrincipalTypes],
+        }
+      : null,
+  };
+}
+
 export function routeDefinitionsToIpcMethods(
   routes: RouteDefinition[],
 ): RouteDefinition[] {
@@ -20,12 +60,11 @@ export function routeDefinitionsToIpcMethods(
     operationId: "get_route_schema",
     method: "GET",
     endpoint: "_internal/route-schema",
-    handler: async () =>
-      eligible.map((r) => ({
-        operationId: r.operationId,
-        endpoint: r.endpoint,
-        method: r.method,
-      })),
+    // The IPC route schema endpoint is the gateway's bootstrap call —
+    // it runs before any policy table is in scope and has no actor
+    // scopes attached. Explicitly unprotected.
+    policy: null,
+    handler: async () => eligible.map(toSchemaEntry),
   };
 
   return [...eligible, metaRoute];

package/src/ipc/skill-routes/__tests__/memory.test.ts

@@ -18,12 +18,16 @@ const addMessageSpy = mock(
     _conversationId: string,
     _role: string,
     _content: string,
-    _metadata?: Record<string, unknown>,
-    _opts?: { skipIndexing?: boolean },
+    _options?: {
+      metadata?: Record<string, unknown>;
+      skipIndexing?: boolean;
+      clientMessageId?: string;
+    },
   ) => ({ id: "msg-xyz", createdAt: 123 }),
 );
 mock.module("../../../memory/conversation-crud.js", () => ({
   addMessage: addMessageSpy,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const wakeAgentSpy = mock(
@@ -62,13 +66,13 @@ describe("memorySkillRoutes registry", () => {
 });
 
 describe("host.memory.addMessage", () => {
-  test("forwards all positional args to addMessage and returns its result", async () => {
+  test("forwards all fields to addMessage as options object and returns its result", async () => {
     const result = await memoryAddMessageRoute.handler({
       conversationId: "conv-1",
       role: "user",
       content: "hello",
       metadata: { foo: "bar" },
-      opts: { skipIndexing: true },
+      skipIndexing: true,
     });
 
     expect(addMessageSpy).toHaveBeenCalledTimes(1);
@@ -76,12 +80,15 @@ describe("host.memory.addMessage", () => {
     expect(call[0]).toBe("conv-1");
     expect(call[1]).toBe("user");
     expect(call[2]).toBe("hello");
-    expect(call[3]).toEqual({ foo: "bar" });
-    expect(call[4]).toEqual({ skipIndexing: true });
+    expect(call[3]).toEqual({
+      metadata: { foo: "bar" },
+      skipIndexing: true,
+      clientMessageId: undefined,
+    });
     expect(result).toEqual({ id: "msg-xyz", createdAt: 123 });
   });
 
-  test("accepts omitted metadata + opts", async () => {
+  test("accepts omitted optional fields", async () => {
     await memoryAddMessageRoute.handler({
       conversationId: "conv-2",
       role: "assistant",
@@ -90,8 +97,11 @@ describe("host.memory.addMessage", () => {
 
     expect(addMessageSpy).toHaveBeenCalledTimes(1);
     const call = addMessageSpy.mock.calls[0];
-    expect(call[3]).toBeUndefined();
-    expect(call[4]).toBeUndefined();
+    expect(call[3]).toEqual({
+      metadata: undefined,
+      skipIndexing: undefined,
+      clientMessageId: undefined,
+    });
   });
 
   test("rejects missing conversationId", async () => {