@vellumai/assistant 0.11.1-dev.202608032128.6f59e1c → 0.11.1-dev.202608032226.351a4e2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.1-dev.202608032128.6f59e1c",
+  "version": "0.11.1-dev.202608032226.351a4e2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/conversation-error.test.ts

@@ -170,6 +170,112 @@ describe("classifyConversationError", () => {
       expect(result.userMessage).toContain("AI provider");
       expect(result.errorCategory).toBe("rate_limit");
     });
+
+    it("uses the ChatGPT OAuth route instead of the OpenAI registry default", () => {
+      providerRoutingSources.openai = "managed-proxy";
+      const err = new ProviderError(
+        "OpenAI API error (429): Too many requests",
+        "openai",
+        429,
+        { reason: "rate_limited" },
+      );
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "chatgpt-subscription",
+        isManagedRoute: false,
+      });
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.userMessage).toContain("AI provider");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
+
+    it("prefers the failed call's direct route over stale managed turn attribution", () => {
+      providerRoutingSources.openai = "managed-proxy";
+      const err = new ProviderError(
+        "OpenAI API error (429): Too many requests",
+        "openai",
+        429,
+        { reason: "rate_limited" },
+      );
+      err.attachRouteAttribution({
+        connectionName: "chatgpt-subscription",
+        profileName: "chatgpt",
+        isManagedRoute: false,
+      });
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "vellum",
+        profileName: "managed",
+        isManagedRoute: true,
+      });
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.userMessage).toContain("AI provider");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
+
+    it("prefers the failed call's managed fallback over stale direct turn attribution", () => {
+      const err = new ProviderError(
+        "Anthropic API error (429): Too many requests",
+        "anthropic",
+        429,
+        { reason: "rate_limited" },
+      );
+      err.attachRouteAttribution({
+        profileName: "direct",
+        isManagedRoute: true,
+      });
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "anthropic-key",
+        profileName: "direct",
+        isManagedRoute: false,
+      });
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.userMessage).toContain("Vellum managed inference");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
+
+    it("does not apply a managed LLM route to a plain rate-limit error", () => {
+      const result = classifyConversationError(
+        new Error("429 Too Many Requests from a tool API"),
+        {
+          ...baseCtx,
+          isManagedRoute: true,
+        },
+      );
+
+      expect(result.code).toBe("PROVIDER_RATE_LIMIT");
+      expect(result.errorCategory).toBe("rate_limit");
+    });
+
+    it("falls back to context for fields the failed call's route omits", () => {
+      const err = new ProviderError("Unauthorized", "anthropic", 401);
+      err.attachRouteAttribution({ profileName: "direct" });
+
+      const result = classifyConversationError(err, {
+        ...baseCtx,
+        connectionName: "anthropic-key",
+      });
+
+      expect(result.connectionName).toBe("anthropic-key");
+      expect(result.profileName).toBe("direct");
+    });
+
+    it("still recognizes a rewrapped Vellum quota body", () => {
+      const result = classifyConversationError(
+        new Error('429 {"code":"daily_quota_exceeded"}'),
+        baseCtx,
+      );
+
+      expect(result.code).toBe("MANAGED_USAGE_LIMIT");
+      expect(result.errorCategory).toBe("managed_usage_limit");
+    });
   });
 
   describe("provider overloaded errors", () => {

package/src/__tests__/llm-resolver.test.ts

@@ -6,6 +6,7 @@ import { CODE_DEFAULT_PROFILE_ENTRIES } from "../config/default-profile-catalog.
 import {
   type ResolutionFallbackReason,
   resolveCallSiteConfig,
+  resolveCallSiteConfigWithProfile,
   resolveDefaultProfileKey,
   resolveEffectiveProfileKey,
 } from "../config/llm-resolver.js";
@@ -859,6 +860,21 @@ describe("mix profiles", () => {
     }
   });
 
+  test("config and profile attribution share one mix selection", () => {
+    const selectedArms: string[] = [];
+    const resolved = resolveCallSiteConfigWithProfile("mainAgent", mixLlm, {
+      onMixSelected: ({ chosenProfile }) => {
+        selectedArms.push(chosenProfile);
+      },
+    });
+
+    expect(resolved.profileName).toBe("ab");
+    expect(selectedArms).toHaveLength(1);
+    expect(resolved.config.model).toBe(
+      selectedArms[0] === "a" ? "model-a" : "model-b",
+    );
+  });
+
   test("all dereference spots in a turn agree for the same seed", () => {
     // mainAgent (mix as activeProfile) and a non-main call site resolving the
     // same mix as its call-site profile must pick the same arm when given the

package/src/__tests__/provider-send-message-override-profile.test.ts

@@ -27,6 +27,7 @@ import type {
   ProviderResponse,
   SendMessageOptions,
 } from "../providers/types.js";
+import { ProviderError } from "../util/errors.js";
 import { setConfig } from "./helpers/set-config.js";
 
 const DUMMY_MESSAGES: Message[] = [
@@ -239,6 +240,91 @@ describe("SendMessageOptions.config.overrideProfile", () => {
     expect(response.model).toBe("openai");
   });
 
+  test("CallSiteRoutingProvider attributes provider errors to the actual resolved connection", async () => {
+    setLlmConfig({
+      profiles: {
+        fast: {
+          provider: "openai",
+          provider_connection: "openai-conn",
+          model: "gpt-5.4",
+        },
+      },
+    });
+
+    const providerError = new ProviderError(
+      "OpenAI API error (429): Too many requests",
+      "openai",
+      429,
+      { reason: "rate_limited" },
+    );
+    const defaultProvider = makeThrowingProvider(
+      "anthropic",
+      new Error("default provider should not be called"),
+    );
+    const altProvider = makeThrowingProvider("openai", providerError);
+    altProvider.routeAttribution = {
+      connectionName: "openai-recovered",
+      isManagedRoute: false,
+    };
+    const wrapped = new CallSiteRoutingProvider(
+      defaultProvider,
+      async (connectionName) =>
+        connectionName === "openai-conn" ? altProvider : null,
+      { connectionName: "vellum", isManagedRoute: true },
+    );
+
+    await expect(
+      wrapped.sendMessage(DUMMY_MESSAGES, {
+        config: { callSite: "mainAgent", overrideProfile: "fast" },
+      }),
+    ).rejects.toBe(providerError);
+    expect(providerError.routeAttribution).toEqual({
+      connectionName: "openai-recovered",
+      profileName: "fast",
+      isManagedRoute: false,
+    });
+  });
+
+  test("CallSiteRoutingProvider attributes soft fallback errors to the actual default connection", async () => {
+    setLlmConfig({
+      profiles: {
+        fast: {
+          provider: "openai",
+          provider_connection: "openai-conn",
+          model: "gpt-5.4",
+        },
+      },
+    });
+
+    const providerError = new ProviderError(
+      "Anthropic API error (429): Too many requests",
+      "anthropic",
+      429,
+      { reason: "rate_limited" },
+    );
+    const defaultProvider = makeThrowingProvider("anthropic", providerError);
+    defaultProvider.routeAttribution = {
+      connectionName: "anthropic-default",
+      isManagedRoute: false,
+    };
+    const wrapped = new CallSiteRoutingProvider(
+      defaultProvider,
+      async () => null,
+      defaultProvider.routeAttribution,
+    );
+
+    await expect(
+      wrapped.sendMessage(DUMMY_MESSAGES, {
+        config: { callSite: "mainAgent", overrideProfile: "fast" },
+      }),
+    ).rejects.toBe(providerError);
+    expect(providerError.routeAttribution).toEqual({
+      connectionName: "anthropic-default",
+      profileName: "fast",
+      isManagedRoute: false,
+    });
+  });
+
   test("missing overrideProfile name silently falls through to base resolution", async () => {
     setLlmConfig({
       // The call-site tweak applies last in resolution, so it pins the model
@@ -328,6 +414,15 @@ describe("SendMessageOptions.config.overrideProfile", () => {
   });
 });
 
+function makeThrowingProvider(name: string, error: Error): Provider {
+  return {
+    name,
+    async sendMessage(): Promise<ProviderResponse> {
+      throw error;
+    },
+  };
+}
+
 describe("SendMessageOptions.config.forceOverrideProfile", () => {
   test("CallSiteConfiguredProvider forwards forceOverrideProfile into the send config", async () => {
     let captured: SendMessageOptions | undefined;

package/src/config/llm-resolver.ts

@@ -114,12 +114,29 @@ export interface ResolveCallSiteOpts {
 
 export type ResolutionFallbackReason = "missing" | "disabled" | "incomplete";
 
+export interface ResolvedCallSiteConfig {
+  config: z.infer<typeof LLMConfigBase>;
+  profileName?: string;
+}
+
+export function resolveCallSiteConfigWithProfile(
+  callSite: LLMCallSite,
+  llm: z.infer<typeof LLMSchema>,
+  opts: ResolveCallSiteOpts = {},
+): ResolvedCallSiteConfig {
+  const selection = selectWinningProfile(callSite, llm, opts);
+  return {
+    config: resolveOverrideOrDefault(callSite, llm, selection),
+    ...(selection.profileName ? { profileName: selection.profileName } : {}),
+  };
+}
+
 export function resolveCallSiteConfig(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
   opts: ResolveCallSiteOpts = {},
 ): z.infer<typeof LLMConfigBase> {
-  return resolveOverrideOrDefault(callSite, llm, opts);
+  return resolveCallSiteConfigWithProfile(callSite, llm, opts).config;
 }
 
 // ─── Single-winner profile resolution ───────────────────────────────────────
@@ -358,9 +375,8 @@ const CODE_DEFAULT_BASE: z.infer<typeof LLMConfigBase> = LLMConfigBase.parse(
 function resolveOverrideOrDefault(
   callSite: LLMCallSite,
   llm: z.infer<typeof LLMSchema>,
-  opts: ResolveCallSiteOpts,
+  selection: ProfileWinnerSelection,
 ): z.infer<typeof LLMConfigBase> {
-  const selection = selectWinningProfile(callSite, llm, opts);
   const winnerFragment: Mergeable =
     selection.entry == null ? {} : winnerConfigFragment(selection.entry);
 

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -120,6 +120,7 @@ import type { AssistantSurface } from "./conversation-agent-loop.js";
 import {
   buildConversationErrorMessage,
   classifyConversationError,
+  type ConversationErrorAttribution,
   maxTokensReachedClassification,
 } from "./conversation-error.js";
 import { buildDeferredFinalizeEffect } from "./conversation-turn-finalize.js";
@@ -555,6 +556,8 @@ export interface EventHandlerDeps {
    * degrades gracefully when it's absent.
    */
   readonly latencyTracker?: TurnLatencyTracker;
+  /** Best-effort resolved route metadata for provider error classification. */
+  readonly errorAttribution?: () => ConversationErrorAttribution;
 }
 
 // ── Factory ──────────────────────────────────────────────────────────
@@ -2628,9 +2631,7 @@ function handleError(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "error" }>,
 ): void {
-  const classified = classifyConversationError(event.error, {
-    phase: "agent_loop",
-  });
+  const classified = classifyAgentLoopError(event.error, deps);
   if (classified.errorCategory === "provider_api_error") {
     log.error(
       {
@@ -3140,9 +3141,7 @@ function handleProviderError(
   deps: EventHandlerDeps,
   event: Extract<AgentEvent, { type: "provider_error" }>,
 ): void {
-  const classified = classifyConversationError(event.error, {
-    phase: "agent_loop",
-  });
+  const classified = classifyAgentLoopError(event.error, deps);
   if (!shouldPersistProviderErrorAsAssistantMessage(classified)) {
     return;
   }
@@ -3164,6 +3163,16 @@ function handleProviderError(
   }
 }
 
+function classifyAgentLoopError(
+  error: Error,
+  deps: EventHandlerDeps,
+): ReturnType<typeof classifyConversationError> {
+  return classifyConversationError(error, {
+    phase: "agent_loop",
+    ...deps.errorAttribution?.(),
+  });
+}
+
 // ── Dispatcher ───────────────────────────────────────────────────────
 
 /** Routes an AgentEvent to the appropriate handler. */

package/src/daemon/conversation-agent-loop.ts

@@ -30,7 +30,7 @@ import {
 } from "../config/llm-context-resolution.js";
 import {
   resolveCallSiteConfig,
-  resolveEffectiveProfileKey,
+  resolveCallSiteConfigWithProfile,
   resolveProfilelessModelKey,
   selectWinningProfile,
 } from "../config/llm-resolver.js";
@@ -61,6 +61,11 @@ import { HOOKS } from "../plugin-api/constants.js";
 import type { ConversationGraphMemory } from "../plugins/defaults/memory/graph/conversation-graph-memory.js";
 import { enqueueMemoryRetrospectiveOnCompaction } from "../plugins/defaults/memory/memory-retrospective-enqueue.js";
 import { runHook } from "../plugins/pipeline.js";
+import { isManagedConnectionRoute } from "../providers/connection-resolution.js";
+import {
+  ConnectionResolutionError,
+  resolveRoutingIdentity,
+} from "../providers/routing-identity.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import { resolveCapabilities } from "../runtime/capabilities.js";
@@ -95,6 +100,7 @@ import {
   budgetYieldUnrecoveredClassification,
   buildConversationErrorMessage,
   classifyConversationError,
+  type ConversationErrorAttribution,
   isUserCancellation,
 } from "./conversation-error.js";
 import { raceWithTimeout } from "./conversation-media-retry.js";
@@ -422,10 +428,7 @@ export async function runAgentLoopImpl(
   // connection and profile so credential/connection errors point at the
   // exact slot to fix instead of a generic banner. Resolution can itself
   // throw on a broken config — attribution must never mask the real error.
-  const turnErrorAttribution = (): {
-    connectionName?: string;
-    profileName?: string;
-  } => {
+  const turnErrorAttribution = (): ConversationErrorAttribution => {
     try {
       const overrideProfile = readCurrentOverrideProfile();
       const resolveOpts = {
@@ -433,21 +436,30 @@ export async function runAgentLoopImpl(
         forceOverrideProfile,
         selectionSeed: ctx.conversationId,
       };
-      const resolved = resolveCallSiteConfig(
-        turnCallSite,
-        config.llm,
-        resolveOpts,
-      );
-      const profileName = resolveEffectiveProfileKey(
-        turnCallSite,
-        config.llm,
-        resolveOpts,
-      );
+      const { config: resolved, profileName } =
+        resolveCallSiteConfigWithProfile(turnCallSite, config.llm, resolveOpts);
+      let connectionName = resolved.provider_connection;
+      try {
+        connectionName =
+          resolveRoutingIdentity(resolved.provider, resolved.model)
+            ?.connectionName ?? connectionName;
+      } catch (error) {
+        if (!(error instanceof ConnectionResolutionError)) {
+          throw error;
+        }
+        connectionName = error.connectionName;
+      }
+      // Managed-ness comes from the connection row, matching what dispatch
+      // decides. The profile's own provider can't stand in: a concrete
+      // provider tweak over a managed winner keeps the managed connection
+      // while replacing the provider (`llm-resolver.ts`).
+      const isManagedRoute = connectionName
+        ? isManagedConnectionRoute(connectionName)
+        : undefined;
       return {
-        ...(resolved.provider_connection
-          ? { connectionName: resolved.provider_connection }
-          : {}),
+        ...(connectionName ? { connectionName } : {}),
         ...(profileName ? { profileName } : {}),
+        ...(isManagedRoute !== undefined ? { isManagedRoute } : {}),
       };
     } catch {
       return {};
@@ -1049,6 +1061,7 @@ export async function runAgentLoopImpl(
       turnInterfaceContext: capturedTurnInterfaceContext,
       applyCompaction: applySuccessfulCompaction,
       latencyTracker,
+      errorAttribution: turnErrorAttribution,
     };
     const eventHandler = (event: AgentEvent): Promise<void> => {
       if (

package/src/daemon/conversation-error.ts

@@ -63,6 +63,8 @@ export interface ClassifiedConversationError {
 export interface ConversationErrorAttribution {
   connectionName?: string;
   profileName?: string;
+  /** Whether the resolved turn route uses Vellum-managed inference. */
+  isManagedRoute?: boolean;
 }
 
 // Network-level error patterns (connection refused, timeout, DNS, reset)
@@ -181,6 +183,11 @@ export interface ErrorContext {
    * underlying connection name is generic.
    */
   profileName?: string;
+  /**
+   * Whether the resolved turn route uses Vellum-managed inference. Turn routing
+   * takes precedence over the provider registry's boot-time default.
+   */
+  isManagedRoute?: boolean;
 }
 
 /**
@@ -253,9 +260,19 @@ export function classifyConversationError(
   // credential-related classifications can name the exact slot to fix.
   // A `ProviderNotConfiguredError` instance carries its own attribution
   // (from the throw site) which takes priority over context when present.
+  // The failed call's own route wins field by field — it is resolved at
+  // dispatch, while context describes the turn and can be stale for this
+  // call. Per-field, so a route carrying only some fields doesn't blank the
+  // rest.
+  const providerRoute =
+    error instanceof ProviderError ? error.routeAttribution : undefined;
+  const connectionName = providerRoute?.connectionName ?? ctx.connectionName;
+  const profileName = providerRoute?.profileName ?? ctx.profileName;
+  const isManagedRoute = providerRoute?.isManagedRoute ?? ctx.isManagedRoute;
   const attribution: ConversationErrorAttribution = {
-    ...(ctx.connectionName ? { connectionName: ctx.connectionName } : {}),
-    ...(ctx.profileName ? { profileName: ctx.profileName } : {}),
+    ...(connectionName ? { connectionName } : {}),
+    ...(profileName ? { profileName } : {}),
+    ...(isManagedRoute !== undefined ? { isManagedRoute } : {}),
   };
 
   // Dedicated classification for missing provider API key
@@ -354,13 +371,18 @@ function classifyCore(
   message: string,
   attribution: ConversationErrorAttribution = {},
 ): Omit<ClassifiedConversationError, "debugDetails"> {
+  const isManagedRoute =
+    error instanceof ProviderError &&
+    (attribution.isManagedRoute ??
+      getProviderRoutingSource(error.provider) === "managed-proxy");
+
   // Prefer the semantic reason stamped by the provider layer, regardless of
   // HTTP status — statusless errors (e.g. SDK streaming failures) still carry a
   // reason. Reasons that map cleanly win here; `bad_request`/`unknown` (and a
   // reason-less error) fall through to the status switch + regex battery below.
   if (error instanceof ProviderError && error.reason) {
     const c = reasonToClassification(error.reason, {
-      routingSource: getProviderRoutingSource(error.provider),
+      isManagedRoute,
       attribution,
       message,
     });
@@ -382,20 +404,19 @@ function classifyCore(
       // Everything else is a user-set credential that the upstream provider
       // rejected, so emit `PROVIDER_INVALID_KEY` and let the chat banner point
       // at Settings.
-      const providerName = error.provider;
-      if (getProviderRoutingSource(providerName) === "managed-proxy") {
+      if (isManagedRoute) {
         return managedKeyInvalidClassification();
       }
       return invalidApiKeyClassification(attribution);
     }
     if (error.statusCode === 402) {
-      if (isManagedBalanceError(error)) {
+      if (isManagedRoute) {
         return managedBalanceClassification();
       }
       return providerBillingClassification();
     }
     if (error.statusCode === 429) {
-      if (isManagedUsageLimitError(error, message)) {
+      if (isManagedUsageLimitError(message, isManagedRoute)) {
         return managedUsageLimitClassification();
       }
       return rateLimitClassification();
@@ -508,7 +529,7 @@ function classifyCore(
   }
 
   // Regex fallback for non-ProviderError or ProviderError without statusCode
-  return classifyByMessage(error, message);
+  return classifyByMessage(message, isManagedRoute);
 }
 
 /**
@@ -540,12 +561,12 @@ function extractProviderDetail(message: string): string | undefined {
 function reasonToClassification(
   reason: ProviderErrorReason,
   args: {
-    routingSource?: string;
+    isManagedRoute: boolean;
     attribution?: ConversationErrorAttribution;
     message: string;
   },
 ): Omit<ClassifiedConversationError, "debugDetails"> | null {
-  const managed = args.routingSource === "managed-proxy";
+  const managed = args.isManagedRoute;
   switch (reason) {
     case "invalid_credentials":
       return managed
@@ -670,18 +691,13 @@ function isStreamingError(message: string): boolean {
   return STREAMING_ERROR_PATTERNS.some((p) => p.test(message));
 }
 
-function isManagedUsageLimitError(error: unknown, message: string): boolean {
-  if (
-    error instanceof ProviderError &&
-    getProviderRoutingSource(error.provider) === "managed-proxy"
-  ) {
-    return true;
-  }
-  return MANAGED_USAGE_LIMIT_PATTERNS.some((p) => p.test(message));
-}
-
-function isManagedBalanceError(error: ProviderError): boolean {
-  return getProviderRoutingSource(error.provider) === "managed-proxy";
+function isManagedUsageLimitError(
+  message: string,
+  isManagedRoute: boolean,
+): boolean {
+  return (
+    isManagedRoute || MANAGED_USAGE_LIMIT_PATTERNS.some((p) => p.test(message))
+  );
 }
 
 function isProviderBillingError(message: string): boolean {
@@ -912,8 +928,8 @@ function providerNotConfiguredClassification(
  * short-circuit and the status switch both decline to classify.
  */
 function classifyByMessage(
-  error: unknown,
   message: string,
+  isManagedRoute: boolean,
 ): Omit<ClassifiedConversationError, "debugDetails"> {
   // Empty-request-messages is always an internal construction failure — check
   // it before the provider/network patterns so a ProviderError that carries the
@@ -930,7 +946,7 @@ function classifyByMessage(
   // Check rate limit first (before network, since 429 could match both)
   for (const pattern of RATE_LIMIT_PATTERNS) {
     if (pattern.test(message)) {
-      if (isManagedUsageLimitError(error, message)) {
+      if (isManagedUsageLimitError(message, isManagedRoute)) {
         return managedUsageLimitClassification();
       }
       return rateLimitClassification();

package/src/live-voice/__tests__/activity-label.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Tests for the voice activity line.
+ *
+ * The invariant worth guarding is totality: the tool vocabulary is open
+ * (plugins, MCP servers, and skills all contribute names this module has never
+ * seen), and the surface this feeds is a Lock Screen the user cannot correct.
+ * A label that came back empty would blank the island exactly when the
+ * assistant is busiest.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  activityLabelForTool,
+  GENERIC_ACTIVITY_LABEL,
+} from "../activity-label.js";
+
+describe("activityLabelForTool", () => {
+  test("names what the user would say is happening, not the tool", () => {
+    expect(activityLabelForTool("bash")).toBe("Running a command");
+    expect(activityLabelForTool("web_search")).toBe("Searching the web");
+    expect(activityLabelForTool("file_read")).toBe("Reading a file");
+  });
+
+  // Where a tool runs is not a distinction anyone glancing at a Lock Screen is
+  // making.
+  test("host and sandbox variants read the same", () => {
+    expect(activityLabelForTool("host_bash")).toBe(
+      activityLabelForTool("bash"),
+    );
+    expect(activityLabelForTool("host_file_read")).toBe(
+      activityLabelForTool("file_read"),
+    );
+  });
+
+  test("falls back by prefix for structured tool families", () => {
+    expect(activityLabelForTool("browser_click")).toBe("Using the browser");
+    expect(activityLabelForTool("mcp_notion_search")).toBe(
+      "Using a connected app",
+    );
+  });
+
+  test("every tool gets a label, including ones this module has never seen", () => {
+    for (const name of [
+      "slack_conversations_history",
+      "",
+      "a",
+      "some_vendor::weird.tool/name",
+    ]) {
+      expect(activityLabelForTool(name)).toBe(GENERIC_ACTIVITY_LABEL);
+    }
+  });
+
+  test("labels stay short enough for the slot they land in", () => {
+    for (const name of [
+      "bash",
+      "web_search",
+      "host_file_transfer",
+      "computer_use",
+      "ui_show",
+      "unknown_tool",
+    ]) {
+      const label = activityLabelForTool(name);
+      expect(label.length).toBeLessThanOrEqual(32);
+      expect(label).not.toMatch(/[.!?]$/);
+    }
+  });
+});