@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/tools/acp/spawn.ts

@@ -111,7 +111,7 @@ export async function executeAcpSpawn(
       // This failure raises the inline Connect card. Record it so the
       // credential-prompt route only redirects a redundant secure-prompt when a
       // card actually exists (not for a proactive prompt before any failure).
-      markAcpConnectCardRaised(context.conversationId);
+      markAcpConnectCardRaised(context.conversationId, agent);
     }
     return { content: msg, isError: true, ...(errorCode ? { errorCode } : {}) };
   }
@@ -174,7 +174,7 @@ export async function executeAcpSpawn(
         err instanceof Error
           ? err.message
           : String((err as { message?: unknown }).message ?? err);
-      markAcpConnectCardRaised(context.conversationId);
+      markAcpConnectCardRaised(context.conversationId, agent);
       return {
         content: `${message}\n\n${ACP_AUTH_RECOVERY_GUIDANCE}`,
         isError: true,

package/src/tools/browser/__tests__/browser-status.test.ts

@@ -5,6 +5,7 @@ import type { ToolContext } from "../../types.js";
 import {
   BROWSER_STATUS_INPUT_FIELD,
   BROWSER_STATUS_MODE,
+  CHROME_EXTENSION_INSTALL_HINT,
 } from "../browser-status-constants.js";
 import { CdpError } from "../cdp-client/errors.js";
 
@@ -214,6 +215,10 @@ describe("executeBrowserStatus", () => {
     expect(extension.summary).toContain("no Chrome Extension is connected");
     expect(extension.verified).toBe("preflight");
     expect(extension.details.transport).toBe("extension-ws");
+    expect(extension.userActions).toEqual([
+      CHROME_EXTENSION_INSTALL_HINT,
+      "Tell the user to make sure a browser is open with the Vellum Chrome extension on.",
+    ]);
   });
 
   test("probe failure diagnostics include remediation actions", async () => {
@@ -237,6 +242,10 @@ describe("executeBrowserStatus", () => {
     expect(extension).toBeDefined();
     expect(extension.available).toBe(false);
     expect(extension.summary).toContain("probe failed");
+    expect(extension.userActions).toEqual([
+      CHROME_EXTENSION_INSTALL_HINT,
+      "Tell the user to make sure a browser is open with the Vellum Chrome extension on.",
+    ]);
   });
 
   test("recommendation order follows auto candidate precedence with available extension", async () => {

package/src/tools/browser/browser-execution.ts

@@ -39,7 +39,8 @@ import {
   BROWSER_STATUS_MODES,
   type BrowserStatusMode,
   CDP_INSPECT_STATUS_DISCOVERY_CODE,
-  EXTENSION_STATUS_ERROR_MARKER,
+  CHROME_EXTENSION_INSTALL_HINT,
+  CHROME_WEB_STORE_INSTALL_URL,
 } from "./browser-status-constants.js";
 import {
   formatAxSnapshot,
@@ -296,6 +297,7 @@ export function parseBrowserMode(
 const REMEDIATION_HINTS: Record<string, string[]> = {
   // Extension backend
   "extension:transport_error": [
+    CHROME_EXTENSION_INSTALL_HINT,
     "Ensure the Vellum browser extension is installed and enabled, or that the macOS desktop client is running for host browser proxy mode.",
     "For extension mode: check that the extension WebSocket connection is active (extension popup → status).",
     "For macOS host browser proxy: verify the desktop client is running and has an active SSE connection to the assistant.",
@@ -335,11 +337,11 @@ const REMEDIATION_HINTS: Record<string, string[]> = {
     "Ensure Chrome on the user's machine is on version 146 or higher (chrome://settings/help).",
     'Ensure "Allow remote debugging for this browser instance" is toggled on at chrome://inspect/#remote-debugging.',
     "Verify the desktop client is running and has an active SSE connection to the assistant.",
-    "Installing the Vellum Chrome extension is the preferred path and avoids the debug-port requirement.",
+    `Installing the Vellum Chrome extension is the preferred path and avoids the debug-port requirement: ${CHROME_WEB_STORE_INSTALL_URL}`,
   ],
   "host-bridge:transport_error": [
     "The desktop client could not reach Chrome's remote-debugging endpoint on the user's machine.",
-    "Ensure Chrome is running with remote debugging enabled, or install the Vellum Chrome extension (preferred).",
+    `Ensure Chrome is running with remote debugging enabled, or install the Vellum Chrome extension (preferred): ${CHROME_WEB_STORE_INSTALL_URL}`,
     "Verify the desktop client is running and connected.",
   ],
   // Local/Playwright backend
@@ -2485,10 +2487,10 @@ function modeTradeoffs(mode: StatusCheckMode): string[] {
   return MODE_TRADEOFFS[mode];
 }
 
-function extensionSetupActions(): string[] {
+function extensionConnectionActions(): string[] {
   return [
-    "Install the Vellum Assistant Chrome extension from the Chrome Web Store: https://chromewebstore.google.com/detail/vellum-assistant-browser/hphbdmpffeigpcdjkckleobjmhhokpne",
-    "Open the extension and pair with your assistant.",
+    CHROME_EXTENSION_INSTALL_HINT,
+    "Tell the user to make sure a browser is open with the Vellum Chrome extension on.",
   ];
 }
 
@@ -2517,49 +2519,14 @@ function extractDiscoveryCodes(error: CdpError): string[] {
   return dedupeStrings(codes);
 }
 
-function containsTokenCaseInsensitive(text: string, token: string): boolean {
-  return text.toLowerCase().includes(token.toLowerCase());
-}
-
 function probeFailureActions(mode: StatusCheckMode, error: CdpError): string[] {
   const actions: string[] = [];
-  const message = error.message.toLowerCase();
   const discoveryCodes = extractDiscoveryCodes(error).map((c) =>
     c.toLowerCase(),
   );
 
   if (mode === BROWSER_STATUS_MODE.EXTENSION) {
-    actions.push(...extensionSetupActions());
-    if (
-      containsTokenCaseInsensitive(
-        message,
-        EXTENSION_STATUS_ERROR_MARKER.UNAUTHORIZED_ORIGIN,
-      )
-    ) {
-      actions.push(
-        "Ensure this extension ID is present in chrome-extension-allowlist.local.json in $GATEWAY_SECURITY_DIR and restart the assistant.",
-      );
-    }
-    if (
-      containsTokenCaseInsensitive(
-        message,
-        EXTENSION_STATUS_ERROR_MARKER.NATIVE_MESSAGING_HOST,
-      )
-    ) {
-      actions.push(
-        "Reinstall the native messaging host manifest and confirm it allows this extension ID.",
-      );
-    }
-    if (
-      containsTokenCaseInsensitive(
-        message,
-        EXTENSION_STATUS_ERROR_MARKER.HTTP_401,
-      )
-    ) {
-      actions.push(
-        "Re-pair the extension so it refreshes its local relay credential.",
-      );
-    }
+    actions.push(...extensionConnectionActions());
   }
 
   if (mode === BROWSER_STATUS_MODE.CDP_INSPECT) {
@@ -2651,7 +2618,7 @@ async function checkExtensionModeStatus(
       autoCandidate,
       summary:
         "Extension mode is unavailable: no Chrome Extension is connected.",
-      userActions: extensionSetupActions(),
+      userActions: extensionConnectionActions(),
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
       details: { transport: "extension-ws" },
     };

package/src/tools/browser/browser-manager.ts

@@ -268,6 +268,7 @@ class BrowserManager {
             {
               stdout: "pipe",
               stderr: "pipe",
+              windowsHide: true,
             },
           );
           const timeoutMs = 300_000;

package/src/tools/browser/browser-status-constants.ts

@@ -20,11 +20,12 @@ export const BROWSER_STATUS_INPUT_FIELD = {
   CHECK_LOCAL_LAUNCH: "check_local_launch",
 } as const;
 
-export const EXTENSION_STATUS_ERROR_MARKER = {
-  UNAUTHORIZED_ORIGIN: "unauthorized_origin",
-  NATIVE_MESSAGING_HOST: "native messaging host",
-  HTTP_401: "401",
-} as const;
+/** Chrome Web Store listing for the Vellum Assistant browser extension. */
+export const CHROME_WEB_STORE_INSTALL_URL =
+  "https://chromewebstore.google.com/detail/vellum-assistant-browser/hphbdmpffeigpcdjkckleobjmhhokpne";
+
+/** User-facing install step for status userActions and command-failure hints. */
+export const CHROME_EXTENSION_INSTALL_HINT = `Install the Vellum Assistant Chrome extension from the Chrome Web Store: ${CHROME_WEB_STORE_INSTALL_URL}`;
 
 export const CDP_INSPECT_STATUS_DISCOVERY_CODE = {
   NO_TARGETS: DEVTOOLS_DISCOVERY_CODE.NO_TARGETS,

package/src/tools/browser/runtime-check.ts

@@ -104,6 +104,7 @@ export async function importPlaywright(): Promise<typeof import("playwright")> {
       cwd: externalDir,
       stdout: "pipe",
       stderr: "pipe",
+      windowsHide: true,
     });
     const exitCode = await proc.exited;
     if (exitCode !== 0) {
@@ -168,6 +169,7 @@ export async function ensureChromiumHeadlessShell(
         stdout: "pipe",
         stderr: "pipe",
         cwd: externalPwExists ? externalDir : undefined,
+        windowsHide: true,
       },
     );
     const timeoutMs = 120_000;

package/src/tools/channel/react-to-message.test.ts

@@ -0,0 +1,193 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ReactionTarget } from "../../messaging/providers/channel-transport.js";
+import type { ToolContext } from "../types.js";
+
+let reactCalls: Array<{ channel: string; target: ReactionTarget }> = [];
+let reactResultOk = true;
+let channelSupported = true;
+
+mock.module("../../messaging/providers/index.js", () => ({
+  supportsChannelReaction: () => channelSupported,
+  sendChannelReaction: async (channel: string, target: ReactionTarget) => {
+    reactCalls.push({ channel, target });
+    return { ok: reactResultOk };
+  },
+}));
+
+import type { QueuedReactionRecord } from "../../daemon/reaction-record.js";
+
+let queued: Array<{ conversationId: string; record: QueuedReactionRecord }> =
+  [];
+let conversationResident = true;
+mock.module("../../daemon/conversation-registry.js", () => ({
+  findConversationOrSubagent: (id: string) =>
+    conversationResident
+      ? {
+          queueReactionRecord: (record: QueuedReactionRecord) =>
+            queued.push({ conversationId: id, record }),
+        }
+      : undefined,
+}));
+
+let directPersists: Array<{
+  conversationId: string;
+  records: readonly QueuedReactionRecord[];
+}> = [];
+mock.module("../../daemon/reaction-record.js", () => ({
+  persistReactionRecords: async (
+    conversationId: string,
+    records: readonly QueuedReactionRecord[],
+  ) => {
+    directPersists.push({ conversationId, records });
+  },
+}));
+
+const { reactToMessageTool } = await import("./react-to-message.js");
+
+function channelContext(overrides: Partial<ToolContext> = {}): ToolContext {
+  return {
+    workingDir: "/tmp",
+    conversationId: "conv-1",
+    trustClass: "guardian",
+    executionChannel: "slack",
+    requesterChatId: "C123",
+    sourceMessageId: "1700000000.111111",
+    ...overrides,
+  } as ToolContext;
+}
+
+describe("react_to_message", () => {
+  beforeEach(() => {
+    reactCalls = [];
+    reactResultOk = true;
+    channelSupported = true;
+    queued = [];
+    directPersists = [];
+    conversationResident = true;
+  });
+
+  test("reacts to the triggering message by default", async () => {
+    const result = await reactToMessageTool.execute(
+      { emoji: "thumbsup" },
+      channelContext(),
+    );
+    expect(result.isError).toBe(false);
+    expect(reactCalls).toHaveLength(1);
+    expect(reactCalls[0]).toEqual({
+      channel: "slack",
+      target: {
+        chatId: "C123",
+        messageId: "1700000000.111111",
+        emoji: "thumbsup",
+        action: "add",
+      },
+    });
+  });
+
+  test("an explicit messageId overrides the default target", async () => {
+    await reactToMessageTool.execute(
+      { emoji: "tada", messageId: "1700000000.222222" },
+      channelContext(),
+    );
+    expect(reactCalls[0]?.target.messageId).toBe("1700000000.222222");
+  });
+
+  test("the turn's thread coordinate rides only the default target", async () => {
+    await reactToMessageTool.execute(
+      { emoji: "tada" },
+      channelContext({ sourceThreadId: "THREAD-1" }),
+    );
+    expect(reactCalls[0]?.target.threadId).toBe("THREAD-1");
+
+    await reactToMessageTool.execute(
+      { emoji: "tada", messageId: "other-msg" },
+      channelContext({ sourceThreadId: "THREAD-1" }),
+    );
+    expect(reactCalls[1]?.target.threadId).toBeUndefined();
+  });
+
+  test("remove action passes through and reports removal", async () => {
+    const result = await reactToMessageTool.execute(
+      { emoji: "tada", action: "remove" },
+      channelContext(),
+    );
+    expect(reactCalls[0]?.target.action).toBe("remove");
+    expect(result.content).toContain("Removed");
+  });
+
+  test("errors without channel message context", async () => {
+    const result = await reactToMessageTool.execute(
+      { emoji: "thumbsup" },
+      channelContext({ executionChannel: undefined }),
+    );
+    expect(result.isError).toBe(true);
+    expect(reactCalls).toHaveLength(0);
+  });
+
+  test("errors on a channel without the capability", async () => {
+    channelSupported = false;
+    const result = await reactToMessageTool.execute(
+      { emoji: "thumbsup" },
+      channelContext(),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("does not support reactions");
+    expect(reactCalls).toHaveLength(0);
+  });
+
+  test("a channel rejection reaches the model as an error", async () => {
+    reactResultOk = false;
+    const result = await reactToMessageTool.execute(
+      { emoji: "thumbsup" },
+      channelContext(),
+    );
+    expect(result.isError).toBe(true);
+  });
+
+  test("a delivered reaction queues its durable record on the conversation", async () => {
+    await reactToMessageTool.execute({ emoji: "thumbsup" }, channelContext());
+    expect(queued).toHaveLength(1);
+    expect(queued[0]).toEqual({
+      conversationId: "conv-1",
+      record: {
+        channel: "slack",
+        chatId: "C123",
+        messageId: "1700000000.111111",
+        emoji: "thumbsup",
+        op: "added",
+        provenanceTrustClass: "guardian",
+      },
+    });
+    expect(directPersists).toHaveLength(0);
+  });
+
+  test("a removed reaction queues op removed", async () => {
+    await reactToMessageTool.execute(
+      { emoji: "thumbsup", action: "remove" },
+      channelContext(),
+    );
+    expect(queued[0]?.record.op).toBe("removed");
+  });
+
+  test("with no resident conversation the record persists directly", async () => {
+    conversationResident = false;
+    await reactToMessageTool.execute({ emoji: "thumbsup" }, channelContext());
+    expect(queued).toHaveLength(0);
+    expect(directPersists).toHaveLength(1);
+    expect(directPersists[0]?.records[0]?.emoji).toBe("thumbsup");
+  });
+
+  test("a rejected reaction records nothing", async () => {
+    reactResultOk = false;
+    await reactToMessageTool.execute({ emoji: "thumbsup" }, channelContext());
+    expect(queued).toHaveLength(0);
+    expect(directPersists).toHaveLength(0);
+  });
+
+  test("rejects input with no emoji", async () => {
+    const result = await reactToMessageTool.execute({}, channelContext());
+    expect(result.isError).toBe(true);
+    expect(reactCalls).toHaveLength(0);
+  });
+});

package/src/tools/channel/react-to-message.ts

@@ -0,0 +1,159 @@
+/**
+ * `react_to_message`: the assistant reacts with an emoji on the current
+ * channel conversation.
+ *
+ * The producer half of the transport's `react` capability: the tool surface
+ * only offers this when the turn's channel transport implements `react`
+ * (`isToolActiveForContext` gates on `supportsChannelReaction`), so the
+ * model never sees the option on a channel that cannot honor it.
+ *
+ * The default target is the message that triggered the turn, which is the
+ * one id every channel turn carries (`ToolContext.sourceMessageId`); an
+ * explicit `messageId` in the channel's own id space overrides it for
+ * callers that hold one (a skill working from platform APIs).
+ */
+import { z } from "zod";
+
+import { parseChannelId } from "../../channels/types.js";
+import { findConversationOrSubagent } from "../../daemon/conversation-registry.js";
+import { persistReactionRecords } from "../../daemon/reaction-record.js";
+import {
+  sendChannelReaction,
+  supportsChannelReaction,
+} from "../../messaging/providers/index.js";
+import { RiskLevel } from "../../permissions/types.js";
+import {
+  invalidToolInputResult,
+  toToolInputSchema,
+} from "../shared/zod-tool-schema.js";
+import type {
+  ToolContext,
+  ToolDefinition,
+  ToolExecutionResult,
+} from "../types.js";
+
+export const reactToMessageInputSchema = z.looseObject({
+  emoji: z
+    .string()
+    .min(1)
+    .describe(
+      "The emoji, in this channel's own form: a Slack emoji name like " +
+        "thumbsup (colons optional), a unicode emoji on other channels.",
+    ),
+  action: z
+    .enum(["add", "remove"])
+    .describe("Add the reaction (default) or remove one you added earlier.")
+    .optional()
+    .catch(undefined),
+  messageId: z
+    .string()
+    .min(1)
+    .describe(
+      "Target message id in the channel's own id space. Omit to react to " +
+        "the message that started this turn, which is the usual case.",
+    )
+    .optional()
+    .catch(undefined),
+});
+
+const DESCRIPTION =
+  "React with an emoji on the current channel conversation, the way a " +
+  "person would tap a reaction instead of writing a reply. By default the " +
+  "reaction lands on the message that started this turn. Use it to " +
+  "acknowledge without adding a message; it does not replace answering " +
+  "when an answer is called for. When the reaction is your whole reply, " +
+  "output exactly <no_response/> afterward so no message is posted.";
+
+export const reactToMessageTool = {
+  name: "react_to_message",
+  description: DESCRIPTION,
+  category: "interaction",
+  executionTarget: "sandbox",
+  defaultRiskLevel: RiskLevel.Low,
+  input_schema: toToolInputSchema(reactToMessageInputSchema),
+
+  async execute(
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolExecutionResult> {
+    const parsed = reactToMessageInputSchema.safeParse(input);
+    if (!parsed.success) {
+      return invalidToolInputResult("react_to_message", parsed.error);
+    }
+
+    const channel = context.executionChannel;
+    const chatId = context.requesterChatId;
+    const messageId = parsed.data.messageId ?? context.sourceMessageId;
+    if (!channel || !chatId || !messageId) {
+      return {
+        content:
+          "Reactions are only available in a channel conversation with a " +
+          "message to react to; this turn has no channel message context.",
+        isError: true,
+      };
+    }
+    if (!supportsChannelReaction(channel)) {
+      return {
+        content: `The ${channel} channel does not support reactions.`,
+        isError: true,
+      };
+    }
+
+    const action = parsed.data.action ?? "add";
+    // The turn's thread coordinate belongs only to the turn's own message;
+    // an explicit messageId may live elsewhere, so it travels bare.
+    const threadId =
+      parsed.data.messageId === undefined ? context.sourceThreadId : undefined;
+    const result = await sendChannelReaction(channel, {
+      chatId,
+      messageId,
+      ...(threadId ? { threadId } : {}),
+      emoji: parsed.data.emoji,
+      action,
+    });
+    if (!result.ok) {
+      return {
+        content:
+          `Could not ${action} the ${parsed.data.emoji} reaction; the ` +
+          "channel rejected it.",
+        isError: true,
+      };
+    }
+
+    // The delivered reaction becomes a durable row, the same canonical
+    // fact inbound reactions store. Queued on the live conversation and
+    // drained by the agent loop at the turn boundary, never written here:
+    // an assistant row inserted between this call's tool_use and its
+    // tool_result would break the pairing history repair enforces, and a
+    // reload would read the reaction as having failed. The rare turn with
+    // no resident conversation persists directly, trading perfect row
+    // ordering for durability.
+    const sourceChannel = parseChannelId(channel);
+    if (sourceChannel) {
+      const record = {
+        channel: sourceChannel,
+        chatId,
+        messageId,
+        emoji: parsed.data.emoji,
+        op: action === "remove" ? ("removed" as const) : ("added" as const),
+        ...(context.trustClass
+          ? { provenanceTrustClass: context.trustClass }
+          : {}),
+      };
+      const conversation = findConversationOrSubagent(context.conversationId);
+      if (conversation) {
+        conversation.queueReactionRecord(record);
+      } else {
+        await persistReactionRecords(context.conversationId, [record]);
+      }
+    }
+
+    return {
+      content:
+        action === "remove"
+          ? `Removed the ${parsed.data.emoji} reaction.`
+          : `Reacted with ${parsed.data.emoji}.`,
+      isError: false,
+    };
+  },
+} satisfies ToolDefinition;