@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.4

package/src/runtime/routes/__tests__/schedule-routes-disarm-reason.test.ts

@@ -0,0 +1,215 @@
+/**
+ * The schedule list and detail routes say why a plugin-sourced schedule is
+ * off, so a client never has to show an unexplained disabled row.
+ *
+ * The reason is derived from the row plus the plugin's files, so the fixtures
+ * here write real plugin directories under the per-test-process workspace
+ * plugins dir and converge them against the real schedule store.
+ */
+
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { setOverridesForTesting } from "../../../__tests__/feature-flag-test-helpers.js";
+import { getDb } from "../../../persistence/db-connection.js";
+import { initializeDb } from "../../../persistence/db-init.js";
+import {
+  createSchedule,
+  setUserEnabled,
+  upsertDeclaredSchedule,
+} from "../../../schedule/schedule-store.js";
+import { getWorkspacePluginsDir } from "../../../util/platform.js";
+import { ROUTES } from "../schedule-routes.js";
+
+await initializeDb();
+
+const pluginsDir = getWorkspacePluginsDir();
+
+function routeHandler(operationId: string) {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) {
+    throw new Error(`${operationId} route not found`);
+  }
+  return route.handler;
+}
+
+const listHandler = routeHandler("listSchedules");
+const getHandler = routeHandler("getSchedule");
+
+interface SerializedSchedule {
+  id: string;
+  sourceKey: string | null;
+  enabled: boolean;
+  disarmReason: string | null;
+}
+
+async function listed(id: string): Promise<SerializedSchedule> {
+  const { schedules } = (await listHandler({ queryParams: {} })) as {
+    schedules: SerializedSchedule[];
+  };
+  const found = schedules.find((s) => s.id === id);
+  if (!found) {
+    throw new Error(`schedule ${id} missing from the list response`);
+  }
+  return found;
+}
+
+async function fetched(id: string): Promise<SerializedSchedule> {
+  const { schedule } = (await getHandler({ pathParams: { id } })) as {
+    schedule: SerializedSchedule;
+  };
+  return schedule;
+}
+
+/** Write a plugin dir holding one `schedules/<name>/` declaration. */
+function writePlugin(
+  pluginName: string,
+  options: { declaration?: string; disabled?: boolean } = {},
+): void {
+  const dir = join(pluginsDir, pluginName);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "package.json"),
+    JSON.stringify({ name: pluginName, version: "1.0.0" }),
+  );
+  if (options.declaration) {
+    const declarationDir = join(dir, "schedules", options.declaration);
+    mkdirSync(declarationDir, { recursive: true });
+    writeFileSync(
+      join(declarationDir, "config.json"),
+      JSON.stringify({ expression: "* * * * *" }),
+    );
+    writeFileSync(join(declarationDir, "index.md"), "Summarize the day.\n");
+  }
+  if (options.disabled) {
+    writeFileSync(join(dir, ".disabled"), "");
+  }
+}
+
+/** A declared row for `plugin:<pluginName>/digest`, armed or not. */
+async function declaredRow(
+  pluginName: string,
+  enabled: boolean,
+): Promise<string> {
+  const job = await upsertDeclaredSchedule(`plugin:${pluginName}/digest`, {
+    name: `${pluginName}-digest`,
+    description: "Daily digest",
+    syntax: "cron",
+    expression: "* * * * *",
+    message: "Summarize the day.",
+    mode: "execute",
+    enabled,
+    definitionHash: `hash-${pluginName}`,
+  });
+  return job.id;
+}
+
+/** Stamp the engine's exhaust latch onto a row: off, spent, and last run. */
+function latchAsCompleted(id: string): void {
+  getDb().run(
+    `UPDATE cron_jobs SET enabled = 0, next_run_at = 0, last_run_at = ${Date.now()} WHERE id = '${id}'`,
+  );
+}
+
+beforeEach(() => {
+  getDb().run("DELETE FROM cron_runs");
+  getDb().run("DELETE FROM cron_jobs");
+  rmSync(pluginsDir, { recursive: true, force: true });
+  // The feature ships off, so every case states the flag it runs under rather
+  // than inheriting the registry default.
+  setOverridesForTesting({ "plugin-schedules": true });
+});
+
+describe("schedule serialization: disarmReason", () => {
+  test("a user's own override outranks whatever the plugin's files say", async () => {
+    writePlugin("news", { declaration: "digest" });
+    const id = await declaredRow("news", true);
+    await setUserEnabled(id, false);
+
+    expect((await listed(id)).disarmReason).toBe("user_disabled");
+    expect((await fetched(id)).disarmReason).toBe("user_disabled");
+  });
+
+  test("a plugin that is gone from disk reads as removed", async () => {
+    const id = await declaredRow("news", false);
+
+    expect((await listed(id)).disarmReason).toBe("plugin_removed");
+    expect((await fetched(id)).disarmReason).toBe("plugin_removed");
+  });
+
+  test("a plugin carrying the .disabled sentinel reads as disabled", async () => {
+    writePlugin("news", { declaration: "digest", disabled: true });
+    const id = await declaredRow("news", false);
+
+    expect((await listed(id)).disarmReason).toBe("plugin_disabled");
+    expect((await fetched(id)).disarmReason).toBe("plugin_disabled");
+  });
+
+  test("a declaration dropped from a plugin that is still installed", async () => {
+    writePlugin("news");
+    const id = await declaredRow("news", false);
+
+    expect((await listed(id)).disarmReason).toBe("declaration_removed");
+    expect((await fetched(id)).disarmReason).toBe("declaration_removed");
+  });
+
+  test("a declaration still on disk means the plugin's files turned it off", async () => {
+    writePlugin("news", { declaration: "digest" });
+    const id = await declaredRow("news", false);
+
+    expect((await listed(id)).disarmReason).toBe("declaration_disabled");
+    expect((await fetched(id)).disarmReason).toBe("declaration_disabled");
+  });
+
+  test("an armed plugin row has no reason to give", async () => {
+    writePlugin("news", { declaration: "digest" });
+    const id = await declaredRow("news", true);
+
+    const row = await listed(id);
+    expect(row.enabled).toBe(true);
+    expect(row.disarmReason).toBeNull();
+    expect((await fetched(id)).disarmReason).toBeNull();
+  });
+
+  test("a run-to-completion row reads as finished, not paused", async () => {
+    writePlugin("news", { declaration: "digest" });
+    const id = await declaredRow("news", true);
+    latchAsCompleted(id);
+
+    const row = await listed(id);
+    expect(row.enabled).toBe(false);
+    expect(row.disarmReason).toBeNull();
+    expect((await fetched(id)).disarmReason).toBeNull();
+  });
+
+  test("the kill switch being off is not a per-row cause", async () => {
+    writePlugin("news", { declaration: "digest" });
+    const id = await declaredRow("news", false);
+    setOverridesForTesting({ "plugin-schedules": false });
+
+    const row = await listed(id);
+    expect(row.enabled).toBe(false);
+    expect(row.disarmReason).toBeNull();
+    expect((await fetched(id)).disarmReason).toBeNull();
+  });
+
+  test("a user-created schedule never carries one, off or on", async () => {
+    const job = await createSchedule({
+      name: "wt-imperative",
+      description: "d",
+      message: "do the thing",
+      mode: "execute",
+      enabled: false,
+      timezone: null,
+      expression: "* * * * *",
+      syntax: "cron",
+    });
+
+    const row = await listed(job.id);
+    expect(row.sourceKey).toBeNull();
+    expect(row.enabled).toBe(false);
+    expect(row.disarmReason).toBeNull();
+    expect((await fetched(job.id)).disarmReason).toBeNull();
+  });
+});

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

