distri 0.3.7

Rust client for the Distri A2A agent platform
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::printer::{COLOR_GRAY, COLOR_GREEN, COLOR_RED, COLOR_RESET};
use crate::renderers::RESULT_PREFIX;
use distri_types::{Part, ToolResponse};

pub fn render_platform_tool(result: &ToolResponse) {
    let name = result.tool_name.as_str();
    let text = first_text(&result.parts);
    let data = first_data(&result.parts);

    match name {
        "load_skill" => {
            if let Some(d) = data {
                let skill_name = d.get("name").and_then(|v| v.as_str()).unwrap_or("?");
                let steps = d
                    .get("steps")
                    .and_then(|v| v.as_array())
                    .map(|a| a.len())
                    .unwrap_or(0);
                println!(
                    "{}{}Loaded \"{}\" ({} steps){}",
                    COLOR_GRAY, RESULT_PREFIX, skill_name, steps, COLOR_RESET
                );
            } else {
                render_one_liner(text, false);
            }
        }
        "run_skill_script" => {
            if false {
                render_one_liner(text, true);
            } else {
                println!("{}{}Done{}", COLOR_GRAY, RESULT_PREFIX, COLOR_RESET);
            }
        }
        "list_skills" => {
            let count = data
                .and_then(|d| d.as_array())
                .map(|a| a.len())
                .unwrap_or(0);
            println!(
                "{}{}Found {} skills{}",
                COLOR_GRAY, RESULT_PREFIX, count, COLOR_RESET
            );
        }
        "list_agents" => {
            let count = data
                .and_then(|d| d.as_array())
                .map(|a| a.len())
                .unwrap_or(0);
            println!(
                "{}{}Found {} agents{}",
                COLOR_GRAY, RESULT_PREFIX, count, COLOR_RESET
            );
        }
        "create_skill" => {
            let skill_name = data
                .and_then(|d| d.get("name").and_then(|v| v.as_str()))
                .unwrap_or("skill");
            println!(
                "{}{}Created \"{}\"{}",
                COLOR_GRAY, RESULT_PREFIX, skill_name, COLOR_RESET
            );
        }
        "delete_skill" => {
            println!("{}{}Deleted{}", COLOR_GRAY, RESULT_PREFIX, COLOR_RESET);
        }
        "write_to_storage" => {
            println!("{}{}Saved{}", COLOR_GRAY, RESULT_PREFIX, COLOR_RESET);
        }
        "read_from_storage" => {
            if let Some(t) = text {
                let lines = t.lines().count();
                println!(
                    "{}{}({} lines){}",
                    COLOR_GRAY, RESULT_PREFIX, lines, COLOR_RESET
                );
            } else {
                println!("{}{}Done{}", COLOR_GRAY, RESULT_PREFIX, COLOR_RESET);
            }
        }
        "tool_search" => {
            let count = data
                .and_then(|d| d.as_array())
                .map(|a| a.len())
                .unwrap_or(0);
            println!(
                "{}{}Found {} tools{}",
                COLOR_GRAY, RESULT_PREFIX, count, COLOR_RESET
            );
        }
        "inject_connection_env" => {
            if false {
                render_one_liner(text, true);
            } else {
                println!("{}{}Connected{}", COLOR_GREEN, RESULT_PREFIX, COLOR_RESET);
            }
        }
        _ => render_one_liner(text, false),
    }
}

fn first_text(parts: &[Part]) -> Option<&str> {
    parts.iter().find_map(|p| {
        if let Part::Text(t) = p {
            Some(t.as_str())
        } else {
            None
        }
    })
}

fn first_data(parts: &[Part]) -> Option<&serde_json::Value> {
    parts.iter().find_map(|p| {
        if let Part::Data(v) = p {
            Some(v)
        } else {
            None
        }
    })
}

fn render_one_liner(text: Option<&str>, is_error: bool) {
    let color = if is_error { COLOR_RED } else { COLOR_GRAY };
    match text {
        Some(t) => {
            let first_line = t.lines().next().unwrap_or("");
            let truncated = if first_line.len() > 100 {
                format!("{}...", &first_line[..100])
            } else {
                first_line.to_string()
            };
            println!("{}{}{}{}", color, RESULT_PREFIX, truncated, COLOR_RESET);
        }
        None => {
            println!("{}{}Done{}", COLOR_GRAY, RESULT_PREFIX, COLOR_RESET);
        }
    }
}