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
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

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

/// Search-and-replace editing in files.
pub struct EditFileTool;

impl Tool for EditFileTool {
    fn name(&self) -> &str {
        "edit"
    }

    fn description(&self) -> &str {
        "Edit a file by searching for an exact string and replacing it. \
         The 'old' string must match exactly (including whitespace). \
         Only the first occurrence is replaced unless 'all' is set to true."
    }

    fn parameters_schema(&self) -> serde_json::Value {
        serde_json::json!({
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "Path to the file to edit"
                },
                "old": {
                    "type": "string",
                    "description": "The exact text to search for"
                },
                "new": {
                    "type": "string",
                    "description": "The replacement text"
                },
                "all": {
                    "type": "boolean",
                    "description": "If true, replace all occurrences. Default: false."
                }
            },
            "required": ["path", "old", "new"]
        })
    }

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

        let old = args["old"].as_str().ok_or_else(|| AgentError::Tool {
            tool: "edit".to_string(),
            message: "Missing 'old' argument".to_string(),
        })?;

        let new = args["new"].as_str().ok_or_else(|| AgentError::Tool {
            tool: "edit".to_string(),
            message: "Missing 'new' argument".to_string(),
        })?;

        let replace_all = args["all"].as_bool().unwrap_or(false);

        let content = match std::fs::read_to_string(path) {
            Ok(c) => c,
            Err(e) => {
                return Ok(ToolResult::err(format!(
                    "Failed to read '{}': {}",
                    path, e
                )))
            }
        };

        if !content.contains(old) {
            return Ok(ToolResult::err(format!(
                "Search string not found in '{}'. Make sure the 'old' text matches exactly (including whitespace and newlines).",
                path
            )));
        }

        let (new_content, count) = if replace_all {
            let count = content.matches(old).count();
            (content.replace(old, new), count)
        } else {
            (content.replacen(old, new, 1), 1)
        };

        match std::fs::write(path, &new_content) {
            Ok(_) => Ok(ToolResult::ok(format!(
                "Replaced {} occurrence(s) in '{}'",
                count, path
            ))),
            Err(e) => Ok(ToolResult::err(format!(
                "Failed to write '{}': {}",
                path, e
            ))),
        }
    }

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