@@ -209,28 +209,41 @@ function resolveOrThrow(rawId: string): string {
 // Handlers
 // ---------------------------------------------------------------------------
 
+/**
+ * Read a query parameter that admits a closed set of values. Absent or empty
+ * reads as `undefined`; anything outside `accepted` is a 400. The strictness
+ * is the point: silently coercing a typo or a newer client's value to "no
+ * filter" would hand back the full list where a subset was asked for, and
+ * that skew is invisible to the client (it masks version skew too).
+ */
+function parseEnumQueryParam<const T extends readonly string[]>(
+  queryParams: Record<string, string | undefined>,
+  name: string,
+  accepted: T,
+): T[number] | undefined {
+  const raw = queryParams[name];
+  if (raw === undefined || raw === "") {
+    return undefined;
+  }
+  if ((accepted as readonly string[]).includes(raw)) {
+    return raw as T[number];
+  }
+  throw new BadRequestError(
+    `Unknown ${name} "${raw}"; expected ${accepted.map((v) => `"${v}"`).join(" or ")}.`,
+  );
+}
+
 function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
   const limit = Number(queryParams.limit ?? 50);
   const offset = Number(queryParams.offset ?? 0);
   // "background" is the back-compat umbrella (background + scheduled); newer
   // clients can pass "scheduled" to load only the Scheduled section. Absent
-  // defaults to the standard foreground list. Any other value is rejected so
-  // an unrecognized type surfaces as a 400 rather than being silently coerced
-  // to the foreground list (which would mask client/daemon version skew).
-  const rawConversationType = queryParams.conversationType;
-  let conversationType: ConversationType = "standard";
-  if (rawConversationType !== undefined && rawConversationType !== "") {
-    if (
-      rawConversationType === "background" ||
-      rawConversationType === "scheduled"
-    ) {
-      conversationType = rawConversationType;
-    } else {
-      throw new BadRequestError(
-        `Unknown conversationType "${rawConversationType}"; expected "background" or "scheduled".`,
-      );
-    }
-  }
+  // defaults to the standard foreground list.
+  const conversationType: ConversationType =
+    parseEnumQueryParam(queryParams, "conversationType", [
+      "background",
+      "scheduled",
+    ]) ?? "standard";
   // Defaults to `active` so sidebar restores no longer pull archived rows.
   // The Archive page opts into `archived` to render only archived rows
   // without dragging the entire live history through pagination first.
@@ -251,11 +264,17 @@ function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
       ? queryParams.groupId
       : undefined;
 
+  const needsAttention =
+    parseEnumQueryParam(queryParams, "needsAttention", ["true"]) === "true"
+      ? true
+      : undefined;
+
   const filter: ConversationListFilter = {
     conversationType,
     archiveStatus,
     originChannel,
     groupId,
+    needsAttention,
   };
   let rows = listConversations({ ...filter, limit, offset });
   const totalCount = countConversations(filter);
@@ -270,15 +289,19 @@ function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
   // Skipped for group-scoped queries for the same reason: a caller asking
   // for one group gets that group, and a client that fetches the Pinned
   // section via `groupId=system:pinned` has no use for rows appended to
-  // some other group's page. This is the compatibility shim for clients
-  // that still read Pinned out of the unfiltered list; it goes away once
-  // every section fetches its own group.
+  // some other group's page. Skipped for attention-scoped queries too: the
+  // caller asked for the unseen subset, and a seen pinned row appended to
+  // it would put a row outside the filter in the page while `hasMore` is
+  // computed from the filtered count. This is the compatibility shim for
+  // clients that still read Pinned out of the unfiltered list; it goes
+  // away once every section fetches its own group.
   if (
     offset === 0 &&
     conversationType === "standard" &&
     archiveStatus === "active" &&
     originChannel === undefined &&
-    groupId === undefined
+    groupId === undefined &&
+    needsAttention === undefined
   ) {
     const pinned = listPinnedConversations(archiveStatus);
     const seen = new Set(rows.map((c) => c.id));
@@ -580,6 +603,14 @@ export const ROUTES: RouteDefinition[] = [
         description:
           'Filter to a single group, so each sidebar section can load independently of the paginated list. Pass "system:all" for conversations in no group, "system:pinned" for the Pinned section, or a custom group id. A group-scoped request is recency-ordered like every list read (COALESCE(last_message_at, updated_at) descending) and never has pinned rows appended to it. Omit to span every group.',
       },
+      {
+        name: "needsAttention",
+        type: "string",
+        required: false,
+        description:
+          'Pass "true" to return only conversations whose latest assistant message the user has not seen: the same predicate behind the unread count and the section index, so a client that keeps no complete conversation list can ask for exactly the rows its attention surfaces need. Composes with every other filter. Any value other than "true" is rejected. Omit to span every conversation.',
+        schema: { type: "string", enum: ["true"] },
+      },
     ],
     responseBody: listConversationsResponseSchema,
     handler: handleListConversations,
@@ -683,7 +714,8 @@ export const ROUTES: RouteDefinition[] = [
     },
     pathParams: [{ name: "id", type: "uuid" }],
     summary: "Get conversation detail",
-    description: "Retrieve a single conversation with full metadata.",
+    description:
+      "Retrieve a single conversation with full metadata. Rows the listing hides by type (legacy private rows) are not found here either.",
     tags: ["conversations"],
     responseBody: conversationDetailResponseSchema,
     handler: handleGetConversation,

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

@@ -308,9 +308,8 @@ async function handleSummarizeConversation({ body = {} }: RouteHandlerArgs) {
         statusText: "Summarizing conversation",
       });
       // The context-window usage push goes out on the same broadcast path as
