ilo 0.8.2

ilo — a programming language for AI agents
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

pub mod http_provider;
#[cfg(feature = "tools")]
pub mod mcp_client;
#[cfg(feature = "tools")]
pub mod mcp_provider;

use crate::interpreter::Value;
use std::future::Future;
use std::pin::Pin;

#[derive(Debug, thiserror::Error)]
#[allow(dead_code)] // variants used when `tools` feature is enabled
pub enum ToolError {
    #[error("tool not configured: {0}")]
    NotConfigured(String),
    #[error("HTTP error calling '{0}': {1}")]
    Http(String, String),
    #[error("JSON error for tool '{0}': {1}")]
    Json(String, String),
    #[error("timeout calling tool '{0}'")]
    Timeout(String),
}

#[allow(dead_code)] // method used when `tools` feature is enabled
pub trait ToolProvider: Send + Sync {
    fn call(
        &self,
        name: &str,
        args: Vec<Value>,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ToolError>> + Send + '_>>;
}

#[allow(dead_code)] // used in tests and when the tools feature is enabled
pub struct StubProvider;

impl ToolProvider for StubProvider {
    fn call(
        &self,
        _name: &str,
        _args: Vec<Value>,
    ) -> Pin<Box<dyn Future<Output = Result<Value, ToolError>> + Send + '_>> {
        Box::pin(async { Ok(Value::Ok(Box::new(Value::Nil))) })
    }
}

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

    #[test]
    fn tool_error_display_not_configured() {
        let e = ToolError::NotConfigured("fetch".into());
        assert_eq!(e.to_string(), "tool not configured: fetch");
    }

    #[test]
    fn tool_error_display_http() {
        let e = ToolError::Http("fetch".into(), "connection refused".into());
        assert_eq!(e.to_string(), "HTTP error calling 'fetch': connection refused");
    }

    #[test]
    fn tool_error_display_json() {
        let e = ToolError::Json("fetch".into(), "invalid json".into());
        assert_eq!(e.to_string(), "JSON error for tool 'fetch': invalid json");
    }

    #[test]
    fn tool_error_display_timeout() {
        let e = ToolError::Timeout("fetch".into());
        assert_eq!(e.to_string(), "timeout calling tool 'fetch'");
    }

    #[test]
    fn stub_provider_returns_ok_nil() {
        let provider = StubProvider;
        let fut = provider.call("any", vec![]);
        let result = tokio::runtime::Builder::new_current_thread()
            .build()
            .unwrap()
            .block_on(fut);
        let Ok(Value::Ok(inner)) = result else { panic!("expected Ok(Ok(_))") };
        assert_eq!(*inner, Value::Nil);
    }
}