@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.3-staging.1",
+  "version": "0.12.3-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/smoke-desktop-browser-cli.ts

@@ -14,26 +14,18 @@ import { registerBrowserCommand } from "../src/cli/commands/browser.js";
 import { DesktopAutomationLease } from "../src/desktop/desktop-automation-lease.js";
 import {
   desktopChromePath,
-  desktopDependencyInstaller,
+  desktopDependencies,
 } from "../src/desktop/desktop-dependencies.js";
 import { DesktopSessionManager } from "../src/desktop/desktop-session-manager.js";
 import { getAssistantSocketPath } from "../src/ipc/socket-path.js";
 
-if (
-  process.platform !== "linux" ||
-  !process.argv[2] ||
-  !process.env.ASSISTANT_IPC_SOCKET_DIR
-) {
+if (process.platform !== "linux" || !process.env.ASSISTANT_IPC_SOCKET_DIR) {
   throw new Error(
-    "Run in disposable Linux with desktop packages, a temporary ASSISTANT_IPC_SOCKET_DIR and a Chrome executable argument or --install for a cold install.",
+    "Run in a disposable Linux assistant image with a temporary ASSISTANT_IPC_SOCKET_DIR.",
   );
 }
-const coldInstall = process.argv[2] === "--install";
-const executable = coldInstall ? desktopChromePath() : process.argv[2];
-if (coldInstall) {
-  assert.equal(desktopDependencyInstaller.getStatus().state, "required");
-  assert.equal(Bun.which("Xtigervnc"), null);
-}
+const executable = desktopChromePath();
+assert.equal(desktopDependencies.getStatus().state, "ready");
 const directory = await mkdtemp(join(tmpdir(), "desktop-browser-cli-"));
 const manager = new DesktopSessionManager({
   resolveChromePath: async () => executable,
@@ -44,9 +36,7 @@ const manager = new DesktopSessionManager({
 const control = new DesktopAutomationLease({
   notify: async () => {},
   enabled: () => true,
-  ready: () =>
-    !coldInstall || desktopDependencyInstaller.getStatus().state === "ready",
-  ensureReady: (signal) => desktopDependencyInstaller.ensureReady(signal),
+  ready: () => desktopDependencies.getStatus().state === "ready",
   manager: () => manager,
 });
 const context = {
@@ -182,16 +172,10 @@ try {
     "--allow-private-network",
   );
   assert.equal(navigations, 1);
-  if (coldInstall) {
-    assert.equal(desktopDependencyInstaller.getStatus().state, "ready");
-    assert(
-      setupNotifications >= 3,
-      "Installation progress must reach the viewer",
-    );
-    console.error(
-      "PASS: one CLI navigate installed desktop and Chrome from scratch, then loaded the requested page once",
-    );
-  }
+  assert.equal(setupNotifications, 0);
+  console.error(
+    "PASS: baked desktop opened the requested page without installation",
+  );
   const snapshot = await cli("snapshot");
   await cli(
     "type",

package/scripts/smoke-desktop-window-theme.ts

@@ -91,15 +91,14 @@ try {
     `<bindings xmlns="http://openbox.org/3.4/rc">${mouse}${keyboard}</bindings>`,
   );
   const configDir = join(directory, "managed & theme");
-  const config = writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  const config = writeDesktopWindowTheme(configDir, home);
   const expanded = run("xmllint", "--xinclude", config);
   assert(
     expanded.includes("NextWindow") && expanded.includes("Move"),
     "Relative includes must retain the actual keyboard and mouse bindings",
   );
   assert.equal(await readFile(sourcePath, "utf8"), source);
-  writeDesktopWindowTheme(configDir, home, "#bc7799");
-  writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  writeDesktopWindowTheme(configDir, home);
   assert.equal(await readFile(sourcePath, "utf8"), source);
   const blocked = join(directory, "blocked");
   await writeFile(blocked, "not a directory");

package/src/__tests__/agent-loop-output-hooks.test.ts

@@ -6,7 +6,7 @@
  */
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { AgentEvent } from "../agent/loop.js";
+import type { AgentEvent, PreparedModelCall } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type {
   PostModelCallContext,
@@ -18,12 +18,14 @@ import type {
   ContentBlock,
   Message,
   ProviderResponse,
+  ToolDefinition,
 } from "../providers/types.js";
 import {
   createMockProvider,
   textResponse,
   toolUseResponse,
 } from "./helpers/mock-provider.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const userMessage: Message = {
   role: "user",
@@ -91,6 +93,7 @@ function registerOutputHookPlugin(hooks: {
 describe("agent loop output hooks", () => {
   beforeEach(() => {
     resetPluginRegistryAndRegisterDefaults();
+    setConfig("llm", {});
   });
 
   test("post-model-call transforms the persisted message content", async () => {
@@ -403,6 +406,152 @@ describe("agent loop output hooks", () => {
     expect(calls[0].options?.config?.overrideProfile).toBe("fast-profile");
   });
 
+  test("prepared model call carries the post-hook route and wire tool surface", async () => {
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        ctx.systemPrompt = `${ctx.systemPrompt ?? ""} [EDITED]`;
+        ctx.modelProfile = "fast-profile";
+      },
+    });
+    const tool: ToolDefinition = {
+      name: "dynamic_tool",
+      description: "Dynamic",
+      input_schema: { type: "object" },
+    };
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    Object.assign(provider, { supportsNativeWebSearch: true });
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+      config: { enableNativeWebSearch: true },
+      resolveTools: () => [tool],
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      overrideProfile: "conversation-profile",
+      forceOverrideProfile: true,
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared).toMatchObject({
+      callSite: "mainAgent",
+      overrideProfile: "fast-profile",
+      forceOverrideProfile: true,
+      systemPrompt: "base prompt [EDITED]",
+    });
+    expect(prepared?.tools.map((item) => item.name)).toEqual([
+      "dynamic_tool",
+      "web_search",
+    ]);
+    expect(calls[0].tools).toEqual(prepared?.tools);
+  });
+
+  test("prepared model call carries the finalized cache policy", async () => {
+    setConfig("llm", {
+      callSites: { mainAgent: { disableCache: true } },
+    });
+    const { provider } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared?.disableCache).toBe(true);
+  });
+
+  test("prepared model call preserves explicit system-prompt removal", async () => {
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        ctx.systemPrompt = null;
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared?.systemPrompt).toBeNull();
+    expect(calls[0].options?.systemPrompt).toBeUndefined();
+  });
+
+  test("inference routing preserves the semantic call site for hooks and events", async () => {
+    const preModelCallSites: Array<string | null> = [];
+    const postModelCallSites: Array<string | null> = [];
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        preModelCallSites.push(ctx.callSite);
+      },
+      postModelCall: (ctx) => {
+        postModelCallSites.push(ctx.callSite);
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+    const events: AgentEvent[] = [];
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect(events),
+      callSite: "callAgent",
+      inferenceCallSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(calls[0].options?.config?.callSite).toBe("mainAgent");
+    expect(prepared?.callSite).toBe("mainAgent");
+    expect(preModelCallSites).toEqual(["callAgent"]);
+    expect(postModelCallSites).toEqual(["callAgent"]);
+    expect(events).toContainEqual({
+      type: "llm_call_started",
+      callSite: "callAgent",
+    });
+  });
+
   test("pre-model-call seeds modelProfile from the resolved override and clearing it drops the override", async () => {
     // GIVEN a hook that observes the seeded override and then clears it
     let seeded: string | null | undefined;

package/src/__tests__/agent-loop-provider-error-recording.test.ts

@@ -3,17 +3,19 @@
  *
  * When the provider call throws (provider rejected the request before
  * returning a usable response), the loop must emit a `provider_error` event
- * carrying the loop-level raw request and the thrown error so downstream
- * consumers can persist an `llm_request_logs` row. Without this, rejected
- * calls leave nothing in the LLM inspector — only a pino log line.
+ * carrying the inspectable wire request (when the throw attached one) and
+ * the thrown error so downstream consumers can persist an `llm_request_logs`
+ * row. Without this, rejected calls leave nothing in the LLM inspector —
+ * only a pino log line.
  *
  * Coverage:
- *  - Emits `provider_error` with `rawRequest`, `error`, and `actualProvider`
- *    when the provider throws a `ProviderError`.
- *  - `rawRequest` carries the message history, tools, and system prompt the
- *    loop attempted to send — so the row replays/debugs cleanly.
- *  - `actualProvider` echoes `ProviderError.provider` when available, falling
- *    back to `provider.name` for non-ProviderError throws.
+ *  - Emits `provider_error` with `error` and `actualProvider` when the
+ *    provider throws a `ProviderError`.
+ *  - `rawRequest` is `ProviderError.rawRequest` when present, and stays
+ *    unset when the throw did not attach a wire payload. The loop does
+ *    not invent a messages/tools/systemPrompt snapshot.
+ *  - `actualProvider` echoes `ProviderError.provider` when available, even
+ *    if the wrapping `provider.name` is a different default transport.
  *  - The error is still re-thrown internally (the existing `error` event
  *    still fires after the new `provider_error` event), preserving the
  *    outer-catch behavior (abort/Sentry/break).
@@ -73,7 +75,7 @@ function makeThrowingProvider(
 }
 
 describe("AgentLoop provider_error event emission", () => {
-  test("emits provider_error with loop-level rawRequest when provider throws ProviderError", async () => {
+  test("emits provider_error without inventing a rawRequest snapshot", async () => {
     const thrown = new ProviderError(
       "Anthropic API error (429): rate limited",
       "anthropic",
@@ -107,16 +109,81 @@ describe("AgentLoop provider_error event emission", () => {
     }
     expect(providerErrorEvent.error).toBe(thrown);
     expect(providerErrorEvent.actualProvider).toBe("anthropic");
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
+  });
+
+  test("forwards ProviderError.rawRequest on the provider_error event", async () => {
+    const wirePayload = {
+      model: "qwen/qwen3-8b",
+      directions: { serious: 0.8 },
+    };
+    const thrown = new ProviderError(
+      "Vellum API error (400): directions are not loaded",
+      "vellum",
+      400,
+      {
+        rawRequest: wirePayload,
+        rawBody: '{"detail":"directions are not loaded"}',
+      },
+    );
+    const { provider } = makeThrowingProvider("fireworks", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    expect(providerErrorEvent.actualProvider).toBe("vellum");
+    expect(providerErrorEvent.rawRequest).toEqual(wirePayload);
+  });
+
+  test("actualProvider uses ProviderError.provider, not the wrapper name", async () => {
+    const thrown = new ProviderError(
+      "Vellum API error (400): directions are not loaded",
+      "vellum",
+      400,
+    );
+    const { provider } = makeThrowingProvider("fireworks", () => thrown);
+
+    const events: AgentEvent[] = [];
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
 
-    // rawRequest should carry the loop-level abstract shape: messages,
-    // tools, systemPrompt, and the provider name we tried to dispatch
-    // through. The provider-specific shape (e.g. Gemini's `contents`) is
-    // never built because the provider threw before returning it.
-    const raw = providerErrorEvent.rawRequest as Record<string, unknown>;
-    expect(raw.provider).toBe("anthropic");
-    expect(raw.systemPrompt).toBe("you are a helpful assistant");
-    expect(Array.isArray(raw.messages)).toBe(true);
-    expect((raw.messages as Message[])[0].role).toBe("user");
+    const providerErrorEvent = events.find((e) => e.type === "provider_error");
+    expect(providerErrorEvent).toBeDefined();
+    if (providerErrorEvent?.type !== "provider_error") {
+      throw new Error("type narrowing");
+    }
+    expect(providerErrorEvent.actualProvider).toBe("vellum");
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
   });
 
   test("error event still fires after provider_error (outer catch behavior unchanged)", async () => {
@@ -185,6 +252,7 @@ describe("AgentLoop provider_error event emission", () => {
     // `provider` column populated even for surprise errors.
     expect(providerErrorEvent.actualProvider).toBe("openai");
     expect(providerErrorEvent.error).toBe(thrown);
+    expect(providerErrorEvent.rawRequest).toBeUndefined();
   });
 
   test("does NOT emit provider_error on user-aborted runs", async () => {

package/src/__tests__/annotate-activity-metadata.test.ts

@@ -44,6 +44,7 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { ToolActivityMetadata } from "../api/events/tool-result.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -52,7 +53,7 @@ import {
   createEventHandlerState,
   handleToolResult,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -65,6 +66,7 @@ function makeDeps(): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: () => {},
     reqId: "test-req",

package/src/__tests__/annotate-risk-options.test.ts

@@ -47,6 +47,7 @@ import {
   createEventHandlerState,
   handleToolResult,
 } from "../daemon/conversation-agent-loop-handlers.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -59,6 +60,7 @@ function makeDeps(): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: () => {},
     reqId: "test-req",

package/src/__tests__/answered-question-persistence.test.ts

@@ -46,6 +46,7 @@ import {
   createEventHandlerState,
   handleToolResult,
 } from "../daemon/conversation-agent-loop-handlers.js";
+import { mockUnownedModeSessions } from "./helpers/mock-conversation.js";
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -60,6 +61,7 @@ function makeDeps(): EventHandlerDeps {
       emitActivityState: () => {},
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
+      modeSessions: mockUnownedModeSessions(),
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (event: unknown) => {
       emitted.push(event as Record<string, unknown>);

package/src/__tests__/anthropic-gateway-shared.test.ts

@@ -103,6 +103,26 @@ describe("retagDelegateError", () => {
     expect(err.apiErrorCode).toBe("restricted");
     expect(err.apiErrorParam).toBe("model");
     expect(err.rawBody).toBe('{"type":"error"}');
+    expect(err.rawRequest).toBeUndefined();
+  });
+
+  test("carries rawRequest across the re-tag", () => {
+    const rawRequest = { model: "anthropic/claude-opus-4.6", messages: [] };
+    const inner = new ProviderError("rate limited", "anthropic", 429, {
+      rawRequest,
+    });
+
+    let caught: unknown;
+    try {
+      retagDelegateError(inner, providerName);
+    } catch (error) {
+      caught = error;
+    }
+
+    expect(caught).toBeInstanceOf(ProviderError);
+    const err = caught as ProviderError;
+    expect(err.provider).toBe(providerName);
+    expect(err.rawRequest).toEqual(rawRequest);
   });
 
   test("re-tags a delegate ContextOverflowError, preserving token counts", () => {
@@ -110,6 +130,7 @@ describe("retagDelegateError", () => {
       actualTokens: 250_000,
       maxTokens: 200_000,
       statusCode: 400,
+      rawRequest: { model: "anthropic/claude-opus-4.6" },
     });
 
     let caught: unknown;
@@ -126,6 +147,7 @@ describe("retagDelegateError", () => {
     expect(err.maxTokens).toBe(200_000);
     expect(err.statusCode).toBe(400);
     expect(err.cause).toBe(inner);
+    expect(err.rawRequest).toEqual({ model: "anthropic/claude-opus-4.6" });
   });
 
   test("rethrows an already-tagged error unchanged", () => {

package/src/__tests__/approval-message-composer.test.ts

@@ -17,21 +17,10 @@ const ALL_SCENARIOS: ApprovalMessageScenario[] = [
   "standard_prompt",
   "guardian_prompt",
   "reminder_prompt",
-  "guardian_delivery_failed",
-  "guardian_request_forwarded",
-  "guardian_disambiguation",
   "guardian_identity_mismatch",
   "request_pending_guardian",
-  "guardian_decision_outcome",
-  "guardian_expired_requester",
-  "guardian_expired_guardian",
-  "guardian_verify_success",
   "guardian_verify_failed",
   "guardian_verify_challenge_setup",
-  "guardian_verify_status_bound",
-  "guardian_verify_status_unbound",
-  "guardian_deny_no_identity",
-  "guardian_deny_no_binding",
 ];
 
 describe("approval-message-composer", () => {
@@ -66,59 +55,6 @@ describe("approval-message-composer", () => {
       expect(msg).toContain("write_file");
     });
 
-    test("guardian_delivery_failed includes toolName when provided", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_delivery_failed",
-        toolName: "execute_shell",
-      });
-      expect(msg).toContain("execute_shell");
-    });
-
-    test("guardian_request_forwarded includes toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_request_forwarded",
-        toolName: "execute_shell",
-      });
-      expect(msg).toContain("execute_shell");
-    });
-
-    test("guardian_disambiguation includes pendingCount", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_disambiguation",
-        pendingCount: 3,
-      });
-      expect(msg).toContain("3");
-    });
-
-    test("guardian_decision_outcome includes decision and toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_decision_outcome",
-        decision: "approved",
-        toolName: "read_file",
-      });
-      expect(msg).toContain("approved");
-      expect(msg).toContain("read_file");
-    });
-
-    test("guardian_expired_requester includes toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_expired_requester",
-        toolName: "deploy",
-      });
-      expect(msg).toContain("deploy");
-      expect(msg).toContain("expired");
-    });
-
-    test("guardian_expired_guardian includes requester and toolName", () => {
-      const msg = getFallbackMessage({
-        scenario: "guardian_expired_guardian",
-        requesterIdentifier: "bob",
-        toolName: "delete_file",
-      });
-      expect(msg).toContain("bob");
-      expect(msg).toContain("delete_file");
-    });
-
     test("guardian_verify_failed includes failureReason", () => {
       const msg = getFallbackMessage({
         scenario: "guardian_verify_failed",
@@ -141,36 +77,7 @@ describe("approval-message-composer", () => {
   // -----------------------------------------------------------------------
 
   describe("composeApprovalMessage", () => {
-    test("returns assistantPreface when provided (primary source)", () => {
-      const preface = "The assistant already said something helpful.";
-      const msg = composeApprovalMessage({
-        scenario: "standard_prompt",
-        toolName: "execute_shell",
-        assistantPreface: preface,
-      });
-      expect(msg).toBe(preface);
-    });
-
-    test("ignores empty assistantPreface and falls back to template", () => {
-      const msg = composeApprovalMessage({
-        scenario: "standard_prompt",
-        toolName: "execute_shell",
-        assistantPreface: "",
-      });
-      expect(msg).toContain("execute_shell");
-      expect(msg).not.toBe("");
-    });
-
-    test("ignores whitespace-only assistantPreface", () => {
-      const msg = composeApprovalMessage({
-        scenario: "standard_prompt",
-        toolName: "execute_shell",
-        assistantPreface: "   ",
-      });
-      expect(msg).toContain("execute_shell");
-    });
-
-    test("falls back to deterministic template when no assistantPreface", () => {
+    test("returns the deterministic template", () => {
       const msg = composeApprovalMessage({
         scenario: "guardian_prompt",
         toolName: "write_file",
@@ -222,29 +129,5 @@ describe("approval-message-composer", () => {
       expect(msg.length).toBeGreaterThan(0);
       expect(msg).toContain("invalid or has expired");
     });
-
-    test("guardian_verify_success produces a non-empty success message", () => {
-      const msg = composeApprovalMessage({
-        scenario: "guardian_verify_success",
-      });
-      expect(typeof msg).toBe("string");
-      expect(msg.length).toBeGreaterThan(0);
-    });
-
-    test("guardian_verify_status_bound produces a non-empty message", () => {
-      const msg = composeApprovalMessage({
-        scenario: "guardian_verify_status_bound",
-      });
-      expect(typeof msg).toBe("string");
-      expect(msg.length).toBeGreaterThan(0);
-    });
-
-    test("guardian_verify_status_unbound produces a non-empty message", () => {
-      const msg = composeApprovalMessage({
-        scenario: "guardian_verify_status_unbound",
-      });
-      expect(typeof msg).toBe("string");
-      expect(msg.length).toBeGreaterThan(0);
-    });
   });
 });