mobile-debug-mcp 0.22.0 → 0.24.0

package/src/types.ts

@@ -132,14 +132,67 @@ export interface TapResponse {
   error?: string;
 }
 
-export interface TapElementResponse {
+export type ActionFailureCode =
+  | 'ELEMENT_NOT_FOUND'
+  | 'ELEMENT_NOT_INTERACTABLE'
+  | 'TIMEOUT'
+  | 'NAVIGATION_NO_CHANGE'
+  | 'AMBIGUOUS_TARGET'
+  | 'STALE_REFERENCE'
+  | 'UNKNOWN'
+
+export interface ActionTargetResolved {
+  elementId: string | null;
+  text: string | null;
+  resource_id: string | null;
+  accessibility_id: string | null;
+  class: string | null;
+  bounds: [number, number, number, number] | null;
+  index: number | null;
+}
+
+export interface ActionExecutionResult {
+  action_id: string;
+  timestamp: number;
+  action_type: string;
+  target: {
+    selector: Record<string, unknown> | null;
+    resolved: ActionTargetResolved | null;
+  };
+  success: boolean;
+  failure_code?: ActionFailureCode;
+  retryable?: boolean;
+  ui_fingerprint_before?: string | null;
+  ui_fingerprint_after?: string | null;
+}
+
+export interface TapElementResponse extends ActionExecutionResult {}
+
+export interface ExpectScreenResponse {
+  success: boolean;
+  observed_screen: {
+    fingerprint: string | null;
+    screen: string | null;
+  };
+  expected_screen: {
+    fingerprint: string | null;
+    screen: string | null;
+  };
+  confidence: number;
+}
+
+export interface ExpectElementVisibleResponse {
   success: boolean;
-  elementId: string;
-  action: 'tap';
-  error?: {
-    code: 'element_not_found' | 'element_not_visible' | 'element_not_enabled' | 'tap_failed';
-    message: string;
+  selector: {
+    text?: string;
+    resource_id?: string;
+    accessibility_id?: string;
+    contains?: boolean;
   };
+  element_id: string | null;
+  element?: ActionTargetResolved | null;
+  failure_code?: 'TIMEOUT' | 'ELEMENT_NOT_FOUND' | 'UNKNOWN';
+  retryable?: boolean;
 }
 
 export interface SwipeResponse {

package/test/unit/interact/classify_action_outcome.test.ts

@@ -0,0 +1,110 @@
+import assert from 'assert'
+import { classifyActionOutcome } from '../../../src/interact/classify.js'
+
+function run() {
+  // Step 1 — uiChanged → success
+  {
+    const result = classifyActionOutcome({ uiChanged: true })
+    assert.strictEqual(result.outcome, 'success')
+    assert.ok(result.reasoning.length > 0)
+    assert.strictEqual(result.nextAction, undefined)
+  }
+
+  // Step 1 — expectedElementVisible → success
+  {
+    const result = classifyActionOutcome({ uiChanged: false, expectedElementVisible: true })
+    assert.strictEqual(result.outcome, 'success')
+    assert.strictEqual(result.reasoning, 'expected element is visible')
+    assert.strictEqual(result.nextAction, undefined)
+  }
+
+  // Step 1 — both uiChanged and expectedElementVisible → success
+  {
+    const result = classifyActionOutcome({ uiChanged: true, expectedElementVisible: true })
+    assert.strictEqual(result.outcome, 'success')
+  }
+
+  // Step 2 — UI did not change, networkRequests not yet provided → nextAction required
+  {
+    const result = classifyActionOutcome({ uiChanged: false })
+    assert.strictEqual(result.outcome, 'unknown')
+    assert.strictEqual(result.nextAction, 'call_get_network_activity')
+  }
+
+  // Step 2 — explicit null networkRequests → nextAction required
+  {
+    const result = classifyActionOutcome({ uiChanged: false, expectedElementVisible: null, networkRequests: null })
+    assert.strictEqual(result.outcome, 'unknown')
+    assert.strictEqual(result.nextAction, 'call_get_network_activity')
+  }
+
+  // Step 3 — failure status → backend_failure
+  {
+    const result = classifyActionOutcome({
+      uiChanged: false,
+      networkRequests: [{ endpoint: '/login', status: 'failure' }]
+    })
+    assert.strictEqual(result.outcome, 'backend_failure')
+    assert.ok(result.reasoning.includes('/login'))
+    assert.ok(result.reasoning.includes('failure'))
+  }
+
+  // Step 3 — retryable status → backend_failure
+  {
+    const result = classifyActionOutcome({
+      uiChanged: false,
+      networkRequests: [
+        { endpoint: '/api/submit', status: 'retryable' },
+        { endpoint: '/api/other', status: 'success' }
+      ]
+    })
+    assert.strictEqual(result.outcome, 'backend_failure')
+    assert.ok(result.reasoning.includes('/api/submit'))
+  }
+
+  // Step 4 — empty network requests → no_op
+  {
+    const result = classifyActionOutcome({ uiChanged: false, networkRequests: [] })
+    assert.strictEqual(result.outcome, 'no_op')
+    assert.ok(result.reasoning.includes('no UI change'))
+    assert.ok(result.reasoning.includes('no network activity'))
+  }
+
+  // Step 4 — empty network requests with log errors → no_op with note
+  {
+    const result = classifyActionOutcome({ uiChanged: false, networkRequests: [], hasLogErrors: true })
+    assert.strictEqual(result.outcome, 'no_op')
+    assert.ok(result.reasoning.includes('log errors'))
+  }
+
+  // Step 5 — all requests succeeded but UI unchanged → ui_failure
+  {
+    const result = classifyActionOutcome({
+      uiChanged: false,
+      networkRequests: [
+        { endpoint: '/api/save', status: 'success' },
+        { endpoint: '/api/refresh', status: 'success' }
+      ]
+    })
+    assert.strictEqual(result.outcome, 'ui_failure')
+    assert.ok(result.reasoning.includes('network requests succeeded'))
+  }
+
+  // Step 1 takes priority over network signals — success even when failures present
+  {
+    const result = classifyActionOutcome({
+      uiChanged: true,
+      networkRequests: [{ endpoint: '/api/log', status: 'failure' }]
+    })
+    assert.strictEqual(result.outcome, 'success')
+  }
+
+  console.log('classify_action_outcome tests passed')
+}
+
+try {
+  run()
+} catch (error) {
+  console.error(error)
+  process.exit(1)
+}

package/test/unit/interact/expect_tools.test.ts

@@ -0,0 +1,77 @@
+import assert from 'assert'
+import { ToolsInteract } from '../../../src/interact/index.js'
+import * as Observe from '../../../src/observe/index.js'
+
+async function run() {
+  console.log('Starting expect_* unit tests...')
+  const originalGetScreenFingerprintHandler = (Observe as any).ToolsObserve.getScreenFingerprintHandler
+  const originalGetCurrentScreenHandler = (Observe as any).ToolsObserve.getCurrentScreenHandler
+  const originalWaitForUIHandler = (ToolsInteract as any).waitForUIHandler
+
+  try {
+    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => ({ fingerprint: 'fp_home', activity: 'com.example.HomeActivity' })
+    let expectScreen = await ToolsInteract.expectScreenHandler({ platform: 'android', fingerprint: 'fp_home' })
+    assert.deepStrictEqual(expectScreen, {
+      success: true,
+      observed_screen: { fingerprint: 'fp_home', screen: 'com.example.HomeActivity' },
+      expected_screen: { fingerprint: 'fp_home', screen: null },
+      confidence: 1
+    })
+
+    ;(Observe as any).ToolsObserve.getCurrentScreenHandler = async () => ({
+      activity: 'com.example.HomeActivity',
+      shortActivity: 'HomeActivity'
+    })
+    expectScreen = await ToolsInteract.expectScreenHandler({ platform: 'android', screen: 'HomeActivity' })
+    assert.strictEqual(expectScreen.success, true)
+    assert.strictEqual(expectScreen.observed_screen.screen, 'HomeActivity')
+    assert.strictEqual(expectScreen.confidence, 1)
+
+    ;(ToolsInteract as any).waitForUIHandler = async () => ({
+      status: 'success',
+      element: {
+        text: 'Ready',
+        resource_id: 'rid_ready',
+        accessibility_id: null,
+        class: 'TextView',
+        bounds: [0, 0, 10, 10],
+        index: 0,
+        elementId: 'el_ready'
+      }
+    })
+    const expectElementVisible = await ToolsInteract.expectElementVisibleHandler({
+      selector: { text: 'Ready' },
+      platform: 'android'
+    })
+    assert.strictEqual(expectElementVisible.success, true)
+    assert.strictEqual(expectElementVisible.element_id, 'el_ready')
+    assert.strictEqual(expectElementVisible.element?.resource_id, 'rid_ready')
+
+    ;(ToolsInteract as any).waitForUIHandler = async () => ({
+      status: 'timeout',
+      error: { code: 'ELEMENT_NOT_FOUND', message: 'Condition visible not satisfied within timeout' }
+    })
+    const timeoutResult = await ToolsInteract.expectElementVisibleHandler({
+      selector: { text: 'Missing' },
+      platform: 'android'
+    })
+    assert.deepStrictEqual(timeoutResult, {
+      success: false,
+      selector: { text: 'Missing' },
+      element_id: null,
+      failure_code: 'TIMEOUT',
+      retryable: true
+    })
+
+    console.log('expect_* unit tests passed')
+  } finally {
+    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = originalGetScreenFingerprintHandler
+    ;(Observe as any).ToolsObserve.getCurrentScreenHandler = originalGetCurrentScreenHandler
+    ;(ToolsInteract as any).waitForUIHandler = originalWaitForUIHandler
+  }
+}
+
+run().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/test/unit/interact/tap_element.test.ts

@@ -5,11 +5,18 @@ import * as Observe from '../../../src/observe/index.js'
 async function run() {
   console.log('Starting tap_element unit tests...')
   const originalGetUITreeHandler = (Observe as any).ToolsObserve.getUITreeHandler
+  const originalGetScreenFingerprintHandler = (Observe as any).ToolsObserve.getScreenFingerprintHandler
   const originalTapHandler = (ToolsInteract as any).tapHandler
   const originalComputeElementId = (ToolsInteract as any)._computeElementId
   ;(ToolsInteract as any)._resetResolvedUiElementsForTests()
 
   try {
+    let fingerprintCalls = 0
+    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = async () => {
+      fingerprintCalls++
+      return { fingerprint: 'fp_mock' }
+    }
+
     ;(Observe as any).ToolsObserve.getUITreeHandler = async () => ({
       device: { platform: 'android', id: 'mock-device' },
       elements: [
@@ -34,7 +41,12 @@ async function run() {
     }
 
     const tapSuccess = await ToolsInteract.tapElementHandler({ elementId: successElementId })
-    assert.deepStrictEqual(tapSuccess, { success: true, elementId: successElementId, action: 'tap' })
+    assert.strictEqual(tapSuccess.success, true)
+    assert.strictEqual(tapSuccess.action_type, 'tap_element')
+    assert.strictEqual(tapSuccess.target.selector?.elementId, successElementId)
+    assert.strictEqual(tapSuccess.target.resolved?.elementId, successElementId)
+    assert.strictEqual(tapSuccess.ui_fingerprint_before, 'fp_mock')
+    assert.strictEqual(tapSuccess.ui_fingerprint_after, 'fp_mock')
     assert.deepStrictEqual(tapped, { platform: 'android', x: 10, y: 10, deviceId: 'mock-device' })
 
     ;(Observe as any).ToolsObserve.getUITreeHandler = async () => ({
@@ -52,7 +64,8 @@ async function run() {
     })
     const hiddenResult = await ToolsInteract.tapElementHandler({ elementId: waitHidden.element.elementId })
     assert.strictEqual(hiddenResult.success, false)
-    assert.strictEqual(hiddenResult.error?.code, 'element_not_visible')
+    assert.strictEqual(hiddenResult.failure_code, 'ELEMENT_NOT_INTERACTABLE')
+    assert.strictEqual(hiddenResult.retryable, true)
 
     ;(Observe as any).ToolsObserve.getUITreeHandler = async () => ({
       device: { platform: 'android', id: 'mock-device' },
@@ -69,7 +82,7 @@ async function run() {
     })
     const disabledResult = await ToolsInteract.tapElementHandler({ elementId: waitDisabled.element.elementId })
     assert.strictEqual(disabledResult.success, false)
-    assert.strictEqual(disabledResult.error?.code, 'element_not_enabled')
+    assert.strictEqual(disabledResult.failure_code, 'ELEMENT_NOT_INTERACTABLE')
 
     ;(Observe as any).ToolsObserve.getUITreeHandler = async () => ({
       device: { platform: 'android', id: 'mock-device' },
@@ -77,7 +90,7 @@ async function run() {
     })
     const notFoundResult = await ToolsInteract.tapElementHandler({ elementId: successElementId })
     assert.strictEqual(notFoundResult.success, false)
-    assert.strictEqual(notFoundResult.error?.code, 'element_not_found')
+    assert.strictEqual(notFoundResult.failure_code, 'STALE_REFERENCE')
 
     ;(ToolsInteract as any)._resetResolvedUiElementsForTests()
     const targetIndex = 25
@@ -124,7 +137,7 @@ async function run() {
     })
     const shiftedIndexResult = await ToolsInteract.tapElementHandler({ elementId: indexedWait.element.elementId })
     assert.strictEqual(shiftedIndexResult.success, false)
-    assert.strictEqual(shiftedIndexResult.error?.code, 'element_not_found')
+    assert.strictEqual(shiftedIndexResult.failure_code, 'STALE_REFERENCE')
 
     ;(ToolsInteract as any)._resetResolvedUiElementsForTests()
     const cacheLimit = (ToolsInteract as any)._maxResolvedUiElements as number
@@ -151,15 +164,19 @@ async function run() {
     }
 
     assert.ok(oldestElementId, 'Oldest element ID should be captured')
+    const fingerprintCallsBeforeEvictedTap = fingerprintCalls
     const evictedResult = await ToolsInteract.tapElementHandler({ elementId: oldestElementId as string })
     assert.strictEqual(evictedResult.success, false)
-    assert.strictEqual(evictedResult.error?.code, 'element_not_found')
+    assert.strictEqual(evictedResult.failure_code, 'STALE_REFERENCE')
+    assert.strictEqual(evictedResult.ui_fingerprint_before, null)
+    assert.strictEqual(fingerprintCalls, fingerprintCallsBeforeEvictedTap)
 
     console.log('tap_element unit tests passed')
   } finally {
     ;(ToolsInteract as any)._resetResolvedUiElementsForTests()
     ;(ToolsInteract as any)._computeElementId = originalComputeElementId
     ;(Observe as any).ToolsObserve.getUITreeHandler = originalGetUITreeHandler
+    ;(Observe as any).ToolsObserve.getScreenFingerprintHandler = originalGetScreenFingerprintHandler
     ;(ToolsInteract as any).tapHandler = originalTapHandler
   }
 }

package/test/unit/network/get_network_activity.test.ts

@@ -0,0 +1,181 @@
+import assert from 'assert'
+import {
+  parseMessageToEvent,
+  normalizeEndpoint,
+  classifyStatus,
+  _setTimestampsForTests,
+  ToolsNetwork
+} from '../../../src/network/index.js'
+
+function run() {
+
+  // ─── normalizeEndpoint ──────────────────────────────────────────────────────
+
+  {
+    const r = normalizeEndpoint('https://api.example.com/v1/users?page=2')
+    assert.strictEqual(r, '/v1/users', `normalizeEndpoint full URL: expected /v1/users, got ${r}`)
+  }
+
+  {
+    const r = normalizeEndpoint('/api/login/')
+    assert.strictEqual(r, '/api/login', `normalizeEndpoint path trailing slash: expected /api/login, got ${r}`)
+  }
+
+  {
+    const r = normalizeEndpoint('/Api/Login')
+    assert.strictEqual(r, '/api/login', `normalizeEndpoint uppercase: expected /api/login, got ${r}`)
+  }
+
+  // ─── classifyStatus ─────────────────────────────────────────────────────────
+
+  {
+    const s = classifyStatus(200, null)
+    assert.strictEqual(s, 'success', `200 should be success`)
+  }
+
+  {
+    const s = classifyStatus(404, null)
+    assert.strictEqual(s, 'failure', `404 should be failure`)
+  }
+
+  {
+    const s = classifyStatus(500, null)
+    assert.strictEqual(s, 'retryable', `500 should be retryable`)
+  }
+
+  {
+    const s = classifyStatus(null, 'timeout')
+    assert.strictEqual(s, 'retryable', `networkError should override to retryable`)
+  }
+
+  {
+    const s = classifyStatus(200, 'connection_reset')
+    assert.strictEqual(s, 'retryable', `networkError beats statusCode`)
+  }
+
+  {
+    const s = classifyStatus(null, null)
+    assert.strictEqual(s, 'success', `null/null (request detected, no error) = success`)
+  }
+
+  // ─── parseMessageToEvent — emission criteria ─────────────────────────────────
+
+  // Condition 1: full URL
+  {
+    const e = parseMessageToEvent('OkHttp: GET https://api.example.com/v1/login 200')
+    assert.ok(e !== null, 'full URL line should emit')
+    assert.strictEqual(e!.endpoint, '/v1/login')
+    assert.strictEqual(e!.method, 'GET')
+    assert.strictEqual(e!.statusCode, 200)
+    assert.strictEqual(e!.status, 'success')
+  }
+
+  // Condition 2: explicit HTTP status line
+  {
+    const e = parseMessageToEvent('HTTP/1.1 404 Not Found')
+    assert.ok(e !== null, 'HTTP status line should emit')
+    assert.strictEqual(e!.statusCode, 404)
+    assert.strictEqual(e!.status, 'failure')
+  }
+
+  // Condition 3: method + path
+  {
+    const e = parseMessageToEvent('Sending POST /api/register HTTP/1.1')
+    assert.ok(e !== null, 'method+path line should emit')
+    assert.strictEqual(e!.method, 'POST')
+    assert.strictEqual(e!.endpoint, '/api/register')
+    assert.strictEqual(e!.statusCode, null)
+    assert.strictEqual(e!.status, 'success') // no error signal
+  }
+
+  // No criteria met — keyword-only noise
+  {
+    const e = parseMessageToEvent('HTTP connection pool initialised')
+    assert.strictEqual(e, null, 'keyword-only line should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('Request interceptor registered')
+    assert.strictEqual(e, null, 'generic Request line should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('Task 200 completed')
+    assert.strictEqual(e, null, 'bare status-like numbers should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('Response code: 404')
+    assert.strictEqual(e, null, 'labeled status without endpoint or HTTP context should not emit')
+  }
+
+  {
+    const e = parseMessageToEvent('GetBestInfo: /data/app/~~pkg/base.apk status=447')
+    assert.strictEqual(e, null, 'filesystem paths should not emit as network endpoints')
+  }
+
+  {
+    const e = parseMessageToEvent('system/gd/hci/le_address_manager.cc:576 GetNextPrivateAddressIntervalRange')
+    assert.strictEqual(e, null, 'source file paths should not emit as network endpoints')
+  }
+
+  {
+    const e = parseMessageToEvent('status=503 for /api/session/generate')
+    assert.ok(e !== null, 'status with plausible endpoint should emit')
+    assert.strictEqual(e!.endpoint, '/api/session/generate')
+    assert.strictEqual(e!.statusCode, 503)
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  // Network error detection
+  {
+    const e = parseMessageToEvent('java.net.SocketTimeoutException: POST /api/data timed out after 30s')
+    assert.ok(e !== null, 'timeout error should emit')
+    assert.strictEqual(e!.networkError, 'timeout')
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  {
+    const e = parseMessageToEvent('SSL handshake failed for https://api.example.com/v1/auth')
+    assert.ok(e !== null, 'TLS error should emit')
+    assert.strictEqual(e!.networkError, 'tls_error')
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  {
+    const e = parseMessageToEvent('DNS resolution failed: GET /api/users')
+    assert.ok(e !== null, 'DNS error should emit')
+    assert.strictEqual(e!.networkError, 'dns_error')
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  // 5xx → retryable even without networkError
+  {
+    const e = parseMessageToEvent('Response 503 for https://api.example.com/v1/data')
+    assert.ok(e !== null, '5xx should emit')
+    assert.strictEqual(e!.statusCode, 503)
+    assert.strictEqual(e!.status, 'retryable')
+  }
+
+  // ─── lastConsumedTimestamp dedupe ────────────────────────────────────────────
+
+  {
+    // Simulate: action happened 1000ms ago, last consumed 500ms ago → use consumed
+    _setTimestampsForTests(Date.now() - 1000, Date.now() - 500)
+    // We can't easily verify the sinceMs value from outside without deep mocking,
+    // but we can confirm getNetworkActivity resolves without throwing.
+    const promise = ToolsNetwork.getNetworkActivity({ platform: 'android' })
+    assert.ok(promise instanceof Promise, 'getNetworkActivity should return a Promise')
+    // Allow the promise to settle (logcat may fail in test env — that's fine)
+    promise.catch(() => {})
+  }
+
+  console.log('get_network_activity tests passed')
+}
+
+try {
+  run()
+} catch (err) {
+  console.error(err)
+  process.exit(1)
+}

package/test/unit/server/contract.test.ts

@@ -8,6 +8,8 @@ async function run() {
   assert.strictEqual(serverInfo.name, 'mobile-debug-mcp')
   assert.strictEqual(names.length, uniqueNames.size, 'tool names should be unique')
   assert(names.includes('wait_for_ui'))
+  assert(names.includes('expect_screen'))
+  assert(names.includes('expect_element_visible'))
   assert(names.includes('capture_screenshot'))
   assert(names.includes('get_ui_tree'))
   assert(names.includes('tap_element'))
@@ -16,6 +18,14 @@ async function run() {
   assert(waitForUI, 'wait_for_ui should be registered')
   assert.strictEqual((waitForUI as any).inputSchema.properties.timeout_ms.default, 60000)
   assert.strictEqual((waitForUI as any).inputSchema.properties.condition.default, 'exists')
+  assert.match((waitForUI as any).description, /resolve elements/i)
+  assert.match((waitForUI as any).description, /must not be used alone to confirm action success/i)
+  assert.match((waitForUI as any).description, /follow with expect_\*/i)
+
+  const waitForScreenChange = toolDefinitions.find((tool) => tool.name === 'wait_for_screen_change')
+  assert(waitForScreenChange, 'wait_for_screen_change should be registered')
+  assert.match((waitForScreenChange as any).description, /does not verify correctness of the resulting state/i)
+  assert.match((waitForScreenChange as any).description, /follow with expect_screen/i)
 
   const captureDebugSnapshot = toolDefinitions.find((tool) => tool.name === 'capture_debug_snapshot')
   assert(captureDebugSnapshot, 'capture_debug_snapshot should be registered')
@@ -33,6 +43,22 @@ async function run() {
   const tapElement = toolDefinitions.find((tool) => tool.name === 'tap_element')
   assert(tapElement, 'tap_element should be registered')
   assert.deepStrictEqual((tapElement as any).inputSchema.required, ['elementId'])
+  assert.match((tapElement as any).description, /RESOLVE → ACT → WAIT \(if needed\) → EXPECT/)
+  assert.match((tapElement as any).description, /If needed, wait for transition using wait_for_\*/)
+  assert.match((tapElement as any).description, /Verify outcome using expect_\*/)
+
+  const expectScreen = toolDefinitions.find((tool) => tool.name === 'expect_screen')
+  assert(expectScreen, 'expect_screen should be registered')
+  assert.match((expectScreen as any).description, /Primary and authoritative verification tool/i)
+  assert.match((expectScreen as any).description, /final verification step/i)
+  assert.match((expectScreen as any).description, /Returns structured binary success\/failure only/i)
+
+  const expectElementVisible = toolDefinitions.find((tool) => tool.name === 'expect_element_visible')
+  assert(expectElementVisible, 'expect_element_visible should be registered')
+  assert.deepStrictEqual((expectElementVisible as any).inputSchema.required, ['selector'])
+  assert.match((expectElementVisible as any).description, /Primary and authoritative verification tool/i)
+  assert.match((expectElementVisible as any).description, /selector is the primary input/i)
+  assert.match((expectElementVisible as any).description, /Returns structured binary success\/failure only/i)
 
   await assert.rejects(() => handleToolCall('unknown_tool'), /Unknown tool: unknown_tool/)