@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/guardian-reply-router-answer-mode.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Tests for the guardian reply router's answer-mode handling
+ * (`guardian-reply-router.ts`):
+ *
+ *  - an `apr:<requestId>:answer_<idx>` / `:answer_skip` callback on an
+ *    answer-mode request applies a decision carrying the token as userText
+ *    (the pending_question resolver maps it to the option);
+ *  - an answer token aimed at an approval-mode request is never applied;
+ *  - a bare text reply while exactly ONE answer-mode request is pending IS
+ *    the answer — including replies that look like decision words ("no"),
+ *    and it must be consumed (never fall through to an agent turn, which
+ *    would deadlock behind the parked question's processing lock);
+ *  - bare non-decision text with a sole approval-mode request stays
+ *    not-consumed (existing behavior).
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { GuardianRequestWire } from "../channels/gateway-guardian-requests.js";
+import * as pendingInteractions from "../runtime/pending-interactions.js";
+
+// Capture decisions instead of running the real primitive (CAS + resolvers).
+const applyGuardianDecisionMock = mock(
+  (_params: Record<string, unknown>): Promise<Record<string, unknown>> =>
+    Promise.resolve({ applied: true }),
+);
+
+// Gateway-request reads return fixtures configured per test.
+let requestsById = new Map<string, GuardianRequestWire>();
+let pendingList: GuardianRequestWire[] = [];
+
+mock.module("../approvals/guardian-decision-primitive.js", () => ({
+  applyGuardianDecision: (params: Record<string, unknown>) =>
+    applyGuardianDecisionMock(params),
+}));
+
+mock.module("../channels/gateway-guardian-requests.js", () => ({
+  getGuardianRequestOrNull: (id: string) =>
+    Promise.resolve(requestsById.get(id) ?? null),
+  getGuardianRequestByCodeOrNull: () => Promise.resolve(null),
+  getPendingRequestByDestinationMessageOrNull: () => Promise.resolve(null),
+  listGuardianRequestsOrEmpty: () => Promise.resolve(pendingList),
+}));
+
+const { routeGuardianReply } =
+  await import("../runtime/guardian-reply-router.js");
+
+function makeRequest(
+  overrides: Partial<GuardianRequestWire> = {},
+): GuardianRequestWire {
+  return {
+    id: "req-q1",
+    kind: "pending_question",
+    sourceType: "channel",
+    sourceChannel: "telegram",
+    sourceConversationId: "conv-1",
+    requesterExternalUserId: "tg-guardian",
+    requesterChatId: "chat-1",
+    guardianExternalUserId: "tg-guardian",
+    guardianPrincipalId: "prin-guardian",
+    callSessionId: null,
+    pendingQuestionId: null,
+    questionText: "Which fruit?",
+    requestCode: "ABC123",
+    toolName: null,
+    inputDigest: null,
+    commandPreview: null,
+    riskLevel: null,
+    activityText: null,
+    executionTarget: null,
+    requesterSignals: null,
+    requestTrigger: null,
+    status: "pending",
+    answerText: null,
+    decidedByExternalUserId: null,
+    decidedByPrincipalId: null,
+    followupState: null,
+    expiresAt: null,
+    createdAt: 0,
+    updatedAt: 0,
+    ...overrides,
+  };
+}
+
+function makeContext(overrides: Record<string, unknown> = {}) {
+  return {
+    messageText: "",
+    channel: "telegram",
+    actor: {
+      actorPrincipalId: "prin-guardian",
+      actorExternalUserId: "tg-guardian",
+      channel: "telegram",
+      guardianPrincipalId: "prin-guardian",
+    },
+    // Matches the fixture request's sourceConversationId: the guardian answers
+    // in the chat the question was asked in.
+    conversationId: "conv-1",
+    ...overrides,
+  };
+}
+
+/** Register the parked interaction backing an ask_question request row. */
+function registerLiveQuestion(requestId: string): void {
+  pendingInteractions.register(requestId, {
+    conversationId: "conv-1",
+    kind: "question",
+    rpcResolve: () => {},
+    metadata: { orderedIds: ["q1"], optionsById: { q1: ["apple", "banana"] } },
+  });
+}
+
+beforeEach(() => {
+  applyGuardianDecisionMock.mockClear();
+  applyGuardianDecisionMock.mockImplementation(() =>
+    Promise.resolve({ applied: true }),
+  );
+  requestsById = new Map();
+  pendingList = [];
+  pendingInteractions.clear();
+});
+
+afterEach(() => {
+  pendingInteractions.clear();
+});
+
+describe("answer-option callback taps", () => {
+  test("applies an option token on an answer-mode request as userText", async () => {
+    const request = makeRequest();
+    requestsById.set(request.id, request);
+    registerLiveQuestion(request.id);
+
+    const result = await routeGuardianReply(
+      makeContext({ callbackData: "apr:req-q1:answer_1" }),
+    );
+
+    expect(result.consumed).toBe(true);
+    expect(result.decisionApplied).toBe(true);
+    expect(applyGuardianDecisionMock).toHaveBeenCalledTimes(1);
+    expect(applyGuardianDecisionMock.mock.calls[0]?.[0]).toMatchObject({
+      requestId: "req-q1",
+      action: "approve_once",
+      userText: "answer_1",
+    });
+  });
+
+  test("applies the skip token as a reject decision carrying the token", async () => {
+    const request = makeRequest();
+    requestsById.set(request.id, request);
+    registerLiveQuestion(request.id);
+
+    await routeGuardianReply(
+      makeContext({ callbackData: "apr:req-q1:answer_skip" }),
+    );
+
+    expect(applyGuardianDecisionMock.mock.calls[0]?.[0]).toMatchObject({
+      requestId: "req-q1",
+      action: "reject",
+      userText: "answer_skip",
+    });
+  });
+
+  test("never applies an answer token aimed at an approval-mode request", async () => {
+    const request = makeRequest({
+      id: "req-t1",
+      kind: "tool_approval",
+      toolName: "bash",
+    });
+    requestsById.set(request.id, request);
+
+    const result = await routeGuardianReply(
+      makeContext({ callbackData: "apr:req-t1:answer_0" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(applyGuardianDecisionMock).not.toHaveBeenCalled();
+  });
+
+  test("a tap on a stale card (interaction gone) is not applied", async () => {
+    // Answered on another surface or timed out: the row may briefly outlive
+    // the interaction. The tap must fall through to stale handling, never
+    // commit a decision that can no longer resolve anything.
+    const request = makeRequest();
+    requestsById.set(request.id, request);
+
+    const result = await routeGuardianReply(
+      makeContext({ callbackData: "apr:req-q1:answer_1" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(applyGuardianDecisionMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("bare-text answers to a sole pending question", () => {
+  test("treats an unprefixed reply as the answer and consumes it", async () => {
+    pendingList = [makeRequest()];
+    registerLiveQuestion("req-q1");
+
+    const result = await routeGuardianReply(
+      makeContext({ messageText: "3pm works" }),
+    );
+
+    // Consumption matters as much as the decision: an unconsumed reply would
+    // fall through to a normal agent turn and defer behind the parked
+    // question's processing lock until the prompt timeout.
+    expect(result.consumed).toBe(true);
+    expect(applyGuardianDecisionMock.mock.calls[0]?.[0]).toMatchObject({
+      requestId: "req-q1",
+      action: "approve_once",
+      userText: "3pm works",
+    });
+  });
+
+  test('a decision-looking word ("no") is the ANSWER, not a rejection', async () => {
+    pendingList = [makeRequest()];
+    registerLiveQuestion("req-q1");
+
+    await routeGuardianReply(makeContext({ messageText: "no" }));
+
+    expect(applyGuardianDecisionMock.mock.calls[0]?.[0]).toMatchObject({
+      requestId: "req-q1",
+      action: "approve_once",
+      userText: "no",
+    });
+  });
+
+  test("non-decision text with a sole approval-mode request stays not consumed", async () => {
+    pendingList = [
+      makeRequest({ id: "req-t1", kind: "tool_approval", toolName: "bash" }),
+    ];
+
+    const result = await routeGuardianReply(
+      makeContext({ messageText: "3pm works" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(applyGuardianDecisionMock).not.toHaveBeenCalled();
+  });
+
+  test("prose in a DIFFERENT chat never answers a question pending elsewhere", async () => {
+    // Under the identity-fallback scope a guardian's pending requests are
+    // visible cross-chat; an unprefixed reply must only count as the answer
+    // in the conversation the question was asked in. Codes and taps stay
+    // cross-chat.
+    pendingList = [makeRequest()];
+    registerLiveQuestion("req-q1");
+
+    const result = await routeGuardianReply(
+      makeContext({
+        messageText: "3pm works",
+        conversationId: "conv-other-chat",
+      }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(applyGuardianDecisionMock).not.toHaveBeenCalled();
+  });
+
+  test("prose is not swallowed when the interaction is gone (stale row)", async () => {
+    // App-card answer or timeout can leave the row briefly pending with no
+    // interaction behind it. The reply must flow to a normal agent turn, not
+    // into a decision that then fails to resolve anything.
+    pendingList = [makeRequest()];
+
+    const result = await routeGuardianReply(
+      makeContext({ messageText: "unrelated new request" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(applyGuardianDecisionMock).not.toHaveBeenCalled();
+  });
+
+  test("a voice question (callSessionId) keeps its existing code/NL paths", async () => {
+    pendingList = [makeRequest({ id: "req-v1", callSessionId: "call-1" })];
+
+    const result = await routeGuardianReply(
+      makeContext({ messageText: "3pm works", conversationId: "conv-1" }),
+    );
+
+    expect(result.consumed).toBe(false);
+    expect(applyGuardianDecisionMock).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/guardian-vellum-destination-pinning.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Regression tests for guardian-card vellum destination routing (LUM-2870).
+ *
+ * Two unrelated guardian requests must never share a vellum conversation:
+ * un-pinned requests are forced to `start_new` by the decision engine's
+ * guardian-request affinity guard (overriding any LLM `reuse_existing`
+ * choice), so each request pairs with its own fresh conversation; pinned
+ * requests land in their originating conversation via the affinity hint.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mocks — declared before imports that depend on them ─────────────
+
+let nextConversationSeq = 0;
+
+/** Simulated existing conversations for getConversation mock. */
+let mockExistingConversations: Record<
+  string,
+  { id: string; source: string; title: string | null }
+> = {};
+
+const createdConversationIds: string[] = [];
+const appendedMessages: Array<{ conversationId: string }> = [];
+
+const createConversationMock = mock((_opts?: unknown) => {
+  nextConversationSeq += 1;
+  const id = `conv-new-${nextConversationSeq}`;
+  createdConversationIds.push(id);
+  return { id };
+});
+
+const addMessageMock = mock(
+  (
+    conversationId: string,
+    _role: string,
+    _content: string,
+    _options?: unknown,
+  ) => {
+    appendedMessages.push({ conversationId });
+    return { id: `msg-${conversationId}` };
+  },
+);
+
+const getConversationMock = mock((id: string) => {
+  return mockExistingConversations[id] ?? null;
+});
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  createConversation: createConversationMock,
+  addMessage: addMessageMock,
+  getConversation: getConversationMock,
+}));
+
+mock.module("../persistence/external-conversation-store.js", () => ({
+  getBindingByChannelChat: () => null,
+  upsertOutboundBinding: () => {},
+}));
+
+import { pairDeliveryWithConversation } from "../notifications/conversation-pairing.js";
+import { enforceGuardianRequestConversationAffinity } from "../notifications/decision-engine.js";
+import type { NotificationSignal } from "../notifications/signal.js";
+import type {
+  ConversationAction,
+  NotificationDecision,
+} from "../notifications/types.js";
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function makeSignal(
+  overrides?: Partial<NotificationSignal>,
+): NotificationSignal {
+  return {
+    signalId: `sig-${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: Date.now(),
+    sourceChannel: "slack",
+    sourceContextId: "ctx-1",
+    sourceEventName: "guardian.question",
+    contextPayload: {},
+    attentionHints: {
+      requiresAction: true,
+      urgency: "high",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+    requiresConversation: true,
+    ...overrides,
+  };
+}
+
+function makeLlmDecisionReusing(conversationId: string): NotificationDecision {
+  return {
+    shouldNotify: true,
+    selectedChannels: ["vellum"],
+    reasoningSummary: "llm chose reuse",
+    renderedCopy: {
+      vellum: { title: "Approval needed", body: "Please decide." },
+    },
+    conversationActions: {
+      vellum: { action: "reuse_existing", conversationId },
+    },
+    dedupeKey: "test-key",
+    confidence: 0.9,
+    fallbackUsed: false,
+  };
+}
+
+/** Run a signal's decision through the guard and pair the vellum delivery. */
+async function routeVellumDelivery(
+  signal: NotificationSignal,
+  decision: NotificationDecision,
+) {
+  const guarded = enforceGuardianRequestConversationAffinity(decision, signal);
+  const conversationAction = guarded.conversationActions?.vellum as
+    | ConversationAction
+    | undefined;
+  return pairDeliveryWithConversation(
+    signal,
+    "vellum",
+    guarded.renderedCopy.vellum!,
+    { conversationAction },
+  );
+}
+
+// ── Tests ───────────────────────────────────────────────────────────
+
+describe("guardian vellum destination pinning", () => {
+  beforeEach(() => {
+    nextConversationSeq = 0;
+    createdConversationIds.length = 0;
+    appendedMessages.length = 0;
+    mockExistingConversations = {
+      // The "catch-all" — a recent guardian conversation the LLM keeps
+      // offering as a reuse candidate.
+      "conv-catchall": {
+        id: "conv-catchall",
+        source: "notification",
+        title: "Access Request",
+      },
+      // An originating inbound conversation a producer can pin to.
+      "conv-origin": { id: "conv-origin", source: "user", title: "Slack chat" },
+    };
+    createConversationMock.mockClear();
+    addMessageMock.mockClear();
+  });
+
+  test("two unrelated un-pinned guardian requests land in two different conversations", async () => {
+    // Both decisions simulate the LLM steering to the same catch-all.
+    const accessRequest = makeSignal({
+      sourceEventName: "ingress.access_request",
+      contextPayload: { requestId: "access-req-1" },
+    });
+    const toolGrant = makeSignal({
+      sourceEventName: "guardian.question",
+      contextPayload: {
+        requestId: "tool-grant-1",
+        requestKind: "tool_grant_request",
+        toolName: "host_bash",
+      },
+    });
+
+    const first = await routeVellumDelivery(
+      accessRequest,
+      makeLlmDecisionReusing("conv-catchall"),
+    );
+    const second = await routeVellumDelivery(
+      toolGrant,
+      makeLlmDecisionReusing("conv-catchall"),
+    );
+
+    expect(first.conversationId).toBeTruthy();
+    expect(second.conversationId).toBeTruthy();
+    expect(first.conversationId).not.toBe(second.conversationId);
+    expect(first.createdNewConversation).toBe(true);
+    expect(second.createdNewConversation).toBe(true);
+    // The catch-all never receives either card.
+    expect(
+      appendedMessages.filter((m) => m.conversationId === "conv-catchall"),
+    ).toHaveLength(0);
+  });
+
+  test("a pinned guardian request lands in its originating conversation", async () => {
+    const pinned = makeSignal({
+      sourceEventName: "guardian.question",
+      contextPayload: {
+        requestId: "tool-approval-1",
+        requestKind: "tool_approval",
+        toolName: "bash",
+      },
+      conversationAffinityHint: { vellum: "conv-origin" },
+      conversationMetadata: { source: "user" },
+    });
+
+    // With a hint the guard is a no-op; affinity enforcement (exercised in
+    // decision-engine tests) rewrites the action to reuse the pinned target.
+    const guarded = enforceGuardianRequestConversationAffinity(
+      makeLlmDecisionReusing("conv-catchall"),
+      pinned,
+    );
+    expect(guarded.conversationActions?.vellum).toEqual({
+      action: "reuse_existing",
+      conversationId: "conv-catchall",
+    });
+
+    const pairing = await pairDeliveryWithConversation(
+      pinned,
+      "vellum",
+      guarded.renderedCopy.vellum!,
+      {
+        conversationAction: {
+          action: "reuse_existing",
+          conversationId: "conv-origin",
+        },
+      },
+    );
+
+    expect(pairing.conversationId).toBe("conv-origin");
+    expect(pairing.createdNewConversation).toBe(false);
+    expect(appendedMessages).toEqual([{ conversationId: "conv-origin" }]);
+  });
+});

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -26,6 +26,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   countCompletedHeartbeatRuns: mock(() => 10),
   countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
+  getLastHeartbeatRunAt: mock(() => null),
 }));
 
 mock.module("../schedule/recurrence-engine.js", () => ({

package/src/__tests__/heartbeat-service.test.ts

@@ -34,6 +34,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
   countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
+  getLastHeartbeatRunAt: mock(() => null),
 }));
 
 // ── Heartbeat config seeding ────────────────────────────────────────

package/src/__tests__/helpers/native-web-search-harness.ts

@@ -4,7 +4,7 @@
  *
  * Both `native-web-search.test.ts` and `web-search-backend-failure.test.ts`
  * exercise the same handler the same way: build a set of mocked
- * `EventHandlerDeps` (capturing emitted `ServerMessage`s and `rlog.warn`
+ * `EventHandlerDeps` (capturing emitted `AssistantEvent`s and `rlog.warn`
  * records), then drive a `server_tool_start` → `server_tool_complete` pair.
  * This module is the single source of truth for that harness so the two suites
  * cannot drift apart.
@@ -14,15 +14,15 @@
  * load time (config loader, conversation-crud, llm-request-log-store), because
  * Bun's `mock.module()` is scoped to the file that registers it.
  */
+import type { AssistantEvent } from "../../api/index.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
 } from "../../daemon/conversation-agent-loop-handlers.js";
 import { dispatchAgentEvent } from "../../daemon/conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../../daemon/message-protocol.js";
 
-/** A `tool_result` `ServerMessage` emitted by the handler. */
-export type ToolResultEvent = Extract<ServerMessage, { type: "tool_result" }>;
+/** A `tool_result` `AssistantEvent` emitted by the handler. */
+export type ToolResultEvent = Extract<AssistantEvent, { type: "tool_result" }>;
 
 /** A captured `rlog.warn(obj, msg)` call. */
 export interface LogRecord {
@@ -32,15 +32,15 @@ export interface LogRecord {
 
 export interface HandlerHarness {
   deps: EventHandlerDeps;
-  /** Every `ServerMessage` the handler emitted via `onEvent`. */
-  events: ServerMessage[];
+  /** Every `AssistantEvent` the handler emitted via `onEvent`. */
+  events: AssistantEvent[];
   /** Every `rlog.warn(obj, msg)` call the handler made. */
   warnings: LogRecord[];
 }
 
 /** Build mocked handler deps that capture emitted events and warn logs. */
 export function createHandlerDeps(reqId = "req-web-search"): HandlerHarness {
-  const events: ServerMessage[] = [];
+  const events: AssistantEvent[] = [];
   const warnings: LogRecord[] = [];
   const rlog = {
     warn: (obj: Record<string, unknown>, msg?: string) =>
@@ -60,7 +60,7 @@ export function createHandlerDeps(reqId = "req-web-search"): HandlerHarness {
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
     } as unknown as EventHandlerDeps["ctx"],
-    onEvent: (msg: ServerMessage) => events.push(msg),
+    onEvent: (msg: AssistantEvent) => events.push(msg),
     reqId,
     isFirstMessage: false,
     shouldGenerateTitle: false,
@@ -110,13 +110,13 @@ export async function completeNativeWebSearch(
 }
 
 /** All `tool_result` events emitted so far, in order. */
-export function toolResults(events: ServerMessage[]): ToolResultEvent[] {
+export function toolResults(events: AssistantEvent[]): ToolResultEvent[] {
   return events.filter((e): e is ToolResultEvent => e.type === "tool_result");
 }
 
 /** The most recent `tool_result` event, if any. */
 export function lastToolResult(
-  events: ServerMessage[],
+  events: AssistantEvent[],
 ): ToolResultEvent | undefined {
   const results = toolResults(events);
   return results[results.length - 1];

package/src/__tests__/host-browser-proxy.test.ts

@@ -59,7 +59,7 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
 const pendingInteractions = await import("../runtime/pending-interactions.js");
 const { HostBrowserProxy } = await import("../daemon/host-browser-proxy.js");
 
-/** Extract the ServerMessage payloads from published events. */
+/** Extract the AssistantEvent payloads from published events. */
 function getPublishedMessages(): unknown[] {
   return publishedEvents;
 }

package/src/__tests__/host-file-edit-tool.test.ts

@@ -152,7 +152,7 @@ describe("host_file_edit tool", () => {
       makeContext(),
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("path is required");
+    expect(result.content).toContain('Invalid input for tool "host_file_edit"');
   });
 
   test("rejects non-string old_string", async () => {
@@ -170,7 +170,7 @@ describe("host_file_edit tool", () => {
       makeContext(),
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("old_string is required");
+    expect(result.content).toContain('Invalid input for tool "host_file_edit"');
   });
 
   test("rejects non-string new_string", async () => {
@@ -188,7 +188,7 @@ describe("host_file_edit tool", () => {
       makeContext(),
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("new_string is required");
+    expect(result.content).toContain('Invalid input for tool "host_file_edit"');
   });
 
   test("rejects empty old_string", async () => {

package/src/__tests__/host-file-read-tool.test.ts

@@ -118,13 +118,13 @@ describe("host_file_read tool", () => {
   test("rejects missing path parameter", async () => {
     const result = await hostFileReadTool.execute({}, makeContext());
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("path is required");
+    expect(result.content).toContain('Invalid input for tool "host_file_read"');
   });
 
   test("rejects non-string path", async () => {
     const result = await hostFileReadTool.execute({ path: 42 }, makeContext());
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("path is required and must be a string");
+    expect(result.content).toContain('Invalid input for tool "host_file_read"');
   });
 
   test("reads entire file when no offset or limit specified", async () => {

package/src/__tests__/host-file-write-tool.test.ts

@@ -69,7 +69,7 @@ describe("host_file_write tool", () => {
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain(
-      "content is required and must be a string",
+      'Invalid input for tool "host_file_write"',
     );
   });
 
@@ -124,7 +124,9 @@ describe("host_file_write tool", () => {
       makeContext(),
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("path is required");
+    expect(result.content).toContain(
+      'Invalid input for tool "host_file_write"',
+    );
   });
 
   test("rejects non-string path", async () => {
@@ -133,7 +135,9 @@ describe("host_file_write tool", () => {
       makeContext(),
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("path is required and must be a string");
+    expect(result.content).toContain(
+      'Invalid input for tool "host_file_write"',
+    );
   });
 
   test("success message contains the file path", async () => {