@vellumai/assistant 0.10.4-dev.202607021153.195c867 → 0.10.4-dev.202607021247.94bb87f

package/openapi.yaml

@@ -18196,6 +18196,17 @@ paths:
                   anyOf:
                     - type: string
                     - type: "null"
+                enabledPlugins:
+                  description:
+                    Plugin ids that scope this conversation to a subset of installed plugins (first-party defaults are always
+                    available). When present on a message, it sets/updates the conversation's plugin scope (the web
+                    client sends it only on the first message of a new chat). null clears the scope to default (all
+                    enabled plugins); omitting the field leaves the existing scope unchanged.
+                  anyOf:
+                    - type: array
+                      items:
+                        type: string
+                    - type: "null"
                 riskThreshold:
                   type: string
                   enum:
@@ -24432,6 +24443,110 @@ paths:
                 required:
                   - summaries
                 additionalProperties: false
+  /v1/schedules/worker/start:
+    post:
+      operationId: schedules_worker_start_post
+      summary: Start the schedule worker
+      description:
+        Spawns (or reuses) the schedule worker process as a child of the daemon and enables
+        schedules.worker.enabled, so scheduled jobs run out of process.
+      tags:
+        - system
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  pid:
+                    type: number
+                  alreadyRunning:
+                    type: boolean
+                  workerEnabled:
+                    type: boolean
+                    const: true
+                  pidPath:
+                    type: string
+                required:
+                  - pid
+                  - alreadyRunning
+                  - workerEnabled
+                  - pidPath
+                additionalProperties: false
+  /v1/schedules/worker/status:
+    get:
+      operationId: schedules_worker_status_get
+      summary: Schedule worker status
+      description:
+        Reports the schedule worker process state, schedules.worker.enabled, and whether the daemon's in-process
+        scheduler is currently executing schedules.
+      tags:
+        - system
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status:
+                    type: string
+                    enum:
+                      - running
+                      - not_running
+                  pid:
+                    type: number
+                  workerEnabled:
+                    type: boolean
+                  inProcessScheduler:
+                    type: object
+                    properties:
+                      status:
+                        type: string
+                        enum:
+                          - running
+                          - not_running
+                      pid:
+                        type: number
+                    required:
+                      - status
+                    additionalProperties: false
+                required:
+                  - status
+                  - workerEnabled
+                  - inProcessScheduler
+                additionalProperties: false
+  /v1/schedules/worker/stop:
+    post:
+      operationId: schedules_worker_stop_post
+      summary: Stop the schedule worker
+      description:
+        Disables schedules.worker.enabled (handing schedule execution back to the in-process scheduler) and
+        SIGTERMs the schedule worker process if it is running.
+      tags:
+        - system
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  workerWasRunning:
+                    type: boolean
+                  pid:
+                    type: number
+                  workerEnabled:
+                    type: boolean
+                    const: false
+                required:
+                  - workerWasRunning
+                  - workerEnabled
+                additionalProperties: false
   /v1/search:
     get:
       operationId: search_get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607021153.195c867",
