@browserbridge/bbx 1.7.7 → 1.8.0

package/packages/agent-client/src/types.ts

@@ -4,10 +4,19 @@ import type {
   BridgeMethod,
   BridgeRequestSource,
   BridgeResponse,
+  ScreenshotResult,
+  SetupStatus,
 } from '../../protocol/src/types.js';
 import type { restartBridgeDaemon } from '../../native-host/src/daemon-process.js';
 
-export type { BridgeMeta, BridgeMethod, BridgeRequestSource, BridgeResponse, BridgeTransport };
+export type {
+  BridgeMeta,
+  BridgeMethod,
+  BridgeRequestSource,
+  BridgeResponse,
+  BridgeTransport,
+  ScreenshotResult,
+};
 
 export type McpClientName =
   | 'codex'
@@ -43,6 +52,7 @@ export interface SetupStatusOptions {
 export interface ProtocolHealthResult {
   extensionConnected?: boolean;
   supported_versions?: string[];
+  extension_supported_versions?: string[];
   daemon_supported_versions?: string[];
   deprecated_since?: string;
   migration_hint?: string;
@@ -78,6 +88,7 @@ export interface BridgeClientOptions {
   clientId?: string;
   defaultTimeoutMs?: number;
   autoReconnect?: boolean;
+  checkProtocolOnConnect?: boolean;
   restartDaemonOnVersionMismatch?: boolean;
   restartDaemonFn?: typeof restartBridgeDaemon;
   authToken?: string | null;
@@ -110,6 +121,106 @@ export interface NativeHostManifestIssue {
   message: string;
 }
 
+export interface DoctorTransportDiagnostics {
+  kind: 'socket' | 'tcp' | 'unknown';
+  local: true;
+  status: 'reachable' | 'offline' | 'authentication_failed';
+  proxyConfigured: boolean;
+  proxyExposed: boolean | null;
+  credentials: 'not_required' | 'accepted' | 'rejected' | 'unknown';
+}
+
+export interface DoctorConnectionDiagnostics {
+  extensionCount: number;
+  profileCount: number;
+}
+
+export interface DoctorProtocolDiagnostics {
+  clientVersion: string;
+  daemonVersion: string | null;
+  daemonSupportedVersions: string[];
+  extensionSupportedVersions: string[];
+  daemonCompatible: boolean | null;
+  extensionCompatible: boolean | null;
+  compatible: boolean | null;
+  migration: 'none' | 'update_client' | 'restart_daemon' | 'update_extension' | 'unknown';
+}
+
+export interface DoctorDebuggerDiagnostics {
+  state: 'idle' | 'active' | 'conflict' | 'detached' | 'unknown';
+  attachedTabCount: number | null;
+  heldTabCount: number | null;
+  pendingTabCount: number | null;
+  recentReason:
+    | 'debugger_conflict'
+    | 'debugger_detached'
+    | 'debugger_replaced'
+    | 'debugger_canceled'
+    | 'target_closed'
+    | null;
+  captureState:
+    | 'idle'
+    | 'stopped'
+    | 'armed'
+    | 'active'
+    | 'capturing'
+    | 'stop_failed'
+    | 'unavailable'
+    | 'unknown';
+  captureActiveTabCount: number | null;
+  captureOwnershipCount: number | null;
+  captureInflightCount: number | null;
+  interceptionActiveTabCount: number | null;
+  interceptionRuleCount: number | null;
+}
+
+export interface DoctorDaemonMetrics {
+  uptimeMs: number;
+  activeAgents: number;
+  activeExtensions: number;
+  pendingRequests: number;
+  requestsProcessed: number;
+  requestsFailed: number;
+  avgResponseTimeMs: number;
+}
+
+export interface DoctorRecentEvent {
+  at?: string;
+  method?: BridgeMethod;
+  ok?: boolean;
+  source?: BridgeRequestSource;
+  cause?:
+    | 'debugger_conflict'
+    | 'debugger_detached'
+    | 'debugger_replaced'
+    | 'debugger_canceled'
+    | 'target_closed'
+    | 'dialog_conflict'
+    | 'extension_disconnected'
+    | 'wrong_window';
+}
+
+export interface DoctorSetupSummary {
+  source: 'daemon' | 'direct';
+  scope: 'global' | 'local';
+  mcp: {
+    detected: number;
+    configured: number;
+  };
+  skills: {
+    detected: number;
+    installed: number;
+    managed: number;
+    updatesAvailable: number;
+  };
+}
+
+export interface DoctorRemoteDiagnostics {
+  configuredCount: number;
+  status: 'not_configured' | 'not_probed_local_only' | 'config_unavailable';
+  credentials: 'not_configured' | 'unverified';
+}
+
 export interface DoctorReport {
   manifestInstalled: boolean;
   manifestPath: string;
@@ -117,6 +228,7 @@ export interface DoctorReport {
   defaultExtensionId: string | null;
   defaultExtensionIdSource: string;
   daemonReachable: boolean;
+  healthAvailable: boolean;
   extensionConnected: boolean;
   accessEnabled: boolean;
   enabledWindowId: number | null;
@@ -130,6 +242,16 @@ export interface DoctorReport {
   issues: string[];
   nextSteps: string[];
   browserManifests: BrowserManifestStatus[];
+  transport: DoctorTransportDiagnostics;
+  connections: DoctorConnectionDiagnostics;
+  protocol: DoctorProtocolDiagnostics;
+  debugger: DoctorDebuggerDiagnostics;
+  metrics: DoctorDaemonMetrics | null;
+  recentEvents: DoctorRecentEvent[];
+  recentCauses: DoctorRecentEvent['cause'][];
+  setup: DoctorSetupSummary | null;
+  remoteDestinations: DoctorRemoteDiagnostics;
+  diagnosticFailures: string[];
 }
 
 export interface DoctorReportOptions {
@@ -145,6 +267,14 @@ export interface DoctorReportOptions {
   checkNativeHostManifestHealth?: (
     browserManifests: BrowserManifestStatus[]
   ) => Promise<NativeHostManifestIssue[]>;
+  readInstalledExtensionIds?: (browserManifests: BrowserManifestStatus[]) => Promise<string[]>;
+  collectSetupStatus?: () => Promise<SetupStatus>;
+  readRemoteConfig?: () => Promise<{
+    remotes: Array<{ id: string; host: string; port: number; token: string }>;
+  }>;
+  getLocalTransport?: () => BridgeTransport;
+  readProxyConfig?: () => { enabled: boolean } | null;
+  includeSetupStatus?: boolean;
 }
 
 export type BridgeClientRequest = (options: {
@@ -154,8 +284,3 @@ export type BridgeClientRequest = (options: {
   meta?: BridgeMeta;
   timeoutMs?: number;
 }) => Promise<BridgeResponse>;
-
-export interface ScreenshotResult {
-  image: string;
-  rect: Record<string, unknown>;
-}

package/packages/mcp-server/src/guidance.js

@@ -5,7 +5,7 @@ export const MCP_SERVER_INSTRUCTIONS = [
   'In permission-ask hosts, use browser_call as the default Browser Bridge MCP tool so the user can approve one BBX tool instead of separate browser_status, browser_page, browser_dom, browser_input, and other tools.',
   'Prefer Browser Bridge MCP tools over shelling out to bbx. Use bbx only for explicit CLI setup, doctor, logs, or raw debugging requests.',
   'Start with browser_call method health.ping. If window access is disabled, call browser_call method access.request once, ask the user to click Enable in the Browser Bridge popup or side panel, then retry once.',
-  'Use structured reads first through browser_call: page.get_state, dom.query, page.get_text, styles.get_computed, or layout.get_box_model. Use browser_batch only for parallel reads; run mutations sequentially and keep limits tight before widening.',
+  'Use structured reads first through browser_call: page.get_state, dom.query, page.get_text, page.extract_content, styles.get_computed, or layout.get_box_model. Prefer semantic extraction for articles and documentation. Use browser_batch only for parallel reads; run mutations sequentially and keep limits tight before widening.',
   'Reuse elementRef values returned by DOM tools. Use attribute allowlists for focused DOM reads.',
   'Escalate to screenshot.capture_element, screenshot.capture_region, dom.get_accessibility_tree, page.evaluate, viewport.resize, or CDP only when structured reads cannot answer the question.',
   'Use patch.apply_styles or patch.apply_dom for temporary experiments, and rollback patches before finishing unless the user asks to keep them.',

package/packages/mcp-server/src/handlers-capture.js

@@ -22,17 +22,28 @@ export const CAPTURE_ACTIONS = {
   element: {
     ref: true,
     method: 'screenshot.capture_element',
-    params: (_, r) => ({ elementRef: r }),
+    params: (a, r) => ({
+      elementRef: r,
+      ...(a.format ? { format: a.format } : {}),
+      ...(typeof a.quality === 'number' ? { quality: a.quality } : {}),
+    }),
   },
   region: {
     ref: false,
     method: 'screenshot.capture_region',
-    params: (a) => /** @type {Record<string, unknown>} */ (a.rect || {}),
+    params: (a) => ({
+      .../** @type {Record<string, unknown>} */ (a.rect || {}),
+      ...(a.format ? { format: a.format } : {}),
+      ...(typeof a.quality === 'number' ? { quality: a.quality } : {}),
+    }),
   },
   full_page: {
     ref: false,
     method: 'screenshot.capture_full_page',
-    params: () => ({}),
+    params: (a) => ({
+      ...(a.format ? { format: a.format } : {}),
+      ...(typeof a.quality === 'number' ? { quality: a.quality } : {}),
+    }),
   },
   cdp_document: { ref: false, method: 'cdp.get_document', params: () => ({}) },
   cdp_dom_snapshot: {
@@ -82,7 +93,7 @@ function isValidCaptureRegion(rect) {
 }
 
 /**
- * @param {{ action: string, elementRef?: string, selector?: string, rect?: Record<string, unknown>, nodeId?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ action: string, elementRef?: string, selector?: string, rect?: Record<string, unknown>, format?: 'png' | 'jpeg' | 'webp', quality?: number, nodeId?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleCaptureTool(args) {
@@ -148,6 +159,9 @@ export function createScreenshotResult(response, method) {
       mimeType: image.mimeType,
       byteLength: image.byteLength,
       ...(rect ? { rect } : {}),
+      format: result.format ?? image.mimeType.replace('image/', ''),
+      complete: result.complete === true,
+      clipped: result.clipped === true,
     },
     false,
     [{ type: 'image', data: image.data, mimeType: image.mimeType }]
@@ -294,7 +308,20 @@ function createInputTarget(elementRef, selector) {
 }
 
 /**
- * @param {{ action: string, elementRef?: string, selector?: string, button?: string, clickCount?: number, text?: string, value?: string, mode?: 'auto' | 'setter' | 'keystrokes', clear?: boolean, submit?: boolean, key?: string, code?: string, modifiers?: string[], checked?: boolean, values?: string[], labels?: string[], indexes?: number[], duration?: number, sourceElementRef?: string, sourceSelector?: string, destinationElementRef?: string, destinationSelector?: string, offsetX?: number, offsetY?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * Avoid changing legacy handler payloads when new options are omitted.
+ *
+ * @param {{ executionMode?: 'dom' | 'cdp', recoverStale?: boolean }} args
+ * @returns {{ executionMode?: 'dom' | 'cdp', recoverStale?: boolean }}
+ */
+function createInputOptions(args) {
+  return {
+    ...(args.executionMode ? { executionMode: args.executionMode } : {}),
+    ...(typeof args.recoverStale === 'boolean' ? { recoverStale: args.recoverStale } : {}),
+  };
+}
+
+/**
+ * @param {{ action: string, elementRef?: string, selector?: string, button?: string, clickCount?: number, text?: string, value?: string, mode?: 'auto' | 'setter' | 'keystrokes', executionMode?: 'dom' | 'cdp', recoverStale?: boolean, clear?: boolean, submit?: boolean, key?: string, code?: string, modifiers?: string[], checked?: boolean, values?: string[], labels?: string[], indexes?: number[], duration?: number, sourceElementRef?: string, sourceSelector?: string, destinationElementRef?: string, destinationSelector?: string, offsetX?: number, offsetY?: number, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleInputTool(args) {
@@ -337,6 +364,7 @@ export async function handleInputTool(args) {
               button: args.button,
               clickCount: args.clickCount,
               modifiers: args.modifiers,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -352,6 +380,7 @@ export async function handleInputTool(args) {
             'input.focus',
             {
               target: elementTarget(),
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -371,6 +400,7 @@ export async function handleInputTool(args) {
               clear: args.clear,
               submit: args.submit,
               modifiers: args.modifiers,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -388,6 +418,7 @@ export async function handleInputTool(args) {
               target: elementTarget(),
               value: args.value,
               mode: args.mode,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -406,6 +437,7 @@ export async function handleInputTool(args) {
               target,
               key: args.key,
               modifiers: args.modifiers,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -439,6 +471,7 @@ export async function handleInputTool(args) {
             {
               target: elementTarget(),
               checked: args.checked,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -457,6 +490,7 @@ export async function handleInputTool(args) {
               values: args.values,
               labels: args.labels,
               indexes: args.indexes,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -474,6 +508,7 @@ export async function handleInputTool(args) {
               target: elementTarget(),
               duration: args.duration,
               modifiers: args.modifiers,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,
@@ -502,6 +537,7 @@ export async function handleInputTool(args) {
               destination,
               offsetX: args.offsetX,
               offsetY: args.offsetY,
+              ...createInputOptions(args),
             },
             {
               tabId: requestedTabId,

package/packages/mcp-server/src/handlers-dom.js

@@ -85,12 +85,18 @@ export const DOM_ACTIONS = {
   accessibility_tree: {
     ref: false,
     method: 'dom.get_accessibility_tree',
-    params: (a) => ({ maxNodes: a.maxNodes, maxDepth: a.maxDepth }),
+    params: (a) => ({
+      selector: a.selector,
+      maxNodes: a.maxNodes,
+      maxDepth: a.maxDepth,
+      compact: a.compact,
+      interactiveOnly: a.interactiveOnly,
+    }),
   },
 };
 
 /**
- * @param {{ action: string, selector?: string, elementRef?: string, withinRef?: string, maxNodes?: number, maxDepth?: number, textBudget?: number, includeBbox?: boolean, attributeAllowlist?: string[], attributes?: string[], text?: string, exact?: boolean, maxResults?: number, role?: string, name?: string, state?: string, timeoutMs?: number, outer?: boolean, maxLength?: number, tabId?: number, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ action: string, selector?: string, elementRef?: string, withinRef?: string, maxNodes?: number, maxDepth?: number, compact?: boolean, interactiveOnly?: boolean, textBudget?: number, includeBbox?: boolean, attributeAllowlist?: string[], attributes?: string[], text?: string, exact?: boolean, maxResults?: number, role?: string, name?: string, state?: string, timeoutMs?: number, outer?: boolean, maxLength?: number, tabId?: number, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handleDomTool(args) {

package/packages/mcp-server/src/handlers-navigation.js

@@ -32,7 +32,8 @@ export async function handleTabsTool(args) {
         let client = null;
         try {
           client = await createBridgeClientForDestination(
-            destination.local ? null : destination.id
+            destination.local ? null : destination.id,
+            { checkProtocolOnConnect: false }
           );
           await client.connect();
           const response = await requestBridgeWithRetry(

package/packages/mcp-server/src/handlers-page.js

@@ -49,6 +49,7 @@ const BATCH_SAFE_METHODS = new Set([
   'page.wait_for_load_state',
   'page.get_storage',
   'page.get_text',
+  'page.extract_content',
   'page.get_network',
   'dom.query',
   'dom.describe',
@@ -78,6 +79,14 @@ export function isBatchSafeBridgeCall(method, params) {
   if ((method === 'page.get_console' || method === 'page.get_network') && params.clear === true) {
     return false;
   }
+  if (
+    method === 'page.get_network' &&
+    params.source === 'cdp' &&
+    params.capture !== undefined &&
+    params.capture !== 'read'
+  ) {
+    return false;
+  }
   return true;
 }
 
@@ -97,9 +106,22 @@ export const PAGE_ACTIONS = {
     method: 'page.get_console',
     params: (a) => ({ level: a.level, clear: a.clear, limit: a.limit }),
   },
+  handle_dialog: {
+    method: 'page.handle_dialog',
+    params: (a) => ({
+      action: a.dialogAction,
+      promptText: a.promptText,
+      expectedDialogId: a.expectedDialogId,
+    }),
+  },
   wait_for_load: {
     method: 'page.wait_for_load_state',
-    params: (a) => ({ timeoutMs: a.timeoutMs }),
+    params: (a) => ({
+      timeoutMs: a.timeoutMs,
+      waitForLoad: a.waitForLoad,
+      url: a.url,
+      urlMatch: a.urlMatch,
+    }),
   },
   storage: {
     method: 'page.get_storage',
@@ -109,24 +131,37 @@ export const PAGE_ACTIONS = {
     method: 'page.get_text',
     params: (a) => ({ textBudget: a.textBudget }),
   },
+  extract_content: {
+    method: 'page.extract_content',
+    params: (a) => ({
+      format: a.format,
+      selector: a.selector,
+      includeMetadata: a.includeMetadata,
+      consistency: a.consistency,
+      textBudget: a.textBudget,
+      settleTimeoutMs: a.settleTimeoutMs,
+    }),
+  },
   network: {
     method: 'page.get_network',
     params: (a) => ({
       clear: a.clear,
       limit: a.limit,
       urlPattern: a.urlPattern,
+      source: a.source,
+      capture: a.capture,
     }),
   },
   performance: { method: 'performance.get_metrics', params: () => ({}) },
 };
 
 /**
- * @param {{ action: string, expression?: string, awaitPromise?: boolean, timeoutMs?: number, returnByValue?: boolean, level?: string, clear?: boolean, limit?: number, type?: string, keys?: string[], textBudget?: number, urlPattern?: string, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
+ * @param {{ action: string, expression?: string, awaitPromise?: boolean, timeoutMs?: number, returnByValue?: boolean, level?: string, clear?: boolean, limit?: number, type?: string, keys?: string[], textBudget?: number, format?: 'text' | 'markdown', selector?: string, includeMetadata?: boolean, consistency?: 'best_effort' | 'settled', settleTimeoutMs?: number, urlPattern?: string, source?: 'fetch-xhr' | 'cdp', capture?: 'read' | 'start' | 'clear' | 'stop', dialogAction?: string, promptText?: string, expectedDialogId?: string, waitForLoad?: boolean, url?: string, urlMatch?: string, tabId?: number, destinationId?: string, budgetPreset?: 'quick' | 'normal' | 'deep' }} args
  * @returns {Promise<ToolResult>}
  */
 export async function handlePageTool(args) {
   let normalizedArgs = args;
-  if (args.action === 'text') {
+  if (args.action === 'text' || args.action === 'extract_content') {
     normalizedArgs = applyPageTextBudgetPreset(args);
   } else if (args.action === 'console') {
     normalizedArgs = applyLimitBudgetPreset(args, {
@@ -201,7 +236,9 @@ export async function handleBatchTool(args) {
     /** @type {unknown} */
     let callError = null;
     try {
-      callClient = await createBridgeClientForDestination(destinationId);
+      callClient = await createBridgeClientForDestination(destinationId, {
+        checkProtocolOnConnect: false,
+      });
       await callClient.connect();
       const params = applyMethodBudgetPreset(method, call.params || {}, call.budgetPreset);
       response = await requestBridgeWithRetry(callClient, method, params, {

package/packages/mcp-server/src/handlers-utils.js

@@ -45,6 +45,7 @@ const RETRY_SAFE_METHODS = new Set([
   'page.get_state',
   'page.get_storage',
   'page.get_text',
+  'page.extract_content',
   'dom.query',
   'dom.describe',
   'dom.get_text',
@@ -75,7 +76,13 @@ const RETRY_SAFE_METHODS = new Set([
  */
 export function isRetrySafeBridgeMethod(method, params) {
   if (method === 'page.get_console' || method === 'page.get_network') {
-    return params.clear !== true;
+    return (
+      params.clear !== true &&
+      (method !== 'page.get_network' ||
+        params.source !== 'cdp' ||
+        params.capture === undefined ||
+        params.capture === 'read')
+    );
   }
   return RETRY_SAFE_METHODS.has(method);
 }
@@ -136,6 +143,7 @@ export function summarizeToolResponse(response, method, params = {}) {
   if (response.ok) {
     const evidence = getRequestAwareEvidence(response.result, method, params, summary.evidence);
     summary.evidence = evidence.value;
+    if (evidence.metadata) summaryRecord.evidenceMeta = evidence.metadata;
     if (evidence.truncated) {
       summaryRecord.outputTruncated = true;
       summaryRecord.outputLimit = evidence.limit;
@@ -190,9 +198,11 @@ export function summarizeToolError(error) {
 export async function withToolClient(callback, options = {}) {
   try {
     if (!options.destinationId) {
-      return await withBridgeClient(callback);
+      return await withBridgeClient(callback, { checkProtocolOnConnect: false });
     }
-    const client = await createBridgeClientForDestination(options.destinationId);
+    const client = await createBridgeClientForDestination(options.destinationId, {
+      checkProtocolOnConnect: false,
+    });
     await client.connect();
     try {
       return await callback(client);
@@ -364,7 +374,7 @@ export function applyMethodBudgetPreset(method, params, budgetPreset) {
     normalized = applyTextBudgetPreset(args);
   } else if (method === 'dom.get_html') {
     normalized = applyHtmlBudgetPreset(args);
-  } else if (method === 'page.get_text') {
+  } else if (method === 'page.get_text' || method === 'page.extract_content') {
     normalized = applyPageTextBudgetPreset(args);
   } else if (method === 'page.get_console') {
     normalized = applyLimitBudgetPreset(args, {
@@ -392,7 +402,7 @@ export function applyMethodBudgetPreset(method, params, budgetPreset) {
 /**
  * @param {unknown} input
  * @param {{ maxEntries?: number, maxCharacters?: number, maxStringLength?: number }} [options]
- * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number> }}
+ * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number>, metadata?: Record<string, unknown> }}
  */
 export function boundToolValue(input, options = {}) {
   const maxEntries = options.maxEntries ?? 500;
@@ -451,13 +461,27 @@ export function boundToolValue(input, options = {}) {
  * @param {string | undefined} method
  * @param {Record<string, unknown>} params
  * @param {unknown} fallback
- * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number> }}
+ * @returns {{ value: unknown, truncated: boolean, limit: Record<string, number>, metadata?: Record<string, unknown> }}
  */
 function getRequestAwareEvidence(rawResult, method, params, fallback) {
   const result =
     rawResult && typeof rawResult === 'object' && !Array.isArray(rawResult)
       ? /** @type {Record<string, unknown>} */ (rawResult)
       : {};
+  if (method === 'page.extract_content' && typeof result.content === 'string') {
+    const requested = positiveInteger(params.textBudget) ?? DEFAULT_PAGE_TEXT_BUDGET;
+    const maxCharacters = Math.min(requested, 16_000);
+    const content = result.content.slice(0, maxCharacters);
+    return {
+      value: {
+        ...result,
+        content,
+        returnedChars: content.length,
+      },
+      truncated: result.content.length > maxCharacters,
+      limit: { maxCharacters },
+    };
+  }
   if (method === 'page.get_text' || method === 'dom.get_text') {
     const text = typeof result.text === 'string' ? result.text : result.value;
     if (typeof text === 'string') {
@@ -506,14 +530,30 @@ function getRequestAwareEvidence(rawResult, method, params, fallback) {
       const node =
         value && typeof value === 'object' ? /** @type {Record<string, unknown>} */ (value) : {};
       return {
+        nodeId: node.nodeId,
         role: node.role,
         name: node.name,
         ...(node.interactive === true ? { interactive: true } : {}),
+        ...(node.semanticInteractive === true ? { semanticInteractive: true } : {}),
+        ...(node.focusableAndEnabled === true ? { focusableAndEnabled: true } : {}),
         ...(node.value !== undefined ? { value: node.value } : {}),
+        childIds: Array.isArray(node.childIds) ? node.childIds : [],
       };
     });
     return {
       value: nodes,
+      metadata: {
+        rootIds: Array.isArray(result.rootIds) ? result.rootIds : [],
+        count: result.count,
+        total: result.total,
+        rawTotal: result.rawTotal,
+        source: result.source,
+        compact: result.compact,
+        interactiveOnly: result.interactiveOnly,
+        truncated: result.truncated,
+        truncation: result.truncation,
+        continuationHint: result.continuationHint,
+      },
       truncated: result.truncated === true || result.nodes.length > maxEntries,
       limit: { maxEntries },
     };
@@ -535,7 +575,27 @@ function getRequestAwareEvidence(rawResult, method, params, fallback) {
         : result.entries.slice(0, maxEntries);
     const bounded = boundToolValue(selected, { maxEntries: 500, maxCharacters: 20_000 });
     return {
-      value: bounded.value,
+      value:
+        method === 'page.get_network'
+          ? {
+              entries: bounded.value,
+              count: result.count,
+              total: result.total,
+              filteredTotal: result.filteredTotal,
+              dropped: result.dropped,
+              abandoned: result.abandoned,
+              source: result.source,
+              capture: result.capture,
+              armed: result.armed,
+              armedDuringCapture: result.armedDuringCapture,
+              captureState: result.captureState,
+              startedAt: result.startedAt,
+              inflight: result.inflight,
+              ownershipHeld: result.ownershipHeld,
+              truncated: result.truncated,
+              truncation: result.truncation,
+            }
+          : bounded.value,
       truncated: result.entries.length > maxEntries || bounded.truncated,
       limit: { maxEntries, maxCharacters: 20_000 },
     };

package/packages/mcp-server/src/handlers.js

@@ -69,7 +69,7 @@ export {
 const HOME_DIR = os.homedir();
 
 /**
- * @param {{ destinationId?: string }} [args]
+ * @param {{ destinationId?: string, intent?: import('../../protocol/src/types.js').AccessIntent }} [args]
  * @returns {Promise<ToolResult>}
  */
 export async function handleStatusTool(args = {}) {
@@ -155,7 +155,7 @@ async function callRemoteHealth(destinationId) {
 }
 
 /**
- * @param {{ destinationId?: string }} [args]
+ * @param {{ destinationId?: string, intent?: import('../../protocol/src/types.js').AccessIntent }} [args]
  * @returns {Promise<ToolResult>}
  */
 export async function handleSkillTool(args = {}) {
@@ -231,13 +231,13 @@ export async function handleHealthTool(args = {}) {
 }
 
 /**
- * @param {{ destinationId?: string }} [args]
+ * @param {{ destinationId?: string, intent?: import('../../protocol/src/types.js').AccessIntent }} [args]
  * @returns {Promise<ToolResult>}
  */
 export async function handleAccessTool(args = {}) {
   return callBridgeTool(
     'access.request',
-    {},
+    { intent: args.intent },
     {
       destinationId: typeof args.destinationId === 'string' ? args.destinationId : null,
     }