atman-runtime 1.5.0

atman flow execution runtime: evaluator, tool dispatch, provider dispatch, executor, memory stores
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

pub mod anthropic;
pub mod codex;
pub mod mock;
pub mod openai;

pub(crate) fn classify_attachment_error(status: u16, body: &str) -> Option<String> {
    if status == 413 {
        return Some("payload_too_large".into());
    }
    let lower = body.to_ascii_lowercase();
    let attachment_markers = [
        "image",
        "attachment",
        "media_type",
        "unsupported",
        "invalid image",
        "image_parse_error",
        "invalid_image_url",
        "request_too_large",
    ];
    let has_marker = attachment_markers.iter().any(|m| lower.contains(m));
    let is_size_signal = lower.contains("too large") || lower.contains("payload_too_large");
    if status == 400 && has_marker {
        return Some(pick_reason(&lower));
    }
    if is_size_signal {
        return Some("payload_too_large".into());
    }
    None
}

fn pick_reason(lower: &str) -> String {
    if lower.contains("invalid_image_url") {
        "invalid_image_url".into()
    } else if lower.contains("image_parse_error") {
        "image_parse_error".into()
    } else if lower.contains("unsupported") {
        "unsupported_media_type".into()
    } else if lower.contains("too large") {
        "payload_too_large".into()
    } else {
        "invalid_image".into()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn http_413_maps_to_payload_too_large() {
        let r = classify_attachment_error(413, "").unwrap();
        assert_eq!(r, "payload_too_large");
    }

    #[test]
    fn openai_invalid_image_url_recognized() {
        let body = r#"{"error":{"code":"invalid_image_url","message":"..."}}"#;
        let r = classify_attachment_error(400, body).unwrap();
        assert_eq!(r, "invalid_image_url");
    }

    #[test]
    fn anthropic_image_error_recognized() {
        let body = "unsupported media_type for image";
        let r = classify_attachment_error(400, body).unwrap();
        assert_eq!(r, "unsupported_media_type");
    }

    #[test]
    fn non_attachment_error_returns_none() {
        assert!(classify_attachment_error(500, "internal").is_none());
        assert!(classify_attachment_error(401, "unauthorized").is_none());
    }
}