@vellumai/assistant 0.8.4 → 0.8.5

package/src/runtime/sync/resource-sync-events.ts

@@ -9,15 +9,18 @@ import { getAvatarImagePath } from "../../util/platform.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
 import { publishSyncInvalidation } from "./sync-publisher.js";
 
-export function publishAvatarChanged(): void {
+export function publishAvatarChanged(originClientId?: string): void {
   broadcastMessage({
     type: "avatar_updated",
     avatarPath: getAvatarImagePath(),
   });
-  void publishSyncInvalidation([SYNC_TAGS.assistantAvatar]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantAvatar], originClientId);
 }
 
-export function publishIdentityChanged(fields: IdentityFields): void {
+export function publishIdentityChanged(
+  fields: IdentityFields,
+  originClientId?: string,
+): void {
   broadcastMessage({
     type: "identity_changed",
     name: fields.name,
@@ -26,59 +29,112 @@ export function publishIdentityChanged(fields: IdentityFields): void {
     emoji: fields.emoji,
     home: fields.home,
   });
-  void publishSyncInvalidation([SYNC_TAGS.assistantIdentity]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantIdentity], originClientId);
 }
 
-export function publishConfigChanged(): void {
+export function publishConfigChanged(originClientId?: string): void {
   broadcastMessage({ type: "config_changed" });
-  void publishSyncInvalidation([SYNC_TAGS.assistantConfig]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantConfig], originClientId);
 }
 
-export function publishSoundsConfigUpdated(): void {
+export function publishSoundsConfigUpdated(originClientId?: string): void {
   broadcastMessage({ type: "sounds_config_updated" });
-  void publishSyncInvalidation([SYNC_TAGS.assistantSounds]);
+  void publishSyncInvalidation([SYNC_TAGS.assistantSounds], originClientId);
 }
 
-export function publishSchedulesChanged(): void {
-  void publishSyncInvalidation([SYNC_TAGS.assistantSchedules]);
+export function publishSchedulesChanged(originClientId?: string): void {
+  void publishSyncInvalidation([SYNC_TAGS.assistantSchedules], originClientId);
+}
+
+/**
+ * Reasons that change the *shape* of the conversation list — a row is
+ * added, removed, or its position changes. These require web clients to
+ * refetch the paginated list because the row patch path (`refreshConversationRow`)
+ * only handles a single known id. Reasons not in this set are *content-only*
+ * changes to an existing row (e.g. `seen_changed`, `renamed`) and are
+ * delivered exclusively via the per-conversation `sync_changed` tag, which
+ * web consumes by GET-and-patching the single row.
+ */
+const SHAPE_CHANGING_REASONS: ReadonlySet<ConversationListInvalidatedReason> =
+  new Set(["created", "deleted", "reordered"]);
+
+/**
+ * Publish the legacy `conversation_list_invalidated` broadcast to macOS
+ * subscribers only.
+ *
+ * Web consumes `sync_changed` (`conversationsList` for shape changes,
+ * `conversation:<id>:metadata` for content changes) directly and patches
+ * the cached list in place — see `useAssistantSyncStream` for the consumer
+ * side. macOS (`ConversationRestorer.swift`) still listens for the typed
+ * broadcast.
+ *
+ * TODO(electron-cutover): remove this helper and all callers once macOS
+ * migrates to the Electron client and consumes `sync_changed` directly.
+ * At that point the `conversation_list_invalidated` message type can be
+ * retired entirely.
+ */
+function broadcastConversationListInvalidatedToMacos(
+  reason: ConversationListInvalidatedReason,
+): void {
+  broadcastMessage(
+    {
+      type: "conversation_list_invalidated",
+      reason,
+    },
+    undefined,
+    { targetInterfaceId: "macos" },
+  );
 }
 
 export function publishConversationListChanged(
   reason: ConversationListInvalidatedReason,
+  originClientId?: string,
 ): void {
-  broadcastMessage({
-    type: "conversation_list_invalidated",
-    reason,
-  });
-  void publishSyncInvalidation([SYNC_TAGS.conversationsList]);
+  broadcastConversationListInvalidatedToMacos(reason);
+  void publishSyncInvalidation([SYNC_TAGS.conversationsList], originClientId);
 }
 
 export function publishConversationMessagesChanged(
   conversationId: string,
+  originClientId?: string,
 ): void {
-  void publishSyncInvalidation([conversationMessagesSyncTag(conversationId)]);
+  void publishSyncInvalidation(
+    [conversationMessagesSyncTag(conversationId)],
+    originClientId,
+  );
 }
 
 export function publishConversationListAndMetadataChanged(
   reason: ConversationListInvalidatedReason,
   conversationIds: string | string[],
+  originClientId?: string,
 ): void {
   const ids = Array.isArray(conversationIds)
     ? conversationIds
     : [conversationIds];
-  broadcastMessage({
-    type: "conversation_list_invalidated",
-    reason,
-  });
-  void publishSyncInvalidation([
-    SYNC_TAGS.conversationsList,
-    ...ids.map((conversationId) => conversationMetadataSyncTag(conversationId)),
-  ]);
+  broadcastConversationListInvalidatedToMacos(reason);
+
+  // Shape-changing reasons (`created`, `deleted`, `reordered`) add or
+  // remove rows or change the order of the paginated window — web must
+  // refetch the list, so include the `conversationsList` umbrella tag.
+  // Content-only reasons (`renamed`, `seen_changed`) modify an existing
+  // row; web consumes the per-conversation metadata tag and GET-and-
+  // patches the single row, avoiding the full paginated list drain
+  // (`limit=50&offset=0..N` × foreground + background — ~14 requests
+  // per write at a few hundred conversations).
+  const tags: string[] = ids.map((conversationId) =>
+    conversationMetadataSyncTag(conversationId),
+  );
+  if (SHAPE_CHANGING_REASONS.has(reason)) {
+    tags.unshift(SYNC_TAGS.conversationsList);
+  }
+  void publishSyncInvalidation(tags, originClientId);
 }
 
 export function publishConversationTitleChanged(
   conversationId: string,
   title: string,
+  originClientId?: string,
 ): void {
   broadcastMessage(
     {
@@ -88,18 +144,27 @@ export function publishConversationTitleChanged(
     },
     conversationId,
   );
-  void publishSyncInvalidation([
-    SYNC_TAGS.conversationsList,
-    conversationMetadataSyncTag(conversationId),
-  ]);
+  // Renames are content-only — the paired typed `conversation_title_updated`
+  // event already carries the new title and patches the row in place on
+  // web; macOS receives the per-interface `conversation_list_invalidated`
+  // emitted from `broadcastMessage` (see `assistant-event-hub.ts`). The
+  // `sync_changed` metadata tag is included as a belt-and-suspenders signal
+  // for any sibling-tab consumer that missed the typed event.
+  void publishSyncInvalidation(
+    [conversationMetadataSyncTag(conversationId)],
+    originClientId,
+  );
 }
 
-export function publishConversationInferenceProfileChanged(params: {
-  conversationId: string;
-  profile: string | null;
-  sessionId?: string | null;
-  expiresAt?: number | null;
-}): void {
+export function publishConversationInferenceProfileChanged(
+  params: {
+    conversationId: string;
+    profile: string | null;
+    sessionId?: string | null;
+    expiresAt?: number | null;
+  },
+  originClientId?: string,
+): void {
   broadcastMessage(
     {
       type: "conversation_inference_profile_updated",
@@ -110,8 +175,11 @@ export function publishConversationInferenceProfileChanged(params: {
     },
     params.conversationId,
   );
-  void publishSyncInvalidation([
-    SYNC_TAGS.conversationsList,
-    conversationMetadataSyncTag(params.conversationId),
-  ]);
+  void publishSyncInvalidation(
+    [
+      SYNC_TAGS.conversationsList,
+      conversationMetadataSyncTag(params.conversationId),
+    ],
+    originClientId,
+  );
 }

package/src/runtime/sync/sync-publisher.test.ts

@@ -102,4 +102,53 @@ describe("sync publisher", () => {
       subscription.dispose();
     }
   });
+
+  test("forwards originClientId when provided", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const message = await publishSyncInvalidation(
+        [SYNC_TAGS.assistantAvatar],
+        "client-abc",
+      );
+
+      await waitFor(() => received.length === 1);
+
+      expect(message).toEqual({
+        type: "sync_changed",
+        tags: [SYNC_TAGS.assistantAvatar],
+        originClientId: "client-abc",
+      });
+      expect(received[0].message).toEqual(message);
+    } finally {
+      subscription.dispose();
+    }
+  });
+
+  test("omits originClientId when not provided", async () => {
+    const received: AssistantEvent[] = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        received.push(event);
+      },
+    });
+
+    try {
+      const message = await publishSyncInvalidation([SYNC_TAGS.assistantAvatar]);
+
+      await waitFor(() => received.length === 1);
+
+      expect("originClientId" in message).toBe(false);
+      expect(received[0].message).toEqual(message);
+    } finally {
+      subscription.dispose();
+    }
+  });
 });

