llm 1.3.8

A Rust library unifying multiple LLM backends.
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

//! File read tool with indentation-aware mode.

#![allow(dead_code)]

mod indentation;
mod slice;
mod types;

use std::path::Path;
use std::sync::Arc;

use serde_json::Value;

use crate::tools::context::ToolContext;
use crate::tools::definition::{ToolDefinition, ToolParam};
use crate::tools::error::ToolError;

use indentation::read_indentation;
use slice::read_slice;
use types::{FileReadArgs, ReadMode};

/// Create the file_read tool definition.
#[must_use]
pub fn file_read_tool() -> ToolDefinition {
    ToolDefinition {
        name: "file_read",
        description: "Read a file with optional indentation-aware block extraction. \
                      Use mode='indentation' to extract code blocks based on indentation.",
        params: vec![
            ToolParam {
                name: "file_path",
                description: "Absolute path to the file to read.",
                param_type: "string",
                items: None,
            },
            ToolParam {
                name: "offset",
                description: "1-indexed line number to start from (default: 1).",
                param_type: "number",
                items: None,
            },
            ToolParam {
                name: "limit",
                description: "Maximum lines to return (default: 2000).",
                param_type: "number",
                items: None,
            },
            ToolParam {
                name: "mode",
                description: "Read mode: 'slice' (default) or 'indentation'.",
                param_type: "string",
                items: None,
            },
        ],
        required: vec!["file_path"],
        executor: Arc::new(execute_file_read),
    }
}

fn execute_file_read(_ctx: &ToolContext, args: Value) -> Result<String, ToolError> {
    let read_args: FileReadArgs =
        serde_json::from_value(args).map_err(|e| ToolError::InvalidArgs(e.to_string()))?;

    if read_args.offset == 0 {
        return Err(ToolError::RespondToModel(
            "offset must be a 1-indexed line number".to_string(),
        ));
    }

    if read_args.limit == 0 {
        return Err(ToolError::RespondToModel(
            "limit must be greater than zero".to_string(),
        ));
    }

    let path = Path::new(&read_args.file_path);
    if !path.is_absolute() {
        return Err(ToolError::RespondToModel(
            "file_path must be an absolute path".to_string(),
        ));
    }

    let result = match read_args.mode {
        ReadMode::Slice => read_slice(path, read_args.offset, read_args.limit),
        ReadMode::Indentation => {
            let opts = read_args.indentation.unwrap_or_default();
            read_indentation(path, read_args.offset, read_args.limit, opts)
        }
    }?;

    Ok(result.join("\n"))
}