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

use std::io::IsTerminal;
use std::io::{self, Write};

use llm::{FunctionCall, ToolCall};

use crate::config::ToolExecutionMode;
use crate::tools::{ToolContext, ToolRegistry};

pub(super) struct ToolRunner {
    registry: ToolRegistry,
    context: ToolContext,
    execution_mode: ToolExecutionMode,
    stdin_is_tty: bool,
}

impl ToolRunner {
    pub(super) fn new(
        registry: ToolRegistry,
        context: ToolContext,
        execution_mode: ToolExecutionMode,
    ) -> Self {
        Self {
            registry,
            context,
            execution_mode,
            stdin_is_tty: io::stdin().is_terminal(),
        }
    }

    pub(super) fn execute(&self, calls: &[ToolCall]) -> anyhow::Result<Vec<ToolCall>> {
        let mut results = Vec::with_capacity(calls.len());
        for call in calls {
            results.push(self.execute_call(call)?);
        }
        Ok(results)
    }

    pub(super) fn print_calls(&self, calls: &[ToolCall]) {
        for call in calls {
            eprintln!("[tool] {} {}", call.function.name, call.id);
            eprintln!("{}", call.function.arguments);
        }
    }

    pub(super) fn print_results(&self, results: &[ToolCall]) {
        for result in results {
            eprintln!("[tool result] {} {}", result.function.name, result.id);
            eprintln!("{}", result.function.arguments);
        }
    }

    fn execute_call(&self, call: &ToolCall) -> anyhow::Result<ToolCall> {
        let decision = self.should_execute_tool(call)?;
        let (output, success) = match decision {
            ToolDecision::Execute => self.run_tool(call),
            ToolDecision::Decline(reason) => (reason, false),
        };
        Ok(tool_result_call(call, output, success))
    }

    fn should_execute_tool(&self, call: &ToolCall) -> anyhow::Result<ToolDecision> {
        match self.execution_mode {
            ToolExecutionMode::Always => Ok(ToolDecision::Execute),
            ToolExecutionMode::Never => Ok(ToolDecision::Decline("Tool execution disabled".into())),
            ToolExecutionMode::Ask => self.ask_for_approval(call),
        }
    }

    fn ask_for_approval(&self, call: &ToolCall) -> anyhow::Result<ToolDecision> {
        if !self.stdin_is_tty {
            return Ok(ToolDecision::Decline(
                "Tool execution requires approval".into(),
            ));
        }
        let approved = prompt_for_tool(call)?;
        if approved {
            Ok(ToolDecision::Execute)
        } else {
            Ok(ToolDecision::Decline("Tool execution declined".into()))
        }
    }

    fn run_tool(&self, call: &ToolCall) -> (String, bool) {
        match self
            .registry
            .execute(&call.function.name, &call.function.arguments, &self.context)
        {
            Ok(output) => (output, true),
            Err(err) => (format!("Tool error: {err}"), false),
        }
    }
}

enum ToolDecision {
    Execute,
    Decline(String),
}

fn tool_result_call(call: &ToolCall, output: String, success: bool) -> ToolCall {
    let call_type = if success {
        call.call_type.clone()
    } else {
        "function".to_string()
    };
    ToolCall {
        id: call.id.clone(),
        call_type,
        function: FunctionCall {
            name: call.function.name.clone(),
            arguments: output,
        },
    }
}

fn prompt_for_tool(call: &ToolCall) -> anyhow::Result<bool> {
    eprintln!("[tool approval] {} {}", call.function.name, call.id);
    eprintln!("{}", call.function.arguments);
    eprint!("Run tool? [y/N]: ");
    io::stderr().flush()?;
    let mut input = String::new();
    io::stdin().read_line(&mut input)?;
    Ok(matches!(input.trim(), "y" | "Y"))
}