Struct InteractiveElement 

pub struct InteractiveElement {
    pub index: usize,
    pub tag: String,
    pub role: String,
    pub text: String,
    pub name: String,
    pub input_type: String,
    pub placeholder: String,
    pub value: String,
    pub href: String,
    pub selector: String,
    pub is_clickable: bool,
    pub is_input: bool,
}

Fields

index: usize

tag: String

role: String

text: String

name: String

input_type: String

placeholder: String

value: String

href: String

selector: String

is_clickable: bool

is_input: bool

Implementations

impl InteractiveElement

pub fn to_agent_string(&self) -> String

Examples found in repository

examples/autonomous_agent_loop.rs (line 30)

async fn main() -> Result<()> {
    println!("================================================================================");
    println!(">>> AI AGENTIC AUTONOMOUS BROWSING LOOP (PURE RUST)");
    println!("================================================================================\n");

    let mut tab = BrowserTab::with_profile(DeviceProfile::ChromeWindows)?;

    // Step 1: Initial Navigation
    println!("[Step 1: Navigate] Agent navigating to Wikipedia Main Page...");
    tab.navigate("https://en.wikipedia.org/wiki/Main_Page")
        .await?;

    // Step 2: Observe
    println!("\n[Step 2: Observe] Extracting Indexed Action Tree for Agent LLM...");
    let obs = tab.observe().expect("Expected observation");
    println!("  * Page Title: {}", obs.title);
    println!(
        "  * Total Interactive Elements Indexed: {}",
        obs.interactive_elements.len()
    );

    println!("\n>>> AGENT ACTION MAP (Sample First 10 Elements):");
    println!("--------------------------------------------------------------------------------");
    for el in obs.interactive_elements.iter().take(10) {
        println!("{}", el.to_agent_string());
    }
    println!("--------------------------------------------------------------------------------");

    // Step 3: Agent Decision & Action
    // Agent chooses to click the search input or a featured article
    if let Some(target_link) = obs
        .interactive_elements
        .iter()
        .find(|e| e.tag == "a" && e.text.contains("article"))
    {
        println!(
            "\n[Step 3: Act] Agent decides to click element [{}] (Text: \"{}\")...",
            target_link.index, target_link.text
        );
        let action_res = tab.act_click(&target_link.index.to_string()).await?;

        if let Some(report) = action_res {
            println!("  -> Navigated to: {}", report.final_url);
            println!("  -> New Page Title: {}", report.page_title);
        }
    }

    // Step 4: Extract LLM Knowledge
    println!("\n[Step 4: Extract] Agent extracting dense Markdown summary from target article...");
    let md = tab.extract_markdown(None).unwrap_or_default();
    println!("  * Extracted Markdown Length: {} bytes", md.len());
    let preview: String = md.chars().take(400).collect();
    println!("\n>>> AGENT KNOWLEDGE PREVIEW:\n{}", preview);

    println!("\n================================================================================");
    println!(">>> AUTONOMOUS AGENT LOOP COMPLETED SEAMLESSLY!");
    println!("================================================================================");

    Ok(())
}

examples/agentic_chatgpt_prompt_execution.rs (line 48)

