@vellumai/assistant 0.4.55 → 0.4.57

package/src/__tests__/{session-error.test.ts → conversation-error.test.ts}

@@ -1,11 +1,11 @@
 import { describe, expect, it } from "bun:test";
 
-import type { ErrorContext } from "../daemon/session-error.js";
+import type { ErrorContext } from "../daemon/conversation-error.js";
 import {
-  buildSessionErrorMessage,
-  classifySessionError,
+  buildConversationErrorMessage,
+  classifyConversationError,
   isUserCancellation,
-} from "../daemon/session-error.js";
+} from "../daemon/conversation-error.js";
 import { ProviderError } from "../util/errors.js";
 
 describe("isUserCancellation", () => {
@@ -56,7 +56,7 @@ describe("isUserCancellation", () => {
   });
 });
 
-describe("classifySessionError", () => {
+describe("classifyConversationError", () => {
   const baseCtx: ErrorContext = { phase: "agent_loop" };
 
   describe("network errors", () => {
@@ -66,6 +66,8 @@ describe("classifySessionError", () => {
       "ETIMEDOUT",
       "ENOTFOUND",
       "socket hang up",
+      "The socket connection was closed unexpectedly",
+      "Anthropic request failed: The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()",
       "fetch failed",
       "Connection refused by server",
       "connection reset",
@@ -74,7 +76,7 @@ describe("classifySessionError", () => {
 
     for (const msg of cases) {
       it(`classifies "${msg}" as PROVIDER_NETWORK`, () => {
-        const result = classifySessionError(new Error(msg), baseCtx);
+        const result = classifyConversationError(new Error(msg), baseCtx);
         expect(result.code).toBe("PROVIDER_NETWORK");
         expect(result.retryable).toBe(true);
         expect(result.errorCategory).toBe("provider_network");
@@ -93,7 +95,7 @@ describe("classifySessionError", () => {
 
     for (const msg of cases) {
       it(`classifies "${msg}" as PROVIDER_RATE_LIMIT`, () => {
-        const result = classifySessionError(new Error(msg), baseCtx);
+        const result = classifyConversationError(new Error(msg), baseCtx);
         expect(result.code).toBe("PROVIDER_RATE_LIMIT");
         expect(result.retryable).toBe(true);
         expect(result.userMessage).toContain("busy");
@@ -114,7 +116,7 @@ describe("classifySessionError", () => {
 
     for (const msg of cases) {
       it(`classifies "${msg}" as PROVIDER_API`, () => {
-        const result = classifySessionError(new Error(msg), baseCtx);
+        const result = classifyConversationError(new Error(msg), baseCtx);
         expect(result.code).toBe("PROVIDER_API");
         expect(result.retryable).toBe(true);
       });
@@ -126,7 +128,7 @@ describe("classifySessionError", () => {
 
     for (const msg of cases) {
       it(`classifies "${msg}" as PROVIDER_API with timeout message`, () => {
-        const result = classifySessionError(new Error(msg), baseCtx);
+        const result = classifyConversationError(new Error(msg), baseCtx);
         expect(result.code).toBe("PROVIDER_API");
         expect(result.userMessage).toContain("timed out");
         expect(result.retryable).toBe(true);
@@ -135,7 +137,7 @@ describe("classifySessionError", () => {
     }
 
     it('does not steal "connection timeout" from PROVIDER_NETWORK', () => {
-      const result = classifySessionError(
+      const result = classifyConversationError(
         new Error("connection timeout"),
         baseCtx,
       );
@@ -143,7 +145,7 @@ describe("classifySessionError", () => {
     });
 
     it('does not steal "Gateway timeout" from PROVIDER_API', () => {
-      const result = classifySessionError(
+      const result = classifyConversationError(
         new Error("Gateway timeout"),
         baseCtx,
       );
@@ -167,7 +169,7 @@ describe("classifySessionError", () => {
 
     for (const msg of cases) {
       it(`classifies "${msg}" as CONTEXT_TOO_LARGE`, () => {
-        const result = classifySessionError(new Error(msg), baseCtx);
+        const result = classifyConversationError(new Error(msg), baseCtx);
         expect(result.code).toBe("CONTEXT_TOO_LARGE");
         expect(result.retryable).toBe(false);
         expect(result.userMessage).toContain("too long");
@@ -183,7 +185,7 @@ describe("classifySessionError", () => {
         "anthropic",
         400,
       );
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("CONTEXT_TOO_LARGE");
       expect(result.retryable).toBe(false);
     });
@@ -194,7 +196,7 @@ describe("classifySessionError", () => {
         "anthropic",
         413,
       );
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("CONTEXT_TOO_LARGE");
       expect(result.retryable).toBe(false);
     });
@@ -205,7 +207,7 @@ describe("classifySessionError", () => {
         "anthropic",
         400,
       );
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
       expect(result.retryable).toBe(true);
     });
@@ -222,7 +224,7 @@ describe("classifySessionError", () => {
 
     for (const msg of cases) {
       it(`classifies "${msg}" as PROVIDER_ORDERING`, () => {
-        const result = classifySessionError(new Error(msg), baseCtx);
+        const result = classifyConversationError(new Error(msg), baseCtx);
         expect(result.code).toBe("PROVIDER_ORDERING");
         expect(result.retryable).toBe(true);
         expect(result.userMessage).toBe(
@@ -238,7 +240,7 @@ describe("classifySessionError", () => {
         "anthropic",
         400,
       );
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_ORDERING");
       expect(result.retryable).toBe(true);
       expect(result.errorCategory).toBe("tool_ordering");
@@ -253,7 +255,7 @@ describe("classifySessionError", () => {
 
     for (const msg of cases) {
       it(`classifies "${msg}" as PROVIDER_WEB_SEARCH`, () => {
-        const result = classifySessionError(new Error(msg), baseCtx);
+        const result = classifyConversationError(new Error(msg), baseCtx);
         expect(result.code).toBe("PROVIDER_WEB_SEARCH");
         expect(result.retryable).toBe(true);
         expect(result.userMessage).toBe(
@@ -269,29 +271,60 @@ describe("classifySessionError", () => {
         "anthropic",
         400,
       );
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_WEB_SEARCH");
       expect(result.retryable).toBe(true);
       expect(result.errorCategory).toBe("web_search_ordering");
     });
   });
 
+  describe("streaming corruption errors", () => {
+    const cases = [
+      "Unexpected event order, got message_start before receiving message_stop",
+      "Anthropic request failed: Unexpected event order, got message_start before receiving \"message_stop\"",
+      "stream ended without producing a Message",
+      "request ended without sending any chunks",
+      "stream has ended, this shouldn't happen",
+    ];
+
+    for (const msg of cases) {
+      it(`classifies "${msg}" as PROVIDER_API (retryable)`, () => {
+        const result = classifyConversationError(new Error(msg), baseCtx);
+        expect(result.code).toBe("PROVIDER_API");
+        expect(result.retryable).toBe(true);
+        expect(result.userMessage).toContain("interrupted");
+        expect(result.errorCategory).toBe("stream_corruption");
+      });
+    }
+
+    it("classifies ProviderError without statusCode with streaming message as PROVIDER_API", () => {
+      const err = new ProviderError(
+        "Unexpected event order, got message_start before receiving message_stop",
+        "anthropic",
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_API");
+      expect(result.retryable).toBe(true);
+      expect(result.errorCategory).toBe("stream_corruption");
+    });
+  });
+
   describe("abort/cancel errors (non-user-initiated)", () => {
-    it('classifies "aborted" as SESSION_ABORTED', () => {
-      const result = classifySessionError(
+    it('classifies "aborted" as CONVERSATION_ABORTED', () => {
+      const result = classifyConversationError(
         new Error("Request aborted"),
         baseCtx,
       );
-      expect(result.code).toBe("SESSION_ABORTED");
+      expect(result.code).toBe("CONVERSATION_ABORTED");
       expect(result.retryable).toBe(true);
     });
 
-    it('classifies "cancelled" as SESSION_ABORTED', () => {
-      const result = classifySessionError(
+    it('classifies "cancelled" as CONVERSATION_ABORTED', () => {
+      const result = classifyConversationError(
         new Error("Operation cancelled"),
         baseCtx,
       );
-      expect(result.code).toBe("SESSION_ABORTED");
+      expect(result.code).toBe("CONVERSATION_ABORTED");
       expect(result.retryable).toBe(true);
     });
   });
@@ -299,7 +332,7 @@ describe("classifySessionError", () => {
   describe("regenerate phase", () => {
     it("returns REGENERATE_FAILED with nested classification info", () => {
       const ctx: ErrorContext = { phase: "regenerate" };
-      const result = classifySessionError(new Error("ECONNREFUSED"), ctx);
+      const result = classifyConversationError(new Error("ECONNREFUSED"), ctx);
       expect(result.code).toBe("REGENERATE_FAILED");
       expect(result.retryable).toBe(true);
       expect(result.userMessage).toContain("regenerate");
@@ -308,19 +341,19 @@ describe("classifySessionError", () => {
 
     it("returns REGENERATE_FAILED for generic errors", () => {
       const ctx: ErrorContext = { phase: "regenerate" };
-      const result = classifySessionError(new Error("unknown issue"), ctx);
+      const result = classifyConversationError(new Error("unknown issue"), ctx);
       expect(result.code).toBe("REGENERATE_FAILED");
       expect(result.retryable).toBe(true);
     });
   });
 
   describe("generic errors", () => {
-    it("classifies unknown errors as SESSION_PROCESSING_FAILED with error summary", () => {
-      const result = classifySessionError(
+    it("classifies unknown errors as CONVERSATION_PROCESSING_FAILED with error summary", () => {
+      const result = classifyConversationError(
         new Error("something completely unexpected"),
         baseCtx,
       );
-      expect(result.code).toBe("SESSION_PROCESSING_FAILED");
+      expect(result.code).toBe("CONVERSATION_PROCESSING_FAILED");
       expect(result.retryable).toBe(false);
       expect(result.userMessage).toContain("something completely unexpected");
       expect(result.errorCategory).toBe("processing_failed");
@@ -328,32 +361,32 @@ describe("classifySessionError", () => {
 
     it("includes debugDetails with stack trace", () => {
       const err = new Error("test error");
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.debugDetails).toBeDefined();
       expect(result.debugDetails).toContain("test error");
     });
 
     it("handles non-Error values", () => {
-      const result = classifySessionError("plain string error", baseCtx);
-      expect(result.code).toBe("SESSION_PROCESSING_FAILED");
+      const result = classifyConversationError("plain string error", baseCtx);
+      expect(result.code).toBe("CONVERSATION_PROCESSING_FAILED");
       expect(result.userMessage).toContain("plain string error");
       expect(result.debugDetails).toBe("plain string error");
     });
 
     it("falls back to generic message for empty error", () => {
-      const result = classifySessionError(new Error(""), baseCtx);
-      expect(result.code).toBe("SESSION_PROCESSING_FAILED");
+      const result = classifyConversationError(new Error(""), baseCtx);
+      expect(result.code).toBe("CONVERSATION_PROCESSING_FAILED");
       expect(result.userMessage).toBe(
         "Something went wrong processing your message. Please try again.",
       );
     });
 
     it("skips leading newlines to find first non-empty line", () => {
-      const result = classifySessionError(
+      const result = classifyConversationError(
         new Error("\n\nactual error on line 3"),
         baseCtx,
       );
-      expect(result.code).toBe("SESSION_PROCESSING_FAILED");
+      expect(result.code).toBe("CONVERSATION_PROCESSING_FAILED");
       expect(result.userMessage).toContain("actual error on line 3");
     });
   });
@@ -361,7 +394,7 @@ describe("classifySessionError", () => {
   describe("ProviderError with statusCode (deterministic classification)", () => {
     it("classifies ProviderError with 429 as PROVIDER_RATE_LIMIT", () => {
       const err = new ProviderError("Rate limit exceeded", "anthropic", 429);
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_RATE_LIMIT");
       expect(result.retryable).toBe(true);
       expect(result.errorCategory).toBe("rate_limit");
@@ -369,42 +402,50 @@ describe("classifySessionError", () => {
 
     it("classifies ProviderError with 500 as PROVIDER_API (retryable)", () => {
       const err = new ProviderError("Internal server error", "anthropic", 500);
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
       expect(result.retryable).toBe(true);
     });
 
     it("classifies ProviderError with 502 as PROVIDER_API (retryable)", () => {
       const err = new ProviderError("Bad gateway", "openai", 502);
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
       expect(result.retryable).toBe(true);
     });
 
     it("classifies ProviderError with 503 as PROVIDER_API (retryable)", () => {
       const err = new ProviderError("Service unavailable", "gemini", 503);
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
       expect(result.retryable).toBe(true);
     });
 
     it("classifies ProviderError with 401 as PROVIDER_BILLING (non-retryable)", () => {
       const err = new ProviderError("Unauthorized", "anthropic", 401);
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.retryable).toBe(false);
+    });
+
+    it("classifies ProviderError with 402 as credits_exhausted (non-retryable)", () => {
+      const err = new ProviderError("Payment Required", "anthropic", 402);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_BILLING");
+      expect(result.errorCategory).toBe("credits_exhausted");
       expect(result.retryable).toBe(false);
     });
 
     it("classifies ProviderError with 400 as PROVIDER_API (retryable)", () => {
       const err = new ProviderError("Bad request", "anthropic", 400);
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
       expect(result.retryable).toBe(true);
     });
 
     it("ProviderError without statusCode falls back to regex", () => {
       const err = new ProviderError("ECONNREFUSED", "anthropic");
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_NETWORK");
       expect(result.retryable).toBe(true);
     });
@@ -412,7 +453,7 @@ describe("classifySessionError", () => {
     it("statusCode takes priority over conflicting message regex", () => {
       // Message says "rate limit" but statusCode is 500 → should use statusCode
       const err = new ProviderError("rate limit error", "anthropic", 500);
-      const result = classifySessionError(err, baseCtx);
+      const result = classifyConversationError(err, baseCtx);
       expect(result.code).toBe("PROVIDER_API");
       expect(result.retryable).toBe(true);
     });
@@ -431,7 +472,7 @@ describe("classifySessionError", () => {
         },
       ];
       for (const { error, ctx } of cases) {
-        const result = classifySessionError(error, ctx);
+        const result = classifyConversationError(error, ctx);
         expect(result.errorCategory).toBeDefined();
         expect(result.errorCategory.length).toBeGreaterThan(0);
       }
@@ -441,14 +482,14 @@ describe("classifySessionError", () => {
   describe("debug detail truncation", () => {
     it("truncates debugDetails longer than 4000 chars", () => {
       const longMsg = "x".repeat(5000);
-      const result = classifySessionError(new Error(longMsg), baseCtx);
+      const result = classifyConversationError(new Error(longMsg), baseCtx);
       expect(result.debugDetails!.length).toBeLessThanOrEqual(4020); // 4000 + truncation marker
       expect(result.debugDetails!).toContain("(truncated)");
     });
 
     it("preserves debugDetails under 4000 chars", () => {
       const shortMsg = "short error message";
-      const result = classifySessionError(new Error(shortMsg), baseCtx);
+      const result = classifyConversationError(new Error(shortMsg), baseCtx);
       expect(result.debugDetails).toBeDefined();
       expect(result.debugDetails!).not.toContain("(truncated)");
     });
@@ -478,9 +519,9 @@ describe("classifySessionError", () => {
   });
 });
 
-describe("buildSessionErrorMessage", () => {
-  it("builds a valid SessionErrorMessage", () => {
-    const msg = buildSessionErrorMessage("session-123", {
+describe("buildConversationErrorMessage", () => {
+  it("builds a valid ConversationErrorMessage", () => {
+    const msg = buildConversationErrorMessage("session-123", {
       code: "PROVIDER_NETWORK",
       userMessage: "Network error",
       retryable: true,
@@ -488,8 +529,8 @@ describe("buildSessionErrorMessage", () => {
       errorCategory: "provider_network",
     });
 
-    expect(msg.type).toBe("session_error");
-    expect(msg.sessionId).toBe("session-123");
+    expect(msg.type).toBe("conversation_error");
+    expect(msg.conversationId).toBe("session-123");
     expect(msg.code).toBe("PROVIDER_NETWORK");
     expect(msg.userMessage).toBe("Network error");
     expect(msg.retryable).toBe(true);
@@ -498,20 +539,20 @@ describe("buildSessionErrorMessage", () => {
   });
 
   it("omits debugDetails when not provided", () => {
-    const msg = buildSessionErrorMessage("session-456", {
+    const msg = buildConversationErrorMessage("session-456", {
       code: "UNKNOWN",
       userMessage: "Something went wrong",
       retryable: false,
       errorCategory: "processing_failed",
     });
 
-    expect(msg.type).toBe("session_error");
+    expect(msg.type).toBe("conversation_error");
     expect(msg.debugDetails).toBeUndefined();
     expect(msg.errorCategory).toBe("processing_failed");
   });
 
   it("includes errorCategory for ordering errors", () => {
-    const msg = buildSessionErrorMessage("session-789", {
+    const msg = buildConversationErrorMessage("session-789", {
       code: "PROVIDER_ORDERING",
       userMessage: "An internal error occurred. Please try again.",
       retryable: true,
@@ -523,7 +564,7 @@ describe("buildSessionErrorMessage", () => {
   });
 
   it("includes errorCategory for web search errors", () => {
-    const msg = buildSessionErrorMessage("session-abc", {
+    const msg = buildConversationErrorMessage("session-abc", {
       code: "PROVIDER_WEB_SEARCH",
       userMessage:
         "An internal error occurred with web search. Please try again.",

package/src/__tests__/{session-evictor.test.ts → conversation-evictor.test.ts}

@@ -1,13 +1,13 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
-  type EvictableSession,
-  SessionEvictor,
-} from "../daemon/session-evictor.js";
+  ConversationEvictor,
+  type EvictableConversation,
+} from "../daemon/conversation-evictor.js";
 
 function createMockSession(
   processing = false,
-): EvictableSession & { disposed: boolean } {
+): EvictableConversation & { disposed: boolean } {
   return {
     disposed: false,
     isProcessing() {
@@ -19,18 +19,21 @@ function createMockSession(
   };
 }
 
-describe("SessionEvictor", () => {
-  let sessions: Map<string, EvictableSession & { disposed: boolean }>;
-  let evictor: SessionEvictor;
+describe("ConversationEvictor", () => {
+  let sessions: Map<string, EvictableConversation & { disposed: boolean }>;
+  let evictor: ConversationEvictor;
 
   beforeEach(() => {
     sessions = new Map();
-    evictor = new SessionEvictor(sessions as Map<string, EvictableSession>, {
-      ttlMs: 1000,
-      maxSessions: 3,
-      memoryThresholdBytes: Number.MAX_SAFE_INTEGER, // disable memory pressure for most tests
-      sweepIntervalMs: 60_000,
-    });
+    evictor = new ConversationEvictor(
+      sessions as Map<string, EvictableConversation>,
+      {
+        ttlMs: 1000,
+        maxConversations: 3,
+        memoryThresholdBytes: Number.MAX_SAFE_INTEGER, // disable memory pressure for most tests
+        sweepIntervalMs: 60_000,
+      },
+    );
   });
 
   describe("TTL eviction", () => {
@@ -84,9 +87,10 @@ describe("SessionEvictor", () => {
   });
 
   describe("LRU eviction", () => {
-    test("evicts least-recently-used sessions when over maxSessions", () => {
-      // maxSessions = 3, add 5 sessions
-      const allSessions: Array<EvictableSession & { disposed: boolean }> = [];
+    test("evicts least-recently-used conversations when over maxConversations", () => {
+      // maxConversations = 3, add 5 sessions
+      const allSessions: Array<EvictableConversation & { disposed: boolean }> =
+        [];
       for (let i = 0; i < 5; i++) {
         const s = createMockSession();
         sessions.set(`s${i}`, s);
@@ -115,7 +119,7 @@ describe("SessionEvictor", () => {
     });
 
     test("skips processing sessions during LRU eviction", () => {
-      // maxSessions = 3, add 4 sessions, one processing
+      // maxConversations = 3, add 4 sessions, one processing
       const s0 = createMockSession(true); // processing — should not be evicted
       const s1 = createMockSession();
       const s2 = createMockSession();

package/src/__tests__/{session-history-web-search.test.ts → conversation-history-web-search.test.ts}

@@ -74,9 +74,9 @@ mock.module("../memory/qdrant-client.js", () => ({
 import {
   consolidateAssistantMessages,
   findLastUndoableUserMessageIndex,
-  type HistorySessionContext,
+  type HistoryConversationContext,
   regenerate,
-} from "../daemon/session-history.js";
+} from "../daemon/conversation-history.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
 // ── Helpers ──────────────────────────────────────────────────────────
@@ -433,11 +433,11 @@ describe("regenerate with web_search_tool_result", () => {
     let agentLoopContent = "";
     let agentLoopUserMessageId = "";
 
-    const session: HistorySessionContext = {
+    const session: HistoryConversationContext = {
       conversationId,
       traceEmitter: {
         emit: () => {},
-      } as unknown as HistorySessionContext["traceEmitter"],
+      } as unknown as HistoryConversationContext["traceEmitter"],
       messages: [...inMemoryMessages],
       processing: false,
       abortController: null,
@@ -721,7 +721,7 @@ describe("web_search_tool_result structural guard", () => {
    * are listed in the allowlist below.
    *
    * If this test fails, either:
-   * 1. Use `isToolResultBlock()` from session-history.ts, or
+   * 1. Use `isToolResultBlock()` from conversation-history.ts, or
    * 2. Include both "tool_result" and "web_search_tool_result" in the check, or
    * 3. Add the file to the allowlist with a comment explaining why only
    *    `tool_result` is correct.
@@ -762,7 +762,7 @@ describe("web_search_tool_result structural guard", () => {
 
     // Reconciles synthesized cancellation tool_results for locally-executed
     // tools only. Same reasoning as agent/loop.ts above.
-    "daemon/session-agent-loop.ts",
+    "daemon/conversation-agent-loop.ts",
 
     // Parses tool_result blocks from skill invocation results. Skills
     // return tool_result blocks, never web_search_tool_result blocks.
@@ -800,6 +800,12 @@ describe("web_search_tool_result structural guard", () => {
     // helper function definition (which canonically defines the check).
     // We use brace depth tracking so nested blocks (if/else, etc.) inside the
     // helper don't prematurely end the allowlisted region.
+    //
+    // Two-phase state: `insideHelperSignature` is true when we've matched the
+    // function name but haven't yet seen the opening `{` (handles multi-line
+    // signatures like `function isToolResultBlock(\n  ...\n): boolean {`).
+    // Once the first `{` is found, we switch to brace-depth tracking.
+    let insideHelperSignature = false;
     let helperBraceDepth = 0;
 
     // Track which lines have already been used to suppress a raw tool_result check.
@@ -813,17 +819,35 @@ describe("web_search_tool_result structural guard", () => {
 
       // Detect entry of known helper functions that define the canonical check
       if (
+        !insideHelperSignature &&
         helperBraceDepth === 0 &&
         /function isToolResult(Block|Content)\b/.test(line)
       ) {
-        // Count opening braces on the declaration line itself (e.g. `function foo() {`)
+        // The opening `{` may be on this line or a subsequent line (multi-line
+        // signatures). Check if there are braces on this line to determine
+        // whether we can start depth tracking immediately.
         const opens = (line.match(/{/g) || []).length;
         const closes = (line.match(/}/g) || []).length;
-        helperBraceDepth = opens - closes;
+        if (opens > 0) {
+          helperBraceDepth = opens - closes;
+        } else {
+          insideHelperSignature = true;
+        }
+        continue;
+      }
+
+      // Still scanning the multi-line function signature for the opening `{`
+      if (insideHelperSignature) {
+        const opens = (line.match(/{/g) || []).length;
+        if (opens > 0) {
+          const closes = (line.match(/}/g) || []).length;
+          helperBraceDepth = opens - closes;
+          insideHelperSignature = false;
+        }
         continue;
       }
 
-      // Track brace depth while inside a helper function
+      // Track brace depth while inside a helper function body
       if (helperBraceDepth > 0) {
         const opens = (line.match(/{/g) || []).length;
         const closes = (line.match(/}/g) || []).length;
@@ -932,7 +956,7 @@ describe("web_search_tool_result structural guard", () => {
         ...allViolations.map((v) => `  - ${v.file}:${v.line}: ${v.text}`),
         "",
         "Fix options:",
-        "  1. Use isToolResultBlock() from session-history.ts",
+        "  1. Use isToolResultBlock() from conversation-history.ts",
         '  2. Add || block.type === "web_search_tool_result" to your check',
         "  3. If only tool_result is correct, add the file to ALLOWLISTED_FILES",
         "     in this test with a comment explaining why.",