-      // the result card below: this route resolves its conversation outside
-      // the send path, so the instance may still hold the store's no-op
-      // sender and a `sendToClient` emit would reach nobody.
+      // the result card below, so the two can never be delivered to different
+      // places.
       const result = await conversation.summarizeUpToMessage(
         beforeMessageId,
         broadcastMessage,

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

@@ -1979,20 +1979,18 @@ export async function handleSendMessage(
       sourceActorPrincipalId,
     );
   }
-  // Wire sendToClient to the SSE hub so all subsystems can reach the HTTP client.
-  // hasNoClient must remain `!isInteractive` so downstream tool gating
-  // (`isToolActiveForContext` for HOST_TOOL_NAMES, `createToolExecutor`'s
-  // `isInteractive: !ctx.hasNoClient`) keeps host_bash/host_file/host_cu
-  // tools gated for non-desktop interfaces. The chrome-extension interface
-  // is non-interactive (no SSE prompter UI) but still has a connected client
-  // that can service host_browser_request events; we restore that single
-  // proxy explicitly below without relaxing `hasNoClient`.
-  conversation.updateClient(broadcastMessage, !isInteractive);
+  // Delivery needs no wiring: the conversation's sink is the SSE hub for its
+  // whole life. Presence travels with the turn (`isInteractive` below), which
+  // is what keeps host_bash/host_file/host_cu gated for non-desktop
+  // interfaces. The chrome-extension interface is non-interactive (no SSE
+  // prompter UI) but still has a connected client that can service
+  // host_browser_request events; that single proxy is restored explicitly
+  // below without claiming a human is present.
   if (isInteractive) {
-    getSubagentManager().updateParentSender(
-      mapping.conversationId,
-      broadcastMessage,
-    );
+    // A client that reconnected mid-phase resyncs the current activity state
+    // and any subagent card it left stale while disconnected.
+    conversation.replayActivityState();
+    getSubagentManager().reannounceChildStatuses(mapping.conversationId);
   }
 
   // ── URL scan path: rewrite first message for scan onboarding ──

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

