@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

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

@@ -0,0 +1,407 @@
+/**
+ * Queue-branch contract for hidden sends in POST /v1/messages.
+ *
+ * A hidden send is a machine signal (e.g. the channel-setup wizard-close
+ * marker), not a user decision — when it queues behind an in-flight turn it
+ * must NOT supersede pending interactions: no auto-denied confirmations, no
+ * steer of a parked ask_question. A visible send in the same state keeps the
+ * existing supersede behavior ("the user chose to move on").
+ */
+import { afterEach, 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" },
+    },
+  }),
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../persistence/conversation-key-store.js", () => ({
+  getOrCreateConversation: () => ({ conversationId: "conv-hidden-queue" }),
+  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: () => [],
+  resolveCanonicalGuardianRequest: () => undefined,
+}));
+
+mock.module("../runtime/confirmation-request-guardian-bridge.js", () => ({
+  bridgeConfirmationRequestToGuardian: async () => undefined,
+}));
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  addMessage: async (_conversationId: string, role: string) => ({
+    id: role === "user" ? "persisted-user-id" : "persisted-assistant-id",
+    deduplicated: false,
+  }),
+  extractImageSourcePaths: () => undefined,
+  getConversation: () => null,
+  getConversationOverrideProfile: () => undefined,
+  getMessages: () => [],
+  isHiddenMessageMetadata: (meta: Record<string, unknown> | undefined) =>
+    meta?.hidden === true,
+  provenanceFromTrustContext: (ctx: unknown) =>
+    ctx
+      ? { provenanceTrustClass: (ctx as Record<string, unknown>).trustClass }
+      : { provenanceTrustClass: "unknown" },
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+  setConversationInferenceProfile: () => {},
+  setConversationEnabledPlugins: () => {},
+  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",
+    },
+  ],
+}));
+
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: async () => ({ ok: true }),
+}));
+
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+import { handleSendMessage } from "../runtime/routes/conversation-routes.js";
+import { callHandler } from "./helpers/call-route-handler.js";
+
+const CONV_ID = "conv-hidden-queue";
+
+interface BusyConversationSpies {
+  conversation: Conversation;
+  enqueuedMetadata: () => Record<string, unknown> | undefined;
+  denyAllCount: () => number;
+  abortCount: () => number;
+  agentLoopOptions: () => Record<string, unknown> | undefined;
+}
+
+/**
+ * A live conversation with a pending tool confirmation. `processing: true`
+ * models a mid-turn conversation (queue branch); `false` an idle one whose
+ * confirmation outlived its turn (e.g. a guardian approval awaiting a
+ * channel reply).
+ */
+function makeConversationWithPendingConfirmation(
+  processing: boolean,
+): BusyConversationSpies {
+  let enqueuedMetadata: Record<string, unknown> | undefined;
+  let denyAllCount = 0;
+  let abortCount = 0;
+  let agentLoopOptions: Record<string, unknown> | undefined;
+  const conversation = {
+    conversationId: CONV_ID,
+    messages: [],
+    abortController: {
+      abort: () => {
+        abortCount += 1;
+      },
+    },
+    currentRequestId: undefined,
+    queue: {
+      length: 0,
+      promoteToHead: (requestId: string) => ({ requestId }),
+    },
+    pendingSteerRepair: false,
+    setTrustContext: () => {},
+    updateClient: () => {},
+    emitConfirmationStateChanged: () => {},
+    emitActivityState: () => {},
+    setTurnChannelContext: () => {},
+    setTurnInterfaceContext: () => {},
+    getTurnChannelContext: () => null,
+    getTurnInterfaceContext: () => null,
+    ensureActorScopedHistory: async () => {},
+    isProcessing: () => processing,
+    setProcessing: () => {},
+    hasAnyPendingConfirmation: () => true,
+    denyAllPendingConfirmations: () => {
+      denyAllCount += 1;
+    },
+    enqueueMessage: (options: { metadata?: Record<string, unknown> }) => {
+      enqueuedMetadata = options.metadata;
+      return { queued: true, requestId: "queued-id" };
+    },
+    persistUserMessage: async () => ({
+      id: "persisted-user-id",
+      deduplicated: false,
+    }),
+    runAgentLoop: async (
+      _content: string,
+      _messageId: string,
+      options?: Record<string, unknown>,
+    ) => {
+      agentLoopOptions = options;
+    },
+    setPreactivatedSkillIds: () => {},
+    drainQueue: async () => {},
+    warmPromptCache: () => {},
+    getMessages: () => [],
+    assistantId: "self",
+    trustContext: undefined,
+    hasPendingConfirmation: () => false,
+    setHostBrowserProxy: () => {},
+    setHostCuProxy: () => {},
+    setHostAppControlProxy: () => {},
+    addPreactivatedSkillId: () => {},
+    usageStats: { inputTokens: 1000, outputTokens: 500, estimatedCost: 0.05 },
+  } as unknown as Conversation;
+  return {
+    conversation,
+    enqueuedMetadata: () => enqueuedMetadata,
+    denyAllCount: () => denyAllCount,
+    abortCount: () => abortCount,
+    agentLoopOptions: () => agentLoopOptions,
+  };
+}
+
+function makeBusyConversation(): BusyConversationSpies {
+  return makeConversationWithPendingConfirmation(true);
+}
+
+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: "hidden-queue-key",
+      content:
+        "[User action on channel_setup surface: closed the slack setup wizard]",
+      sourceChannel: "vellum",
+      interface: "macos",
+      ...extras,
+    }),
+  });
+}
+
+function makeDeps(conversation: Conversation) {
+  return {
+    sendMessageDeps: {
+      getOrCreateConversation: async () => conversation,
+      assistantEventHub: { publish: async () => {} } as never,
+      resolveAttachments: () => [],
+    },
+  };
+}
+
+const registeredRequestIds: string[] = [];
+function registerConfirmation(): void {
+  const requestId = `pending-confirmation-${registeredRequestIds.length}`;
+  pendingInteractions.register(requestId, {
+    conversationId: CONV_ID,
+    kind: "confirmation",
+  });
+  registeredRequestIds.push(requestId);
+}
+
+afterEach(() => {
+  for (const id of registeredRequestIds) {
+    pendingInteractions.resolve(id, "cancelled");
+  }
+  registeredRequestIds.length = 0;
+  deleteConversation(CONV_ID);
+});
+
+describe("hidden sends queued behind an in-flight turn", () => {
+  test("carry hidden metadata and do NOT supersede pending interactions", async () => {
+    const spies = makeBusyConversation();
+    setConversation(CONV_ID, spies.conversation);
+    registerConfirmation();
+
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(spies.conversation)),
+      makeRequest({ hidden: true }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    // Queued with the transcript-suppression flag intact...
+    expect(spies.enqueuedMetadata()?.hidden).toBe(true);
+    // ...without auto-denying the live approval prompt or aborting the turn:
+    // a passive UI event is not the user choosing to move on.
+    expect(spies.denyAllCount()).toBe(0);
+    expect(spies.abortCount()).toBe(0);
+  });
+
+  test("visible sends in the same state keep the supersede behavior", async () => {
+    const spies = makeBusyConversation();
+    setConversation(CONV_ID, spies.conversation);
+    registerConfirmation();
+
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(spies.conversation)),
+      makeRequest({ content: "actually, do this instead" }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    expect(spies.enqueuedMetadata()?.hidden).toBeUndefined();
+    // The typed message supersedes: pending confirmations are auto-denied.
+    expect(spies.denyAllCount()).toBe(1);
+  });
+});
+
+describe("hidden sends to an idle conversation with a pending confirmation", () => {
+  test("do NOT auto-deny the confirmation and mark the turn as a hidden prompt", async () => {
+    const spies = makeConversationWithPendingConfirmation(false);
+    setConversation(CONV_ID, spies.conversation);
+    registerConfirmation();
+
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(spies.conversation)),
+      makeRequest({ hidden: true }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    // The confirmation that outlived its turn (e.g. a guardian approval
+    // awaiting a channel reply) survives the machine signal...
+    expect(spies.denyAllCount()).toBe(0);
+    // ...and the turn is flagged so prompt-as-user-speech consumers (title
+    // generation) skip it.
+    expect(spies.agentLoopOptions()?.isHiddenPrompt).toBe(true);
+  });
+
+  test("visible sends to the same state keep the idle auto-deny cleanup", async () => {
+    const spies = makeConversationWithPendingConfirmation(false);
+    setConversation(CONV_ID, spies.conversation);
+    registerConfirmation();
+
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(spies.conversation)),
+      makeRequest({ content: "hello again" }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    expect(spies.denyAllCount()).toBe(1);
+    expect(spies.agentLoopOptions()?.isHiddenPrompt).toBeUndefined();
+  });
+});

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -33,15 +33,13 @@ mock.module("../config/loader.js", () => ({
   },
 }));
 
