@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/conversation-slash-commands.test.ts

@@ -140,53 +140,19 @@ describe("resolveSlash command contract", () => {
   });
 });
 
-describe("resolveSlash /compact target override", () => {
-  test("plain /compact returns no override", async () => {
+describe("resolveSlash /compact", () => {
+  test("plain /compact resolves to kind=compact", async () => {
     const result = await resolveSlash("/compact");
     expect(result).toEqual({ kind: "compact" });
   });
 
-  test("/compact <integer> sets explicit token target", async () => {
+  test("/compact rejects arguments with usage hint", async () => {
     const result = await resolveSlash("/compact 30000");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 30000,
-    });
-  });
-
-  test("/compact <n>k expands to thousands", async () => {
-    const result = await resolveSlash("/compact 30k");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 30_000,
-    });
-  });
-
-  test("/compact <n>m expands to millions", async () => {
-    const result = await resolveSlash("/compact 1.5M");
-    expect(result).toEqual({
-      kind: "compact",
-      targetInputTokensOverride: 1_500_000,
-    });
-  });
-
-  test("/compact rejects malformed args with usage hint", async () => {
-    const result = await resolveSlash("/compact bogus");
     expect(result.kind).toBe("unknown");
     if (result.kind !== "unknown") throw new Error("expected unknown");
-    expect(result.message).toContain("`bogus`");
+    expect(result.message).toContain("does not take arguments");
     expect(result.message).toContain("/compact");
   });
-
-  test("/compact rejects zero", async () => {
-    const result = await resolveSlash("/compact 0");
-    expect(result.kind).toBe("unknown");
-  });
-
-  test("/compact rejects negative numbers", async () => {
-    const result = await resolveSlash("/compact -50");
-    expect(result.kind).toBe("unknown");
-  });
 });
 
 describe("resolveSlash /clean", () => {
@@ -227,9 +193,9 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/status", kind: "unknown" },
     { input: "/commands", kind: "unknown" },
     { input: "/compact", kind: "compact" },
-    { input: "/compact 30000", kind: "compact" },
-    { input: "/compact 30k", kind: "compact" },
-    { input: "/compact 1.5M", kind: "compact" },
+    { input: "/compact 30000", kind: "unknown" },
+    { input: "/compact 30k", kind: "unknown" },
+    { input: "/compact 1.5M", kind: "unknown" },
     { input: "/compact bogus", kind: "unknown" },
     { input: "/clean", kind: "clean" },
     { input: "  /clean  ", kind: "clean" },
@@ -239,7 +205,7 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/opus", kind: "unknown" },
     { input: "hello", kind: "passthrough" },
     { input: "  /compact  ", kind: "compact" },
-    { input: "  /compact 50k  ", kind: "compact" },
+    { input: "  /compact 50k  ", kind: "unknown" },
     { input: "/models foo", kind: "passthrough" },
   ];
 

package/src/__tests__/conversation-slash-queue.test.ts

@@ -228,7 +228,12 @@ mock.module("../agent/loop.js", () => ({
       const history = await new Promise<Message[]>((resolve) => {
         pendingRuns.push({ resolve, messages, onEvent });
       });
-      return { history, exitReason: null };
+      return {
+        history,
+        exitReason: null,
+        appendedNewMessages: history.length > messages.length,
+        newMessages: history.slice(messages.length),
+      };
     }
   },
 }));

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -366,6 +366,90 @@ describe("surface action delivery to assistant", () => {
     expect(JSON.stringify(completeMsg)).not.toContain(largeBase64);
   });
 
+  test("choice surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "choice",
+      title: "Pick an outcome",
+      data: {
+        options: [
+          { id: "inbox", title: "Clean up my inbox" },
+          { id: "calendar", title: "Plan my week" },
+        ],
+      },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "inbox", {
+      choiceId: "inbox",
+      choiceTitle: "Clean up my inbox",
+      selectedIds: ["inbox"],
+      selectedTitles: ["Clean up my inbox"],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+    expect(completeMsg?.summary).toBe('User chose: "Clean up my inbox"');
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
+  });
+
+  test("oauth_connect surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "oauth_connect",
+      title: "Connect Google",
+      data: {
+        providerKey: "google",
+        displayName: "Google",
+      },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "connect", {
+      status: "connected",
+      providerKey: "google",
+      providerLabel: "Google",
+      accountLabel: "user@example.com",
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+    expect(completeMsg?.summary).toBe("Connected Google: user@example.com");
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(false);
+  });
+
   test("table surface does NOT broadcast ui_surface_complete (not one-shot)", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);

package/src/__tests__/conversation-sync-tags.test.ts

@@ -1,5 +1,3 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
 import {
@@ -18,6 +16,7 @@ import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as CONVERSATION_LIST_ROUTES } from "../runtime/routes/conversation-list-routes.js";
 import { ROUTES as CONVERSATION_MANAGEMENT_ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import type { RouteDefinition } from "../runtime/routes/types.js";
+import { publishConversationTitleChanged } from "../runtime/sync/resource-sync-events.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { waitFor } from "./helpers/wait-for.js";
 
@@ -122,20 +121,33 @@ describe("conversation sync tags", () => {
     ).toBe(false);
   });
 
-  test("agent-loop title updates emit metadata-only sync tags (no list umbrella)", () => {
-    const source = readFileSync(
-      join(import.meta.dir, "..", "daemon", "conversation-agent-loop.ts"),
-      "utf-8",
+  test("auto-title generation emits the typed title event and a metadata-only sync tag (no list umbrella)", async () => {
+    // Auto-title generation (first-pass on prompt submit, second-pass
+    // regeneration, bootstrap, and voice) persists via the title service and
+    // broadcasts through `publishConversationTitleChanged` — the same helper
+    // the rename route uses. Like a rename, generation is content-only: the
+    // row stays in place and only the title flips, so web patches the cached
+    // row from the typed `conversation_title_updated` event and the per-
+    // conversation metadata tag is the belt-and-suspenders signal. The list
+    // umbrella is deliberately omitted so web never redrains the paginated
+    // list for a title change.
+    const conversation = createConversation("Generating…");
+
+    const received = await captureEvents(() => {
+      publishConversationTitleChanged(conversation.id, "Generated title");
+    }, 2);
+
+    expect(received.map((event) => event.message.type)).toEqual([
+      "conversation_title_updated",
+      "sync_changed",
+    ]);
+    expect(received[1]!.message).toEqual({
+      type: "sync_changed",
+      tags: [conversationMetadataSyncTag(conversation.id)],
+    });
+    expect((received[1]!.message as { tags: string[] }).tags).not.toContain(
+      SYNC_TAGS.conversationsList,
     );
-    const titleUpdateBlocks =
-      source.match(
-        /type: "conversation_title_updated"[\s\S]{0,500}?type: "sync_changed"[\s\S]{0,250}?tags: \[[\s\S]*?\]/g,
-      ) ?? [];
-
-    expect(titleUpdateBlocks.length).toBeGreaterThanOrEqual(2);
-    for (const block of titleUpdateBlocks) {
-      expect(block).not.toContain("SYNC_TAGS.conversationsList");
-    }
   });
 
   test("create emits a sync_changed with the conversationsList umbrella tag", async () => {

package/src/__tests__/conversation-title-service.test.ts

@@ -51,9 +51,18 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+const mockPublishConversationTitleChanged = mock(
+  (_conversationId: string, _title: string) => {},
+);
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  publishConversationTitleChanged: mockPublishConversationTitleChanged,
+}));
+
 import {
   generateAndPersistConversationTitle,
+  queueGenerateConversationTitle,
   regenerateConversationTitle,
+  titleMutex,
 } from "../memory/conversation-title-service.js";
 
 describe("conversation-title-service", () => {
@@ -63,6 +72,7 @@ describe("conversation-title-service", () => {
     mockGetMessages.mockClear();
     mockUpdateConversationTitle.mockClear();
     mockGetConfiguredProvider.mockClear();
+    mockPublishConversationTitleChanged.mockClear();
   });
 
   test("uses the BTW side-chain helper for initial title generation", async () => {
@@ -87,7 +97,7 @@ describe("conversation-title-service", () => {
         systemPrompt: expect.stringContaining("conversation titles"),
         tools: [],
         callSite: "conversationTitle",
-        timeoutMs: 10_000,
+        timeoutMs: 15_000,
       }),
     );
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
@@ -95,6 +105,12 @@ describe("conversation-title-service", () => {
       "Project kickoff",
       1,
     );
+    // Emit is service-native: persisting a title broadcasts the update so
+    // every title origin (agent loop, bootstrap, voice) updates clients live.
+    expect(mockPublishConversationTitleChanged).toHaveBeenCalledWith(
+      "conv-1",
+      "Project kickoff",
+    );
   });
 
   test("regeneration extracts text from JSON content blocks", async () => {
@@ -205,7 +221,7 @@ describe("conversation-title-service", () => {
         systemPrompt: expect.stringContaining("conversation titles"),
         tools: [],
         callSite: "conversationTitle",
-        timeoutMs: 10_000,
+        timeoutMs: 15_000,
       }),
     );
     expect(mockUpdateConversationTitle).toHaveBeenCalledWith(
@@ -354,4 +370,121 @@ describe("conversation-title-service", () => {
     expect(call.content).not.toContain("do NOT respond");
     expect(call.systemPrompt).toContain("Do NOT respond");
   });
+
+  test("queueGenerateConversationTitle serializes concurrent calls", async () => {
+    const callOrder: string[] = [];
+    let resolveFirst!: () => void;
+    const firstBlocked = new Promise<void>((r) => {
+      resolveFirst = r;
+    });
+
+    // First call: blocks until we release it
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      callOrder.push("first:start");
+      await firstBlocked;
+      callOrder.push("first:end");
+      return {
+        text: "Title One",
+        hadTextDeltas: true,
+        response: {
+          content: [{ type: "text", text: "Title One" }],
+          model: "test-model",
+          usage: { inputTokens: 10, outputTokens: 5 },
+          stopReason: "end_turn",
+        },
+      };
+    });
+
+    // Second call: resolves immediately
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      callOrder.push("second:start");
+      return {
+        text: "Title Two",
+        hadTextDeltas: true,
+        response: {
+          content: [{ type: "text", text: "Title Two" }],
+          model: "test-model",
+          usage: { inputTokens: 10, outputTokens: 5 },
+          stopReason: "end_turn",
+        },
+      };
+    });
+
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("should not call directly");
+      }),
+    };
+
+    // Fire both calls — without serialization both would start immediately
+    queueGenerateConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "first message",
+    });
+    queueGenerateConversationTitle({
+      conversationId: "conv-2",
+      provider,
+      userMessage: "second message",
+    });
+
+    // Let microtasks settle — only the first call should have started
+    await new Promise((r) => setTimeout(r, 10));
+    expect(callOrder).toEqual(["first:start"]);
+
+    // Release the first call
+    resolveFirst();
+    await titleMutex.withLock(async () => {});
+
+    // Second should have started only after first finished
+    expect(callOrder).toEqual(["first:start", "first:end", "second:start"]);
+  });
+
+  test("queue continues processing after a failed call", async () => {
+    // First call: throws
+    mockRunBtwSidechain.mockImplementationOnce(async () => {
+      throw new Error("provider timeout");
+    });
+
+    // Second call: succeeds
+    mockRunBtwSidechain.mockImplementationOnce(async () => ({
+      text: "Recovery Title",
+      hadTextDeltas: true,
+      response: {
+        content: [{ type: "text", text: "Recovery Title" }],
+        model: "test-model",
+        usage: { inputTokens: 10, outputTokens: 5 },
+        stopReason: "end_turn",
+      },
+    }));
+
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("should not call directly");
+      }),
+    };
+
+    queueGenerateConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "will fail",
+    });
+    queueGenerateConversationTitle({
+      conversationId: "conv-2",
+      provider,
+      userMessage: "will succeed",
+    });
+
+    await titleMutex.withLock(async () => {});
+
+    // Both calls went through — failure didn't break the chain
+    expect(mockRunBtwSidechain).toHaveBeenCalledTimes(2);
+    // Second conversation got a proper title
+    const secondUpdate = (
+      mockUpdateConversationTitle.mock.calls as unknown as string[][]
+    ).find((c) => c[0] === "conv-2" && c[1] === "Recovery Title");
+    expect(secondUpdate).toBeTruthy();
+  });
 });

