neuron-types 0.3.0

Core traits for AI agents in Rust — Provider, Tool, and ContextStrategy without the framework buy-in
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

use neuron_types::*;

/// A mock provider that always returns a fixed response.
struct MockProvider;

impl Provider for MockProvider {
    async fn complete(
        &self,
        _request: CompletionRequest,
    ) -> Result<CompletionResponse, ProviderError> {
        Ok(CompletionResponse {
            id: "mock_1".into(),
            model: "mock".into(),
            message: Message {
                role: Role::Assistant,
                content: vec![ContentBlock::Text("mock response".into())],
            },
            usage: TokenUsage::default(),
            stop_reason: StopReason::EndTurn,
        })
    }

    async fn complete_stream(
        &self,
        _request: CompletionRequest,
    ) -> Result<StreamHandle, ProviderError> {
        Err(ProviderError::Other("streaming not implemented".into()))
    }
}

#[tokio::test]
async fn mock_provider_complete() {
    let provider = MockProvider;
    let request = CompletionRequest {
        model: "mock".into(),
        messages: vec![Message {
            role: Role::User,
            content: vec![ContentBlock::Text("hi".into())],
        }],
        system: None,
        tools: vec![],
        max_tokens: None,
        temperature: None,
        top_p: None,
        stop_sequences: vec![],
        tool_choice: None,
        response_format: None,
        thinking: None,
        reasoning_effort: None,
        extra: None,
        context_management: None,
    };
    let response = provider.complete(request).await.unwrap();
    assert_eq!(response.id, "mock_1");
    assert_eq!(response.stop_reason, StopReason::EndTurn);
}

#[tokio::test]
async fn mock_provider_stream_returns_error() {
    let provider = MockProvider;
    let request = CompletionRequest {
        model: "mock".into(),
        messages: vec![],
        system: None,
        tools: vec![],
        max_tokens: None,
        temperature: None,
        top_p: None,
        stop_sequences: vec![],
        tool_choice: None,
        response_format: None,
        thinking: None,
        reasoning_effort: None,
        extra: None,
        context_management: None,
    };
    let err = provider.complete_stream(request).await.unwrap_err();
    assert!(err.to_string().contains("streaming not implemented"));
}