@@ -4,20 +4,12 @@
  * Exposes document CRUD over HTTP, sharing business logic with the
  * handlers in `daemon/handlers/documents.ts`.
  */
-import { randomUUID } from "node:crypto";
-import { readFileSync, statSync } from "node:fs";
-import { basename, extname } from "node:path";
-
 import { z } from "zod";
 
 import {
   addDocumentConversation,
-  createFileBackedDocument,
   getDocumentById,
-  getDocumentByWorkspacePath,
   getDocumentsForConversation,
-  isDocumentAssociatedWithConversation,
-  refreshDocumentContentFromFile,
   saveDocument,
 } from "../../documents/document-store.js";
 import { rawAll } from "../../persistence/raw-query.js";
@@ -28,18 +20,9 @@ import {
   publishDocumentsChanged,
 } from "../sync/resource-sync-events.js";
 import { renderMarkdownToPDF } from "./document-pdf-renderer.js";
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  UnprocessableEntityError,
-} from "./errors.js";
-import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
+import type { RouteDefinition } from "./types.js";
 import { RouteResponse } from "./types.js";
-import {
-  resolveWorkspacePath,
-  toWorkspaceRelativePath,
-} from "./workspace-utils.js";
 
 const log = getLogger("documents-routes");
 
@@ -85,14 +68,7 @@ function listAllDocuments(): Array<{
   }
 }
 