package/src/__tests__/conversation-workspace-injection.test.ts

@@ -265,7 +265,12 @@ mock.module("../agent/loop.js", () => ({
         content: [{ type: "text", text: "ok" }],
       };
       onEvent({ type: "message_complete", message: assistantMessage });
-      return { history: [...messages, assistantMessage], exitReason: null };
+      return {
+        history: [...messages, assistantMessage],
+        exitReason: null,
+        appendedNewMessages: true,
+        newMessages: [assistantMessage],
+      };
     }
   },
 }));

package/src/__tests__/cross-provider-web-search.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type {
   ContentBlock,
@@ -221,6 +221,64 @@ import {
   OpenAIResponsesProvider,
 } from "../providers/openai/client.js";
 
+// ---------------------------------------------------------------------------
+// App-side web_search provider adapters (Brave/Perplexity/Tavily)
+//
+// Exercise the real `web-search.ts` execute path with a mocked config, provider
+// key, and global fetch. The logger is mocked to capture structured warnings so
+// we can assert the `web_search_backend_failure` telemetry (ATL-727).
+// ---------------------------------------------------------------------------
+
+let mockWebSearchProvider: string = "brave";
+let mockProviderKey: string | undefined = "test-key";
+const capturedWarnLogs: Record<string, unknown>[] = [];
+
+const realConfigLoader = await import("../config/loader.js");
+mock.module("../config/loader.js", () => ({
+  ...realConfigLoader,
+  getConfig: () => ({
+    services: { "web-search": { provider: mockWebSearchProvider } },
+  }),
+}));
+
+const realSecureKeys = await import("../security/secure-keys.js");
+mock.module("../security/secure-keys.js", () => ({
+  ...realSecureKeys,
+  getProviderKeyAsync: async () => mockProviderKey,
+}));
+
+const realLogger = await import("../util/logger.js");
+mock.module("../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: (_target, prop) => {
+        if (prop === "warn") {
+          return (obj: Record<string, unknown>) => {
+            capturedWarnLogs.push(obj);
+          };
+        }
+        return () => {};
+      },
+    }),
+}));
+
+const { webSearchTool } = await import("../tools/network/web-search.js");
+const { WEB_SEARCH_BACKEND_FAILURE_MESSAGE } = await import(
+  "../tools/network/web-search-error.js"
+);
+
+function executeWebSearch(input: Record<string, unknown>) {
+  return webSearchTool.execute(input, {} as never);
+}
+
+function executeWebSearchWithSignal(
+  input: Record<string, unknown>,
+  signal: AbortSignal,
+) {
+  return webSearchTool.execute(input, { signal } as never);
+}
+
 // ---------------------------------------------------------------------------
 // OpenAI Responses API provider tests
 // ---------------------------------------------------------------------------
