af-agent 0.4.0

Stable Agent model, tool, inbox, and trusted-plugin contracts.
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
124
125
126

//! Unit coverage for ToolRegistry surfaces and the type-erased ChatModel impl.

use std::sync::Arc;

use async_trait::async_trait;
use serde_json::{json, Value};

use af_agent::{
    CancellationToken, ChatModel, RequestContext, Tool, ToolExecutionContext, ToolRegistry,
};
use af_llm::{ChatMessage, Choice, CompletionRequest, CompletionResponse, LlmError};

struct PingTool;

#[async_trait]
impl Tool for PingTool {
    fn name(&self) -> &str {
        "ping"
    }
    fn description(&self) -> &str {
        "returns pong"
    }
    fn parameters(&self) -> Value {
        json!({"type": "object"})
    }
    fn output_schema(&self) -> Value {
        json!({"type":"object","required":["reply"],"properties":{"reply":{"const":"pong"}}})
    }
    async fn call(&self, _args: Value) -> Result<Value, String> {
        Ok(json!({"reply": "pong"}))
    }
}

#[tokio::test]
async fn tool_registry_surfaces() {
    let mut reg = ToolRegistry::new();
    assert!(reg.is_empty());
    assert_eq!(reg.len(), 0);

    reg.register(Arc::new(PingTool)).unwrap();
    assert!(!reg.is_empty());
    assert_eq!(reg.len(), 1);
    assert!(reg.contains("ping"));
    assert!(!reg.contains("nope"));
    assert_eq!(reg.names(), ["ping"]);

    let allowed = reg.filtered(["ping"]);
    assert!(allowed.contains("ping"));
    let denied = reg.filtered(["ghost"]);
    assert!(denied.is_empty());
    assert!(format!("{reg:?}").contains("ping"));

    // specs expose the LLM-facing tool definitions
    let specs = reg.specs();
    assert_eq!(specs.len(), 1);

    // execute known + unknown
    let execution = ToolExecutionContext {
        request: RequestContext {
            tenant_id: "tenant".parse().unwrap(),
            subject_id: "subject".parse().unwrap(),
            roles: Default::default(),
            locale: "en".into(),
            request_id: "request".parse().unwrap(),
            entitlements: Default::default(),
        },
        session_id: "session".parse().unwrap(),
        run_id: "run".parse().unwrap(),
        step: 1,
        call_id: "call".parse().unwrap(),
        source_event_seq: 1,
        interaction_resolution: None,
        cancellation: CancellationToken::default(),
        deadline: std::time::Instant::now() + std::time::Duration::from_secs(1),
    };
    let ok = reg
        .execute_with_context("ping", &execution, json!({}))
        .await
        .unwrap();
    assert_eq!(ok["reply"], "pong");
    let err = reg
        .execute_with_context("ghost", &execution, json!({}))
        .await
        .unwrap_err();
    assert!(err.contains("unknown tool"));
    assert!(err.contains("Available:"));

    assert!(reg
        .execute_with_context("Notebookping", &execution, json!({}))
        .await
        .is_err());
}

struct FixedModel;

#[async_trait]
impl ChatModel for FixedModel {
    async fn complete_streaming(
        &self,
        _req: &CompletionRequest,
        delta_tx: tokio::sync::mpsc::UnboundedSender<(String, bool)>,
    ) -> Result<CompletionResponse, LlmError> {
        let _ = delta_tx.send(("ok".into(), false));
        Ok(CompletionResponse {
            id: "f".into(),
            choices: vec![Choice {
                index: 0,
                message: ChatMessage::assistant("ok"),
                finish_reason: None,
                output_blocks: Vec::new(),
            }],
            usage: None,
        })
    }
}

#[tokio::test]
async fn type_erased_chat_model_delegates() {
    let model: Arc<dyn ChatModel> = Arc::new(FixedModel);
    // exercise the `impl ChatModel for Arc<dyn ChatModel>` delegation
    let req = CompletionRequest::new("m", vec![ChatMessage::user("hi")]);
    let (delta_tx, mut delta_rx) = tokio::sync::mpsc::unbounded_channel();
    let resp = model.complete_streaming(&req, delta_tx).await.unwrap();
    assert_eq!(resp.first_content(), Some("ok"));
    assert_eq!(delta_rx.recv().await.unwrap(), ("ok".into(), false));
}