@vellumai/assistant 0.8.6 → 0.8.7

package/src/home/feed-types.ts

@@ -1,17 +1,18 @@
 /**
  * Home activity feed data contract.
  *
- * Defines the shape of `FeedItem`s shown in the macOS Home page feed
- * section plus the on-disk file format written by the daemon feed
- * writer (PR 5) and served by the daemon HTTP route (PR 6).
+ * The feed-item and suggested-prompt wire shapes are owned by the
+ * canonical `@vellumai/assistant-api` package (`api/responses/home.ts`)
+ * so the daemon route handlers, the OpenAPI generator, and external
+ * clients all derive from one source. This module re-exports those
+ * shapes for daemon-internal consumers and adds the on-disk file format
+ * (`HomeFeedFile`) that composes them — a daemon-only persistence
+ * concern that never crosses the wire.
  *
- * The TDD contract field originally named `ttl` is renamed internally
- * to `expiresAt` — it is an absolute ISO-8601 timestamp, not a
- * duration. Absolute timestamps match the `timestamp` and `createdAt`
- * fields and make stateless read-time expiry filtering trivial. If we
- * ever need to expose `ttl` on a public wire format again we can add
- * a translation layer at the route boundary; within the daemon, all
- * internal types use `expiresAt`.
+ * The TDD contract field originally named `ttl` is surfaced as
+ * `expiresAt` — an absolute ISO-8601 timestamp, not a duration. Absolute
+ * timestamps match the `timestamp` and `createdAt` fields and make
+ * stateless read-time expiry filtering trivial.
  *
  * **v2 schema collapse** — feed items now have a single `notification`
  * type. The legacy `nudge | digest | action | thread` distinctions
@@ -19,240 +20,54 @@
  * them) have been removed; everything that lands in the home feed is
  * a notification, with the writer's only merge rule being "same `id`
  * replaces in place, otherwise append". Workspace migration
- * `061-home-feed-notification-only` rewrites pre-v2 files on first
- * boot.
- *
- * A structurally compatible Swift mirror lives at
- * `clients/shared/Network/FeedItem.swift` (PR 3). Any change here
- * must be mirrored there.
+ * `079-home-feed-notification-only` rewrites pre-v2 files on first boot.
  */
 
 import { z } from "zod";
 
-/** High-level kind of feed item — drives which Swift view renders it. */
-export type FeedItemType = "notification";
-
-/** User-facing lifecycle of a feed item. */
-export type FeedItemStatus = "new" | "seen" | "acted_on" | "dismissed";
-
-/** Visual urgency treatment — controls badge color independently of sort priority. */
-export type FeedItemUrgency = "low" | "medium" | "high" | "critical";
-
-/** Broad category for grouping and filtering feed items. */
-export type FeedItemCategory =
-  | "security"
-  | "scheduling"
-  | "background"
-  | "email"
-  | "system";
-
-/**
- * A single action button attached to a feed item.
- *
- * `prompt` is the pre-seeded user message the action sends to the
- * assistant when triggered — the HTTP route (PR 6) creates a new
- * conversation with this prompt as the first user turn.
- */
-export interface FeedAction {
-  id: string;
-  label: string;
-  prompt: string;
-}
-
-/** Which detail panel the macOS client should open for this feed item. */
-export type FeedItemDetailPanelKind =
-  | "emailDraft"
-  | "documentPreview"
-  | "permissionChat"
-  | "paymentAuth"
-  | "toolPermission"
-  | "updatesList";
-
-/** Server-driven detail panel descriptor attached to a feed item. */
-export interface FeedItemDetailPanel {
-  kind: FeedItemDetailPanelKind;
-}
-
-/**
- * A single item rendered in the Home feed.
- *
- * Mirrors the TDD contract plus one internal-only field:
- *   - `createdAt` — when the writer recorded the item (distinct from
- *                   `timestamp`, which is the event time). Used for
- *                   TTL sweeps and stable ordering.
- *
- * The TDD's `ttl` field is renamed to `expiresAt` here; see the
- * module comment above for the rationale.
- */
-export interface FeedItem {
-  id: string;
-  type: FeedItemType;
-  /** Integer in [0, 100]; higher values sort earlier. */
-  priority: number;
-  /**
-   * Optional short header. Omit when the source did not supply one — the
-   * notification pipeline never manufactures a title from rendered copy
-   * (LLM-echoed bodies stutter against `summary`). Clients fall back to
-   * `summary` when rendering a row.
-   */
-  title?: string;
-  summary: string;
-  /** Event time (ISO-8601). */
-  timestamp: string;
-  /** Defaults to `"new"` at parse time. */
-  status: FeedItemStatus;
-  /** Absolute ISO-8601 expiry timestamp (renamed from TDD `ttl`). */
-  expiresAt?: string;
-  actions?: FeedAction[];
-  /** Visual urgency treatment — controls badge color independently of sort priority. */
-  urgency?: FeedItemUrgency;
-  /**
-   * Source conversation that emitted this notification, when known. Used by
-   * the "Go to Thread" affordance in the detail panel. Omitted when the
-   * source context is not a navigable conversation (scheduler job ids,
-   * watcher event ids, CLI tool-call ids).
-   */
-  conversationId?: string;
-  /** Server-driven detail panel descriptor; when present, the client opens this panel kind. */
-  detailPanel?: FeedItemDetailPanel;
-  /** Broad category for grouping and filtering feed items. */
-  category?: FeedItemCategory;
-  /** True when this item represents an assistant-initiated share or a high-importance system event. Used by clients to split inbox vs activity surfaces. */
-  noteworthy?: boolean;
-  /** True when the assistant herself emitted this item (e.g. via the `notifications send` skill). Drives clients to swap the row's leading icon for the persona avatar; system-generated items keep the category icon. */
-  fromAssistant?: boolean;
-  /** Arbitrary structured data the detail panel or other consumers can use. */
-  metadata?: Record<string, unknown>;
-  /** Internal: ISO-8601 writer-record time, used for ordering + TTL. */
-  createdAt: string;
-}
+import { FeedItemSchema } from "../api/responses/home.js";
+
+export {
+  type FeedAction,
+  type FeedItem,
+  type FeedItemCategory,
+  type FeedItemDetailPanel,
+  type FeedItemDetailPanelKind,
+  FeedItemSchema as feedItemSchema,
+  type FeedItemStatus,
+  type FeedItemType,
+  type FeedItemUrgency,
+  type SuggestedPrompt,
+  SuggestedPromptSchema as suggestedPromptSchema,
+  type SuggestedPromptSource,
+} from "../api/responses/home.js";
 
 /**
  * On-disk file format for `~/.vellum/workspace/data/home-feed.json`.
  *
- * Written by the PR 5 writer, read by the PR 6 HTTP route and
- * `parseFeedFile` below. `version` is pinned to `2` (collapsed schema);
- * pre-v2 files are rewritten by workspace migration
- * `061-home-feed-notification-only`.
+ * Written by the feed writer, read by the HTTP route and `parseFeedFile`
+ * below. `version` is pinned to `2` (collapsed schema); pre-v2 files are
+ * rewritten by workspace migration `079-home-feed-notification-only`.
  */
 export interface HomeFeedFile {
   version: 2;
-  items: FeedItem[];
+  items: z.infer<typeof FeedItemSchema>[];
   updatedAt: string;
 }
 