package/src/runtime/sync/sync-publisher.ts

@@ -10,8 +10,9 @@ const log = getLogger("sync-publisher");
 
 export async function publishSyncInvalidation(
   tags: SyncInvalidationTag[],
+  originClientId?: string,
 ): Promise<SyncChangedMessage> {
-  const message = buildSyncChangedMessage(tags);
+  const message = buildSyncChangedMessage(tags, originClientId);
   try {
     broadcastMessage(message);
   } catch (err) {

package/src/runtime/verification-outbound-actions.ts

@@ -234,12 +234,20 @@ export async function startOutbound(
       params.rebind,
       originConversationId,
     );
+  } else if (channel === "email") {
+    return startOutboundEmail(
+      params.destination,
+      assistantId,
+      channel,
+      params.rebind,
+      originConversationId,
+    );
   }
 
   return {
     success: false,
     error: "unsupported_channel",
-    message: `Outbound verification is only supported for Telegram, phone, and Slack. Got: ${channel}`,
+    message: `Outbound verification is not supported for ${channel}. Supported channels: Telegram, phone, Slack, email.`,
     channel,
   };
 }
@@ -582,6 +590,70 @@ function startOutboundSlack(
   };
 }
 
+function startOutboundEmail(
+  destination: string | undefined,
+  assistantId: string,
+  channel: ChannelId,
+  rebind?: boolean,
+  originConversationId?: string,
+): OutboundActionResult {
+  if (!destination) {
+    return {
+      success: false,
+      error: "missing_destination",
+      message:
+        "An email address is required for outbound email verification.",
+      channel,
+    };
+  }
+
+  const normalizedEmail = destination.trim().toLowerCase();
+
+  const existingBinding = getGuardianBinding(assistantId, channel);
+  if (existingBinding && !rebind) {
+    return {
+      success: false,
+      error: "already_bound",
+      message:
+        "A guardian is already bound for this channel. Set rebind: true to replace.",
+      channel,
+    };
+  }
+
+  const recentSendCount = countRecentSendsToDestination(
+    channel,
+    normalizedEmail,
+    DESTINATION_RATE_WINDOW_MS,
+  );
+  if (recentSendCount >= MAX_SENDS_PER_DESTINATION_WINDOW) {
+    return {
+      success: false,
+      error: "rate_limited",
+      message:
+        "Too many verification attempts to this email address. Please try again later.",
+      channel,
+    };
+  }
+
+  const sessionResult = createOutboundSession({
+    channel,
+    expectedExternalUserId: normalizedEmail,
+    expectedChatId: normalizedEmail,
+    identityBindingStatus: "bound",
+    destinationAddress: normalizedEmail,
+    verificationPurpose: "guardian",
+  });
+
+  return {
+    success: true,
+    verificationSessionId: sessionResult.sessionId,
+    secret: sessionResult.secret,
+    expiresAt: sessionResult.expiresAt,
+    channel,
+    originConversationId,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Resend outbound
 // ---------------------------------------------------------------------------

package/src/telemetry/types.ts

@@ -38,6 +38,18 @@ export interface LlmUsageTelemetryEvent extends TelemetryEventBase {
   output_tokens: number;
   cache_creation_input_tokens: number | null;
   cache_read_input_tokens: number | null;
+  /**
+   * The provider's untouched `usage` block. Anthropic surfaces a TTL
+   * breakdown under `cache_creation.ephemeral_{5m,1h}_input_tokens`;
+   * OpenAI surfaces cached-read counts under
+   * `prompt_tokens_details.cached_tokens` (and reasoning tokens under
+   * `completion_tokens_details`). Both shapes are forwarded verbatim so
+   * downstream consumers (admin charts, dbt models) can extract any
+   * provider-specific detail without requiring a schema change here.
+   * Null when the provider did not return a usage payload, and for
+   * daemons that predate `260-llm-usage-add-raw-usage`.
+   */
+  raw_usage: Record<string, unknown> | null;
   actor: string;
   llm_call_site: LLMCallSite | null;
   inference_profile: string | null;

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -159,6 +159,7 @@ function makeUsageEvent(
     outputTokens: 50,
     cacheCreationInputTokens: 10,
     cacheReadInputTokens: 5,
+    rawUsage: null,
     actor: "main_agent",
     callSite: null,
     inferenceProfile: null,
@@ -435,6 +436,53 @@ describe("UsageTelemetryReporter", () => {
     expect(e.inference_profile_source).toBe("conversation");
     expect(e.cost).toBe(0.001);
     expect(e.recorded_at).toBe(1700000099000);
+    // raw_usage defaults to null on this fixture (the makeUsageEvent default),
+    // confirming the wire shape carries the key as `null` rather than
+    // dropping it for legacy rows or providers that did not return a
+    // usage block.
+    expect(e.raw_usage).toBeNull();
+  });
+
+  test("payload forwards the provider's raw_usage block verbatim", async () => {
+    // The reporter must surface the literal usage object the provider
+    // returned (Anthropic nests TTL breakdown under `cache_creation`,
+    // OpenAI nests cached-read counts under `prompt_tokens_details`,
+    // etc.) so downstream consumers can extract any provider-specific
+    // detail without a wire-level schema change. Anything that
+    // transforms, summarises, or strips fields here destroys data the
+    // admin charts and dbt models depend on.
+    const rawUsage = {
+      input_tokens: 200,
+      output_tokens: 100,
+      cache_creation_input_tokens: 750,
+      cache_creation: {
+        ephemeral_5m_input_tokens: 250,
+        ephemeral_1h_input_tokens: 500,
+      },
+      cache_read_input_tokens: 15,
+      service_tier: "standard",
+    };
+    const event = makeUsageEvent({
+      id: "evt-raw-usage",
+      provider: "anthropic",
+      model: "claude-sonnet-4-20250514",
+      cacheCreationInputTokens: 750,
+      rawUsage,
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([event]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    const e = body.events[0];
+    expect(e.cache_creation_input_tokens).toBe(750);
+    expect(e.raw_usage).toEqual(rawUsage);
   });
 
   test("payload preserves null attribution for historical usage rows", async () => {

package/src/telemetry/usage-telemetry-reporter.ts

@@ -234,6 +234,7 @@ export class UsageTelemetryReporter {
             output_tokens: e.outputTokens,
             cache_creation_input_tokens: e.cacheCreationInputTokens ?? null,
             cache_read_input_tokens: e.cacheReadInputTokens ?? null,
+            raw_usage: e.rawUsage,
             actor: e.actor,
             llm_call_site: e.callSite,
             inference_profile: e.inferenceProfile,

package/src/tools/acp/spawn.test.ts

@@ -82,6 +82,25 @@ mock.module("../../util/logger.js", () => ({
     }),
 }));
 
+// Stub secure-keys so the `prepareAgentEnv` preflight finds a token without
+// the test having to populate the real OS keyring. Driven via `secureKeyStore`
+// per test in beforeEach; the default seeds a vault token so existing tests
+// (which assume claude spawns succeed) keep passing.
+//
+// The real module's other exports are spread in so transitive importers
+// (e.g. session-manager → pending-interactions → credential-routes, which
+// imports `getSecureKeyResultAsync`) still resolve at parse time. Bun's
+// `mock.module` is process-global and returns *exactly* the keys the factory
+// returns — without the spread, any consumer pulling a non-`getSecureKeyAsync`
+// export errors with "Export named '<X>' not found".
+const secureKeyStore = new Map<string, string>();
+const realSecureKeys = await import("../../security/secure-keys.js");
+
+mock.module("../../security/secure-keys.js", () => ({
+  ...realSecureKeys,
+  getSecureKeyAsync: async (key: string) => secureKeyStore.get(key),
+}));
+
 // Stub session manager so we don't actually spawn child processes.
 const spawnMock = mock(
   async (
@@ -131,6 +150,14 @@ beforeEach(() => {
   _resetAdapterVersionCacheForTests();
   config.setConfig({ agents: DEFAULT_TEST_AGENTS });
   which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
+  // Default: vault has a claude token so the preflight in `prepareAgentEnv`
+  // succeeds for tests that don't care about env injection. Env-injection
+  // tests below clear/override this explicitly.
+  secureKeyStore.clear();
+  secureKeyStore.set(
+    "credential/acp/claude_oauth_token",
+    "default-test-token",
+  );
 });
 
 // ---------------------------------------------------------------------------
@@ -376,3 +403,95 @@ describe("executeAcpSpawn — per-agent resume hint", () => {
     expect(payload.message).not.toContain("To resume this session later");
   });
 });
+
+// ---------------------------------------------------------------------------
+// executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN env injection + preflight
+//
+// Mirrors the HTTP-route test block in
+// `runtime/routes/acp-routes.test.ts` — the skill tool calls into the same
+// `prepareAgentEnv` helper, and the contract must be identical so a
+// missing token fails the spawn at the tool boundary (`isError: true`)
+// instead of letting a token-less subprocess zombie out. PR-history
+// context: the inline env-injection used to live in the route only; this
+// tool path was bypassing it entirely, causing every skill-driven ACP
+// spawn to die on first prompt with "Authentication required". Pin both
+// the happy paths and the throw path here so future drift on either
+// caller fails the suite loudly.
+// ---------------------------------------------------------------------------
+
+describe("executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN injection", () => {
+  test("injects CLAUDE_CODE_OAUTH_TOKEN from the secure store for the claude agent", async () => {
+    secureKeyStore.clear();
+    secureKeyStore.set(
+      "credential/acp/claude_oauth_token",
+      "tool-vault-token-abc",
+    );
+    execScripts.set("npm ls", { error: new Error("npm not installed") });
+    execScripts.set("npm view", { error: new Error("npm not installed") });
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(spawnMock).toHaveBeenCalledTimes(1);
+    const agentConfigArg = spawnMock.mock.calls[0][1] as {
+      env?: Record<string, string>;
+    };
+    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
+      "tool-vault-token-abc",
+    );
+  });
+
+  test("accepts CLAUDE_CODE_OAUTH_TOKEN from config.json agent.env without a vault entry", async () => {
+    // Mirrors the route-level precedence test: a config.json env override
+    // is the first-priority provisioning route. The resolver surfaces it
+    // on `resolved.agent.env`, which the helper preserves.
+    secureKeyStore.clear();
+    config.setConfig({
+      agents: {
+        claude: {
+          command: "claude-agent-acp",
+          args: [],
+          env: { CLAUDE_CODE_OAUTH_TOKEN: "tool-config-token-xyz" },
+        },
+        codex: { command: "codex-acp", args: [] },
+        "unknown-agent": { command: "some-other-binary", args: [] },
+      },
+    });
+    execScripts.set("npm ls", { error: new Error("npm not installed") });
+    execScripts.set("npm view", { error: new Error("npm not installed") });
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    const agentConfigArg = spawnMock.mock.calls[0][1] as {
+      env?: Record<string, string>;
+    };
+    expect(agentConfigArg.env?.CLAUDE_CODE_OAUTH_TOKEN).toBe(
+      "tool-config-token-xyz",
+    );
+  });
+
+  test("returns isError when no token is available from either route (preflight throw mapped to tool result)", async () => {
+    // Both routes empty. The helper throws `FailedDependencyError`; the
+    // tool catches it and returns `{ isError: true, content: <msg> }`
+    // rather than letting it propagate (the tool boundary is a sync
+    // ToolExecutionResult, not an HTTP response).
+    secureKeyStore.clear();
+
+    const result = await executeAcpSpawn(
+      { agent: "claude", task: "do something" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("CLAUDE_CODE_OAUTH_TOKEN");
+    // Spawn was NEVER called — preflight fired before the subprocess started.
+    expect(spawnMock).not.toHaveBeenCalled();
+  });
+});

package/src/tools/acp/spawn.ts

@@ -1,6 +1,7 @@
 import { execFile } from "node:child_process";
 
 import { getAcpSessionManager } from "../../acp/index.js";
+import { prepareAgentEnv } from "../../acp/prepare-agent-env.js";
 import { resolveAcpAgent } from "../../acp/resolve-agent.js";
 import { DEFAULT_AGENT_NPM_PACKAGES } from "../../config/acp-defaults.js";
 import { getLogger } from "../../util/logger.js";
@@ -159,8 +160,6 @@ export async function executeAcpSpawn(
       }
     }
   }
-  const agentConfig = resolved.agent;
-
   const sendToClient = context.sendToClient as
     | ((msg: { type: string; [key: string]: unknown }) => void)
     | undefined;
@@ -171,6 +170,20 @@ export async function executeAcpSpawn(
     };
   }
 
+  // Inject required env vars and preflight via the shared helper. Mirrors
+  // the HTTP route at `runtime/routes/acp-routes.ts:spawnSession` — both
+  // call sites MUST go through `prepareAgentEnv` before `manager.spawn`,
+  // otherwise the spawned subprocess starts with no auth and dies as a
+  // zombie after the first prompt. See `acp/prepare-agent-env.ts` for
+  // the full rationale.
+  let agentConfig;
+  try {
+    agentConfig = await prepareAgentEnv(resolved.agent);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: msg, isError: true };
+  }
+
   // Best-effort version check — never blocks the spawn. If outdated, we
   // append a non-blocking warning to the success payload.
   const versionInfo = await checkAdapterVersion(agentConfig.command);

package/src/tools/apps/definitions.ts

@@ -9,7 +9,6 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import type { Tool, ToolExecutionResult } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -33,12 +32,9 @@ const appOpenTool: Tool = {
   category: "apps",
   defaultRiskLevel: RiskLevel.Low,
   executionMode: "proxy",
+  executionTarget: "host",
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema: {
         type: "object",
         properties: {
           app_id: {
@@ -54,8 +50,6 @@ const appOpenTool: Tool = {
         },
         required: ["app_id"],
       },
-    };
-  },
 
   execute: proxyExecute,
 };

package/src/tools/ask-question/ask-question-tool.test.ts

@@ -51,7 +51,7 @@ const singleQ = {
 
 describe("AskQuestionTool definition", () => {
   test("exposes the expected schema shape and description language", () => {
-    const def = new AskQuestionTool().getDefinition();
+    const def = new AskQuestionTool();
     expect(def.name).toBe("ask_question");
     expect(def.description).toContain("free-text fallback is always added");
     expect(def.description).toContain("do not");
@@ -463,8 +463,8 @@ describe("AskQuestionTool batched input", () => {
 
 describe("AskQuestionTool definition (batched schema)", () => {
   test("exposes `questions[]` shape, keeps legacy fields, omits per-question id", () => {
-    const def = new AskQuestionTool().getDefinition();
-    const schema = def.input_schema as {
+    const def = new AskQuestionTool();
+    const schema = def.input_schema as unknown as {
       properties: Record<
         string,
         {