@vellumai/assistant 0.10.5-staging.1 → 0.10.5-staging.2

package/openapi.yaml

@@ -6463,6 +6463,12 @@ paths:
                           type: number
                         inferenceProfile:
                           type: string
+                        enabledPlugins:
+                          anyOf:
+                            - type: array
+                              items:
+                                type: string
+                            - type: "null"
                         isProcessing:
                           type: boolean
                       required:
@@ -6802,6 +6808,12 @@ paths:
                         type: number
                       inferenceProfile:
                         type: string
+                      enabledPlugins:
+                        anyOf:
+                          - type: array
+                            items:
+                              type: string
+                          - type: "null"
                       isProcessing:
                         type: boolean
                     required:
@@ -7003,6 +7015,12 @@ paths:
                         type: number
                       inferenceProfile:
                         type: string
+                      enabledPlugins:
+                        anyOf:
+                          - type: array
+                            items:
+                              type: string
+                          - type: "null"
                       isProcessing:
                         type: boolean
                     required:
@@ -7210,6 +7228,56 @@ paths:
           description: Returned when the callId is missing or refers to a call in a different conversation.
         "404":
           description: Returned when the conversation or the referenced LLM call does not exist.
+  /v1/conversations/{id}/enabledplugins:
+    put:
+      operationId: conversations_by_id_enabledplugins_put
+      summary: Set conversation enabled plugins
+      description:
+        Scope a single conversation to a subset of installed plugins (first-party defaults are always available).
+        Pass null to clear the scope back to the default (all enabled plugins).
+      tags:
+        - conversations
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                enabledPlugins:
+                  anyOf:
+                    - type: array
+                      items:
+                        type: string
+                    - type: "null"
+              required:
+                - enabledPlugins
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  conversationId:
+                    type: string
+                  enabledPlugins:
+                    anyOf:
+                      - type: array
+                        items:
+                          type: string
+                      - type: "null"
+                required:
+                  - conversationId
+                  - enabledPlugins
+                additionalProperties: false
   /v1/conversations/{id}/inference-profile:
     put:
       operationId: conversations_by_id_inferenceprofile_put
@@ -8140,6 +8208,12 @@ paths:
                         type: number
                       inferenceProfile:
                         type: string
+                      enabledPlugins:
+                        anyOf:
+                          - type: array
+                            items:
+                              type: string
+                          - type: "null"
                       isProcessing:
                         type: boolean
                     required:
@@ -17980,7 +18054,7 @@ paths:
                           required:
                             - acpSessionId
                           additionalProperties: false
-                        backgroundToolNotification:
+                        backgroundEventNotification:
                           type: boolean
                         backgroundToolCompletion:
                           type: object
@@ -18216,9 +18290,12 @@ paths:
                     - high
                 hidden:
                   description:
-                    When true, persist the user message but suppress it from the UI transcript (it stays in LLM-side history
-                    and still drives the turn). Used to prime a proactive assistant greeting without showing the
-                    triggering user message. Honored on the standard send path only.
+                    "When true, persist the user message but suppress it from the UI transcript (it stays in LLM-side history
+                    and still drives the turn). Used for machine signals the user never typed (proactive-greeting
+                    priming, channel-setup wizard close). Suppression covers the queued path too: a hidden send that
+                    lands mid-turn returns { queued: true, requestId } but never appears in list-messages queued
+                    snapshots, emits no echo, and does not supersede pending interactions. Honored on the standard send
+                    path only — slash-command content bypasses it."
                   type: boolean
                 onboarding:
                   type: object

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.5-staging.1",
+  "version": "0.10.5-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-enabledplugins-route.test.ts

