Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

feat(webmcp): implement document tools and CDP integration

ldm0c345a594f47d
diff --git a/Cargo.lock b/Cargo.lock
index 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.rs
index 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.rs
index 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: configuration
diff --git a/moli-page-types/src/inspector_state.rs b/moli-page-types/src/inspector_state.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_inputs
diff --git a/moli-protocol/src/conn/state/devtools_session.rs b/moli-protocol/src/conn/state/devtools_session.rs
index 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_state
diff --git a/moli-protocol/src/conn/state/fetch.rs b/moli-protocol/src/conn/state/fetch.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_a
response_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_navigat
response_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.rs
index 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<Nativ
match 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.rs
index 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.rs
index 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_t
let 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.rs
index 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_asy
navigation.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_async
None,
&[],
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.rs
index 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.rs
index 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.rs
index 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(&params.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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.toml
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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() {
PageAgent
diff --git a/moli-renderer-v8/src/document_runtime/events.rs b/moli-renderer-v8/src/document_runtime/events.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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_config
prepared
.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.rs
index 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.rs
index 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_host
diff --git a/moli-renderer-v8/src/script_vm/document_environment.rs b/moli-renderer-v8/src/script_vm/document_environment.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.json
new file mode 100644
index 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\":[]}"
+ }
+ ]
+}