agent-fetch 0.1.10

A sandboxed HTTP client for AI agents with SSRF protection, domain policies, rate limiting, and resource controls
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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use agent_fetch::{FetchPolicy, FetchRequest, SafeClient};

#[tokio::test]
async fn rejects_private_ip_direct() {
    let client = SafeClient::new(FetchPolicy::default());
    let req = FetchRequest {
        url: "http://127.0.0.1/".into(),
        method: "GET".into(),
        headers: Default::default(),
        body: None,
    };
    let err = client.fetch(req).await.unwrap_err();
    assert!(
        err.to_string().contains("private IP blocked"),
        "expected private IP error, got: {err}"
    );
}

#[tokio::test]
async fn rejects_metadata_ip() {
    let client = SafeClient::new(FetchPolicy::default());
    let req = FetchRequest {
        url: "http://169.254.169.254/latest/meta-data/".into(),
        method: "GET".into(),
        headers: Default::default(),
        body: None,
    };
    let err = client.fetch(req).await.unwrap_err();
    assert!(
        err.to_string().contains("private IP blocked"),
        "expected private IP error, got: {err}"
    );
}

#[tokio::test]
async fn rejects_blocked_domain() {
    let policy = FetchPolicy {
        blocked_domains: vec![agent_fetch::DomainPattern("evil.com".into())],
        ..Default::default()
    };
    let client = SafeClient::new(policy);
    let req = FetchRequest {
        url: "https://evil.com/".into(),
        method: "GET".into(),
        headers: Default::default(),
        body: None,
    };
    let err = client.fetch(req).await.unwrap_err();
    assert!(err.to_string().contains("blocked"), "got: {err}");
}

#[tokio::test]
async fn rejects_domain_not_in_allowlist() {
    let policy = FetchPolicy {
        allowed_domains: Some(vec![agent_fetch::DomainPattern("good.com".into())]),
        ..Default::default()
    };
    let client = SafeClient::new(policy);
    let req = FetchRequest {
        url: "https://bad.com/".into(),
        method: "GET".into(),
        headers: Default::default(),
        body: None,
    };
    let err = client.fetch(req).await.unwrap_err();
    assert!(err.to_string().contains("allowlist"), "got: {err}");
}

#[tokio::test]
async fn rejects_disallowed_method() {
    let client = SafeClient::new(FetchPolicy::default());
    let req = FetchRequest {
        url: "https://example.com/".into(),
        method: "TRACE".into(),
        headers: Default::default(),
        body: None,
    };
    let err = client.fetch(req).await.unwrap_err();
    assert!(err.to_string().contains("method"), "got: {err}");
}

#[tokio::test]
async fn rejects_ftp_scheme() {
    let client = SafeClient::new(FetchPolicy::default());
    let req = FetchRequest {
        url: "ftp://example.com/file".into(),
        method: "GET".into(),
        headers: Default::default(),
        body: None,
    };
    let err = client.fetch(req).await.unwrap_err();
    assert!(
        err.to_string().contains("scheme"),
        "expected scheme error, got: {err}"
    );
}

#[tokio::test]
async fn rejects_oversized_request_body() {
    let policy = FetchPolicy {
        max_request_body_bytes: 100,
        ..Default::default()
    };
    let client = SafeClient::new(policy);
    let req = FetchRequest {
        url: "https://example.com/".into(),
        method: "POST".into(),
        headers: Default::default(),
        body: Some(vec![0u8; 200]),
    };
    let err = client.fetch(req).await.unwrap_err();
    assert!(
        err.to_string().contains("request body too large"),
        "got: {err}"
    );
}