agent-first-http 0.12.0

Give your AI agent its own private browser — so it reads the real page, past logins and bot walls, without ever touching yours.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

//! Raw CDP client: a WebSocket transport with flattened-session
//! multiplexing for multi-attach.

pub mod session;
pub mod ws_client;

use serde_json::Value;

use crate::sdk::client::Client;
use crate::shared::error::Error;
use crate::shared::ids::TabId;

/// Builder for `Client::cdp(method)`.
pub struct CdpBuilder {
    pub(crate) client: Client,
    pub(crate) method: String,
    pub(crate) tab: Option<TabId>,
    pub(crate) params: Value,
    pub(crate) wait: Option<(String, std::time::Duration)>,
}

impl CdpBuilder {
    pub fn new(client: Client, method: impl Into<String>) -> Self {
        Self {
            client,
            method: method.into(),
            tab: None,
            params: Value::Object(Default::default()),
            wait: None,
        }
    }

    #[must_use]
    pub fn tab(mut self, tab: TabId) -> Self {
        self.tab = Some(tab);
        self
    }

    #[must_use]
    pub fn params(mut self, p: Value) -> Self {
        self.params = p;
        self
    }

    #[must_use]
    pub fn wait_for(mut self, event: impl Into<String>, timeout: std::time::Duration) -> Self {
        self.wait = Some((event.into(), timeout));
        self
    }

    /// Execute the CDP method on the Client's cached `/cdp` connection,
    /// optionally waiting for a follow-up event.
    pub async fn send(self) -> Result<Value, Error> {
        let conn = self.client.cdp_connection().await?;

        // If --tab was provided, attach to it via Target.attachToTarget so
        // the call lands on the right session. Without --tab we issue
        // browser-scoped methods (Browser.getVersion, Target.*, etc.).
        let session_id = if let Some(tab) = self.tab.as_ref() {
            Some(session::attach_to_target(&conn, tab.as_str()).await?)
        } else {
            None
        };

        let outcome = async {
            let result = conn
                .send(&self.method, &self.params, session_id.as_deref())
                .await?;

            if let Some((event, timeout)) = self.wait {
                let event_name = event.clone();
                let _ev = conn
                    .wait_event(timeout, move |ev| ev.method == event_name)
                    .await?;
            }
            Ok(result)
        }
        .await;

        if let Some(sid) = session_id.as_deref() {
            let _ = session::detach_from_target(&conn, sid).await;
        }
        outcome
    }
}