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

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__/list-messages-background-tool-completion.test.ts

@@ -4,7 +4,7 @@
  * A backgrounded bash/host_bash run posts a `<background_event
  * source="background-tool">` wake on completion, stamped with
  * `metadata.backgroundToolCompletion`. The history projection must surface
- * that structured record (and the `backgroundToolNotification` flag) so the
+ * that structured record (and the `backgroundEventNotification` flag) so the
  * web can rebuild a terminal inline card after a daemon restart.
  */
 
@@ -48,7 +48,7 @@ function resetTables() {
 
 interface ProjectedMessage {
   role: string;
-  backgroundToolNotification?: boolean;
+  backgroundEventNotification?: boolean;
   backgroundToolCompletion?: Record<string, unknown>;
 }
 
@@ -76,8 +76,8 @@ describe("handleListMessages background-tool completion projection", () => {
     };
     // Mirror persistWakeTriggerMessage: a user-role
     // `<background_event source="background-tool">` row carrying the structured
-    // completion. Not flagged `hidden`; the client suppresses it from the
-    // transcript via `backgroundToolNotification`.
+    // completion. The client suppresses it from the transcript via
+    // `backgroundEventNotification`.
     await addMessage(
       conv.id,
       "user",
@@ -110,7 +110,7 @@ describe("handleListMessages background-tool completion projection", () => {
       (m) => m.backgroundToolCompletion !== undefined,
     );
     expect(wakeRow).toBeDefined();
-    expect(wakeRow?.backgroundToolNotification).toBe(true);
+    expect(wakeRow?.backgroundEventNotification).toBe(true);
     expect(wakeRow?.backgroundToolCompletion).toEqual(completion);
   });
 
@@ -134,7 +134,7 @@ describe("handleListMessages background-tool completion projection", () => {
     expect(response.messages).toHaveLength(2);
     for (const message of response.messages) {
       expect(message.backgroundToolCompletion).toBeUndefined();
-      expect(message.backgroundToolNotification).toBeUndefined();
+      expect(message.backgroundEventNotification).toBeUndefined();
       expect(() => ConversationMessageSchema.parse(message)).not.toThrow();
     }
   });

package/src/__tests__/list-messages-queued.test.ts

@@ -178,6 +178,31 @@ describe("handleListMessages in-memory queue", () => {
     expect(att?.id).toBe("req-att:attachment:0");
   });
 
+  test("filters hidden queued messages from the snapshot, keeping positions contiguous", async () => {
+    // A hidden send (e.g. the channel-setup wizard-close marker) that queued
+    // behind an in-flight turn must not surface as a queued bubble on a
+    // reload/reconnect fetch; visible siblings keep 1-based positions.
+    const conv = createConversation();
+    registerLiveConversation(conv.id, [
+      makeQueued({
+        requestId: "req-hidden",
+        content:
+          "[User action on channel_setup surface: closed the slack setup wizard]",
+        metadata: { hidden: true },
+      }),
+      makeQueued({ requestId: "req-visible", content: "a real message" }),
+    ]);
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].id).toBe("req-visible");
+    expect(body.messages[0].queuePosition).toBe(1);
+  });
+
   test("does not append queued messages to an older-history page", async () => {
     // GIVEN history requested with beforeTimestamp (older page)
     const conv = createConversation();

package/src/__tests__/slack-app-setup-skill-regression.test.ts

@@ -32,6 +32,30 @@ describe("slack-app-setup skill regression", () => {
     );
   });
 
+  test("verifies on the wizard-closed auto-notify instead of manual confirmation", () => {
+    // Step 2 must promise the auto-notify rather than asking the user to
+    // report back...
+    expect(skillContent).toContain(
+      "The wizard will auto-notify me when you close it",
+    );
+    expect(skillContent).not.toContain("let me know when you're done");
+    // ...and Step 3 must trigger on the notification, keyed to the exact
+    // marker the web client sends on drawer close (see
+    // `clients/web/src/domains/chat/channel-setup-close-notify.ts`).
+    expect(skillContent).toContain("wizard-closed notification");
+    expect(skillContent).toContain(
+      "[User action on channel_setup surface: closed the slack setup wizard]",
+    );
+    // Phone-sized clients open the setup on the Contacts page, which cannot
+    // auto-notify on completion — the client signals the relocation with a
+    // hand-off marker and the skill must react by asking the user to report
+    // back instead of waiting for a wizard-closed notification.
+    expect(skillContent).toContain(
+      "[User action on channel_setup surface: moved the slack setup to the Contacts page]",
+    );
+    expect(skillContent).toContain("Hand-off notification");
+  });
+
   test("retains the Settings clearing path", () => {
     expect(skillContent).toContain(
       "same Slack settings handler used by Settings",

package/src/__tests__/title-generate-hook.test.ts

@@ -185,6 +185,22 @@ describe("title-generate user-prompt-submit hook", () => {
     expect(call).not.toHaveProperty("onTitleUpdated");
   });
 
+  test("skips title generation for hidden machine-signal prompts", async () => {
+    // A hidden send (e.g. the channel-setup wizard-close marker) is not user
+    // speech — minting a title from it would surface invisible scaffolding
+    // text in the sidebar.
+    const ctx = makeCtx({
+      prompt:
+        "[User action on channel_setup surface: closed the slack setup wizard]",
+      isHiddenPrompt: true,
+    });
+
+    await userPromptSubmit(ctx);
+    await flushMacrotasks();
+
+    expect(queueGenerateConversationTitleMock).toHaveBeenCalledTimes(0);
+  });
+
   test("does not block: returns before the title job is scheduled", async () => {
     // GIVEN a fresh user prompt submission
     const ctx = makeCtx();

package/src/api/responses/conversation-message.ts

@@ -567,13 +567,13 @@ export const ConversationMessageSchema = z.object({
   contentBlocks: z.array(ConversationContentBlockSchema).optional(),
   subagentNotification: ConversationSubagentNotificationSchema.optional(),
   acpNotification: ConversationAcpNotificationSchema.optional(),
-  /** Set on the persisted `<background_event source="background-tool">` wake a
-   *  backgrounded bash/host_bash run posts on completion. Like the subagent/ACP
-   *  notifications, the row stays in state (the LLM reads it) but is filtered
-   *  from the rendered transcript — the inline card carries the status. */
-  backgroundToolNotification: z.boolean().optional(),
+  /** Set on any persisted `<background_event source="...">` wake trigger row.
+   *  Like the subagent/ACP notifications, the row stays in state (the LLM reads
+   *  it) but is filtered from the rendered transcript — the user-facing wake
+   *  card carries the status. */
+  backgroundEventNotification: z.boolean().optional(),
   /** Structured completion of a backgrounded bash/host_bash run, stamped on the
-   *  same persisted background-event wake row as `backgroundToolNotification`.
+   *  same persisted background-event wake row as `backgroundEventNotification`.
    *  Lets the web reconstruct a terminal inline card after a daemon restart
    *  (the in-memory completed ring does not survive restarts). `id` equals the
    *  spawning tool call's `{backgrounded,id}` id. */

package/src/daemon/conversation-agent-loop.ts

@@ -261,6 +261,13 @@ export async function runAgentLoopImpl(
     isInteractive?: boolean;
     isUserMessage?: boolean;
     titleText?: string;
+    /**
+     * True when the triggering message is a transcript-suppressed machine
+     * signal (`metadata.hidden`). Forwarded to the user-prompt-submit hook
+     * context so prompt-as-user-speech consumers (title generation) skip
+     * the turn.
+     */
+    isHiddenPrompt?: boolean;
     /**
      * LLM call-site identifier threaded into the per-call provider config.
      * Adapter callers (heartbeat, filing, scheduler, etc.) pass their own
@@ -903,6 +910,7 @@ export async function runAgentLoopImpl(
       userMessageId,
       requestId: reqId,
       prompt: options?.titleText ?? content,
+      isHiddenPrompt: options?.isHiddenPrompt === true,
       originalMessages: ctx.messages,
       latestMessages: ctx.messages,
       logger: rlog,