+  "version": "0.10.4-dev.202607021247.94bb87f",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -79,6 +79,8 @@ const mockSkillRefCount = new Map<string, number>();
 
 mock.module("../config/skills.js", () => ({
   loadSkillCatalog: () => mockCatalog,
+  // Pass-through: these tests don't exercise per-chat plugin scoping.
+  filterSkillsByEnabledPlugins: (skills: unknown) => skills,
 }));
 
 mock.module("../skills/active-skill-tools.js", () => ({

package/src/__tests__/conversation-crud-enabled-plugins.test.ts

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import {
+  addMessage,
+  createConversation,
+  forkConversation,
+  getConversation,
+  getConversationEnabledPlugins,
+  setConversationEnabledPlugins,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+await initializeDb();
+
+describe("getConversationEnabledPlugins / setConversationEnabledPlugins", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run(`DELETE FROM messages`);
+    db.run(`DELETE FROM conversations`);
+  });
+
+  test("defaults to null on a fresh conversation", () => {
+    const conv = createConversation("enabled-plugins-default");
+    expect(getConversationEnabledPlugins(conv.id)).toBeNull();
+    expect(getConversation(conv.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("round-trips a plugin list and clears it with null", () => {
+    const conv = createConversation("enabled-plugins-roundtrip");
+
+    setConversationEnabledPlugins(conv.id, ["a", "b"]);
+    expect(getConversationEnabledPlugins(conv.id)).toEqual(["a", "b"]);
+    expect(getConversation(conv.id)?.enabledPlugins).toEqual(["a", "b"]);
+
+    setConversationEnabledPlugins(conv.id, null);
+    expect(getConversationEnabledPlugins(conv.id)).toBeNull();
+    expect(getConversation(conv.id)?.enabledPlugins).toBeNull();
+  });
+
+  test("stores an empty list distinctly from null", () => {
+    const conv = createConversation("enabled-plugins-empty");
+    setConversationEnabledPlugins(conv.id, []);
+    expect(getConversationEnabledPlugins(conv.id)).toEqual([]);
+  });
+
+  test("a forked conversation carries the plugin selection", async () => {
+    const conv = createConversation("enabled-plugins-fork-source");
+    setConversationEnabledPlugins(conv.id, ["x", "y"]);
+    await addMessage(conv.id, "user", "hi");
+
+    const forked = forkConversation({ conversationId: conv.id });
+    expect(getConversationEnabledPlugins(forked.id)).toEqual(["x", "y"]);
+  });
+});

package/src/__tests__/conversation-routes-enabled-plugins.test.ts

@@ -0,0 +1,389 @@
+/**
+ * Tests for per-conversation `enabledPlugins` wiring in the POST /v1/messages
+ * handler.
+ *
+ * Validates that when a message mints/targets a conversation:
+ * - `enabledPlugins: [...]` is persisted (setConversationEnabledPlugins) AND
+ *   applied to the live conversation (setEnabledPlugins), observable via
+ *   getEffectiveEnabledPluginSet.
+ * - `[]` scopes the chat to no plugins (empty set).
+ * - explicit `null` clears to the default (no per-chat restriction).
+ * - omitting the field leaves the stored value untouched (no persist call).
+ */
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "claude-opus-4-7",
+    provider: "anthropic",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+    contextWindow: { maxInputTokens: 200000 },
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        maxTokens: 64000,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: true, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 200000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+}));
+
+const addMessageMock = mock(async (_conversationId: string, role: string) => ({
+  id: role === "user" ? "persisted-user-id" : "persisted-assistant-id",
+  deduplicated: false,
+}));
+
+const setConversationEnabledPluginsMock = mock(
+  (_conversationId: string, _plugins: string[] | null) => {},
+);
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../persistence/conversation-key-store.js", () => ({
+  getOrCreateConversation: () => ({ conversationId: "conv-plugins-test" }),
+  getConversationByKey: () => null,
+}));
+
+mock.module("../runtime/guardian-reply-router.js", () => ({
+  routeGuardianReply: async () => ({
+    consumed: false,
+    decisionApplied: false,
+    type: "not_consumed",
+  }),
+}));
+
+mock.module("../contacts/canonical-guardian-store.js", () => ({
+  createCanonicalGuardianRequest: () => ({
+    id: "canonical-id",
+    requestCode: "ABC123",
+  }),
+  generateCanonicalRequestCode: () => "ABC123",
+  listPendingCanonicalGuardianRequestsByDestinationConversation: () => [],
+  listCanonicalGuardianRequests: () => [],
+  listPendingRequestsByConversationScope: () => [],
+}));
+
+mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
+  bridgeConfirmationRequestToGuardian: async () => undefined,
+}));
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  addMessage: (conversationId: string, role: string) =>
+    addMessageMock(conversationId, role),
+  extractImageSourcePaths: () => undefined,
+  getConversation: () => null,
+  getConversationOverrideProfile: () => undefined,
+  getMessages: () => [],
+  provenanceFromTrustContext: (ctx: unknown) =>
+    ctx
+      ? { provenanceTrustClass: (ctx as Record<string, unknown>).trustClass }
+      : { provenanceTrustClass: "unknown" },
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+  setConversationInferenceProfile: () => {},
+  setConversationEnabledPlugins: (
+    conversationId: string,
+    plugins: string[] | null,
+  ) => setConversationEnabledPluginsMock(conversationId, plugins),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../persistence/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+  updateMetaFile: () => {},
+}));
+
+mock.module("../persistence/attachments-store.js", () => ({
+  getAttachmentsByIds: () => [],
+  getSourcePathsForAttachments: () => new Map(),
+  attachmentExists: () => false,
+  linkAttachmentToMessage: () => {},
+  attachInlineAttachmentToMessage: () => {},
+  validateAttachmentUpload: () => ({ ok: true }),
+}));
+
+mock.module("../daemon/conversation-process.js", () => ({
+  buildModelInfoEvent: () => ({
+    type: "model_info",
+    model: "claude-opus-4-7",
+    provider: "anthropic",
+    configuredProviders: ["anthropic"],
+  }),
+  isModelSlashCommand: () => false,
+  formatCompactResult: () => "",
+}));
+
+mock.module("../runtime/local-actor-identity.js", () => ({
+  resolveLocalTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
+}));
+
+mock.module("../runtime/trust-context-resolver.js", () => ({
+  resolveTrustContext: () => ({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  }),
+  withSourceChannel: (sourceChannel: unknown, ctx: unknown) => ({
+    ...(ctx as Record<string, unknown>),
+    sourceChannel,
+  }),
+}));
+
+mock.module("../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async () => [
+    {
+      channelType: "vellum",
+      contactId: "guardian-contact",
+      principalId: "test-user",
+      address: "test-user",
+      status: "active",
+    },
+  ],
+}));
+
+const ipcCallMock = mock(
+  async (): Promise<Record<string, unknown> | undefined> => ({ ok: true }),
+);
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: ipcCallMock,
+}));
+
+import { getEffectiveEnabledPluginSet } from "../daemon/conversation-tool-setup.js";
+import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
+import { callHandler } from "./helpers/call-route-handler.js";
+
+function makeConversation() {
+  const runAgentLoop = mock(async () => undefined);
+  const persistUserMessage = mock(async () => ({
+    id: "persisted-user-id",
+    deduplicated: false,
+  }));
+  const messages: unknown[] = [];
+  let processing = false;
+  let enabledPlugins: string[] | null = null;
+  const conversation = {
+    conversationId: "conv-plugins-test",
+    messages,
+    get enabledPlugins(): string[] | null {
+      return enabledPlugins;
+    },
+    set enabledPlugins(value: string[] | null) {
+      enabledPlugins = value;
+    },
+    abortController: null,
+    currentRequestId: undefined,
+    queue: { length: 0 },
+    setTrustContext: () => {},
+    updateClient: () => {},
+    emitConfirmationStateChanged: () => {},
+    emitActivityState: () => {},
+    setTurnChannelContext: () => {},
+    setTurnInterfaceContext: () => {},
+    getTurnChannelContext: () => null,
+    getTurnInterfaceContext: () => null,
+    ensureActorScopedHistory: async () => {},
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
+    setEnabledPlugins: (plugins: string[] | null) => {
+      enabledPlugins = plugins;
+    },
+    hasAnyPendingConfirmation: () => false,
+    denyAllPendingConfirmations: () => {},
+    enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
+    persistUserMessage,
+    runAgentLoop,
+    setPreactivatedSkillIds: () => {},
+    drainQueue: async () => {},
+    warmPromptCache: () => {},
+    getMessages: () => messages,
+    assistantId: "self",
+    trustContext: undefined,
+    hasPendingConfirmation: () => false,
+    setHostBrowserProxy: () => {},
+    setHostCuProxy: () => {},
+    setHostAppControlProxy: () => {},
+    addPreactivatedSkillId: () => {},
+    usageStats: { inputTokens: 1000, outputTokens: 500, estimatedCost: 0.05 },
+  } as unknown as import("../daemon/conversation.js").Conversation;
+  return { conversation, runAgentLoop };
+}
+
+function makeRequest(extras: Record<string, unknown> = {}) {
+  return new Request("http://localhost/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-vellum-actor-principal-id": "test-user",
+      "x-vellum-principal-type": "actor",
+    },
+    body: JSON.stringify({
+      conversationKey: "plugins-test-key",
+      content: "hello there",
+      sourceChannel: "vellum",
+      interface: "macos",
+      ...extras,
+    }),
+  });
+}
+
+function makeDeps(
+  conversation: import("../daemon/conversation.js").Conversation,
+) {
+  return {
+    sendMessageDeps: {
+      getOrCreateConversation: async () => conversation,
+      assistantEventHub: { publish: async () => {} } as never,
+      resolveAttachments: () => [],
+    },
+  };
+}
+
+describe("handleSendMessage enabledPlugins", () => {
+  beforeEach(() => {
+    addMessageMock.mockClear();
+    setConversationEnabledPluginsMock.mockClear();
+    ipcCallMock.mockClear();
+  });
+
+  afterEach(() => {
+    setConversationEnabledPluginsMock.mockClear();
+  });
+
+  test("persists and applies enabledPlugins when minting a conversation", async () => {
+    const { conversation } = makeConversation();
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(conversation)),
+      makeRequest({ enabledPlugins: ["a", "b"] }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+
+    // Persisted to the conversation row.
+    expect(setConversationEnabledPluginsMock).toHaveBeenCalledTimes(1);
+    expect(setConversationEnabledPluginsMock).toHaveBeenCalledWith(
+      "conv-plugins-test",
+      ["a", "b"],
+    );
+
+    // Applied to the live conversation instance: the user's selection, unioned
+    // with the always-on first-party defaults (which the pills never list).
+    const effective = getEffectiveEnabledPluginSet(conversation);
+    expect(effective?.has("a")).toBe(true);
+    expect(effective?.has("b")).toBe(true);
+    expect(effective?.has("default-memory")).toBe(true);
+  });
+
+  test("empty array scopes the chat to no plugins", async () => {
+    const { conversation } = makeConversation();
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(conversation)),
+      makeRequest({ enabledPlugins: [] }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    expect(setConversationEnabledPluginsMock).toHaveBeenCalledWith(
+      "conv-plugins-test",
+      [],
+    );
+    // No user plugins are in scope, but the always-on first-party defaults are
+    // never filtered out — core runtime infra must keep running.
+    const effective = getEffectiveEnabledPluginSet(conversation);
+    expect(effective).not.toBeNull();
+    expect(effective?.has("default-memory")).toBe(true);
+    expect(effective?.has("a")).toBe(false);
+  });
+
+  test("explicit null clears to the default (no per-chat restriction)", async () => {
+    const { conversation } = makeConversation();
+    conversation.enabledPlugins = ["pre-existing"];
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(conversation)),
+      makeRequest({ enabledPlugins: null }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    expect(setConversationEnabledPluginsMock).toHaveBeenCalledWith(
+      "conv-plugins-test",
+      null,
+    );
+    expect(getEffectiveEnabledPluginSet(conversation)).toBeNull();
+  });
+
+  test("omitting the field leaves the stored value untouched", async () => {
+    const { conversation } = makeConversation();
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(conversation)),
+      makeRequest(),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    expect(setConversationEnabledPluginsMock).not.toHaveBeenCalled();
+    expect(getEffectiveEnabledPluginSet(conversation)).toBeNull();
+  });
+
+  test("rejects non-array, non-null enabledPlugins values", async () => {
+    const { conversation } = makeConversation();
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(conversation)),
+      makeRequest({ enabledPlugins: "not-an-array" }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(400);
+    const text = await res.text();
+    expect(text).toContain("enabledPlugins");
+    expect(setConversationEnabledPluginsMock).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/conversation-skill-tools.test.ts

@@ -47,6 +47,19 @@ let recordedLastUsedTouches: Array<{ skillDir: string; today: string }> = [];
 
 mock.module("../config/skills.js", () => ({
   loadSkillCatalog: () => mockCatalog,
+  // Faithful reimplementation of the real plugin-scope filter — the
+  // per-chat plugin scope suite below depends on its drop behavior.
+  filterSkillsByEnabledPlugins: (
+    skills: SkillSummary[],
+    effectiveEnabledPluginSet: Set<string> | null,
+  ) =>
+    effectiveEnabledPluginSet === null
+      ? skills
+      : skills.filter((skill) => {
+          const owner = skill.owner;
+          if (owner?.kind !== "plugin") return true;
+          return effectiveEnabledPluginSet.has(owner.id);
+        }),
 }));
 
 mock.module("../skills/active-skill-tools.js", () => {
@@ -3007,6 +3020,66 @@ describe("includes metadata does not auto-activate child skill tools", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Per-chat plugin scope — effectiveEnabledPluginSet drops plugin skills
+// ---------------------------------------------------------------------------
+
+describe("projectSkillTools per-chat plugin scope", () => {
+  function makePluginSkill(id: string, pluginId: string): SkillSummary {
+    return {
+      ...makeSkill(id, `/skills/${id}`, "plugin"),
+      owner: { kind: "plugin", id: pluginId },
+    };
+  }
+
+  beforeEach(() => {
+    mockCatalog = [makeSkill("deploy"), makePluginSkill("plug_skill", "b")];
+    mockManifests = {
+      deploy: makeManifest(["deploy_run"]),
+      plug_skill: makeManifest(["plug_action"]),
+    };
+    mockRegisteredTools = new Map();
+    mockUnregisteredSkillIds = [];
+    mockSkillRefCount = new Map();
+    mockVersionHashes = {};
+    mockVersionHashErrors = new Set();
+    mockRegisterFailures = new Set();
+  });
+
+  test("set excluding the owning plugin drops that plugin's skill tools", () => {
+    const result = projectSkillTools([], {
+      preactivatedSkillIds: ["deploy", "plug_skill"],
+      previouslyActiveSkillIds: new Map<string, string>(),
+      effectiveEnabledPluginSet: new Set(["a"]),
+    });
+
+    expect(result.allowedToolNames.has("deploy_run")).toBe(true);
+    expect(result.allowedToolNames.has("plug_action")).toBe(false);
+  });
+
+  test("null set leaves plugin skill resolution unchanged", () => {
+    const result = projectSkillTools([], {
+      preactivatedSkillIds: ["deploy", "plug_skill"],
+      previouslyActiveSkillIds: new Map<string, string>(),
+      effectiveEnabledPluginSet: null,
+    });
+
+    expect(result.allowedToolNames.has("deploy_run")).toBe(true);
+    expect(result.allowedToolNames.has("plug_action")).toBe(true);
+  });
+
+  test("set including the owning plugin keeps that plugin's skill tools", () => {
+    const result = projectSkillTools([], {
+      preactivatedSkillIds: ["deploy", "plug_skill"],
+      previouslyActiveSkillIds: new Map<string, string>(),
+      effectiveEnabledPluginSet: new Set(["b"]),
+    });
+
+    expect(result.allowedToolNames.has("deploy_run")).toBe(true);
+    expect(result.allowedToolNames.has("plug_action")).toBe(true);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Skill load harness — validates shared test helpers
 // ---------------------------------------------------------------------------