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

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__/guardian-question-mode.test.ts

@@ -9,10 +9,12 @@ import {
   buildGuardianRequestCodeInstruction,
   hasGuardianRequestCodeInstruction,
   parseGuardianQuestionPayload,
+  parseInteractiveApprovalPayload,
   resolveGuardianInstructionModeForRequest,
   resolveGuardianInstructionModeFromFields,
   resolveGuardianQuestionInstructionMode,
   stripConflictingGuardianRequestInstructions,
+  stripGuardianRequestCodeInstructions,
 } from "../notifications/guardian-question-mode.js";
 
 describe("guardian-question-mode", () => {
@@ -228,4 +230,59 @@ describe("guardian-question-mode", () => {
       ),
     ).toBe("");
   });
+
+  test("stripGuardianRequestCodeInstructions removes both-mode directives and bare code mentions", () => {
+    const text = [
+      "Alice is asking to run ls /tmp.",
+      "Approval code: A1B2C3",
+      'Reference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
+      'Reply "A1B2C3 <your answer>".',
+    ].join("\n");
+
+    expect(stripGuardianRequestCodeInstructions(text, "A1B2C3")).toBe(
+      "Alice is asking to run ls /tmp.",
+    );
+  });
+
+  test("stripGuardianRequestCodeInstructions leaves unrelated text and other codes intact", () => {
+    const text = 'Approval code: ZZZZZZ. Reply "A1B2C3 approve" if you agree.';
+    expect(stripGuardianRequestCodeInstructions(text, "A1B2C3")).toBe(text);
+  });
+
+  test("parseInteractiveApprovalPayload accepts approval-mode payloads with a requestId", () => {
+    expect(
+      parseInteractiveApprovalPayload({
+        requestKind: "tool_grant_request",
+        requestId: "req-1",
+        requestCode: "A1B2C3",
+        questionText: "Allow host bash?",
+        toolName: "host_bash",
+      }),
+    ).not.toBeNull();
+  });
+
+  test("parseInteractiveApprovalPayload rejects answer-mode and unparseable payloads", () => {
+    // Answer mode: free-text questions get no Approve/Reject buttons.
+    expect(
+      parseInteractiveApprovalPayload({
+        requestKind: "pending_question",
+        requestId: "req-2",
+        requestCode: "A1B2C3",
+        questionText: "What time works?",
+        callSessionId: "call-1",
+        activeGuardianRequestCount: 1,
+      }),
+    ).toBeNull();
+
+    // Strict-parse failure: missing required pending_question fields.
+    expect(
+      parseInteractiveApprovalPayload({
+        requestKind: "pending_question",
+        requestId: "req-3",
+        requestCode: "A1B2C3",
+        questionText: "Allow send_email?",
+        toolName: "send_email",
+      }),
+    ).toBeNull();
+  });
 });

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__/notification-decision-fallback.test.ts

@@ -285,6 +285,100 @@ describe("notification decision fallback copy", () => {
     expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 reject"');
     expect(decision.renderedCopy.vellum?.body).not.toContain("<your answer>");
   });
+
+  test("slack approval copy is stripped of request-code instructions instead of enforced", async () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: "req-grant-slack-1",
+        questionText: "Approve tool: bash — ls /tmp (requested by Alice)",
+        requestCode: "A1B2C3",
+        requestKind: "tool_grant_request",
+        toolName: "bash",
+      },
+    });
+
+    const decision = await evaluateSignal(signal, [
+      "vellum",
+      "slack",
+    ] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(true);
+    // Vellum keeps the code-reply directive.
+    expect(decision.renderedCopy.vellum?.body).toContain('"A1B2C3 approve"');
+    // Slack renders Approve/Reject buttons — no code anywhere in its copy.
+    expect(decision.renderedCopy.slack?.body).toBe(
+      "Approve tool: bash — ls /tmp (requested by Alice)",
+    );
+    expect(decision.renderedCopy.slack?.body).not.toContain("A1B2C3");
+  });
+
+  test("slack copy strips LLM-authored approval-code phrasing for approval requests", async () => {
+    configuredProvider = {
+      sendMessage: async () => ({ content: [] }),
+    };
+    extractedToolUse = {
+      name: "record_notification_decision",
+      input: {
+        shouldNotify: true,
+        selectedChannels: ["slack"],
+        reasoningSummary: "LLM decision",
+        renderedCopy: {
+          slack: {
+            title: "Tool Grant Request",
+            body: "Alice is asking to run ls /tmp.",
+            deliveryText:
+              'Alice is asking to run ls /tmp.\nApproval code: A1B2C3\nReference code: A1B2C3. Reply "A1B2C3 approve" or "A1B2C3 reject".',
+          },
+        },
+        dedupeKey: "guardian-question-slack-llm-test",
+        confidence: 0.9,
+      },
+    };
+
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: "req-grant-slack-2",
+        questionText: "Approve tool: bash — ls /tmp (requested by Alice)",
+        requestCode: "A1B2C3",
+        requestKind: "tool_grant_request",
+        toolName: "bash",
+      },
+    });
+
+    const decision = await evaluateSignal(signal, [
+      "slack",
+    ] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(false);
+    expect(decision.renderedCopy.slack?.deliveryText).toBe(
+      "Alice is asking to run ls /tmp.",
+    );
+    expect(decision.renderedCopy.slack?.body).toBe(
+      "Alice is asking to run ls /tmp.",
+    );
+  });
+
+  test("slack answer-mode questions keep code instructions (no buttons render)", async () => {
+    const signal = makeSignal({
+      contextPayload: {
+        requestId: "req-pending-slack-1",
+        questionText: "What is the gate code?",
+        requestCode: "A1B2C3",
+        requestKind: "pending_question",
+        callSessionId: "call-1",
+        activeGuardianRequestCount: 1,
+      },
+    });
+
+    const decision = await evaluateSignal(signal, [
+      "slack",
+    ] as NotificationChannel[]);
+
+    expect(decision.fallbackUsed).toBe(true);
+    expect(decision.renderedCopy.slack?.body).toContain(
+      '"A1B2C3 <your answer>"',
+    );
+  });
 });
 
 // ── Access-request instruction enforcement ──────────────────────────────

package/src/__tests__/pre-model-call-sanitize.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { preModelCallSanitize } from "../agent/loop.js";
+import { preModelCallSanitize } from "../context/outbound-sanitize.js";
 import type { Message } from "../providers/types.js";
 
 /**