-/**
- * Origin of a suggested prompt — whether it was deterministically derived
- * (e.g. from a missing OAuth connection) or generated by the assistant.
- */
-export type SuggestedPromptSource = "deterministic" | "assistant";
-
-/**
- * A prompt suggestion shown at the top of the Home page.
- *
- * Deterministic prompts are derived from workspace state (e.g. missing
- * OAuth connections). Assistant-generated prompts are contextual
- * conversation starters produced by the LLM.
- */
-export interface SuggestedPrompt {
-  id: string;
-  label: string;
-  icon?: string;
-  prompt: string;
-  source: SuggestedPromptSource;
-}
-
-// ---------------------------------------------------------------------------
-// Zod schemas
-// ---------------------------------------------------------------------------
-
-const feedItemTypeSchema = z.literal("notification");
-
-const feedItemStatusSchema = z.enum(["new", "seen", "acted_on", "dismissed"]);
-
-const feedItemUrgencySchema = z.enum(["low", "medium", "high", "critical"]);
-
-const feedActionSchema = z.object({
-  id: z.string(),
-  label: z.string(),
-  prompt: z.string(),
-});
-
-const feedItemDetailPanelKindSchema = z.enum([
-  "emailDraft",
-  "documentPreview",
-  "permissionChat",
-  "paymentAuth",
-  "toolPermission",
-  "updatesList",
-]);
-
-const feedItemDetailPanelSchema = z.object({
-  kind: feedItemDetailPanelKindSchema,
-});
-
-const feedItemCategorySchema = z.enum([
-  "security",
-  "scheduling",
-  "background",
-  "email",
-  "system",
-]);
-
-/**
- * Schema for a single `FeedItem`.
- *
- * Notes:
- *   - `priority` must be an integer in [0, 100]; string numerics
- *     (e.g. `"5"`) are rejected — we want deterministic ordering and
- *     silent coercion tends to mask writer bugs.
- *   - `status` defaults to `"new"` so the writer does not need to
- *     set it on every append.
- */
-export const feedItemSchema = z.object({
-  id: z.string(),
-  type: feedItemTypeSchema,
-  priority: z.number().int().min(0).max(100),
-  title: z.string().optional(),
-  summary: z.string(),
-  timestamp: z.string(),
-  status: feedItemStatusSchema.default("new"),
-  expiresAt: z.string().optional(),
-  actions: z.array(feedActionSchema).optional(),
-  urgency: feedItemUrgencySchema.optional(),
-  conversationId: z.string().optional(),
-  detailPanel: feedItemDetailPanelSchema.optional(),
-  category: feedItemCategorySchema.optional(),
-  noteworthy: z.boolean().optional(),
-  fromAssistant: z.boolean().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional(),
-  createdAt: z.string(),
-});
-
-const suggestedPromptSourceSchema = z.enum(["deterministic", "assistant"]);
-
-export const suggestedPromptSchema = z.object({
-  id: z.string(),
-  label: z.string(),
-  icon: z.string().optional(),
-  prompt: z.string(),
-  source: suggestedPromptSourceSchema,
-});
-
 /** Schema for the on-disk `home-feed.json` file. */
 const homeFeedFileSchema = z.object({
   version: z.literal(2),
-  items: z.array(feedItemSchema),
+  items: z.array(FeedItemSchema),
   updatedAt: z.string(),
 });
 
 /**
  * Parse and validate a raw value read from `home-feed.json`.
  *
- * Used by the PR 5 writer on read-back and by the PR 6 HTTP route
- * when serving the feed. Throws a `ZodError` on any validation
- * failure — callers are expected to log + recover (e.g. treat the
- * file as empty).
+ * Used by the writer on read-back and by the HTTP route when serving the
+ * feed. Throws a `ZodError` on any validation failure — callers are
+ * expected to log + recover (e.g. treat the file as empty).
  */
 export function parseFeedFile(raw: unknown): HomeFeedFile {
   return homeFeedFileSchema.parse(raw) as HomeFeedFile;

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/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,8 +18,11 @@ 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", () => ({
@@ -63,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);
@@ -77,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",
@@ -91,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 () => {