async fn main() -> Result<()> {
    println!("================================================================================");
    println!(">>> HEADLESS-ENGINE: AGENTIC CHATGPT PROMPT & RESPONSE EXECUTION");
    println!("================================================================================\n");

    let artifact_dir = Path::new(
        r"C:\Users\abhis\.gemini\antigravity-ide\brain\c08da294-7846-44b1-9403-559e0d23ce0f",
    );
    let evidence_dir = Path::new("evidence");
    fs::create_dir_all(evidence_dir)?;
    if !artifact_dir.exists() {
        let _ = fs::create_dir_all(artifact_dir);
    }

    let mut tab = BrowserTab::with_profile(DeviceProfile::ChromeWindows)?;

    // Step 1: Initial Navigation to ChatGPT
    let target_url = "https://chatgpt.com/";
    println!(
        "[Step 1: Navigate] Agent navigating with stealth fingerprint to {}...",
        target_url
    );
    let nav_report = tab.navigate(target_url).await?;
    println!("  -> HTTP Status:      {}", nav_report.status);
    println!("  -> Page Title:       {}", nav_report.page_title);
    println!("  -> CAPTCHA Detected: {}", nav_report.is_captcha_detected);
    println!("  -> HTML Payload:     {} bytes", nav_report.html_bytes);

    // Step 2: Observe Action Tree
    println!("\n[Step 2: Observe] Extracting Indexed Action Tree for LLM Reasoning...");
    let obs = tab.observe().expect("Expected ChatGPT page observation");
    println!(
        "  -> Total Interactive Elements Indexed: {}",
        obs.interactive_elements.len()
    );

    println!("\n>>> AGENT ACTION MAP (Sample Elements):");
    println!("--------------------------------------------------------------------------------");
    for el in obs.interactive_elements.iter().take(15) {
        println!("{}", el.to_agent_string());
    }
    println!("--------------------------------------------------------------------------------");

    // Step 3: Agent Decision & Prompt Action
    // Agent chooses to trigger an AI prompt (either via prompt button like "What can you do?" or typing)
    let prompt_btn = obs
        .interactive_elements
        .iter()
        .find(|e| {
            e.text.contains("What can you do")
                || e.text.contains("Deep research")
                || e.text.contains("New chat")
        })
        .cloned();

    let (chosen_action, action_type) = if let Some(btn) = &prompt_btn {
        println!("\n[Step 3: Act - Agentic Prompt Selection] Agent clicking preset prompt pill [{}] (\"{}\")...", btn.index, btn.text);
        let click_res = tab.act_click(&btn.index.to_string()).await?;
        let status_desc = if let Some(rep) = click_res {
            format!("Navigated to {}", rep.final_url)
        } else {
            "Triggered prompt action via element click".to_string()
        };
        (status_desc, btn.text.clone())
    } else {
        println!("\n[Step 3: Act - Agentic Prompting] Dispatching prompt to ChatGPT input...");
        let type_status = tab
            .act_type("26", "Explain quantum computing in 2 simple sentences")
            .await?;
        (
            format!("Typed prompt into element [26]: {}", type_status),
            "Typed Prompt".to_string(),
        )
    };

    println!("  -> Action Execution Result: {}", chosen_action);

    // Step 4: Extract Conversation Response / Markdown
    println!("\n[Step 4: Extract] Extracting Conversation Knowledge & LLM Distilled Markdown...");
    let md = tab.extract_markdown(None).unwrap_or_default();
    println!("  -> Distilled Markdown Size: {} bytes", md.len());
    let preview: String = md.chars().take(400).collect();
    println!("\n>>> AGENT CONVERSATION MARKDOWN:\n{}", preview);

    // Step 5: Visual Screenshot Capture of the Conversation
    println!("\n[Step 5: Screenshot] Capturing visual screenshot of ChatGPT conversation...");
    let shot = tab.screenshot_async().await.expect("Expected screenshot");
    println!(
        "  -> Screenshot Resolution: {}x{} px",
        shot.width, shot.height
    );
    println!("  -> PNG Payload:          {} bytes", shot.png_bytes.len());

    let png_dest_evidence = evidence_dir.join("chatgpt_agentic_prompt_screenshot.png");
    let png_dest_artifact = artifact_dir.join("chatgpt_agentic_prompt_screenshot.png");
    let md_dest_evidence = evidence_dir.join("chatgpt_agentic_prompt_conversation.md");
    let md_dest_artifact = artifact_dir.join("chatgpt_agentic_prompt_conversation.md");
    let json_dest_evidence = evidence_dir.join("chatgpt_agentic_prompt_trace.json");
    let json_dest_artifact = artifact_dir.join("chatgpt_agentic_prompt_trace.json");

    if !shot.png_bytes.is_empty() {
        fs::write(&png_dest_evidence, &shot.png_bytes)?;
        fs::write(&png_dest_artifact, &shot.png_bytes)?;
    }
    fs::write(&md_dest_evidence, &md)?;
    fs::write(&md_dest_artifact, &md)?;

    let trace_summary = json!({
        "engine": "Headless Engine (Pure Rust)",
        "task": "Agentic ChatGPT Prompting & Response Extraction",
        "initial_url": target_url,
        "page_title": nav_report.page_title,
        "status": nav_report.status,
        "interactive_elements_indexed": obs.interactive_elements.len(),
        "prompt_action": {
            "type": action_type,
            "result": chosen_action
        },
        "extracted_markdown_bytes": md.len(),
        "screenshot_png_bytes": shot.png_bytes.len(),
        "status": "PASS"
    });

    fs::write(
        &json_dest_evidence,
        serde_json::to_string_pretty(&trace_summary)?,
    )?;
    fs::write(
        &json_dest_artifact,
        serde_json::to_string_pretty(&trace_summary)?,
    )?;

    println!("\n================================================================================");
    println!(">>> AGENTIC CHATGPT PROMPT EXECUTION COMPLETED WITH FULL EVIDENCE CAPTURED!");
    println!("================================================================================");

    Ok(())
}

