Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
perf(webmcp): synchronize affected forms from the native index
ldm0ca436657cc28
diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative.rsindex 77e1d52f8..9a6292c02 100644--- a/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative.rs+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative.rs@@ -10,6 +10,7 @@ use crate::util::context_host_ptr_from_global_bridge;use moli_page_types::{RendererWebMcpEvent, RendererWebMcpToolId};use crate::dom::native::{DomHost, DomMutationEffects, Node};+use std::collections::{HashMap, HashSet};pub(super) mod invocation;mod schema;@@ -31,58 +32,53 @@ pub(crate) fn note_mutation(.iter().any(|root| dom.is_host_including_inclusive_ancestor(*root, handle))};- let targets = effects- .style()- .attribute_mutations()- .iter()- .filter(|attribute| {- attribute.namespace().is_none() && schema_attribute(attribute.local_name())- })- .map(|attribute| attribute.target())- .chain(- effects- .style()- .child_list_mutations()- .iter()- .flat_map(|mutation| {- mutation- .added_nodes()- .iter()- .chain(mutation.removed_nodes())- .copied()- }),- )- .chain(effects.style().character_data_mutations().iter().copied())- .map(|target| (target, true))- .chain(- effects- .style()- .child_list_mutations()+ for attribute in effects.style().attribute_mutations() {+ if attribute.namespace().is_some() || !schema_attribute(attribute.local_name()) {+ continue;+ }+ let target = attribute.target();+ let scope = if matches!(attribute.local_name(), "id" | "form" | "for") {+ FormMutationScope::Associations+ } else if dom.is_html_element_named(target, "fieldset") {+ FormMutationScope::Subtree+ } else {+ FormMutationScope::Target+ };+ mark_affected_forms(host, dom, target, scope);+ }+ for mutation in effects.style().child_list_mutations() {+ let scope = if dom.is_html_element_named(mutation.target(), "fieldset")+ && mutation+ .added_nodes().iter()- .map(|mutation| (mutation.target(), false)),- );- for (target, discover_descendants) in targets {- if let Some(document) = dom.owner_document_handle(target)- && (host- .native_bridge()- .web_mcp- .documents- .get(&document)- .is_some_and(|entry| {- entry- .tools- .values()- .any(|tool| matches!(tool.executor, ToolExecutor::Form { .. }))- })- || (dom.is_connected(target)- && ((discover_descendants && contains_tool_form(dom, target))- || affects_tool_form(dom, target))))+ .chain(mutation.removed_nodes())+ .any(|node| dom.is_html_element_named(*node, "legend")){- host.native_bridge_mut()- .web_mcp- .dirty_form_documents- .insert(document);+ FormMutationScope::Subtree+ } else {+ FormMutationScope::Target+ };+ mark_affected_forms(host, dom, mutation.target(), scope);+ for node in mutation.added_nodes() {+ mark_affected_forms(host, dom, *node, FormMutationScope::Subtree);}+ for node in mutation.removed_nodes() {+ // Adoption has already changed the removed subtree's owner. Its+ // former container still identifies the document whose external+ // control associations must be refreshed.+ if dom.owner_document_handle(*node) != dom.owner_document_handle(mutation.target()) {+ mark_affected_forms(+ host,+ dom,+ mutation.target(),+ FormMutationScope::Associations,+ );+ }+ mark_affected_forms(host, dom, *node, FormMutationScope::RemovedSubtree);+ }+ }+ for target in effects.style().character_data_mutations() {+ mark_affected_forms(host, dom, *target, FormMutationScope::Target);}let invalid = host.native_bridge()@@ -105,10 +101,14 @@ pub(crate) fn note_mutation(.iter().map(|(_, _, handle)| *handle).collect::<std::collections::HashSet<_>>();- for (document, name, _) in invalid {+ for (document, name, handle) in invalid {let (frame_id, tree, origin) = {let store = &mut host.native_bridge_mut().web_mcp;- store.dirty_form_documents.insert(document);+ store+ .dirty_forms+ .entry(document)+ .or_default()+ .insert(handle);let entry = store.documents.get_mut(&document).expect("form document");entry.tools.remove(&name);(@@ -144,25 +144,13 @@ pub(crate) fn note_mutation(}}-// Native forms in connected shadow trees participate in the same registry.-// Use this traversal for initial discovery and every mutation synchronization.+// The native index includes closed shadow trees. Keep the existing traversal+// order for duplicate names without visiting every unrelated DOM node.fn form_handles(dom: &DomHost, root: DomHandle) -> Vec<DomHandle> {- let mut forms = Vec::new();- let mut stack = vec![root];- while let Some(handle) = stack.pop() {- if dom.is_html_element_named(handle, "form") {- forms.push(handle);- }- stack.extend(- dom.child_handles(handle)- .collect::<Vec<_>>()- .into_iter()- .rev(),- );- if let Some(shadow) = dom.shadow_root_handle(handle) {- stack.push(shadow);- }- }+ let mut forms = dom.html_elements_by_local_name_in_shadow_including_subtree(root, "form");+ forms.sort_unstable_by(|left, right| {+ dom.compare_handles_in_shadow_including_tree_order(*left, *right)+ });forms}@@ -188,22 +176,98 @@ fn contains_tool_form(dom: &DomHost, root: DomHandle) -> bool {})}-fn affects_tool_form(dom: &DomHost, target: DomHandle) -> bool {+enum FormMutationScope {+ Target,+ Subtree,+ RemovedSubtree,+ Associations,+}++fn mark_affected_forms(+ host: &mut JsContextHost,+ dom: &DomHost,+ target: DomHandle,+ scope: FormMutationScope,+) {+ if !dom.is_connected(target) && !matches!(scope, FormMutationScope::RemovedSubtree) {+ return;+ }let Some(document) = dom.owner_document_handle(target) else {- return false;+ return;};- let forms = dom.html_elements_by_local_name_in_shadow_including_subtree(document, "form");- if forms.is_empty() {- return false;+ // Discovery is independent of successful registration: name-conflicting+ // candidates still need to retry when their controls change.+ if !contains_tool_form(dom, document) {+ return;+ }+ let mut affected = HashSet::new();+ let mut all = matches!(scope, FormMutationScope::Associations);+ let mut mark_owner = |handle| {+ if dom.is_html_element_named(handle, "form") && form_registration_is_valid(dom, handle) {+ affected.insert(handle);+ }+ if let Some(owner) = dom.form_control_owner(handle)+ && form_registration_is_valid(dom, owner)+ {+ affected.insert(owner);+ }+ };+ let mut ancestor = Some(target);+ while let Some(handle) = ancestor {+ mark_owner(handle);+ all |= dom.is_html_element_named(handle, "label");+ ancestor = dom.parent_node(handle);+ }+ if matches!(+ scope,+ FormMutationScope::Subtree | FormMutationScope::RemovedSubtree+ ) {+ let mut stack = vec![target];+ while let Some(handle) = stack.pop() {+ mark_owner(handle);+ if let Some(element) = dom.node(handle).and_then(Node::as_element) {+ // ID/label association changes can affect both the old and new+ // owners. A removed external control has already lost its old+ // owner, so conservatively update candidates in that document.+ all |= element.has_attribute("id")+ || element.is_html_label()+ || (matches!(scope, FormMutationScope::RemovedSubtree)+ && element.namespace() == "http://www.w3.org/1999/xhtml"+ && matches!(+ element.local_name(),+ "button"+ | "fieldset"+ | "input"+ | "object"+ | "output"+ | "select"+ | "textarea"+ ));+ }+ if all {+ break;+ }+ stack.extend(dom.child_handles(handle));+ if let Some(shadow) = dom.shadow_root_handle(handle) {+ stack.push(shadow);+ }+ }+ }+ if all {+ affected.extend(+ dom.html_elements_by_local_name_in_shadow_including_subtree(document, "form")+ .into_iter()+ .filter(|form| form_registration_is_valid(dom, *form)),+ );+ }+ if !affected.is_empty() {+ host.native_bridge_mut()+ .web_mcp+ .dirty_forms+ .entry(document)+ .or_default()+ .extend(affected);}- let owner = dom.form_control_owner(target);- // A name collision can keep a valid form out of the tool registry. Its- // descendants and associated controls still need to update its definition.- // Inspect indexed forms, never the growing mutation container's subtree.- forms.into_iter().any(|form| {- form_registration_is_valid(dom, form)- && (form == target || dom.is_ancestor(form, target) || owner == Some(form))- })}fn schema_attribute(name: &str) -> bool {@@ -238,18 +302,29 @@ pub(crate) fn prepare_registration_task(host: &mut JsContextHost) -> bool {let document = host.document_handle();let owner = document_owner(host, document);let needs_initial_scan = host.native_bridge().web_mcp.initialized_form_owner != owner;- let has_initial_forms = needs_initial_scan && contains_tool_form(host.dom_host(), document);+ let initial_forms = if needs_initial_scan {+ form_handles(host.dom_host(), document)+ .into_iter()+ .filter(|form| form_registration_is_valid(host.dom_host(), *form))+ .collect::<HashSet<_>>()+ } else {+ HashSet::new()+ };let store = &mut host.native_bridge_mut().web_mcp;if needs_initial_scan {// The scheduler discards tasks owned by the previous document. Its// queued marker must not prevent the replacement document's scan.store.form_registration_task_queued = false;store.initialized_form_owner = owner;- if has_initial_forms {- store.dirty_form_documents.insert(document);+ if !initial_forms.is_empty() {+ store+ .dirty_forms+ .entry(document)+ .or_default()+ .extend(initial_forms);}}- !store.form_registration_task_queued && !store.dirty_form_documents.is_empty()+ !store.form_registration_task_queued && !store.dirty_forms.is_empty()}pub(crate) fn queue_registration_task(@@ -279,11 +354,11 @@ fn registration_callback<'s>(let mut documents = {let store = &mut unsafe { &mut *host_ptr }.native_bridge_mut().web_mcp;store.form_registration_task_queued = false;- std::mem::take(&mut store.dirty_form_documents)+ std::mem::take(&mut store.dirty_forms).into_iter().collect::<Vec<_>>()};- documents.sort_unstable_by_key(|document| document.index());+ documents.sort_unstable_by_key(|(document, _)| document.index());// An observed invalidation cannot be undone by the final DOM snapshot.let invalidated = unsafe { &*host_ptr }.native_bridge()@@ -306,8 +381,8 @@ fn registration_callback<'s>("Tool definition changed during execution",);}- for document in documents {- synchronize_document(scope, host_ptr, document);+ for (document, forms) in documents {+ synchronize_document(scope, host_ptr, document, forms);}}@@ -322,6 +397,7 @@ fn form_tools(scope: &mut v8::PinScope<'_, '_>,host: &JsContextHost,document: DomHandle,+ forms: impl IntoIterator<Item = DomHandle>,) -> Vec<FormTool> {if document_owner(host, document).is_none()|| !host.document_scripting_enabled(document)@@ -340,7 +416,12 @@ fn form_tools(}let dom = host.dom_host();let mut result = Vec::new();- for handle in form_handles(dom, document) {+ for handle in forms {+ if !form_registration_is_valid(dom, handle)+ || dom.owner_document_handle(handle) != Some(document)+ {+ continue;+ }let element = dom.node(handle).and_then(Node::as_element).expect("form");let (Some(name), Some(description)) = (element.attribute("toolname"),@@ -372,8 +453,19 @@ fn synchronize_document(scope: &mut v8::PinScope<'_, '_>,host_ptr: *mut JsContextHost,document: DomHandle,+ affected_forms: HashSet<DomHandle>,) {- let definitions = form_tools(scope, unsafe { &*host_ptr }, document);+ let mut forms = affected_forms.iter().copied().collect::<Vec<_>>();+ forms.sort_unstable_by(|left, right| {+ unsafe { &*host_ptr }+ .dom_host()+ .compare_handles_in_shadow_including_tree_order(*left, *right)+ });+ let definitions = form_tools(scope, unsafe { &*host_ptr }, document, forms);+ let definitions_by_handle = definitions+ .iter()+ .map(|definition| (definition.handle, definition))+ .collect::<HashMap<_, _>>();if definitions.is_empty()&& !unsafe { &*host_ptr }.native_bridge()@@ -420,12 +512,16 @@ fn synchronize_document(else {return None;};- let same = definitions.iter().any(|definition| {- definition.handle == handle- && &definition.name == name- && definition.metadata == tool.metadata- && definition.autosubmit == autosubmit- });+ if !affected_forms.contains(&handle) {+ return None;+ }+ let same = definitions_by_handle+ .get(&handle)+ .is_some_and(|definition| {+ &definition.name == name+ && definition.metadata == tool.metadata+ && definition.autosubmit == autosubmit+ });(!same).then(|| name.clone())}).collect::<Vec<_>>()@@ -477,6 +573,12 @@ fn synchronize_document(}for definition in definitions {let host = unsafe { &mut *host_ptr };+ if host.native_bridge().web_mcp.documents[&document]+ .tools+ .contains_key(&definition.name)+ {+ continue;+ }let backend_node_id = host.renderer_backend_node_id_for_live_handle(definition.handle);let observed = devtools::observes_tree(host,@@ -484,9 +586,6 @@ fn synchronize_document();let store = &mut host.native_bridge_mut().web_mcp;let entry = store.documents.get_mut(&document).expect("form document");- if entry.tools.contains_key(&definition.name) {- continue;- }let tool = RegisteredTool {metadata: definition.metadata,stack_trace: None,diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/state.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/state.rsindex cccfa8798..981a3013c 100644--- a/moli-renderer-v8/src/context_bootstrap/web_mcp/state.rs+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/state.rs@@ -25,7 +25,7 @@ pub(crate) struct ModelContextStore {pub(super) retired_aborts: Vec<AbortRegistration>,pub(super) retired_invocations: Vec<PendingInvocation>,pub(super) retirement_task_queued: bool,- pub(super) dirty_form_documents: HashSet<DomHandle>,+ pub(super) dirty_forms: HashMap<DomHandle, HashSet<DomHandle>>,pub(super) form_registration_task_queued: bool,pub(super) initialized_form_owner: Option<WindowDocumentOwner>,pub(super) child_navigations: HashMap<diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/discovery.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/discovery.rsindex ff04d3bb1..510cff3f6 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/discovery.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/discovery.rs@@ -1,5 +1,172 @@use super::*;+#[test]+fn web_mcp_adopted_external_controls_update_both_document_schemas() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML='<form id=shared toolname=outer tooldescription=Outer></form><input name=query form=shared><iframe></iframe>';+ globalThis.input=document.querySelector('input');+ globalThis.childDocument=document.querySelector('iframe').contentDocument;+ childDocument.body.innerHTML='<form id=shared toolname=inner tooldescription=Inner></form>';+ globalThis.probe='pending';+ globalThis.capture=()=>document.modelContext.getTools().then(tools=>{+ probe=tools.map(tool=>tool.name+':'+Object.keys(tool.inputSchema.properties).sort().join(',')).sort().join('|');+ });+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("capture()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "inner:|outer:query"+ );+ vm.eval("childDocument.body.appendChild(input)").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("capture()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "inner:query|outer:"+ );+ vm.eval("document.body.appendChild(input)").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("capture()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "inner:|outer:query"+ );+}++#[test]+fn web_mcp_unrelated_dom_mutations_do_not_rebuild_form_schemas() {+ use crate::native_bridge::element::take_form_lookup_work_for_test;++ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(+ r#"+ for (let i=0;i<32;i++) {+ const form=document.createElement('form');+ form.setAttribute('toolname','form_'+i);+ form.setAttribute('tooldescription','Form '+i);+ form.innerHTML='<input name=value>';+ document.body.appendChild(form);+ }+ globalThis.input=document.querySelector('input');+ globalThis.root=document.body.appendChild(document.createElement('section'));+ globalThis.probe='pending';+ "#,+ )+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ take_form_lookup_work_for_test();+ vm.eval(+ r#"+ for (let i=0;i<8000;i++) root.appendChild(document.createElement('div'));+ root.setAttribute('value','unrelated');+ root.firstChild.textContent='unrelated';+ root.lastChild.remove();+ "#,+ )+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ assert_eq!(take_form_lookup_work_for_test().traversals, 0);++ vm.eval("input.name='changed'").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ let work = take_form_lookup_work_for_test();+ assert_eq!(work.traversals, 1, "one affected form among 32: {work:?}");+ vm.eval("document.modelContext.getTools().then(tools=>probe=tools.length+'|'+Object.keys(tools.find(tool=>tool.name==='form_0').inputSchema.properties).join(','))").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "32|changed"+ );+}++#[test]+fn web_mcp_incremental_schemas_track_external_controls_labels_and_disabled_fieldsets() {+ for mode in ["light", "open", "closed"] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(r#"+ globalThis.root=document.body;+ if ('{mode}' !== 'light') {{+ const host=document.body.appendChild(document.createElement('section'));+ root=host.attachShadow({{mode:'{mode}'}});+ }}+ root.innerHTML='<form id=one toolname=one tooldescription=One></form><form id=two toolname=two tooldescription=Two></form><label for=query>Old label</label><input id=query name=query form=one><fieldset><input name=outside form=one></fieldset>';+ globalThis.input=root.querySelector('input');+ globalThis.label=root.querySelector('label');+ globalThis.fieldset=root.querySelector('fieldset');+ globalThis.probe='pending';+ globalThis.capture=()=>document.modelContext.getTools().then(tools=>{{+ probe=tools.map(tool=>tool.name+':'+Object.keys(tool.inputSchema.properties).sort().join(',')).sort().join('|');+ }});+ "#)).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("capture()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "one:outside,query|two:",+ "{mode}"+ );+ vm.eval("label.firstChild.data='New label'").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(tools=>probe=tools.find(tool=>tool.name==='one').inputSchema.properties.query.description)").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "New label",+ "{mode}"+ );+ vm.eval("input.setAttribute('form','two'); fieldset.disabled=true")+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("capture()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "one:|two:query",+ "{mode}"+ );+ vm.eval("globalThis.wrapper=document.createElement('div'); wrapper.innerHTML='<input name=bulk form=one>'; root.appendChild(wrapper)").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("capture()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "one:bulk|two:query",+ "{mode}"+ );+ vm.eval("wrapper.remove(); fieldset.disabled=false")+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("capture()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "one:outside|two:query",+ "{mode}"+ );+ }+}++#[test]+fn web_mcp_indexed_discovery_preserves_shadow_including_duplicate_name_order() {+ for mode in ["open", "closed"] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(r#"+ const host=document.body.appendChild(document.createElement('section'));+ const light=document.createElement('form');+ light.setAttribute('toolname','duplicate'); light.setAttribute('tooldescription','Light');+ host.appendChild(light);+ const shadow=host.attachShadow({{mode:'{mode}'}});+ shadow.innerHTML='<form toolname=duplicate tooldescription=Shadow></form>';+ globalThis.probe='pending';+ "#)).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(([tool])=>probe=tool.description)")+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "Shadow",+ "{mode}"+ );+ }+}+#[test]fn web_mcp_aborted_callback_registration_cannot_remove_its_form_replacement() {let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");@@ -25,24 +192,30 @@ fn web_mcp_aborted_callback_registration_cannot_remove_its_form_replacement() {#[test]fn web_mcp_declarative_candidates_retry_registration_when_their_controls_change() {for mode in ["light", "open", "closed"] {- for (markup, mutation) in [+ for (markup, external_control, mutation) in [("",+ false,"const input=document.createElement('input'); input.name='query'; form.appendChild(input)",),("<div></div>",+ false,"const input=document.createElement('input'); input.name='query'; form.firstChild.appendChild(input)",),("<div><input name=discard><input name=query></div>",+ false,"form.elements.discard.remove()",),- ("<input name=old>", "form.elements.old.name='query'"),+ ("<input name=old>", false, "form.elements.old.name='query'"),("",+ false,"const input=document.createElement('input'); input.name='query'; input.setAttribute('form',form.id); root.appendChild(input)",),+ ("", true, "external.remove()"),+ ("", true, "external.removeAttribute('form')"),] {let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");vm.eval(@@ -73,12 +246,23 @@ fn web_mcp_declarative_candidates_retry_registration_when_their_controls_change(form.setAttribute('toolautosubmit','');form.innerHTML='{markup}';form.addEventListener('submit',event=>{{- event.preventDefault(); event.respondWith(form.elements.query.value);+ event.preventDefault();+ const query=form.elements.namedItem('query');+ event.respondWith(query ? query.value : 'empty');}});root.appendChild(form);+ if ({external_control}) {{+ globalThis.external=document.createElement('input');+ external.name='query';+ external.setAttribute('form',form.id);+ root.appendChild(external);+ }}"#)).unwrap();+ if external_control {+ assert_eq!(vm.eval("external.form===form").unwrap(), "true", "{mode}");+ }// Complete the conflicting registration attempt before freeing the// name, so a coalesced initial scan cannot hide a missing retry.vm.eval_after_selected_page_tasks("undefined").unwrap();@@ -102,6 +286,13 @@ fn web_mcp_declarative_candidates_retry_registration_when_their_controls_change(assert_eq!(vm.eval_after_selected_page_tasks("probe").unwrap(), "[]");vm.eval(mutation).unwrap();+ if external_control {+ assert_eq!(+ vm.eval("external.form===null").unwrap(),+ "true",+ "{mode}: {mutation}"+ );+ }vm.eval_after_selected_page_tasks("undefined").unwrap();vm.eval(r#"mc.getTools().then(tools=>{@@ -111,14 +302,23 @@ fn web_mcp_declarative_candidates_retry_registration_when_their_controls_change("#).unwrap();assert_eq!(vm.eval_after_selected_page_tasks("probe").unwrap(),- "Declarative|query",+ if external_control {+ "Declarative|"+ } else {+ "Declarative|query"+ },"{mode}: {mutation}");- vm.eval("mc.getTools().then(([tool])=>mc.executeTool(tool,{query:'filled'})).then(value=>probe=value,error=>probe=error.name)")+ let input = if external_control {+ "{}"+ } else {+ "{query:'filled'}"+ };+ vm.eval(&format!("mc.getTools().then(([tool])=>mc.executeTool(tool,{input})).then(value=>probe=value,error=>probe=error.name)")).unwrap();assert_eq!(vm.eval_after_selected_page_tasks("probe").unwrap(),- "filled",+ if external_control { "empty" } else { "filled" },"{mode}: {mutation}");}