@@ -0,0 +1,184 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+const config = {
+  llm: {
+    profiles: {},
+  },
+};
+
+mock.module("../config/loader.js", () => ({
+  loadConfig: () => config,
+  getConfig: () => config,
+}));
+
+import {
+  createConversation,
+  getConversation,
+  setConversationEnabledPlugins,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { ROUTES } from "../runtime/routes/conversation-management-routes.js";
+import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
+import { buildConversationDetailResponse } from "../runtime/services/conversation-serializer.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
+
+await initializeDb();
+
+const pluginsRoute = ROUTES.find(
+  (r) => r.operationId === "conversations_by_id_enabledplugins_put",
+)!;
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+describe("PUT /v1/conversations/:id/enabledplugins", () => {
+  beforeEach(() => {
+    clearTables();
+  });
+
+  afterAll(() => {
+    resetDbForTesting();
+    mock.restore();
+  });
+
+  test("persists a string[] scope and reflects it on the conversation", async () => {
+    const conversation = createConversation("enabledplugins-route");
+
+    const result = await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: ["plugin-a", "plugin-b"] },
+      headers: {},
+    });
+
+    expect(result).toMatchObject({
+      conversationId: conversation.id,
+      enabledPlugins: ["plugin-a", "plugin-b"],
+    });
+    expect(getConversation(conversation.id)?.enabledPlugins).toEqual([
+      "plugin-a",
+      "plugin-b",
+    ]);
+
+    // The HTTP conversation-detail response (what the web `conversationsByIdGet`
+    // reads) must also carry the scope, not just the internal DB getter.
+    const detail = buildConversationDetailResponse(conversation.id);
+    expect(detail?.conversation.enabledPlugins).toEqual([
+      "plugin-a",
+      "plugin-b",
+    ]);
+  });
+
+  test("detail response omits enabledPlugins by default and preserves an explicit []", async () => {
+    const conversation = createConversation("enabledplugins-detail-shape");
+
+    // Default (no per-chat restriction): the field is omitted from the wire.
+    expect(
+      "enabledPlugins" in buildConversationDetailResponse(conversation.id)!
+        .conversation,
+    ).toBe(false);
+
+    // Explicit empty scope (user cleared all optional plugins): preserved as [].
+    await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: [] },
+      headers: {},
+    });
+    expect(
+      buildConversationDetailResponse(conversation.id)?.conversation
+        .enabledPlugins,
+    ).toEqual([]);
+  });
+
+  test("clears the scope to default when enabledPlugins is null", async () => {
+    const conversation = createConversation("enabledplugins-clear");
+
+    await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: ["plugin-x"] },
+      headers: {},
+    });
+    expect(getConversation(conversation.id)?.enabledPlugins).toEqual([
+      "plugin-x",
+    ]);
+
+    const result = await pluginsRoute.handler({
+      pathParams: { id: conversation.id },
+      body: { enabledPlugins: null },
+      headers: {},
+    });
+
+    expect(result).toMatchObject({
+      conversationId: conversation.id,
+      enabledPlugins: null,
+    });
+    expect(getConversation(conversation.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("rejects a non-array, non-null body with BadRequestError", async () => {
+    const conversation = createConversation("enabledplugins-bad");
+
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: conversation.id },
+        body: { enabledPlugins: "not-an-array" },
+        headers: {},
+      }),
+    ).rejects.toThrow(BadRequestError);
+    expect(getConversation(conversation.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("rejects an array containing a non-string with BadRequestError", async () => {
+    const conversation = createConversation("enabledplugins-bad-element");
+
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: conversation.id },
+        body: { enabledPlugins: ["ok", 123] },
+        headers: {},
+      }),
+    ).rejects.toThrow(BadRequestError);
+    expect(getConversation(conversation.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("rejects a missing enabledPlugins field without clearing the scope", async () => {
+    const conversation = createConversation("enabledplugins-missing");
+    // Seed an explicit scope, then send a body with no `enabledPlugins`.
+    setConversationEnabledPlugins(conversation.id, ["plugin-a"]);
+
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: conversation.id },
+        body: {},
+        headers: {},
+      }),
+    ).rejects.toThrow(BadRequestError);
+    // The existing scope must survive a malformed request (null is the only
+    // explicit clear signal).
+    expect(getConversation(conversation.id)?.enabledPlugins).toEqual([
+      "plugin-a",
+    ]);
+  });
+
+  test("throws NotFoundError when the conversation does not exist", async () => {
+    await expect(
+      pluginsRoute.handler({
+        pathParams: { id: "missing" },
+        body: { enabledPlugins: [] },
+        headers: {},
+      }),
+    ).rejects.toThrow(NotFoundError);
+  });
+});

package/src/__tests__/conversation-queue.test.ts

@@ -3062,6 +3062,54 @@ describe("subagent notification user_message_echo suppression", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
+  test("drained hidden message persists with hidden metadata and emits no user_message_echo", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events1: ServerMessage[] = [];
+    const eventsHidden: ServerMessage[] = [];
+
+    // Occupy the conversation so the hidden send queues — e.g. the user
+    // closes the channel-setup wizard while the assistant is mid-turn.
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // A hidden `POST /messages` send carries `hidden: true` metadata through
+    // the queue branch (see conversation-routes.ts).
+    conversation.enqueueMessage({
+      content:
+        "[User action on channel_setup surface: closed the slack setup wizard]",
+      onEvent: (e) => eventsHidden.push(e),
+      requestId: "req-hidden",
+      metadata: { hidden: true },
+    });
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    // Persisted with the hidden flag so the transcript filter keeps it out
+    // of the rendered history...
+    const persisted = capturedAddMessages.find((m) =>
+      m.content.includes("channel_setup"),
+    );
+    expect(persisted?.metadata?.hidden).toBe(true);
+    // ...the agent still wakes on it...
+    expect(pendingRuns.length).toBe(2);
+    // ...and no user_message_echo is broadcast, so no visible user bubble.
+    expect(eventsHidden.some((e) => e.type === "user_message_echo")).toBe(
+      false,
+    );
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
   test("drained acp-notification message persists and wakes the agent but emits no user_message_echo", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();