Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
fix(runtime): defer child-frame evaluation through the Inspector owner
ldm0218755595980
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rsindex 9048fee61..a230ec3c1 100644--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs@@ -100,6 +100,7 @@ async fn assert_empty_http_error_navigation(ctx: &mut TestContext, error_url: &s);}+mod child_await;mod contexts;mod dom_integration;mod evaluation;diff --git a/moli-protocol/src/domains/runtime/tests/evaluate/child_await.rs b/moli-protocol/src/domains/runtime/tests/evaluate/child_await.rsnew file mode 100644index 000000000..d2da78ae3--- /dev/null+++ b/moli-protocol/src/domains/runtime/tests/evaluate/child_await.rs@@ -0,0 +1,235 @@+use super::*;++async fn child_context(ctx: &mut TestContext) -> i64 {+ with_loaded_document_async(+ ctx,+ r#"<!doctype html><title>parent</title><iframe srcdoc="<title>child</title><body>child realm</body>"></iframe>"#,+ )+ .await;+ ctx.process_async(json!({"id": 12_001, "method": "Page.getFrameTree"}))+ .await;+ let frame_id =+ take_response_by_id(ctx, 12_001)["result"]["frameTree"]["childFrames"][0]["frame"]["id"]+ .as_str()+ .expect("the iframe must have its own browsing context")+ .to_owned();+ ctx.process_async(json!({+ "id": 12_002, "method": "Page.createIsolatedWorld",+ "params": {"frameId": frame_id, "worldName": "child-await-materialization"}+ }))+ .await;+ assert!(take_response_by_id(ctx, 12_002)["result"]["executionContextId"].is_i64());+ ctx.process_async(json!({"id": 12_003, "method": "Runtime.enable"}))+ .await;+ assert_eq!(take_response_by_id(ctx, 12_003)["result"], json!({}));+ crate::testing::wait_until_message(ctx, None, "child default execution context", |message| {+ message["method"] == "Runtime.executionContextCreated"+ && message["params"]["context"]["auxData"]["frameId"] == frame_id+ && message["params"]["context"]["auxData"]["isDefault"] == true+ })+ .await;+ ctx.sent+ .iter()+ .find(|message| {+ message["method"] == "Runtime.executionContextCreated"+ && message["params"]["context"]["auxData"]["frameId"] == frame_id+ && message["params"]["context"]["auxData"]["isDefault"] == true+ })+ .and_then(|message| message["params"]["context"]["id"].as_i64())+ .expect("Runtime.enable must report the actual child default context")+}++#[tokio::test]+async fn child_runtime_evaluate_timer_reply_follows_console_on_owner_turns() {+ let mut ctx = TestContext::new();+ let context_id = child_context(&mut ctx).await;+ ctx.sent.clear();+ ctx.process_async(json!({+ "id": 12_010, "method": "Runtime.evaluate",+ "params": {+ "contextId": context_id, "returnByValue": true, "awaitPromise": true,+ "expression": "new Promise(resolve => setTimeout(() => { console.log('child-await-output'); resolve({value:42, title:document.title, child:window!==top}); }, 20))"+ }+ }))+ .await;+ crate::testing::wait_until_message(+ &mut ctx,+ None,+ "child timer-backed Inspector reply",+ |message| message["id"] == 12_010,+ )+ .await;+ let console = ctx+ .sent+ .iter()+ .position(|message| {+ message["method"] == "Runtime.consoleAPICalled"+ && message["params"]["executionContextId"] == context_id+ && message["params"]["args"][0]["value"] == "child-await-output"+ })+ .expect("the real child timer must run without a follow-up evaluation");+ let terminal = ctx+ .sent+ .iter()+ .position(|message| message["id"] == 12_010)+ .unwrap();+ assert!(+ console < terminal,+ "concrete output must precede the response: {:?}",+ ctx.sent+ );+ let response = take_response_by_id(&mut ctx, 12_010);+ assert_eq!(+ response["result"]["result"]["value"],+ json!({"value":42, "title":"child", "child":true})+ );+ assert!(!ctx.conn.has_pending_inspector_awaits());+}++#[tokio::test]+async fn child_runtime_evaluate_preserves_native_exception_details() {+ let mut ctx = TestContext::new();+ let context_id = child_context(&mut ctx).await;+ for (id, expression, await_promise) in [+ (+ 12_020,+ "throw new TypeError('child-await-rejection')",+ false,+ ),+ (+ 12_021,+ "new Promise((resolve,reject) => setTimeout(() => reject(new TypeError('child-await-rejection')), 20))",+ true,+ ),+ ] {+ ctx.process_async(json!({+ "id": id, "method": "Runtime.evaluate",+ "params": {"contextId":context_id, "expression":expression,+ "returnByValue":true, "awaitPromise":await_promise}+ }))+ .await;+ let response = wait_for_response_by_id_async(&mut ctx, None, id).await;+ assert!(response.get("error").is_none(), "{response:?}");+ let details = &response["result"]["exceptionDetails"];+ assert_eq!(+ details["exception"]["className"], "TypeError",+ "{response:?}"+ );+ assert!(+ details["exception"]["description"]+ .as_str()+ .unwrap()+ .contains("child-await-rejection")+ );+ assert!(details["exceptionId"].is_number(), "{response:?}");+ assert!(+ !details["stackTrace"]["callFrames"]+ .as_array()+ .unwrap()+ .is_empty(),+ "{response:?}"+ );+ assert!(!ctx.conn.has_pending_inspector_awaits());+ }+}++#[tokio::test]+async fn child_runtime_evaluate_pending_promise_releases_page_dispatch() {+ let mut ctx = TestContext::new();+ let context_id = child_context(&mut ctx).await;+ ctx.sent.clear();+ ctx.process_async(json!({+ "id": 12_030, "method": "Runtime.evaluate",+ "params": {+ "contextId":context_id, "returnByValue":true, "awaitPromise":true,+ "expression":"new Promise(resolve => { globalThis.resolveChildAwait = resolve; console.log('child-await-pending'); })"+ }+ }))+ .await;+ crate::testing::wait_until_message(+ &mut ctx,+ None,+ "unresolved child expression started",+ |message| {+ message["method"] == "Runtime.consoleAPICalled"+ && message["params"]["args"][0]["value"] == "child-await-pending"+ },+ )+ .await;+ assert!(!ctx.sent.iter().any(|message| message["id"] == 12_030));+ assert!(+ ctx.conn+ .has_unclaimed_pending_inspector_awaits_for_session_owner(None)+ );+ assert!(+ !ctx.conn+ .has_claimed_pending_inspector_awaits_for_session_owner(None)+ );+ ctx.process_async(json!({+ "id":12_031, "method":"Runtime.evaluate",+ "params":{"expression":"document.title", "returnByValue":true}+ }))+ .await;+ assert_eq!(+ take_response_by_id(&mut ctx, 12_031)["result"]["result"]["value"],+ "parent"+ );+ assert!(!ctx.sent.iter().any(|message| message["id"] == 12_030));+ ctx.process_async(json!({+ "id":12_032, "method":"Runtime.evaluate",+ "params":{"contextId":context_id, "expression":"resolveChildAwait(42)", "returnByValue":true}+ }))+ .await;+ let response = wait_for_response_by_id_async(&mut ctx, None, 12_030).await;+ assert_eq!(response["result"]["result"]["value"], 42);+ assert!(!ctx.conn.has_pending_inspector_awaits());+}++#[tokio::test]+async fn child_runtime_evaluate_frame_retirement_rejects_pending_and_stale_requests() {+ let mut ctx = TestContext::new();+ let context_id = child_context(&mut ctx).await;+ ctx.sent.clear();+ ctx.process_async(json!({+ "id":12_040, "method":"Runtime.evaluate",+ "params":{"contextId":context_id, "returnByValue":true, "awaitPromise":true,+ "expression":"new Promise(() => { console.log('child-await-retire'); })"}+ }))+ .await;+ crate::testing::wait_until_message(+ &mut ctx,+ None,+ "child expression before retirement",+ |message| {+ message["method"] == "Runtime.consoleAPICalled"+ && message["params"]["args"][0]["value"] == "child-await-retire"+ },+ )+ .await;+ assert!(!ctx.sent.iter().any(|message| message["id"] == 12_040));+ ctx.process_async(json!({+ "id":12_041, "method":"Runtime.evaluate",+ "params":{"expression":"document.querySelector('iframe').remove()", "returnByValue":true}+ }))+ .await;+ let response = wait_for_response_by_id_async(&mut ctx, None, 12_040).await;+ assert_eq!(response["error"]["code"], -32000, "{response:?}");+ assert!(+ !response["error"]["message"]+ .as_str()+ .unwrap()+ .contains("outside an owner continuation")+ );+ assert!(!ctx.conn.has_pending_inspector_awaits());+ ctx.process_async(json!({+ "id":12_042, "method":"Runtime.evaluate",+ "params":{"contextId":context_id, "expression":"42", "returnByValue":true}+ }))+ .await;+ let stale = take_response_by_id(&mut ctx, 12_042);+ assert_eq!(stale["error"]["code"], -32000);+ assert!(+ !ctx.sent.iter().any(|message| message["id"] == 12_040),+ "retirement must have a single terminal"+ );+}diff --git a/moli-renderer-v8/src/runtime/page_dom.rs b/moli-renderer-v8/src/runtime/page_dom.rsindex feef92393..0be59a0d2 100644--- a/moli-renderer-v8/src/runtime/page_dom.rs+++ b/moli-renderer-v8/src/runtime/page_dom.rs@@ -750,11 +750,6 @@ impl PageVm {action: &str,raw_json: &str,) -> Result<Vec<RendererRuntimeInspectorMessage>> {- if action == "evaluate"- && let Some(messages) = self.try_dispatch_child_default_runtime_evaluate(raw_json)?- {- return Ok(messages);- }let prepared_json =self.prepare_runtime_protocol_message_with_context_resolution(action, raw_json)?;let messages = self@@ -779,34 +774,6 @@ impl PageVm {raw_json: &str,deferred_response: RendererRuntimeInspectorResponseSender,) -> Result<Vec<RendererRuntimeInspectorMessage>> {- if action == "evaluate"- && let Some(messages) = self.try_dispatch_child_default_runtime_evaluate(raw_json)?- {- let call_id = deferred_response.call_id();- if let Some(message) = messages.into_iter().next() {- if deferred_response.response_delivery()- == moli_page_types::RendererInspectorResponseDelivery::SessionSink- {- let deferred_response = self.vm().route_frontend_runtime_inspector_response(- inspector_session_id,- deferred_response,- )?;- let settlement = deferred_response.finalize_output(- RendererRuntimeCommandOutput::from_inspector_message(message),- );- self.append_runtime_command_output_settlement(settlement);- } else if let Err(message) =- deferred_response.send(message.into_v8_inspector_message())- {- tracing::debug!(- call_id,- message = ?message,- "dropping child-frame runtime response because deferred receiver was closed"- );- }- }- return Ok(Vec::new());- }let prepared_json =self.prepare_runtime_protocol_message_with_context_resolution(action, raw_json)?;self.dispatch_runtime_protocol_message_with_command_output(@@ -1126,103 +1093,6 @@ impl PageVm {}}- fn try_dispatch_child_default_runtime_evaluate(- &mut self,- raw_json: &str,- ) -> Result<Option<Vec<RendererRuntimeInspectorMessage>>> {- let message: Value = serde_json::from_str(raw_json)?;- if message.get("method").and_then(Value::as_str) != Some("Runtime.evaluate") {- return Ok(None);- }- let Some(params) = message.get("params").and_then(Value::as_object) else {- return Ok(None);- };- let Some(context_id) = params.get("contextId").and_then(Value::as_i64) else {- return Ok(None);- };- if self- .vm_mut()- .child_default_frame_id_for_execution_context_id(context_id)- .is_none()- {- return Ok(None);- }- if params.get("objectGroup").is_some()- || params.get("generatePreview").and_then(Value::as_bool) == Some(true)- || params.get("returnByValue").and_then(Value::as_bool) != Some(true)- {- return Ok(None);- }- let expression = params- .get("expression")- .and_then(Value::as_str)- .unwrap_or_default();- let await_promise = params- .get("awaitPromise")- .and_then(Value::as_bool)- .unwrap_or(false);- let user_gesture = params- .get("userGesture")- .and_then(Value::as_bool)- .unwrap_or(false);- let file_prompt_handler = params- .get(crate::script_vm::WEBDRIVER_BIDI_FILE_PROMPT_HANDLER_PARAM)- .and_then(Value::as_str)- .filter(|handler| matches!(*handler, "accept" | "dismiss"));- let id = message.get("id").cloned().unwrap_or(Value::Null);- let result = self- .vm_mut()- .evaluate_expression_by_value_payload_in_context_with_await(- Some(context_id),- expression,- await_promise,- user_gesture,- file_prompt_handler,- );- let response = match result {- Ok(payload) if payload.get("exception").is_none() => {- json!({ "id": id, "result": { "result": payload } })- }- Ok(payload) => {- let description = payload- .get("exception")- .and_then(Value::as_str)- .unwrap_or("Error");- json!({- "id": id,- "result": {- "result": {- "type": "object",- "subtype": "error",- "description": description,- },- "exceptionDetails": {- "text": "Uncaught",- "executionContextId": context_id,- "exception": {- "type": "object",- "subtype": "error",- "description": description,- },- },- },- })- }- Err(error) => {- json!({- "id": id,- "error": {- "code": -32000,- "message": error.to_string(),- },- })- }- };- Ok(Some(vec![RendererRuntimeInspectorMessage::protocol(- response,- )]))- }-fn prepare_runtime_protocol_message_with_context_resolution(&mut self,action: &str,diff --git a/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rs b/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rsindex 8473489be..00da3d838 100644--- a/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rs+++ b/moli-renderer-v8/src/runtime/tests/extracted/runtime_scripts.rs@@ -721,38 +721,87 @@ async fn child_default_runtime_evaluate_pending_await_promise_does_not_leak_inte);let child_context_id = child_context_ids[0];- let evaluate = dispatch_runtime_protocol_with_context_resolution_for_test(+ let (response_tx, mut response_rx) = oneshot::channel();+ let (evaluate, _) = page+ .run_async_command(+ RendererPageCommand::dispatch_runtime_protocol_message_with_context_resolution_and_deferred_response(+ None,+ "evaluate".to_owned(),+ serde_json::json!({+ "id": 67,+ "method": "Runtime.evaluate",+ "params": {+ "contextId": child_context_id,+ "expression": "new Promise(resolve => { globalThis.resolveChildAwait = resolve; })",+ "awaitPromise": true,+ "returnByValue": true+ }+ }).to_string(),+ RendererRuntimeInspectorResponseSender::new(67, response_tx),+ ),+ )+ .await+ .expect("child Runtime.evaluate awaitPromise should dispatch");+ assert!(matches!(+ evaluate,+ RendererPageReply::RuntimeInspectorProtocolMessages(ref messages) if messages.is_empty()+ ));+ assert!(matches!(+ response_rx.try_recv(),+ Err(tokio::sync::oneshot::error::TryRecvError::Empty)+ ));++ let resolved = dispatch_runtime_protocol_with_context_resolution_for_test(&page,"evaluate",serde_json::json!({- "id": 67,+ "id": 68,"method": "Runtime.evaluate","params": {"contextId": child_context_id,- "expression": "new Promise(() => {})",- "awaitPromise": true,+ "expression": "resolveChildAwait('child-result'); 'resolved'","returnByValue": true}}),).await- .expect("child Runtime.evaluate awaitPromise should dispatch");- let response =- runtime_protocol_response_by_id(&evaluate, 67).expect("child awaitPromise response");+ .expect("the pending child evaluation must release Page dispatch");+ assert_eq!(+ runtime_protocol_response_by_id(&resolved, 68).expect("resolver response")["result"]["result"]+ ["value"],+ serde_json::json!("resolved")+ );+ let completion = tokio::time::timeout(Duration::from_secs(2), &mut response_rx)+ .await+ .expect("the child Promise response must settle on its Page owner")+ .expect("the child response must retain its callback owner");+ assert_eq!(completion.call_id, 67);+ let response = completion+ .output+ .protocol_response(67)+ .expect("child awaitPromise response");+ let messages: Vec<_> = completion+ .output+ .messages()+ .iter()+ .cloned()+ .map(RendererRuntimeInspectorMessage::into_v8_inspector_message)+ .collect();let messages_json =- serde_json::to_string(&evaluate).expect("Runtime.evaluate messages should serialize");+ serde_json::to_string(&messages).expect("Runtime.evaluate messages should serialize");assert!(!messages_json.contains("__moliAwaitPromiseToken"),- "child Runtime.evaluate awaitPromise leaked internal polling token: {evaluate:?}"+ "child Runtime.evaluate awaitPromise leaked internal polling token: {messages_json}");assert!(!messages_json.contains("__moliPendingPromise"),- "child Runtime.evaluate awaitPromise leaked internal pending marker: {evaluate:?}"+ "child Runtime.evaluate awaitPromise leaked internal pending marker: {messages_json}");assert!(- response.get("error").is_some() || response["result"]["exceptionDetails"].is_object(),- "pending child Runtime.evaluate awaitPromise must fail closed instead of returning an internal success payload: {response:?}"+ response.get("error").is_none() && response["result"].get("exceptionDetails").is_none(),+ "a resolved child Promise must return its native result: {response:?}");+ assert_eq!(response["result"]["result"]["value"], "child-result");page.close_async().awaitdiff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rsindex 0ef7a5b5a..c35e0ee90 100644--- a/moli-renderer-v8/src/script_vm.rs+++ b/moli-renderer-v8/src/script_vm.rs@@ -1436,15 +1436,6 @@ impl ScriptVm {)}- pub(super) fn route_frontend_runtime_inspector_response(- &self,- inspector_session_id: Option<&str>,- response: RendererRuntimeInspectorResponseSender,- ) -> Result<RendererRuntimeInspectorResponseSender> {- self.page_inspector- .route_frontend_response(inspector_session_id, response)- }-fn dispatch_internal_runtime_evaluate_protocol_message(&mut self,raw_json: &str,diff --git a/moli-renderer-v8/src/script_vm/inspector/agent.rs b/moli-renderer-v8/src/script_vm/inspector/agent.rsindex 8a4297211..12ee5c903 100644--- a/moli-renderer-v8/src/script_vm/inspector/agent.rs+++ b/moli-renderer-v8/src/script_vm/inspector/agent.rs@@ -351,17 +351,6 @@ impl RendererDevToolsAgent {self.state.borrow().sessions.frontend_routes()}- pub(super) fn frontend_outbound(- &self,- session_key: &DevToolsSessionKey,- ) -> Option<InspectorOutbound> {- self.state- .borrow()- .sessions- .frontend_session_and_outbound(session_key)- .map(|(_, outbound)| outbound)- }-pub(super) fn deactivate_all_routes(&self) {self.state.borrow().sessions.deactivate_all();}diff --git a/moli-renderer-v8/src/script_vm/inspector/mod.rs b/moli-renderer-v8/src/script_vm/inspector/mod.rsindex 6ab308cb9..cc9ae1828 100644--- a/moli-renderer-v8/src/script_vm/inspector/mod.rs+++ b/moli-renderer-v8/src/script_vm/inspector/mod.rs@@ -36,7 +36,6 @@ pub(crate) use self::v8_backend::{use crate::devtools::target::RendererDevToolsTargetHandle;#[cfg(test)]use crate::runtime::RendererRuntimeCommandOutputRecorder;-use crate::runtime::RendererRuntimeInspectorResponseSender;use crate::{frame_owner_model::FrameRealmId,protocol_types::RuntimeBindingRegistration,@@ -45,8 +44,8 @@ use crate::{};use anyhow::Result;use moli_page_types::{- DevToolsSessionKey, RendererDevToolsAgentToken, RendererInspectorResponseDelivery,- RendererInspectorSessionRestoreSnapshot, V8InspectorSessionState,+ DevToolsSessionKey, RendererDevToolsAgentToken, RendererInspectorSessionRestoreSnapshot,+ V8InspectorSessionState,};use serde_json::{Value, json};use std::{cell::RefCell, collections::HashMap};@@ -155,22 +154,6 @@ impl DocumentInspectorBinding {}}- pub(super) fn route_frontend_response(- &self,- inspector_session_id: Option<&str>,- response: RendererRuntimeInspectorResponseSender,- ) -> Result<RendererRuntimeInspectorResponseSender> {- if response.response_delivery() == RendererInspectorResponseDelivery::AdapterReply {- return Ok(response);- }- let session_key = inspector_session_key(inspector_session_id);- let outbound = self- .agent- .frontend_outbound(&session_key)- .ok_or_else(|| anyhow::anyhow!("Inspector frontend session is not available"))?;- Ok(outbound.route_frontend_response(response))- }-pub(super) fn v8_session_state(&self,inspector_session_id: Option<&str>,diff --git a/moli-renderer-v8/src/script_vm/inspector/tests.rs b/moli-renderer-v8/src/script_vm/inspector/tests.rsindex aff847ffd..7ba494c71 100644--- a/moli-renderer-v8/src/script_vm/inspector/tests.rs+++ b/moli-renderer-v8/src/script_vm/inspector/tests.rs@@ -1,5 +1,6 @@use super::*;use crate::inspector_session::InspectorSessionOutput;+use crate::runtime::RendererRuntimeInspectorResponseSender;#[test]fn inspector_outbound_queue_reports_its_exact_length_until_flushed() {diff --git a/moli-renderer-v8/src/script_vm/runtime_evaluation.rs b/moli-renderer-v8/src/script_vm/runtime_evaluation.rsindex 26506c59b..d6954925b 100644--- a/moli-renderer-v8/src/script_vm/runtime_evaluation.rs+++ b/moli-renderer-v8/src/script_vm/runtime_evaluation.rs@@ -39,26 +39,6 @@ impl ScriptVm {self.require_completed_runtime_evaluate(outcome)}- pub(crate) fn evaluate_expression_by_value_payload_in_context_with_await(- &mut self,- execution_context_id: Option<i64>,- expression: &str,- await_promise: bool,- user_gesture: bool,- file_prompt_handler: Option<&str>,- ) -> Result<Value> {- let outcome = self.begin_runtime_evaluate(- execution_context_id,- expression,- await_promise,- user_gesture,- file_prompt_handler,- RuntimeEvaluateCodeGenerationPolicy::from_cdp(None),- RuntimeEvaluateResultMode::ByValue,- )?;- self.require_completed_runtime_evaluate(outcome)- }-pub(crate) fn performance_metric_snapshot(&mut self,) -> Result<RendererPerformanceMetricSnapshot> {