@@ -604,3 +662,158 @@ describe("Cross-Provider Web Search — Gemini", () => {
     expect(functionCallParts).toHaveLength(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// App-side provider backend-failure normalization (ATL-727)
+// ---------------------------------------------------------------------------
+
+describe("Cross-Provider Web Search — app-side backend failure normalization", () => {
+  let originalFetch: typeof globalThis.fetch;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    mockWebSearchProvider = "brave";
+    mockProviderKey = "test-key";
+    capturedWarnLogs.length = 0;
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  function backendFailureLog() {
+    return capturedWarnLogs.find(
+      (entry) => entry.event === "web_search_backend_failure",
+    );
+  }
+
+  test("503 from provider yields friendly recoverable copy in content + errorMessage, logs raw 503, no body leak", async () => {
+    const rawBody = '{"error":"upstream exploded","trace":"do-not-leak"}';
+    globalThis.fetch = (async () =>
+      new Response(rawBody, { status: 503 })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "needle in a haystack" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    const meta = result.activityMetadata?.webSearch;
+    expect(meta?.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(meta?.results).toEqual([]);
+    expect(meta?.resultCount).toBe(0);
+
+    const logEntry = backendFailureLog();
+    expect(logEntry).toBeDefined();
+    expect(logEntry!.provider).toBe("brave");
+    expect(logEntry!.errorCategory).toBe("backend_unavailable");
+    expect(logEntry!.fallbackShown).toBe(true);
+    expect(logEntry!.queryLength).toBe("needle in a haystack".length);
+    expect(String(logEntry!.rawDetail)).toContain("503");
+    // Provider diagnostic body is preserved in internal telemetry rawDetail.
+    expect(String(logEntry!.rawDetail)).toContain("upstream exploded");
+    expect(String(logEntry!.rawDetail)).toContain("do-not-leak");
+
+    // Raw provider body must never reach user-facing fields.
+    expect(result.content).not.toContain("upstream exploded");
+    expect(result.content).not.toContain("do-not-leak");
+    expect(meta?.errorMessage).not.toContain("upstream exploded");
+    expect(meta?.errorMessage).not.toContain("do-not-leak");
+  });
+
+  test("thrown network error yields the same friendly backend result", async () => {
+    globalThis.fetch = (async () => {
+      throw new TypeError("fetch failed");
+    }) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "offline" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(result.activityMetadata?.webSearch?.errorMessage).toBe(
+      WEB_SEARCH_BACKEND_FAILURE_MESSAGE,
+    );
+    const logEntry = backendFailureLog();
+    expect(logEntry).toBeDefined();
+    expect(logEntry!.errorCategory).toBe("backend_unavailable");
+    expect(result.content).not.toContain("fetch failed");
+  });
+
+  test("401 invalid-key preserves the specific message, not the backend copy", async () => {
+    globalThis.fetch = (async () =>
+      new Response("Unauthorized", { status: 401 })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "bad key" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("Invalid or expired Brave Search API key");
+    expect(result.content).not.toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    expect(result.activityMetadata?.webSearch?.errorMessage).not.toBe(
+      WEB_SEARCH_BACKEND_FAILURE_MESSAGE,
+    );
+    expect(backendFailureLog()).toBeUndefined();
+  });
+
+  test("HTTP 200 with zero results stays a success (unchanged)", async () => {
+    globalThis.fetch = (async () =>
+      new Response(JSON.stringify({ web: { results: [] } }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "no hits" });
+
+    expect(result.isError).toBe(false);
+    expect(result.activityMetadata?.webSearch?.errorMessage).toBeUndefined();
+    expect(result.content).toContain("No results found");
+    expect(backendFailureLog()).toBeUndefined();
+  });
+
+  test("post-retry 429 yields the friendly recoverable copy and preserves body in rawDetail", async () => {
+    const rawBody = '{"error":"quota burned","retryHint":"do-not-leak-429"}';
+    globalThis.fetch = (async () =>
+      new Response(rawBody, {
+        status: 429,
+        headers: { "retry-after": "0" },
+      })) as unknown as typeof fetch;
+
+    const result = await executeWebSearch({ query: "rate limited" });
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    const meta = result.activityMetadata?.webSearch;
+    expect(meta?.errorMessage).toBe(WEB_SEARCH_BACKEND_FAILURE_MESSAGE);
+    const logEntry = backendFailureLog();
+    expect(logEntry).toBeDefined();
+    expect(logEntry!.errorCategory).toBe("rate_limited");
+    expect(String(logEntry!.rawDetail)).toContain("429");
+    // Provider diagnostic body is preserved in internal telemetry rawDetail.
+    expect(String(logEntry!.rawDetail)).toContain("quota burned");
+    expect(String(logEntry!.rawDetail)).toContain("do-not-leak-429");
+
+    // Raw provider body must never reach user-facing fields.
+    expect(result.content).not.toContain("quota burned");
+    expect(result.content).not.toContain("do-not-leak-429");
+    expect(meta?.errorMessage).not.toContain("quota burned");
+    expect(meta?.errorMessage).not.toContain("do-not-leak-429");
+  });
+
+  test("caller abort re-throws instead of producing a backend failure (no telemetry)", async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    // A caller-aborted request surfaces an AbortError from fetch.
+    globalThis.fetch = (async () => {
+      const abortError = new Error("The operation was aborted");
+      abortError.name = "AbortError";
+      throw abortError;
+    }) as unknown as typeof fetch;
+
+    // The cancellation must re-throw so the executor's abort handling takes
+    // over — NOT resolve to the friendly backend-failure result.
+    await expect(
+      executeWebSearchWithSignal({ query: "cancel me" }, controller.signal),
+    ).rejects.toThrow();
+
+    // No spurious backend-failure telemetry for a user/external cancellation.
+    expect(backendFailureLog()).toBeUndefined();
+  });
+});