-// `resolveTurnInboundActorContext` reads INFO (contact notes / interaction
-// count) via a local contactId join. Stub the join so the actor-context tests
-// can stage it without standing up the contacts schema.
+// `resolveTurnInboundActorContext` reads the INFO `notes` field via a local
+// contactId join (interaction count now comes from the gateway verdict). Stub
+// the join so the actor-context tests can stage it without standing up the
+// contacts schema.
 const realContactStoreForAssemblyTest =
   await import("../contacts/contact-store.js");
-let contactInfoById: Record<
-  string,
-  { notes: string | null; interactionCount: number }
-> = {};
+let contactInfoById: Record<string, { notes: string | null }> = {};
 mock.module("../contacts/contact-store.js", () => ({
   ...realContactStoreForAssemblyTest,
   findContactInfoById: (contactId: string) =>
@@ -1592,15 +1590,13 @@ describe("resolveTurnInboundActorContext", () => {
   });
 
   /**
-   * INFO fields (contact notes, interaction count) are joined locally by the
-   * verdict-stamped contact ID, not re-resolved through the ACL store.
+   * The INFO `notes` field is joined locally by the verdict-stamped contact ID,
+   * while the interaction count is gateway-owned and carried on the verdict
+   * (never re-resolved through the ACL store or the local aggregation).
    */
-  test("populates INFO via the local contactId join", () => {
-    // GIVEN a contact whose INFO is available by id
-    contactInfoById["contact-42"] = {
-      notes: "prefers async updates",
-      interactionCount: 7,
-    };
+  test("notes come from the local join; interaction count from the verdict", () => {
+    // GIVEN a contact whose notes are available by id
+    contactInfoById["contact-42"] = { notes: "prefers async updates" };
     const trustContext: TrustContext = {
       sourceChannel: "telegram",
       trustClass: "trusted_contact",
@@ -1609,17 +1605,41 @@ describe("resolveTurnInboundActorContext", () => {
       requesterContactId: "contact-42",
       memberStatus: "active",
       memberPolicy: "allow",
+      // Gateway-owned interaction telemetry, stamped from the trust verdict.
+      requesterInteractionCount: 7,
     };
 
     // WHEN the inbound actor context is resolved
     const actorContext = resolveTurnInboundActorContext(trustContext);
 
-    // THEN INFO comes from the local join and ACL stays verdict-derived
+    // THEN notes come from the local join, the count from the verdict, and ACL
+    // stays verdict-derived
     expect(actorContext?.contactNotes).toBe("prefers async updates");
     expect(actorContext?.contactInteractionCount).toBe(7);
     expect(actorContext?.memberStatus).toBe("active");
     expect(resolveActorTrustCalls).toBe(0);
   });
+
+  /**
+   * A verdict without member telemetry (unknown sender) leaves the interaction
+   * count undefined rather than reviving a local assistant-DB read.
+   */
+  test("interaction count is undefined when the verdict carries none", () => {
+    contactInfoById["contact-99"] = { notes: "some note" };
+    const trustContext: TrustContext = {
+      sourceChannel: "telegram",
+      trustClass: "trusted_contact",
+      requesterExternalUserId: "tg-999",
+      requesterChatId: "chat-9",
+      requesterContactId: "contact-99",
+      // No requesterInteractionCount stamped.
+    };
+
+    const actorContext = resolveTurnInboundActorContext(trustContext);
+
+    expect(actorContext?.contactNotes).toBe("some note");
+    expect(actorContext?.contactInteractionCount).toBeUndefined();
+  });
 });
 
 // ---------------------------------------------------------------------------

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
 // ---------------------------------------------------------------------------

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

@@ -118,16 +118,31 @@ describe("wipeConversation", () => {
       }
     ).$client;
 
-    // Both jobs should be failed with conversation_wiped error
     const jobs = raw
-      .query("SELECT status, last_error FROM memory_jobs")
-      .all() as Array<{ status: string; last_error: string | null }>;
-
-    for (const job of jobs) {
+      .query("SELECT type, status, last_error FROM memory_jobs")
+      .all() as Array<{
+      type: string;
+      status: string;
+      last_error: string | null;
+    }>;
+
+    // The pre-existing jobs should be failed with the conversation_wiped error.
+    for (const job of jobs.filter(
+      (j) => j.type !== "purge_conversation_lexical",
+    )) {
       expect(job.status).toBe("failed");
       expect(job.last_error).toContain("conversation_wiped");
     }
 
+    // Wiping also enqueues a lexical-index purge, which must SURVIVE the
+    // job-cancellation pass (it is enqueued after cancellation) so the worker
+    // can delete the conversation's Qdrant points.
+    const purgeJobs = jobs.filter(
+      (j) => j.type === "purge_conversation_lexical",
+    );
+    expect(purgeJobs).toHaveLength(1);
+    expect(purgeJobs[0].status).toBe("pending");
+
     expect(result.cancelledJobCount).toBeGreaterThanOrEqual(2);
   });