tiny-agent-rs 0.1.0

A lightweight, type-safe Rust agent library for LLM tool calling
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

use crate::tools::FunctionFactory;

/// Generate a planning prompt for the agent before tool execution
pub fn generate_planning_prompt(
    task: &str,
    available_tools: &[String],
    iteration: usize,
) -> String {
    let tools_list = if available_tools.is_empty() {
        "No tools available".to_string()
    } else {
        available_tools.join(", ")
    };

    if iteration == 1 {
        format!(
            "Task: {}\n\nAvailable tools: {}\n\nThink step-by-step about how to solve this task. What tools will you need? What's your approach?",
            task, tools_list
        )
    } else {
        format!(
            "Continuing task: {}\n\nIteration {}\nAvailable tools: {}\n\nBased on previous observations, what should be the next step?",
            task, iteration, tools_list
        )
    }
}

/// Extract tool names from FunctionFactory for planning context
pub fn get_tool_names(factory: &FunctionFactory) -> Vec<String> {
    factory
        .get_openai_tools()
        .iter()
        .filter_map(|tool| {
            tool.get("function")
                .and_then(|f| f.get("name"))
                .and_then(|n| n.as_str())
                .map(|s| s.to_string())
        })
        .collect()
}

/// Generate a simplified planning prompt that encourages direct tool use
pub fn generate_tool_planning_prompt(task: &str, factory: &FunctionFactory) -> String {
    let tool_descriptions: Vec<String> = factory
        .get_openai_tools()
        .iter()
        .filter_map(|tool| {
            let function = tool.get("function")?;
            let name = function.get("name")?.as_str()?;
            let description = function.get("description")?.as_str()?;
            Some(format!("- {}: {}", name, description))
        })
        .collect();

    if tool_descriptions.is_empty() {
        format!("Task: {}\n\nHow would you approach solving this?", task)
    } else {
        format!(
            "Task: {}\n\nAvailable tools:\n{}\n\nWhat's your plan to solve this task?",
            task,
            tool_descriptions.join("\n")
        )
    }
}

/// Check if a response indicates the agent is planning vs. executing
pub fn is_planning_response(content: &str) -> bool {
    let planning_indicators = [
        "plan", "approach", "strategy", "steps:", "first,", "then,", "finally,", "need to",
        "should", "will use",
    ];

    let content_lower = content.to_lowercase();
    planning_indicators
        .iter()
        .any(|indicator| content_lower.contains(indicator))
}

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

    #[test]
    fn test_generate_planning_prompt() {
        let tools = vec!["search".to_string(), "calculator".to_string()];
        let prompt = generate_planning_prompt("Calculate 2+2", &tools, 1);

        assert!(prompt.contains("Calculate 2+2"));
        assert!(prompt.contains("search, calculator"));
        assert!(prompt.contains("Think step-by-step"));
    }

    #[test]
    fn test_generate_planning_prompt_continuation() {
        let tools = vec!["search".to_string()];
        let prompt = generate_planning_prompt("Find info", &tools, 3);

        assert!(prompt.contains("Iteration 3"));
        assert!(prompt.contains("next step"));
    }

    #[test]
    fn test_empty_tools() {
        let tools: Vec<String> = vec![];
        let prompt = generate_planning_prompt("Task", &tools, 1);

        assert!(prompt.contains("No tools available"));
    }

    #[test]
    fn test_is_planning_response() {
        assert!(is_planning_response("My plan is to use the search tool"));
        assert!(is_planning_response(
            "First, I will search. Then, I will analyze."
        ));
        assert!(is_planning_response("I need to calculate the result"));
        assert!(!is_planning_response("The result is 42"));
        assert!(!is_planning_response("Done"));
    }

    #[test]
    fn test_tool_planning_prompt_empty() {
        let factory = FunctionFactory::new();
        let prompt = generate_tool_planning_prompt("Test task", &factory);

        assert!(prompt.contains("Test task"));
        assert!(prompt.contains("How would you approach"));
    }
}