Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
feat(webmcp): implement document tools and CDP integration
ldm0c345a594f47d
diff --git a/Cargo.lock b/Cargo.lockindex b20b90f81..dd0eebab7 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -3149,6 +3149,7 @@ dependencies = ["moli-webcrypto","moli-webidl","moli-webidl-callback",+ "moli-webmcp","moli-websocket","moli-window-features","moli-xpath",diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rsindex 9973c4221..a48c341f1 100644--- a/moli-core/src/page/command_dispatch.rs+++ b/moli-core/src/page/command_dispatch.rs@@ -272,6 +272,7 @@ impl Page {pub(super) fn page_reply_kind(reply: &RendererPageReply) -> &'static str {match reply {+ RendererPageReply::WebMcp(_) => "a WebMCP command result",RendererPageReply::RuntimeEvaluationResult(_) => "a runtime evaluation result reply",RendererPageReply::ElementClickPreparation(_) => "an element click preparation reply",RendererPageReply::ElementClickDispatch(_) => "an element click dispatch reply",diff --git a/moli-core/src/runtime/navigation_engine.rs b/moli-core/src/runtime/navigation_engine.rsindex d91b65f9a..bd8dbb735 100644--- a/moli-core/src/runtime/navigation_engine.rs+++ b/moli-core/src/runtime/navigation_engine.rs@@ -193,6 +193,7 @@ pub struct PreparedDocumentPage {#[derive(Debug, Clone)]pub struct PreparedDocumentPageCommitConfiguration {+ pub web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,pub document_start_scripts: Vec<DocumentStartScript>,pub runtime_bindings: Vec<RuntimeBindingRegistration>,pub runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,@@ -247,6 +248,7 @@ impl PreparedDocumentPage {self.prepared.update_commit_configuration(moli_renderer_v8::RendererPreparedDocumentCommitConfiguration {+ web_mcp_invocation: configuration.web_mcp_invocation,document_start_scripts: configuration.document_start_scripts,runtime_bindings: configuration.runtime_bindings,runtime_inspector_session_restore_snapshots: configurationdiff --git a/moli-page-types/src/inspector_state.rs b/moli-page-types/src/inspector_state.rsindex a8d8f3c0e..e0ef5022b 100644--- a/moli-page-types/src/inspector_state.rs+++ b/moli-page-types/src/inspector_state.rs@@ -75,6 +75,7 @@ impl V8InspectorSessionAttach {/// segments instead.#[derive(Debug, Clone, Default, PartialEq)]pub struct RendererInspectorProtocolConfiguration {+ pub web_mcp_enabled: bool,pub runtime_bindings: Vec<RuntimeBindingRegistration>,pub runtime_frontend_enabled: bool,pub console_frontend_enabled: bool,@@ -179,6 +180,7 @@ impl RendererInspectorProtocolConfiguration {pub fn requires_restore(&self) -> bool {self.runtime_frontend_enabled+ || self.web_mcp_enabled|| !self.runtime_bindings.is_empty()|| self.console_frontend_enabled|| !self.dom_debugger_event_listener_breakpoints.is_empty()diff --git a/moli-page-types/src/lib.rs b/moli-page-types/src/lib.rsindex b65fcd50d..1d85a92ec 100644--- a/moli-page-types/src/lib.rs+++ b/moli-page-types/src/lib.rs@@ -13,8 +13,14 @@ mod navigation_history;mod navigator_overrides;mod renderer_transport_memory;mod session_history;+mod web_mcp;pub use session_history::{SessionHistoryCommit, SessionHistorySeed, SessionHistoryUpdate};+pub use web_mcp::{+ RendererWebMcpAnnotations, RendererWebMcpCommand, RendererWebMcpError, RendererWebMcpEvent,+ RendererWebMcpNavigation, RendererWebMcpObservation, RendererWebMcpResult, RendererWebMcpTool,+ RendererWebMcpToolId,+};use std::{borrow::Cow,diff --git a/moli-page-types/src/web_mcp.rs b/moli-page-types/src/web_mcp.rsnew file mode 100644index 000000000..7fd808867--- /dev/null+++ b/moli-page-types/src/web_mcp.rs@@ -0,0 +1,98 @@+//! Native WebMCP operations and producer-owned tool observations.+//! A missing frame ID denotes this renderer agent's local root; child IDs are+//! captured from the frame owner at production, before the Document retires.++use crate::DevToolsSessionKey;++#[derive(Clone, Debug)]+pub enum RendererWebMcpCommand {+ Enable,+ Disable,+ InvokeTool {+ frame_id: Option<String>,+ name: String,+ input: String,+ },+ CancelInvocation {+ invocation_id: u64,+ },+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub enum RendererWebMcpError {+ NotEnabled,+ InvalidParams(&'static str),+ SchedulingFailed,+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub struct RendererWebMcpTool {+ pub frame_id: Option<String>,+ pub name: String,+ pub description: String,+ pub input_schema: Option<String>,+ pub annotations: Option<RendererWebMcpAnnotations>,+ pub autosubmit: bool,+ pub backend_node_id: Option<u32>,+ pub stack_trace: Option<serde_json::Value>,+}++#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub struct RendererWebMcpAnnotations {+ pub read_only: bool,+ pub consequential: bool,+ pub untrusted_content: bool,+ pub debugging: bool,+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub struct RendererWebMcpToolId {+ pub frame_id: Option<String>,+ pub name: String,+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub enum RendererWebMcpEvent {+ ToolsAdded(Vec<RendererWebMcpTool>),+ ToolsRemoved(Vec<RendererWebMcpToolId>),+ ToolInvoked {+ tool: RendererWebMcpToolId,+ invocation_id: u64,+ input: String,+ },+ ToolResponded {+ invocation_id: u64,+ result: RendererWebMcpResult,+ },+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub enum RendererWebMcpResult {+ Completed(String),+ Canceled,+ Error {+ message: String,+ exception: Option<serde_json::Value>,+ },+}++impl RendererWebMcpResult {+ pub fn navigation_failed() -> Self {+ Self::Error {+ message: "Tool navigation did not produce an active destination Document".into(),+ exception: None,+ }+ }+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub struct RendererWebMcpObservation {+ pub session: DevToolsSessionKey,+ pub event: RendererWebMcpEvent,+}++#[derive(Clone, Debug, PartialEq, Eq)]+pub struct RendererWebMcpNavigation {+ pub invocation_id: u64,+ pub origin: url::Origin,+}diff --git a/moli-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rsindex 5f1ab57b5..527c1e1a1 100644--- a/moli-protocol/src/conn/dispatch.rs+++ b/moli-protocol/src/conn/dispatch.rs@@ -836,7 +836,7 @@ impl CdpConnection {Some(self.complete_with_output_plan(command_context, plan, cmd.id, cmd.session_id))}"WebMCP" => {- let plan = crate::domains::web_mcp::command_output_plan(&cmd);+ let plan = crate::domains::web_mcp::command_output_plan(self, &cmd);Some(self.complete_with_output_plan(command_context, plan, cmd.id, cmd.session_id))}"Performance" => Some(diff --git a/moli-protocol/src/conn/dispatch_tests/bidi.rs b/moli-protocol/src/conn/dispatch_tests/bidi.rsindex 127e56a67..5424f05c4 100644--- a/moli-protocol/src/conn/dispatch_tests/bidi.rs+++ b/moli-protocol/src/conn/dispatch_tests/bidi.rs@@ -20,6 +20,7 @@ async fn bidi_fetch_control_resolves_background_request_owner() {interception_session_id: Some("bidi-session-1".to_owned()),document_navigation_token: None,navigation: NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: None,diff --git a/moli-protocol/src/conn/page_state/fetch_state.rs b/moli-protocol/src/conn/page_state/fetch_state.rsindex 4846c8244..fc5b546b2 100644--- a/moli-protocol/src/conn/page_state/fetch_state.rs+++ b/moli-protocol/src/conn/page_state/fetch_state.rs@@ -352,6 +352,7 @@ mod tests {fn navigation_state(url: &Url) -> NavigationDispatchState {NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),diff --git a/moli-protocol/src/conn/runtime_load.rs b/moli-protocol/src/conn/runtime_load.rsindex c69d2b1c0..462365ce1 100644--- a/moli-protocol/src/conn/runtime_load.rs+++ b/moli-protocol/src/conn/runtime_load.rs@@ -1493,6 +1493,7 @@ impl CdpConnection {.or_else(|| self.global_browser_identity_override.clone()).unwrap_or_else(|| self.base_browser_identity.clone());Ok(PreparedDocumentPageCommitConfiguration {+ web_mcp_invocation: None,document_start_scripts: load_inputs.document_start_scripts,runtime_bindings: load_inputs.runtime_bindings,runtime_inspector_session_restore_snapshots: load_inputsdiff --git a/moli-protocol/src/conn/state/devtools_session.rs b/moli-protocol/src/conn/state/devtools_session.rsindex eda85606c..42b4ec21e 100644--- a/moli-protocol/src/conn/state/devtools_session.rs+++ b/moli-protocol/src/conn/state/devtools_session.rs@@ -31,6 +31,7 @@ use moli_page_types::{/// attachment, replay, and disposal all address the same session object.#[derive(Clone, Debug, Default, PartialEq)]pub(crate) struct DevToolsSessionState {+ pub(crate) web_mcp_enabled: bool,pub(crate) dom_session_state: DevToolsDomSessionState,pub(crate) dom_debugger_event_listener_breakpoints:BTreeSet<RendererDomDebuggerEventListenerBreakpoint>,@@ -528,6 +529,7 @@ impl DevToolsSessionRegistry {.iter().filter_map(|(key, state)| {let requires_restore = state.runtime_session_state.runtime_frontend_enabled+ || state.web_mcp_enabled|| state.console_output_session_state.console_enabled|| !state.runtime_bindings.is_empty()|| !state.dom_debugger_event_listener_breakpoints.is_empty()@@ -539,6 +541,7 @@ impl DevToolsSessionRegistry {state.inspector_session_state.v8_state.clone(),),protocol_configuration: RendererInspectorProtocolConfiguration {+ web_mcp_enabled: state.web_mcp_enabled,runtime_bindings: state.runtime_bindings.clone(),runtime_frontend_enabled: state.runtime_session_statediff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rsindex 6168ffc01..9187eeb0d 100644--- a/moli-protocol/src/conn/state/fetch.rs+++ b/moli-protocol/src/conn/state/fetch.rs@@ -2415,6 +2415,7 @@ mod tests {response_stage_request_id: request_id.to_owned(),document_navigation_token: None,navigation: NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),diff --git a/moli-protocol/src/conn/state/navigation_outcome.rs b/moli-protocol/src/conn/state/navigation_outcome.rsindex 34c4e88d6..6b03e8dcf 100644--- a/moli-protocol/src/conn/state/navigation_outcome.rs+++ b/moli-protocol/src/conn/state/navigation_outcome.rs@@ -304,6 +304,7 @@ impl NavigationResultProjection {#[derive(Debug, Clone)]pub struct NavigationDispatchState {+ pub(crate) web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,pub(crate) redirect_chain: Vec<moli_fetch::RedirectInfo>,pub(crate) redirect_headers: Option<moli_fetch::RequestHeaders>,pub navigate_id: Option<u64>,diff --git a/moli-protocol/src/conn/state/tests.rs b/moli-protocol/src/conn/state/tests.rsindex 48250247c..129956d19 100644--- a/moli-protocol/src/conn/state/tests.rs+++ b/moli-protocol/src/conn/state/tests.rs@@ -25,6 +25,7 @@ use url::Url;fn test_navigation_dispatch_state(fetch_request_id: &str) -> NavigationDispatchState {NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),diff --git a/moli-protocol/src/conn/tests/mod.rs b/moli-protocol/src/conn/tests/mod.rsindex b839567f6..be73964ee 100644--- a/moli-protocol/src/conn/tests/mod.rs+++ b/moli-protocol/src/conn/tests/mod.rs@@ -1754,6 +1754,7 @@ fn materialized_navigation_test_state(requested_url: &str,) -> NavigationDispatchState {NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id,diff --git a/moli-protocol/src/conn/tests/navigation_error.rs b/moli-protocol/src/conn/tests/navigation_error.rsindex cf3084632..e041af4ab 100644--- a/moli-protocol/src/conn/tests/navigation_error.rs+++ b/moli-protocol/src/conn/tests/navigation_error.rs@@ -278,6 +278,7 @@ fn navigation_fixture() -> (ctx.conn.install_browser_context_fixture_for_test(browser_context);let navigation = NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),@@ -515,18 +516,22 @@ async fn background_claim_checks_dispatch_identity_and_owner_before_claiming() {.unwrap();for mismatch in [NavigationDispatchState {+ web_mcp_invocation: None,frame_id: "other frame".into(),..navigation.clone()},NavigationDispatchState {+ web_mcp_invocation: None,loader_id: "other loader".into(),..navigation.clone()},NavigationDispatchState {+ web_mcp_invocation: None,owner: CommandOwnerScope::for_session("missing session"),..navigation.clone()},NavigationDispatchState {+ web_mcp_invocation: None,owner: CommandOwnerScope::for_session("SID-other"),..navigation.clone()},@@ -611,6 +616,7 @@ async fn background_claims_are_target_owned_in_inactive_browser_contexts() {ctx.conn.push_inactive_browser_context_fixture_for_test(other);let other_navigation = NavigationDispatchState {+ web_mcp_invocation: None,owner: CommandOwnerScope::for_session("SID-other"),frame_id: other_token.target_id.clone(),session_id: Some("SID-other".into()),diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rsindex 8308a9933..30c877de0 100644--- a/moli-protocol/src/conn/tests/resource_runtime.rs+++ b/moli-protocol/src/conn/tests/resource_runtime.rs@@ -106,6 +106,7 @@ async fn buffered_navigation_for_inactive_session_retains_its_target_engine() {let requested_url = Url::parse("https://target.example/fulfilled").unwrap();let navigation = NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),diff --git a/moli-protocol/src/domains/actions.rs b/moli-protocol/src/domains/actions.rsindex 6a5d5a5f9..83933c672 100644--- a/moli-protocol/src/domains/actions.rs+++ b/moli-protocol/src/domains/actions.rs@@ -480,4 +480,6 @@ pub(crate) enum WebAuthnAction {pub(crate) enum WebMcpAction {Enable,Disable,+ InvokeTool,+ CancelInvocation,}diff --git a/moli-protocol/src/domains/activity/main_document.rs b/moli-protocol/src/domains/activity/main_document.rsindex 632b69861..795fc5952 100644--- a/moli-protocol/src/domains/activity/main_document.rs+++ b/moli-protocol/src/domains/activity/main_document.rs@@ -933,6 +933,7 @@ mod tests {fn navigation_state() -> NavigationDispatchState {NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(77),diff --git a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rsindex 1bda9ad10..e6c1ba3cb 100644--- a/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs+++ b/moli-protocol/src/domains/activity/output_ingress/prepared_outputs.rs@@ -75,6 +75,14 @@ impl PreparedProtocolOutputs {) -> Self {let mut prepared = Self::empty();match observation {+ RendererProtocolObservation::WebMcp(observation) => {+ crate::domains::web_mcp::append_observation(+ conn,+ owner,+ observation,+ &mut prepared,+ );+ }RendererProtocolObservation::MainDocumentCommit(commit) => {crate::domains::page::append_renderer_main_document_commit_to_output_sink(commit.clone(),diff --git a/moli-protocol/src/domains/activity/output_payloads.rs b/moli-protocol/src/domains/activity/output_payloads.rsindex 5f3c0cdf5..ec0ef260e 100644--- a/moli-protocol/src/domains/activity/output_payloads.rs+++ b/moli-protocol/src/domains/activity/output_payloads.rs@@ -14,6 +14,7 @@ use crate::domains::{/// was not named by the producer.#[derive(Debug)]pub(in crate::domains) enum ProtocolOutputPayload {+ WebMcp(crate::domains::web_mcp::WebMcpPreparedOutputSlot),Dom(DomPreparedOutputSlot),DomStorage(DomStoragePreparedOutputSlot),Input(InputPreparedOutputSlot),@@ -32,6 +33,7 @@ pub(in crate::domains) enum ProtocolOutputPayload {/// renderer or synthesize another output family.#[derive(Debug, Default)]pub(in crate::domains) struct ProtocolOutputPayloads {+ web_mcp: Option<crate::domains::web_mcp::WebMcpPreparedOutputSlot>,dom: Option<DomPreparedOutputSlot>,dom_storage: Option<DomStoragePreparedOutputSlot>,input: Option<InputPreparedOutputSlot>,@@ -65,6 +67,7 @@ impl ProtocolOutputPayloads {}};}match payload {+ ProtocolOutputPayload::WebMcp(value) => merge!(web_mcp, value),ProtocolOutputPayload::Dom(value) => merge!(dom, value),ProtocolOutputPayload::DomStorage(value) => merge!(dom_storage, value),ProtocolOutputPayload::Input(value) => merge!(input, value),@@ -83,6 +86,12 @@ impl ProtocolOutputPayloads {self.dom.as_mut()}+ pub(in crate::domains) fn web_mcp_mut(+ &mut self,+ ) -> Option<&mut crate::domains::web_mcp::WebMcpPreparedOutputSlot> {+ self.web_mcp.as_mut()+ }+pub(in crate::domains) fn dom_storage_mut(&mut self,) -> Option<&mut DomStoragePreparedOutputSlot> {@@ -128,6 +137,7 @@ impl ProtocolOutputPayloads {#[cfg(test)]fn slot_count(&self) -> usize {[+ self.web_mcp.is_some(),self.dom.is_some(),self.dom_storage.is_some(),self.input.is_some(),@@ -155,6 +165,7 @@ macro_rules! impl_payload_from {}impl_payload_from!(DomPreparedOutputSlot, Dom);+impl_payload_from!(crate::domains::web_mcp::WebMcpPreparedOutputSlot, WebMcp);impl_payload_from!(DomStoragePreparedOutputSlot, DomStorage);impl_payload_from!(InputPreparedOutputSlot, Input);impl_payload_from!(MainDocumentCommitPreparedOutput, MainDocumentCommit);diff --git a/moli-protocol/src/domains/activity/output_slot.rs b/moli-protocol/src/domains/activity/output_slot.rsindex d8e645fa8..7d53deb28 100644--- a/moli-protocol/src/domains/activity/output_slot.rs+++ b/moli-protocol/src/domains/activity/output_slot.rs@@ -29,6 +29,7 @@ pub(in crate::domains) enum ProtocolOutputResponseOrder {/// time.#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]pub(in crate::domains) enum ProtocolOutputSlot {+ WebMcp,PendingSubresourceContinueEvents,TopLevelLocationNavigation,TopLevelHistoryTraversal,@@ -80,6 +81,7 @@ impl ProtocolOutputSlot {| Self::TopLevelLocationNavigation| Self::TopLevelHistoryTraversal => ProtocolOutputDelivery::OwnerAction,Self::WindowOpen+ | Self::WebMcp| Self::Audits| Self::Console| Self::Log@@ -136,6 +138,7 @@ impl ProtocolOutputSlot {| Self::DocumentLifecycle| Self::RuntimeObservable| Self::DomStorage+ | Self::WebMcp| Self::SessionHistoryUpdate| Self::SameDocumentNavigation => ProtocolOutputResponseOrder::BeforeResponse,}@@ -149,6 +152,7 @@ impl ProtocolOutputSlot {) -> Pin<Box<dyn Future<Output = ()> + 'a>> {Box::pin(async move {match self {+ Self::WebMcp => crate::domains::web_mcp::project_async(context, payloads).await,Self::PendingSubresourceContinueEvents => {crate::domains::network::project_pending_subresource_continue_async(conn, context, payloads,@@ -307,6 +311,7 @@ mod tests {(DocumentLifecycle, ProtocolObservation, BeforeResponse),(RuntimeObservable, OwnerAction, BeforeResponse),(DomStorage, ProtocolObservation, BeforeResponse),+ (WebMcp, ProtocolObservation, BeforeResponse),(ChildFrameActivity, OwnerAction, AfterResponse),(SameDocumentNavigation, OwnerAction, BeforeResponse),(SessionHistoryUpdate, OwnerAction, BeforeResponse),diff --git a/moli-protocol/src/domains/fetch/tests/basics.rs b/moli-protocol/src/domains/fetch/tests/basics.rsindex 2a0bf9be7..b1f7ff190 100644--- a/moli-protocol/src/domains/fetch/tests/basics.rs+++ b/moli-protocol/src/domains/fetch/tests/basics.rs@@ -1060,6 +1060,7 @@ async fn disable_clears_fetch_state() {interception_session_id: Some("SID-1".to_owned()),document_navigation_token: None,navigation: crate::conn::NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),@@ -1102,6 +1103,7 @@ async fn disable_clears_fetch_state() {response_stage_request_id: "INT-1".to_owned(),document_navigation_token: None,navigation: crate::conn::NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),@@ -1330,6 +1332,7 @@ async fn continue_with_auth_rejects_invalid_response_without_consuming_pending_aresponse_stage_request_id: "INT-8".to_owned(),document_navigation_token: None,navigation: crate::conn::NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),@@ -1407,6 +1410,7 @@ async fn continue_with_auth_unsupported_challenge_preserves_pending_auth_navigatresponse_stage_request_id: "INT-9".to_owned(),document_navigation_token: None,navigation: crate::conn::NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),@@ -1581,6 +1585,7 @@ fn emit_auth_required_preserves_request_headers_and_post_data_shape() {interception_session_id: Some("SID-1".to_owned()),document_navigation_token: None,navigation: crate::conn::NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),diff --git a/moli-protocol/src/domains/native.rs b/moli-protocol/src/domains/native.rsindex d51f6c4dd..18e3b9a89 100644--- a/moli-protocol/src/domains/native.rs+++ b/moli-protocol/src/domains/native.rs@@ -188,6 +188,7 @@ pub(crate) fn try_start(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> Option<Nativmatch cmd.method.split_once('.')?.0 {"DOMDebugger" => super::dom_debugger::native::try_start,"Autofill" => super::autofill::try_start_native_command,+ "WebMCP" => super::web_mcp::try_start_native_command,"Page" => super::page::native::try_start,"DOM" => super::dom::try_start_native_command,"DOMSnapshot" => super::dom_snapshot::try_start_native_command,@@ -229,6 +230,11 @@ pub(crate) fn project_terminal_for_owner(continue;};match update {+ moli_core::RendererNativeProtocolStateUpdate::WebMcpEnabled(enabled) => {+ conn.with_target_devtools_session_state_for_owner_mut(owner, |state| {+ state.web_mcp_enabled = enabled+ });+ }moli_core::RendererNativeProtocolStateUpdate::RemoteObjects { object_group } => {let Ok(result) = &response.result else {continue;diff --git a/moli-protocol/src/domains/network/tests/cache.rs b/moli-protocol/src/domains/network/tests/cache.rsindex 720be24e4..c4a6d9240 100644--- a/moli-protocol/src/domains/network/tests/cache.rs+++ b/moli-protocol/src/domains/network/tests/cache.rs@@ -648,6 +648,7 @@ async fn clear_browser_cache_keeps_pending_response_navigation_transfer() {"INT-1".to_owned(),None,NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),diff --git a/moli-protocol/src/domains/network/tests/response_body.rs b/moli-protocol/src/domains/network/tests/response_body.rsindex 18addbe4b..c0760e1d6 100644--- a/moli-protocol/src/domains/network/tests/response_body.rs+++ b/moli-protocol/src/domains/network/tests/response_body.rs@@ -507,6 +507,7 @@ async fn get_request_post_data_returns_main_document_navigation_post_body() {let requested_url = Url::parse("http://127.0.0.1:1/post").unwrap();let navigation_state = NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),@@ -598,6 +599,7 @@ async fn get_request_post_data_uses_text_projection_while_bidi_collector_keeps_tlet requested_url = Url::parse("http://127.0.0.1:1/upload").unwrap();let navigation_state = NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: Some(1),diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rsindex f531eb59d..a0a88436b 100644--- a/moli-protocol/src/domains/page.rs+++ b/moli-protocol/src/domains/page.rs@@ -1335,6 +1335,7 @@ pub(crate) async fn navigate_page_owned_top_level_location_background_events_asynavigation.request_body(),navigation.request_headers(),navigation.browser_navigation_kind(),+ navigation.web_mcp_invocation(),).await;}@@ -1354,6 +1355,7 @@ pub(crate) async fn navigate_command_owner_from_renderer_background_events_asyncNone,&[],moli_fetch::BrowserNavigationRequestKind::Navigate,+ None,).await;}@@ -1367,6 +1369,7 @@ async fn navigate_command_owner_from_renderer_request_background_events_async(request_body: Option<&[u8]>,request_headers: &[(String, String)],browser_navigation_kind: moli_fetch::BrowserNavigationRequestKind,+ web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,) {let start = navigation::start_session_owner_navigation_from_renderer(conn,@@ -1376,6 +1379,7 @@ async fn navigate_command_owner_from_renderer_request_background_events_async(request_body,request_headers,browser_navigation_kind,+ web_mcp_invocation,);let step =navigation::finish_started_navigation_command_for_parts(conn, None, owner, start, &[]);diff --git a/moli-protocol/src/domains/page/navigation.rs b/moli-protocol/src/domains/page/navigation.rsindex 7418b1fba..74add1f8f 100644--- a/moli-protocol/src/domains/page/navigation.rs+++ b/moli-protocol/src/domains/page/navigation.rs@@ -2066,6 +2066,7 @@ pub(super) fn start_session_owner_navigation_from_renderer(request_body: Option<&[u8]>,request_headers: &[(String, String)],browser_navigation_kind: moli_fetch::BrowserNavigationRequestKind,+ web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,) -> NavigateCommandStart {let session_id = owner.session_id();let reloaded_after_crash_session_ids = reloaded_after_crash_session_ids(conn, owner);@@ -2117,6 +2118,7 @@ pub(super) fn start_session_owner_navigation_from_renderer(}},NavigationStartInitiator::Renderer,+ web_mcp_invocation,)};clear_crash_state_for_renderer_navigation(conn, start, owner, &reloaded_after_crash_session_ids)@@ -2661,6 +2663,7 @@ fn start_navigate_to_url_command_with_background_policy(allow_background_navigation,request_load_policy,initiator,+ None,)}@@ -2685,6 +2688,7 @@ fn start_navigate_to_url_command_with_background_policy_and_request(allow_background_navigation: bool,request_load_policy: NavigationRequestLoadPolicy,initiator: NavigationStartInitiator,+ web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,) -> NavigateCommandStart {let command_session_id = owner.session_id();let mut out = Vec::new();@@ -2734,6 +2738,7 @@ fn start_navigate_to_url_command_with_background_policy_and_request(.map(|preflight| preflight.inherited_secure_context_type.clone()).unwrap_or_else(|| "Secure".to_owned());let mut navigation_state = NavigationDispatchState {+ web_mcp_invocation,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: command_id,@@ -3252,6 +3257,13 @@ pub(crate) async fn complete_materialized_navigation_into_buffer_async(command_context: &mut crate::conn::CommandDispatchContext,) {if !conn.accepts_pending_document_navigation_for_owner(&state.owner, &token) {+ if let Some(id) = state.web_mcp_invocation.as_ref() {+ out.extend_background_events_after_messages(super::super::web_mcp::navigation_failed(+ conn,+ &state.owner,+ id.invocation_id,+ ));+ }push_superseded_navigation_result(out, &state);// A stale response cannot commit or alter the current navigation, but// its exact renderer-channel suspension still needs to be retired.@@ -3286,7 +3298,10 @@ async fn complete_materialized_navigation_into_buffer_inner_async(&state.owner,navigation.final_url(),) {- Ok(configuration) => navigation.update_commit_configuration(configuration).await,+ Ok(mut configuration) => {+ configuration.web_mcp_invocation = state.web_mcp_invocation.clone();+ navigation.update_commit_configuration(configuration).await+ }Err(error) => Err(error),};if let Err(error) = update_result {@@ -3365,10 +3380,20 @@ async fn complete_materialized_navigation_into_buffer_inner_async(.await;}network::MaterializedNavigationLoadOutcome::Download(navigation) => {+ if let Some(id) = state.web_mcp_invocation.as_ref() {+ out.extend_background_events_after_messages(+ super::super::web_mcp::navigation_failed(conn, &state.owner, id.invocation_id),+ );+ }let _ = conn.clear_pending_navigation_history_update_for_owner(&state.owner);commit_download_navigation_async(conn, out, state, navigation, command_context).await;}network::MaterializedNavigationLoadOutcome::Failed(navigation) => {+ if let Some(id) = state.web_mcp_invocation.as_ref() {+ out.extend_background_events_after_messages(+ super::super::web_mcp::navigation_failed(conn, &state.owner, id.invocation_id),+ );+ }let _ = conn.clear_pending_navigation_history_update_for_owner(&state.owner);let network::MaterializedFailedDocumentProgress {error_text,diff --git a/moli-protocol/src/domains/runtime/tests/evaluate/navigation.rs b/moli-protocol/src/domains/runtime/tests/evaluate/navigation.rsindex b3e82a808..37a948e4b 100644--- a/moli-protocol/src/domains/runtime/tests/evaluate/navigation.rs+++ b/moli-protocol/src/domains/runtime/tests/evaluate/navigation.rs@@ -642,6 +642,7 @@ async fn page_navigate_network_failure_commits_error_document() {let stale_body_completion = BackgroundNavigationCompletion::main_document_body(old_document_token.clone(),crate::conn::NavigationDispatchState {+ web_mcp_invocation: None,redirect_chain: Vec::new(),redirect_headers: None,navigate_id: None,diff --git a/moli-protocol/src/domains/web_mcp.rs b/moli-protocol/src/domains/web_mcp.rsindex 9b417f984..6422dae50 100644--- a/moli-protocol/src/domains/web_mcp.rs+++ b/moli-protocol/src/domains/web_mcp.rs@@ -1,10 +1,133 @@-use crate::conn::Cmd;-use crate::domains::actions::WebMcpAction;-use crate::domains::command_output::CommandOutputPlan;+use crate::{+ conn::{CdpConnection, Cmd, CommandOwnerScope},+ domains::{actions::WebMcpAction, command_output::CommandOutputPlan},+};+use moli_page_types::{DevToolsSessionKey, RendererWebMcpCommand, RendererWebMcpError};+use serde::Deserialize;+use serde_json::{Value, json};-pub(crate) fn command_output_plan(cmd: &Cmd<'_>) -> CommandOutputPlan {+mod output;+#[cfg(test)]+mod tests;+pub(in crate::domains) use output::navigation_failed;+pub(in crate::domains) use output::{WebMcpPreparedOutputSlot, append_observation, project_async};++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct InvokeParams {+ frame_id: String,+ tool_name: String,+ input: serde_json::Map<String, Value>,+}+#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+struct CancelParams {+ invocation_id: String,+}++fn request(+ conn: &CdpConnection,+ cmd: &Cmd<'_>,+) -> Result<RendererWebMcpCommand, CommandOutputPlan> {+ match cmd.parse_action::<WebMcpAction>() {+ Some(WebMcpAction::Enable) => Ok(RendererWebMcpCommand::Enable),+ Some(WebMcpAction::Disable) => Ok(RendererWebMcpCommand::Disable),+ Some(WebMcpAction::InvokeTool) => {+ let params = cmd+ .get_params::<InvokeParams>()+ .ok()+ .flatten()+ .ok_or_else(|| CommandOutputPlan::error(-32602, "Invalid parameters"))?;+ let root = conn+ .target_session_owner_frame_tree_identity(cmd.session_id)+ .map(|identity| identity.0);+ Ok(RendererWebMcpCommand::InvokeTool {+ frame_id: Some(params.frame_id).filter(|frame| Some(frame) != root.as_ref()),+ name: params.tool_name,+ input: serde_json::to_string(¶ms.input).expect("JSON input"),+ })+ }+ Some(WebMcpAction::CancelInvocation) => {+ let params = cmd+ .get_params::<CancelParams>()+ .ok()+ .flatten()+ .ok_or_else(|| CommandOutputPlan::error(-32602, "Invalid parameters"))?;+ let invocation_id = params+ .invocation_id+ .parse()+ .ok()+ .filter(|id| *id > 0)+ .ok_or_else(|| CommandOutputPlan::error(-32602, "Invalid invocation id"))?;+ Ok(RendererWebMcpCommand::CancelInvocation { invocation_id })+ }+ None => Err(CommandOutputPlan::error(-32601, "UnknownMethod")),+ }+}++pub(crate) fn try_start_native_command(+ conn: &mut CdpConnection,+ cmd: &Cmd<'_>,+) -> Option<super::native::NativeCommandStep> {+ use moli_core::{+ RendererNativeProtocolResponse as Response, RendererNativeProtocolStateUpdate as Update,+ RendererPageCommand as Command, RendererPageReply as Reply,+ };+ let command = match request(conn, cmd) {+ Ok(command) => command,+ Err(plan) => return Some(super::native::NativeCommandStep::Complete(plan)),+ };+ let enabled = match &command {+ RendererWebMcpCommand::Enable => Some(true),+ RendererWebMcpCommand::Disable => Some(false),+ _ => None,+ };+ let session = DevToolsSessionKey::from_wire_session_id(+ conn.target_renderer_runtime_inspector_session_id_for_session(cmd.session_id)+ .as_deref(),+ );+ Some(super::native::start(+ conn,+ cmd,+ Command::WebMcp { session, command },+ move |reply| match reply {+ Ok(Reply::WebMcp(Ok(id))) => {+ let mut response = Response::success(+ id.map_or_else(|| json!({}), |id| json!({"invocationId": id.to_string()})),+ );+ if let Some(enabled) = enabled {+ response.state_updates.push(Update::WebMcpEnabled(enabled));+ }+ response+ }+ Ok(Reply::WebMcp(Err(error))) => match error {+ RendererWebMcpError::NotEnabled => {+ Response::error(-32000, "WebMCP domain is not enabled")+ }+ RendererWebMcpError::InvalidParams(message) => Response::error(-32602, message),+ RendererWebMcpError::SchedulingFailed => {+ Response::error(-32000, "Tool invocation could not be scheduled")+ }+ },+ Err(error) => Response::error(-32000, error.to_string()),+ _ => unreachable!("WebMCP command reply"),+ },+ ))+}++// Pre-document configuration is replayed when the renderer attaches.+pub(crate) fn command_output_plan(conn: &mut CdpConnection, cmd: &Cmd<'_>) -> CommandOutputPlan {match cmd.parse_action::<WebMcpAction>() {- Some(WebMcpAction::Enable | WebMcpAction::Disable) => CommandOutputPlan::success(),+ Some(action @ (WebMcpAction::Enable | WebMcpAction::Disable)) => {+ let owner = CommandOwnerScope::capture(conn, cmd.session_id);+ conn.with_target_devtools_session_state_for_owner_mut(&owner, |state| {+ state.web_mcp_enabled = action == WebMcpAction::Enable+ });+ CommandOutputPlan::success()+ }+ Some(WebMcpAction::InvokeTool | WebMcpAction::CancelInvocation) => {+ CommandOutputPlan::error(-32000, "NoDocumentLoaded")+ }None => CommandOutputPlan::error(-32601, "UnknownMethod"),}}diff --git a/moli-protocol/src/domains/web_mcp/output.rs b/moli-protocol/src/domains/web_mcp/output.rsnew file mode 100644index 000000000..20832fe07--- /dev/null+++ b/moli-protocol/src/domains/web_mcp/output.rs@@ -0,0 +1,191 @@+use crate::{+ conn::{BackgroundProtocolEvent, CdpConnection, CommandOwnerScope},+ domains::{+ activity::{+ ProtocolOutputPayloads, ProtocolOutputProjectionContext, ProtocolOutputSink,+ ProtocolOutputSlot,+ },+ command_output::protocol_message_background_event,+ },+};+use moli_page_types::{+ RendererWebMcpEvent, RendererWebMcpObservation, RendererWebMcpResult, RendererWebMcpTool,+};+use serde_json::{Value, json};++#[derive(Debug, Default)]+pub(in crate::domains) struct WebMcpPreparedOutputSlot {+ events: Vec<BackgroundProtocolEvent>,+}++impl WebMcpPreparedOutputSlot {+ pub(in crate::domains) fn extend(&mut self, mut other: Self) {+ self.events.append(&mut other.events);+ }+}++pub(in crate::domains) async fn project_async(+ context: &mut ProtocolOutputProjectionContext<'_>,+ payloads: &mut ProtocolOutputPayloads,+) {+ if let Some(slot) = payloads.web_mcp_mut() {+ context+ .command+ .protocol_events_mut()+ .append(&mut slot.events);+ }+}++pub(in crate::domains) fn append_observation(+ conn: &mut CdpConnection,+ owner: &CommandOwnerScope,+ observation: &RendererWebMcpObservation,+ sink: &mut impl ProtocolOutputSink,+) {+ // The producer selected the interested session. Resolve its exact route at+ // ingress, rather than delivering a historical event to a newly enabled one.+ let session_id = conn+ .page_event_session_ids_for_owner(owner)+ .into_iter()+ .find(|session| {+ moli_page_types::DevToolsSessionKey::from_wire_session_id(+ conn.target_renderer_runtime_inspector_session_id_for_session(session.as_deref())+ .as_deref(),+ ) == observation.session+ });+ let Some(session_id) = session_id else {+ return;+ };+ let Some((root, _, _, _)) = conn.target_session_owner_frame_tree_identity_for_owner(owner)+ else {+ return;+ };+ let (method, params) = match &observation.event {+ RendererWebMcpEvent::ToolsAdded(tools) => (+ "WebMCP.toolsAdded",+ json!({"tools": tools.iter().map(|tool| tool_json(tool, &root)).collect::<Vec<_>>()}),+ ),+ RendererWebMcpEvent::ToolsRemoved(tools) => (+ "WebMCP.toolsRemoved",+ json!({"tools": tools.iter().map(|tool| json!({"name":tool.name,"frameId":tool.frame_id.as_ref().unwrap_or(&root)})).collect::<Vec<_>>()}),+ ),+ RendererWebMcpEvent::ToolInvoked {+ tool,+ invocation_id,+ input,+ } => (+ "WebMCP.toolInvoked",+ json!({"toolName":tool.name,"frameId":tool.frame_id.as_ref().unwrap_or(&root),"invocationId":invocation_id.to_string(),"input":input}),+ ),+ RendererWebMcpEvent::ToolResponded {+ invocation_id,+ result,+ } => {+ if let RendererWebMcpResult::Error {+ exception: Some(exception),+ ..+ } = result+ {+ let event_owner = session_id+ .as_deref()+ .map(CommandOwnerScope::for_session)+ .unwrap_or_else(|| owner.clone());+ conn.register_runtime_remote_object_ids_from_value_for_owner(+ &event_owner,+ exception,+ );+ }+ (+ "WebMCP.toolResponded",+ response_json(*invocation_id, result),+ )+ }+ };+ let mut message = json!({"method":method,"params":params});+ if let Some(session_id) = session_id {+ message["sessionId"] = json!(session_id);+ }+ let event = protocol_message_background_event(message);+ sink.push_produced_slot(ProtocolOutputSlot::WebMcp);+ sink.push_prepared_payload(+ WebMcpPreparedOutputSlot {+ events: vec![event],+ }+ .into(),+ );+}++fn response_json(id: u64, result: &RendererWebMcpResult) -> Value {+ let mut params = json!({"invocationId":id.to_string()});+ match result {+ RendererWebMcpResult::Completed(output) => {+ params["status"] = json!("Completed");+ params["output"] = serde_json::from_str(output).unwrap_or_else(|_| json!(output));+ }+ RendererWebMcpResult::Canceled => {+ params["status"] = json!("Canceled");+ params["errorText"] = json!("");+ }+ RendererWebMcpResult::Error { message, exception } => {+ params["status"] = json!("Error");+ params["errorText"] = json!(message);+ if let Some(exception) = exception {+ params["exception"] = exception.clone();+ }+ }+ }+ params+}++fn tool_json(tool: &RendererWebMcpTool, root: &str) -> Value {+ let mut result = json!({"name":tool.name,"description":tool.description,"frameId":tool.frame_id.as_deref().unwrap_or(root)});+ if let Some(schema) = &tool.input_schema+ && let Ok(Value::Object(schema)) = serde_json::from_str(schema)+ {+ result["inputSchema"] = Value::Object(schema);+ }+ if let Some(annotations) = tool.annotations {+ result["annotations"] = json!({"readOnly":annotations.read_only,"consequential":annotations.consequential,"untrustedContent":annotations.untrusted_content,"debugging":annotations.debugging});+ }+ if tool.autosubmit {+ if result.get("annotations").is_none() {+ result["annotations"] = json!({});+ }+ result["annotations"]["autosubmit"] = json!(true);+ }+ if let Some(backend_node_id) = tool.backend_node_id {+ result["backendNodeId"] = json!(backend_node_id);+ }+ if let Some(stack_trace) = &tool.stack_trace {+ result["stackTrace"] = stack_trace.clone();+ }+ result+}++pub(in crate::domains) fn navigation_failed(+ conn: &CdpConnection,+ owner: &CommandOwnerScope,+ id: u64,+) -> Vec<BackgroundProtocolEvent> {+ let params = response_json(id, &RendererWebMcpResult::navigation_failed());+ conn.page_event_session_ids_for_owner(owner)+ .into_iter()+ .filter_map(|session_id| {+ let event_owner = session_id+ .as_deref()+ .map(CommandOwnerScope::for_session)+ .unwrap_or_else(|| owner.clone());+ if !conn+ .target_devtools_session_state_for_owner(&event_owner)+ .is_some_and(|state| state.web_mcp_enabled)+ {+ return None;+ }+ let mut message = json!({"method":"WebMCP.toolResponded","params":params});+ if let Some(session) = session_id {+ message["sessionId"] = json!(session);+ }+ Some(protocol_message_background_event(message))+ })+ .collect()+}diff --git a/moli-protocol/src/domains/web_mcp/tests.rs b/moli-protocol/src/domains/web_mcp/tests.rsnew file mode 100644index 000000000..1f4535857--- /dev/null+++ b/moli-protocol/src/domains/web_mcp/tests.rs@@ -0,0 +1,1072 @@+//! Behavioral ports of Chromium 2d184faab9fb11e1070fb1eeafebf291f6e85923:+//! third_party/blink/web_tests/inspector-protocol/webmcp/invoke-tool.js,+//! cancel-invocation.js, list-tools.js, track-autosubmit.js and+//! invoke-tool-cross-document.js.+//! These adapters use the production CDP scheduler and renderer output fences.++use crate::testing::TestContext;+use serde_json::{Value, json};++async fn page(script: &str) -> TestContext {+ page_at(script, url::Url::parse("https://webmcp.test/").unwrap()).await+}++async fn page_at(script: &str, source_url: url::Url) -> TestContext {+ let mut ctx = TestContext::new_with_target_discovery(false);+ ctx.process_and_wait_for_response_async(+ json!({"id":1,"method":"Target.createTarget","params":{"url":"about:blank"}}),+ )+ .await;+ assert!(ctx.take_response_by_id(1)["result"]["targetId"].is_string());+ ctx.install_buffered_navigation_fixture_for_session_owner(+ source_url,+ format!("<!doctype html><body><script>{script}</script>"),+ None,+ )+ .await;+ ctx.sent.clear();+ ctx+}++async fn command(ctx: &mut TestContext, id: u64, method: &str, params: Value) -> Value {+ session_command(ctx, id, method, params, None).await+}++async fn session_command(+ ctx: &mut TestContext,+ id: u64,+ method: &str,+ params: Value,+ session: Option<&str>,+) -> Value {+ let mut message = json!({"id":id,"method":method,"params":params});+ if let Some(session) = session {+ message["sessionId"] = json!(session);+ }+ ctx.process_and_wait_for_response_async(message).await;+ ctx.sent+ .iter()+ .find(|message| message["id"] == id)+ .expect("command response")+ .clone()+}++async fn event(ctx: &mut TestContext, method: &str) -> Value {+ ctx.wait_for_scheduler_message(method, |message| message["method"] == method)+ .await+}++async fn frame_id(ctx: &mut TestContext) -> String {+ command(ctx, 2, "Page.getFrameTree", json!({})).await["result"]["frameTree"]["frame"]["id"]+ .as_str()+ .unwrap()+ .into()+}++#[tokio::test]+async fn web_mcp_permissions_header_bounds_cross_origin_iframe_delegation() {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let cases = std::sync::Arc::new([+ (None, false, false, "allowed"),+ (+ Some("tools=(self)".to_owned()),+ false,+ false,+ "NotAllowedError",+ ),+ (Some("tools=()".to_owned()), false, false, "NotAllowedError"),+ (Some("tools=*".to_owned()), false, false, "allowed"),+ (+ Some(format!("tools=(self \"http://{address}\")")),+ false,+ false,+ "allowed",+ ),+ (+ Some(format!("tools=(\"http://{address}\")")),+ false,+ false,+ "NotAllowedError",+ ),+ (Some("tools=*".to_owned()), false, true, "NotAllowedError"),+ (Some("tools=(self)".to_owned()), true, false, "allowed"),+ ]);+ let parent_cases = cases.clone();+ let child_cases = cases.clone();+ let server = tokio::spawn(async move {+ let app = axum::Router::new()+ .route("/parent/{case}", axum::routing::get(move |axum::extract::Path(index): axum::extract::Path<usize>| {+ let cases = parent_cases.clone();+ async move {+ let mut headers = axum::http::HeaderMap::new();+ if let Some(header) = &cases[index].0 {+ headers.insert("permissions-policy", header.parse().unwrap());+ }+ (headers, axum::response::Html(format!(r#"<!doctype html><body><script>+ globalThis.childResult = new Promise(resolve => addEventListener('message', event => resolve(event.data), {{once:true}}));+ const frame = document.createElement('iframe');+ frame.allow = 'tools *'; frame.src = 'http://{address}/child/{index}'; document.body.append(frame);+ </script>"#)))+ }+ }))+ .route("/child/{case}", axum::routing::get(move |axum::extract::Path(index): axum::extract::Path<usize>| {+ let cases = child_cases.clone();+ async move {+ let mut headers = axum::http::HeaderMap::new();+ if cases[index].2 {+ headers.insert("permissions-policy", "tools=()".parse().unwrap());+ }+ (headers, axum::response::Html(r#"<!doctype html><script>+ (async () => {+ try {+ await document.modelContext.registerTool({name:'child', description:'Child', execute:()=>42});+ parent.postMessage('allowed', '*');+ } catch (error) { parent.postMessage(error.name, '*'); }+ })();+ </script>"#))+ }+ }));+ axum::serve(listener, app).await.unwrap();+ });+ for (index, (header, same_origin, _, expected)) in cases.iter().enumerate() {+ let mut ctx = page("").await;+ command(&mut ctx, 2, "Page.enable", json!({})).await;+ let host = if *same_origin {+ "127.0.0.1"+ } else {+ "localhost"+ };+ let url = format!("http://{host}:{}/parent/{index}", address.port());+ let reply = command(&mut ctx, 3, "Page.navigate", json!({"url":url})).await;+ assert!(reply["result"].get("errorText").is_none(), "{reply}");+ event(&mut ctx, "Page.loadEventFired").await;+ let result = command(+ &mut ctx,+ 4,+ "Runtime.evaluate",+ json!({+ "expression":"childResult", "awaitPromise":true, "returnByValue":true+ }),+ )+ .await;+ assert_eq!(+ result["result"]["result"]["value"], *expected,+ "{header:?}, same origin: {same_origin}: {result}"+ );+ }+ server.abort();+}++#[tokio::test]+async fn web_mcp_invocation_requires_an_enabled_domain_and_reports_parameter_errors() {+ let mut ctx = page(+ "document.modelContext.registerTool({name:'echo',description:'Echo',execute:()=>42});",+ )+ .await;+ let root = frame_id(&mut ctx).await;+ let input = json!({"frameId":root,"toolName":"echo","input":{}});+ assert_eq!(+ command(&mut ctx, 3, "WebMCP.invokeTool", input.clone()).await["error"],+ json!({"code":-32000,"message":"WebMCP domain is not enabled"})+ );+ command(&mut ctx, 4, "WebMCP.enable", json!({})).await;+ event(&mut ctx, "WebMCP.toolsAdded").await;+ for (id, params, message) in [+ (+ 5,+ json!({"frameId":root,"toolName":"missing","input":{}}),+ "Tool not found",+ ),+ (+ 6,+ json!({"frameId":"missing","toolName":"echo","input":{}}),+ "No frame for given id found",+ ),+ ] {+ assert_eq!(+ command(&mut ctx, id, "WebMCP.invokeTool", params).await["error"],+ json!({"code":-32602,"message":message})+ );+ }+ assert_eq!(+ command(+ &mut ctx,+ 7,+ "WebMCP.cancelInvocation",+ json!({"invocationId":"18446744073709551615"})+ )+ .await["error"],+ json!({"code":-32602,"message":"No pending execution for invocation id"})+ );+ command(&mut ctx, 8, "WebMCP.disable", json!({})).await;+ assert_eq!(+ command(&mut ctx, 9, "WebMCP.invokeTool", input).await["error"]["code"],+ -32000+ );+}++#[tokio::test]+async fn web_mcp_invocation_uses_the_callback_realm_for_arguments() {+ let mut ctx = page(+ r#"+ const frame = document.createElement('iframe');+ document.body.append(frame);+ document.modelContext.registerTool({+ name: 'realm', description: 'Callback in another realm',+ execute: frame.contentWindow.eval(`async (input, options) => ({+ root: Object.getPrototypeOf(input) === Object.prototype,+ nested: Object.getPrototypeOf(input.nested) === Object.prototype,+ array: Object.getPrototypeOf(input.items) === Array.prototype,+ element: Object.getPrototypeOf(input.items[0]) === Object.prototype,+ options: Object.getPrototypeOf(options) === Object.prototype,+ signal: options.signal instanceof parent.AbortSignal+ })`)+ });+ "#,+ )+ .await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ event(&mut ctx, "WebMCP.toolsAdded").await;+ let reply = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"realm","input":{"nested":{},"items":[{}]}}),+ )+ .await;+ assert!(reply.get("error").is_none(), "{reply}");+ let response = event(&mut ctx, "WebMCP.toolResponded").await;+ assert_eq!(+ response["params"]["invocationId"],+ reply["result"]["invocationId"]+ );+ assert_eq!(response["params"]["status"], "Completed");+ assert_eq!(+ response["params"]["output"],+ json!({"root":true,"nested":true,"array":true,"element":true,"options":true,"signal":true})+ );+ assert_eq!(+ command(+ &mut ctx,+ 5,+ "WebMCP.cancelInvocation",+ json!({"invocationId":reply["result"]["invocationId"]})+ )+ .await["error"]["message"],+ "No pending execution for invocation id"+ );+}++#[tokio::test]+async fn web_mcp_result_serialization_exception_remains_inspectable() {+ let mut ctx = page("document.modelContext.registerTool({name:'serialize',description:'Throw from toJSON',execute:()=>({toJSON(){throw new TypeError('serialization failed')}})});").await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ event(&mut ctx, "WebMCP.toolsAdded").await;+ let reply = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"serialize","input":{}}),+ )+ .await;+ let response = event(&mut ctx, "WebMCP.toolResponded").await;+ assert_eq!(+ response["params"]["invocationId"],+ reply["result"]["invocationId"]+ );+ assert_eq!(response["params"]["status"], "Error");+ assert!(response["params"].get("output").is_none());+ let exception = &response["params"]["exception"];+ assert_eq!(exception["className"], "TypeError");+ assert!(+ exception["description"]+ .as_str()+ .unwrap()+ .contains("serialization failed")+ );+ let properties = command(+ &mut ctx,+ 5,+ "Runtime.getProperties",+ json!({"objectId":exception["objectId"],"ownProperties":true}),+ )+ .await;+ assert!(properties.get("error").is_none(), "{properties}");+ assert!(+ properties["result"]["result"]+ .as_array()+ .unwrap()+ .iter()+ .any(|property| property["name"] == "message"+ && property["value"]["value"] == "serialization failed")+ );+}++#[tokio::test]+async fn web_mcp_registration_stack_trace_is_retained_for_later_enable() {+ let script = r#"+ function registerFromCallsite() {+ document.modelContext.registerTool({name:'located',description:'Registration location',execute:()=>42});+ }+ registerFromCallsite();+ //# sourceURL=https://webmcp.test/tools.js+ "#;+ let mut ctx = page(script).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ let added = event(&mut ctx, "WebMCP.toolsAdded").await;+ let frames = added["params"]["tools"][0]["stackTrace"]["callFrames"]+ .as_array()+ .expect("registration stack");+ assert!(frames.len() >= 2, "{frames:?}");+ assert_eq!(frames[0]["functionName"], "registerFromCallsite");+ assert_eq!(frames[0]["url"], "https://webmcp.test/tools.js");+ assert_eq!(+ frames[0]["lineNumber"],+ script+ .lines()+ .position(|line| line.contains("document.modelContext.registerTool"))+ .unwrap()+ );+ assert!(frames[0]["columnNumber"].is_u64());+ assert!(+ frames[0]["scriptId"]+ .as_str()+ .unwrap()+ .parse::<u64>()+ .unwrap()+ > 0+ );+}++async fn assert_navigation_result(topology: &str, destination: &str) {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ let server = tokio::spawn(async move {+ axum::serve(listener, axum::Router::new().route("/result", axum::routing::any(|| async {+ axum::response::Html(r#"<!doctype html><body>+ <script type="application/ld+json">{"cross-document":"success"}</script>+ <script type="application/ld+json">malformed</script>+ <script type="application/ld+json">/* comment */ {"url":"https://example.test/","escaped":"\\\"//"}</script>+ <script type="APPLICATION/LD+JSON">{"ignored":true}</script>+ <script>document.addEventListener('DOMContentLoaded',()=>{+ document.querySelector('script').textContent='{"too-late":true}';+ });</script>"#)+ })).route("/replace", axum::routing::get(|| async {+ axum::response::Html(r#"<!doctype html><script defer src="/hold.js"></script><script>+ const channel=new MessageChannel();+ channel.port1.onmessage=()=>{+ document.open();document.write('<script type="application/ld+json">{"wrong-document":true}<\/script>');document.close();+ };+ channel.port2.postMessage('replace');+ </script>"#)+ })).route("/blocked_result", axum::routing::get(|| async {+ axum::response::Html(r#"<!doctype html><script defer src="/hold.js"></script>+ <script type="application/ld+json">{"must-not-return":true}</script>"#)+ })).route("/hold.js", axum::routing::get(|| async {+ // DCL remains blocked. Cross-origin tool results must fail at+ // commit without waiting for this resource; replacement retires it.+ std::future::pending::<axum::response::Html<&'static str>>().await+ })).route("/sandbox", axum::routing::get(|| async {+ ([("Content-Security-Policy", "sandbox allow-scripts")], axum::response::Html(r#"<!doctype html><script type="application/ld+json">{"sandboxed":true}</script>"#))+ })).route("/empty", axum::routing::get(|| async { axum::http::StatusCode::NO_CONTENT }))+ .route("/same_redirect", axum::routing::get(|| async {axum::response::Redirect::temporary("/result")}))+ .route("/cross_redirect", axum::routing::get(move || async move {axum::response::Redirect::temporary(&format!("http://localhost:{}/result", address.port()))}))+ .route("/reset", axum::routing::get(|| async { axum::http::StatusCode::RESET_CONTENT }))).await.unwrap();+ });+ let target = match topology {+ "named_child" => "target=result",+ "named_child_post" => "target=result method=post",+ "top" => "target=_top",+ "parent" | "child_parent" | "nested_parent" => "target=_parent",+ "parent_post" | "child_parent_post" | "nested_parent_post" => "target=_PARENT method=post",+ "child_self_post" => "target=_self method=post",+ _ => "",+ };+ let action = if destination == "cross_blocked" {+ format!("http://localhost:{}/blocked_result", address.port())+ } else if destination == "cross_origin" {+ format!("http://localhost:{}/result", address.port())+ } else {+ format!("http://{address}/{destination}")+ };+ let form = json!(format!(+ r#"<form toolname=navigate_tool tooldescription=Navigate toolautosubmit {target} action="{action}"><input name=text></form>"#+ ));+ let source = if matches!(topology, "nested_parent" | "nested_parent_post") {+ format!(+ "const outer=document.createElement('iframe');document.body.append(outer);const child=outer.contentDocument.createElement('iframe');child.srcdoc={form};outer.contentDocument.body.append(child);"+ )+ } else if matches!(+ topology,+ "child_self" | "child_parent" | "child_self_post" | "child_parent_post"+ ) {+ format!(+ "const child=document.createElement('iframe');child.srcdoc={form};document.body.append(child);"+ )+ } else {+ format!(+ "document.body.innerHTML={form};{}",+ if matches!(topology, "named_child" | "named_child_post") {+ "const child=document.createElement('iframe');child.name='result';document.body.append(child);"+ } else {+ ""+ }+ )+ };+ let source_url = format!("http://{address}/source");+ let mut ctx = page_at(&source, url::Url::parse(&source_url).unwrap()).await;+ command(+ &mut ctx,+ 2,+ "Runtime.evaluate",+ json!({"expression":"globalThis.retainedDocument=document"}),+ )+ .await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ let added = event(&mut ctx, "WebMCP.toolsAdded").await;+ let frame = added["params"]["tools"][0]["frameId"].as_str().unwrap();+ let reply = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":frame,"toolName":"navigate_tool","input":{"text":"unused"}}),+ )+ .await;+ let invocation = reply["result"]["invocationId"].as_str().unwrap();+ let response = event(&mut ctx, "WebMCP.toolResponded").await;+ if matches!(destination, "result" | "same_redirect") {+ assert_eq!(+ response["params"],+ json!({"invocationId":invocation,"status":"Completed","output":[+ {"cross-document":"success"},{"url":"https://example.test/","escaped":"\\\"//"}+ ]})+ );+ } else {+ assert_eq!(response["params"]["invocationId"], invocation);+ assert_eq!(response["params"]["status"], "Error");+ assert!(response["params"].get("output").is_none());+ if matches!(+ destination,+ "cross_origin" | "cross_blocked" | "cross_redirect" | "sandbox"+ ) {+ assert_eq!(+ response["params"]["errorText"],+ "Cannot return tool results after a cross-origin navigation"+ );+ }+ }+ if matches!(destination, "empty" | "reset") {+ let retained = command(&mut ctx, 5, "Runtime.evaluate", json!({+ "expression": format!("document===retainedDocument && location.href==='{source_url}' && \+ document.querySelector('form input').value==='unused' && \+ !document.querySelector('form').matches(':tool-form-active')"),+ "returnByValue":true+ })).await;+ assert_eq!(retained["result"]["result"]["value"], true);+ assert!(+ !ctx.sent+ .iter()+ .any(|message| message["method"] == "WebMCP.toolsRemoved")+ );+ }+ assert_eq!(+ ctx.sent+ .iter()+ .filter(|message| message["method"] == "WebMCP.toolResponded"+ && message["params"]["invocationId"] == invocation)+ .count(),+ 0+ );+ server.abort();+}++#[tokio::test]+async fn web_mcp_chromium_cross_document_navigation_returns_destination_json_ld() {+ assert_navigation_result("root", "result").await;+}++#[tokio::test]+async fn web_mcp_named_child_navigation_returns_destination_json_ld() {+ assert_navigation_result("named_child", "result").await;+}++#[tokio::test]+async fn web_mcp_parsed_child_form_navigation_returns_destination_json_ld() {+ assert_navigation_result("child_self", "result").await;+}++#[tokio::test]+async fn web_mcp_top_target_navigation_returns_destination_json_ld() {+ assert_navigation_result("top", "result").await;+}++#[tokio::test]+async fn web_mcp_navigation_rejects_replaced_destination_document() {+ assert_navigation_result("root", "replace").await;+ assert_navigation_result("named_child", "replace").await;+}++#[tokio::test]+async fn web_mcp_navigation_without_destination_document_reports_error() {+ for destination in ["empty", "reset"] {+ assert_navigation_result("root", destination).await;+ assert_navigation_result("named_child", destination).await;+ }+}++#[tokio::test]+async fn web_mcp_form_navigation_binds_resolved_targets_for_get_and_post() {+ for topology in [+ "parent",+ "child_parent",+ "nested_parent",+ "parent_post",+ "child_parent_post",+ "nested_parent_post",+ "child_self_post",+ "named_child_post",+ ] {+ assert_navigation_result(topology, "result").await;+ }+}++#[tokio::test]+async fn web_mcp_navigation_results_require_the_original_origin_after_redirects() {+ for topology in ["root", "named_child", "child_self", "parent"] {+ for destination in [+ "cross_blocked",+ "cross_origin",+ "cross_redirect",+ "same_redirect",+ "sandbox",+ ] {+ assert_navigation_result(topology, destination).await;+ }+ }+}++#[tokio::test]+async fn web_mcp_chromium_declarative_autosubmit_changes_and_backend_node() {+ let mut ctx = page(r#"+ document.body.innerHTML = '<form id="declarative" toolname="declarative_tool" tooldescription="A declarative WebMCP tool"><input name="text"></form>';+ "#).await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ let added = event(&mut ctx, "WebMCP.toolsAdded").await;+ let tool = &added["params"]["tools"][0];+ assert_eq!(tool["name"], "declarative_tool");+ assert_eq!(tool["frameId"], root);+ assert_eq!(+ tool["inputSchema"],+ json!({"type":"object","properties":{"text":{"type":"string"}},"required":[]})+ );+ assert!(tool.get("annotations").is_none());+ let backend = tool["backendNodeId"]+ .as_u64()+ .expect("native form backend node");+ let resolved = command(+ &mut ctx,+ 4,+ "DOM.resolveNode",+ json!({"backendNodeId":backend}),+ )+ .await;+ let object_id = resolved["result"]["object"]["objectId"].as_str().unwrap();+ let description = command(&mut ctx,5,"Runtime.callFunctionOn",json!({"objectId":object_id,"functionDeclaration":"function(){return this.tagName+'|'+this.id}","returnByValue":true})).await;+ assert_eq!(description["result"]["result"]["value"], "FORM|declarative");+ for (id, expression, autosubmit) in [+ (+ 6,+ "document.getElementById('declarative').setAttribute('toolautosubmit','')",+ true,+ ),+ (+ 7,+ "document.getElementById('declarative').removeAttribute('toolautosubmit')",+ false,+ ),+ ] {+ command(+ &mut ctx,+ id,+ "Runtime.evaluate",+ json!({"expression":expression}),+ )+ .await;+ assert_eq!(+ event(&mut ctx, "WebMCP.toolsRemoved").await["params"]["tools"],+ json!([{"name":"declarative_tool","frameId":root}])+ );+ let added = event(&mut ctx, "WebMCP.toolsAdded").await;+ let tool = &added["params"]["tools"][0];+ assert_eq!(tool["backendNodeId"], backend);+ assert_eq!(+ tool["annotations"]["autosubmit"].as_bool().unwrap_or(false),+ autosubmit+ );+ }+}++#[tokio::test]+async fn web_mcp_declarative_cdp_invocation_fills_native_controls_and_returns_response() {+ let mut ctx = page(r#"+ document.body.innerHTML = '<form toolautosubmit toolname="echo_form" tooldescription="Echo form"><input name="text" required></form>';+ document.querySelector('form').addEventListener('submit',e=>{+ e.preventDefault();e.respondWith(Promise.resolve({agent:e.agentInvoked,text:e.target.elements.text.value}));+ });+ "#).await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ event(&mut ctx, "WebMCP.toolsAdded").await;+ let reply = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"echo_form","input":{"text":"hello"}}),+ )+ .await;+ let invocation = reply["result"]["invocationId"].as_str().unwrap();+ assert_eq!(+ event(&mut ctx, "WebMCP.toolInvoked").await["params"]["invocationId"],+ invocation+ );+ assert_eq!(+ event(&mut ctx, "WebMCP.toolResponded").await["params"],+ json!({+ "invocationId":invocation,"status":"Completed","output":{"agent":true,"text":"hello"}+ })+ );+ let reply = command(+ &mut ctx,+ 5,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"echo_form","input":{"unknown":"invalid"}}),+ )+ .await;+ let invocation = reply["result"]["invocationId"].as_str().unwrap();+ event(&mut ctx, "WebMCP.toolInvoked").await;+ let response = event(&mut ctx, "WebMCP.toolResponded").await;+ assert_eq!(response["params"]["invocationId"], invocation);+ assert_eq!(response["params"]["status"], "Error");+ assert!(response["params"].get("exception").is_none());+ assert!(+ response["params"]["errorText"]+ .as_str()+ .is_some_and(|text| !text.is_empty())+ );+}++#[tokio::test]+async fn web_mcp_chromium_list_imperative_tools_replays_and_tracks_changes() {+ let mut ctx = page(r#"+ globalThis.initialController = new AbortController();+ document.modelContext.registerTool({name:'initial_imperative_tool',description:'An imperative WebMCP tool',execute:obj=>obj.text,annotations:{readOnlyHint:true}}, {signal:initialController.signal});+ "#).await;+ let root = frame_id(&mut ctx).await;+ assert_eq!(+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await["result"],+ json!({})+ );+ let added = event(&mut ctx, "WebMCP.toolsAdded").await;+ let mut tools = added["params"]["tools"].clone();+ let stack = tools[0]+ .as_object_mut()+ .unwrap()+ .remove("stackTrace")+ .expect("registration stack");+ assert!(!stack["callFrames"].as_array().unwrap().is_empty());+ assert_eq!(+ tools,+ json!([{"name":"initial_imperative_tool","description":"An imperative WebMCP tool","frameId":root,"annotations":{"readOnly":true,"consequential":false,"untrustedContent":false,"debugging":false}}])+ );+ command(&mut ctx, 4, "Runtime.evaluate", json!({"expression":"document.modelContext.registerTool({name:'new_imperative_tool',description:'Another imperative tool',execute: obj => obj.text,inputSchema:{type:'object',properties:{text:{type:'string'}},required:['text']}})","awaitPromise":true})).await;+ let added = event(&mut ctx, "WebMCP.toolsAdded").await;+ assert_eq!(added["params"]["tools"][0]["name"], "new_imperative_tool");+ assert_eq!(+ added["params"]["tools"][0]["inputSchema"]["required"],+ json!(["text"])+ );+ assert!(added["params"]["tools"][0].get("annotations").is_none());+ command(+ &mut ctx,+ 5,+ "Runtime.evaluate",+ json!({"expression":"initialController.abort()"}),+ )+ .await;+ assert_eq!(+ event(&mut ctx, "WebMCP.toolsRemoved").await["params"],+ json!({"tools":[{"name":"initial_imperative_tool","frameId":root}]})+ );+ command(&mut ctx, 6, "WebMCP.disable", json!({})).await;+ command(&mut ctx, 7, "Runtime.evaluate", json!({"expression":"document.modelContext.registerTool({name:'newer_imperative_tool',description:'Another imperative tool',execute:()=>{}})","awaitPromise":true})).await;+ assert!(+ ctx.sent+ .iter()+ .all(|message| message["method"] != "WebMCP.toolsAdded")+ );+ command(&mut ctx, 8, "WebMCP.enable", json!({})).await;+ let replay = event(&mut ctx, "WebMCP.toolsAdded").await;+ assert_eq!(replay["params"]["tools"].as_array().unwrap().len(), 2);+}++#[tokio::test]+async fn web_mcp_chromium_invoke_returns_id_before_events_and_preserves_failure_exception() {+ let mut ctx = page(r#"+ document.modelContext.registerTool({name:'test_tool',description:'A test WebMCP tool',execute:async obj=>obj.text});+ document.modelContext.registerTool({name:'failing_tool',description:'A failing WebMCP tool',execute:async()=>{throw new Error('This tool always fails')}});+ "#).await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ event(&mut ctx, "WebMCP.toolsAdded").await;+ let reply = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"test_tool","input":{"text":"hello world"}}),+ )+ .await;+ let invocation = reply["result"]["invocationId"].as_str().unwrap();+ let response_position = ctx+ .sent+ .iter()+ .position(|message| message["id"] == 4)+ .unwrap();+ for method in ["WebMCP.toolInvoked", "WebMCP.toolResponded"] {+ if let Some(position) = ctx+ .sent+ .iter()+ .position(|message| message["method"] == method)+ {+ assert!(+ response_position < position,+ "invoke response must precede {method}: {:?}",+ ctx.sent+ );+ }+ }+ let invoked = event(&mut ctx, "WebMCP.toolInvoked").await;+ assert_eq!(invoked["params"]["invocationId"], invocation);+ assert_eq!(invoked["params"]["input"], r#"{"text":"hello world"}"#);+ assert!(+ ctx.sent.iter().any(|message| message["id"] == 4),+ "response is delivered before invocation event"+ );+ let result = event(&mut ctx, "WebMCP.toolResponded").await;+ assert_eq!(+ result["params"],+ json!({"invocationId":invocation,"status":"Completed","output":"hello world"})+ );+ assert_eq!(+ command(+ &mut ctx,+ 5,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"nonexistent_tool","input":{}})+ )+ .await["error"]["message"],+ "Tool not found"+ );+ assert_eq!(+ command(+ &mut ctx,+ 6,+ "WebMCP.invokeTool",+ json!({"frameId":"invalid_frame_id","toolName":"test_tool","input":{}})+ )+ .await["error"]["message"],+ "No frame for given id found"+ );+ let reply = command(+ &mut ctx,+ 7,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"failing_tool","input":{}}),+ )+ .await;+ let result = event(&mut ctx, "WebMCP.toolResponded").await;+ assert_eq!(+ result["params"]["invocationId"],+ reply["result"]["invocationId"]+ );+ assert_eq!(result["params"]["status"], "Error");+ assert_eq!(result["params"]["exception"]["className"], "Error");+ assert!(+ result["params"]["exception"]["description"]+ .as_str()+ .unwrap()+ .contains("This tool always fails")+ );+ let object = result["params"]["exception"]["objectId"].as_str().unwrap();+ let properties = command(+ &mut ctx,+ 8,+ "Runtime.getProperties",+ json!({"objectId":object,"ownProperties":true}),+ )+ .await;+ assert!(+ properties.get("error").is_none(),+ "exception remains inspectable: {properties}"+ );+}++#[tokio::test]+async fn web_mcp_chromium_cancel_rejects_invalid_and_repeated_ids_and_ignores_late_result() {+ let mut ctx = page(r#"+ globalThis.aborted = 0;+ document.modelContext.registerTool({name:'test_tool',description:'A test WebMCP tool',execute:(input,options)=>new Promise(resolve=>{options.signal.onabort=()=>{aborted++;resolve('late result')}})});+ "#).await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ let reply = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"test_tool","input":{}}),+ )+ .await;+ let id = reply["result"]["invocationId"].as_str().unwrap();+ event(&mut ctx, "WebMCP.toolInvoked").await;+ assert_eq!(+ command(+ &mut ctx,+ 5,+ "WebMCP.cancelInvocation",+ json!({"invocationId":"invalid-id"})+ )+ .await["error"]["message"],+ "Invalid invocation id"+ );+ assert_eq!(+ command(+ &mut ctx,+ 6,+ "WebMCP.cancelInvocation",+ json!({"invocationId":id})+ )+ .await["result"],+ json!({})+ );+ assert_eq!(+ command(+ &mut ctx,+ 7,+ "WebMCP.cancelInvocation",+ json!({"invocationId":id})+ )+ .await["error"]["message"],+ "No pending execution for invocation id"+ );+ assert_eq!(+ event(&mut ctx, "WebMCP.toolResponded").await["params"],+ json!({"invocationId":id,"status":"Canceled","errorText":""})+ );+ assert_eq!(+ command(+ &mut ctx,+ 8,+ "Runtime.evaluate",+ json!({"expression":"aborted","returnByValue":true})+ )+ .await["result"]["result"]["value"],+ 1+ );+ assert!(+ ctx.sent+ .iter()+ .all(|message| message["method"] != "WebMCP.toolResponded")+ );+}++#[tokio::test]+async fn web_mcp_enable_survives_document_replacement_and_ids_are_not_reused() {+ let script = "document.modelContext.registerTool({name:'wait',description:'pending',execute:()=>new Promise(()=>{})});";+ let mut ctx = page(script).await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ let first = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"wait","input":{}}),+ )+ .await;+ event(&mut ctx, "WebMCP.toolInvoked").await;+ ctx.sent.clear();+ ctx.install_buffered_navigation_fixture_for_session_owner(+ url::Url::parse("https://webmcp.test/next").unwrap(),+ format!("<!doctype html><script>{script}</script>"),+ None,+ )+ .await;+ let replay = event(&mut ctx, "WebMCP.toolsAdded").await;+ let root = replay["params"]["tools"][0]["frameId"].as_str().unwrap();+ let second = command(+ &mut ctx,+ 5,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"wait","input":{}}),+ )+ .await;+ assert_ne!(+ first["result"]["invocationId"],+ second["result"]["invocationId"]+ );+ assert_eq!(+ command(+ &mut ctx,+ 6,+ "WebMCP.cancelInvocation",+ json!({"invocationId":first["result"]["invocationId"]})+ )+ .await["error"]["message"],+ "No pending execution for invocation id"+ );+ assert_eq!(+ command(+ &mut ctx,+ 7,+ "WebMCP.cancelInvocation",+ json!({"invocationId":second["result"]["invocationId"]})+ )+ .await["result"],+ json!({})+ );+}++#[tokio::test]+async fn web_mcp_document_open_removes_tools_and_finishes_pending_invocations_once() {+ let mut ctx = page(r#"+ document.modelContext.registerTool({name:'wait',description:'pending',execute:(input,{signal})=>{+ globalThis.savedSignal = signal;+ return new Promise(resolve=>signal.addEventListener('abort',()=>resolve('late')));+ }});+ "#).await;+ let root = frame_id(&mut ctx).await;+ command(&mut ctx, 3, "WebMCP.enable", json!({})).await;+ event(&mut ctx, "WebMCP.toolsAdded").await;+ let reply = command(+ &mut ctx,+ 4,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"wait","input":{}}),+ )+ .await;+ let invocation = &reply["result"]["invocationId"];+ event(&mut ctx, "WebMCP.toolInvoked").await;+ command(&mut ctx, 5, "Runtime.evaluate", json!({"expression":"document.open(); document.write('<!doctype html><body>new</body>'); document.close();"})).await;+ assert_eq!(+ event(&mut ctx, "WebMCP.toolsRemoved").await["params"],+ json!({"tools":[{"name":"wait","frameId":root}]})+ );+ assert_eq!(+ event(&mut ctx, "WebMCP.toolResponded").await["params"],+ json!({"invocationId":invocation,"status":"Error","errorText":"Tool document is no longer active"})+ );+ // Retirement emits the protocol result before its browser task aborts the+ // signal. Wait for that task's effect rather than racing Runtime.evaluate.+ assert_eq!(+ command(+ &mut ctx,+ 6,+ "Runtime.evaluate",+ json!({"expression":"savedSignal.aborted ? true : new Promise(resolve => savedSignal.addEventListener('abort', () => resolve(savedSignal.aborted), {once:true}))","returnByValue":true,"awaitPromise":true})+ )+ .await["result"]["result"]["value"],+ true+ );+ assert_eq!(+ command(+ &mut ctx,+ 7,+ "WebMCP.cancelInvocation",+ json!({"invocationId":invocation})+ )+ .await["error"]["message"],+ "No pending execution for invocation id"+ );+ command(&mut ctx, 8, "Runtime.evaluate", json!({"expression":"document.modelContext.registerTool({name:'wait',description:'new',execute:()=> 'new'})","awaitPromise":true})).await;+ assert_eq!(+ event(&mut ctx, "WebMCP.toolsAdded").await["params"]["tools"][0]["description"],+ "new"+ );+ let reply = command(+ &mut ctx,+ 9,+ "WebMCP.invokeTool",+ json!({"frameId":root,"toolName":"wait","input":{}}),+ )+ .await;+ event(&mut ctx, "WebMCP.toolInvoked").await;+ assert_eq!(+ event(&mut ctx, "WebMCP.toolResponded").await["params"],+ json!({"invocationId":reply["result"]["invocationId"],"status":"Completed","output":"new"})+ );+ assert!(+ ctx.sent+ .iter()+ .all(|message| message["method"] != "WebMCP.toolResponded")+ );+}++#[tokio::test]+async fn web_mcp_sessions_receive_only_their_enabled_events_and_own_replays() {+ let mut ctx = page("").await;+ let targets = command(&mut ctx, 2, "Target.getTargets", json!({})).await;+ let target = targets["result"]["targetInfos"]+ .as_array()+ .unwrap()+ .iter()+ .find(|target| target["type"] == "page")+ .unwrap()["targetId"]+ .clone();+ let first = command(+ &mut ctx,+ 3,+ "Target.attachToTarget",+ json!({"targetId":target,"flatten":true}),+ )+ .await;+ let first = first["result"]["sessionId"].as_str().unwrap();+ let second = command(+ &mut ctx,+ 4,+ "Target.attachToTarget",+ json!({"targetId":target,"flatten":true}),+ )+ .await;+ let second = second["result"]["sessionId"].as_str().unwrap();+ assert_ne!(first, second);+ ctx.sent.clear();+ assert_eq!(+ session_command(&mut ctx, 5, "WebMCP.enable", json!({}), Some(first)).await["result"],+ json!({})+ );+ session_command(&mut ctx, 6, "Runtime.evaluate", json!({"expression":"document.modelContext.registerTool({name:'first',description:'first',execute:()=>{}})","awaitPromise":true}), Some(second)).await;+ assert_eq!(+ event(&mut ctx, "WebMCP.toolsAdded").await["sessionId"],+ first+ );+ assert_eq!(+ session_command(&mut ctx, 7, "WebMCP.enable", json!({}), Some(second)).await["result"],+ json!({})+ );+ let replay = event(&mut ctx, "WebMCP.toolsAdded").await;+ assert_eq!(replay["sessionId"], second);+ assert_eq!(replay["params"]["tools"][0]["name"], "first");+ session_command(&mut ctx, 8, "WebMCP.disable", json!({}), Some(first)).await;+ session_command(&mut ctx, 9, "Runtime.evaluate", json!({"expression":"document.modelContext.registerTool({name:'second',description:'second',execute:()=>{}})","awaitPromise":true}), Some(first)).await;+ let added = event(&mut ctx, "WebMCP.toolsAdded").await;+ assert_eq!(added["sessionId"], second);+ assert_eq!(added["params"]["tools"][0]["name"], "second");+ assert!(+ ctx.sent+ .iter()+ .all(|message| message["method"] != "WebMCP.toolsAdded")+ );+}+mod permissions;diff --git a/moli-protocol/src/domains/web_mcp/tests/permissions.rs b/moli-protocol/src/domains/web_mcp/tests/permissions.rsnew file mode 100644index 000000000..5a1c8544b--- /dev/null+++ b/moli-protocol/src/domains/web_mcp/tests/permissions.rs@@ -0,0 +1,208 @@+use super::*;++#[tokio::test]+async fn web_mcp_permissions_use_the_committed_origin_after_redirects_and_sandboxing() {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let address = listener.local_addr().unwrap();+ // Header, source, container allowlist, iframe sandbox, response sandbox,+ // nested initial about:blank, expected registration result.+ let cases = std::sync::Arc::new([+ (+ Some("tools=(self)"),+ "/redirect",+ Some("tools *"),+ None,+ false,+ false,+ "NotAllowedError",+ ),+ (+ Some("tools=(self)"),+ "/child",+ None,+ Some("allow-scripts"),+ false,+ false,+ "NotAllowedError",+ ),+ (+ None,+ "/child",+ None,+ Some("allow-scripts"),+ false,+ false,+ "NotAllowedError",+ ),+ (+ Some("tools=(self)"),+ "/child",+ Some("tools *"),+ Some("allow-scripts"),+ false,+ false,+ "NotAllowedError",+ ),+ (+ None,+ "/child",+ Some("tools *"),+ Some("allow-scripts"),+ false,+ false,+ "allowed",+ ),+ (+ Some("tools=*"),+ "/child",+ Some("tools *"),+ Some("allow-scripts"),+ false,+ false,+ "allowed",+ ),+ (+ Some("tools=(self)"),+ "/child",+ None,+ Some("allow-scripts allow-same-origin"),+ false,+ false,+ "allowed",+ ),+ (None, "/child", None, None, false, true, "allowed"),+ (+ Some("tools=(self)"),+ "/child",+ Some("tools *"),+ None,+ true,+ false,+ "NotAllowedError",+ ),+ (+ None,+ "/child",+ Some("tools *"),+ None,+ true,+ false,+ "allowed",+ ),+ (+ None,+ "/redirect",+ Some("tools 'src'"),+ None,+ false,+ false,+ "NotAllowedError",+ ),+ (+ None,+ "/redirect",+ Some("tools"),+ None,+ false,+ false,+ "NotAllowedError",+ ),+ (+ None,+ "/redirect",+ Some("tools *"),+ None,+ false,+ false,+ "allowed",+ ),+ (+ Some("tools=(self)"),+ "/return",+ None,+ None,+ false,+ false,+ "allowed",+ ),+ ]);+ let parent_cases = cases.clone();+ let child_cases = cases.clone();+ let server = tokio::spawn(async move {+ let app = axum::Router::new()+ .route("/parent/{case}", axum::routing::get(move |axum::extract::Path(index): axum::extract::Path<usize>| {+ let cases = parent_cases.clone();+ async move {+ let (header, source, allow, sandbox, _, nested, _) = cases[index];+ let mut headers = axum::http::HeaderMap::new();+ if let Some(header) = header { headers.insert("permissions-policy", header.parse().unwrap()); }+ let source = if source == "/return" {+ format!("http://{address}/return/{index}")+ } else {+ format!("{source}/{index}")+ };+ (headers, axum::response::Html(format!(r#"<!doctype html><body><script>+ globalThis.childResult=new Promise(resolve=>addEventListener('message',event=>resolve(event.data),{{once:true}}));+ const frame=document.createElement('iframe');+ const allow={allow}; const sandbox={sandbox};+ if (allow!==null) frame.allow=allow;+ if (sandbox!==null) frame.setAttribute('sandbox',sandbox);+ if ({nested}) {{+ document.body.append(frame);+ const grandchild=frame.contentDocument.createElement('iframe');+ grandchild.src=new URL({source},location.href).href;+ frame.contentDocument.body.append(grandchild);+ }} else {{ frame.src={source}; document.body.append(frame); }}+ </script>"#,+ allow=json!(allow), sandbox=json!(sandbox), nested=nested, source=json!(source))))+ }+ }))+ .route("/redirect/{case}", axum::routing::get(move |axum::extract::Path(index): axum::extract::Path<usize>| async move {+ axum::response::Redirect::temporary(&format!("http://{address}/child/{index}"))+ }))+ .route("/return/{case}", axum::routing::get(move |axum::extract::Path(index): axum::extract::Path<usize>| async move {+ axum::response::Redirect::temporary(&format!("http://localhost:{}/child/{index}",address.port()))+ }))+ .route("/child/{case}", axum::routing::get(move |axum::extract::Path(index): axum::extract::Path<usize>| {+ let cases=child_cases.clone();+ async move {+ let mut headers=axum::http::HeaderMap::new();+ if cases[index].4 { headers.insert("content-security-policy","sandbox allow-scripts".parse().unwrap()); }+ (headers, axum::response::Html(r#"<!doctype html><script>+ (async()=>{+ try {+ await document.modelContext.registerTool({name:'child',description:'Child',execute:()=>42});+ top.postMessage('allowed','*');+ } catch (error) { top.postMessage(error.name,'*'); }+ })();+ </script>"#))+ }+ }));+ axum::serve(listener, app).await.unwrap();+ });+ for (index, case) in cases.iter().enumerate() {+ let mut ctx = page("").await;+ command(&mut ctx, 2, "Page.enable", json!({})).await;+ let reply = command(+ &mut ctx,+ 3,+ "Page.navigate",+ json!({"url":format!("http://localhost:{}/parent/{index}",address.port())}),+ )+ .await;+ assert!(reply["result"].get("errorText").is_none(), "{reply}");+ event(&mut ctx, "Page.loadEventFired").await;+ let result = command(+ &mut ctx,+ 4,+ "Runtime.evaluate",+ json!({"expression":"childResult","awaitPromise":true,"returnByValue":true}),+ )+ .await;+ assert_eq!(+ result["result"]["result"]["value"], case.6,+ "case {index}: {case:?}: {result}"+ );+ }+ server.abort();+}diff --git a/moli-renderer-v8/Cargo.toml b/moli-renderer-v8/Cargo.tomlindex 83b885235..7c20cddc8 100644--- a/moli-renderer-v8/Cargo.toml+++ b/moli-renderer-v8/Cargo.toml@@ -89,6 +89,7 @@ moli-webcrypto = { path = "../moli-webcrypto" }moli-webapi-declare = { path = "../moli-webapi-declare" }moli-webidl = { path = "../moli-webidl" }moli-webidl-callback = { path = "../moli-webidl-callback" }+moli-webmcp = { path = "../moli-webmcp" }moli-window-features = { path = "../moli-window-features" }moli-websocket = { path = "../moli-websocket" }moli-xpath = { path = "../moli-xpath" }diff --git a/moli-renderer-v8/src/abort_signal_route.rs b/moli-renderer-v8/src/abort_signal_route.rsindex 1e21937a5..dfe903988 100644--- a/moli-renderer-v8/src/abort_signal_route.rs+++ b/moli-renderer-v8/src/abort_signal_route.rs@@ -64,6 +64,21 @@ impl<'s> ResolvedAbortSignal<'s> {}}+ pub(crate) fn reason(+ self,+ scope: &mut v8::PinScope<'s, '_>,+ ) -> Option<v8::Local<'s, v8::Value>> {+ match self.owner {+ AbortSignalOwner::Window => {+ let host_ptr = context_host_ptr_from_global_bridge(scope)?;+ unsafe { &mut *host_ptr }.abort_signal_reason(scope, self.signal)+ }+ AbortSignalOwner::Worker => {+ crate::worker::abort::worker_abort_signal_reason(scope, self.signal)+ }+ }+ }+pub(crate) fn abort(self, scope: &mut v8::PinScope<'s, '_>, reason: v8::Local<'s, v8::Value>) {match self.owner {AbortSignalOwner::Window => {diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rsindex c646b0c7f..9da4f1722 100644--- a/moli-renderer-v8/src/context_bootstrap.rs+++ b/moli-renderer-v8/src/context_bootstrap.rs@@ -25,6 +25,7 @@ mod form_data_runtime;mod geometry_runtime;mod history_mutation;mod history_runtime;+pub(crate) mod web_mcp;pub(crate) use history_runtime::state::bind_isolated_window_history_owner;mod idle_detection;mod image_data;@@ -255,9 +256,9 @@ pub(crate) use self::events::{EVENT_STOP_PROPAGATION_SLOT, clear_event_composed_path, event_attribute, event_backing,event_bool_attribute, event_initialized, event_internal_bool_flag, event_is_dispatching,event_is_error_event, event_is_mouse_event, event_private_value, initialize_event_object,- initialize_event_wrapper, mark_event_trusted, new_event_state, new_event_wrapper,- set_event_composed_path, set_event_internal_flag, set_event_private_value, set_event_trusted,- submit_event_submitter_value,+ initialize_event_wrapper, mark_agent_submit_event, mark_event_trusted, new_event_state,+ new_event_wrapper, set_event_composed_path, set_event_internal_flag, set_event_private_value,+ set_event_trusted, submit_event_submitter_value,};pub(crate) use self::file_api::{DataTransferStringCallbackTask, DataTransferStringCallbackTaskEffect,diff --git a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rsindex 14ba68eb5..603c6fa14 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/constructor_templates.rs@@ -117,6 +117,12 @@ pub(in crate::context_bootstrap) fn build_constructor_template<'s>(ConstructorKind::WebGLContextEvent => {build_value_event_template(scope, ValueEventKind::WebGlContext)}+ ConstructorKind::ToolActivatedEvent => {+ build_value_event_template(scope, ValueEventKind::ToolActivated)+ }+ ConstructorKind::ToolCancelEvent => {+ build_value_event_template(scope, ValueEventKind::ToolCancel)+ }ConstructorKind::UiEvent => {build_event_subclass_template(scope, EventSubclassKind::UiEvent)}diff --git a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rsindex bb5cbdf9d..af68cc657 100644--- a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs+++ b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs@@ -457,6 +457,7 @@ pub(super) fn install_constructor_template_bindings<'s>(template,spec.interface.name(),);+ super::super::web_mcp::install_template_bindings(scope, template, spec.interface.name());crate::native_bridge::install_collection_template_bindings(scope,template,diff --git a/moli-renderer-v8/src/context_bootstrap/event_template.rs b/moli-renderer-v8/src/context_bootstrap/event_template.rsindex 15c9eac06..eea1810c6 100644--- a/moli-renderer-v8/src/context_bootstrap/event_template.rs+++ b/moli-renderer-v8/src/context_bootstrap/event_template.rs@@ -19,6 +19,7 @@ use super::{event_target_getter_function, event_time_stamp_getter_function, event_type_getter_function,focus_event_related_target_getter_function, form_data_event_form_data_getter_function,mouse_event_related_target_getter_function, pointer_event_get_predicted_events_callback,+ submit_event_agent_invoked_getter_function, submit_event_respond_with_callback,submit_event_submitter_getter_function, track_event_track_getter_function,ui_event_pseudo_target_getter_function,},@@ -153,6 +154,10 @@ struct TrackEventTemplateAccessorsDeclaration {#[derive(WebApiFunctionTemplate)]#[webapi(interface = web_api_interfaces::SubmitEvent, enumerable, receiver)]struct SubmitEventTemplateAccessorsDeclaration {+ #[webapi(accessor_property = "agentInvoked", getter = submit_event_agent_invoked_getter_function)]+ agent_invoked: (),+ #[webapi(method = "respondWith", length = 1, callback = submit_event_respond_with_callback)]+ respond_with: (),#[webapi(accessor_property, getter = submit_event_submitter_getter_function)]submitter: (),}diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rsindex f2deefd48..3c05db930 100644--- a/moli-renderer-v8/src/context_bootstrap/events.rs+++ b/moli-renderer-v8/src/context_bootstrap/events.rs@@ -8,6 +8,7 @@ mod init;mod kind;mod methods;mod subclasses;+mod submit;mod value;mod wrappers;@@ -26,6 +27,12 @@ const CLOSE_EVENT_WAS_CLEAN_SLOT: &str = "__moliCloseEventWasClean";const CLOSE_EVENT_CODE_SLOT: &str = "__moliCloseEventCode";const CLOSE_EVENT_REASON_SLOT: &str = "__moliCloseEventReason";const SUBMIT_EVENT_SUBMITTER_SLOT: &str = "__moliSubmitEventSubmitter";+const SUBMIT_EVENT_AGENT_INVOKED_SLOT: &str = "__moliSubmitEventAgentInvoked";+const SUBMIT_EVENT_RESPONSE_SLOT: &str = "__moliSubmitEventResponse";+pub(crate) use submit::{mark_agent_submit_event, take_submit_event_response};+pub(super) use submit::{+ submit_event_agent_invoked_getter_function, submit_event_respond_with_callback,+};const FORM_DATA_EVENT_FORM_DATA_SLOT: &str = "__moliFormDataEventFormData";const TRACK_EVENT_TRACK_SLOT: &str = "__moliTrackEventTrack";const EVENT_SUBCLASS_KIND_SLOT: &str = "__moliEventSubclassKind";diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rsindex c10337512..11ed91b8d 100644--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/data.rs@@ -1424,6 +1424,7 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_submit_event<event: v8::Local<'s, v8::Object>,init: Option<v8::Local<'s, v8::Object>>,) -> bool {+ let agent_invoked = init_bool_property(scope, init, "agentInvoked", false);let Some(submitter) = submit_event_submitter(scope, init) else {return false;};@@ -1433,6 +1434,12 @@ pub(in crate::context_bootstrap::events::subclasses) fn initialize_submit_event<SUBMIT_EVENT_SUBMITTER_SLOT,submitter,);+ crate::context_bootstrap::set_event_private_value(+ scope,+ event,+ SUBMIT_EVENT_AGENT_INVOKED_SLOT,+ v8::Boolean::new(scope, agent_invoked).into(),+ );true}diff --git a/moli-renderer-v8/src/context_bootstrap/events/submit.rs b/moli-renderer-v8/src/context_bootstrap/events/submit.rsnew file mode 100644index 000000000..9a82399ec--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/events/submit.rs@@ -0,0 +1,78 @@+use super::*;+use crate::webidl;++#[derive(webidl::WebIdlArgs)]+#[webidl(prefix = "SubmitEvent.respondWith")]+struct RespondWithArgs<'s> {+ #[webidl(required)]+ response: v8::Local<'s, v8::Promise>,+}++pub(in crate::context_bootstrap) fn submit_event_agent_invoked_getter_function<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ rv.set_bool(+ event_private_value(scope, args.this(), SUBMIT_EVENT_AGENT_INVOKED_SLOT)+ .is_some_and(|value| value.is_true()),+ );+}++pub(in crate::context_bootstrap) fn submit_event_respond_with_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(parsed) = webidl::parse_args::<RespondWithArgs<'s>>(scope, &args) else {+ return;+ };+ let event = args.this();+ let agent_invoked = event_private_value(scope, event, SUBMIT_EVENT_AGENT_INVOKED_SLOT)+ .is_some_and(|value| value.is_true());+ if !agent_invoked+ || !event_bool_attribute(scope, event, "defaultPrevented")+ || !event_is_dispatching(scope, event)+ {+ crate::native_bridge::throw_dom_exception(+ scope,+ "InvalidStateError",+ 11,+ "respondWith requires an agent-invoked submit event during dispatch after preventDefault()",+ );+ return;+ }+ set_event_private_value(+ scope,+ event,+ SUBMIT_EVENT_RESPONSE_SLOT,+ parsed.response.into(),+ );+}++pub(crate) fn mark_agent_submit_event(+ scope: &mut v8::PinScope<'_, '_>,+ event: v8::Local<'_, v8::Object>,+) {+ set_event_private_value(+ scope,+ event,+ SUBMIT_EVENT_AGENT_INVOKED_SLOT,+ v8::Boolean::new(scope, true).into(),+ );+}++pub(crate) fn take_submit_event_response<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ event: v8::Local<'s, v8::Object>,+) -> Option<v8::Local<'s, v8::Promise>> {+ let response = event_private_value(scope, event, SUBMIT_EVENT_RESPONSE_SLOT)+ .and_then(|value| v8::Local::<v8::Promise>::try_from(value).ok());+ set_event_private_value(+ scope,+ event,+ SUBMIT_EVENT_RESPONSE_SLOT,+ v8::undefined(scope).into(),+ );+ response+}diff --git a/moli-renderer-v8/src/context_bootstrap/events/value.rs b/moli-renderer-v8/src/context_bootstrap/events/value.rsindex 9ed9ad7cb..2e07b9699 100644--- a/moli-renderer-v8/src/context_bootstrap/events/value.rs+++ b/moli-renderer-v8/src/context_bootstrap/events/value.rs@@ -16,6 +16,7 @@ const PSEUDO_ELEMENT_SLOT: &str = "__moliValueEventPseudoElement";const BLOB_SLOT: &str = "__moliValueEventBlob";const STATUS_MESSAGE_SLOT: &str = "__moliWebGlContextEventStatusMessage";const TIMECODE_SLOT: &str = "__moliValueEventTimecode";+const TOOL_NAME_SLOT: &str = "__moliToolEventName";#[derive(Clone, Copy)]pub(in crate::context_bootstrap) enum ValueEventKind {@@ -23,6 +24,8 @@ pub(in crate::context_bootstrap) enum ValueEventKind {Transition,Blob,WebGlContext,+ ToolActivated,+ ToolCancel,}impl ValueEventKind {@@ -32,6 +35,8 @@ impl ValueEventKind {Self::Transition => "TransitionEvent",Self::Blob => "BlobEvent",Self::WebGlContext => "WebGLContextEvent",+ Self::ToolActivated => "ToolActivatedEvent",+ Self::ToolCancel => "ToolCancelEvent",}}@@ -81,6 +86,33 @@ struct WebGlContextEventPrototypeDeclaration {status_message: (),}+#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::ToolActivatedEvent, enumerable, receiver)]+struct ToolActivatedEventPrototypeDeclaration {+ #[webapi(accessor_property = "toolName", getter = payload_getter, data = v8str(scope, TOOL_NAME_SLOT))]+ tool_name: (),+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::ToolCancelEvent, enumerable, receiver)]+struct ToolCancelEventPrototypeDeclaration {+ #[webapi(accessor_property = "toolName", getter = payload_getter, data = v8str(scope, TOOL_NAME_SLOT))]+ tool_name: (),+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "ToolEventInit")]+struct ToolEventInit<'s> {+ #[webidl(default = false)]+ bubbles: bool,+ #[webidl(default = false)]+ cancelable: bool,+ #[webidl(default = false)]+ composed: bool,+ #[webidl(name = "toolName", with = string_member)]+ tool_name: v8::Local<'s, v8::String>,+}+#[derive(webidl::WebIdlDictionary)]#[webidl(prefix = "WebGLContextEventInit")]struct WebGlContextEventInit<'s> {@@ -196,6 +228,12 @@ pub(in crate::context_bootstrap) fn install_value_event_template_bindings<'s>("BlobEvent" => {BlobEventPrototypeDeclaration::initialize_prototype_template(scope, prototype)}+ "ToolActivatedEvent" => {+ ToolActivatedEventPrototypeDeclaration::initialize_prototype_template(scope, prototype)+ }+ "ToolCancelEvent" => {+ ToolCancelEventPrototypeDeclaration::initialize_prototype_template(scope, prototype)+ }_ => {}}}@@ -231,6 +269,8 @@ fn value_event_constructor<'s>(Some(1) => ValueEventKind::Transition,Some(2) => ValueEventKind::Blob,Some(3) => ValueEventKind::WebGlContext,+ Some(4) => ValueEventKind::ToolActivated,+ Some(5) => ValueEventKind::ToolCancel,_ => return,};if !args.is_construct_call() {@@ -311,6 +351,11 @@ fn value_event_constructor<'s>();(parsed.bubbles, parsed.cancelable, parsed.composed)}+ ValueEventKind::ToolActivated | ValueEventKind::ToolCancel => {+ let parsed = webidl::parse_dictionary_object::<ToolEventInit>(scope, dictionary)?;+ set_event_private_value(scope, state, TOOL_NAME_SLOT, parsed.tool_name.into());+ (parsed.bubbles, parsed.cancelable, parsed.composed)+ }};initialize_event_object_with_type(scope, state, event_type, bubbles, cancelable);define_event_property(diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rsindex eb7032c71..230d3c8d5 100644--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rs+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/install.rs@@ -151,6 +151,7 @@ pub(crate) fn filter_window_exposed_interfaces(})?;}}+ crate::context_bootstrap::web_mcp::filter_exposure(scope, secure_context)?;Ok(())}diff --git a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rs b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rsindex 5aa036820..ec525e461 100644--- a/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rs+++ b/moli-renderer-v8/src/context_bootstrap/exposed_interfaces/metadata.rs@@ -101,6 +101,9 @@ const SECURE_CONTEXT_ONLY_INTERFACE_NAMES: &[&str] = &["MIDIOutput","MIDIInputMap","MIDIOutputMap",+ "ModelContext",+ "ToolActivatedEvent",+ "ToolCancelEvent","MediaDeviceInfo","InputDeviceInfo","DeviceMotionEvent",diff --git a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs b/moli-renderer-v8/src/context_bootstrap/runtime_state.rsindex d4f3425cb..4182793ad 100644--- a/moli-renderer-v8/src/context_bootstrap/runtime_state.rs+++ b/moli-renderer-v8/src/context_bootstrap/runtime_state.rs@@ -2090,7 +2090,11 @@ fn install_window_runtime_state<'s>(global,runtime.document_url().as_str(),)?;- let origin = moli_url::origin_ascii_serialization(runtime.document_url());+ let origin = if runtime.document_sandbox_policy().forces_opaque_origin {+ "null".into()+ } else {+ moli_url::origin_ascii_serialization(runtime.document_url())+ };set_window_origin_runtime_state(scope, global, &origin)?;let console = ConsoleObjectDeclaration::default()diff --git a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs b/moli-renderer-v8/src/context_bootstrap/specs/registry.rsindex 4bb47140a..1490e7d66 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/registry.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/registry.rs@@ -4,6 +4,18 @@ use crate::web_api_interfaces;use std::collections::HashSet;const CONSTRUCTOR_SPECS_BEFORE_STREAMS: &[ConstructorSpec] = &[+ ConstructorSpec {+ interface: web_api_interfaces::ModelContext::DESCRIPTOR,+ kind: ConstructorKind::Illegal,+ },+ ConstructorSpec {+ interface: web_api_interfaces::ToolActivatedEvent::DESCRIPTOR,+ kind: ConstructorKind::ToolActivatedEvent,+ },+ ConstructorSpec {+ interface: web_api_interfaces::ToolCancelEvent::DESCRIPTOR,+ kind: ConstructorKind::ToolCancelEvent,+ },ConstructorSpec {interface: web_api_interfaces::External::DESCRIPTOR,kind: ConstructorKind::Illegal,diff --git a/moli-renderer-v8/src/context_bootstrap/specs/types.rs b/moli-renderer-v8/src/context_bootstrap/specs/types.rsindex ce78d30b6..04f1f05ca 100644--- a/moli-renderer-v8/src/context_bootstrap/specs/types.rs+++ b/moli-renderer-v8/src/context_bootstrap/specs/types.rs@@ -11,6 +11,8 @@ pub(in crate::context_bootstrap) enum ConstructorKind {TransitionEvent,BlobEvent,WebGLContextEvent,+ ToolActivatedEvent,+ ToolCancelEvent,UiEvent,FocusEvent,CompositionEvent,diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp.rsnew file mode 100644index 000000000..491f654e0--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp.rs@@ -0,0 +1,31 @@+//! Document-owned WebMCP tools, shared by page API and DevTools callers.+//!+//! Reference: Chromium 2d184faab9, Blink core/script_tools/model_context.cc.+//! Registrations and invocations have separate lifetimes: unregistering a JS+//! tool never cancels a callback that has already started.++mod api;+mod bindings;+mod conversion;+mod declarative;+mod devtools;+mod events;+mod execution;+mod lifecycle;+mod navigation;+mod state;+mod tasks;++pub(in crate::context_bootstrap) use bindings::{filter_exposure, install_template_bindings};+pub(crate) use declarative::invocation::{+ begin_form_submit, cancel_form_execution, finish_form_navigation, finish_form_submit,+ form_submission_failed,+};+pub(crate) use declarative::{note_mutation, prepare_registration_task, queue_registration_task};+pub(crate) use devtools::{configure_session, dispatch_command, emit as emit_protocol_event};+pub(crate) use lifecycle::queue_retirement_task;+pub(crate) use navigation::{+ bind_child_navigation, bind_root_navigation, cancel_child_navigation, commit_child_navigation,+ complete_navigation, fail_navigation, receive_navigation,+};+pub(crate) use state::ModelContextStore;diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/api.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/api.rsnew file mode 100644index 000000000..406284530--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/api.rs@@ -0,0 +1,481 @@+use super::bindings::{check_target, document_for_target, document_owner, dom_error};+use super::events::queue_tool_change;+use super::state::{AbortRegistration, RegisteredTool, ToolExecutor, ToolMetadata};+use super::tasks::{queue_task, remove_abort_registration, signal_reason, task_context, task_data};+use super::{conversion, devtools, execution};+use crate::document_runtime::DomHandle;+use crate::native_bridge::JsContextHost;+use crate::util::context_host_ptr_from_global_bridge;+use crate::web_api_interfaces;+use crate::window_webidl_callback::WindowWebIdlCallbackFunction;+use moli_page_types::{RendererWebMcpEvent, RendererWebMcpToolId};++use crate::{abort_signal_route::ResolvedAbortSignal, webidl};++// Promise-returning Web IDL operations reject even when argument conversion+// throws. Preserve the original exception from getters, proxies and toJSON.+macro_rules! promise_callback {+ ($callback:ident, $operation:ident) => {+ pub(super) fn $callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+ ) {+ let Some(resolver) = v8::PromiseResolver::new(scope) else {+ return;+ };+ rv.set(resolver.get_promise(scope).into());+ let exception = {+ let try_catch = std::pin::pin!(v8::TryCatch::new(scope));+ let mut scope = try_catch.init();+ if let Err(error) = $operation(&mut scope, &args, resolver) {+ webidl::throw_error(&mut scope, &error);+ }+ let exception = scope+ .exception()+ .map(|value| v8::Global::new(&scope, value));+ scope.reset();+ exception+ };+ if let Some(exception) = exception {+ let _ = resolver.reject(scope, v8::Local::new(scope, &exception));+ }+ }+ };+}++promise_callback!(register_tool_callback, register_tool);+promise_callback!(get_tools_callback, get_tools);+promise_callback!(execute_tool_callback, execute_tool);++fn receiver<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+) -> Result<(), webidl::WebIdlError> {+ if web_api_interfaces::ModelContext::is_instance(scope, args.this()) {+ Ok(())+ } else {+ Err(webidl::WebIdlError::custom_message("Illegal invocation"))+ }+}++fn active_target<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ target: v8::Local<'s, v8::Object>,+) -> Result<(*mut JsContextHost, DomHandle), webidl::WebIdlError> {+ check_target(scope, target).map_err(|error| {+ scope.throw_exception(error);+ webidl::WebIdlError::pending_exception(webidl::Context::member("ModelContext", "document"))+ })+}++fn register_tool<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ resolver: v8::Local<'s, v8::PromiseResolver>,+) -> Result<(), webidl::WebIdlError> {+ receiver(scope, args)?;+ let definition = conversion::dictionary(scope, args, 0, "ModelContext.registerTool")?;+ let definition =+ webidl::parse_dictionary_object::<conversion::ToolDefinition>(scope, definition)?;+ let options = conversion::dictionary(scope, args, 1, "ModelContext.registerTool")?;+ let options = webidl::parse_dictionary_object::<conversion::RegisterOptions>(scope, options)?;+ let target = args.this();+ let (host_ptr, document) = active_target(scope, target)?;+ let error = if unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .documents+ .get(&document)+ .is_some_and(|entry| entry.tools.contains_key(&definition.name))+ {+ Some("Duplicate tool name")+ } else if !moli_webmcp::is_valid_tool_name(&definition.name) {+ Some("Invalid tool name")+ } else if definition.description.is_empty() {+ Some("Description is required")+ } else {+ None+ };+ if let Some(message) = error {+ let error = dom_error(scope, "InvalidStateError", message);+ let _ = resolver.reject(scope, error);+ return Ok(());+ }+ let input_schema = definition+ .input_schema+ .map(|schema| conversion::stringify_object(scope, schema))+ .transpose()?;+ // JSON.stringify invokes author toJSON/getters. They can replace the+ // document or detach its frame, retiring the registry checked above.+ let (host_ptr, document) = active_target(scope, target)?;+ if let Some(signal) = options.signal+ && ResolvedAbortSignal::resolve(scope, signal)+ .is_some_and(|signal| signal.is_aborted(scope))+ {+ let reason = signal_reason(scope, signal);+ let _ = resolver.reject(scope, reason);+ return Ok(());+ }+ let exposed_to = conversion::validate_origins(scope, options.exposed_to)?;+ // An author serializer may have registered this name after the first+ // duplicate check. Preserve that registration and its pending resolver.+ if unsafe { &*host_ptr }.native_bridge().web_mcp.documents[&document]+ .tools+ .contains_key(&definition.name)+ {+ let error = dom_error(scope, "InvalidStateError", "Duplicate tool name");+ let _ = resolver.reject(scope, error);+ return Ok(());+ }+ let registration = {+ let store = &mut unsafe { &mut *host_ptr }.native_bridge_mut().web_mcp;+ store.next_registration = store+ .next_registration+ .checked_add(1)+ .expect("WebMCP registration space exhausted");+ store.next_registration+ };+ let data = task_data(scope, target, registration, Some(&definition.name));+ let abort = options.signal.map(|signal| {+ let algorithm = v8::Function::builder(unregister_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP abort algorithm");+ ResolvedAbortSignal::resolve(scope, signal)+ .expect("validated AbortSignal")+ .register_algorithm(scope, algorithm);+ AbortRegistration {+ signal: v8::Global::new(scope, signal),+ algorithm: v8::Global::new(scope, algorithm),+ }+ });+ let callback =+ WindowWebIdlCallbackFunction::new(scope, unsafe { &*host_ptr }, definition.execute);+ let tool = RegisteredTool {+ registration,+ metadata: ToolMetadata {+ description: definition.description,+ title: definition.title.unwrap_or_default(),+ input_schema,+ annotations: definition.annotations,+ },+ stack_trace: devtools::capture_registration_stack(scope),+ exposed_to,+ executor: ToolExecutor::Callback(callback),+ abort,+ registration_resolver: Some(v8::Global::new(scope, resolver)),+ };+ let (snapshot, origin, origins, tree) = {+ let entry = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .documents+ .get_mut(&document)+ .expect("active ModelContext");+ let snapshot = devtools::protocol_tool(entry, &definition.name, &tool);+ let origins = tool.exposed_to.clone();+ entry.tools.insert(definition.name, tool);+ (snapshot, entry.origin.clone(), origins, entry.frame_tree)+ };+ devtools::emit_in_tree(+ unsafe { &*host_ptr },+ tree,+ RendererWebMcpEvent::ToolsAdded(vec![snapshot]),+ );+ queue_tool_change(scope, host_ptr, document, &origin, &origins);+ let ack = v8::Function::builder(registration_ack_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP registration acknowledgement");+ queue_task(scope, host_ptr, ack);+ Ok(())+}++fn registration_ack_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((target, id, name)) = task_context(scope, &args) else {+ return;+ };+ let Ok((host_ptr, document)) = check_target(scope, target) else {+ return;+ };+ let name = name.to_rust_string_lossy(scope);+ let resolver = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .documents+ .get_mut(&document)+ .and_then(|entry| entry.tools.get_mut(&name))+ .filter(|tool| tool.registration == id)+ .and_then(|tool| tool.registration_resolver.take());+ if let Some(resolver) = resolver {+ let resolver = v8::Local::new(scope, &resolver);+ let _ = resolver.resolve(scope, v8::undefined(scope).into());+ }+}++fn unregister_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((target, id, name)) = task_context(scope, &args) else {+ return;+ };+ let Some(document) = document_for_target(scope, target) else {+ return;+ };+ let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {+ return;+ };+ let name = name.to_rust_string_lossy(scope);+ let removed = {+ let store = &mut unsafe { &mut *host_ptr }.native_bridge_mut().web_mcp;+ let Some(entry) = store.documents.get_mut(&document) else {+ return;+ };+ if entry+ .tools+ .get(&name)+ .is_none_or(|tool| tool.registration != id)+ {+ return;+ }+ entry.tools.remove(&name).map(|tool| {+ (+ tool,+ entry.origin.clone(),+ entry.frame_id.clone(),+ entry.frame_tree,+ )+ })+ };+ if let Some((mut tool, origin, frame_id, tree)) = removed {+ devtools::emit_in_tree(+ unsafe { &*host_ptr },+ tree,+ RendererWebMcpEvent::ToolsRemoved(vec![RendererWebMcpToolId { frame_id, name }]),+ );+ if let Some(resolver) = tool.registration_resolver.take() {+ let signal = tool+ .abort+ .as_ref()+ .map(|abort| v8::Local::new(scope, &abort.signal));+ let reason = signal+ .map(|signal| signal_reason(scope, signal))+ .unwrap_or_else(|| crate::native_bridge::abort::abort_error_value(scope));+ let resolver = v8::Local::new(scope, &resolver);+ let _ = resolver.reject(scope, reason);+ }+ remove_abort_registration(scope, tool.abort.take());+ queue_tool_change(scope, host_ptr, document, &origin, &tool.exposed_to);+ }+}++fn get_tools<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ resolver: v8::Local<'s, v8::PromiseResolver>,+) -> Result<(), webidl::WebIdlError> {+ receiver(scope, args)?;+ let options = conversion::dictionary(scope, args, 0, "ModelContext.getTools")?;+ let options = webidl::parse_dictionary_object::<conversion::GetOptions>(scope, options)?;+ let (host_ptr, document) = active_target(scope, args.this())?;+ let from_origins = conversion::validate_origins(scope, options.from_origins)?;+ let host = unsafe { &*host_ptr };+ let caller_tree = host.native_bridge().web_mcp.documents[&document].frame_tree;+ let caller_origin = host.native_bridge().web_mcp.documents[&document]+ .origin+ .clone();+ let mut tools = host+ .native_bridge()+ .web_mcp+ .documents+ .iter()+ .filter(|(document, entry)| {+ entry.frame_tree == caller_tree+ && document_owner(host, **document) == Some(entry.owner)+ && host+ .document_permissions_policy_for_document_handle(**document)+ .is_some_and(|policy| policy.tools_enabled())+ && (entry.origin == caller_origin || from_origins.contains(&entry.origin))+ })+ .flat_map(|(_, entry)| {+ entry+ .tools+ .iter()+ .filter(|(_, tool)| {+ entry.origin == caller_origin || tool.exposed_to.contains(&caller_origin)+ })+ .map(move |(name, tool)| (entry, name, tool))+ })+ .collect::<Vec<_>>();+ tools.sort_by_key(|(_, name, _)| *name);+ let snapshots = tools+ .into_iter()+ .filter_map(|(entry, name, tool)| conversion::tool_snapshot(scope, entry, name, tool))+ .map(Into::into)+ .collect::<Vec<_>>();+ let result = v8::Array::new_with_elements(scope, &snapshots);+ let data = v8::Array::new_with_elements(scope, &[resolver.into(), result.into()]);+ let ack = v8::Function::builder(get_tools_ack_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP discovery acknowledgement");+ queue_task(scope, host_ptr, ack);+ Ok(())+}++fn get_tools_ack_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Ok(data) = v8::Local::<v8::Array>::try_from(args.data()) else {+ return;+ };+ let Some(resolver) = data+ .get_index(scope, 0)+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())+ else {+ return;+ };+ let Some(result) = data.get_index(scope, 1) else {+ return;+ };+ // SAFETY: This callback's private data is created above with a native+ // PromiseResolver at index zero and is never exposed to author code.+ let resolver = unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(resolver) };+ let _ = resolver.resolve(scope, result);+}++fn execute_tool<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ resolver: v8::Local<'s, v8::PromiseResolver>,+) -> Result<(), webidl::WebIdlError> {+ receiver(scope, args)?;+ let reference = conversion::dictionary(scope, args, 0, "ModelContext.executeTool")?;+ let reference = webidl::parse_dictionary_object::<conversion::ToolReference>(scope, reference)?;+ // IDL still converts every metadata member (including its author getters).+ // Invocation authority comes from the live registry, not caller metadata.+ let _metadata = (+ reference.annotations,+ reference.description,+ reference.input_schema,+ reference.title,+ );+ // Optional Web IDL object: undefined means missing; null and primitives fail.+ let input = if args.length() < 2 || args.get(1).is_undefined() {+ v8::Object::new(scope)+ } else {+ webidl::convert::<v8::Local<v8::Object>>(+ scope,+ args.get(1),+ webidl::Context::argument("ModelContext.executeTool", 2),+ )?+ };+ let options = conversion::dictionary(scope, args, 2, "ModelContext.executeTool")?;+ let options = webidl::parse_dictionary_object::<conversion::ExecuteOptions>(scope, options)?;+ let (host_ptr, caller_document) = active_target(scope, args.this())?;+ let expected = match url::Url::parse(&reference.origin) {+ Ok(url) if matches!(url.origin(), url::Origin::Tuple(..)) => url.origin(),+ _ => {+ let error = dom_error(+ scope,+ "NotSupportedError",+ "The provided origin is invalid or opaque.",+ );+ let _ = resolver.reject(scope, error);+ return Ok(());+ }+ };+ if matches!(+ unsafe { &*host_ptr }.native_bridge().web_mcp.documents[&caller_document].origin,+ url::Origin::Opaque(_)+ ) {+ let error = dom_error(+ scope,+ "NotSupportedError",+ "Tool invocation is not supported from an opaque origin",+ );+ let _ = resolver.reject(scope, error);+ return Ok(());+ }+ let input = conversion::stringify_object(scope, input)?;+ let (host_ptr, caller_document) = active_target(scope, args.this())?;+ if super::super::navigation_window::child_browsing_context_handle_for_runtime_owner(+ scope,+ reference.window,+ )+ .is_some_and(|handle| !unsafe { &*host_ptr }.child_browsing_context_host_is_active(handle))+ {+ let error = dom_error(scope, "InvalidStateError", "Target frame is detached.");+ let _ = resolver.reject(scope, error);+ return Ok(());+ }+ if let Some(signal) = options.signal+ && ResolvedAbortSignal::resolve(scope, signal)+ .is_some_and(|signal| signal.is_aborted(scope))+ {+ let reason = signal_reason(scope, signal);+ let _ = resolver.reject(scope, reason);+ return Ok(());+ }+ let target_document = {+ let host = unsafe { &*host_ptr };+ host.native_bridge()+ .web_mcp+ .documents+ .iter()+ .find(|(document, entry)| {+ entry.frame_tree+ == host.native_bridge().web_mcp.documents[&caller_document].frame_tree+ && v8::Local::new(scope, &entry.window).strict_equals(reference.window.into())+ && document_owner(host, **document) == Some(entry.owner)+ && host+ .document_permissions_policy_for_document_handle(**document)+ .is_some_and(|policy| policy.tools_enabled())+ && entry.origin == expected+ && entry.tools.get(&reference.name).is_some_and(|tool| {+ entry.origin+ == host.native_bridge().web_mcp.documents[&caller_document].origin+ || tool.exposed_to.contains(+ &host.native_bridge().web_mcp.documents[&caller_document].origin,+ )+ })+ })+ .map(|(document, entry)| {+ (+ *document,+ v8::Global::new(scope, v8::Local::new(scope, &entry.target)),+ )+ })+ };+ let Some((document, target)) = target_document else {+ execution::reject_unavailable_tool(+ scope,+ host_ptr,+ caller_document,+ resolver,+ options.signal,+ );+ return Ok(());+ };+ execution::schedule_invocation(+ scope,+ host_ptr,+ caller_document,+ document,+ target,+ reference.name,+ input,+ Some(resolver),+ options.signal,+ );+ Ok(())+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/bindings.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/bindings.rsnew file mode 100644index 000000000..918c891aa--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/bindings.rs@@ -0,0 +1,296 @@+//! ModelContext bindings, document ownership, and target policy checks.++use super::devtools::document_frame_id;+use super::state::DocumentTools;+use super::{api, events};+use crate::document_runtime::DomHandle;+use crate::native_bridge::{JsContextHost, WindowDocumentOwner};+use crate::util::{context_host_ptr_from_global_bridge, get_private_object, set_private_value};+use crate::web_api_interfaces;+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};+use std::collections::BTreeMap;++const DOCUMENT_SLOT: &str = "__moliModelContextDocument";+const MODEL_CONTEXT_SLOT: &str = "__moliDocumentModelContext";++#[derive(WebApiObject)]+#[webapi(interface = web_api_interfaces::ModelContext, prototype = "Object")]+struct ModelContextObject<'s> {+ #[webapi(prototype)]+ prototype: v8::Local<'s, v8::Object>,+ #[webapi(slot = DOCUMENT_SLOT)]+ document: v8::Local<'s, v8::Object>,+ #[webapi(slot = crate::context_bootstrap::SIMPLE_EVENT_TARGET_SLOT, value = events::LISTENERS_SLOT)]+ event_target: (),+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::ModelContext, enumerable)]+struct ModelContextPrototype {+ #[webapi(method = "registerTool", length = 1, callback = api::register_tool_callback)]+ register_tool: (),+ #[webapi(method = "getTools", length = 0, callback = api::get_tools_callback)]+ get_tools: (),+ #[webapi(method = "executeTool", length = 1, callback = api::execute_tool_callback)]+ execute_tool: (),+ #[webapi(accessor_property = "ontoolchange", getter = events::handler_getter, setter = events::handler_setter, data = v8::Integer::new(scope, 0))]+ on_tool_change: (),+ #[webapi(accessor_property = "ontoolactivated", getter = events::handler_getter, setter = events::handler_setter, data = v8::Integer::new(scope, 1))]+ on_tool_activated: (),+ #[webapi(accessor_property = "ontoolcancel", getter = events::handler_getter, setter = events::handler_setter, data = v8::Integer::new(scope, 2))]+ on_tool_cancel: (),+}++#[derive(WebApiFunctionTemplate)]+#[webapi(interface = web_api_interfaces::Document, enumerable, receiver)]+struct DocumentModelContextPrototype {+ #[webapi(accessor_property = "modelContext", getter = model_context_getter)]+ model_context: (),+}++pub(in crate::context_bootstrap) fn install_template_bindings<'s>(+ scope: &mut v8::PinScope<'s, '_, ()>,+ template: v8::Local<'s, v8::FunctionTemplate>,+ name: &str,+) {+ let prototype = template.prototype_template(scope);+ if name == "ModelContext" {+ ModelContextPrototype::initialize_prototype_template(scope, prototype);+ } else if name == "Document" {+ DocumentModelContextPrototype::initialize_prototype_template(scope, prototype);+ }+}++pub(in crate::context_bootstrap) fn filter_exposure(+ scope: &mut v8::PinScope<'_, '_>,+ secure: bool,+) -> anyhow::Result<()> {+ if !secure {+ let prototype =+ crate::context_bootstrap::ensure_intrinsic_interface_prototype(scope, "Document")?;+ let key = js_string(scope, "modelContext");+ anyhow::ensure!(+ prototype.delete(scope, key.into()) == Some(true),+ "failed to remove insecure Document.modelContext"+ );+ }+ Ok(())+}++fn model_context_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ if let Some(target) = model_context_for_document(scope, args.this()) {+ rv.set(target.into());+ }+}++pub(super) fn model_context_for_document<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ document: v8::Local<'s, v8::Object>,+) -> Option<v8::Local<'s, v8::Object>> {+ if let Some(context) = get_private_object(scope, document, MODEL_CONTEXT_SLOT) {+ return Some(context);+ }+ let Ok((_, handle)) =+ crate::native_bridge::node_runtime_and_handle_from_object_or_detached(scope, document)+ else {+ return None;+ };+ let host_ptr = context_host_ptr_from_global_bridge(scope)?;+ let prototype =+ crate::context_bootstrap::ensure_intrinsic_interface_prototype(scope, "ModelContext")+ .ok()?;+ let Ok(target) = ModelContextObject {+ prototype,+ document,+ event_target: (),+ }+ .bind(scope) else {+ return None;+ };+ crate::context_bootstrap::media_queries::install_simple_event_target_ordered_handlers(+ scope, target,+ );+ set_private_value(scope, document, MODEL_CONTEXT_SLOT, target.into());+ if let Some(owner) = document_owner(unsafe { &*host_ptr }, handle) {+ bind_document_target(scope, host_ptr, handle, target, owner);+ }+ Some(target)+}++fn bind_document_target<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ document: DomHandle,+ target: v8::Local<'s, v8::Object>,+ owner: WindowDocumentOwner,+) {+ let host = unsafe { &*host_ptr };+ let shared = host+ .native_bridge()+ .web_mcp+ .documents+ .get(&document)+ .filter(|entry| entry.owner == owner)+ .map(|entry| v8::Local::new(scope, &entry.target));+ if let Some(shared) = shared {+ crate::context_bootstrap::shared_event_targets::bind_shared_target(scope, target, shared);+ return;+ }+ let context = target+ .get_creation_context(scope)+ .unwrap_or_else(|| scope.get_current_context());+ let window = document_window(scope, host, document, context);+ let entry = DocumentTools {+ owner,+ target: v8::Global::new(scope, target),+ window: v8::Global::new(scope, window),+ origin: document_origin(host, document),+ frame_id: document_frame_id(host, document),+ frame_tree: document_frame_tree(host, document),+ tools: BTreeMap::new(),+ };+ unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .documents+ .insert(document, entry);+ crate::context_bootstrap::shared_event_targets::bind_shared_target(scope, target, target);+}++pub(super) fn document_owner(+ host: &JsContextHost,+ document: DomHandle,+) -> Option<WindowDocumentOwner> {+ if document == host.document_handle() {+ return host+ .current_main_document_task_owner()+ .map(WindowDocumentOwner::Frame);+ }+ if let Some(popup) = host.lightweight_popup_id_for_document_handle(document) {+ return host+ .current_lightweight_popup_document_owner(popup)+ .map(WindowDocumentOwner::LightweightPopup);+ }+ let handle = host.child_browsing_context_host_for_document_handle(document)?;+ if !host.child_browsing_context_host_is_active(handle) {+ return None;+ }+ host.current_child_document_task_owner(handle)+ .map(WindowDocumentOwner::Frame)+}++pub(super) fn document_frame_tree(host: &JsContextHost, document: DomHandle) -> Option<u64> {+ let mut current = document;+ loop {+ if let Some(popup) = host.lightweight_popup_id_for_document_handle(current) {+ return Some(popup);+ }+ let handle = host.child_browsing_context_host_for_document_handle(current)?;+ current = host.dom_host().node(handle)?.owner_document()?;+ }+}++fn document_window<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host: &JsContextHost,+ document: DomHandle,+ context: v8::Local<'s, v8::Context>,+) -> v8::Local<'s, v8::Object> {+ if let Some(popup) = host.lightweight_popup_id_for_document_handle(document)+ && let Some(window) = host.lightweight_popup_window(scope, popup)+ {+ return window;+ }+ host.child_browsing_context_host_for_document_handle(document)+ .and_then(|handle| host.existing_child_browsing_context_window_wrapper(scope, handle))+ .unwrap_or_else(|| context.global(scope))+}++pub(super) fn document_origin(host: &JsContextHost, document: DomHandle) -> url::Origin {+ if document == host.document_handle() && host.document_sandbox_policy().forces_opaque_origin+ || host+ .child_browsing_context_host_for_document_handle(document)+ .is_some_and(|child| host.child_browsing_context_has_opaque_origin(child))+ {+ return url::Origin::new_opaque();+ }+ host.lightweight_popup_id_for_document_handle(document)+ .and_then(|popup| host.lightweight_popup_origin(popup))+ .or_else(|| {+ host.child_browsing_context_host_for_document_handle(document)+ .and_then(|child| host.child_browsing_context_target_origin(child))+ })+ .and_then(|origin| url::Url::parse(&origin).ok())+ .map_or_else(+ || host.document_url_for_handle(document).origin(),+ |url| url.origin(),+ )+}++pub(super) fn document_for_target<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ target: v8::Local<'s, v8::Object>,+) -> Option<DomHandle> {+ let document = get_private_object(scope, target, DOCUMENT_SLOT)?;+ crate::native_bridge::node_runtime_and_handle_from_object_or_detached(scope, document)+ .ok()+ .map(|(_, handle)| handle)+}++pub(super) fn check_target<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ target: v8::Local<'s, v8::Object>,+) -> Result<(*mut JsContextHost, DomHandle), v8::Local<'s, v8::Value>> {+ if !web_api_interfaces::ModelContext::is_instance(scope, target) {+ return Err(v8::Exception::type_error(+ scope,+ js_string(scope, "Illegal invocation"),+ ));+ }+ let active = (|| {+ let host_ptr = context_host_ptr_from_global_bridge(scope)?;+ let document = document_for_target(scope, target)?;+ let owner = document_owner(unsafe { &*host_ptr }, document)?;+ Some((host_ptr, document, owner))+ })();+ let Some((host_ptr, document, owner)) = active else {+ return Err(dom_error(+ scope,+ "InvalidStateError",+ "The document is not active.",+ ));+ };+ if !unsafe { &*host_ptr }+ .document_permissions_policy_for_document_handle(document)+ .is_some_and(|policy| policy.tools_enabled())+ {+ return Err(dom_error(+ scope,+ "NotAllowedError",+ "Access to the feature tools is disallowed by permissions policy.",+ ));+ }+ // document.open keeps its Document wrapper while retiring its previous+ // generation. A cached ModelContext must acquire fresh registration state.+ bind_document_target(scope, host_ptr, document, target, owner);+ Ok((host_ptr, document))+}++pub(super) fn dom_error<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ name: &str,+ message: &str,+) -> v8::Local<'s, v8::Value> {+ crate::native_bridge::abort::dom_exception_value(scope, message, name)+}++pub(super) fn js_string<'s>(+ scope: &v8::PinScope<'s, '_, ()>,+ value: &str,+) -> v8::Local<'s, v8::String> {+ v8::String::new(scope, value).expect("WebMCP string")+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/conversion.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/conversion.rsnew file mode 100644index 000000000..480b8c422--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/conversion.rs@@ -0,0 +1,245 @@+use super::bindings::{dom_error, js_string};+use super::state::{DocumentTools, RegisteredTool};+use crate::web_api_interfaces;+use moli_webapi_declare::WebApiObject;++use crate::{abort_signal_route::ResolvedAbortSignal, webidl};++#[derive(Clone, Copy, Default, PartialEq, Eq, webidl::WebIdlDictionary)]+#[webidl(prefix = "ToolAnnotations")]+pub(super) struct ToolAnnotations {+ #[webidl(name = "consequentialHint", default = false)]+ pub(super) consequential: bool,+ #[webidl(default = false)]+ pub(super) debugging: bool,+ #[webidl(name = "readOnlyHint", default = false)]+ pub(super) read_only: bool,+ #[webidl(name = "untrustedContentHint", default = false)]+ pub(super) untrusted_content: bool,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "ModelContextTool")]+pub(super) struct ToolDefinition<'s> {+ #[webidl(with = annotations_member)]+ pub(super) annotations: Option<ToolAnnotations>,+ #[webidl(required, converter = "dom_string")]+ pub(super) description: String,+ #[webidl(required, converter = "callback_function")]+ pub(super) execute: webidl::WebIdlCallbackFunction,+ #[webidl(name = "inputSchema")]+ pub(super) input_schema: Option<v8::Local<'s, v8::Object>>,+ #[webidl(required, converter = "dom_string")]+ pub(super) name: String,+ #[webidl(converter = "usv_string")]+ pub(super) title: Option<String>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "ModelContextRegisterToolOptions")]+pub(super) struct RegisterOptions<'s> {+ #[webidl(name = "exposedTo", converter = "raw", default = webidl::Sequence(Vec::new()))]+ pub(super) exposed_to: webidl::Sequence<webidl::UsvString>,+ #[webidl(with = signal_member)]+ pub(super) signal: Option<v8::Local<'s, v8::Object>>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "ModelContextGetToolOptions")]+pub(super) struct GetOptions {+ #[webidl(name = "fromOrigins", converter = "raw", default = webidl::Sequence(Vec::new()))]+ pub(super) from_origins: webidl::Sequence<webidl::UsvString>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "ExecuteToolOptions")]+pub(super) struct ExecuteOptions<'s> {+ #[webidl(with = signal_member)]+ pub(super) signal: Option<v8::Local<'s, v8::Object>>,+}++#[derive(webidl::WebIdlDictionary)]+#[webidl(prefix = "RegisteredTool")]+pub(super) struct ToolReference<'s> {+ #[webidl(with = annotations_member)]+ pub(super) annotations: Option<ToolAnnotations>,+ #[webidl(required, converter = "dom_string")]+ pub(super) description: String,+ #[webidl(name = "inputSchema")]+ pub(super) input_schema: Option<v8::Local<'s, v8::Object>>,+ #[webidl(required, converter = "dom_string")]+ pub(super) name: String,+ #[webidl(required, converter = "usv_string")]+ pub(super) origin: String,+ #[webidl(converter = "dom_string")]+ pub(super) title: Option<String>,+ #[webidl(with = window_member)]+ pub(super) window: v8::Local<'s, v8::Object>,+}++pub(super) fn dictionary<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+ index: i32,+ prefix: &'static str,+) -> Result<v8::Local<'s, v8::Object>, webidl::WebIdlError> {+ webidl::dictionary_arg(+ args,+ index,+ webidl::Context::argument(prefix, (index + 1) as usize),+ )+ .map(|value| value.unwrap_or_else(|| crate::util::new_null_prototype_object(scope)))+}++fn annotations_member<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+ name: &'static str,+) -> Result<Option<ToolAnnotations>, webidl::WebIdlError> {+ let context = webidl::Context::member("ModelContextTool", name);+ let Some(value) = webidl::property_result(scope, object, name, context)?+ .filter(|value| !value.is_undefined())+ else {+ return Ok(None);+ };+ if value.is_null() {+ return Ok(Some(ToolAnnotations::default()));+ }+ let dictionary = webidl::convert::<v8::Local<v8::Object>>(scope, value, context)?;+ webidl::parse_dictionary_object::<ToolAnnotations>(scope, dictionary).map(Some)+}++fn signal_member<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+ name: &'static str,+) -> Result<Option<v8::Local<'s, v8::Object>>, webidl::WebIdlError> {+ let signal = webidl::optional_member(+ scope,+ object,+ name,+ webidl::Context::member("ModelContextTool", name),+ )?;+ if signal.is_some_and(|signal| ResolvedAbortSignal::resolve(scope, signal).is_none()) {+ return Err(webidl::WebIdlError::cannot_convert(+ webidl::Context::member("ModelContextOptions", name),+ "AbortSignal",+ ));+ }+ Ok(signal)+}++fn window_member<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+ name: &'static str,+) -> Result<v8::Local<'s, v8::Object>, webidl::WebIdlError> {+ let context = webidl::Context::member("RegisteredTool", name);+ let window = webidl::property_result(scope, object, name, context)?+ .filter(|value| !value.is_undefined())+ .ok_or_else(|| webidl::WebIdlError::missing_required(context))?;+ let window = webidl::convert::<v8::Local<v8::Object>>(scope, window, context)?;+ if !web_api_interfaces::Window::is_instance(scope, window)+ && crate::native_bridge::lightweight_popup_id_from_window(scope, window).is_none()+ {+ return Err(webidl::WebIdlError::cannot_convert(context, "Window"));+ }+ Ok(window)+}++pub(super) fn validate_origins<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ strings: webidl::Sequence<webidl::UsvString>,+) -> Result<Vec<url::Origin>, webidl::WebIdlError> {+ let context = webidl::Context::member("ModelContextOptions", "origins");+ strings+ .0+ .into_iter()+ .map(|value| {+ let origin = url::Url::parse(&value.0).ok();+ if !origin.as_ref().is_some_and(|url| {+ moli_url::is_potentially_trustworthy_url(url)+ && matches!(url.origin(), url::Origin::Tuple(..))+ }) {+ // The algorithm reports SecurityError, rather than accepting insecure+ // or opaque origins merely because the calling realm is secure.+ let error = dom_error(+ scope,+ "SecurityError",+ "Only secure origins are allowed in the origins list.",+ );+ scope.throw_exception(error);+ return Err(webidl::WebIdlError::pending_exception(context));+ }+ Ok(origin.expect("validated origin").origin())+ })+ .collect()+}++pub(super) fn stringify_object<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ object: v8::Local<'s, v8::Object>,+) -> Result<String, webidl::WebIdlError> {+ let context = webidl::Context::member("ModelContext", "input");+ let value = v8::json::stringify(scope, object.into())+ .ok_or_else(|| webidl::WebIdlError::pending_exception(context))?;+ let value = value.to_rust_string_lossy(scope);+ if value == "undefined" {+ return Err(webidl::WebIdlError::custom_message(+ "toJSON() returned undefined",+ ));+ }+ Ok(value)+}++#[derive(WebApiObject)]+#[webapi(plain, data_properties, enumerable, scope_lifetime = 's, no_dynamic_constructor)]+struct ToolSnapshot<'s, 'metadata> {+ name: &'metadata str,+ description: &'metadata str,+ title: &'metadata str,+ origin: String,+ window: v8::Local<'s, v8::Object>,+ input_schema: Option<v8::Local<'s, v8::Object>>,+ annotations: Option<AnnotationSnapshot>,+}++#[derive(WebApiObject)]+#[webapi(plain, data_properties, enumerable)]+struct AnnotationSnapshot {+ read_only_hint: bool,+ consequential_hint: bool,+ untrusted_content_hint: bool,+ debugging: bool,+}++pub(super) fn tool_snapshot<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ document: &DocumentTools,+ name: &str,+ tool: &RegisteredTool,+) -> Option<v8::Local<'s, v8::Object>> {+ let metadata = &tool.metadata;+ let schema = if let Some(schema) = &metadata.input_schema {+ let value = v8::json::parse(scope, js_string(scope, schema))?;+ Some(v8::Local::<v8::Object>::try_from(value).ok()?)+ } else {+ None+ };+ ToolSnapshot {+ name,+ description: &metadata.description,+ title: &metadata.title,+ origin: document.origin.ascii_serialization(),+ window: v8::Local::new(scope, &document.window),+ input_schema: schema,+ annotations: metadata.annotations.map(|annotations| AnnotationSnapshot {+ read_only_hint: annotations.read_only,+ consequential_hint: annotations.consequential,+ untrusted_content_hint: annotations.untrusted_content,+ debugging: annotations.debugging,+ }),+ }+ .bind(scope)+ .ok()+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative.rsnew file mode 100644index 000000000..711aa91b2--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative.rs@@ -0,0 +1,519 @@+//! Native form registration following Chromium HTMLFormElement and FormMCPSchema.++use super::bindings::{check_target, document_owner, model_context_for_document};+use super::state::{FormInvocationState, RegisteredTool, ToolExecutor, ToolMetadata};+use super::tasks::queue_task;+use super::{devtools, events, execution};+use crate::document_runtime::DomHandle;+use crate::native_bridge::JsContextHost;+use crate::util::context_host_ptr_from_global_bridge;+use moli_page_types::{RendererWebMcpEvent, RendererWebMcpToolId};++use crate::dom::native::{DomHost, DomMutationEffects, Node};++pub(super) mod invocation;+mod schema;++pub(crate) fn note_mutation(+ scope: &mut v8::PinScope<'_, '_>,+ host: &mut JsContextHost,+ dom: &DomHost,+ effects: &DomMutationEffects,+) {+ let removed_roots = effects+ .style()+ .child_list_mutations()+ .iter()+ .flat_map(|mutation| mutation.removed_nodes().iter().copied())+ .collect::<Vec<_>>();+ let was_removed = |handle| {+ removed_roots+ .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()+ .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))))+ {+ host.native_bridge_mut()+ .web_mcp+ .dirty_form_documents+ .insert(document);+ }+ }+ let invalid = host+ .native_bridge()+ .web_mcp+ .documents+ .iter()+ .flat_map(|(document, entry)| {+ entry.tools.iter().filter_map(|(name, tool)| {+ let ToolExecutor::Form { handle, .. } = tool.executor else {+ return None;+ };+ (was_removed(handle)+ || !form_registration_is_valid(dom, handle)+ || dom.owner_document_handle(handle) != Some(*document))+ .then(|| (*document, name.clone(), handle))+ })+ })+ .collect::<Vec<_>>();+ let invalidated_forms = invalid+ .iter()+ .map(|(_, _, handle)| *handle)+ .collect::<std::collections::HashSet<_>>();+ for (document, name, _) in invalid {+ let (frame_id, tree, origin) = {+ let store = &mut host.native_bridge_mut().web_mcp;+ store.dirty_form_documents.insert(document);+ let entry = store.documents.get_mut(&document).expect("form document");+ entry.tools.remove(&name);+ (+ entry.frame_id.clone(),+ entry.frame_tree,+ entry.origin.clone(),+ )+ };+ devtools::emit_in_tree(+ host,+ tree,+ RendererWebMcpEvent::ToolsRemoved(vec![RendererWebMcpToolId { frame_id, name }]),+ );+ events::queue_form_removal_change(scope, host, document, &origin);+ }+ for pending in host.native_bridge_mut().web_mcp.pending.values_mut() {+ let Some(form) = &mut pending.form else {+ continue;+ };+ // A protected removal already retired that registration. Later unrelated+ // mutations must not invalidate its captured response a second time.+ if !invalidated_forms.contains(&form.handle) {+ continue;+ }+ let protected = match &form.state {+ FormInvocationState::Submitting => true,+ FormInvocationState::Responding(response) => {+ v8::Local::new(scope, response).state() == v8::PromiseState::Pending+ }+ _ => false,+ };+ if !protected {+ form.state = FormInvocationState::Invalidated;+ }+ }+}++// Native forms in connected shadow trees participate in the same registry.+// Use this traversal for initial discovery and every mutation synchronization.+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);+ }+ }+ forms+}++fn form_registration_is_valid(dom: &DomHost, handle: DomHandle) -> bool {+ dom.is_connected(handle)+ && dom+ .node(handle)+ .and_then(Node::as_element)+ .is_some_and(|element| {+ element.has_attribute("toolname") && element.has_attribute("tooldescription")+ })+}++fn contains_tool_form(dom: &DomHost, root: DomHandle) -> bool {+ dom.html_elements_by_local_name_in_shadow_including_subtree(root, "form")+ .into_iter()+ .any(|handle| {+ dom.node(handle)+ .and_then(Node::as_element)+ .is_some_and(|element| {+ element.has_attribute("toolname") && element.has_attribute("tooldescription")+ })+ })+}++fn affects_tool_form(dom: &DomHost, target: DomHandle) -> bool {+ let Some(document) = dom.owner_document_handle(target) else {+ return false;+ };+ let forms = dom.html_elements_by_local_name_in_shadow_including_subtree(document, "form");+ if forms.is_empty() {+ return false;+ }+ 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 {+ matches!(+ name,+ "toolname"+ | "tooldescription"+ | "tooltitle"+ | "toolautosubmit"+ | "name"+ | "type"+ | "form"+ | "id"+ | "disabled"+ | "readonly"+ | "required"+ | "min"+ | "max"+ | "step"+ | "pattern"+ | "multiple"+ | "value"+ | "toolparamdescription"+ | "aria-description"+ | "for"+ )+}++// Keep discovery outside V8: pages without declarative tools must not acquire+// another realm entry while completing unrelated parser or resource work.+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 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);+ }+ }+ !store.form_registration_task_queued && !store.dirty_form_documents.is_empty()+}++pub(crate) fn queue_registration_task(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+) {+ if !prepare_registration_task(unsafe { &mut *host_ptr }) {+ return;+ }+ unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .form_registration_task_queued = true;+ let callback =+ v8::Function::new(scope, registration_callback).expect("WebMCP form registration task");+ queue_task(scope, host_ptr, callback);+}++fn registration_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ _args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {+ return;+ };+ 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)+ .into_iter()+ .collect::<Vec<_>>()+ };+ 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()+ .web_mcp+ .pending+ .iter()+ .filter(|(_, pending)| {+ pending+ .form+ .as_ref()+ .is_some_and(|form| matches!(form.state, FormInvocationState::Invalidated))+ })+ .map(|(id, _)| *id)+ .collect::<Vec<_>>();+ for id in invalidated {+ execution::finish_error(+ scope,+ host_ptr,+ id,+ "Tool definition changed during execution",+ );+ }+ for document in documents {+ synchronize_document(scope, host_ptr, document);+ }+}++struct FormTool {+ handle: DomHandle,+ name: String,+ metadata: ToolMetadata,+ autosubmit: bool,+}++fn form_tools(+ scope: &mut v8::PinScope<'_, '_>,+ host: &JsContextHost,+ document: DomHandle,+) -> Vec<FormTool> {+ if document_owner(host, document).is_none()+ || !host.document_scripting_enabled(document)+ || !host+ .document_permissions_policy_for_document_handle(document)+ .is_some_and(|policy| policy.tools_enabled())+ {+ return Vec::new();+ }+ let secure_url = host+ .child_browsing_context_host_for_document_handle(document)+ .and_then(|child| host.child_browsing_context_secure_context_url(child))+ .unwrap_or_else(|| host.document_url_for_handle(document));+ if !moli_url::is_potentially_trustworthy_url(&secure_url) {+ return Vec::new();+ }+ let dom = host.dom_host();+ let mut result = Vec::new();+ for handle in form_handles(dom, document) {+ let element = dom.node(handle).and_then(Node::as_element).expect("form");+ let (Some(name), Some(description)) = (+ element.attribute("toolname"),+ element.attribute("tooldescription"),+ ) else {+ continue;+ };+ if !moli_webmcp::is_valid_tool_name(name) {+ continue;+ }+ result.push(FormTool {+ handle,+ name: name.into(),+ metadata: ToolMetadata {+ description: description.into(),+ title: element.attribute("tooltitle").unwrap_or_default().into(),+ input_schema: Some(schema::input_schema(host, handle, |pattern| {+ crate::native_bridge::element::v8_pattern_is_usable(scope, pattern).is_some()+ })),+ annotations: None,+ },+ autosubmit: element.has_attribute("toolautosubmit"),+ });+ }+ result+}++fn synchronize_document(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ document: DomHandle,+) {+ let definitions = form_tools(scope, unsafe { &*host_ptr }, document);+ if definitions.is_empty()+ && !unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .documents+ .contains_key(&document)+ {+ return;+ }+ if document_owner(unsafe { &*host_ptr }, document).is_none() {+ return;+ }+ let context = if document == unsafe { &*host_ptr }.document_handle() {+ Some(scope.get_current_context())+ } else {+ let host = unsafe { &mut *host_ptr };+ host.child_browsing_context_host_for_document_handle(document)+ .and_then(|child| host.child_browsing_context_window_wrapper(scope, child))+ .and_then(|window| window.get_creation_context(scope))+ };+ let Some(context) = context else { return };+ let scope = &mut v8::ContextScope::new(scope, context);+ let Some(document_wrapper) =+ crate::native_bridge::wrapped_handle_value(scope, host_ptr, document)+ .and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())+ else {+ return;+ };+ let Some(target) = model_context_for_document(scope, document_wrapper) else {+ return;+ };+ if check_target(scope, target).is_err() {+ return;+ }+ let removed_names = {+ let entry = &unsafe { &*host_ptr }.native_bridge().web_mcp.documents[&document];+ entry+ .tools+ .iter()+ .filter_map(|(name, tool)| {+ let ToolExecutor::Form {+ handle, autosubmit, ..+ } = tool.executor+ else {+ return None;+ };+ let same = definitions.iter().any(|definition| {+ definition.handle == handle+ && &definition.name == name+ && definition.metadata == tool.metadata+ && definition.autosubmit == autosubmit+ });+ (!same).then(|| name.clone())+ })+ .collect::<Vec<_>>()+ };+ let mut changes = 0;+ for name in removed_names {+ let pending = unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .iter()+ .filter(|(_, pending)| {+ pending.document == document+ && pending.name == name+ && pending.form.as_ref().is_some_and(|form| {+ matches!(+ form.state,+ FormInvocationState::Filling+ | FormInvocationState::Ready+ | FormInvocationState::Invalidated+ )+ })+ })+ .map(|(id, _)| *id)+ .collect::<Vec<_>>();+ for id in pending {+ execution::finish_error(+ scope,+ host_ptr,+ id,+ "Tool definition changed during execution",+ );+ }+ let host = unsafe { &mut *host_ptr };+ let entry = host+ .native_bridge_mut()+ .web_mcp+ .documents+ .get_mut(&document)+ .expect("form document");+ entry.tools.remove(&name);+ let frame_id = entry.frame_id.clone();+ devtools::emit_in_tree(+ host,+ host.native_bridge().web_mcp.documents[&document].frame_tree,+ RendererWebMcpEvent::ToolsRemoved(vec![RendererWebMcpToolId { frame_id, name }]),+ );+ changes += 1;+ }+ for definition in definitions {+ let host = unsafe { &mut *host_ptr };+ let backend_node_id = host.renderer_backend_node_id_for_live_handle(definition.handle);+ 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;+ }+ store.next_registration = store+ .next_registration+ .checked_add(1)+ .expect("WebMCP registration space exhausted");+ let tool = RegisteredTool {+ registration: store.next_registration,+ metadata: definition.metadata,+ stack_trace: None,+ exposed_to: Vec::new(),+ executor: ToolExecutor::Form {+ handle: definition.handle,+ autosubmit: definition.autosubmit,+ backend_node_id,+ },+ abort: None,+ registration_resolver: None,+ };+ let snapshot = devtools::protocol_tool(entry, &definition.name, &tool);+ entry.tools.insert(definition.name, tool);+ let tree = entry.frame_tree;+ devtools::emit_in_tree(host, tree, RendererWebMcpEvent::ToolsAdded(vec![snapshot]));+ changes += 1;+ }+ if changes > 0 {+ let origin = unsafe { &*host_ptr }.native_bridge().web_mcp.documents[&document]+ .origin+ .clone();+ for _ in 0..changes {+ events::queue_tool_change(scope, host_ptr, document, &origin, &[]);+ }+ }+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative/invocation.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative/invocation.rsnew file mode 100644index 000000000..92394d17d--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative/invocation.rs@@ -0,0 +1,306 @@+//! Declarative execution uses native control state and the normal submit path.+use super::super::bindings::document_owner;+use super::super::state::{FormInvocation, FormInvocationState, PendingInvocation, ToolExecutor};+use super::super::{execution, navigation};+use super::schema;+use crate::{+ document_runtime::DomHandle,+ dom::{forms::InputType, native::Node},+ native_bridge::{+ JsContextHost,+ element::{+ dispatch_text_control_event, focus_element, form_control_elements,+ form_control_is_effectively_disabled, is_valid_submit_button,+ submit_form_with_submit_event, text_control_value,+ },+ },+};+use moli_webmcp::{Fill, prepare_fill};++pub(in crate::context_bootstrap::web_mcp) fn start(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+ form: DomHandle,+ autosubmit: bool,+ input: &str,+) {+ let host = unsafe { &*host_ptr };+ if host+ .native_bridge()+ .web_mcp+ .pending+ .values()+ .any(|pending| {+ pending+ .form+ .as_ref()+ .is_some_and(|active| active.handle == form)+ })+ {+ execution::finish_error(scope, host_ptr, id, "Form tool is already running");+ return;+ }+ let Some(plan) = prepare_fill(+ host.dom_host(),+ schema::parameter_controls(host, form),+ input,+ ) else {+ execution::finish_error(scope, host_ptr, id, "Invalid form tool input");+ return;+ };+ let submitter = form_control_elements(host, form)+ .into_iter()+ .find(|control| {+ is_valid_submit_button(host, *control)+ && !form_control_is_effectively_disabled(host, *control)+ });+ if !autosubmit && submitter.is_none() {+ execution::finish_error(scope, host_ptr, id, "Form tool requires a submit button");+ return;+ }+ unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .pending+ .get_mut(&id)+ .expect("form invocation")+ .form = Some(FormInvocation {+ handle: form,+ submitter,+ state: FormInvocationState::Filling,+ });+ for fill in plan {+ let (control, changed) = match fill {+ Fill::Value(handle, value) => {+ let before = text_control_value(unsafe { &*host_ptr }, handle);+ unsafe { &mut *host_ptr }.set_input_value(handle, &value);+ (+ handle,+ before != text_control_value(unsafe { &*host_ptr }, handle),+ )+ }+ Fill::Checked(handle, checked) => {+ let before = unsafe { &*host_ptr }+ .dom_host()+ .node(handle)+ .and_then(Node::as_element)+ .is_some_and(|element| element.checked());+ unsafe { &mut *host_ptr }.set_checked_state(scope, host_ptr, handle, checked);+ (handle, before != checked)+ }+ Fill::Checkable {+ handle,+ selected,+ radio,+ } => {+ let checked = selected.contains(&text_control_value(unsafe { &*host_ptr }, handle));+ if radio && !checked {+ continue;+ }+ let before = unsafe { &*host_ptr }+ .dom_host()+ .node(handle)+ .and_then(Node::as_element)+ .is_some_and(|element| element.checked());+ unsafe { &mut *host_ptr }.set_checked_state(scope, host_ptr, handle, checked);+ (handle, before != checked)+ }+ Fill::Select(handle, selected_values) => {+ let dom = unsafe { &*host_ptr }.dom_host();+ let multiple = dom.get_attribute(handle, "multiple").is_some();+ let mut matched = false;+ let options = dom+ .select_option_elements(handle)+ .into_iter()+ .map(|option| {+ let selected = dom+ .option_value(option)+ .is_some_and(|value| selected_values.contains(&value))+ && (multiple || !matched);+ matched |= selected;+ (option, selected)+ })+ .collect::<Vec<_>>();+ let before = unsafe { &*host_ptr }+ .dom_host()+ .select_selected_option_elements(handle);+ let any_selected = options.iter().any(|(_, selected)| *selected);+ for (option, selected) in options {+ unsafe { &mut *host_ptr }.set_selected_state(scope, host_ptr, option, selected);+ }+ unsafe { &mut *host_ptr }.set_select_explicit_none(+ scope,+ host_ptr,+ handle,+ !any_selected,+ );+ (+ handle,+ before+ != unsafe { &*host_ptr }+ .dom_host()+ .select_selected_option_elements(handle),+ )+ }+ };+ let checkable = unsafe { &*host_ptr }+ .dom_host()+ .node(control)+ .and_then(Node::as_element)+ .is_some_and(|element| {+ element.is_html_input()+ && matches!(element.input_type(), InputType::Checkbox | InputType::Radio)+ });+ if changed {+ dispatch_text_control_event(scope, host_ptr, control, "input");+ }+ if changed || checkable {+ dispatch_text_control_event(scope, host_ptr, control, "change");+ }+ if !form_is_current(unsafe { &*host_ptr }, id, form) {+ execution::finish_error(+ scope,+ host_ptr,+ id,+ "Form tool was removed while filling controls",+ );+ return;+ }+ }+ let Some(pending) = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .pending+ .get_mut(&id)+ else {+ return;+ };+ pending.form.as_mut().expect("form invocation").state = FormInvocationState::Ready;+ unsafe { &mut *host_ptr }.set_web_mcp_activity(form, true, false);+ if let Some(submitter) = submitter {+ unsafe { &mut *host_ptr }.set_web_mcp_activity(submitter, false, true);+ }+ if autosubmit {+ let _ = submit_form_with_submit_event(scope, host_ptr, form, submitter, false);+ } else if let Some(submitter) = submitter {+ focus_element(scope, host_ptr, submitter);+ }+}++fn form_is_current(host: &JsContextHost, id: u64, form: DomHandle) -> bool {+ let store = &host.native_bridge().web_mcp;+ let Some(pending) = store.pending.get(&id) else {+ return false;+ };+ document_owner(host, pending.document) == Some(pending.owner)+ && host.dom_host().is_connected(form)+ && store+ .documents+ .get(&pending.document)+ .and_then(|entry| entry.tools.get(&pending.name))+ .is_some_and(+ |tool| matches!(tool.executor, ToolExecutor::Form { handle, .. } if handle == form),+ )+}++pub(crate) fn begin_form_submit(host: &mut JsContextHost, form: DomHandle) -> Option<u64> {+ host.native_bridge_mut()+ .web_mcp+ .pending+ .iter_mut()+ .find_map(|(id, pending)| {+ let active = pending.form.as_mut()?;+ if active.handle != form || !matches!(active.state, FormInvocationState::Ready) {+ return None;+ }+ active.state = FormInvocationState::Submitting;+ Some(*id)+ })+}++pub(crate) fn finish_form_submit<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+ event: v8::Local<'s, v8::Object>,+ allows_default: bool,+) {+ let Some(pending) = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .pending+ .get_mut(&id)+ else {+ return;+ };+ let form = pending.form.as_mut().expect("form invocation");+ if let Some(response) =+ crate::context_bootstrap::events::take_submit_event_response(scope, event)+ {+ form.state = FormInvocationState::Responding(v8::Global::new(scope, response));+ execution::await_response(scope, host_ptr, id, response);+ } else if !allows_default {+ execution::finish_error(+ scope,+ host_ptr,+ id,+ "Submit was prevented without respondWith()",+ );+ } else {+ form.state = FormInvocationState::Ready;+ }+}++pub(crate) fn form_submission_failed(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+) {+ execution::finish_error(scope, host_ptr, id, "Form validation or submission failed");+}++pub(crate) fn finish_form_navigation(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ form: DomHandle,+ accepted: bool,+) {+ let id = navigation::form_invocation(unsafe { &*host_ptr }, form);+ if let Some(id) = id {+ if accepted {+ execution::finish_navigation(scope, host_ptr, id);+ } else {+ form_submission_failed(scope, host_ptr, id);+ }+ }+}++pub(in crate::context_bootstrap::web_mcp) fn finish_activity(+ host: &mut JsContextHost,+ pending: &PendingInvocation,+) {+ if let Some(form) = &pending.form {+ host.set_web_mcp_activity(form.handle, false, false);+ if let Some(submitter) = form.submitter {+ host.set_web_mcp_activity(submitter, false, false);+ }+ }+}++pub(crate) fn cancel_form_execution(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ form: DomHandle,+) {+ // start() allows at most one pending execution per form.+ let id = unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .iter()+ .find_map(|(id, pending)| (pending.form.as_ref()?.handle == form).then_some(*id));+ if let Some(id) = id {+ execution::finish_error(scope, host_ptr, id, "Form tool execution was reset");+ }+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative/schema.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative/schema.rsnew file mode 100644index 000000000..19a2e83e1--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/declarative/schema.rs@@ -0,0 +1,47 @@+//! Discover browser-owned form controls for the shared WebMCP DOM algorithms.++use moli_webmcp::ParameterControls;++use crate::{+ document_runtime::DomHandle,+ dom::native::Node,+ native_bridge::{+ JsContextHost,+ element::{+ control_label_handles, form_control_elements, form_control_is_effectively_disabled,+ },+ },+};++pub(super) fn parameter_controls(host: &JsContextHost, form: DomHandle) -> ParameterControls {+ let mut groups = ParameterControls::new();+ for control in form_control_elements(host, form) {+ let Some(element) = host.dom_host().node(control).and_then(Node::as_element) else {+ continue;+ };+ let readonly = element.has_attribute("readonly")+ && (element.is_html_textarea()+ || (element.is_html_input() && element.input_type().supports_readonly()));+ if form_control_is_effectively_disabled(host, control) || readonly {+ continue;+ }+ let name = element.attribute("name").unwrap_or_default().trim();+ if !name.is_empty() {+ groups.entry(name.into()).or_default().push(control);+ }+ }+ groups+}++pub(super) fn input_schema(+ host: &JsContextHost,+ form: DomHandle,+ pattern_is_usable: impl FnMut(&str) -> bool,+) -> String {+ moli_webmcp::input_schema(+ host.dom_host(),+ parameter_controls(host, form),+ |control| control_label_handles(host, control),+ pattern_is_usable,+ )+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/devtools.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/devtools.rsnew file mode 100644index 000000000..0ffc476ec--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/devtools.rs@@ -0,0 +1,215 @@+use super::bindings::document_owner;+use super::execution;+use super::state::{DocumentTools, RegisteredTool, ToolExecutor};+use crate::document_runtime::DomHandle;+use crate::native_bridge::JsContextHost;+use moli_page_types::{+ DevToolsSessionKey, RendererWebMcpAnnotations, RendererWebMcpEvent, RendererWebMcpObservation,+ RendererWebMcpTool,+};++use moli_page_types::{RendererWebMcpCommand, RendererWebMcpError};++pub(crate) fn configure_session(+ host: &mut JsContextHost,+ session: DevToolsSessionKey,+ enabled: bool,+) {+ if !enabled {+ host.native_bridge_mut()+ .web_mcp+ .enabled_sessions+ .remove(&session);+ return;+ }+ host.native_bridge_mut()+ .web_mcp+ .enabled_sessions+ .insert(session.clone());+ let tools = host+ .native_bridge()+ .web_mcp+ .documents+ .iter()+ .filter(|(document, entry)| {+ entry.frame_tree.is_none() && document_owner(host, **document) == Some(entry.owner)+ })+ .flat_map(|(_, entry)| {+ entry+ .tools+ .iter()+ .map(|(name, tool)| protocol_tool(entry, name, tool))+ })+ .collect::<Vec<_>>();+ if !tools.is_empty() {+ host.append_live_turn_observation(crate::runtime::RendererProtocolObservation::WebMcp(+ RendererWebMcpObservation {+ session,+ event: RendererWebMcpEvent::ToolsAdded(tools),+ },+ ));+ }+}++pub(crate) fn dispatch_command<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ session: DevToolsSessionKey,+ command: RendererWebMcpCommand,+) -> Result<Option<u64>, RendererWebMcpError> {+ match command {+ RendererWebMcpCommand::Enable | RendererWebMcpCommand::Disable => {+ configure_session(+ unsafe { &mut *host_ptr },+ session,+ matches!(command, RendererWebMcpCommand::Enable),+ );+ Ok(None)+ }+ RendererWebMcpCommand::InvokeTool {+ frame_id,+ name,+ input,+ } => {+ if !unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .enabled_sessions+ .contains(&session)+ {+ return Err(RendererWebMcpError::NotEnabled);+ }+ let found = {+ let host = unsafe { &*host_ptr };+ host.native_bridge()+ .web_mcp+ .documents+ .iter()+ .find(|(document, entry)| {+ entry.frame_tree.is_none()+ && entry.frame_id == frame_id+ && document_owner(host, **document) == Some(entry.owner)+ })+ .map(|(document, entry)| {+ (+ *document,+ entry.tools.contains_key(&name),+ v8::Global::new(scope, v8::Local::new(scope, &entry.target)),+ )+ })+ };+ let Some((document, registered, target)) = found else {+ return Err(RendererWebMcpError::InvalidParams(if frame_id.is_none() {+ "Tool not found"+ } else {+ "No frame for given id found"+ }));+ };+ if !registered {+ return Err(RendererWebMcpError::InvalidParams("Tool not found"));+ }+ execution::schedule_invocation(+ scope, host_ptr, document, document, target, name, input, None, None,+ )+ .map(Some)+ .ok_or(RendererWebMcpError::SchedulingFailed)+ }+ RendererWebMcpCommand::CancelInvocation { invocation_id } => {+ if unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .get(&invocation_id)+ .is_none_or(|pending| pending.frame_tree.is_some())+ || !execution::cancel_invocation(scope, host_ptr, invocation_id)+ {+ return Err(RendererWebMcpError::InvalidParams(+ "No pending execution for invocation id",+ ));+ }+ Ok(None)+ }+ }+}++pub(super) fn document_frame_id(host: &JsContextHost, document: DomHandle) -> Option<String> {+ let child = host.child_browsing_context_host_for_document_handle(document)?;+ host.frame_owner_frame_id_for_child_handle(child)+ .map(|frame| frame.0)+}++pub(super) fn protocol_tool(+ entry: &DocumentTools,+ name: &str,+ tool: &RegisteredTool,+) -> RendererWebMcpTool {+ let metadata = &tool.metadata;+ let (autosubmit, backend_node_id) = match tool.executor {+ ToolExecutor::Form {+ autosubmit,+ backend_node_id,+ ..+ } => (autosubmit, backend_node_id),+ ToolExecutor::Callback(_) => (false, None),+ };+ RendererWebMcpTool {+ autosubmit,+ backend_node_id,+ frame_id: entry.frame_id.clone(),+ name: name.into(),+ description: metadata.description.clone(),+ input_schema: metadata.input_schema.clone(),+ stack_trace: tool.stack_trace.clone(),+ annotations: metadata+ .annotations+ .map(|annotations| RendererWebMcpAnnotations {+ read_only: annotations.read_only,+ consequential: annotations.consequential,+ untrusted_content: annotations.untrusted_content,+ debugging: annotations.debugging,+ }),+ }+}++pub(super) fn capture_registration_stack(+ scope: &mut v8::PinScope<'_, '_>,+) -> Option<serde_json::Value> {+ let stack = v8::StackTrace::current_stack_trace(scope, 32)?;+ let frames = (0..stack.get_frame_count())+ .filter_map(|index| {+ let frame = stack.get_frame(scope, index)?;+ let function_name = frame+ .get_function_name(scope)+ .map(|name| name.to_rust_string_lossy(scope))+ .unwrap_or_default();+ let url = frame+ .get_script_name_or_source_url(scope)+ .map(|name| name.to_rust_string_lossy(scope))+ .unwrap_or_default();+ Some(serde_json::json!({+ "functionName":function_name,"url":url,+ "scriptId":frame.get_script_id().to_string(),+ "lineNumber":frame.get_line_number().saturating_sub(1),+ "columnNumber":frame.get_column().saturating_sub(1),+ }))+ })+ .collect::<Vec<_>>();+ (!frames.is_empty()).then(|| serde_json::json!({"callFrames":frames}))+}++pub(crate) fn emit(host: &JsContextHost, event: RendererWebMcpEvent) {+ for session in &host.native_bridge().web_mcp.enabled_sessions {+ host.append_live_turn_observation(crate::runtime::RendererProtocolObservation::WebMcp(+ RendererWebMcpObservation {+ session: session.clone(),+ event: event.clone(),+ },+ ));+ }+}++pub(super) fn emit_in_tree(host: &JsContextHost, tree: Option<u64>, event: RendererWebMcpEvent) {+ if tree.is_none() {+ emit(host, event);+ }+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/events.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/events.rsnew file mode 100644index 000000000..8bb5d163a--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/events.rs@@ -0,0 +1,213 @@+//! Trusted tool events and one toolchange task per registry notification.++use super::bindings::{check_target, document_owner, js_string};+use super::tasks::queue_task;+use crate::document_runtime::DomHandle;+use crate::native_bridge::JsContextHost;+use crate::util::{get_private_value, set_private_value};+use crate::web_api_interfaces;++pub(super) const LISTENERS_SLOT: &str = "__moliModelContextListeners";+const HANDLERS: &[(&str, &str)] = &[+ ("ontoolchange", "toolchange"),+ ("ontoolactivated", "toolactivated"),+ ("ontoolcancel", "toolcancel"),+];++pub(super) fn dispatch_event<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ target: v8::Local<'s, v8::Object>,+ event_type: &str,+ name: Option<&str>,+) {+ let event = if let Some(name) = name {+ let constructor_name = if event_type == "toolcancel" {+ "ToolCancelEvent"+ } else {+ "ToolActivatedEvent"+ };+ let Ok(constructor) = crate::context_bootstrap::ensure_intrinsic_interface_constructor(+ scope,+ constructor_name,+ ) else {+ return;+ };+ let init = v8::Object::new(scope);+ let _ = init.create_data_property(+ scope,+ js_string(scope, "toolName").into(),+ js_string(scope, name).into(),+ );+ let Some(event) =+ constructor.new_instance(scope, &[js_string(scope, event_type).into(), init.into()])+ else {+ return;+ };+ event+ } else {+ let event = crate::context_bootstrap::events::new_event_state(scope);+ crate::context_bootstrap::events::initialize_event_object(+ scope, event, event_type, false, false,+ );+ event+ };+ crate::context_bootstrap::events::mark_event_trusted(scope, event);+ let owner = crate::context_bootstrap::shared_event_targets::shared_target_owner(scope, target);+ crate::context_bootstrap::media_queries::dispatch_simple_event_target_event(+ scope,+ owner,+ LISTENERS_SLOT,+ event_type,+ event,+ );+}++pub(super) fn handler_getter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ mut rv: v8::ReturnValue<'_, v8::Value>,+) {+ if !web_api_interfaces::ModelContext::is_instance(scope, args.this()) {+ let error = v8::Exception::type_error(scope, js_string(scope, "Illegal invocation"));+ scope.throw_exception(error);+ return;+ }+ let index = args.data().int32_value(scope).unwrap_or(-1) as usize;+ let Some((property, _)) = HANDLERS.get(index) else {+ return;+ };+ let target =+ crate::context_bootstrap::shared_event_targets::shared_target_owner(scope, args.this());+ rv.set(get_private_value(scope, target, property).unwrap_or_else(|| v8::null(scope).into()));+}++pub(super) fn handler_setter<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ if !web_api_interfaces::ModelContext::is_instance(scope, args.this()) {+ let error = v8::Exception::type_error(scope, js_string(scope, "Illegal invocation"));+ scope.throw_exception(error);+ return;+ }+ let index = args.data().int32_value(scope).unwrap_or(-1) as usize;+ let Some((property, event_type)) = HANDLERS.get(index) else {+ return;+ };+ let target =+ crate::context_bootstrap::shared_event_targets::shared_target_owner(scope, args.this());+ let active = args.get(0).is_object();+ let value = if active {+ args.get(0)+ } else {+ v8::null(scope).into()+ };+ set_private_value(scope, target, property, value);+ crate::context_bootstrap::media_queries::simple_object_event_set_ordered_handler(+ scope,+ target,+ LISTENERS_SLOT,+ event_type,+ property,+ active,+ );+}++pub(super) fn queue_tool_change<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ document: DomHandle,+ origin: &url::Origin,+ exposed_to: &[url::Origin],+) {+ queue_tool_change_tasks(scope, host_ptr, document, origin, exposed_to, false);+}++pub(super) fn queue_form_removal_change<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ document: DomHandle,+ origin: &url::Origin,+) {+ // Synchronous invalidation occurs inside the DOM mutation. Its registration+ // synchronization is queued at the end of that turn. Relay each removal+ // notification so synchronization precedes author event listeners, as it+ // does before the browser's notification returns to Blink.+ queue_tool_change_tasks(scope, host_ptr, document, origin, &[], true);+}++fn queue_tool_change_tasks<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ document: DomHandle,+ origin: &url::Origin,+ exposed_to: &[url::Origin],+ relay: bool,+) {+ let targets = {+ let host = unsafe { &*host_ptr };+ let tree = host.native_bridge().web_mcp.documents[&document].frame_tree;+ host.native_bridge()+ .web_mcp+ .documents+ .iter()+ .filter(|(document, entry)| {+ entry.frame_tree == tree+ && document_owner(host, **document) == Some(entry.owner)+ && host+ .document_permissions_policy_for_document_handle(**document)+ .is_some_and(|policy| policy.tools_enabled())+ && (&entry.origin == origin || exposed_to.contains(&entry.origin))+ })+ .map(|(document, entry)| (*document, v8::Local::new(scope, &entry.target)))+ .collect::<Vec<_>>()+ };+ for (_, target) in targets {+ let Some(context) = target.get_creation_context(scope) else {+ continue;+ };+ let scope = &mut v8::ContextScope::new(scope, context);+ let callback = if relay {+ v8::Function::builder(tool_change_relay_callback)+ .data(target.into())+ .build(scope)+ } else {+ v8::Function::builder(tool_change_callback)+ .data(target.into())+ .build(scope)+ }+ .expect("WebMCP toolchange task");+ queue_task(scope, host_ptr, callback);+ }+}++fn tool_change_relay_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Ok(target) = v8::Local::<v8::Object>::try_from(args.data()) else {+ return;+ };+ if let Ok((host_ptr, _)) = check_target(scope, target) {+ let callback = v8::Function::builder(tool_change_callback)+ .data(target.into())+ .build(scope)+ .expect("WebMCP toolchange dispatch task");+ queue_task(scope, host_ptr, callback);+ }+}++fn tool_change_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Ok(target) = v8::Local::<v8::Object>::try_from(args.data()) else {+ return;+ };+ if check_target(scope, target).is_ok() {+ dispatch_event(scope, target, "toolchange", None);+ }+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/execution.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/execution.rsnew file mode 100644index 000000000..86c107b2e--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/execution.rs@@ -0,0 +1,740 @@+use super::bindings::{document_frame_tree, document_owner, dom_error, js_string};+use super::devtools::document_frame_id;+use super::events::dispatch_event;+use super::state::{+ AbortRegistration, CallerResult, FormInvocationState, PendingDelivery, PendingInvocation,+ ToolExecutor,+};+use super::tasks::{invocation_context, queue_task, remove_abort_registration, signal_reason};+use super::{declarative, devtools};+use crate::document_runtime::DomHandle;+use crate::native_bridge::JsContextHost;+use moli_page_types::{+ RendererWebMcpEvent, RendererWebMcpObservation, RendererWebMcpResult, RendererWebMcpToolId,+};++use crate::{+ abort_signal_route::ResolvedAbortSignal,+ window_webidl_callback::PreparedWindowWebIdlCallbackFunction,+ window_webidl_callback::PreparedWindowWebIdlCallbackFunctionOutcome,+};++fn next_invocation_id() -> u64 {+ static NEXT_INVOCATION: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);+ NEXT_INVOCATION+ .fetch_update(+ std::sync::atomic::Ordering::Relaxed,+ std::sync::atomic::Ordering::Relaxed,+ |id| id.checked_add(1),+ )+ .expect("WebMCP invocation space exhausted")+}++fn register_caller_abort<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ id: u64,+ signal: Option<v8::Local<'s, v8::Object>>,+) -> Option<AbortRegistration> {+ signal.map(|signal| {+ let data = v8::BigInt::new_from_u64(scope, id);+ let algorithm = v8::Function::builder(caller_abort_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP invocation abort algorithm");+ ResolvedAbortSignal::resolve(scope, signal)+ .expect("validated AbortSignal")+ .register_algorithm(scope, algorithm);+ AbortRegistration {+ signal: v8::Global::new(scope, signal),+ algorithm: v8::Global::new(scope, algorithm),+ }+ })+}++fn queue_delivery(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+ delivery: PendingDelivery,+) {+ let resolver = v8::Local::new(scope, &delivery.resolver);+ let Some(context) = resolver.get_promise(scope).get_creation_context(scope) else {+ remove_abort_registration(scope, delivery.caller_abort);+ return;+ };+ unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .deliveries+ .insert(id, delivery);+ let scope = &mut v8::ContextScope::new(scope, context);+ let data = v8::BigInt::new_from_u64(scope, id);+ let callback = v8::Function::builder(delivery_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP caller result task");+ queue_task(scope, host_ptr, callback);+}++fn complete_for_caller(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+ pending: &mut PendingInvocation,+ result: CallerResult,+) {+ declarative::invocation::finish_activity(unsafe { &mut *host_ptr }, pending);+ if let Some(resolver) = pending.resolver.take() {+ queue_delivery(+ scope,+ host_ptr,+ id,+ PendingDelivery {+ caller_owner: pending.caller_owner,+ caller_document: pending.caller_document,+ resolver,+ caller_abort: pending.caller_abort.take(),+ result,+ },+ );+ } else {+ remove_abort_registration(scope, pending.caller_abort.take());+ }+}++pub(super) fn reject_unavailable_tool<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ caller_document: DomHandle,+ resolver: v8::Local<'s, v8::PromiseResolver>,+ signal: Option<v8::Local<'s, v8::Object>>,+) {+ let id = next_invocation_id();+ let caller_abort = register_caller_abort(scope, id, signal);+ queue_delivery(+ scope,+ host_ptr,+ id,+ PendingDelivery {+ caller_owner: document_owner(unsafe { &*host_ptr }, caller_document)+ .expect("active caller"),+ caller_document,+ resolver: v8::Global::new(scope, resolver),+ caller_abort,+ result: CallerResult::Error(+ "Tool invocation failed: tool or target document is no longer available.".into(),+ ),+ },+ );+}++fn delivery_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((host_ptr, id)) = invocation_context(scope, &args) else {+ return;+ };+ let Some(delivery) = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .deliveries+ .remove(&id)+ else {+ return;+ };+ remove_abort_registration(scope, delivery.caller_abort);+ if document_owner(unsafe { &*host_ptr }, delivery.caller_document)+ != Some(delivery.caller_owner)+ {+ return;+ }+ let resolver = v8::Local::new(scope, &delivery.resolver);+ match delivery.result {+ CallerResult::Completed(value) => {+ let _ = resolver.resolve(scope, js_string(scope, &value).into());+ }+ CallerResult::Navigated => {+ let _ = resolver.resolve(scope, v8::null(scope).into());+ }+ CallerResult::Error(message) => {+ let error = dom_error(scope, "UnknownError", &message);+ let _ = resolver.reject(scope, error);+ }+ }+}++// Each invocation owns its signal and resolver independently of the tool+// registration. Neither an unregister nor a late callback settlement can+// complete a different invocation of the same tool.+#[allow(clippy::too_many_arguments)]+pub(super) fn schedule_invocation<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ caller_document: DomHandle,+ document: DomHandle,+ target: v8::Global<v8::Object>,+ name: String,+ input: String,+ resolver: Option<v8::Local<'s, v8::PromiseResolver>>,+ caller_signal: Option<v8::Local<'s, v8::Object>>,+) -> Option<u64> {+ let target_context = v8::Local::new(scope, &target).get_creation_context(scope)?;+ let scope = &mut v8::ContextScope::new(scope, target_context);+ let signal =+ crate::native_bridge::abort::create_signal(scope, unsafe { &mut *host_ptr }, false, None)?;+ let id = next_invocation_id();+ let data = v8::BigInt::new_from_u64(scope, id);+ let caller_abort = register_caller_abort(scope, id, caller_signal);+ let owner = document_owner(unsafe { &*host_ptr }, document).expect("active tool document");+ let caller_owner =+ document_owner(unsafe { &*host_ptr }, caller_document).expect("active caller document");+ let frame_tree = document_frame_tree(unsafe { &*host_ptr }, document);+ unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .pending+ .insert(+ id,+ PendingInvocation {+ document,+ owner,+ caller_owner,+ caller_document,+ frame_tree,+ name,+ target,+ resolver: resolver.map(|resolver| v8::Global::new(scope, resolver)),+ signal: v8::Global::new(scope, signal),+ caller_abort,+ input,+ caller_cancel_requested: false,+ form: None,+ },+ );+ let start = v8::Function::builder(start_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP invocation task");+ queue_task(scope, host_ptr, start);+ Some(id)+}++fn start_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((host_ptr, id)) = invocation_context(scope, &args) else {+ return;+ };+ let invocation = {+ let host = unsafe { &*host_ptr };+ let Some(pending) = host.native_bridge().web_mcp.pending.get(&id) else {+ return;+ };+ let executor = host+ .native_bridge()+ .web_mcp+ .documents+ .get(&pending.document)+ .filter(|entry| {+ entry.owner == pending.owner+ && document_owner(host, pending.document) == Some(entry.owner)+ })+ .and_then(|entry| entry.tools.get(&pending.name))+ .map(|tool| match &tool.executor {+ ToolExecutor::Callback(callback) => {+ InvocationExecutor::Callback(callback.prepare(scope))+ }+ ToolExecutor::Form {+ handle, autosubmit, ..+ } => InvocationExecutor::Form(*handle, *autosubmit),+ });+ (+ executor,+ pending.document,+ pending.input.clone(),+ pending.name.clone(),+ v8::Local::new(scope, &pending.signal),+ v8::Local::new(scope, &pending.target),+ pending.frame_tree,+ )+ };+ let (Some(executor), document, input, name, signal, target, tree) = invocation else {+ finish_error(scope, host_ptr, id, "Tool is no longer registered");+ return;+ };+ devtools::emit_in_tree(+ unsafe { &*host_ptr },+ tree,+ RendererWebMcpEvent::ToolInvoked {+ tool: RendererWebMcpToolId {+ frame_id: document_frame_id(unsafe { &*host_ptr }, document),+ name: name.clone(),+ },+ invocation_id: id,+ input: input.clone(),+ },+ );+ let callback = match executor {+ InvocationExecutor::Callback(callback) => callback,+ InvocationExecutor::Form(form, autosubmit) => {+ let owner = document_owner(unsafe { &*host_ptr }, document);+ declarative::invocation::start(scope, host_ptr, id, form, autosubmit, &input);+ if owner.is_some() && document_owner(unsafe { &*host_ptr }, document) == owner {+ dispatch_event(scope, target, "toolactivated", Some(&name));+ }+ return;+ }+ };+ let callback_unavailable = "Tool callback is no longer available";+ let result = callback.invoke(+ scope,+ unsafe { &*host_ptr },+ v8::undefined(scope).into(),+ &[],+ |scope, callback, receiver, _arguments| {+ let try_catch = std::pin::pin!(v8::TryCatch::new(scope));+ let mut scope = try_catch.init();+ // Invoke enters the callback's relevant realm before allocating+ // input (including nested objects/arrays) and its options object.+ let input = v8::json::parse(&scope, js_string(&scope, &input))+ .filter(|input| input.is_object())+ .ok_or(CallbackInvocationError::InvalidInput)?;+ let options = v8::Object::new(&scope);+ let _ = options.create_data_property(+ &scope,+ js_string(&scope, "signal").into(),+ signal.into(),+ );+ let resolver = v8::PromiseResolver::new(&scope)+ .ok_or(CallbackInvocationError::CallbackUnavailable)?;+ match callback.call(&scope, receiver, &[input, options.into()]) {+ Some(value) => {+ resolver+ .resolve(&scope, value)+ .ok_or(CallbackInvocationError::CallbackUnavailable)?;+ }+ None => {+ let exception = scope+ .exception()+ .unwrap_or_else(|| v8::undefined(&scope).into());+ scope.reset();+ resolver+ .reject(&scope, exception)+ .ok_or(CallbackInvocationError::CallbackUnavailable)?;+ }+ }+ Ok(v8::Global::new(&scope, resolver.get_promise(&scope)))+ },+ );+ // Chromium activates a live tool even when parsing its input fails. Keep+ // that failure distinct from a retired or otherwise unavailable callback,+ // and retain the owner before finish_error removes the pending invocation.+ let activation_owner = match result {+ PreparedWindowWebIdlCallbackFunctionOutcome::Returned(promise) => {+ let promise = v8::Local::new(scope, &promise);+ await_response(scope, host_ptr, id, promise);+ unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .get(&id)+ .map(|pending| pending.owner)+ }+ PreparedWindowWebIdlCallbackFunctionOutcome::Failed(+ CallbackInvocationError::InvalidInput,+ ) => {+ let owner = unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .get(&id)+ .map(|pending| pending.owner);+ finish_error(scope, host_ptr, id, "Invalid tool input");+ owner+ }+ PreparedWindowWebIdlCallbackFunctionOutcome::Failed(+ CallbackInvocationError::CallbackUnavailable,+ )+ | PreparedWindowWebIdlCallbackFunctionOutcome::Retired => {+ finish_error(scope, host_ptr, id, callback_unavailable);+ None+ }+ };+ if activation_owner.is_some()+ && document_owner(unsafe { &*host_ptr }, document) == activation_owner+ {+ dispatch_event(scope, target, "toolactivated", Some(&name));+ }+}++enum CallbackInvocationError {+ InvalidInput,+ CallbackUnavailable,+}++enum InvocationExecutor {+ Callback(PreparedWindowWebIdlCallbackFunction),+ Form(DomHandle, bool),+}++pub(super) fn await_response<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+ promise: v8::Local<'s, v8::Promise>,+) {+ if !unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .contains_key(&id)+ {+ return;+ }+ let data = v8::BigInt::new_from_u64(scope, id);+ let fulfilled = v8::Function::builder(fulfilled_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP fulfillment callback");+ let rejected = v8::Function::builder(rejected_callback)+ .data(data.into())+ .build(scope)+ .expect("WebMCP rejection callback");+ let _ = promise.then2(scope, fulfilled, rejected);+}++fn caller_abort_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((host_ptr, id)) = invocation_context(scope, &args) else {+ return;+ };+ let delivery = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .deliveries+ .remove(&id);+ if let Some(delivery) = delivery {+ let reason = delivery+ .caller_abort+ .as_ref()+ .map(|abort| signal_reason(scope, v8::Local::new(scope, &abort.signal)))+ .unwrap_or_else(|| crate::native_bridge::abort::abort_error_value(scope));+ remove_abort_registration(scope, delivery.caller_abort);+ let resolver = v8::Local::new(scope, &delivery.resolver);+ let _ = resolver.reject(scope, reason);+ return;+ }+ let rejection = {+ let Some(pending) = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .pending+ .get_mut(&id)+ else {+ return;+ };+ if pending.caller_cancel_requested {+ return;+ }+ pending.caller_cancel_requested = true;+ (+ v8::Local::new(+ scope,+ &pending.resolver.take().expect("page caller resolver"),+ ),+ pending+ .caller_abort+ .as_ref()+ .map(|abort| v8::Local::new(scope, &abort.signal)),+ )+ };+ let (resolver, signal) = rejection;+ let reason = signal+ .map(|signal| signal_reason(scope, signal))+ .unwrap_or_else(|| crate::native_bridge::abort::abort_error_value(scope));+ let _ = resolver.reject(scope, reason);+ // The caller's rejection reaction precedes the target signal's abort event.+ // An already posted invocation still starts before this cancellation task.+ let cancel = v8::Function::builder(cancel_callback)+ .data(args.data())+ .build(scope)+ .expect("WebMCP cancellation task");+ queue_task(scope, host_ptr, cancel);+}++fn cancel_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((host_ptr, id)) = invocation_context(scope, &args) else {+ return;+ };+ cancel_invocation(scope, host_ptr, id);+}++pub(super) fn cancel_invocation(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+) -> bool {+ // Take before dispatching author abort callbacks: late settlements and+ // reentrant cancellation must see an already completed invocation.+ let Some(mut pending) = unsafe { &mut *host_ptr }+ .native_bridge_mut()+ .web_mcp+ .pending+ .remove(&id)+ else {+ return false;+ };+ cleanup_invocation(scope, host_ptr, &mut pending);+ devtools::emit_in_tree(+ unsafe { &*host_ptr },+ pending.frame_tree,+ RendererWebMcpEvent::ToolResponded {+ invocation_id: id,+ result: RendererWebMcpResult::Canceled,+ },+ );+ if let Some(resolver) = pending.resolver.take() {+ let resolver = v8::Local::new(scope, &resolver);+ let reason = crate::native_bridge::abort::abort_error_value(scope);+ let _ = resolver.reject(scope, reason);+ }+ abort_target(scope, host_ptr, &pending);+ true+}++pub(super) fn abort_target(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ pending: &PendingInvocation,+) {+ let signal = v8::Local::new(scope, &pending.signal);+ let reason = crate::native_bridge::abort::abort_error_value(scope);+ crate::native_bridge::abort::abort_signal(scope, signal, reason);+ if document_owner(unsafe { &*host_ptr }, pending.document) == Some(pending.owner) {+ dispatch_event(+ scope,+ v8::Local::new(scope, &pending.target),+ "toolcancel",+ Some(&pending.name),+ );+ }+}++fn fulfilled_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((host_ptr, id)) = invocation_context(scope, &args) else {+ return;+ };+ let invalidated = {+ let Some(pending) = unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .get(&id)+ else {+ return;+ };+ pending+ .form+ .as_ref()+ .is_some_and(|form| matches!(form.state, FormInvocationState::Invalidated))+ };+ if invalidated {+ finish_error(+ scope,+ host_ptr,+ id,+ "Form tool was removed before its response completed",+ );+ return;+ }+ let (output, exception) = {+ let try_catch = std::pin::pin!(v8::TryCatch::new(scope));+ let mut scope = try_catch.init();+ let value = args.get(0);+ let output = if value.is_object() {+ v8::json::stringify(&scope, value)+ } else {+ value.to_string(&scope)+ };+ let output = output.map(|value| value.to_rust_string_lossy(&scope));+ let exception = scope.exception();+ scope.reset();+ (output, exception)+ };+ let Some(output) = output else {+ let imperative = unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .get(&id)+ .is_some_and(|pending| pending.form.is_none());+ finish_failure(+ scope,+ host_ptr,+ id,+ "Failed to serialize tool result",+ exception.filter(|_| imperative),+ );+ return;+ };+ // Serializing may invoke toJSON; it may have canceled or retired this call.+ let Some(mut pending) = take_active_invocation(unsafe { &mut *host_ptr }, id) else {+ return;+ };+ let output = if output.is_empty() {+ "Operation succeeded"+ } else {+ &output+ };+ devtools::emit_in_tree(+ unsafe { &*host_ptr },+ pending.frame_tree,+ RendererWebMcpEvent::ToolResponded {+ invocation_id: id,+ result: RendererWebMcpResult::Completed(output.into()),+ },+ );+ complete_for_caller(+ scope,+ host_ptr,+ id,+ &mut pending,+ CallerResult::Completed(output.into()),+ );+}++fn rejected_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some((host_ptr, id)) = invocation_context(scope, &args) else {+ return;+ };+ let declarative = unsafe { &*host_ptr }+ .native_bridge()+ .web_mcp+ .pending+ .get(&id)+ .is_some_and(|pending| pending.form.is_some());+ // Do not call author toString while reporting an arbitrary rejection value.+ finish_failure(+ scope,+ host_ptr,+ id,+ "Tool callback failed",+ (!declarative).then(|| args.get(0)),+ );+}++pub(super) fn finish_navigation(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+) {+ let Some(mut pending) = take_active_invocation(unsafe { &mut *host_ptr }, id) else {+ return;+ };+ if !pending+ .form+ .as_ref()+ .is_some_and(|form| matches!(form.state, FormInvocationState::Navigating))+ {+ devtools::emit_in_tree(+ unsafe { &*host_ptr },+ pending.frame_tree,+ RendererWebMcpEvent::ToolResponded {+ invocation_id: id,+ result: RendererWebMcpResult::Completed("null".into()),+ },+ );+ }+ complete_for_caller(scope, host_ptr, id, &mut pending, CallerResult::Navigated);+}++pub(super) fn finish_error(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+ message: &str,+) {+ finish_failure(scope, host_ptr, id, message, None);+}++fn finish_failure<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ id: u64,+ message: &str,+ exception: Option<v8::Local<'s, v8::Value>>,+) {+ let Some(mut pending) = take_active_invocation(unsafe { &mut *host_ptr }, id) else {+ return;+ };+ let (sessions, wrapper) = {+ let store = &unsafe { &*host_ptr }.native_bridge().web_mcp;+ (+ store+ .enabled_sessions+ .iter()+ .filter(|_| pending.frame_tree.is_none())+ .cloned()+ .collect::<Vec<_>>(),+ store.object_wrapper.clone(),+ )+ };+ for session in sessions {+ let exception = exception.and_then(|value| wrapper.as_ref()?.wrap(scope, &session, value));+ let message = if exception.is_some() {+ String::new()+ } else {+ message.into()+ };+ unsafe { &*host_ptr }.append_live_turn_observation(+ crate::runtime::RendererProtocolObservation::WebMcp(RendererWebMcpObservation {+ session,+ event: RendererWebMcpEvent::ToolResponded {+ invocation_id: id,+ result: RendererWebMcpResult::Error { message, exception },+ },+ }),+ );+ }+ complete_for_caller(+ scope,+ host_ptr,+ id,+ &mut pending,+ CallerResult::Error(message.into()),+ );+}++pub(super) fn cleanup_invocation(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+ pending: &mut PendingInvocation,+) {+ declarative::invocation::finish_activity(unsafe { &mut *host_ptr }, pending);+ remove_abort_registration(scope, pending.caller_abort.take());+}++// The target owns its pending record until completion or its cancellation task.+// A caller rejection does not prevent an earlier target reaction from finishing.+fn take_active_invocation(host: &mut JsContextHost, id: u64) -> Option<PendingInvocation> {+ host.native_bridge_mut().web_mcp.pending.remove(&id)+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/lifecycle.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/lifecycle.rsnew file mode 100644index 000000000..cdfc130d5--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/lifecycle.rs@@ -0,0 +1,160 @@+//! Retire document state before running author code at a browser task boundary.++use moli_page_types::{RendererWebMcpEvent, RendererWebMcpResult, RendererWebMcpToolId};++use crate::{+ native_bridge::{JsContextHost, WindowDocumentOwner},+ util::context_host_ptr_from_global_bridge,+};++use super::{+ bindings::dom_error,+ execution, navigation,+ state::ModelContextStore,+ tasks::{queue_task, remove_abort_registration},+};++impl ModelContextStore {+ pub(crate) fn needs_retirement_task(&self) -> bool {+ !self.retirement_task_queued+ && (!self.retired_resolvers.is_empty()+ || !self.retired_aborts.is_empty()+ || !self.retired_invocations.is_empty()+ || !self.retired_deliveries.is_empty())+ }+ pub(crate) fn clear(&mut self) {+ *self = Self::default();+ }++ pub(crate) fn retire_document(+ &mut self,+ owner: WindowDocumentOwner,+ ) -> Vec<RendererWebMcpEvent> {+ let mut events = Vec::new();+ self.retired_deliveries.extend(+ self.deliveries+ .extract_if(|_, delivery| delivery.caller_owner == owner)+ .map(|(_, delivery)| delivery),+ );+ if let Some(id) = self.navigation_results.remove(&owner) {+ events.push(navigation::failure_event(id));+ }+ self.child_navigations.retain(|_, (binding, id)| {+ if WindowDocumentOwner::Frame(binding.owner()) == owner {+ events.push(navigation::failure_event(id.clone()));+ false+ } else {+ true+ }+ });+ let mut removed = Vec::new();+ for (_, entry) in self.documents.extract_if(|_, entry| entry.owner == owner) {+ for (name, mut tool) in entry.tools {+ if entry.frame_tree.is_none() {+ removed.push(RendererWebMcpToolId {+ frame_id: entry.frame_id.clone(),+ name,+ });+ }+ self.retired_resolvers+ .extend(tool.registration_resolver.take());+ self.retired_aborts.extend(tool.abort.take());+ }+ }+ if !removed.is_empty() {+ events.push(RendererWebMcpEvent::ToolsRemoved(removed));+ }+ for (id, invocation) in self.pending.extract_if(|_, invocation| {+ invocation.owner == owner || invocation.caller_owner == owner+ }) {+ if invocation.frame_tree.is_none() {+ events.push(RendererWebMcpEvent::ToolResponded {+ invocation_id: id,+ result: if invocation.caller_cancel_requested {+ RendererWebMcpResult::Canceled+ } else {+ RendererWebMcpResult::Error {+ message: "Tool document is no longer active".into(),+ exception: None,+ }+ },+ });+ }+ self.retired_invocations.push(invocation);+ }+ events+ }+}++pub(crate) fn queue_retirement_task(+ scope: &mut v8::PinScope<'_, '_>,+ host_ptr: *mut JsContextHost,+) {+ {+ let store = &mut unsafe { &mut *host_ptr }.native_bridge_mut().web_mcp;+ if !store.needs_retirement_task() {+ return;+ }+ store.retirement_task_queued = true;+ }+ // Run abort listeners and promise reactions at a browser task boundary,+ // after document-owner transitions have completed and without host borrows.+ let callback =+ v8::Function::new(scope, retirement_callback).expect("WebMCP document retirement task");+ queue_task(scope, host_ptr, callback);+}++fn retirement_callback<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ _args: v8::FunctionCallbackArguments<'s>,+ _rv: v8::ReturnValue<'_, v8::Value>,+) {+ let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {+ return;+ };+ let (resolvers, aborts, invocations, deliveries) = {+ let store = &mut unsafe { &mut *host_ptr }.native_bridge_mut().web_mcp;+ store.retirement_task_queued = false;+ (+ std::mem::take(&mut store.retired_resolvers),+ std::mem::take(&mut store.retired_aborts),+ std::mem::take(&mut store.retired_invocations),+ std::mem::take(&mut store.retired_deliveries),+ )+ };+ for abort in aborts {+ remove_abort_registration(scope, Some(abort));+ }+ for resolver in resolvers {+ let resolver = v8::Local::new(scope, &resolver);+ let error = dom_error(+ scope,+ "AbortError",+ "The registration document is no longer active.",+ );+ let _ = resolver.reject(scope, error);+ }+ for delivery in deliveries {+ remove_abort_registration(scope, delivery.caller_abort);+ let resolver = v8::Local::new(scope, &delivery.resolver);+ let error = dom_error(+ scope,+ "UnknownError",+ "The caller document is no longer active.",+ );+ let _ = resolver.reject(scope, error);+ }+ for mut pending in invocations {+ execution::cleanup_invocation(scope, host_ptr, &mut pending);+ if let Some(resolver) = pending.resolver.take() {+ let resolver = v8::Local::new(scope, &resolver);+ let error = dom_error(+ scope,+ "UnknownError",+ "The tool document is no longer active.",+ );+ let _ = resolver.reject(scope, error);+ }+ execution::abort_target(scope, host_ptr, &pending);+ }+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/navigation.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/navigation.rsnew file mode 100644index 000000000..d093d6f80--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/navigation.rs@@ -0,0 +1,206 @@+//! Carry invocation identity and origin across native navigation. V8 callbacks remain+//! in the source Document; the destination reports JSON-LD after parsing.+use super::devtools;+use super::state::FormInvocationState;+use crate::document_runtime::DomHandle;+use crate::native_bridge::{JsContextHost, WindowDocumentOwner};+use moli_page_types::{RendererWebMcpEvent, RendererWebMcpNavigation, RendererWebMcpResult};++use crate::frame_owner_model::FrameDocumentNavigationLoadBinding;++pub(crate) fn form_invocation(host: &JsContextHost, form: DomHandle) -> Option<u64> {+ host.native_bridge()+ .web_mcp+ .pending+ .iter()+ .find_map(|(id, pending)| {+ pending+ .form+ .as_ref()+ .is_some_and(|active| {+ active.handle == form+ && matches!(+ active.state,+ FormInvocationState::Ready+ | FormInvocationState::Submitting+ | FormInvocationState::Navigating+ )+ })+ .then_some(*id)+ })+}++fn mark_navigating(host: &mut JsContextHost, id: u64) {+ host.native_bridge_mut()+ .web_mcp+ .pending+ .get_mut(&id)+ .expect("active form invocation")+ .form+ .as_mut()+ .expect("form invocation")+ .state = FormInvocationState::Navigating;+}++fn navigation_invocation(+ host: &JsContextHost,+ form: DomHandle,+) -> Option<RendererWebMcpNavigation> {+ let id = form_invocation(host, form)?;+ let pending = &host.native_bridge().web_mcp.pending[&id];+ if pending.frame_tree.is_some() {+ return None;+ }+ Some(RendererWebMcpNavigation {+ invocation_id: id,+ origin: host.native_bridge().web_mcp.documents[&pending.document]+ .origin+ .clone(),+ })+}++pub(crate) fn bind_root_navigation(host: &mut JsContextHost, form: DomHandle) {+ if let Some(id) = navigation_invocation(host, form)+ && host.bind_pending_web_mcp_navigation(id.clone())+ {+ mark_navigating(host, id.invocation_id);+ }+}++pub(crate) fn bind_child_navigation(host: &mut JsContextHost, form: DomHandle, child: DomHandle) {+ let Some(id) = navigation_invocation(host, form) else {+ return;+ };+ let Some(binding) = host.current_child_navigation_load(child) else {+ return;+ };+ host.native_bridge_mut()+ .web_mcp+ .child_navigations+ .insert(child, (binding, id.clone()));+ mark_navigating(host, id.invocation_id);+}++pub(crate) fn cancel_child_navigation(host: &mut JsContextHost, child: DomHandle) {+ if let Some((_, id)) = host+ .native_bridge_mut()+ .web_mcp+ .child_navigations+ .remove(&child)+ {+ fail_navigation(host, id);+ }+}++pub(crate) fn commit_child_navigation(+ host: &mut JsContextHost,+ child: DomHandle,+ binding: Option<FrameDocumentNavigationLoadBinding>,+ owner: WindowDocumentOwner,+) {+ if let Some((expected, id)) = host+ .native_bridge_mut()+ .web_mcp+ .child_navigations+ .remove(&child)+ {+ if binding == Some(expected) {+ // The owner store has committed, but the adapter's Document-handle+ // map still points at the retired Document at this boundary.+ let origin = if host.child_browsing_context_has_opaque_origin(child) {+ url::Origin::new_opaque()+ } else {+ host.child_browsing_context_target_origin(child)+ .and_then(|origin| url::Url::parse(&origin).ok())+ .map_or_else(url::Origin::new_opaque, |url| url.origin())+ };+ receive_navigation_from_origin(host, owner, id, origin);+ } else {+ fail_navigation(host, id);+ }+ }+}++pub(crate) fn receive_navigation(+ host: &mut JsContextHost,+ owner: WindowDocumentOwner,+ id: RendererWebMcpNavigation,+) {+ let origin = super::bindings::document_origin(host, host.document_handle());+ receive_navigation_from_origin(host, owner, id, origin);+}++fn receive_navigation_from_origin(+ host: &mut JsContextHost,+ owner: WindowDocumentOwner,+ id: RendererWebMcpNavigation,+ origin: url::Origin,+) {+ // Chromium reports a cross-origin commit immediately. Waiting for DCL+ // would leave the invocation hanging on a blocked destination resource.+ if origin != id.origin {+ devtools::emit(host, cross_origin_failure_event(id));+ return;+ }+ host.native_bridge_mut()+ .web_mcp+ .navigation_results+ .insert(owner, id);+}++fn cross_origin_failure_event(id: RendererWebMcpNavigation) -> RendererWebMcpEvent {+ RendererWebMcpEvent::ToolResponded {+ invocation_id: id.invocation_id,+ result: RendererWebMcpResult::Error {+ message: "Cannot return tool results after a cross-origin navigation".into(),+ exception: None,+ },+ }+}++pub(crate) fn failure_event(id: RendererWebMcpNavigation) -> RendererWebMcpEvent {+ RendererWebMcpEvent::ToolResponded {+ invocation_id: id.invocation_id,+ result: RendererWebMcpResult::navigation_failed(),+ }+}++pub(crate) fn fail_navigation(host: &JsContextHost, id: RendererWebMcpNavigation) {+ devtools::emit(host, failure_event(id));+}++pub(crate) fn complete_navigation(+ host: &mut JsContextHost,+ document: DomHandle,+ owner: WindowDocumentOwner,+) {+ let Some(id) = host+ .native_bridge_mut()+ .web_mcp+ .navigation_results+ .remove(&owner)+ else {+ return;+ };+ let origin = host+ .native_bridge()+ .web_mcp+ .documents+ .get(&document)+ .map(|entry| entry.origin.clone())+ .unwrap_or_else(|| super::bindings::document_origin(host, document));+ if origin != id.origin {+ devtools::emit(host, cross_origin_failure_event(id));+ return;+ }+ devtools::emit(+ host,+ RendererWebMcpEvent::ToolResponded {+ invocation_id: id.invocation_id,+ result: RendererWebMcpResult::Completed(moli_webmcp::navigation_result(+ host.dom_host(),+ document,+ )),+ },+ );+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/state.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/state.rsnew file mode 100644index 000000000..22686d35e--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/state.rs@@ -0,0 +1,137 @@+//! Document registrations and invocation state retained by the renderer.++use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};++use moli_page_types::DevToolsSessionKey;++use crate::{+ document_runtime::DomHandle, frame_owner_model::FrameDocumentNavigationLoadBinding,+ native_bridge::WindowDocumentOwner, script_vm::RendererInspectorObjectWrapper,+ window_webidl_callback::WindowWebIdlCallbackFunction,+};++use super::conversion::ToolAnnotations;++#[derive(Default)]+pub(crate) struct ModelContextStore {+ pub(super) documents: HashMap<DomHandle, DocumentTools>,+ pub(super) next_registration: u64,+ pub(super) pending: HashMap<u64, PendingInvocation>,+ pub(super) deliveries: HashMap<u64, PendingDelivery>,+ pub(super) retired_deliveries: Vec<PendingDelivery>,+ pub(super) enabled_sessions: BTreeSet<DevToolsSessionKey>,+ pub(super) object_wrapper: Option<RendererInspectorObjectWrapper>,+ pub(super) retired_resolvers: Vec<v8::Global<v8::PromiseResolver>>,+ 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) form_registration_task_queued: bool,+ pub(super) initialized_form_owner: Option<WindowDocumentOwner>,+ pub(super) child_navigations: HashMap<+ DomHandle,+ (+ FrameDocumentNavigationLoadBinding,+ moli_page_types::RendererWebMcpNavigation,+ ),+ >,+ pub(super) navigation_results:+ HashMap<WindowDocumentOwner, moli_page_types::RendererWebMcpNavigation>,+}++pub(super) struct DocumentTools {+ pub(super) owner: WindowDocumentOwner,+ pub(super) target: v8::Global<v8::Object>,+ pub(super) window: v8::Global<v8::Object>,+ pub(super) origin: url::Origin,+ pub(super) frame_id: Option<String>,+ pub(super) frame_tree: Option<u64>,+ pub(super) tools: BTreeMap<String, RegisteredTool>,+}++pub(super) struct RegisteredTool {+ pub(super) registration: u64,+ pub(super) metadata: ToolMetadata,+ pub(super) stack_trace: Option<serde_json::Value>,+ pub(super) exposed_to: Vec<url::Origin>,+ pub(super) executor: ToolExecutor,+ pub(super) abort: Option<AbortRegistration>,+ pub(super) registration_resolver: Option<v8::Global<v8::PromiseResolver>>,+}++#[derive(PartialEq, Eq)]+pub(super) struct ToolMetadata {+ pub(super) description: String,+ pub(super) title: String,+ pub(super) input_schema: Option<String>,+ pub(super) annotations: Option<ToolAnnotations>,+}++pub(super) enum ToolExecutor {+ Callback(WindowWebIdlCallbackFunction),+ Form {+ handle: DomHandle,+ autosubmit: bool,+ backend_node_id: Option<u32>,+ },+}++pub(super) struct AbortRegistration {+ pub(super) signal: v8::Global<v8::Object>,+ pub(super) algorithm: v8::Global<v8::Function>,+}++pub(super) struct PendingInvocation {+ pub(super) document: DomHandle,+ pub(super) owner: WindowDocumentOwner,+ pub(super) caller_owner: WindowDocumentOwner,+ pub(super) caller_document: DomHandle,+ pub(super) frame_tree: Option<u64>,+ pub(super) name: String,+ pub(super) target: v8::Global<v8::Object>,+ pub(super) resolver: Option<v8::Global<v8::PromiseResolver>>,+ pub(super) signal: v8::Global<v8::Object>,+ pub(super) caller_abort: Option<AbortRegistration>,+ pub(super) input: String,+ pub(super) caller_cancel_requested: bool,+ pub(super) form: Option<FormInvocation>,+}++pub(super) struct FormInvocation {+ pub(super) handle: DomHandle,+ pub(super) submitter: Option<DomHandle>,+ pub(super) state: FormInvocationState,+}++pub(super) enum FormInvocationState {+ Filling,+ Ready,+ Submitting,+ Responding(v8::Global<v8::Promise>),+ Invalidated,+ Navigating,+}++impl ModelContextStore {+ pub(crate) fn set_object_wrapper(&mut self, wrapper: RendererInspectorObjectWrapper) {+ self.object_wrapper = Some(wrapper);+ }+ pub(crate) fn disable_session(&mut self, session: &DevToolsSessionKey) {+ self.enabled_sessions.remove(session);+ }+}++// Target execution has ended; the caller may still cancel until its task runs.+pub(super) struct PendingDelivery {+ pub(super) caller_owner: WindowDocumentOwner,+ pub(super) caller_document: DomHandle,+ pub(super) resolver: v8::Global<v8::PromiseResolver>,+ pub(super) caller_abort: Option<AbortRegistration>,+ pub(super) result: CallerResult,+}++pub(super) enum CallerResult {+ Completed(String),+ Navigated,+ Error(String),+}diff --git a/moli-renderer-v8/src/context_bootstrap/web_mcp/tasks.rs b/moli-renderer-v8/src/context_bootstrap/web_mcp/tasks.rsnew file mode 100644index 000000000..2caf5d55d--- /dev/null+++ b/moli-renderer-v8/src/context_bootstrap/web_mcp/tasks.rs@@ -0,0 +1,76 @@+//! Browser task payloads and invocation abort algorithms.++use super::bindings::js_string;+use super::state::AbortRegistration;+use crate::native_bridge::JsContextHost;+use crate::util::context_host_ptr_from_global_bridge;++pub(super) fn invocation_context(+ scope: &mut v8::PinScope<'_, '_>,+ args: &v8::FunctionCallbackArguments<'_>,+) -> Option<(*mut JsContextHost, u64)> {+ let id = v8::Local::<v8::BigInt>::try_from(args.data())+ .ok()?+ .u64_value()+ .0;+ Some((context_host_ptr_from_global_bridge(scope)?, id))+}++// Native Function data is never exposed to author code. Initialize every array+// element at construction, so indexed prototype setters cannot intercept it.+pub(super) fn task_data<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ target: v8::Local<'s, v8::Object>,+ id: u64,+ name: Option<&str>,+) -> v8::Local<'s, v8::Array> {+ let id = v8::BigInt::new_from_u64(scope, id);+ let name = name+ .map(|name| js_string(scope, name).into())+ .unwrap_or_else(|| v8::undefined(scope).into());+ v8::Array::new_with_elements(scope, &[target.into(), id.into(), name])+}++pub(super) fn task_context<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ args: &v8::FunctionCallbackArguments<'s>,+) -> Option<(v8::Local<'s, v8::Object>, u64, v8::Local<'s, v8::Value>)> {+ let data = v8::Local::<v8::Array>::try_from(args.data()).ok()?;+ let target = v8::Local::<v8::Object>::try_from(data.get_index(scope, 0)?).ok()?;+ let id = v8::Local::<v8::BigInt>::try_from(data.get_index(scope, 1)?)+ .ok()?+ .u64_value()+ .0;+ Some((target, id, data.get_index(scope, 2)?))+}++pub(super) fn queue_task<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ host_ptr: *mut JsContextHost,+ callback: v8::Local<'s, v8::Function>,+) {+ unsafe { &mut *host_ptr }.queue_internal_task(scope, callback);+}++pub(super) fn signal_reason<'s>(+ scope: &mut v8::PinScope<'s, '_>,+ signal: v8::Local<'s, v8::Object>,+) -> v8::Local<'s, v8::Value> {+ crate::abort_signal_route::ResolvedAbortSignal::resolve(scope, signal)+ .and_then(|signal| signal.reason(scope))+ .unwrap_or_else(|| crate::native_bridge::abort::abort_error_value(scope))+}++pub(super) fn remove_abort_registration(+ scope: &mut v8::PinScope<'_, '_>,+ abort: Option<AbortRegistration>,+) {+ if let Some(abort) = abort {+ let signal = v8::Local::new(scope, &abort.signal);+ let algorithm = v8::Local::new(scope, &abort.algorithm);+ if let Some(signal) = crate::abort_signal_route::ResolvedAbortSignal::resolve(scope, signal)+ {+ signal.unregister_algorithm(scope, algorithm);+ }+ }+}diff --git a/moli-renderer-v8/src/devtools/command/nested.rs b/moli-renderer-v8/src/devtools/command/nested.rsindex a786fbd33..a52d78a31 100644--- a/moli-renderer-v8/src/devtools/command/nested.rs+++ b/moli-renderer-v8/src/devtools/command/nested.rs@@ -8,6 +8,7 @@ impl RendererPageCommand {pub(crate) fn nested_dispatch(&self) -> RendererDevToolsMainNestedDispatch {use RendererDevToolsMainNestedDispatch::{InspectorSession, OwnerOnly, PageAgent};match self {+ Self::WebMcp { .. } => OwnerOnly,Self::Native(command) => {if command.operation.can_dispatch_on_nested_main() {PageAgentdiff --git a/moli-renderer-v8/src/document_runtime/events.rs b/moli-renderer-v8/src/document_runtime/events.rsindex 27a811df9..a58e782b1 100644--- a/moli-renderer-v8/src/document_runtime/events.rs+++ b/moli-renderer-v8/src/document_runtime/events.rs@@ -79,6 +79,14 @@ impl DocumentRuntime {.queue_once(scope, callback, delay_ms, owner, extra_args)}+ pub(crate) fn queue_internal_task<'s>(+ &mut self,+ scope: &mut v8::PinScope<'s, '_>,+ callback: v8::Local<'s, v8::Function>,+ ) {+ self.timeouts.queue_internal_task(scope, callback);+ }+pub(crate) fn queue_timeout_with_receiver<'s>(&mut self,scope: &mut v8::PinScope<'s, '_>,@@ -88,8 +96,14 @@ impl DocumentRuntime {owner: HostTimerOwner,extra_args: Vec<v8::Global<v8::Value>>,) -> u32 {- self.timeouts- .queue_once_with_receiver(scope, callback, receiver, delay_ms, owner, extra_args)+ self.timeouts.queue_once_with_receiver(+ scope,+ callback,+ receiver,+ u64::from(delay_ms),+ owner,+ extra_args,+ )}pub(crate) fn queue_window_timer_callback<'s>(diff --git a/moli-renderer-v8/src/document_runtime/mutation_commands.rs b/moli-renderer-v8/src/document_runtime/mutation_commands.rsindex 57d817d34..dc6ab755e 100644--- a/moli-renderer-v8/src/document_runtime/mutation_commands.rs+++ b/moli-renderer-v8/src/document_runtime/mutation_commands.rs@@ -1444,6 +1444,15 @@ impl DocumentRuntime {self.dom_host.set_autofilled_state(handle, autofilled)}+ pub(crate) fn set_web_mcp_activity(+ &mut self,+ handle: DomHandle,+ form: bool,+ submit: bool,+ ) -> bool {+ self.dom_host.set_web_mcp_activity(handle, form, submit)+ }+pub(crate) fn set_input_files(&mut self,handle: DomHandle,diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rsindex 359cec7dc..e850fab8b 100644--- a/moli-renderer-v8/src/document_runtime/security_policy.rs+++ b/moli-renderer-v8/src/document_runtime/security_policy.rs@@ -140,6 +140,14 @@ impl DocumentPolicyContainer {) -> Self {let response_content_security_policies =response_content_security_policies_from_headers(headers);+ let sandbox = DocumentSandboxPolicy::from_response_content_security_policies(+ &response_content_security_policies,+ );+ let origin = if sandbox.forces_opaque_origin {+ url::Origin::new_opaque()+ } else {+ final_url.origin()+ };Self {referrer_policy: crate::referrer_policy::response_referrer_policy_from_headers(headers),cross_origin_embedder_policy:@@ -151,9 +159,7 @@ impl DocumentPolicyContainer {final_url, headers,),document_content_security_policies: response_content_security_policies.clone(),- sandbox: DocumentSandboxPolicy::from_response_content_security_policies(- &response_content_security_policies,- ),+ sandbox,response_content_security_policies,response_content_security_report_only_policies:response_content_security_report_only_policies_from_headers(headers),@@ -166,7 +172,7 @@ impl DocumentPolicyContainer {crate::permissions_policy::DocumentPermissionsPolicy::from_navigation_response_headers(headers,final_url,- ),+ ).for_document_origin(&origin),..Self::default()}}diff --git a/moli-renderer-v8/src/host/timers.rs b/moli-renderer-v8/src/host/timers.rsindex ca64fe9e4..47e423c03 100644--- a/moli-renderer-v8/src/host/timers.rs+++ b/moli-renderer-v8/src/host/timers.rs@@ -59,6 +59,7 @@ struct ScheduledTimerFunction {enum ScheduledTimerCallback {Function(ScheduledTimerFunction),+ InternalFunction(ScheduledTimerFunction),WindowWebIdl(ScheduledWindowWebIdlCallback),Source(ScheduledTimerSource),ResourceTimingBufferFull {@@ -71,7 +72,9 @@ enum ScheduledTimerCallback {impl ScheduledTimerCallback {fn context<'s>(&self, scope: &mut v8::PinScope<'s, '_>) -> v8::Local<'s, v8::Context> {match self {- Self::Function(function) => v8::Local::new(scope, &function.relevant_context),+ Self::Function(function) | Self::InternalFunction(function) => {+ v8::Local::new(scope, &function.relevant_context)+ }Self::WindowWebIdl(callback) => callback.relevant_context(scope).expect("a scheduled Window Web IDL callback must retain its relevant context"),@@ -82,7 +85,9 @@ impl ScheduledTimerCallback {fn realm_token(&self) -> Option<RuntimeObservableContextToken> {match self {- Self::Function(function) => Some(function.realm_token),+ Self::Function(function) | Self::InternalFunction(function) => {+ Some(function.realm_token)+ }Self::WindowWebIdl(callback) => callback.realm_token(),Self::Source(source) => source.realm_token,Self::ResourceTimingBufferFull { .. } => None,@@ -91,7 +96,9 @@ impl ScheduledTimerCallback {fn relevant_identity(&self) -> Option<WindowExecutionContextIdentity> {match self {- Self::Function(function) => function.relevant_identity,+ Self::Function(function) | Self::InternalFunction(function) => {+ function.relevant_identity+ }Self::WindowWebIdl(callback) => callback.relevant_identity(),Self::Source(_) | Self::ResourceTimingBufferFull { .. } => None,}@@ -115,7 +122,9 @@ impl ScheduledTimerCallback {target_binding: Option<&WindowExecutionContextBinding>,) -> Option<OwnerDispatchScope> {match self {- Self::Function(function) => Some(function.relevant_dispatch_scope),+ Self::Function(function) | Self::InternalFunction(function) => {+ Some(function.relevant_dispatch_scope)+ }Self::WindowWebIdl(_) => {target_binding.map(WindowExecutionContextBinding::dispatch_scope)}@@ -137,7 +146,7 @@ impl ScheduledTimerCallback {.map(|binding| binding.context(scope)).unwrap_or_else(|| self.context(scope)),Self::Source(_) => self.context(scope),- Self::Function(_) => self.context(scope),+ Self::Function(_) | Self::InternalFunction(_) => self.context(scope),Self::ResourceTimingBufferFull { .. } => self.context(scope),}}@@ -222,6 +231,7 @@ pub(crate) struct HostTimeoutScheduler {#[derive(Clone, Copy)]struct RunningTimerContext {id: TimerId,+ internal: bool,window_owner: Option<WindowExecutionContextOwner>,target_realm_token: Option<RuntimeObservableContextToken>,callback_realm_token: Option<RuntimeObservableContextToken>,@@ -261,38 +271,47 @@ impl fmt::Debug for HostTimeoutScheduler {}impl HostTimeoutScheduler {- pub(crate) fn queue_once<'s>(+ /// Browser tasks share the Window task scheduler and its retirement checks,+ /// but are not JS timer handles that clearTimeout can cancel.+ pub(crate) fn queue_internal_task<'s>(&mut self,scope: &mut v8::PinScope<'s, '_>,callback: v8::Local<'s, v8::Function>,- delay_ms: u64,- owner: HostTimerOwner,- extra_args: Vec<v8::Global<v8::Value>>,- ) -> u32 {+ ) {let receiver = scope.get_current_context().global(scope);let Some(callback) = scheduled_timer_function(scope, callback, receiver) else {- return 0;+ return;};let Some(owner) = scheduled_timer_owner_for_target(scope,- owner,+ HostTimerOwner::Window,Some(receiver),scope.get_current_context(),) else {- return 0;+ return;};- self.scheduler- .schedule_after(- ScheduledTimerTask {- callback: ScheduledTimerCallback::Function(callback),- owner,- is_interval: false,- extra_args,- },- delay_ms,- Instant::now(),- )- .get()+ self.scheduler.schedule_after(+ ScheduledTimerTask {+ callback: ScheduledTimerCallback::InternalFunction(callback),+ owner,+ is_interval: false,+ extra_args: Vec::new(),+ },+ 0,+ Instant::now(),+ );+ }++ pub(crate) fn queue_once<'s>(+ &mut self,+ scope: &mut v8::PinScope<'s, '_>,+ callback: v8::Local<'s, v8::Function>,+ delay_ms: u64,+ owner: HostTimerOwner,+ extra_args: Vec<v8::Global<v8::Value>>,+ ) -> u32 {+ let receiver = scope.get_current_context().global(scope);+ self.queue_once_with_receiver(scope, callback, receiver, delay_ms, owner, extra_args)}pub(crate) fn queue_once_with_receiver<'s>(@@ -300,7 +319,7 @@ impl HostTimeoutScheduler {scope: &mut v8::PinScope<'s, '_>,callback: v8::Local<'s, v8::Function>,receiver: v8::Local<'s, v8::Object>,- delay_ms: u32,+ delay_ms: u64,owner: HostTimerOwner,extra_args: Vec<v8::Global<v8::Value>>,) -> u32 {@@ -323,7 +342,7 @@ impl HostTimeoutScheduler {is_interval: false,extra_args,},- u64::from(delay_ms),+ delay_ms,Instant::now(),).get()@@ -813,6 +832,10 @@ impl HostTimeoutScheduler {let execution_dispatch_scope = timer.payload.callback.dispatch_scope(target_binding);self.running_timer = Some(RunningTimerContext {id: timer_id,+ internal: matches!(+ timer.payload.callback,+ ScheduledTimerCallback::InternalFunction(_)+ ),window_owner: target_binding.map(WindowExecutionContextBinding::owner),target_realm_token: target_binding.map(WindowExecutionContextBinding::realm_token),callback_realm_token: timer.payload.callback.realm_token(),@@ -859,13 +882,15 @@ impl HostTimeoutScheduler {fn cancel_window_timer(&mut self, id: TimerId, owner: WindowExecutionContextOwner) -> bool {let pending_matches = self.scheduler.active_payload(id).is_some_and(|task| {- task.owner- .window_target()- .is_some_and(|target| target.owner == owner)+ !matches!(task.callback, ScheduledTimerCallback::InternalFunction(_))+ && task+ .owner+ .window_target()+ .is_some_and(|target| target.owner == owner)+ });+ let running_matches = self.running_timer.is_some_and(|running| {+ !running.internal && running.id == id && running.window_owner == Some(owner)});- let running_matches = self- .running_timer- .is_some_and(|running| running.id == id && running.window_owner == Some(owner));if pending_matches || running_matches {self.scheduler.cancel(id)} else {@@ -1079,7 +1104,8 @@ fn run_window_timer_callback(extra_args: &[v8::Global<v8::Value>],) -> std::result::Result<HostTimeoutRunResult, HostTimeoutRunResult> {match callback {- ScheduledTimerCallback::Function(function) => {+ ScheduledTimerCallback::Function(function)+ | ScheduledTimerCallback::InternalFunction(function) => {let callback = v8::Local::new(scope, &function.callback);let receiver = v8::Local::new(scope, &function.receiver);let relevant_context = v8::Local::new(scope, &function.relevant_context);diff --git a/moli-renderer-v8/src/mutation_coordinator/notifications.rs b/moli-renderer-v8/src/mutation_coordinator/notifications.rsindex 2a6aa6cb0..992d2975f 100644--- a/moli-renderer-v8/src/mutation_coordinator/notifications.rs+++ b/moli-renderer-v8/src/mutation_coordinator/notifications.rs@@ -30,6 +30,7 @@ pub(crate) fn notify_dom_mutation(host.apply_stylesheet_owner_changes(effects.stylesheet_owners().changes());}host.note_app_manifest_link_mutation(dom_host, effects);+ crate::context_bootstrap::web_mcp::note_mutation(scope, host, dom_host, effects);let profile = moli_trace::cpu_profile_enabled();let started = profile.then(Instant::now);diff --git a/moli-renderer-v8/src/native_bridge/abort.rs b/moli-renderer-v8/src/native_bridge/abort.rsindex 686db7237..b5993d169 100644--- a/moli-renderer-v8/src/native_bridge/abort.rs+++ b/moli-renderer-v8/src/native_bridge/abort.rs@@ -406,7 +406,7 @@ pub(super) fn timeout_error_value<'s>(dom_exception_value(scope, "signal timed out", "TimeoutError")}-fn create_signal<'s>(+pub(crate) fn create_signal<'s>(scope: &mut v8::PinScope<'s, '_>,host: &mut super::JsContextHost,aborted: bool,diff --git a/moli-renderer-v8/src/native_bridge/bridge.rs b/moli-renderer-v8/src/native_bridge/bridge.rsindex 06cee8c83..f03390d45 100644--- a/moli-renderer-v8/src/native_bridge/bridge.rs+++ b/moli-renderer-v8/src/native_bridge/bridge.rs@@ -27,6 +27,7 @@ pub(crate) struct NativeDomBridge {pub(super) bindings: NativeBridgeBindings,pub(super) identity: BridgeIdentityStore,pub(super) abort: abort::AbortStore,+ pub(crate) web_mcp: crate::context_bootstrap::web_mcp::ModelContextStore,pub(super) traversal: traversal::TraversalStore,}diff --git a/moli-renderer-v8/src/native_bridge/bridge/lifecycle.rs b/moli-renderer-v8/src/native_bridge/bridge/lifecycle.rsindex 631448804..0d66f751c 100644--- a/moli-renderer-v8/src/native_bridge/bridge/lifecycle.rs+++ b/moli-renderer-v8/src/native_bridge/bridge/lifecycle.rs@@ -15,6 +15,7 @@ impl NativeDomBridge {bindings,identity: BridgeIdentityStore::default(),abort: abort::AbortStore::default(),+ web_mcp: crate::context_bootstrap::web_mcp::ModelContextStore::default(),traversal: traversal::TraversalStore::default(),}}diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/bootstrap_commit.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/bootstrap_commit.rsindex 352c364fb..2984e5952 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/bootstrap_commit.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/bootstrap_commit.rs@@ -97,8 +97,15 @@ impl JsContextHost {return Some(ChildDocumentCommitResult::ready(None));}let sandbox = self.child_browsing_context_sandbox_policy_from_owner(handle);+ let permissions_policy = self.child_browsing_context_permissions_policy_for_document(+ handle,+ &bootstrap,+ sandbox,+ &snapshot.policy_container.permissions_policy,+ );{let entry = self.child_browsing_contexts.get_mut(&handle)?;+ entry.set_document_permissions_policy(permissions_policy);entry.commit_child_document_after_failed_async_start(bootstrap,&snapshot,@@ -140,8 +147,18 @@ impl JsContextHost {self.finish_child_frame_navigation_without_load_dispatch(handle, navigation_load);return Some(ChildDocumentCommitResult::ready(None));}+ let permissions_policy = self.child_browsing_context_permissions_policy_for_document(+ handle,+ &bootstrap,+ sandbox,+ &cached_snapshot+ .as_ref()+ .map(|snapshot| snapshot.policy_container.permissions_policy.clone())+ .unwrap_or_default(),+ );{let entry = self.child_browsing_contexts.get_mut(&handle)?;+ entry.set_document_permissions_policy(permissions_policy);entry.commit_new_child_document(bootstrap,cached_snapshot.as_ref(),diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rsindex f8016efb8..743cc557e 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/commit.rs@@ -291,6 +291,7 @@ impl JsContextHost {.expect("synthetic child Document commit requires its parent authority").clone()});+ let web_mcp_navigation = self.current_child_navigation_load(handle);let owner_transition = self.frame_owner_store.replace_child_document_with_local_window_transition(@@ -310,6 +311,16 @@ impl JsContextHost {expected_current_owner,)?;debug_assert_eq!(owner_transition.retired_owner(), expected_current_owner);+ crate::context_bootstrap::web_mcp::commit_child_navigation(+ self,+ handle,+ web_mcp_navigation,+ crate::native_bridge::WindowDocumentOwner::Frame(+ owner_transition+ .current_owner()+ .expect("committed child document"),+ ),+ );match owner_transition.local_window_owner_transition() {FrameLocalWindowOwnerTransition::Replaced { .. } => {diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/lifecycle.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/lifecycle.rsindex f036c38a6..916edd9cf 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/lifecycle.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/lifecycle.rs@@ -359,6 +359,7 @@ impl JsContextHost {let navigation = self.frame_owner_store.replace_current_child_navigation_load(child_handle)?;+ crate::context_bootstrap::web_mcp::cancel_child_navigation(self, child_handle);tracing::debug!(?child_handle,owner = ?navigation.owner(),@@ -416,6 +417,7 @@ impl JsContextHost {);return false;};+ crate::context_bootstrap::web_mcp::cancel_child_navigation(self, child_handle);tracing::debug!(?child_handle,?owner,@@ -712,6 +714,17 @@ impl JsContextHost {{return FrameDocumentLifecycleTaskEffect::NotApplied;}+ if let Some(document) = self+ .child_browsing_context_document_handles+ .get(&child_handle)+ .copied()+ {+ crate::context_bootstrap::web_mcp::complete_navigation(+ self,+ document,+ crate::native_bridge::WindowDocumentOwner::Frame(action.owner()),+ );+ }let event_dispatched = self.child_browsing_context_document_wrapper(scope, child_handle).is_some_and(|document| {diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_documents/loads.rs b/moli-renderer-v8/src/native_bridge/context_host/child_documents/loads.rsindex 90fac5d67..b3f06bb75 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_documents/loads.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_documents/loads.rs@@ -548,6 +548,13 @@ impl JsContextHost {loaded.final_url.clone(),&pending.target_url,);+ let permissions_policy = self+ .child_browsing_context_permissions_policy_for_document(+ handle,+ &super::super::ChildBrowsingContextBootstrap::Url(final_url.clone()),+ sandbox,+ &loaded.policy_container.permissions_policy,+ );self.clear_child_browsing_context_pending_navigation(handle);let Some(entry) = self.child_browsing_contexts.get_mut(&handle) else {self.clear_pending_service_worker_child_client_if_matches(@@ -567,6 +574,7 @@ impl JsContextHost {body_activity,};};+ entry.set_document_permissions_policy(permissions_policy);entry.commit_pending_child_document_load(&final_url,&loaded.policy_container,diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frames.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frames.rsindex 4555cdb0e..99b259a21 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_frames.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_frames.rs@@ -349,7 +349,7 @@ impl ChildBrowsingContextEntry {self.document_policy_container.permissions_policy = self.document_policy_container.permissions_policy- .intersect(policy_container.permissions_policy);+ .intersect(&policy_container.permissions_policy);self.set_document_credentialless_state(credentialless, credentialless_storage_nonce);self.set_document_sandbox_policy(sandbox);}@@ -391,7 +391,7 @@ impl ChildBrowsingContextEntry {self.document_policy_container.permissions_policy = self.document_policy_container.permissions_policy- .intersect(snapshot.policy_container.permissions_policy);+ .intersect(&snapshot.policy_container.permissions_policy);self.set_document_credentialless_state(credentialless, credentialless_storage_nonce);self.set_document_sandbox_policy(sandbox);}@@ -1220,6 +1220,7 @@ impl JsContextHost {form: DomHandle,target: DomHandle,) {+ crate::context_bootstrap::web_mcp::bind_child_navigation(self, form, target);let targets = self.pending_form_submission_child_targets.entry(form)diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frames/discovery.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frames/discovery.rsindex a53f44811..b5e8eb292 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_frames/discovery.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_frames/discovery.rs@@ -96,10 +96,7 @@ impl JsContextHost {.is_some_and(|kind| attribute_name.eq_ignore_ascii_case(kind.navigation_attribute()))}- pub(in crate::native_bridge::context_host) fn child_browsing_context_host_is_active(- &self,- handle: DomHandle,- ) -> bool {+ pub(crate) fn child_browsing_context_host_is_active(&self, handle: DomHandle) -> bool {self.dom_host().is_connected(handle)|| self.lightweight_popup_id_for_node_owner_document(handle)diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rsindex cc8bf9119..95d698b8a 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_frames/registry.rs@@ -53,6 +53,9 @@ impl JsContextHost {retired_owner: crate::frame_owner_model::FrameDocumentTaskOwner,document_handle: DomHandle,) {+ self.retire_web_mcp_document(crate::native_bridge::WindowDocumentOwner::Frame(+ retired_owner,+ ));let _ = self.retire_document_resource_loader(crate::native_bridge::WindowDocumentOwner::Frame(retired_owner),);@@ -386,7 +389,7 @@ impl JsContextHost {)} else {refresh_policy_source- .map(|policy| policy.permissions_policy)+ .map(|policy| policy.permissions_policy.clone()).unwrap_or_default()},};diff --git a/moli-renderer-v8/src/native_bridge/context_host/child_frames/request_scope.rs b/moli-renderer-v8/src/native_bridge/context_host/child_frames/request_scope.rsindex a44c17245..737e6a1b6 100644--- a/moli-renderer-v8/src/native_bridge/context_host/child_frames/request_scope.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/child_frames/request_scope.rs@@ -689,28 +689,67 @@ impl JsContextHost {&self,handle: DomHandle,bootstrap: &ChildBrowsingContextBootstrap,+ ) -> crate::permissions_policy::DocumentPermissionsPolicy {+ self.child_browsing_context_permissions_policy_for_document(+ handle,+ bootstrap,+ self.child_browsing_context_sandbox_policy_from_owner(handle),+ &crate::permissions_policy::DocumentPermissionsPolicy::default(),+ )+ }++ pub(in crate::native_bridge::context_host) fn child_browsing_context_permissions_policy_for_document(+ &self,+ handle: DomHandle,+ bootstrap: &ChildBrowsingContextBootstrap,+ sandbox: crate::document_runtime::DocumentSandboxPolicy,+ response_policy: &crate::permissions_policy::DocumentPermissionsPolicy,) -> crate::permissions_policy::DocumentPermissionsPolicy {let parent_document = self.dom_host().node(handle).and_then(crate::dom::native::Node::owner_document).unwrap_or_else(|| self.document_handle());- let parent_url = self.document_url_for_handle(parent_document);+ let parent_origin = self.permissions_policy_origin_for_document(parent_document);let parent_policy = self.document_permissions_policy_for_document_handle(parent_document)- .unwrap_or_else(|| self.document_policy_container().permissions_policy);- let child_url = Self::child_browsing_context_bootstrap_url(bootstrap)- .unwrap_or_else(|| parent_url.clone());+ .unwrap_or_else(|| self.document_policy_container().permissions_policy.clone());+ let child_origin = if sandbox.forces_opaque_origin {+ url::Origin::new_opaque()+ } else if bootstrap.security_origin_inherited() {+ parent_origin.clone()+ } else {+ Self::child_browsing_context_bootstrap_url(bootstrap)+ .map_or_else(url::Origin::new_opaque, |url| url.origin())+ };+ // The container's 'src' allowlist remains bound to its declared source,+ // while inheritance and default 'self' use the final Document origin.+ let source = self+ .child_browsing_context_bootstrap_for_handle(handle)+ .unwrap_or_else(|| bootstrap.clone());+ let source_origin = if self+ .child_browsing_context_sandbox_policy_from_owner(handle)+ .forces_opaque_origin+ {+ child_origin.clone()+ } else if source.security_origin_inherited() {+ parent_origin.clone()+ } else {+ Self::child_browsing_context_bootstrap_url(&source)+ .map_or_else(url::Origin::new_opaque, |url| url.origin())+ };let is_iframe = self.dom_host().is_html_element_named(handle, "iframe");let allow = is_iframe.then(|| self.dom_host().get_attribute(handle, "allow")).flatten();- parent_policy.delegated_to_child(- &parent_url,- &child_url,- bootstrap.security_origin_inherited(),- allow.as_deref(),- )+ parent_policy+ .delegated_to_child(+ &parent_origin,+ &child_origin,+ &source_origin,+ allow.as_deref(),+ )+ .intersect(&response_policy.for_document_origin(&child_origin))}pub(crate) fn child_browsing_context_is_same_origin_with_top(&self, handle: DomHandle) -> bool {diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rsindex 478556522..4107af34a 100644--- a/moli-renderer-v8/src/native_bridge/context_host/core.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs@@ -1223,6 +1223,16 @@ impl JsContextHost {&self.bridge}+ pub(crate) fn retire_web_mcp_document(+ &mut self,+ owner: crate::native_bridge::WindowDocumentOwner,+ ) {+ let events = self.bridge.web_mcp.retire_document(owner);+ for event in events {+ crate::context_bootstrap::web_mcp::emit_protocol_event(self, event);+ }+ }+pub(crate) fn character_data_utf16_units(&self, handle: DomHandle) -> Option<Vec<u16>> {self.character_data_utf16_overrides.get(&handle)diff --git a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rsindex 3983b5429..151b0d840 100644--- a/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/host_environment.rs@@ -2110,6 +2110,19 @@ impl JsContextHost {changed}+ pub(crate) fn set_web_mcp_activity(&mut self, handle: DomHandle, form: bool, submit: bool) {+ let old_state = self.retained_current_element_state(handle);+ if unsafe {+ DocumentRuntime::set_web_mcp_activity(&mut *self.runtime, handle, form, submit)+ } {+ self.note_element_state_style_activity_with_old_state(+ handle,+ StyloElementState::TOOL_FORM_ACTIVE | StyloElementState::TOOL_SUBMIT_ACTIVE,+ old_state,+ );+ }+ }+fn note_input_value_state_style_activity(&mut self,handle: DomHandle,diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rsindex 4ed2f2e68..fb4105ec1 100644--- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs@@ -1258,6 +1258,7 @@ impl JsContextHost {return;}self.page_context_resources_closed = true;+ self.bridge.web_mcp.clear();self.pending_history_traversal_admissions.clear();self.retire_all_document_resource_loaders();self.page_default_context = None;diff --git a/moli-renderer-v8/src/native_bridge/context_host/navigation.rs b/moli-renderer-v8/src/native_bridge/context_host/navigation.rsindex 67b2d6893..c2d860990 100644--- a/moli-renderer-v8/src/native_bridge/context_host/navigation.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/navigation.rs@@ -67,6 +67,7 @@ pub(crate) struct PendingLocationNavigation {pub(crate) reserved_service_worker_client: Option<PendingReservedServiceWorkerClient>,pub(crate) service_worker_client_navigate:Option<crate::types::ServiceWorkerClientNavigateContinuation>,+ pub(crate) web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,}#[derive(Debug, Clone, Copy, PartialEq, Eq)]@@ -185,6 +186,7 @@ impl JsContextHost {entry_seed,reserved_service_worker_client,service_worker_client_navigate: None,+ web_mcp_invocation: None,},)));self.handoff_ordinary_page_turn_navigation(handoff);@@ -215,6 +217,7 @@ impl JsContextHost {entry_seed: None,reserved_service_worker_client,service_worker_client_navigate: Some(continuation),+ web_mcp_invocation: None,},)));self.handoff_ordinary_page_turn_navigation(handoff);@@ -227,6 +230,22 @@ impl JsContextHost {)}+ pub(crate) fn bind_pending_web_mcp_navigation(+ &mut self,+ id: moli_page_types::RendererWebMcpNavigation,+ ) -> bool {+ let Some(PendingTopLevelNavigation::Location(pending)) =+ self.pending_top_level_navigation.as_mut()+ else {+ return false;+ };+ if pending.kind() != PendingLocationNavigationKind::Document {+ return false;+ }+ pending.web_mcp_invocation = Some(id);+ true+ }+pub(crate) fn pending_location_navigation_kind(&self) -> Option<PendingLocationNavigationKind> {match self.pending_top_level_navigation.as_ref()? {PendingTopLevelNavigation::Location(pending) => Some(pending.kind()),@@ -326,6 +345,9 @@ impl JsContextHost {return;};let pending = *pending;+ if let Some(id) = pending.web_mcp_invocation {+ crate::context_bootstrap::web_mcp::fail_navigation(self, id);+ }let Some(continuation) = pending.service_worker_client_navigate else {return;};diff --git a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rsindex 58d32d999..11531273a 100644--- a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs@@ -129,7 +129,9 @@ impl JsContextHost {owner: OwnerDispatchScope,) -> Option<crate::permissions_policy::DocumentPermissionsPolicy> {match owner {- OwnerDispatchScope::Top => Some(self.document_policy_container().permissions_policy),+ OwnerDispatchScope::Top => {+ Some(self.document_policy_container().permissions_policy.clone())+ }OwnerDispatchScope::Child(handle) => self.frame_owner_current_child_snapshot(handle).map(|snapshot| {@@ -140,7 +142,7 @@ impl JsContextHost {}),OwnerDispatchScope::LightweightPopup(popup_id) => self.lightweight_popup_policy_container(popup_id)- .map(|policy| policy.permissions_policy),+ .map(|policy| policy.permissions_policy.clone()),}}@@ -149,12 +151,12 @@ impl JsContextHost {document: DomHandle,) -> Option<crate::permissions_policy::DocumentPermissionsPolicy> {if document == self.document_handle() {- return Some(self.document_policy_container().permissions_policy);+ return Some(self.document_policy_container().permissions_policy.clone());}if let Some(popup_id) = self.lightweight_popup_id_for_document_handle(document) {return self.lightweight_popup_policy_container(popup_id)- .map(|policy| policy.permissions_policy);+ .map(|policy| policy.permissions_policy.clone());}let child_handle = self.child_browsing_context_host_for_document_handle(document)?;let snapshot = self.frame_owner_current_child_snapshot(child_handle)?;@@ -166,6 +168,38 @@ impl JsContextHost {)}+ pub(in crate::native_bridge::context_host) fn permissions_policy_origin_for_document(+ &self,+ document: crate::document_runtime::DomHandle,+ ) -> url::Origin {+ if document == self.document_handle() && self.document_sandbox_policy().forces_opaque_origin+ {+ return url::Origin::new_opaque();+ }+ let serialized = (document == self.document_handle())+ .then(|| {+ self.frame_owner_store+ .current_main_owner_snapshot()+ .map(|owner| owner.settings.origin)+ })+ .flatten()+ .or_else(|| {+ self.lightweight_popup_id_for_document_handle(document)+ .and_then(|popup| self.lightweight_popup_origin(popup))+ .or_else(|| {+ self.child_browsing_context_host_for_document_handle(document)+ .and_then(|child| self.child_browsing_context_target_origin(child))+ })+ });+ serialized.map_or_else(+ || self.document_url_for_handle(document).origin(),+ |origin| {+ url::Url::parse(&origin)+ .map_or_else(|_| url::Origin::new_opaque(), |url| url.origin())+ },+ )+ }+pub(crate) fn trusted_types_for_script_requirements_for_owner(&self,owner: OwnerDispatchScope,diff --git a/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs b/moli-renderer-v8/src/native_bridge/context_host/service_workers.rsindex afded7177..63ce1c559 100644--- a/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs+++ b/moli-renderer-v8/src/native_bridge/context_host/service_workers.rs@@ -307,6 +307,7 @@ impl JsContextHost {&mut self,retired_owner: WindowDocumentOwner,) {+ self.retire_web_mcp_document(retired_owner);let register_count = self.pending_service_worker_registers.len();self.pending_service_worker_registers.retain(|_, pending| pending.owner.window_document_owner() != retired_owner);@@ -338,6 +339,7 @@ impl JsContextHost {transition: crate::frame_owner_model::MainDocumentOwnerTransition,) {let retired_owner = transition.retired_owner();+ self.retire_web_mcp_document(WindowDocumentOwner::Frame(retired_owner));let register_count = self.pending_service_worker_registers.len();self.pending_service_worker_registers.retain(|_, pending| pending.owner.document_owner() != Some(retired_owner));diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rsindex 29df6ca2f..403341ece 100644--- a/moli-renderer-v8/src/native_bridge/element.rs+++ b/moli-renderer-v8/src/native_bridge/element.rs@@ -304,24 +304,23 @@ pub(super) use forms::{button_popover_target_action_getter_function, button_popover_target_action_setter_function,button_popover_target_element_getter_function, button_popover_target_element_setter_function,button_type_getter_function, button_type_setter_function, button_value_getter_function,- button_value_setter_function, control_check_validity_callback, control_label_handles,- control_labels_getter_function, control_report_validity_callback,- control_set_custom_validity_callback, control_validation_message_getter_function,- control_validity_getter_function, control_will_validate_getter_function,- datalist_options_getter_function, fieldset_disabled_getter_function,- fieldset_disabled_setter_function, fieldset_elements_getter_function,- fieldset_type_getter_function, form_accept_charset_getter_function,- form_accept_charset_setter_function, form_action_getter_function, form_action_setter_function,- form_associated_form_getter_function, form_autocomplete_getter_function,- form_autocomplete_setter_function, form_check_validity_callback, form_elements_getter_function,- form_encoding_getter_function, form_encoding_setter_function, form_enctype_getter_function,- form_enctype_setter_function, form_length_getter_function, form_method_getter_function,- form_method_setter_function, form_name_getter_function, form_name_setter_function,- form_no_validate_getter_function, form_no_validate_setter_function,- form_report_validity_callback, form_request_submit_callback, form_reset_callback,- form_submit_callback, form_target_getter_function, form_target_setter_function,- input_accept_getter_function, input_accept_setter_function, input_alt_getter_function,- input_alt_setter_function, input_autocomplete_getter_function,+ button_value_setter_function, control_check_validity_callback, control_labels_getter_function,+ control_report_validity_callback, control_set_custom_validity_callback,+ control_validation_message_getter_function, control_validity_getter_function,+ control_will_validate_getter_function, datalist_options_getter_function,+ fieldset_disabled_getter_function, fieldset_disabled_setter_function,+ fieldset_elements_getter_function, fieldset_type_getter_function,+ form_accept_charset_getter_function, form_accept_charset_setter_function,+ form_action_getter_function, form_action_setter_function, form_associated_form_getter_function,+ form_autocomplete_getter_function, form_autocomplete_setter_function,+ form_check_validity_callback, form_elements_getter_function, form_encoding_getter_function,+ form_encoding_setter_function, form_enctype_getter_function, form_enctype_setter_function,+ form_length_getter_function, form_method_getter_function, form_method_setter_function,+ form_name_getter_function, form_name_setter_function, form_no_validate_getter_function,+ form_no_validate_setter_function, form_report_validity_callback, form_request_submit_callback,+ form_reset_callback, form_submit_callback, form_target_getter_function,+ form_target_setter_function, input_accept_getter_function, input_accept_setter_function,+ input_alt_getter_function, input_alt_setter_function, input_autocomplete_getter_function,input_autocomplete_setter_function, input_checked_getter_function,input_checked_setter_function, input_default_checked_getter_function,input_default_checked_setter_function, input_default_value_getter_function,@@ -396,6 +395,7 @@ pub(crate) use forms::{cache_input_files_from_selected_files, form_control_is_effectively_disabled,input_files_for_object,};+pub(crate) use forms::{control_label_handles, v8_pattern_is_usable};pub(crate) use forms::{dispatch_text_control_event, is_text_control, perform_implicit_submission_from_control,queue_text_control_document_selection_change_event, replace_text_control_selection,diff --git a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rsindex bd330176e..5955db519 100644--- a/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs+++ b/moli-renderer-v8/src/native_bridge/element/activation/default_action.rs@@ -2355,11 +2355,16 @@ pub(in crate::native_bridge) fn navigate_form_target_browsing_context(return false;};let runtime = unsafe { &mut *runtime_ptr };- return runtime.navigate_child_browsing_context_to_url(- scope,- child_handle,- resolved_url,- );+ let navigated =+ runtime.navigate_child_browsing_context_to_url(scope, child_handle, resolved_url);+ if navigated {+ crate::context_bootstrap::web_mcp::bind_child_navigation(+ runtime,+ form_handle,+ child_handle,+ );+ }+ return navigated;}let source_element = node_wrapper_from_handle(scope, form_handle);if !crate::context_bootstrap::dispatch_top_level_navigation_event_with_source_element(@@ -2377,6 +2382,10 @@ pub(in crate::native_bridge) fn navigate_form_target_browsing_context(return false;};unsafe { &mut *runtime_ptr }.record_pending_location_navigation(url, None);+ crate::context_bootstrap::web_mcp::bind_root_navigation(+ unsafe { &mut *runtime_ptr },+ form_handle,+ );return true;}navigate_target_browsing_context(diff --git a/moli-renderer-v8/src/native_bridge/element/forms.rs b/moli-renderer-v8/src/native_bridge/element/forms.rsindex 9097ffbe9..0477a6431 100644--- a/moli-renderer-v8/src/native_bridge/element/forms.rs+++ b/moli-renderer-v8/src/native_bridge/element/forms.rs@@ -172,11 +172,11 @@ pub(in crate::native_bridge) use self::input::{textarea_text_length_getter_function, textarea_type_getter_function,textarea_wrap_getter_function, textarea_wrap_setter_function,};+pub(crate) use self::labels::control_label_handles;pub(in crate::native_bridge) use self::labels::{- control_label_handles, control_labels_getter_function, label_activation_control_handle,- label_control_getter_function, label_control_handle, label_form_getter_function,- label_html_for_getter_function, label_html_for_setter_function,- label_receives_programmatic_focus,+ control_labels_getter_function, label_activation_control_handle, label_control_getter_function,+ label_control_handle, label_form_getter_function, label_html_for_getter_function,+ label_html_for_setter_function, label_receives_programmatic_focus,};pub(in crate::native_bridge) use self::owner::form_associated_form_getter_function;pub(crate) use self::owner::{@@ -245,6 +245,7 @@ pub(in crate::native_bridge) use self::text_control::{text_control_set_selection_range_callback, textarea_value_getter_function,textarea_value_setter_function,};+pub(crate) use self::validation::v8_pattern_is_usable;pub(in crate::native_bridge) use self::validation::{control_check_validity_callback, control_matches_validity_pseudo,control_report_validity_callback, control_set_custom_validity_callback,diff --git a/moli-renderer-v8/src/native_bridge/element/forms/labels.rs b/moli-renderer-v8/src/native_bridge/element/forms/labels.rsindex f90ccd788..512870c71 100644--- a/moli-renderer-v8/src/native_bridge/element/forms/labels.rs+++ b/moli-renderer-v8/src/native_bridge/element/forms/labels.rs@@ -276,7 +276,7 @@ fn label_reflected_control_handle(label_control_handle(runtime, label_handle)}-pub(in crate::native_bridge) fn control_label_handles(+pub(crate) fn control_label_handles(runtime: &JsContextHost,control_handle: DomHandle,) -> Vec<DomHandle> {diff --git a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs b/moli-renderer-v8/src/native_bridge/element/forms/submission.rsindex 7919cbb02..eda9a642c 100644--- a/moli-renderer-v8/src/native_bridge/element/forms/submission.rs+++ b/moli-renderer-v8/src/native_bridge/element/forms/submission.rs@@ -231,6 +231,10 @@ fn submit_form_with_submit_event_inner(submitter_handle: Option<DomHandle>,user_initiated: bool,) -> bool {+ let invocation = crate::context_bootstrap::web_mcp::begin_form_submit(+ unsafe { &mut *runtime_ptr },+ form_handle,+ );let skips_constraint_validation = {let runtime = unsafe { &*runtime_ptr };form_submission_skips_constraint_validation(runtime, form_handle, submitter_handle)@@ -238,20 +242,48 @@ fn submit_form_with_submit_event_inner(if !skips_constraint_validation&& !form_validate_for_submission(scope, runtime_ptr, form_handle){+ if let Some(id) = invocation {+ crate::context_bootstrap::web_mcp::form_submission_failed(scope, runtime_ptr, id);+ }return false;}let submitter_value = wrap_handle_value(scope, runtime_ptr, submitter_handle);- if let Some(event) = construct_submit_event(scope, submitter_value, true, true)- && dispatch_public_event(scope, runtime_ptr, form_handle, event).allows_default()- {- return submit_form_default_action(+ if let Some(event) = construct_submit_event(scope, submitter_value, true, true) {+ if invocation.is_some() {+ crate::context_bootstrap::mark_agent_submit_event(scope, event);+ }+ let allows_default =+ dispatch_public_event(scope, runtime_ptr, form_handle, event).allows_default();+ if let Some(id) = invocation {+ crate::context_bootstrap::web_mcp::finish_form_submit(+ scope,+ runtime_ptr,+ id,+ event,+ allows_default,+ );+ }+ if !allows_default {+ return false;+ }+ let accepted = submit_form_default_action(scope,runtime_ptr,form_handle,submitter_handle,user_initiated,);+ crate::context_bootstrap::web_mcp::finish_form_navigation(+ scope,+ runtime_ptr,+ form_handle,+ accepted,+ );+ return accepted;+ }+ if let Some(id) = invocation {+ crate::context_bootstrap::web_mcp::form_submission_failed(scope, runtime_ptr, id);}false}@@ -352,6 +384,7 @@ pub(in crate::native_bridge) fn form_reset_callback<'s>(}if dispatch_form_reset_event(scope, runtime_ptr, form_handle, args.this()).allows_default() {+ crate::context_bootstrap::web_mcp::cancel_form_execution(scope, runtime_ptr, form_handle);let _ = reset_form_default_action(scope,runtime_ptr,@@ -467,7 +500,13 @@ pub(in crate::native_bridge) fn form_submit_callback<'s>(return;}- let _ = submit_form_default_action(scope, runtime_ptr, form_handle, None, false);+ let accepted = submit_form_default_action(scope, runtime_ptr, form_handle, None, false);+ crate::context_bootstrap::web_mcp::finish_form_navigation(+ scope,+ runtime_ptr,+ form_handle,+ accepted,+ );rv.set_undefined();}@@ -964,6 +1003,10 @@ fn submit_post_form_to_top_level_browsing_context(None,moli_fetch::BrowserNavigationRequestKind::Navigate,);+ crate::context_bootstrap::web_mcp::bind_root_navigation(+ unsafe { &mut *runtime_ptr },+ form_handle,+ );true}@@ -1008,7 +1051,8 @@ fn submit_post_form_to_child_browsing_context(return true;}}- unsafe { &mut *runtime_ptr }.navigate_child_browsing_context_with_request(+ let runtime = unsafe { &mut *runtime_ptr };+ let navigated = runtime.navigate_child_browsing_context_with_request(scope,child_handle,ChildBrowsingContextNavigationRequest {@@ -1017,7 +1061,15 @@ fn submit_post_form_to_child_browsing_context(body: Some(body),request_headers: vec![("Content-Type".to_owned(), content_type)],},- )+ );+ if navigated {+ crate::context_bootstrap::web_mcp::bind_child_navigation(+ runtime,+ form_handle,+ child_handle,+ );+ }+ navigated}fn build_form_submission_request(diff --git a/moli-renderer-v8/src/native_bridge/element/forms/validation.rs b/moli-renderer-v8/src/native_bridge/element/forms/validation.rsindex 3f325257a..b2c1c9b9f 100644--- a/moli-renderer-v8/src/native_bridge/element/forms/validation.rs+++ b/moli-renderer-v8/src/native_bridge/element/forms/validation.rs@@ -570,7 +570,7 @@ fn control_suffers_pattern_mismatch(})}-fn v8_pattern_is_usable(scope: &mut v8::PinScope<'_, '_>, pattern: &str) -> Option<()> {+pub(crate) fn v8_pattern_is_usable(scope: &mut v8::PinScope<'_, '_>, pattern: &str) -> Option<()> {let try_catch = std::pin::pin!(v8::TryCatch::new(scope));let mut scope = try_catch.init();let pattern = v8_string(&scope, pattern)?;diff --git a/moli-renderer-v8/src/permissions_policy.rs b/moli-renderer-v8/src/permissions_policy.rsindex 71dbbe5db..e996bdea9 100644--- a/moli-renderer-v8/src/permissions_policy.rs+++ b/moli-renderer-v8/src/permissions_policy.rs@@ -1,29 +1,41 @@+use std::sync::Arc;use url::Url;/// Policy-controlled features that currently have observable renderer behavior.///-/// This intentionally stores the effective policy for one committed Document,-/// rather than the raw header/container allowlists. Extend the record when a-/// newly implemented feature needs enforcement at its API boundary.-#[derive(Clone, Copy, Debug, PartialEq, Eq)]+/// Keep the declared tools allowlist alongside effective permissions: a+/// container cannot delegate tools to an origin excluded by its parent header.+#[derive(Clone, Debug, PartialEq, Eq)]pub(crate) struct DocumentPermissionsPolicy {gamepad: bool,+ tools: bool,+ tools_allowlist: Option<ToolsAllowlist>,}impl Default for DocumentPermissionsPolicy {fn default() -> Self {- Self { gamepad: true }+ Self {+ gamepad: true,+ tools: true,+ tools_allowlist: None,+ }}}impl DocumentPermissionsPolicy {- pub(crate) const fn gamepad_enabled(self) -> bool {+ pub(crate) const fn gamepad_enabled(&self) -> bool {self.gamepad}- pub(crate) const fn intersect(self, other: Self) -> Self {+ pub(crate) const fn tools_enabled(&self) -> bool {+ self.tools+ }++ pub(crate) fn intersect(&self, other: &Self) -> Self {Self {gamepad: self.gamepad && other.gamepad,+ tools: self.tools && other.tools,+ tools_allowlist: other.tools_allowlist.clone(),}}@@ -43,31 +55,102 @@ impl DocumentPermissionsPolicy {if feature.trim().eq_ignore_ascii_case("gamepad") {policy.gamepad = response_allowlist_allows_document(allowlist, document_url);}+ if feature.trim().eq_ignore_ascii_case("tools") {+ policy.tools_allowlist = response_tools_allowlist(allowlist);+ policy.tools =+ policy.tools_allows_origin(&document_url.origin(), &document_url.origin());+ }}}policy}pub(crate) fn delegated_to_child(- self,- parent_url: &Url,- child_url: &Url,- child_inherits_origin: bool,+ &self,+ parent_origin: &url::Origin,+ child_origin: &url::Origin,+ source_origin: &url::Origin,allow_attribute: Option<&str>,) -> Self {- let same_origin = child_inherits_origin || moli_url::same_origin(parent_url, child_url);+ let same_origin = parent_origin == child_origin;let gamepad = iframe_allow_feature(allow_attribute,"gamepad",- parent_url,- child_url,- same_origin,+ parent_origin,+ child_origin,+ source_origin,).unwrap_or(true);+ let tools = iframe_allow_feature(+ allow_attribute,+ "tools",+ parent_origin,+ child_origin,+ source_origin,+ )+ .unwrap_or(same_origin);Self {gamepad: self.gamepad && gamepad,+ tools: self.tools+ && self.tools_allows_origin(parent_origin, parent_origin)+ && self.tools_allows_origin(child_origin, parent_origin)+ && tools,+ tools_allowlist: None,+ }+ }++ pub(crate) fn for_document_origin(&self, origin: &url::Origin) -> Self {+ Self {+ tools: self.tools && self.tools_allows_origin(origin, origin),+ ..self.clone()+ }+ }++ fn tools_allows_origin(&self, origin: &url::Origin, self_origin: &url::Origin) -> bool {+ self.tools_allowlist.as_ref().is_none_or(|allowed| {+ allowed.matches_self && origin == self_origin || allowed.origins.contains(origin)+ })+ }+}++#[derive(Clone, Debug, PartialEq, Eq)]+struct ToolsAllowlist {+ matches_self: bool,+ origins: Arc<[url::Origin]>,+}++fn response_tools_allowlist(value: &str) -> Option<ToolsAllowlist> {+ let value = value.trim();+ if value == "*" {+ return None;+ }+ let Some(value) = value+ .strip_prefix('(')+ .and_then(|value| value.strip_suffix(')'))+ else {+ return Some(ToolsAllowlist {+ matches_self: false,+ origins: Arc::from([]),+ });+ };+ let mut origins = Vec::new();+ let mut matches_self = false;+ for token in value.split_ascii_whitespace() {+ if token == "*" {+ return None;+ }+ if token.eq_ignore_ascii_case("self") {+ matches_self = true;+ } else if let Ok(url) = Url::parse(token.trim_matches('"'))+ && matches!(url.origin(), url::Origin::Tuple(..))+ {+ origins.push(url.origin());}}+ Some(ToolsAllowlist {+ matches_self,+ origins: origins.into(),+ })}fn response_allowlist_allows_document(value: &str, document_url: &Url) -> bool {@@ -91,9 +174,9 @@ fn response_allowlist_allows_document(value: &str, document_url: &Url) -> bool {fn iframe_allow_feature(allow_attribute: Option<&str>,feature: &str,- parent_url: &Url,- child_url: &Url,- same_origin: bool,+ parent_origin: &url::Origin,+ child_origin: &url::Origin,+ source_origin: &url::Origin,) -> Option<bool> {let allow_attribute = allow_attribute?;allow_attribute.split(';').find_map(|directive| {@@ -104,7 +187,7 @@ fn iframe_allow_feature(}let allowlist = tokens.collect::<Vec<_>>();if allowlist.is_empty() {- return Some(true);+ return Some(child_origin == source_origin);}if allowlist.iter()@@ -114,10 +197,14 @@ fn iframe_allow_feature(}Some(allowlist.into_iter().any(|token| {token == "*"- || token.eq_ignore_ascii_case("'src'")- || (token.eq_ignore_ascii_case("'self'") && same_origin)- || token_origin_matches(token, child_url)- || token_origin_matches(token, parent_url) && same_origin+ || (token.eq_ignore_ascii_case("'src'") && child_origin == source_origin)+ || (token.eq_ignore_ascii_case("'self'") && child_origin == parent_origin)+ || Url::parse(token.trim_matches(['\'', '"']))+ .ok()+ .is_some_and(|url| {+ matches!(url.origin(), url::Origin::Tuple(..))+ && &url.origin() == child_origin+ })}))})}@@ -133,10 +220,162 @@ fn token_origin_matches(token: &str, url: &Url) -> bool {mod tests {use super::*;+ impl DocumentPermissionsPolicy {+ fn delegated_to_child_urls(+ &self,+ parent: &Url,+ child: &Url,+ inherits: bool,+ allow: Option<&str>,+ ) -> Self {+ let parent_origin = parent.origin();+ let child_origin = if inherits {+ parent_origin.clone()+ } else {+ child.origin()+ };+ self.delegated_to_child(&parent_origin, &child_origin, &child_origin, allow)+ }+ }+fn url(value: &str) -> Url {Url::parse(value).unwrap()}+ #[test]+ fn tools_headers_bind_self_to_the_sandboxed_document_origin() {+ let document = url("https://parent.test/child");+ for (allowlist, expected) in [+ ("tools=(self)", true),+ ("tools=*", true),+ ("tools=(\"https://parent.test\")", false),+ ] {+ let policy =+ crate::document_runtime::DocumentPolicyContainer::from_navigation_response_headers(+ &[+ ("permissions-policy".into(), allowlist.as_bytes().to_vec()),+ (+ "content-security-policy".into(),+ b"sandbox allow-scripts".to_vec(),+ ),+ ],+ &document,+ );+ assert!(policy.sandbox.forces_opaque_origin);+ assert_eq!(+ policy.permissions_policy.tools_enabled(),+ expected,+ "{allowlist}"+ );+ }+ }++ #[test]+ fn tools_policy_defaults_to_self_and_requires_both_parent_and_container_permission() {+ let parent = url("https://parent.test/");+ let same = url("https://parent.test/child");+ let other = url("https://other.test/");+ let allowed = DocumentPermissionsPolicy::default();+ assert!(+ allowed+ .delegated_to_child_urls(&parent, &same, false, None)+ .tools_enabled()+ );+ assert!(+ !allowed+ .delegated_to_child_urls(&parent, &other, false, None)+ .tools_enabled()+ );+ assert!(+ allowed+ .delegated_to_child_urls(&parent, &other, false, Some("tools *"))+ .tools_enabled()+ );+ assert!(+ !allowed+ .delegated_to_child_urls(&parent, &same, false, Some("tools 'none'"))+ .tools_enabled()+ );+ let denied = DocumentPermissionsPolicy::from_navigation_response_headers(+ &[("Permissions-Policy".into(), b"tools=()".to_vec())],+ &parent,+ );+ assert!(+ !denied+ .delegated_to_child_urls(&parent, &other, false, Some("tools *"))+ .tools_enabled()+ );+ assert!(denied.gamepad_enabled());+ }++ #[test]+ fn tools_response_allowlist_bounds_container_delegation() {+ let parent = url("https://parent.test/");+ for (header, child, allowed) in [+ ("tools=(self)", "https://parent.test/child", true),+ ("tools=(self)", "https://other.test/child", false),+ ("tools=()", "https://parent.test/child", false),+ ("tools=*", "https://other.test/child", true),+ (+ "tools=(self \"https://allowed.test\")",+ "https://allowed.test/child",+ true,+ ),+ (+ "tools=(self \"https://allowed.test\")",+ "https://other.test/child",+ false,+ ),+ (+ "tools=(\"https://allowed.test\")",+ "https://allowed.test/child",+ false,+ ),+ ] {+ let policy = DocumentPermissionsPolicy::from_navigation_response_headers(+ &[("Permissions-Policy".into(), header.as_bytes().to_vec())],+ &parent,+ );+ assert_eq!(+ policy+ .delegated_to_child_urls(&parent, &url(child), false, Some("tools *"))+ .tools_enabled(),+ allowed,+ "{header} -> {child}"+ );+ }+ let policy = DocumentPermissionsPolicy::from_navigation_response_headers(+ &[("Permissions-Policy".into(), b"tools=(self)".to_vec())],+ &parent,+ );+ assert!(+ policy+ .delegated_to_child_urls(&parent, &url("about:blank"), true, None)+ .tools_enabled()+ );+ let inherited = DocumentPermissionsPolicy::default().delegated_to_child_urls(+ &parent,+ &url("https://child.test/"),+ false,+ Some("tools *"),+ );+ let child_header = DocumentPermissionsPolicy::from_navigation_response_headers(+ &[("Permissions-Policy".into(), b"tools=(self)".to_vec())],+ &url("https://child.test/"),+ );+ let child = inherited.intersect(&child_header);+ assert!(+ !child+ .delegated_to_child_urls(+ &url("https://child.test/"),+ &parent,+ false,+ Some("tools *")+ )+ .tools_enabled()+ );+ }+#[test]fn permissions_policy_header_takes_precedence_over_legacy_feature_policy() {let policy = DocumentPermissionsPolicy::from_navigation_response_headers(@@ -165,14 +404,18 @@ mod tests {let cross_origin = url("data:text/html,child");let policy = DocumentPermissionsPolicy::default();- let same = policy.delegated_to_child(&parent, &same_origin, false, None);+ let same = policy.delegated_to_child_urls(&parent, &same_origin, false, None);assert!(same.gamepad_enabled());- let cross = policy.delegated_to_child(&parent, &cross_origin, false, None);+ let cross = policy.delegated_to_child_urls(&parent, &cross_origin, false, None);assert!(cross.gamepad_enabled());- let delegated =- policy.delegated_to_child(&parent, &cross_origin, false, Some("payment; gamepad *"));+ let delegated = policy.delegated_to_child_urls(+ &parent,+ &cross_origin,+ false,+ Some("payment; gamepad *"),+ );assert!(delegated.gamepad_enabled());}@@ -180,7 +423,7 @@ mod tests {fn iframe_none_and_parent_policy_cannot_be_overridden() {let parent = url("https://parent.test/page");let child = url("https://parent.test/child");- let denied = DocumentPermissionsPolicy::default().delegated_to_child(+ let denied = DocumentPermissionsPolicy::default().delegated_to_child_urls(&parent,&child,false,@@ -188,8 +431,11 @@ mod tests {);assert!(!denied.gamepad_enabled());- let parent_denied = DocumentPermissionsPolicy { gamepad: false };- let delegated = parent_denied.delegated_to_child(+ let parent_denied = DocumentPermissionsPolicy {+ gamepad: false,+ ..Default::default()+ };+ let delegated = parent_denied.delegated_to_child_urls(&parent,&url("https://other.test/child"),false,diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rsindex d628f2d7d..88295590b 100644--- a/moli-renderer-v8/src/runtime/owner.rs+++ b/moli-renderer-v8/src/runtime/owner.rs@@ -106,6 +106,7 @@ use self::lifecycle_decision::PendingLifecycleNavigation;#[derive(Debug, Clone)]pub struct RendererPreparedDocumentCommitConfiguration {+ pub web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,pub document_start_scripts: Vec<DocumentStartScript>,pub runtime_bindings: Vec<crate::protocol_types::RuntimeBindingRegistration>,pub runtime_inspector_session_restore_snapshots: Vec<RendererInspectorSessionRestoreSnapshot>,@@ -125,6 +126,7 @@ pub struct RendererPreparedDocumentCommitConfiguration {#[derive(Debug)]pub struct RendererCreateHtmlPageRequest {+ pub web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,/// Exact owner-local Page identity reserved before this request is queued.////// Parser/resource output produced while the Page is still being built@@ -173,6 +175,7 @@ pub struct RendererCreateHtmlPageRequest {}pub struct RendererCreateStreamingRawPageRequest {+ pub web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,pub(super) document_replacement:Option<Arc<super::document_replacement::RendererDocumentReplacementScope>>,pub root_frame_id: Option<String>,diff --git a/moli-renderer-v8/src/runtime/owner/page_creation.rs b/moli-renderer-v8/src/runtime/owner/page_creation.rsindex 84bb71671..b64c6dfdc 100644--- a/moli-renderer-v8/src/runtime/owner/page_creation.rs+++ b/moli-renderer-v8/src/runtime/owner/page_creation.rs@@ -659,6 +659,7 @@ impl RendererOwnerHandle {) -> RendererCreateHtmlPageRequest {let layout_configuration = self.seal_layout_configuration_for_page_creation();RendererCreateHtmlPageRequest {+ web_mcp_invocation: None,page_reservation,root_frame_id: options.root_frame_id,main_document_commit: options.main_document_commit,@@ -718,6 +719,7 @@ impl RendererOwnerHandle {) -> RendererCreateStreamingRawPageRequest {let layout_configuration = self.seal_layout_configuration_for_page_creation();RendererCreateStreamingRawPageRequest {+ web_mcp_invocation: None,document_replacement: None,root_frame_id: options.root_frame_id,main_document_commit: options.main_document_commit,@@ -787,6 +789,7 @@ impl RendererOwnerHandle {_owner_local_store: &mut RendererOwnerLocalStore,) -> RenderRuntimeDispatchOutcome {let RendererCreateHtmlPageRequest {+ web_mcp_invocation,page_reservation,root_frame_id,main_document_commit,@@ -877,6 +880,7 @@ impl RendererOwnerHandle {owner.state.browser_context_runtime.clone(),).with_renderer_document_isolate_allocator(renderer_document_isolate_allocator);+ let runtime_hooks = runtime_hooks.with_web_mcp_navigation(web_mcp_invocation);let local_executor = owner.state.local_executor.clone();debug!(stage = ?stage, %final_url, "starting page VM creation from html");let env = PageVmEnvConfig {@@ -1087,6 +1091,7 @@ impl RendererOwnerHandle {_owner_local_store: &mut RendererOwnerLocalStore,) -> RenderRuntimeDispatchOutcome {let RendererCreateStreamingRawPageRequest {+ web_mcp_invocation,document_replacement: _document_replacement,root_frame_id,main_document_commit,@@ -1166,6 +1171,7 @@ impl RendererOwnerHandle {).with_renderer_document_isolate_allocator(isolate_allocator).with_prepared_renderer_document_isolate(isolate_bootstrap, isolate_reservation)?;+ let runtime_hooks = runtime_hooks.with_web_mcp_navigation(web_mcp_invocation);let local_executor = owner.state.local_executor.clone();let env = PageVmEnvConfig {web_storage,diff --git a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs b/moli-renderer-v8/src/runtime/owner_local_store/mod.rsindex 59971159c..dd08e59ab 100644--- a/moli-renderer-v8/src/runtime/owner_local_store/mod.rs+++ b/moli-renderer-v8/src/runtime/owner_local_store/mod.rs@@ -903,6 +903,7 @@ impl RendererOwnerLocalStore {macro_rules! apply_configuration {($request:expr) => {{let request = $request;+ request.web_mcp_invocation = configuration.web_mcp_invocation;request.document_start_scripts = configuration.document_start_scripts;request.runtime_bindings = configuration.runtime_bindings;request.runtime_inspector_session_restore_snapshots =diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rsindex 4d750aeae..375448bf0 100644--- a/moli-renderer-v8/src/runtime/page_commands.rs+++ b/moli-renderer-v8/src/runtime/page_commands.rs@@ -171,6 +171,18 @@ impl PageVm {RendererPageCommand::TriggerAutofill(request) => self.trigger_autofill(request).map(RendererPageReply::AutofillTriggerOutcome),+ RendererPageCommand::WebMcp { session, command } => {+ let enabled = match command {+ moli_page_types::RendererWebMcpCommand::Enable => Some(true),+ moli_page_types::RendererWebMcpCommand::Disable => Some(false),+ _ => None,+ };+ let result = self.vm_mut().dispatch_web_mcp_command(session.clone(), command)?;+ if result.is_ok() && let Some(enabled) = enabled {+ self.runtime_inspector_protocol_configurations.entry(session).or_default().web_mcp_enabled = enabled;+ }+ Ok(RendererPageReply::WebMcp(result))+ }RendererPageCommand::ResetNavigationHistory => self.vm_mut().reset_navigation_history()diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rsindex 12440d2a8..941f86ca7 100644--- a/moli-renderer-v8/src/runtime/page_surface.rs+++ b/moli-renderer-v8/src/runtime/page_surface.rs@@ -314,6 +314,7 @@ pub struct RendererDocumentSourcedTopLevelLocationNavigation {#[derive(Debug, Clone, PartialEq, Eq)]struct RendererTopLevelNavigationRequest {+ web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,url: String,request_method: String,request_body: Option<Vec<u8>>,@@ -354,6 +355,7 @@ impl RendererDocumentSourcedTopLevelLocationNavigation {Self {source_document,request: Box::new(RendererTopLevelNavigationRequest {+ web_mcp_invocation: None,url,request_method,request_body,@@ -368,6 +370,18 @@ impl RendererDocumentSourcedTopLevelLocationNavigation {self.source_document}+ pub fn with_web_mcp_invocation(+ mut self,+ id: Option<moli_page_types::RendererWebMcpNavigation>,+ ) -> Self {+ self.request.web_mcp_invocation = id;+ self+ }++ pub fn web_mcp_invocation(&self) -> Option<moli_page_types::RendererWebMcpNavigation> {+ self.request.web_mcp_invocation.clone()+ }+pub fn url(&self) -> &str {&self.request.url}@@ -4657,6 +4671,10 @@ pub(crate) enum RendererInspectorPageCommand {#[non_exhaustive]pub enum RendererPageCommand {+ WebMcp {+ session: DevToolsSessionKey,+ command: moli_page_types::RendererWebMcpCommand,+ },// The call fits inline; its operation boxes the recursively contained page command.Native(RendererCdpCall),Inspector(RendererInspectorCommandEnvelope),@@ -5658,6 +5676,7 @@ impl RendererPageCommand {Self::RemoveDocumentNode { .. } => Some("RemoveDocumentNode"),Self::EditDocumentNode { .. } => Some("EditDocumentNode"),Self::TriggerAutofill(_) => Some("TriggerAutofill"),+ Self::WebMcp { .. } => Some("WebMCP"),Self::ComputedStyleProperties { .. } => Some("ComputedStyleProperties"),Self::SetFileInputFilesForBackendNodeId { .. } => {Some("SetFileInputFilesForBackendNodeId")@@ -5965,6 +5984,7 @@ pub enum RendererCaptureScreencastFrameReply {}pub enum RendererPageReply {+ WebMcp(std::result::Result<Option<u64>, moli_page_types::RendererWebMcpError>),NativeCommandReady(Box<RendererNativeCommandReadyResponse>),NativeCommandPublished,ElementClickPreparation(Result<RendererElementClickTarget, RendererElementClickError>),diff --git a/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rs b/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rsindex 82bd67bd1..0c975a86e 100644--- a/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rs+++ b/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rs@@ -525,6 +525,7 @@ pub(in crate::runtime) struct PageVmPreparedFollowedNavigationCommit {navigation_bootstrap_entry: Option<crate::native_bridge::NavigationHistoryEntrySeed>,reserved_service_worker_client_id: Option<crate::service_worker_runtime::ServiceWorkerClientId>,service_worker_client_navigate: Option<crate::types::ServiceWorkerClientNavigateContinuation>,+ web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,stage: PageVmInitStage,}@@ -715,6 +716,7 @@ impl PageVm {.reserved_service_worker_client.map(|reserved| reserved.release());let service_worker_client_navigate = pending.service_worker_client_navigate;+ let web_mcp_invocation = pending.web_mcp_invocation;tracing::debug!(stage = ?stage, %url, "following pending location navigation asynchronously");if navigation_kind == crate::native_bridge::PendingLocationNavigationKind::JavascriptUrl {@@ -783,6 +785,9 @@ impl PageVm {{Ok(loaded) => loaded,Err(error) => {+ if let Some(id) = web_mcp_invocation {+ self.vm_mut().fail_web_mcp_navigation(id);+ }self.reject_failed_followed_location_navigation(&initiator_url,reserved_service_worker_client_id,@@ -794,6 +799,9 @@ impl PageVm {};let loaded = match loaded {LoadedFollowedLocationNavigation::NoDocument => {+ if let Some(id) = web_mcp_invocation {+ self.vm_mut().fail_web_mcp_navigation(id);+ }self.abort_followed_navigation_without_document(&initiator_url,reserved_service_worker_client_id,@@ -804,6 +812,9 @@ impl PageVm {)));}LoadedFollowedLocationNavigation::Download(download) => {+ if let Some(id) = web_mcp_invocation {+ self.vm_mut().fail_web_mcp_navigation(id);+ }self.abort_followed_navigation_without_document(&initiator_url,reserved_service_worker_client_id,@@ -825,6 +836,7 @@ impl PageVm {navigation_bootstrap_entry: pending.entry_seed,reserved_service_worker_client_id,service_worker_client_navigate,+ web_mcp_invocation,stage,},)))@@ -842,6 +854,7 @@ impl PageVm {navigation_bootstrap_entry,reserved_service_worker_client_id,service_worker_client_navigate,+ web_mcp_invocation,stage,..} = prepared;@@ -850,6 +863,7 @@ impl PageVm {loaded,navigation_bootstrap_entry,reserved_service_worker_client_id,+ web_mcp_invocation,stage,FollowedLocationNavigationBootstrapBoundary::ContinuePhaseOne,)@@ -952,10 +966,12 @@ impl PageVm {navigation_bootstrap_entry,reserved_service_worker_client_id,service_worker_client_navigate,+ web_mcp_invocation,stage,} = prepared;let env = self.followed_location_navigation_env();- let runtime_hooks = self.runtime_hooks.clone().for_cross_document_commit();+ let mut runtime_hooks = self.runtime_hooks.clone().for_cross_document_commit();+ runtime_hooks.web_mcp_navigation = web_mcp_invocation.clone();#[cfg(test)]let runtime_hooks = {let mut runtime_hooks = runtime_hooks;@@ -987,6 +1003,9 @@ impl PageVm {let window_proxy_commit = match commit_result {Ok(commit) => commit,Err(error) => {+ if let Some(id) = web_mcp_invocation {+ self.vm_mut().fail_web_mcp_navigation(id);+ }self.reject_failed_followed_location_navigation(&initiator_url,reserved_service_worker_client_id,@@ -1257,6 +1276,7 @@ impl PageVm {reserved_service_worker_client_id: Option<crate::service_worker_runtime::ServiceWorkerClientId,>,+ web_mcp_invocation: Option<moli_page_types::RendererWebMcpNavigation>,stage: PageVmInitStage,boundary: FollowedLocationNavigationBootstrapBoundary,) -> Result<PageVmFollowedNavigationBuildOutcome> {@@ -1270,7 +1290,8 @@ impl PageVm {| LoadedFollowedLocationNavigation::ExternalDocument { .. }));let env = self.followed_location_navigation_env();- let runtime_hooks = self.runtime_hooks.clone().for_cross_document_commit();+ let mut runtime_hooks = self.runtime_hooks.clone().for_cross_document_commit();+ runtime_hooks.web_mcp_navigation = web_mcp_invocation;if runtime_hooks.has_renderer_page_script_environment() {self.prepare_main_window_proxy_navigation(self.page_id)?.detach();diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rsindex 61d4958fb..d54b1e395 100644--- a/moli-renderer-v8/src/runtime/page_vm/mod.rs+++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs@@ -1139,6 +1139,7 @@ pub(crate) struct PageVmRuntimeHooks {pub(crate) browser_context_runtime: super::RendererBrowserContextRuntime,document_lifecycle: Option<RendererDocumentLifecycleJournalHandle>,document_lifecycle_install: PageVmDocumentLifecycleInstall,+ web_mcp_navigation: Option<moli_page_types::RendererWebMcpNavigation>,renderer_document_isolate_allocator: Option<RendererDocumentIsolateAllocator>,renderer_page_script_environment: Option<crate::script_vm::RendererPageScriptEnvironment>,renderer_document_isolate_reservation: Option<RendererDocumentIsolateReservation>,@@ -1188,6 +1189,13 @@ struct PageVmRendererDocumentIsolateBootstrap {}impl PageVmRuntimeHooks {+ pub(in crate::runtime) fn with_web_mcp_navigation(+ mut self,+ id: Option<moli_page_types::RendererWebMcpNavigation>,+ ) -> Self {+ self.web_mcp_navigation = id;+ self+ }#[cfg(test)]fn standalone_base_for_test() -> Self {let owner = Rc::new(super::RendererBrowserContextRuntime::new());@@ -1201,6 +1209,7 @@ impl PageVmRuntimeHooks {browser_context_runtime,document_lifecycle: None,document_lifecycle_install: PageVmDocumentLifecycleInstall::default(),+ web_mcp_navigation: None,renderer_document_isolate_allocator: None,renderer_page_script_environment: None,renderer_document_isolate_reservation: None,@@ -1276,6 +1285,7 @@ impl PageVmRuntimeHooks {},document_lifecycle: None,document_lifecycle_install: PageVmDocumentLifecycleInstall::default(),+ web_mcp_navigation: None,renderer_document_isolate_allocator: None,renderer_page_script_environment: None,renderer_document_isolate_reservation: None,@@ -1314,6 +1324,7 @@ impl PageVmRuntimeHooks {browser_context_runtime,document_lifecycle: None,document_lifecycle_install: PageVmDocumentLifecycleInstall::ReuseOrCreateInitial,+ web_mcp_navigation: None,renderer_document_isolate_allocator: None,renderer_page_script_environment: None,renderer_document_isolate_reservation: None,@@ -2330,11 +2341,8 @@ impl PageVm {&mut self,restores: &[RendererInspectorSessionRestoreSnapshot],) -> Result<()> {- if restores.is_empty() {- return Ok(());- }debug_assert!(- is_on_named_owner_execution_lane_for(&self.local_executor),+ restores.is_empty() || is_on_named_owner_execution_lane_for(&self.local_executor),"runtime inspector session restore must execute on the matching named owner lane");for restore in restores {@@ -2344,6 +2352,11 @@ impl PageVm {&restore.v8_attach,)?;}+ // A committed WebMCP continuation can publish an immediate failure.+ // Restore the enabled sessions before handing it to the new Document.+ if let Some(id) = self.runtime_hooks.web_mcp_navigation.take() {+ self.vm_mut().receive_web_mcp_navigation(id);+ }Ok(())}diff --git a/moli-renderer-v8/src/runtime/protocol_output/item.rs b/moli-renderer-v8/src/runtime/protocol_output/item.rsindex c26f7b5c3..d9513af01 100644--- a/moli-renderer-v8/src/runtime/protocol_output/item.rs+++ b/moli-renderer-v8/src/runtime/protocol_output/item.rs@@ -83,6 +83,7 @@ pub enum RendererOwnerAction {/// protocol-boundary responsibility.#[derive(Clone, Debug, PartialEq)]pub enum RendererProtocolObservation {+ WebMcp(moli_page_types::RendererWebMcpObservation),MainDocumentCommit(RendererMainDocumentCommit),DocumentTitleChanged(RendererDocumentTitleChanged),DocumentLifecycle(RendererDocumentLifecycleEvent),diff --git a/moli-renderer-v8/src/runtime/protocol_output/native_response.rs b/moli-renderer-v8/src/runtime/protocol_output/native_response.rsindex 1f40a95e3..e1326ddfe 100644--- a/moli-renderer-v8/src/runtime/protocol_output/native_response.rs+++ b/moli-renderer-v8/src/runtime/protocol_output/native_response.rs@@ -73,9 +73,12 @@ impl RendererNativeProtocolResponse {/// never callbacks into a live Page, and are discarded on attachment retirement.#[derive(Clone, Debug, PartialEq, Eq)]pub enum RendererNativeProtocolStateUpdate {+ WebMcpEnabled(bool),/// Register object IDs from the successful terminal result before delivery./// The reply already owns the payload; this update only retains its group.- RemoteObjects { object_group: Option<String> },+ RemoteObjects {+ object_group: Option<String>,+ },DomRemoteObjectNode {object_id: String,node: serde_json::Value,diff --git a/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rs b/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rsindex 527a4e108..fc9bbcb97 100644--- a/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rs+++ b/moli-renderer-v8/src/runtime/protocol_output/transport_memory.rs@@ -34,6 +34,7 @@ fn native_terminal_charge_bytes(terminal: &super::RendererNativeCommandTerminal)});for update in &response.state_updates {charge = charge.saturating_add(match update {+ super::RendererNativeProtocolStateUpdate::WebMcpEnabled(_) => 0,super::RendererNativeProtocolStateUpdate::RemoteObjects { object_group } => {object_group.as_deref().map_or(0, string_charge)}@@ -91,6 +92,46 @@ fn json_charge(value: &serde_json::Value) -> usize {fn observation_transport_charge_bytes(observation: &RendererProtocolObservation) -> usize {match observation {+ RendererProtocolObservation::WebMcp(observation) => {+ use moli_page_types::{RendererWebMcpEvent as Event, RendererWebMcpResult as Result};+ let frame_charge = |frame: &Option<String>| frame.as_deref().map_or(0, string_charge);+ let payload = match &observation.event {+ Event::ToolsAdded(tools) => tools.iter().fold(+ tools+ .capacity()+ .saturating_mul(std::mem::size_of::<moli_page_types::RendererWebMcpTool>()),+ |sum, tool| {+ sum.saturating_add(frame_charge(&tool.frame_id))+ .saturating_add(string_charge(&tool.name))+ .saturating_add(string_charge(&tool.description))+ .saturating_add(tool.input_schema.as_deref().map_or(0, string_charge))+ },+ ),+ Event::ToolsRemoved(tools) => {+ tools+ .iter()+ .fold(tools.capacity().saturating_mul(64), |sum, tool| {+ sum.saturating_add(frame_charge(&tool.frame_id))+ .saturating_add(string_charge(&tool.name))+ })+ }+ Event::ToolInvoked { tool, input, .. } => frame_charge(&tool.frame_id)+ .saturating_add(string_charge(&tool.name))+ .saturating_add(string_charge(input)),+ Event::ToolResponded { result, .. } => match result {+ Result::Completed(output) => string_charge(output),+ Result::Canceled => 0,+ Result::Error { message, exception } => string_charge(message)+ .saturating_add(exception.as_ref().map_or(0, json_charge)),+ },+ };+ payload.saturating_add(+ observation+ .session+ .wire_session_id()+ .map_or(0, string_charge),+ )+ }RendererProtocolObservation::MainDocumentCommit(commit) => [commit.frame_id.as_str(),commit.loader_id.as_str(),diff --git a/moli-renderer-v8/src/runtime/tests/extracted/navigation_streaming.rs b/moli-renderer-v8/src/runtime/tests/extracted/navigation_streaming.rsindex 71de372c8..d443f0991 100644--- a/moli-renderer-v8/src/runtime/tests/extracted/navigation_streaming.rs+++ b/moli-renderer-v8/src/runtime/tests/extracted/navigation_streaming.rs@@ -168,6 +168,7 @@ async fn streaming_unstyled_xml_converts_live_document_before_domcontentloaded().await;prepared.update_commit_configuration(RendererPreparedDocumentCommitConfiguration {+ web_mcp_invocation: None,document_start_scripts: vec![crate::DocumentStartScript {registry_key: None,devtools_session: None,@@ -286,6 +287,7 @@ async fn prepared_streaming_xml_document_waits_for_permit_and_uses_latest_configprepared.update_commit_configuration(RendererPreparedDocumentCommitConfiguration {+ web_mcp_invocation: None,document_start_scripts: vec![crate::DocumentStartScript {registry_key: None,@@ -733,6 +735,7 @@ globalThis.__preparedCommitObserved = JSON.stringify([.expect("prepared body producer should finish");prepared.update_commit_configuration(RendererPreparedDocumentCommitConfiguration {+ web_mcp_invocation: None,document_start_scripts: vec![crate::DocumentStartScript {registry_key: None,diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex fd4746f76..42a27860b 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -823,6 +823,7 @@ mod text_track_load;mod user_interaction;mod view_transition_update;pub(crate) mod web_fonts;+mod web_mcp;pub(crate) mod webcrypto_tasks;mod websocket_event_body;mod websocket_worker;@@ -899,6 +900,7 @@ pub(crate) use input_helpers::*;use inspector::*;pub(crate) use inspector::{DocumentInspectorBinding, RendererDomDebuggerPauseScheduler, RendererDomDebuggerScheduledPause,+ RendererInspectorObjectWrapper,};use isolated_worlds::*;pub(crate) use runtime_bindings::PromiseRejectDispatchSlot;@@ -1467,6 +1469,16 @@ impl ScriptVm {) -> Result<()> {const INTERNAL_RUNTIME_ENABLE_ID: u64 = 900_013;const INTERNAL_CONSOLE_ENABLE_ID: u64 = 900_014;+ if protocol_configuration.web_mcp_enabled {+ self.prepare_web_mcp_session(+ &moli_page_types::DevToolsSessionKey::from_wire_session_id(inspector_session_id),+ );+ }+ crate::context_bootstrap::web_mcp::configure_session(+ &mut self._context_host.borrow_mut(),+ moli_page_types::DevToolsSessionKey::from_wire_session_id(inspector_session_id),+ protocol_configuration.web_mcp_enabled,+ );self.set_inspector_session_runtime_bindings(inspector_session_id,diff --git a/moli-renderer-v8/src/script_vm/child_frame_runtime.rs b/moli-renderer-v8/src/script_vm/child_frame_runtime.rsindex 72f31d0e0..99a905eb1 100644--- a/moli-renderer-v8/src/script_vm/child_frame_runtime.rs+++ b/moli-renderer-v8/src/script_vm/child_frame_runtime.rs@@ -489,7 +489,7 @@ impl ScriptVm {pending.request_headers,pending.browser_navigation_kind,runtime_command_cause.clone(),- ),+ ).with_web_mcp_invocation(pending.web_mcp_invocation),);anyhow::ensure!(self._context_hostdiff --git a/moli-renderer-v8/src/script_vm/document_environment.rs b/moli-renderer-v8/src/script_vm/document_environment.rsindex f34a45150..d367a5fa9 100644--- a/moli-renderer-v8/src/script_vm/document_environment.rs+++ b/moli-renderer-v8/src/script_vm/document_environment.rs@@ -11,6 +11,10 @@ impl ScriptVm {&mut self,policy: crate::document_runtime::DocumentPolicyContainer,) {+ let was_opaque = self+ .document_runtime+ .document_sandbox_policy()+ .forces_opaque_origin;self.document_runtime.set_main_navigation_policy_container(policy);// The main context exists before its navigation response policy is applied.@@ -23,6 +27,20 @@ impl ScriptVm {"failed to refresh main Window security token; using unique context token");}+ let host = unsafe { &*host_ptr };+ let is_opaque = host.document_sandbox_policy().forces_opaque_origin;+ if was_opaque != is_opaque {+ let origin = if is_opaque {+ "null".into()+ } else {+ moli_url::origin_ascii_serialization(host.document_url())+ };+ crate::context_bootstrap::set_window_origin_runtime_state(+ scope,+ context.global(scope),+ &origin,+ )?;+ }Ok(())});}@@ -77,6 +95,11 @@ impl ScriptVm {inspector_session_id.filter(|session_id| !session_id.is_empty()),);let detached = self.page_inspector.detach_session(inspector_session_id);+ self._context_host+ .borrow_mut()+ .native_bridge_mut()+ .web_mcp+ .disable_session(&devtools_session);let retired_worlds = self.retire_isolated_worlds_for_devtools_session(&devtools_session);detached || retired_worlds != 0}diff --git a/moli-renderer-v8/src/script_vm/eval_exec.rs b/moli-renderer-v8/src/script_vm/eval_exec.rsindex 18f086bcc..ccf65a4ff 100644--- a/moli-renderer-v8/src/script_vm/eval_exec.rs+++ b/moli-renderer-v8/src/script_vm/eval_exec.rs@@ -1254,6 +1254,8 @@ impl ScriptVm {) -> T {self.apply_pending_main_document_owner_transitions();self.apply_pending_child_document_owner_retirements();+ self.queue_retired_web_mcp();+ self.queue_declarative_web_mcp();self.settle_retired_history_traversals();self.drain_pending_style_invalidations_for_turn_exit(boundary);let runtime_continuation_is_ready =diff --git a/moli-renderer-v8/src/script_vm/inspector/agent.rs b/moli-renderer-v8/src/script_vm/inspector/agent.rsindex 710351b7c..2676c2b93 100644--- a/moli-renderer-v8/src/script_vm/inspector/agent.rs+++ b/moli-renderer-v8/src/script_vm/inspector/agent.rs@@ -46,6 +46,42 @@ pub(crate) struct RendererDomDebuggerPauseScheduler {state: Weak<RefCell<RendererDevToolsAgentState>>,}+/// Weak capability to wrap a native API exception in an existing frontend's+/// V8 session. The owning renderer agent retains all RemoteObject authority.+#[derive(Clone)]+pub(crate) struct RendererInspectorObjectWrapper {+ state: Weak<RefCell<RendererDevToolsAgentState>>,+}++impl RendererInspectorObjectWrapper {+ pub(crate) fn wrap<'s>(+ &self,+ scope: &mut v8::PinScope<'s, '_>,+ session_key: &DevToolsSessionKey,+ value: v8::Local<'s, v8::Value>,+ ) -> Option<serde_json::Value> {+ let state = self.state.upgrade()?;+ let session = state+ .borrow()+ .sessions+ .frontend_session_and_outbound(session_key)?+ .0;+ let context = v8::Local::<v8::Object>::try_from(value)+ .ok()+ .and_then(|object| object.get_creation_context(scope))+ .unwrap_or_else(|| scope.get_current_context());+ let remote = session.wrap_object(+ scope,+ context,+ value,+ v8::inspector::StringView::from(&b""[..]),+ false,+ )?;+ let json = v8::crdtp::cbor_to_json(&remote.to_bytes())?;+ serde_json::from_slice(&json).ok()+ }+}+#[must_use]pub(crate) struct RendererDomDebuggerScheduledPause {sessions: Vec<Rc<v8::inspector::V8InspectorSession>>,@@ -123,6 +159,11 @@ impl RendererDomDebuggerPauseScheduler {}impl RendererDevToolsAgent {+ pub(super) fn object_wrapper(&self) -> RendererInspectorObjectWrapper {+ RendererInspectorObjectWrapper {+ state: Rc::downgrade(&self.state),+ }+ }pub(super) fn new(isolate_backend: RendererInspectorIsolateBackendHandle) -> Self {Self {state: Rc::new(RefCell::new(RendererDevToolsAgentState {diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rsindex 1b7d9819e..3a798f1c9 100644--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs@@ -11,6 +11,7 @@ mod v8_backend;use self::agent::RendererDevToolsAgent;pub(crate) use self::agent::{RendererDomDebuggerPauseScheduler, RendererDomDebuggerScheduledPause,+ RendererInspectorObjectWrapper,};pub(super) use self::agent_sessions::PageInspectorSessionTarget;use self::agent_sessions::inspector_session_key;@@ -195,6 +196,10 @@ impl DocumentInspectorBinding {.ensure_frontend(backend, inspector_session_key(inspector_session_id));}+ pub(super) fn object_wrapper(&self) -> RendererInspectorObjectWrapper {+ self.agent.object_wrapper()+ }+pub(super) fn end_runtime_command_output_for_session(&self,inspector_session_id: Option<&str>,diff --git a/moli-renderer-v8/src/script_vm/main_document_lifecycle_body.rs b/moli-renderer-v8/src/script_vm/main_document_lifecycle_body.rsindex f8cdfca0d..1cb221e8e 100644--- a/moli-renderer-v8/src/script_vm/main_document_lifecycle_body.rs+++ b/moli-renderer-v8/src/script_vm/main_document_lifecycle_body.rs@@ -19,6 +19,25 @@ use crate::dom::native::DocumentReadyState;use crate::frame_owner_model::{FrameDocumentTaskOwner, MainDocumentInteractiveLifecycleAction};impl ScriptVm {+ pub(crate) fn receive_web_mcp_navigation(+ &mut self,+ id: moli_page_types::RendererWebMcpNavigation,+ ) {+ let mut host = self._context_host.borrow_mut();+ let owner = crate::native_bridge::WindowDocumentOwner::Frame(+ host.current_main_document_task_owner()+ .expect("committed main document"),+ );+ crate::context_bootstrap::web_mcp::receive_navigation(&mut host, owner, id);+ }++ pub(crate) fn fail_web_mcp_navigation(+ &mut self,+ id: moli_page_types::RendererWebMcpNavigation,+ ) {+ crate::context_bootstrap::web_mcp::fail_navigation(&self._context_host.borrow(), id);+ }+/// Apply Blink's `CancelParsing()` readiness boundary for Page.stopLoading.////// This is deliberately separate from the ordinary Window-load body: the@@ -155,6 +174,15 @@ impl ScriptVm {"dispatching document-owned main DOMContentLoaded transition");self.document_runtime.note_dom_content_loaded_dispatched();+ {+ let mut host = self._context_host.borrow_mut();+ let document = host.document_handle();+ crate::context_bootstrap::web_mcp::complete_navigation(+ &mut host,+ document,+ crate::native_bridge::WindowDocumentOwner::Frame(owner),+ );+ }self.document_runtime.record_quirks_mode_inspector_issue_at_dom_content_loaded();let event_end =diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rsindex 3d5174a1e..5ed85db3a 100644--- a/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/mod.rs@@ -56,6 +56,7 @@ mod traversal_coordinator;mod trusted_types;mod value_events;mod web_audio;+mod web_mcp;mod webrtc;mod webrtc_events;mod window_legacy_objects;diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp.rsnew file mode 100644index 000000000..0485e6e05--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp.rs@@ -0,0 +1,575 @@+use super::*;+mod declarative;+mod discovery;+mod review_regressions;++#[test]+fn web_mcp_get_tools_completes_after_the_current_microtasks() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(+ r#"+ globalThis.probe=[];+ document.modelContext.getTools().then(()=>probe.push('tools'));+ queueMicrotask(()=>probe.push('microtask'));+ probe.push('sync');+ "#,+ )+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')")+ .unwrap(),+ "sync|microtask|tools"+ );+}++#[test]+fn web_mcp_schema_serialization_cannot_replace_a_reentrant_registration() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.inner='pending';globalThis.outer='pending';globalThis.result='pending';+ document.modelContext.registerTool({name:'same',description:'Outer',execute:()=> 'outer',inputSchema:{toJSON(){+ document.modelContext.registerTool({name:'same',description:'Inner',execute:()=> 'inner'}).then(()=>inner='registered',error=>inner=error.name);+ return {};+ }}}).then(()=>outer='registered',error=>outer=error.name);+ document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool)).then(value=>result=value);+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("inner+'|'+outer+'|'+result")+ .unwrap(),+ "registered|InvalidStateError|inner"+ );+}++#[test]+fn web_mcp_interface_descriptors_inheritance_and_receivers_match_idl() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ let failures = vm.eval(r#"+ const failures=[];+ function check(value,label) {if (!value) failures.push(label);}+ function typeError(callback,label) {+ try {callback();failures.push(label+' did not throw');}+ catch (error) {check(error instanceof TypeError,label+' error type');}+ }+ const model=document.modelContext;+ check(model===document.modelContext,'SameObject');+ check(model instanceof ModelContext && model instanceof EventTarget,'ModelContext inheritance');+ check(Object.getPrototypeOf(ModelContext.prototype)===EventTarget.prototype,'prototype parent');+ check(Object.getPrototypeOf(ModelContext)===EventTarget,'constructor parent');+ check(Object.prototype.toString.call(model)==='[object ModelContext]','object brand');+ typeError(()=>new ModelContext(),'illegal constructor');+ const documentAttribute=Object.getOwnPropertyDescriptor(Document.prototype,'modelContext');+ check(documentAttribute.enumerable && documentAttribute.configurable && !documentAttribute.set,'document attribute');+ typeError(()=>documentAttribute.get.call({}),'document attribute receiver');+ for (const [name,length] of [['registerTool',1],['getTools',0],['executeTool',1]]) {+ const property=Object.getOwnPropertyDescriptor(ModelContext.prototype,name);+ check(property.enumerable && property.configurable && property.writable,name+' descriptor');+ check(property.value.length===length,name+' length');+ }+ for (const name of ['ontoolchange','ontoolactivated','ontoolcancel']) {+ const property=Object.getOwnPropertyDescriptor(ModelContext.prototype,name);+ check(property.enumerable && property.configurable && typeof property.get==='function' && typeof property.set==='function',name+' descriptor');+ check(model[name]===null,name+' default');+ typeError(()=>property.get.call({}),name+' receiver');+ }+ for (const constructor of [ToolActivatedEvent,ToolCancelEvent]) {+ const event=new constructor('test',{toolName:'echo'});+ check(event instanceof Event && event.toolName==='echo',constructor.name+' event');+ check(Object.getPrototypeOf(constructor.prototype)===Event.prototype,constructor.name+' prototype parent');+ const property=Object.getOwnPropertyDescriptor(constructor.prototype,'toolName');+ check(property.enumerable && property.configurable && !property.set,constructor.name+' readonly attribute');+ typeError(()=>property.get.call({}),constructor.name+' receiver');+ }+ JSON.stringify(failures);+ "#).unwrap();+ assert_eq!(failures, "[]", "IDL contract failures: {failures}");+}++#[test]+fn web_mcp_get_tools_omits_schemas_that_serialize_to_json_primitives() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.result='pending';+ Promise.all([null,3,true,'text',[],{}].map((value,index)=>+ document.modelContext.registerTool({name:'tool_'+index,description:'JSON schema',inputSchema:{toJSON:()=>value},execute:()=>42})+ )).then(()=>document.modelContext.getTools()).then(tools=>{+ result=tools.map(tool=>tool.name).join('|')+'|'+Array.isArray(tools[0].inputSchema);+ });+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("result").unwrap(),+ "tool_4|tool_5|true"+ );+ // Filtering discovery must not delete the actual registration.+ vm.eval(r#"document.modelContext.executeTool({name:'tool_0',description:'JSON schema',window,origin:location.origin}).then(value=>result=value,error=>result=error.name)"#).unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "42");+}++#[test]+fn web_mcp_execution_rejects_inputs_that_serialize_to_json_primitives() {+ for (value, accepted) in [+ ("null", false),+ ("42", false),+ ("true", false),+ ("'text'", false),+ ("[]", true),+ ("{}", true),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(+ r#"+ globalThis.calls = 0;+ globalThis.activations = 0;+ globalThis.probe = 'pending';+ document.modelContext.addEventListener('toolactivated', () => activations++);+ document.modelContext.registerTool({{+ name: 'echo', description: 'Echo', execute: input => {{ calls++; return input; }}+ }})+ .then(() => document.modelContext.getTools())+ .then(([tool]) => document.modelContext.executeTool(tool, {{toJSON: () => ({value})}}))+ .then(result => probe = result, error => probe = error.name);+ "#+ ))+ .unwrap();+ let result = vm+ .eval_after_selected_page_tasks("JSON.stringify({probe, calls, activations})")+ .unwrap();+ let result: serde_json::Value = serde_json::from_str(&result).unwrap();+ let expected = if accepted {+ serde_json::json!({"probe": value, "calls": 1, "activations": 1})+ } else {+ serde_json::json!({"probe": "UnknownError", "calls": 0, "activations": 1})+ };+ assert_eq!(result, expected, "toJSON returned {value}");+ }+}++#[test]+fn web_mcp_execution_does_not_activate_tools_that_fail_before_input_validation() {+ for (tool_window, invocation, error) in [+ (+ "window",+ "document.modelContext.executeTool(tool, 42)",+ "TypeError",+ ),+ (+ "window",+ "document.modelContext.executeTool(tool, {toJSON() {throw new Error('serialization failed')}})",+ "Error",+ ),+ (+ "frame.contentWindow",+ "document.modelContext.executeTool(tool, {toJSON() {frame.remove(); return null}})",+ "InvalidStateError",+ ),+ (+ "window",+ "(() => {const pending = document.modelContext.executeTool(tool, {toJSON: () => null}); registration.abort(); return pending})()",+ "UnknownError",+ ),+ (+ "window",+ "(() => {const pending = document.modelContext.executeTool(tool, {toJSON: () => null}); frame.remove(); return pending})()",+ "UnknownError",+ ),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(+ r#"+ globalThis.frame = document.createElement('iframe');+ document.body.append(frame);+ globalThis.calls = 0;+ globalThis.activations = 0;+ globalThis.probe = 'pending';+ globalThis.registration = new AbortController();+ const context = {tool_window}.document.modelContext;+ context.addEventListener('toolactivated', () => activations++);+ const execute = frame.contentWindow.eval('input => {{parent.calls++; return input}}');+ context.registerTool({{name: 'echo', description: 'Echo', execute}}, {{signal: registration.signal}})+ .then(() => document.modelContext.getTools())+ .then(([tool]) => {invocation})+ .then(result => probe = result, error => probe = error.name);+ "#+ ))+ .unwrap();+ let result = vm+ .eval_after_selected_page_tasks("JSON.stringify({probe, calls, activations})")+ .unwrap();+ let result: serde_json::Value = serde_json::from_str(&result).unwrap();+ assert_eq!(+ result,+ serde_json::json!({"probe": error, "calls": 0, "activations": 0}),+ "{invocation} targeting {tool_window}"+ );+ }+}++#[test]+fn web_mcp_execution_creates_input_and_options_in_the_callback_realm() {+ for (callback_window, tool_window) in [+ ("frame.contentWindow", "parent"),+ ("window", "parent.frame.contentWindow"),+ ] {+ for callback in ["execute", "execute.bind(null)", "new Proxy(execute, {})"] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(+ r#"+ globalThis.frame = document.createElement('iframe');+ document.body.append(frame);+ globalThis.probe = 'pending';+ const execute = {callback_window}.eval(`(() => {{+ const execute = (input, options) => {{+ const nested = Array.isArray(input) ? input[0] : input.nested;+ const array = Array.isArray(input) ? input[1] : input.items;+ return {{+ root: Object.getPrototypeOf(input) === (Array.isArray(input) ? Array.prototype : Object.prototype),+ nested: Object.getPrototypeOf(nested) === Object.prototype,+ array: Object.getPrototypeOf(array) === Array.prototype,+ element: Object.getPrototypeOf(array[0]) === Object.prototype,+ options: Object.getPrototypeOf(options) === Object.prototype,+ signal: options.signal instanceof {tool_window}.AbortSignal+ }};+ }};+ return {callback};+ }})()`);+ {tool_window}.document.modelContext.registerTool({{+ name: 'realm', description: 'Cross-realm arguments', execute+ }})+ .then(() => document.modelContext.getTools())+ .then(([tool]) => Promise.all([+ {{nested: {{value: 42}}, items: [{{value: 42}}]}},+ [{{value: 42}}, [{{value: 42}}]]+ ].map(input => document.modelContext.executeTool(tool, input))))+ .then(results => probe = results.join('|'), error => probe = error.name);+ "#+ ))+ .unwrap();+ let expected = r#"{"root":true,"nested":true,"array":true,"element":true,"options":true,"signal":true}"#;+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ format!("{expected}|{expected}"),+ "callback {callback} in {callback_window}, tool in {tool_window}"+ );+ }+ }+}++#[test]+fn web_mcp_execution_checks_origin_and_preaborted_signal_before_lookup() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.probe=[];+ globalThis.serialized=0;+ const reason={aborted:true};+ const signal=AbortSignal.abort(reason);+ const input={toJSON(){serialized++;throw new Error('must not serialize invalid origins')}};+ const tool={name:'missing',description:'Missing',window,origin:location.origin};+ document.modelContext.executeTool({...tool,origin:'invalid'},input).catch(error=>probe.push(error.name));+ document.modelContext.executeTool({...tool,origin:'data:text/plain,opaque'},input).catch(error=>probe.push(error.name));+ document.modelContext.executeTool(tool,{}, {signal}).catch(error=>probe.push(error===reason));+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')+'|'+serialized")+ .unwrap(),+ "NotSupportedError|NotSupportedError|true|0"+ );+}++#[test]+fn web_mcp_registration_rechecks_document_after_schema_serialization() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.result='pending';+ document.modelContext.registerTool({name:'fresh',description:'Fresh document',execute:()=>42,inputSchema:{toJSON(){+ document.open();document.write('<!doctype html><body>replacement');document.close();return {type:'object'};+ }}}).then(()=>document.modelContext.getTools()).then(([tool])=>document.modelContext.executeTool(tool)).then(value=>result=value,error=>result=error.name);+ "#).unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "42");+}++#[test]+fn web_mcp_execution_rechecks_caller_detached_during_input_serialization() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.frame=document.createElement('iframe');document.body.append(frame);+ globalThis.calls=0;+ globalThis.result='pending';+ const context=frame.contentDocument.modelContext;+ document.modelContext.registerTool({name:'echo',description:'Echo',execute:()=>{calls++;return 42}})+ .then(()=>context.executeTool({name:'echo',description:'Echo',window,origin:location.origin},{toJSON(){frame.remove();return {}}}))+ .then(value=>result=value,error=>result=error.name);+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("result+'|'+calls")+ .unwrap(),+ "InvalidStateError|0"+ );+}++#[test]+fn web_mcp_root_devtools_cannot_invoke_tools_from_a_popup_frame_tree() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.popup = window.open('about:blank');+ globalThis.registration = 'pending';+ popup.document.modelContext.registerTool({name:'popup_only',description:'Popup tool',execute:()=>42})+ .then(()=>registration='registered',error=>registration=error.name);+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("registration").unwrap(),+ "registered"+ );+ vm.dispatch_web_mcp_command(+ moli_page_types::DevToolsSessionKey::from_wire_session_id(None),+ moli_page_types::RendererWebMcpCommand::Enable,+ )+ .unwrap()+ .unwrap();+ let result = vm+ .dispatch_web_mcp_command(+ moli_page_types::DevToolsSessionKey::from_wire_session_id(None),+ moli_page_types::RendererWebMcpCommand::InvokeTool {+ frame_id: None,+ name: "popup_only".into(),+ input: "{}".into(),+ },+ )+ .unwrap();+ assert_eq!(+ result,+ Err(moli_page_types::RendererWebMcpError::InvalidParams(+ "Tool not found"+ ))+ );+}++#[test]+fn web_mcp_is_exposed_only_in_secure_window_contexts() {+ for (url, expected) in [+ ("https://tools.test/", "true"),+ ("http://tools.test/", "false"),+ ("http://localhost/", "true"),+ ] {+ let mut vm = new_storage_test_vm(url);+ assert_eq!(vm.eval("'modelContext' in Document.prototype && typeof ModelContext === 'function' && typeof ToolActivatedEvent === 'function' && typeof ToolCancelEvent === 'function'").unwrap(), expected);+ }+}++#[test]+fn web_mcp_rejects_argument_exceptions_without_a_synchronous_throw() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(+ r#"+ globalThis.probe = [];+ const reason = new Error('getter failed');+ document.modelContext.registerTool({ get description() { throw reason; } })+ .catch(e => probe.push(e === reason));+ ModelContext.prototype.getTools.call({}).catch(e => probe.push(e instanceof TypeError));+ document.modelContext.getTools({fromOrigins: ['http://untrusted.test']})+ .catch(e => probe.push(e.name === 'SecurityError'));+ document.modelContext.getTools({fromOrigins: ['not a URL']})+ .catch(e => probe.push(e.name === 'SecurityError'));+ "#,+ )+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')")+ .unwrap(),+ "true|true|true|true"+ );+}++#[test]+fn web_mcp_browser_tasks_cannot_be_canceled_with_js_timer_handles() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.probe = 'pending';+ document.modelContext.registerTool({name: 'echo', description: 'echo', execute: input => input})+ .then(() => document.modelContext.getTools())+ .then(([tool]) => document.modelContext.executeTool(tool, {value: 42}))+ .then(result => probe = result);+ for (let id = 1; id < 32; id++) clearTimeout(id);+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ r#"{"value":42}"#+ );+}++#[test]+fn web_mcp_browser_tasks_ignore_indexed_prototype_accessors() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.probe = 'pending';+ globalThis.interceptions = 0;+ for (let index = 0; index < 3; index++) {+ Object.defineProperty(Array.prototype, index, {+ configurable: true,+ get() { interceptions++; throw new Error('indexed getter'); },+ set() { interceptions++; throw new Error('indexed setter'); }+ });+ }+ const controller = new AbortController();+ document.modelContext.registerTool({name: 'echo', description: 'echo', execute: input => input}, {signal: controller.signal})+ .then(() => document.modelContext.getTools())+ .then(([tool]) => document.modelContext.executeTool(tool, {value: 42}))+ .then(result => { probe = result; controller.abort(); return document.modelContext.getTools(); })+ .then(tools => probe += '|' + tools.length + '|' + interceptions);+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ r#"{"value":42}|0|0"#+ );+}++#[test]+fn web_mcp_document_open_retires_old_tools_and_reuses_the_model_context() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.oldContext = document.modelContext;+ globalThis.oldController = new AbortController();+ document.modelContext.registerTool({name: 'echo', description: 'old', execute: () => 'old'}, {signal: oldController.signal});+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(+ r#"+ document.open(); document.write('<!doctype html><body>new</body>'); document.close();+ globalThis.probe = [];+ probe.push(oldContext === document.modelContext);+ document.modelContext.getTools().then(tools => probe.push(tools.length === 0));+ document.modelContext.registerTool({name: 'echo', description: 'new', execute: () => 'new'})+ .then(() => { oldController.abort(); return document.modelContext.getTools(); })+ .then(([tool]) => document.modelContext.executeTool(tool))+ .then(result => probe.push(result === 'new'));+ "#,+ )+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')")+ .unwrap(),+ "true|true|true"+ );+}++#[test]+fn web_mcp_about_blank_tools_inherit_origin_and_execute_in_the_child_realm() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.frame = document.createElement('iframe');+ document.body.append(frame);+ frame.contentWindow.eval(`document.modelContext.registerTool({+ name: 'child', description: 'child realm',+ execute: (input, {signal}) => ({value: input.value, correctRealm: signal instanceof AbortSignal})+ })`);+ globalThis.probe = 'pending';+ document.modelContext.getTools()+ .then(([tool]) => document.modelContext.executeTool(tool, {value: 42}))+ .then(result => probe = result);+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ r#"{"value":42,"correctRealm":true}"#+ );+}++#[test]+fn web_mcp_detached_child_rejects_pending_execution_and_aborts_its_signal() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(+ r#"+ globalThis.frame = document.createElement('iframe');+ document.body.append(frame);+ frame.contentWindow.eval(`document.modelContext.registerTool({+ name: 'wait', description: 'pending child', execute: (input, {signal}) => {+ parent.savedSignal = signal;+ return new Promise(() => {});+ }+ })`);+ globalThis.probe = [];+ globalThis.childContext = frame.contentDocument.modelContext;+ globalThis.retainedWindow = frame.contentWindow;+ retainedWindow.sentinel = 42;+ document.modelContext.getTools()+ .then(([tool]) => document.modelContext.executeTool(tool))+ .catch(error => probe.push(error.name));+ "#,+ )+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("savedSignal.aborted")+ .unwrap(),+ "false"+ );+ vm.eval(+ r#"+ frame.remove();+ document.modelContext.getTools().then(tools => probe.push(tools.length === 0));+ childContext.getTools().catch(error => probe.push(error.name));+ "#,+ )+ .unwrap();+ assert_eq!(vm.eval("retainedWindow.sentinel").unwrap(), "42");+ let result = vm+ .eval_after_selected_page_tasks("JSON.stringify({probe, aborted: savedSignal.aborted})")+ .unwrap();+ let result: serde_json::Value = serde_json::from_str(&result).unwrap();+ assert_eq!(result["aborted"], true, "{result}");+ let probe = result["probe"].as_array().unwrap();+ assert_eq!(probe.len(), 3, "{result}");+ assert!(+ probe.contains(&serde_json::json!("UnknownError")),+ "{result}"+ );+ assert!(+ probe.contains(&serde_json::json!("InvalidStateError")),+ "{result}"+ );+ assert!(probe.contains(&serde_json::json!(true)), "{result}");+}++#[test]+fn web_mcp_document_open_rejects_unacknowledged_registration() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(+ r#"+ globalThis.probe = [];+ document.modelContext.registerTool({name: 'echo', description: 'old', execute: () => 'old'})+ .then(() => probe.push('old accepted'), error => probe.push(error.name));+ document.open(); document.write('<!doctype html><body>new</body>'); document.close();+ document.modelContext.registerTool({name: 'echo', description: 'new', execute: () => 'new'})+ .then(() => probe.push('new accepted'));+ "#,+ )+ .unwrap();+ let result = vm+ .eval_after_selected_page_tasks("probe.sort().join('|')")+ .unwrap();+ assert_eq!(result, "AbortError|new accepted");+}++#[test]+fn web_mcp_document_open_rejects_started_execution_and_ignores_late_result() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.probe = [];+ document.modelContext.registerTool({name: 'wait', description: 'old', execute: (input, {signal}) => {+ globalThis.savedSignal = signal;+ return new Promise(resolve => signal.addEventListener('abort', () => resolve('late')));+ }}).then(() => document.modelContext.getTools())+ .then(([tool]) => document.modelContext.executeTool(tool))+ .then(result => probe.push(result), error => probe.push(error.name));+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("savedSignal.aborted")+ .unwrap(),+ "false"+ );+ vm.eval(+ "document.open(); document.write('<!doctype html><body>new</body>'); document.close();",+ )+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|') + '|' + savedSignal.aborted")+ .unwrap(),+ "UnknownError|true"+ );+}diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/declarative.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/declarative.rsnew file mode 100644index 000000000..28f966e7b--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/declarative.rs@@ -0,0 +1,472 @@+//! Declarative tool regressions and Chromium form schema cases.++use super::*;++#[test]+fn web_mcp_declarative_fills_current_choices_after_earlier_field_events() {+ for (control, input, mutation, expected) in [+ (+ "<select name=choice><option value=a>A</option><option value=b>B</option></select>",+ "'b'",+ "form.elements.choice.innerHTML='<option value=a>A</option><option value=b>B</option>'",+ r#"{"selected":["b"],"events":["input","change"]}"#,+ ),+ (+ "<select name=choice multiple><option value=a>A</option><option value=b>B</option></select>",+ "['b']",+ "form.elements.choice.innerHTML='<option value=a>A</option><option value=b>B</option>'",+ r#"{"selected":["b"],"events":["input","change"]}"#,+ ),+ (+ "<input name=choice type=checkbox value=a><input name=choice type=checkbox value=b>",+ "['b']",+ "form.elements.choice[1].value='c'",+ r#"{"selected":[],"events":["change","change"]}"#,+ ),+ (+ "<input name=choice type=radio value=a checked><input name=choice type=radio value=b>",+ "'b'",+ "form.elements.choice[1].value='c'",+ r#"{"selected":["a"],"events":[]}"#,+ ),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(r#"+ document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=trigger>{control}</form>';+ globalThis.form=document.querySelector('form');+ globalThis.probe='pending';+ const events=[];+ form.elements.trigger.addEventListener('input', () => {{{mutation}}});+ for (const type of ['input','change']) form.addEventListener(type, event => {{+ if (event.target.name==='choice') events.push(type);+ }});+ form.addEventListener('submit', event => {{+ event.preventDefault();+ const controls=Array.from(form.elements).filter(control=>control.name==='choice');+ const selected=controls[0].tagName==='SELECT'+ ? Array.from(controls[0].selectedOptions, option=>option.value)+ : controls.filter(control=>control.checked).map(control=>control.value);+ event.respondWith({{selected,events}});+ }});+ "#)).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(&format!("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{trigger:'changed',choice:{input}}})).then(value=>probe=value,error=>probe=error.name)")).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ expected,+ "{control}"+ );+ }+}++#[test]+fn web_mcp_declarative_rejects_invalid_tool_names_on_discovery_and_mutation() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ for (const name of ['valid','', 'bad name','non_ascii_😀','x'.repeat(129)]) {+ const form=document.createElement('form');form.setAttribute('toolname',name);form.setAttribute('tooldescription','Tool');document.body.append(form);+ }+ globalThis.result='pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(+ "document.modelContext.getTools().then(tools=>result=tools.map(tool=>tool.name).join('|'))",+ )+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("result").unwrap(),+ "valid"+ );+ vm.eval("document.querySelector('form').setAttribute('toolname','invalid name')")+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(tools=>result=tools.length)")+ .unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "0");+}++#[test]+fn web_mcp_declarative_numeric_schema_uses_effective_bounds_and_decimal_steps() {+ for (attributes, expected) in [+ (+ "type=number min=0.3 step=0.1",+ serde_json::json!({"type":"number","minimum":0.3,"multipleOf":0.1}),+ ),+ (+ "type=range min=200 max=10",+ serde_json::json!({"type":"number","minimum":200,"maximum":200,"multipleOf":1}),+ ),+ (+ "type=range value=0.5",+ serde_json::json!({"type":"number","minimum":0,"maximum":100}),+ ),+ ("type=number step=AnY", serde_json::json!({"type":"number"})),+ (+ "type=range step=AnY",+ serde_json::json!({"type":"number","minimum":0,"maximum":100}),+ ),+ (+ "type=number min=+2 max=+3 step=+0.1",+ serde_json::json!({"type":"number","multipleOf":1}),+ ),+ (+ "type=number min=0.0000000001 step=1",+ serde_json::json!({"type":"number","minimum":0.0000000001}),+ ),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!("document.body.innerHTML='<form toolname=schema tooldescription=Schema><input name=value {attributes}></form>';globalThis.result=null;")).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(([tool])=>result=tool.inputSchema.properties.value)").unwrap();+ let actual = vm+ .eval_after_selected_page_tasks("JSON.stringify(result)")+ .unwrap();+ assert_eq!(+ serde_json::from_str::<serde_json::Value>(&actual).unwrap(),+ expected,+ "{attributes}"+ );+ }+}++#[test]+fn web_mcp_declarative_unchanged_values_do_not_dispatch_input_events() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=text value=original><textarea name=area>original</textarea><input name=check type=checkbox checked><input name=radio type=radio value=on checked><select name=choice><option value=a selected>A</option><option value=b>B</option></select><input name=number type=number value=2></form>';+ const form=document.querySelector('form');const events=[];+ for (const type of ['input','change']) form.addEventListener(type,event=>events.push(event.target.name+':'+type));+ form.addEventListener('submit',event=>{event.preventDefault();event.respondWith(events)});+ globalThis.result='pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'original',area:'original',check:true,radio:'on',choice:'a',number:2})).then(value=>result=value,error=>result=error.name)"#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("result").unwrap(),+ r#"["check:change","radio:change"]"#+ );+}++#[test]+fn web_mcp_declarative_numeric_conversion_matches_chromium_json_values() {+ // The fractional cases are from Blink's DtoaTest.ToFixedPrecisionString;+ // JSONBasicValue uses int32 for whole values in that range, double otherwise.+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=value><input name=checked type=checkbox></form>';+ globalThis.form=document.querySelector('form');+ form.addEventListener('submit',event=>{event.preventDefault();event.respondWith(form.elements.value.value)});+ globalThis.result='pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ for (input, expected) in [+ ("0.00000123123123", "0.00000123123"),+ ("0.000000123123123", "1.23123e-7"),+ ("123123.123", "123123"),+ ("1231231.23", "1.23123e+6"),+ ("1e-10", "1.00000e-10"),+ ("0.001953125", "0.00195313"),+ ("2147483647", "2147483647"),+ ("5000000000", "5.00000e+9"),+ ] {+ vm.eval(&format!("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{value:{input}}})).then(value=>result=value,error=>result=error.name)")).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("result").unwrap(),+ expected,+ "{input}"+ );+ }+ for input in ["2147483648", "-2147483649", "0.5"] {+ vm.eval(&format!("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{value:'changed',checked:{input}}})).then(value=>result=value,error=>result=error.name)")).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("result+'|'+form.elements.value.value")+ .unwrap(),+ "UnknownError|5.00000e+9",+ "{input}"+ );+ }+}++#[test]+fn web_mcp_declarative_document_open_discards_stale_registration_tasks() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(+ r#"document.body.innerHTML = '<form toolname="old" tooldescription="Old form"></form>'"#,+ )+ .unwrap();+ // Replace the document before its initial form registration task runs.+ vm.eval(r#"+ document.open();+ document.write('<!doctype html><body><form toolname="new" tooldescription="New form" toolautosubmit></form>');+ document.close();+ globalThis.result = 'pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"document.modelContext.getTools().then(tools => result = tools.map(tool => tool.name).join('|'))"#).unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "new");+}++#[test]+fn web_mcp_declarative_fills_controls_and_responds_in_the_form_realm() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.frame = document.createElement('iframe');+ document.body.append(frame);+ frame.contentWindow.eval(`+ document.body.innerHTML = '<form toolname="fill" tooldescription="Fill controls" toolautosubmit><input name="text"><input name="number" type="number"><input name="checked" type="checkbox"><select name="selected"><option>a</option><option>b</option></select><textarea name="area"></textarea></form>';+ const form = document.querySelector('form');+ const events = [];+ for (const type of ['input','change']) form.addEventListener(type,e=>events.push(e.target.name+':'+type));+ form.addEventListener('submit',e=>{+ e.preventDefault();+ e.respondWith(Promise.resolve({agent:e.agentInvoked,realm:e instanceof SubmitEvent,+ text:form.elements.text.value,number:form.elements.number.value,+ checked:form.elements.checked.checked,selected:form.elements.selected.value,+ area:form.elements.area.value,events}));+ });+ `);+ globalThis.result = 'pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,+ {text:'hello',number:42,checked:true,selected:'b',area:'world'})).then(value=>result=value,e=>result=e.name)"#).unwrap();+ let result = vm.eval_after_selected_page_tasks("result").unwrap();+ let result: serde_json::Value = serde_json::from_str(&result).unwrap();+ assert_eq!(result["agent"], true);+ assert_eq!(result["realm"], true);+ assert_eq!(result["text"], "hello");+ assert_eq!(result["number"], "42");+ assert_eq!(result["checked"], true);+ assert_eq!(result["selected"], "b");+ assert_eq!(result["area"], "world");+ assert_eq!(result["events"].as_array().unwrap().len(), 10);+}++#[test]+fn web_mcp_declarative_uses_native_range_bounds_and_text_sanitization() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=amount type=range min=100 max=200 step=10 value=150><input name=text><textarea name=area></textarea></form>';+ const form=document.querySelector('form');+ form.addEventListener('submit',event=>{+ event.preventDefault();event.respondWith({amount:Number(form.elements.amount.value),text:form.elements.text.value,area:form.elements.area.value});+ });+ globalThis.result='pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{amount:180,text:'x\ny',area:'a\r\nb\rc'})).then(value=>result=value,error=>result=error.name)"#).unwrap();+ let result = vm.eval_after_selected_page_tasks("result").unwrap();+ assert_eq!(+ serde_json::from_str::<serde_json::Value>(&result).unwrap(),+ serde_json::json!({"amount":180,"text":"xy","area":"a\nb\nc"})+ );+}++#[test]+fn web_mcp_declarative_rejects_sanitized_empty_values_before_filling() {+ // Chromium's ValidateTextData/ValidateNumberData check the native input+ // sanitizer before applying any of the supplied parameters.+ for (kind, initial, invalid) in [+ ("text", "original", "\r\n"),+ ("search", "original", "\n"),+ ("password", "original", "\r"),+ ("tel", "original", "\n"),+ ("url", "https://tools.test/", " \t\n"),+ ("email", "[email protected]", " \t\n"),+ ("number", "12", "not a number"),+ ("date", "2024-02-29", "2025-02-29"),+ ("datetime-local", "2024-02-29T12:30", "2024-02-29T25:00"),+ ("month", "2024-02", "2024-13"),+ ("week", "2024-W01", "2024-W00"),+ ("time", "12:30", "25:00"),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(+ r#"+ document.body.innerHTML='<form toolname=atomic tooldescription=Atomic toolautosubmit><input name=first value=original><input name=typed type={kind} value="{initial}"></form>';+ globalThis.form=document.querySelector('form');+ globalThis.events=[];+ for (const type of ['input','change','submit']) form.addEventListener(type,event=>{{+ events.push(type);+ if (type==='submit') {{event.preventDefault();event.respondWith('submitted');}}+ }});+ globalThis.result='pending';+ "#+ ))+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(&format!(+ r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{first:'changed',typed:{}}})).then(value=>result=value,error=>result=error.name)"#,+ serde_json::to_string(invalid).unwrap()+ ))+ .unwrap();+ let result = vm+ .eval_after_selected_page_tasks(+ "JSON.stringify([result,form.elements.first.value,form.elements.typed.value,events])",+ )+ .unwrap();+ assert_eq!(+ serde_json::from_str::<serde_json::Value>(&result).unwrap(),+ serde_json::json!(["UnknownError", "original", initial, []]),+ "input type={kind}"+ );+ }+}++#[test]+fn web_mcp_declarative_range_accepts_nonempty_values_using_native_sanitization() {+ for value in [serde_json::json!("invalid"), serde_json::json!(true)] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><input name=text value=original><input name=amount type=range min=100 max=200 step=10 value=100></form>';+ globalThis.form=document.querySelector('form');+ form.addEventListener('submit',event=>{event.preventDefault();event.respondWith(form.elements.amount.value)});+ globalThis.result='pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(&format!(+ r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{{amount:{value}}})).then(value=>result=value,error=>result=error.name)"#+ )).unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("result").unwrap(), "150");+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'changed',amount:''})).then(value=>result=value,error=>result=error.name)"#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks(+ "result+'|'+form.elements.text.value+'|'+form.elements.amount.value"+ )+ .unwrap(),+ "UnknownError|original|150"+ );+ }+}++#[test]+fn web_mcp_declarative_select_uses_native_option_values_and_first_duplicate() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML='<form toolname=fill tooldescription=Fill toolautosubmit><select name=single><option value=dup>first</option><option value=dup selected>second</option><option value=empty></option><option> a\n \t b </option></select><select name=multiple multiple><option value=dup>first</option><option value=dup>second</option></select></form>';+ globalThis.form=document.querySelector('form');+ globalThis.schema=null;+ globalThis.result='pending';+ form.addEventListener('submit',event=>{event.preventDefault();event.respondWith({index:form.elements.single.selectedIndex,multiple:Array.from(form.elements.multiple.options,option=>option.selected)})});+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>{schema=tool.inputSchema;return document.modelContext.executeTool(tool,{single:'dup',multiple:['dup']})}).then(value=>result=value,error=>result=error.name)"#).unwrap();+ let result = vm.eval_after_selected_page_tasks("result").unwrap();+ assert_eq!(+ serde_json::from_str::<serde_json::Value>(&result).unwrap(),+ serde_json::json!({"index":0,"multiple":[true,true]})+ );+ let schema: serde_json::Value =+ serde_json::from_str(&vm.eval("JSON.stringify(schema)").unwrap()).unwrap();+ assert_eq!(+ schema["properties"]["single"]["enum"],+ serde_json::json!(["dup", "dup", "empty", "a b"])+ );+ assert_eq!(schema["properties"]["single"]["anyOf"][2]["title"], "");+ assert_eq!(+ schema["properties"]["single"]["anyOf"][3]["title"],+ " a\n \t b "+ );+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{single:'a b'})).then(value=>result=value,error=>result=error.name)"#).unwrap();+ let result = vm.eval_after_selected_page_tasks("result").unwrap();+ assert_eq!(+ serde_json::from_str::<serde_json::Value>(&result).unwrap()["index"],+ 3+ );+}++#[test]+fn web_mcp_declarative_manual_confirmation_reset_and_response_guards() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML = '<form toolname="confirm" tooldescription="Confirmation"><input name="query"><button>Submit</button></form>';+ globalThis.form = document.querySelector('form');+ globalThis.probe = [];+ form.addEventListener('submit',e=>{+ probe.push(e.agentInvoked);+ try {e.respondWith('before prevention')} catch(error) {probe.push(error.name)}+ e.preventDefault();+ if (e.agentInvoked) {e.respondWith('confirmed');globalThis.savedEvent=e;}+ });+ form.requestSubmit();+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{query:'hello'})).then(value=>probe.push(value));"#).unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("form.querySelector('input').value+'|'+(document.activeElement===form.querySelector('button'))").unwrap(),"hello|true");+ vm.eval("form.querySelector('button').click()").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"+ try {savedEvent.respondWith('late')} catch(error) {probe.push(error.name)}+ document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{query:'reset'})).catch(error=>probe.push(error.name));+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("form.reset()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')")+ .unwrap(),+ "false|InvalidStateError|true|InvalidStateError|confirmed|InvalidStateError|UnknownError"+ );+}++#[test]+fn web_mcp_declarative_validates_all_arguments_before_mutation_and_preserves_response_after_unregister()+ {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML = '<form toolname="atomic" tooldescription="Atomic fill" toolautosubmit><input name="text" value="original"><select name="choice"><option>a</option></select></form>';+ globalThis.form = document.querySelector('form');+ globalThis.probe = [];+ form.addEventListener('submit',e=>{e.preventDefault();e.respondWith(new Promise(resolve=>globalThis.finish=resolve))});+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'changed',choice:'invalid'})).catch(error=>probe.push(error.name));"#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')+'|'+form.elements.text.value")+ .unwrap(),+ "UnknownError|original"+ );+ vm.eval(r#"document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{text:'changed'})).then(()=>probe.push('late'),error=>probe.push(error.name));"#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("form.remove()").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("finish('late result')").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')")+ .unwrap(),+ "UnknownError|late"+ );+}++#[test]+fn web_mcp_chromium_form_schema_cases() {+ let fixtures: serde_json::Value = serde_json::from_str(include_str!(concat!(+ env!("CARGO_MANIFEST_DIR"),+ "/../moli-wpt-compat/fixtures/wpt/upstream/webmcp/declarative/chromium-form-schema-cases.json"+ ))).unwrap();+ let mut failures = Vec::new();+ for case in fixtures["cases"].as_array().unwrap() {+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();+ let mut vm = new_parsed_page_task_executor_test_vm(+ "https://tools.test/",+ case["html"].as_str().unwrap(),+ &loader,+ );+ vm.eval("undefined").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("globalThis.schema = null; document.modelContext.getTools().then(tools => schema = JSON.stringify(tools[0].inputSchema))").unwrap();+ let actual = vm.eval_after_selected_page_tasks("schema").unwrap();+ let expected = vm+ .eval(&format!(+ "JSON.stringify(JSON.parse({}))",+ serde_json::to_string(&case["expected_json"]).unwrap()+ ))+ .unwrap();+ if actual != expected {+ failures.push(format!(+ "{}\nactual: {actual}\nexpected: {expected}",+ case["name"]+ ));+ }+ }+ assert!(failures.is_empty(), "{}", failures.join("\n"));+}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.rsnew file mode 100644index 000000000..dfe80e3dd--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/discovery.rs@@ -0,0 +1,126 @@+use super::*;++#[test]+fn web_mcp_declarative_candidates_retry_registration_when_their_controls_change() {+ for mode in ["light", "open", "closed"] {+ for (markup, mutation) in [+ (+ "",+ "const input=document.createElement('input'); input.name='query'; form.appendChild(input)",+ ),+ (+ "<div></div>",+ "const input=document.createElement('input'); input.name='query'; form.firstChild.appendChild(input)",+ ),+ (+ "<div><input name=discard><input name=query></div>",+ "form.elements.discard.remove()",+ ),+ ("<input name=old>", "form.elements.old.name='query'"),+ (+ "",+ "const input=document.createElement('input'); input.name='query'; input.setAttribute('form',form.id); root.appendChild(input)",+ ),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(+ r#"+ globalThis.mc=document.modelContext;+ globalThis.controller=new AbortController();+ globalThis.probe='pending';+ mc.registerTool({name:'retry',description:'Imperative',execute:()=> 'imperative'},+ {signal:controller.signal}).then(()=>probe='registered');+ "#,+ )+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "registered"+ );+ vm.eval(&format!(+ r#"+ globalThis.root=document.body;+ if ('{mode}' !== 'light') {{+ const host=document.body.appendChild(document.createElement('div'));+ root=host.attachShadow({{mode:'{mode}'}});+ }}+ globalThis.form=document.createElement('form');+ form.id='candidate';+ form.setAttribute('toolname','retry');+ form.setAttribute('tooldescription','Declarative');+ form.setAttribute('toolautosubmit','');+ form.innerHTML='{markup}';+ form.addEventListener('submit',event=>{{+ event.preventDefault(); event.respondWith(form.elements.query.value);+ }});+ root.appendChild(form);+ "#+ ))+ .unwrap();+ // 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();+ vm.eval("mc.getTools().then(tools=>probe=tools.map(tool=>tool.description).join('|'))")+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "Imperative"+ );+ vm.eval("controller.abort()").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("mc.getTools().then(tools=>probe=JSON.stringify(tools))")+ .unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("probe").unwrap(), "[]");+ // An unrelated insertion must not retry this form's registration.+ vm.eval("document.body.appendChild(document.createElement('section'))")+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("mc.getTools().then(tools=>probe=JSON.stringify(tools))")+ .unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("probe").unwrap(), "[]");++ vm.eval(mutation).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"+ mc.getTools().then(tools=>{+ const tool=tools.find(tool=>tool.name==='retry');+ probe=tool ? tool.description+'|'+Object.keys(tool.inputSchema.properties).sort().join(',') : 'missing';+ });+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "Declarative|query",+ "{mode}: {mutation}"+ );+ vm.eval("mc.getTools().then(([tool])=>mc.executeTool(tool,{query:'filled'})).then(value=>probe=value,error=>probe=error.name)")+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "filled",+ "{mode}: {mutation}"+ );+ }+ }+}++#[test]+fn web_mcp_declarative_discovery_after_unrelated_dom_growth_requires_no_api_access() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.root=document.body.appendChild(document.createElement('section'));+ for (let i=0;i<8000;i++) root.appendChild(document.createElement('div'));+ const detached=document.createElement('section');+ const shadow=detached.attachShadow({mode:'closed'});+ shadow.innerHTML='<form toolname=late tooldescription=Late toolautosubmit><input name=value></form>';+ globalThis.form=shadow.querySelector('form');+ form.addEventListener('submit',event=>{event.preventDefault();event.respondWith(form.elements.value.value)});+ root.appendChild(detached);+ globalThis.probe='pending';+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{value:'filled'})).then(value=>probe=value,error=>probe=error.name)").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "filled"+ );+}diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/review_regressions.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/review_regressions.rsnew file mode 100644index 000000000..de37fb048--- /dev/null+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/web_mcp/review_regressions.rs@@ -0,0 +1,290 @@+//! Regressions for policy, form lifecycle, task delivery and cancellation.+use super::*;++#[test]+fn web_mcp_target_can_complete_before_requested_cancellation_arrives() {+ for (result, expected) in [+ (+ "return {toJSON() {log.push('serialize'); return {ok:true}}}",+ "true|serialize",+ ),+ ("throw new Error('failure')", "true|"),+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(+ r#"+ globalThis.controller = new AbortController();+ globalThis.reason = {{canceled: true}};+ globalThis.probe = 'pending';+ globalThis.log = [];+ const context = document.modelContext;+ context.addEventListener('toolcancel', () => log.push('toolcancel'));+ context.registerTool({{name:'race', description:'Race', execute(_, {{signal}}) {{+ signal.addEventListener('abort', () => log.push('target abort'));+ queueMicrotask(() => controller.abort(reason));+ {result}+ }}}}).then(() => context.getTools())+ .then(([tool]) => context.executeTool(tool, {{}}, {{signal:controller.signal}}))+ .then(() => probe=false, error => probe=error===reason);+ "#+ ))+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe+'|'+log.join(',')")+ .unwrap(),+ expected,+ "{result}"+ );+ }+}++#[test]+fn web_mcp_result_delivery_remains_abortable_until_the_caller_task() {+ for execute in [+ "queueMicrotask(() => queueMicrotask(() => controller.abort(reason))); return 'ok'",+ "queueMicrotask(() => queueMicrotask(() => controller.abort(reason))); throw new Error('failure')",+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(r#"+ globalThis.controller = new AbortController();+ globalThis.reason = {{canceled: true}};+ globalThis.probe = 'pending';+ document.modelContext.registerTool({{name: 'race', description: 'Race', execute() {{{execute}}}}})+ .then(() => document.modelContext.getTools())+ .then(([tool]) => document.modelContext.executeTool(tool, {{}}, {{signal: controller.signal}}))+ .then(value => probe = value, error => probe = error === reason);+ "#)).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "true",+ "{execute}"+ );+ }+}++#[test]+fn web_mcp_missing_tool_and_invalid_input_delivery_remain_abortable() {+ for invocation in [+ "const invocation = context.executeTool({...tool, name: 'missing'}, {}, {signal: controller.signal}); controller.abort(reason); return invocation",+ "context.addEventListener('toolactivated', () => controller.abort(reason), {once: true}); return context.executeTool(tool, {toJSON: () => null}, {signal: controller.signal})",+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(+ r#"+ globalThis.controller = new AbortController();+ globalThis.reason = {{canceled: true}};+ globalThis.probe = 'pending';+ const context = document.modelContext;+ context.registerTool({{name: 'race', description: 'Race', execute: () => 'ok'}})+ .then(() => context.getTools()).then(([tool]) => {{{invocation}}})+ .then(value => probe = value, error => probe = error === reason);+ "#+ ))+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "true",+ "{invocation}"+ );+ }+}++#[test]+fn web_mcp_declarative_invalidation_is_not_undone_by_restoring_the_form() {+ for mutation in [+ "form.remove(); document.body.append(form)",+ "form.removeAttribute('tooldescription'); form.setAttribute('tooldescription', 'Confirm')",+ "other.appendChild(form)",+ "other.insertBefore(form, null)",+ "other.appendChild(original)",+ "other.attachShadow({mode:'open'}).appendChild(form)",+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML = '<section id=original><form toolname=confirm tooldescription=Confirm><input name=value><button>Submit</button></form></section><section id=other></section>';+ globalThis.form = document.querySelector('form');+ globalThis.probe = 'pending';+ globalThis.submissions = [];+ form.addEventListener('submit', event => {submissions.push(event.agentInvoked); event.preventDefault()});+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(([tool]) => document.modelContext.executeTool(tool, {value: 'filled'})).then(value => probe = value, error => probe = error.name)").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("form.matches(':tool-form-active')")+ .unwrap(),+ "true"+ );+ vm.eval(mutation).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe+'|'+form.matches(':tool-form-active')")+ .unwrap(),+ "UnknownError|false",+ "{mutation}"+ );+ vm.eval("form.requestSubmit()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("JSON.stringify(submissions)")+ .unwrap(),+ "[false]"+ );+ }+}++#[test]+fn web_mcp_captured_form_response_survives_removal_and_unrelated_mutations() {+ for mutation in [+ "",+ "document.body.appendChild(document.createElement('div'))",+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(r#"+ document.body.innerHTML='<form toolname=respond tooldescription=Respond toolautosubmit><input name=value></form>';+ globalThis.form=document.querySelector('form');+ globalThis.probe='pending';+ form.addEventListener('submit', event=>{{+ event.preventDefault();+ event.respondWith(Promise.resolve('captured'));+ form.remove();+ }});+ document.modelContext.addEventListener('toolactivated',()=>{{{mutation}}});+ "#)).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(([tool])=>document.modelContext.executeTool(tool,{value:'filled'})).then(value=>probe=value,error=>probe=error.name)").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe+'|'+form.matches(':tool-form-active')")+ .unwrap(),+ "captured|false",+ "{mutation}"+ );+ }+}++#[test]+fn web_mcp_removed_form_releases_its_registration_synchronously() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval("document.body.innerHTML = '<form toolname=replace tooldescription=Replace><input name=value></form>'; globalThis.probe='pending'").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"+ document.querySelector('form').remove();+ document.modelContext.registerTool({name: 'replace', description: 'Replacement', execute: () => 'ok'})+ .then(() => document.modelContext.getTools())+ .then(([tool]) => document.modelContext.executeTool(tool))+ .then(value => probe=value, error => probe=error.name);+ "#).unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("probe").unwrap(), "ok");+}++#[test]+fn web_mcp_discovery_from_toolchange_observes_the_reregistered_form() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval("document.body.innerHTML = '<form toolname=confirm tooldescription=Confirm></form>'; globalThis.form=document.querySelector('form')").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval(r#"+ globalThis.snapshots=[];+ document.modelContext.addEventListener('toolchange', () => {+ document.modelContext.getTools().then(tools => snapshots.push(tools.map(tool => tool.name).join('|')));+ });+ form.remove(); document.body.append(form);+ "#).unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("JSON.stringify(snapshots)")+ .unwrap(),+ "[\"confirm\",\"confirm\"]"+ );+}++#[test]+fn web_mcp_native_forms_in_shadow_trees_are_discovered_and_updated() {+ for mode in ["open", "closed"] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(r#"+ globalThis.host = document.body.appendChild(document.createElement('div'));+ globalThis.shadow = host.attachShadow({{mode: '{mode}'}});+ shadow.innerHTML = '<form toolname=shadow_query tooldescription=Query toolautosubmit><input name=query><button>Submit</button></form>';+ globalThis.form = shadow.querySelector('form');+ form.addEventListener('submit', event => {{event.preventDefault(); event.respondWith(Promise.resolve(form.elements.query.value))}});+ globalThis.probe = 'pending';+ "#)).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(tools => probe=tools.map(tool => tool.name).join('|'))").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "shadow_query",+ "{mode}"+ );+ vm.eval("form.setAttribute('tooldescription', 'Updated')")+ .unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(([tool]) => {probe=tool.description; return document.modelContext.executeTool(tool, {query: 'filled'})}).then(value => probe += '|'+value)").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "Updated|filled",+ "{mode}"+ );+ vm.eval("host.remove()").unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(tools => probe=tools.length)")+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe").unwrap(),+ "0",+ "{mode}"+ );+ }+}++#[test]+fn web_mcp_readonly_applies_only_to_controls_that_support_it() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ document.body.innerHTML = '<form toolname=readonly tooldescription=Readonly toolautosubmit><input name=text readonly><textarea name=area readonly></textarea><select name=choice readonly><option value=a>A</option><option value=b>B</option></select><input name=checked type=checkbox readonly><input name=range type=range readonly></form>';+ globalThis.form = document.querySelector('form');+ globalThis.probe = 'pending';+ form.addEventListener('submit', event => {event.preventDefault(); event.respondWith(Promise.resolve('filled'))});+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("document.modelContext.getTools().then(([tool]) => {probe=Object.keys(tool.inputSchema.properties).sort().join('|'); return document.modelContext.executeTool(tool, {choice: 'b', checked: true, range: 42})}).then(value => probe += '|'+value, error => probe += '|'+error.name)").unwrap();+ assert_eq!(vm.eval_after_selected_page_tasks("probe+'|'+form.elements.choice.value+'|'+form.elements.checked.checked+'|'+form.elements.range.value").unwrap(), "checked|choice|range|filled|b|true|42");+}++#[test]+fn web_mcp_caller_retirement_cancels_the_live_target_with_an_event() {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(r#"+ globalThis.frame=document.createElement('iframe'); document.body.append(frame);+ globalThis.probe=[];+ document.modelContext.addEventListener('toolcancel', event => probe.push(event.toolName));+ document.modelContext.registerTool({name:'wait',description:'Wait',execute(input,{signal}) {signal.addEventListener('abort',()=>probe.push('abort')); return new Promise(()=>{})}})+ .then(()=>frame.contentDocument.modelContext.executeTool({name:'wait',description:'Wait',window,origin:location.origin}));+ "#).unwrap();+ vm.eval_after_selected_page_tasks("undefined").unwrap();+ vm.eval("frame.remove()").unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("probe.join('|')")+ .unwrap(),+ "abort|wait"+ );+}++#[test]+fn web_mcp_toolchange_is_dispatched_for_each_registration() {+ for registration in [+ "Promise.all(['one','two','three'].map(name=>document.modelContext.registerTool({name,description:name,execute:()=>42})))",+ "document.body.innerHTML=['one','two','three'].map(name=>`<form toolname=${name} tooldescription=${name}></form>`).join('')",+ ] {+ let mut vm = new_storage_page_task_executor_test_vm("https://tools.test/");+ vm.eval(&format!(+ r#"+ globalThis.changes=0;+ document.modelContext.addEventListener('toolchange',()=>changes++);+ {registration};+ "#+ ))+ .unwrap();+ assert_eq!(+ vm.eval_after_selected_page_tasks("changes").unwrap(),+ "3",+ "{registration}"+ );+ }+}diff --git a/moli-renderer-v8/src/script_vm/web_mcp.rs b/moli-renderer-v8/src/script_vm/web_mcp.rsnew file mode 100644index 000000000..4ed566635--- /dev/null+++ b/moli-renderer-v8/src/script_vm/web_mcp.rs@@ -0,0 +1,59 @@+use super::ScriptVm;+use moli_page_types::{DevToolsSessionKey, RendererWebMcpCommand, RendererWebMcpError};++impl ScriptVm {+ pub(super) fn queue_declarative_web_mcp(&mut self) {+ {+ let mut host = self._context_host.borrow_mut();+ if !crate::context_bootstrap::web_mcp::prepare_registration_task(&mut host) {+ return;+ }+ }+ let _ = self.with_default_context_scope(|scope, host_ptr| {+ crate::context_bootstrap::web_mcp::queue_registration_task(scope, host_ptr);+ Ok(())+ });+ }+ pub(super) fn queue_retired_web_mcp(&mut self) {+ if !self+ ._context_host+ .borrow()+ .native_bridge()+ .web_mcp+ .needs_retirement_task()+ {+ return;+ }+ let _ = self.with_default_context_scope(|scope, host_ptr| {+ crate::context_bootstrap::web_mcp::queue_retirement_task(scope, host_ptr);+ Ok(())+ });+ }+ pub(super) fn prepare_web_mcp_session(&mut self, session: &DevToolsSessionKey) {+ let inspector = &self.page_inspector;+ self.renderer_document_isolate+ .with_renderer_document_isolate_and_inspector_mut(|_, backend| {+ inspector.ensure_frontend_session(backend, session.wire_session_id());+ });+ self._context_host+ .borrow_mut()+ .native_bridge_mut()+ .web_mcp+ .set_object_wrapper(self.page_inspector.object_wrapper());+ }+ pub(crate) fn dispatch_web_mcp_command(+ &mut self,+ session: DevToolsSessionKey,+ command: RendererWebMcpCommand,+ ) -> anyhow::Result<Result<Option<u64>, RendererWebMcpError>> {+ self.queue_declarative_web_mcp();+ if matches!(command, RendererWebMcpCommand::Enable) {+ self.prepare_web_mcp_session(&session);+ }+ self.with_default_context_scope(|scope, host_ptr| {+ Ok(crate::context_bootstrap::web_mcp::dispatch_command(+ scope, host_ptr, session, command,+ ))+ })+ }+}diff --git a/moli-renderer-v8/src/web_api_interfaces.rs b/moli-renderer-v8/src/web_api_interfaces.rsindex 7c51ca130..6a47c6f59 100644--- a/moli-renderer-v8/src/web_api_interfaces.rs+++ b/moli-renderer-v8/src/web_api_interfaces.rs@@ -310,6 +310,7 @@ interfaces! {MessageChannel;MessageEvent: Event;MessagePort: EventTarget;+ ModelContext: EventTarget;MimeType;MimeTypeArray;MouseEvent: UIEvent;@@ -495,6 +496,8 @@ interfaces! {ToggleEvent: Event;TimeRanges;VideoPlaybackQuality;+ ToolActivatedEvent: Event;+ ToolCancelEvent: Event;Touch;TouchEvent: UIEvent;TouchList;diff --git a/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs b/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rsindex 54ad9ed37..77f91a581 100644--- a/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs+++ b/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs@@ -32,6 +32,9 @@ struct AllowedDirectCallFile {}const RAW_GLOBAL_FUNCTION_ALLOWLIST: &[(&str, usize)] = &[+ // WebMCP retains native registration/invocation abort algorithms here.+ // Page-supplied execute functions use WindowWebIdlCallbackFunction instead.+ ("context_bootstrap/web_mcp/state.rs", 1),("custom_elements/construction.rs", 1),("custom_elements/definition.rs", 10),("custom_elements/definition_callbacks.rs", 1),@@ -71,6 +74,14 @@ const DIRECT_V8_CALL_ALLOWLIST: &[AllowedDirectCallFile] = &[1,DirectCallOwner::TypedWebIdlAdapter,),+ // The typed Window callback adapter checks exact Realm currentness and+ // enters the Web IDL relevant/incumbent contexts before normalizing the+ // Promise-returning execute callback. It owns no raw author-function root.+ allowed(+ "context_bootstrap/web_mcp/execution.rs",+ 1,+ DirectCallOwner::TypedWebIdlAdapter,+ ),// Ordinary calls, including HTML-owned callbacks and script wrappers,// enter through the common JavaScript execution boundary.allowed(diff --git a/moli-wpt-compat/fixtures/wpt/upstream/webmcp/declarative/chromium-form-schema-cases.json b/moli-wpt-compat/fixtures/wpt/upstream/webmcp/declarative/chromium-form-schema-cases.jsonnew file mode 100644index 000000000..79bc99472--- /dev/null+++ b/moli-wpt-compat/fixtures/wpt/upstream/webmcp/declarative/chromium-form-schema-cases.json@@ -0,0 +1,197 @@+{+ "source_commit": "2d184faab9fb11e1070fb1eeafebf291f6e85923",+ "source_path": "third_party/blink/renderer/core/html/forms/html_form_mcp_tool_test.cc",+ "license": "BSD-3-Clause; see licenses/Chromium-BSD-3-Clause.txt at the repository root",+ "cases": [+ {+ "name": "ParameterSchema_Disabled",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"text1\" type=\"text\">\n <input name=\"text2\" type=\"text\" disabled>\n <textarea name=\"area1\" disabled>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Readonly",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"text1\" type=\"text\">\n <input name=\"text2\" type=\"text\" readonly>\n <textarea name=\"area1\" readonly>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"text1\" type=\"text\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput_Required",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"text1\" type=\"text\">\n <input name=\"text2\" type=\"text\" required>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\"},\"text2\":{\"type\":\"string\"}},\"required\":[\"text2\"]}"+ },+ {+ "name": "ParameterSchema_TextInput_Description",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"text1\" type=\"text\" toolparamdescription=\"Some nice text\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\",\"description\":\"Some nice text\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput_Label",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <label for=\"text\">Some text</label>\n <input id=\"text\" name=\"text1\" type=\"text\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\",\"description\":\"Some text\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput_Label_Multiple",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <label for=\"text\">Label one</label>\n <label for=\"text\">Label two</label>\n <input id=\"text\" name=\"text1\" type=\"text\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\",\"description\":\"Label one; Label two\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput_AriaDescription",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"text1\" type=\"text\" aria-description=\"ARIA\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\",\"description\":\"ARIA\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput_PreferLabelOverAria",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <label for=\"text\">Label</label>\n <input id=\"text\" name=\"text1\" type=\"text\" aria-description=\"ARIA\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\",\"description\":\"Label\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput_PreferAttrOverLabel",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <label for=\"text\">Label</label>\n <input\n id=\"text\"\n name=\"text1\"\n type=\"text\"\n toolparamdescription=\"ATTR\"\n aria-description=\"ARIA\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\",\"description\":\"ATTR\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextInput_DuplicateName",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"text1\" type=\"text\">\n <input name=\"text2\" type=\"text\">\n <input name=\"text2\" type=\"text\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"text1\":{\"type\":\"string\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_ImplicitLabelText",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <label>\n LABEL\n <select name=\"select\" required>\n <option value=\"Option 1\">This is option 1</option>\n <option value=\"Option 2\">This is option 2</option>\n <option value=\"Option 3\">This is option 3</option>\n </select>\n <button>Button text</button>\n </label>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"select\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"Option 1\",\"title\":\"This is option 1\"},{\"type\":\"string\",\"const\":\"Option 2\",\"title\":\"This is option 2\"},{\"type\":\"string\",\"const\":\"Option 3\",\"title\":\"This is option 3\"}],\"enum\":[\"Option 1\",\"Option 2\",\"Option 3\"],\"description\":\"LABEL\"}},\"required\":[\"select\"]}"+ },+ {+ "name": "ParameterSchema_Select",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <select name=\"select\" required>\n <option value=\"Option 1\">This is option 1</option>\n <option value=\"Option 2\">This is option 2</option>\n <option value=\"Option 3\">This is option 3</option>\n </select>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"select\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"Option 1\",\"title\":\"This is option 1\"},{\"type\":\"string\",\"const\":\"Option 2\",\"title\":\"This is option 2\"},{\"type\":\"string\",\"const\":\"Option 3\",\"title\":\"This is option 3\"}],\"enum\":[\"Option 1\",\"Option 2\",\"Option 3\"]}},\"required\":[\"select\"]}"+ },+ {+ "name": "ParameterSchema_Select_Multiple",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <select name=\"select\" multiple required>\n <option value=\"Option 1\">This is option 1</option>\n <option value=\"Option 2\">This is option 2</option>\n <option value=\"Option 3\">This is option 3</option>\n </select>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"select\":{\"type\":\"array\",\"items\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"Option 1\",\"title\":\"This is option 1\"},{\"type\":\"string\",\"const\":\"Option 2\",\"title\":\"This is option 2\"},{\"type\":\"string\",\"const\":\"Option 3\",\"title\":\"This is option 3\"}],\"enum\":[\"Option 1\",\"Option 2\",\"Option 3\"]},\"uniqueItems\":true}},\"required\":[\"select\"]}"+ },+ {+ "name": "ParameterSchema_NumberInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"num1\" type=\"number\" min=\"10\" max=\"100\">\n <input name=\"num2\" type=\"number\" min=\"30\" max=\"60\" step=\"10\">\n <input name=\"num3\" type=\"number\" min=\"15\" step=\"10\">\n <input name=\"num4\" type=\"number\" step=\"13\">\n <input name=\"num5\" type=\"number\" step=\"0.1\">\n <input name=\"num6\" type=\"number\" min=\"0.15\" step=\"0.1\">\n <input name=\"num7\" type=\"number\" pattern=\"[1-4]{3}\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"num1\":{\"type\":\"number\",\"minimum\":10,\"maximum\":100,\"multipleOf\":1},\"num2\":{\"type\":\"number\",\"minimum\":30,\"maximum\":60,\"multipleOf\":10},\"num3\":{\"type\":\"number\",\"minimum\":15},\"num4\":{\"type\":\"number\",\"multipleOf\":13},\"num5\":{\"type\":\"number\",\"multipleOf\":0.1},\"num6\":{\"type\":\"number\",\"minimum\":0.15},\"num7\":{\"type\":\"number\",\"multipleOf\":1,\"pattern\":\"[1-4]{3}\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_NumberInput_MinOnly",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"num1\" type=\"number\" min=\"10\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"num1\":{\"type\":\"number\",\"minimum\":10,\"multipleOf\":1}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_NumberInput_MaxOnly",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"num1\" type=\"number\" max=\"100\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"num1\":{\"type\":\"number\",\"maximum\":100,\"multipleOf\":1}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Checkbox",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"check1\" type=\"checkbox\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"check1\":{\"type\":\"boolean\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Checkbox_Multiple",+ "html": "\n <form id=form toolname=\"mytool\" tooldescription=\"pick fruits you like\">\n <label>\n <input id=\"apple\" name=\"fruit\" type=\"checkbox\" value=\"apple\">\n Apple\n </label>\n <label>\n <input id=\"melon\" name=\"fruit\" type=\"checkbox\" value=\"melon\">\n Melon\n </label>\n <label>\n <input id=\"grape\" name=\"fruit\" type=\"checkbox\" value=\"grape\">\n Grape\n </label>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"fruit\":{\"type\":\"array\",\"items\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"apple\",\"title\":\"Apple\"},{\"type\":\"string\",\"const\":\"melon\",\"title\":\"Melon\"},{\"type\":\"string\",\"const\":\"grape\",\"title\":\"Grape\"}],\"enum\":[\"apple\",\"melon\",\"grape\"]},\"uniqueItems\":true}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Checkbox_IgnoreToolParamAttributes",+ "html": "\n <form id=form toolname=\"mytool\" tooldescription=\"pick fruits you like\">\n <input\n id=\"apple\"\n name=\"fruit\"\n type=\"checkbox\"\n value=\"apple\"\n toolparamdescription=\"ERR1\"\n >\n <input\n id=\"melon\"\n name=\"fruit\"\n type=\"checkbox\"\n value=\"melon\"\n toolparamdescription=\"ERR2\"\n >\n <input id=\"grape\" name=\"fruit\" type=\"checkbox\" value=\"grape\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"fruit\":{\"type\":\"array\",\"items\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"apple\"},{\"type\":\"string\",\"const\":\"melon\"},{\"type\":\"string\",\"const\":\"grape\"}],\"enum\":[\"apple\",\"melon\",\"grape\"]},\"uniqueItems\":true}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_RangeInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"range1\" type=\"range\" min=\"0\" max=\"50\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"range1\":{\"type\":\"number\",\"minimum\":0,\"maximum\":50,\"multipleOf\":1}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_RangeInput_Defaults",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"range1\" type=\"range\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"range1\":{\"type\":\"number\",\"minimum\":0,\"maximum\":100,\"multipleOf\":1}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_RangeInput_Step",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"range1\" type=\"range\" min=\"0\" max=\"10\" step=\"2\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"range1\":{\"type\":\"number\",\"minimum\":0,\"maximum\":10,\"multipleOf\":2}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_RangeInput_StepBaseOffset",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"range1\" type=\"range\" min=\"1\" max=\"11\" step=\"2\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"range1\":{\"type\":\"number\",\"minimum\":1,\"maximum\":11}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_DateInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"date1\" type=\"date\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"date1\":{\"type\":\"string\",\"format\":\"date\",\"description\":\"Dates MUST be provided in 'YYYY-MM-DD' format.\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_DatetimeLocalInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"datetime1\" type=\"datetime-local\">\n <input name=\"datetime2\" type=\"datetime-local\" step=\"1\">\n <input name=\"datetime3\" type=\"datetime-local\" step=\"0.001\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"datetime1\":{\"type\":\"string\",\"format\":\"^[0-9]{4}-(0[1-9]|1[0-2])-[0-9]{2}T([01][0-9]|2[0-3]):[0-5][0-9]$\"},\"datetime2\":{\"type\":\"string\",\"format\":\"^[0-9]{4}-(0[1-9]|1[0-2])-[0-9]{2}T([01][0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$\"},\"datetime3\":{\"type\":\"string\",\"format\":\"^[0-9]{4}-(0[1-9]|1[0-2])-[0-9]{2}T([01][0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9](\\\\.[0-9]{1,3})?)?$\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_MonthInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"month1\" type=\"month\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"month1\":{\"type\":\"string\",\"format\":\"^[0-9]{4}-(0[1-9]|1[0-2])$\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_WeekInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"week1\" type=\"week\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"week1\":{\"type\":\"string\",\"format\":\"^[0-9]{4}-W(0[1-9]|[1-4][0-9]|5[0-3])$\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TimeInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"time1\" type=\"time\">\n <input name=\"time2\" type=\"time\" step=\"1\">\n <input name=\"time3\" type=\"time\" step=\"0.001\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"time1\":{\"type\":\"string\",\"format\":\"^([01][0-9]|2[0-3]):[0-5][0-9]$\"},\"time2\":{\"type\":\"string\",\"format\":\"^([01][0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9])?$\"},\"time3\":{\"type\":\"string\",\"format\":\"^([01][0-9]|2[0-3]):[0-5][0-9](:[0-5][0-9](\\\\.[0-9]{1,3})?)?$\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_ColorInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"color1\" type=\"color\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"color1\":{\"type\":\"string\",\"format\":\"^#[0-9a-zA-Z]{6}$\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_TextArea",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <textarea name=\"area1\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"area1\":{\"type\":\"string\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_BaseTextInput",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"email1\" type=\"email\">\n <input name=\"search1\" type=\"search\">\n <input name=\"tel1\" type=\"tel\">\n <input name=\"url1\" type=\"url\">\n <input name=\"hidden1\" type=\"hidden\">\n <input name=\"hidden2\" type=\"hidden\" toolparamdescription=\"DESC\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"email1\":{\"type\":\"string\"},\"search1\":{\"type\":\"string\"},\"tel1\":{\"type\":\"string\"},\"url1\":{\"type\":\"string\"},\"hidden2\":{\"type\":\"string\",\"description\":\"DESC\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_BaseTextInputPatternAttribute",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input name=\"email1\" type=\"email\" pattern=\"[A-Z]{10}\">\n <input name=\"search1\" type=\"search\" pattern=\"[A-Z]{10}\">\n <input name=\"tel1\" type=\"tel\" pattern=\"[A-Z]{10}\">\n <input name=\"url1\" type=\"url\" pattern=\"[A-Z]{10}\">\n <input name=\"hidden1\" type=\"hidden\" pattern=\"[A-Z]{10}\">\n <input name=\"hidden2\" type=\"hidden\" toolparamdescription=\"DESC\" pattern=\"[A-Z]{10}\">\n <input name=\"invalid_pattern\" type=\"text\" toolparamdescription=\"invalid pattern input\" pattern=\"[)]\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"email1\":{\"type\":\"string\",\"pattern\":\"[A-Z]{10}\"},\"search1\":{\"type\":\"string\",\"pattern\":\"[A-Z]{10}\"},\"tel1\":{\"type\":\"string\",\"pattern\":\"[A-Z]{10}\"},\"url1\":{\"type\":\"string\",\"pattern\":\"[A-Z]{10}\"},\"hidden2\":{\"type\":\"string\",\"pattern\":\"[A-Z]{10}\",\"description\":\"DESC\"},\"invalid_pattern\":{\"type\":\"string\",\"description\":\"invalid pattern input\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Radio",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <label>\n <input type=radio name=size value=s>\n Small\n </label>\n <label>\n <input type=radio name=size value=m>\n Medium\n </label>\n <label>\n <input type=radio name=size value=l>\n Large\n </label>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"size\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"s\",\"title\":\"Small\"},{\"type\":\"string\",\"const\":\"m\",\"title\":\"Medium\"},{\"type\":\"string\",\"const\":\"l\",\"title\":\"Large\"}],\"enum\":[\"s\",\"m\",\"l\"]}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Radio_Multiple",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input type=radio name=size value=s>\n <input type=radio name=size value=m>\n <input type=radio name=size value=l>\n <input type=radio name=item value=hoodie>\n <input type=radio name=item value=shirt>\n <input type=radio name=item value=hat>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"size\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"s\"},{\"type\":\"string\",\"const\":\"m\"},{\"type\":\"string\",\"const\":\"l\"}],\"enum\":[\"s\",\"m\",\"l\"]},\"item\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"hoodie\"},{\"type\":\"string\",\"const\":\"shirt\"},{\"type\":\"string\",\"const\":\"hat\"}],\"enum\":[\"hoodie\",\"shirt\",\"hat\"]}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Radio_MixedType",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input type=text name=foo>\n <input type=radio name=size value=s>\n <input type=radio name=size value=m>\n <input type=radio name=size value=l>\n <input type=text name=size> <!-- Oops! -->\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"foo\":{\"type\":\"string\"}},\"required\":[]}"+ },+ {+ "name": "ParameterSchema_Radio_Required",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input type=radio name=size value=s>\n <input type=radio name=size value=m required>\n <input type=radio name=size value=l>\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"size\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"s\"},{\"type\":\"string\",\"const\":\"m\"},{\"type\":\"string\",\"const\":\"l\"}],\"enum\":[\"s\",\"m\",\"l\"]}},\"required\":[\"size\"]}"+ },+ {+ "name": "ParameterSchema_Radio_IgnoreToolParamDescription",+ "html": "\n <form id=\"form\" toolname=\"mytool\" tooldescription=\"perform task\">\n <input type=radio name=size value=s toolparamdescription=\"ERR1\">\n <input type=radio name=size value=m toolparamdescription=\"ERR2\">\n <input type=radio name=size value=l toolparamdescription=\"ERR3\">\n </form>\n ",+ "expected_json": "{\"type\":\"object\",\"properties\":{\"size\":{\"type\":\"string\",\"anyOf\":[{\"type\":\"string\",\"const\":\"s\"},{\"type\":\"string\",\"const\":\"m\"},{\"type\":\"string\",\"const\":\"l\"}],\"enum\":[\"s\",\"m\",\"l\"]}},\"required\":[]}"+ }+ ]+}