-// ---------------------------------------------------------------------------
-// File-backed documents
-// ---------------------------------------------------------------------------
-
-/** Extensions the document editor round-trips faithfully as markdown. */
-const MARKDOWN_EXTENSIONS = new Set([".md", ".markdown"]);
-
-/** The document payload shape shared by `GET documents/{id}` and its siblings. */
+/** The document payload shape returned by `GET documents/{id}`. */
 const documentPayloadSchema = z.object({
   success: z.boolean(),
   surfaceId: z.string(),
@@ -102,173 +78,8 @@ const documentPayloadSchema = z.object({
   wordCount: z.number(),
   createdAt: z.number(),
   updatedAt: z.number(),
-  workspacePath: z
-    .string()
-    .nullable()
-    .describe("Workspace-relative file this document is bound to, or null"),
 });
 
-/**
- * Resolve a client-supplied workspace path to the markdown file it names.
- *
- * Uses the same resolution as the workspace file routes, so a path that
- * escapes the workspace (traversal, absolute, symlinked out, dot-segment) is
- * rejected here exactly as it would be there.
- */
-function resolveWorkspaceMarkdownFile(path: string): {
-  absolutePath: string;
-  relativePath: string;
-} {
-  const resolved = resolveWorkspacePath(path);
-  if (resolved === undefined) {
-    throw new BadRequestError("Invalid path");
-  }
-
-  if (!MARKDOWN_EXTENSIONS.has(extname(resolved).toLowerCase())) {
-    throw new UnprocessableEntityError(
-      "Only markdown files (.md, .markdown) can back a document",
-    );
-  }
-
-  return {
-    absolutePath: resolved,
-    relativePath: toWorkspaceRelativePath(resolved),
-  };
-}
-
-/** Current text of a workspace file, or `null` when it is gone or not a file. */
-function readWorkspaceFileText(absolutePath: string): string | null {
-  try {
-    if (!statSync(absolutePath).isFile()) {
-      return null;
-    }
-    return readFileSync(absolutePath, "utf-8");
-  } catch {
-    return null;
-  }
-}
-
-/** Load a document by surface ID for a response, or fail loudly if it vanished. */
-function loadDocumentPayload(surfaceId: string): Record<string, unknown> {
-  const doc = getDocumentById(surfaceId);
-  if (!doc) {
-    throw new InternalError("Document could not be loaded after persisting");
-  }
-  return { success: true, ...doc };
-}
-
-/**
- * Find or create the document bound to a workspace markdown file.
- *
- * The file is the source of truth at open time: when a bound document's stored
- * content has drifted from the bytes on disk (the file was edited outside the
- * editor), the row is refreshed from the file before it is returned. Writes go
- * the other way — the document store writes through to the file.
- *
- * The publishes here carry no origin client id on purpose. The only caller,
- * `viewer-store.loadWorkspaceFileDocument`, opens the file and never
- * invalidates its own document queries, so the client that creates the row is
- * the one that most needs to hear about it: suppressing its own echo would
- * leave its assets pill and Library without the document it just opened.
- */
-function handleDocumentForWorkspaceFile({
-  body,
-}: RouteHandlerArgs): Record<string, unknown> {
-  const { path, conversationId } = (body ?? {}) as {
-    path?: string;
-    conversationId?: string;
-  };
-
-  if (!path || typeof path !== "string") {
-    throw new BadRequestError("path is required");
-  }
-  if (!conversationId || typeof conversationId !== "string") {
-    throw new BadRequestError("conversationId is required");
-  }
-
-  const { absolutePath, relativePath } = resolveWorkspaceMarkdownFile(path);
-  const existing = getDocumentByWorkspacePath(relativePath);
-  const fileText = readWorkspaceFileText(absolutePath);
-
-  if (fileText === null) {
-    // A bound document whose file is gone is reported distinctly: the client
-    // needs to tell "this file was deleted" apart from "no such file", and the
-    // document must never be used to resurrect the file.
-    if (existing) {
-      throw new NotFoundError(
-        `The file backing this document no longer exists: ${relativePath}`,
-      );
-    }
-    throw new NotFoundError("File not found");
-  }
-
-  if (existing) {
-    // Opening the file from another conversation grants that conversation
-    // access, the same association the link route writes.
-    const alreadyLinked = isDocumentAssociatedWithConversation(
-      existing.surfaceId,
-      conversationId,
-    );
-    addDocumentConversation(existing.surfaceId, conversationId);
-
-    let refreshed = false;
-    if (existing.content !== fileText) {
-      const refresh = refreshDocumentContentFromFile(
-        existing.surfaceId,
-        fileText,
-      );
-      if (!refresh.success) {
-        throw new InternalError(refresh.error);
-      }
-      refreshed = true;
-      log.info(
-        { surfaceId: existing.surfaceId, workspacePath: relativePath },
-        "Refreshed file-backed document from disk",
-      );
-    }
-
-    // Reopening an unchanged, already-linked file writes nothing, so it must
-    // not invalidate every client's document list on each open.
-    if (!alreadyLinked || refreshed) {
-      publishDocumentsChanged();
-    }
-    return loadDocumentPayload(existing.surfaceId);
-  }
-
-  const surfaceId = `doc-${randomUUID()}`;
-  const created = createFileBackedDocument({
-    surfaceId,
-    conversationId,
-    title: basename(relativePath),
-    content: fileText,
-    workspacePath: relativePath,
-  });
-
-  if (!created.success) {
-    // A concurrent request may have won the unique index on workspace_path.
-    const raced = getDocumentByWorkspacePath(relativePath);
-    if (!raced) {
-      throw new InternalError(created.error);
-    }
-    const racedAlreadyLinked = isDocumentAssociatedWithConversation(
-      raced.surfaceId,
-      conversationId,
-    );
-    addDocumentConversation(raced.surfaceId, conversationId);
-    if (!racedAlreadyLinked) {
-      publishDocumentsChanged();
-    }
-    return loadDocumentPayload(raced.surfaceId);
-  }
-
-  log.info(
-    { surfaceId, workspacePath: relativePath, conversationId },
-    "Bound workspace file to a new document",
-  );
-  publishDocumentsChanged();
-  return loadDocumentPayload(surfaceId);
-}
-
 // ---------------------------------------------------------------------------
 // Route definitions
 // ---------------------------------------------------------------------------
@@ -403,36 +214,6 @@ export const ROUTES: RouteDefinition[] = [
     },
   },
 
-  {
-    operationId: "documentForWorkspaceFile",
-    endpoint: "documents/for-workspace-file",
-    method: "POST",
-    policy: {
-      requiredScopes: ["settings.write"],
-      allowedPrincipalTypes: ACTOR_PRINCIPALS,
-    },
-    summary: "Get or create the document for a workspace markdown file",
-    description:
-      "Return the document bound to a workspace markdown file, creating it on " +
-      "first open. The file is the source of truth at open time: stored " +
-      "content that has drifted from the file is refreshed from disk before " +
-      "the document is returned.",
-    tags: ["documents"],
-    requestBody: z.object({
-      path: z
-        .string()
-        .describe("Workspace-relative path to a .md/.markdown file"),
-      conversationId: z
-        .string()
-        .describe("Conversation the document is opened from"),
-    }),
-    responseBody: documentPayloadSchema,
-    additionalResponses: {
-      "422": { description: "Path is not a markdown file" },
-    },
-    handler: handleDocumentForWorkspaceFile,
-  },
-
   {
     operationId: "linkDocumentConversation",
     endpoint: "documents/:id/conversations",

package/src/runtime/routes/playground/__tests__/inject-failures.test.ts

@@ -47,6 +47,7 @@ interface MockConversation {
   contextCompactedAt: number | null;
   sentMessages: AssistantEvent[];
   sendToClient: (msg: AssistantEvent) => void;
+  emit: (msg: AssistantEvent) => void;
   getMessages: () => unknown[];
 }
 
@@ -64,6 +65,7 @@ function makeConversation(id = "conv-playground-test"): MockConversation {
     contextCompactedAt: null,
     sentMessages,
     sendToClient: (msg) => sentMessages.push(msg),
+    emit: (msg) => sentMessages.push(msg),
     getMessages: () => [],
   };
 }

package/src/runtime/routes/playground/__tests__/reset-circuit.test.ts

@@ -75,6 +75,9 @@ function makeFakeConversation(
     sendToClient: (msg: AssistantEvent) => {
       sent.push(msg);
     },
+    emit: (msg: AssistantEvent) => {
+      sent.push(msg);
+    },
   } as unknown as Conversation;
 
   return { conversation: fake, sent, state };