llama-cpp-v3-agent-sdk 0.1.7

Agentic tool-use loop on top of llama-cpp-v3 — local LLM agents with built-in tools
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

use crate::error::AgentError;
use crate::tool::{Tool, ToolResult};

/// Find files matching a glob pattern.
pub struct GlobTool;

impl Tool for GlobTool {
    fn name(&self) -> &str {
        "glob"
    }

    fn description(&self) -> &str {
        "Find files matching a glob pattern. Returns a list of matching file paths. \
         Supports standard glob patterns like '**/*.rs', 'src/*.cpp', etc."
    }

    fn parameters_schema(&self) -> serde_json::Value {
        serde_json::json!({
            "type": "object",
            "properties": {
                "pattern": {
                    "type": "string",
                    "description": "Glob pattern to match files (e.g. '**/*.rs', 'src/**/*.cpp')"
                }
            },
            "required": ["pattern"]
        })
    }

    fn execute(&self, args: &serde_json::Value) -> Result<ToolResult, AgentError> {
        let pattern = args["pattern"].as_str().ok_or_else(|| AgentError::Tool {
            tool: "glob".to_string(),
            message: "Missing 'pattern' argument".to_string(),
        })?;

        match glob::glob(pattern) {
            Ok(paths) => {
                let mut results = Vec::new();
                let mut errors = 0;

                for entry in paths {
                    match entry {
                        Ok(path) => results.push(path.display().to_string()),
                        Err(_) => errors += 1,
                    }
                }

                if results.is_empty() {
                    return Ok(ToolResult::ok(format!(
                        "No files matched pattern '{}'",
                        pattern
                    )));
                }

                let mut output = format!("Found {} file(s) matching '{}':\n", results.len(), pattern);
                for path in &results {
                    output.push_str(&format!("  {}\n", path));
                }
                if errors > 0 {
                    output.push_str(&format!("({} entries could not be read)\n", errors));
                }

                Ok(ToolResult::ok(output))
            }
            Err(e) => Ok(ToolResult::err(format!(
                "Invalid glob pattern '{}': {}",
                pattern, e
            ))),
        }
    }

    fn requires_permission(&self) -> bool {
        false
    }
}