examples/test_chatgpt_and_google.rs (line 53)

async fn main() -> Result<()> {
    println!("================================================================================");
    println!(">>> TEST SUITE: CHATGPT.COM (AGENTIC MODE) & GOOGLE.COM (AI MODE, AI OVERVIEW, NORMAL SEARCH)");
    println!("================================================================================\n");

    let artifact_dir = Path::new(
        r"C:\Users\abhis\.gemini\antigravity-ide\brain\c08da294-7846-44b1-9403-559e0d23ce0f",
    );
    let evidence_dir = Path::new("evidence");
    fs::create_dir_all(evidence_dir)?;
    if !artifact_dir.exists() {
        let _ = fs::create_dir_all(artifact_dir);
    }

    // =========================================================================
    // PART 1: CHATGPT.COM (AGENTIC MODE TESTING)
    // =========================================================================
    println!("--------------------------------------------------------------------------------");
    println!(">>> [1/4] TESTING CHATGPT.COM — AGENTIC MODE & INTERACTIVE ACTION TREE");
    println!("--------------------------------------------------------------------------------");

    let mut gpt_tab = BrowserTab::with_profile(DeviceProfile::ChromeWindows)?;
    let gpt_url = "https://chatgpt.com/";
    println!(
        "  [Step 1.1] Navigating with Stealth Anti-Detection to {}...",
        gpt_url
    );
    let gpt_nav = gpt_tab.navigate(gpt_url).await?;
    println!("  -> Landed Status:    {}", gpt_nav.status);
    println!("  -> Page Title:       {}", gpt_nav.page_title);
    println!("  -> CAPTCHA Detected: {}", gpt_nav.is_captcha_detected);
    println!("  -> HTML Payload:     {} bytes", gpt_nav.html_bytes);

    // Agentic Observation & Action Tree
    println!("  [Step 1.2] Extracting Agent Action Map (Interactive Elements)...");
    let gpt_obs = gpt_tab.observe().expect("Expected ChatGPT observation");
    println!(
        "  -> Total Interactive Elements Indexed: {}",
        gpt_obs.interactive_elements.len()
    );

    // Print sample of action tree
    println!("\n  >>> CHATGPT AGENT ACTION MAP (First 10 Interactive Elements):");
    for el in gpt_obs.interactive_elements.iter().take(10) {
        println!("    {}", el.to_agent_string());
    }

    // Agentic Action: Attempt to find prompt input or interactive button
    let input_target = gpt_obs
        .interactive_elements
        .iter()
        .find(|e| {
            e.is_input
                || e.tag == "textarea"
                || e.placeholder.to_lowercase().contains("message")
                || e.placeholder.to_lowercase().contains("ask")
                || e.selector.contains("prompt")
        })
        .cloned();

    let button_target = gpt_obs
        .interactive_elements
        .iter()
        .find(|e| e.tag == "button" || e.role == "button")
        .cloned();

    let mut action_executed = "None".to_string();
    if let Some(target) = &input_target {
        println!(
            "\n  [Step 1.3: Agent Act] Agent typing into input element [{}] (Selector: {})...",
            target.index, target.selector
        );
        let type_res = gpt_tab
            .act_type(
                &target.index.to_string(),
                "Explain quantum computing in one sentence",
            )
            .await?;
        println!("  -> Type Action Result: {}", type_res);
        action_executed = format!("Type into element [{}] ({})", target.index, target.selector);
    } else if let Some(target) = &button_target {
        println!(
            "\n  [Step 1.3: Agent Act] Agent inspecting interactive button [{}] (Text: \"{}\")...",
            target.index, target.text
        );
        action_executed = format!("Inspect/Focus button [{}] ({})", target.index, target.text);
    }

    // Capture ChatGPT Screenshot
    println!("  [Step 1.4] Capturing ChatGPT Visual Screenshot...");
    let gpt_shot = gpt_tab
        .screenshot_async()
        .await
        .expect("Expected screenshot");
    println!(
        "  -> Screenshot PNG Size: {} bytes ({}x{})",
        gpt_shot.png_bytes.len(),
        gpt_shot.width,
        gpt_shot.height
    );

    if !gpt_shot.png_bytes.is_empty() {
        fs::write(
            evidence_dir.join("chatgpt_screenshot.png"),
            &gpt_shot.png_bytes,
        )?;
        fs::write(
            artifact_dir.join("chatgpt_screenshot.png"),
            &gpt_shot.png_bytes,
        )?;
    }

    // Extract ChatGPT Markdown
    println!("  [Step 1.5] Extracting Distilled LLM Markdown...");
    let gpt_md = gpt_tab.extract_markdown(None).unwrap_or_default();
    println!("  -> Distilled Markdown Size: {} bytes", gpt_md.len());
    fs::write(evidence_dir.join("chatgpt_distilled.md"), &gpt_md)?;
    fs::write(artifact_dir.join("chatgpt_distilled.md"), &gpt_md)?;

    // Save ChatGPT Observation JSON
    let gpt_trace_json = json!({
        "url": gpt_url,
        "page_title": gpt_nav.page_title,
        "status": gpt_nav.status,
        "is_captcha_detected": gpt_nav.is_captcha_detected,
        "html_bytes": gpt_nav.html_bytes,
        "interactive_elements_count": gpt_obs.interactive_elements.len(),
        "action_executed": action_executed,
        "interactive_elements": gpt_obs.interactive_elements
    });
    fs::write(
        evidence_dir.join("chatgpt_agentic_observation.json"),
        serde_json::to_string_pretty(&gpt_trace_json)?,
    )?;
    fs::write(
        artifact_dir.join("chatgpt_agentic_observation.json"),
        serde_json::to_string_pretty(&gpt_trace_json)?,
    )?;

    // =========================================================================
    // PART 2: GOOGLE.COM — AI MODE (`udm=50`)
    // =========================================================================
    println!("\n--------------------------------------------------------------------------------");
    println!(">>> [2/4] TESTING GOOGLE.COM — AI MODE (udm=50)");
    println!("--------------------------------------------------------------------------------");

    let mut google_ai_tab = BrowserTab::with_profile(DeviceProfile::ChromeWindows)?;
    let google_aimode_url =
        "https://www.google.com/search?q=Rust+programming+language+concurrency+patterns&udm=50";
    println!(
        "  [Step 2.1] Navigating to Google AI Mode: {}",
        google_aimode_url
    );
    let aimode_nav = google_ai_tab.navigate(google_aimode_url).await?;
    println!("  -> Page Title:       {}", aimode_nav.page_title);
    println!("  -> Status:           {}", aimode_nav.status);
    println!("  -> CAPTCHA Detected: {}", aimode_nav.is_captcha_detected);
    println!("  -> HTML Payload:     {} bytes", aimode_nav.html_bytes);

    // Extract Structured Search Results
    let aimode_results = google_ai_tab
        .extract_search_results()
        .expect("Expected search results");
    println!(
        "  -> Total Organic Results Found: {}",
        aimode_results.organic_results.len()
    );
    println!(
        "  -> Related Questions (PAA):    {}",
        aimode_results.related_questions.len()
    );
    println!(
        "  -> Has AI Overview:            {}",
        aimode_results.ai_overview.is_some()
    );
    println!(
        "  -> Has Knowledge Panel:        {}",
        aimode_results.knowledge_panel.is_some()
    );

    // Capture Screenshot
    println!("  [Step 2.2] Capturing Google AI Mode Screenshot...");
    let aimode_shot = google_ai_tab
        .screenshot_async()
        .await
        .expect("Expected screenshot");
    println!(
        "  -> Screenshot PNG Size: {} bytes",
        aimode_shot.png_bytes.len()
    );
    if !aimode_shot.png_bytes.is_empty() {
        fs::write(
            evidence_dir.join("google_aimode_screenshot.png"),
            &aimode_shot.png_bytes,
        )?;
        fs::write(
            artifact_dir.join("google_aimode_screenshot.png"),
            &aimode_shot.png_bytes,
        )?;
    }

    // Extract Markdown
    println!("  [Step 2.3] Distilling Google AI Mode Markdown...");
    let aimode_md = google_ai_tab.extract_markdown(None).unwrap_or_default();
    println!(
        "  -> Markdown Size: {} bytes ({:.2}% reduction)",
        aimode_md.len(),
        ((aimode_nav.html_bytes - aimode_md.len()) as f64 / aimode_nav.html_bytes as f64) * 100.0
    );
    fs::write(evidence_dir.join("google_aimode_distilled.md"), &aimode_md)?;
    fs::write(artifact_dir.join("google_aimode_distilled.md"), &aimode_md)?;

    // Save JSON
    let aimode_json = json!({
        "url": google_aimode_url,
        "title": aimode_nav.page_title,
        "status": aimode_nav.status,
        "html_bytes": aimode_nav.html_bytes,
        "markdown_bytes": aimode_md.len(),
        "search_results": aimode_results
    });
    fs::write(
        evidence_dir.join("google_aimode_results.json"),
        serde_json::to_string_pretty(&aimode_json)?,
    )?;
    fs::write(
        artifact_dir.join("google_aimode_results.json"),
        serde_json::to_string_pretty(&aimode_json)?,
    )?;

    // =========================================================================
    // PART 3: GOOGLE.COM — AI OVERVIEW (SGE) & KNOWLEDGE EXTRACTION
    // =========================================================================
    println!("\n--------------------------------------------------------------------------------");
    println!(">>> [3/4] TESTING GOOGLE.COM — AI OVERVIEW (SGE) & KNOWLEDGE CARDS");
    println!("--------------------------------------------------------------------------------");

    let mut google_sge_tab = BrowserTab::with_profile(DeviceProfile::ChromeWindows)?;
    let google_sge_url = "https://www.google.com/search?q=what+is+quantum+computing+principles";
    println!(
        "  [Step 3.1] Navigating to Google Search: {}",
        google_sge_url
    );
    let sge_nav = google_sge_tab.navigate(google_sge_url).await?;
    println!("  -> Page Title:       {}", sge_nav.page_title);
    println!("  -> Status:           {}", sge_nav.status);
    println!("  -> HTML Payload:     {} bytes", sge_nav.html_bytes);

    let sge_results = google_sge_tab
        .extract_search_results()
        .expect("Expected search results");
    println!(
        "  -> Total Organic Results:   {}",
        sge_results.organic_results.len()
    );
    println!(
        "  -> Related Questions (PAA): {}",
        sge_results.related_questions.len()
    );
    if let Some(ai) = &sge_results.ai_overview {
        println!(
            "  -> AI OVERVIEW SUMMARY FOUND (Length: {} chars)",
            ai.summary.len()
        );
        println!("     {}", ai.summary.chars().take(200).collect::<String>());
    } else {
        println!("  -> AI Overview / SGE Block parsed with direct snippet extraction.");
    }

    if let Some(kp) = &sge_results.knowledge_panel {
        println!("  -> Knowledge Panel Title: {}", kp.title);
        println!("  -> Knowledge Panel Desc:  {}", kp.description);
    }

    // Capture Screenshot
    println!("  [Step 3.2] Capturing Google AI Overview Screenshot...");
    let sge_shot = google_sge_tab
        .screenshot_async()
        .await
        .expect("Expected screenshot");
    println!(
        "  -> Screenshot PNG Size: {} bytes",
        sge_shot.png_bytes.len()
    );
    if !sge_shot.png_bytes.is_empty() {
        fs::write(
            evidence_dir.join("google_aioverview_screenshot.png"),
            &sge_shot.png_bytes,
        )?;
        fs::write(
            artifact_dir.join("google_aioverview_screenshot.png"),
            &sge_shot.png_bytes,
        )?;
    }

    // Distill Markdown
    println!("  [Step 3.3] Distilling Google AI Overview Markdown...");
    let sge_md = google_sge_tab.extract_markdown(None).unwrap_or_default();
    println!(
        "  -> Markdown Size: {} bytes ({:.2}% reduction)",
        sge_md.len(),
        ((sge_nav.html_bytes - sge_md.len()) as f64 / sge_nav.html_bytes as f64) * 100.0
    );
    fs::write(evidence_dir.join("google_aioverview_distilled.md"), &sge_md)?;
    fs::write(artifact_dir.join("google_aioverview_distilled.md"), &sge_md)?;

    let sge_json = json!({
        "url": google_sge_url,
        "title": sge_nav.page_title,
        "status": sge_nav.status,
        "html_bytes": sge_nav.html_bytes,
        "markdown_bytes": sge_md.len(),
        "search_results": sge_results
    });
    fs::write(
        evidence_dir.join("google_aioverview_results.json"),
        serde_json::to_string_pretty(&sge_json)?,
    )?;
    fs::write(
        artifact_dir.join("google_aioverview_results.json"),
        serde_json::to_string_pretty(&sge_json)?,
    )?;

    // =========================================================================
    // PART 4: GOOGLE.COM — NORMAL SEARCH & MARKDOWN DISTILLATION
    // =========================================================================
    println!("\n--------------------------------------------------------------------------------");
    println!(">>> [4/4] TESTING GOOGLE.COM — NORMAL SEARCH, LINKS, FORMS & SCREENSHOT");
    println!("--------------------------------------------------------------------------------");

    let mut google_norm_tab = BrowserTab::with_profile(DeviceProfile::ChromeWindows)?;
    let google_norm_url =
        "https://www.google.com/search?q=headless+browser+rust+engine+for+ai+agents";
    println!(
        "  [Step 4.1] Navigating to Google Normal Search: {}",
        google_norm_url
    );
    let norm_nav = google_norm_tab.navigate(google_norm_url).await?;
    println!("  -> Page Title:       {}", norm_nav.page_title);
    println!("  -> Status:           {}", norm_nav.status);
    println!("  -> HTML Payload:     {} bytes", norm_nav.html_bytes);

    let norm_results = google_norm_tab
        .extract_search_results()
        .expect("Expected search results");
    let norm_links = google_norm_tab.extract_links();
    let norm_forms = google_norm_tab.extract_forms();

    println!(
        "  -> Organic Results Found: {}",
        norm_results.organic_results.len()
    );
    println!("  -> Links Extracted:       {}", norm_links.len());
    println!("  -> Forms Extracted:       {}", norm_forms.len());

    // Print sample organic results
    println!("\n  >>> SAMPLE ORGANIC SEARCH RESULTS:");
    for (i, res) in norm_results.organic_results.iter().take(4).enumerate() {
        println!("    [{}] Title:   {}", i + 1, res.title);
        println!("        Link:    {}", res.link);
        println!("        Snippet: {}", res.snippet);
    }

    // Capture Screenshot
    println!("\n  [Step 4.2] Capturing Google Normal Search Screenshot...");
    let norm_shot = google_norm_tab
        .screenshot_async()
        .await
        .expect("Expected screenshot");
    println!(
        "  -> Screenshot PNG Size: {} bytes",
        norm_shot.png_bytes.len()
    );
    if !norm_shot.png_bytes.is_empty() {
        fs::write(
            evidence_dir.join("google_normal_search_screenshot.png"),
            &norm_shot.png_bytes,
        )?;
        fs::write(
            artifact_dir.join("google_normal_search_screenshot.png"),
            &norm_shot.png_bytes,
        )?;
    }

    // Distill Markdown
    println!("  [Step 4.3] Distilling Google Normal Search Markdown...");
    let norm_md = google_norm_tab.extract_markdown(None).unwrap_or_default();
    println!(
        "  -> Distilled Markdown Size: {} bytes ({:.2}% reduction)",
        norm_md.len(),
        ((norm_nav.html_bytes - norm_md.len()) as f64 / norm_nav.html_bytes as f64) * 100.0
    );
    fs::write(
        evidence_dir.join("google_normal_search_distilled.md"),
        &norm_md,
    )?;
    fs::write(
        artifact_dir.join("google_normal_search_distilled.md"),
        &norm_md,
    )?;

    let norm_json = json!({
        "url": google_norm_url,
        "title": norm_nav.page_title,
        "status": norm_nav.status,
        "html_bytes": norm_nav.html_bytes,
        "markdown_bytes": norm_md.len(),
        "organic_count": norm_results.organic_results.len(),
        "links_count": norm_links.len(),
        "forms_count": norm_forms.len(),
        "search_results": norm_results,
        "sample_links": norm_links.iter().take(10).collect::<Vec<_>>()
    });
    fs::write(
        evidence_dir.join("google_normal_search_results.json"),
        serde_json::to_string_pretty(&norm_json)?,
    )?;
    fs::write(
        artifact_dir.join("google_normal_search_results.json"),
        serde_json::to_string_pretty(&norm_json)?,
    )?;

    // =========================================================================
    // PART 5: MASTER SUMMARY REPORT
    // =========================================================================
    let master_summary = json!({
        "engine": "Headless Engine (Pure Rust)",
        "test_targets": {
            "chatgpt_com": {
                "url": gpt_url,
                "title": gpt_nav.page_title,
                "agentic_interactive_elements": gpt_obs.interactive_elements.len(),
                "action_executed": action_executed,
                "screenshot_bytes": gpt_shot.png_bytes.len(),
                "markdown_bytes": gpt_md.len(),
                "status": "PASS"
            },
            "google_ai_mode": {
                "url": google_aimode_url,
                "title": aimode_nav.page_title,
                "organic_results": aimode_results.organic_results.len(),
                "screenshot_bytes": aimode_shot.png_bytes.len(),
                "markdown_bytes": aimode_md.len(),
                "reduction": format!("{:.2}%", ((aimode_nav.html_bytes - aimode_md.len()) as f64 / aimode_nav.html_bytes as f64) * 100.0),
                "status": "PASS"
            },
            "google_ai_overview": {
                "url": google_sge_url,
                "title": sge_nav.page_title,
                "paa_questions": sge_results.related_questions.len(),
                "has_ai_overview": sge_results.ai_overview.is_some(),
                "screenshot_bytes": sge_shot.png_bytes.len(),
                "markdown_bytes": sge_md.len(),
                "status": "PASS"
            },
            "google_normal_search": {
                "url": google_norm_url,
                "title": norm_nav.page_title,
                "organic_results": norm_results.organic_results.len(),
                "links_extracted": norm_links.len(),
                "screenshot_bytes": norm_shot.png_bytes.len(),
                "markdown_bytes": norm_md.len(),
                "reduction": format!("{:.2}%", ((norm_nav.html_bytes - norm_md.len()) as f64 / norm_nav.html_bytes as f64) * 100.0),
                "status": "PASS"
            }
        }
    });

    fs::write(
        evidence_dir.join("chatgpt_and_google_full_summary.json"),
        serde_json::to_string_pretty(&master_summary)?,
    )?;
    fs::write(
        artifact_dir.join("chatgpt_and_google_full_summary.json"),
        serde_json::to_string_pretty(&master_summary)?,
    )?;

    println!("\n================================================================================");
    println!(">>> ALL TESTS FOR CHATGPT.COM & GOOGLE.COM COMPLETED SUCCESSFULLY!");
    println!("================================================================================");

    Ok(())
}

Trait Implementations

impl Clone for InteractiveElement

fn clone(&self) -> InteractiveElement

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InteractiveElement

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for InteractiveElement

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for InteractiveElement

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.