llm-agent-runtime 1.74.0

Unified Tokio agent runtime -- orchestration, memory, knowledge graph, and ReAct loop in one crate
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Integration tests for built-in LLM providers using a local mock HTTP server.
//!
//! These tests verify request serialization and response deserialization for
//! `AnthropicProvider` and `OpenAiProvider` without making live API calls.
//! The wiremock crate is used to intercept HTTP traffic.

#[cfg(all(feature = "anthropic", feature = "openai"))]
mod provider_mock_tests {
    use llm_agent_runtime::providers::{AnthropicProvider, LlmProvider, OpenAiProvider};
    use wiremock::matchers::{header, method, path};
    use wiremock::{Mock, MockServer, ResponseTemplate};

    // ── AnthropicProvider ─────────────────────────────────────────────────────

    #[tokio::test]
    async fn anthropic_complete_sends_correct_request_and_parses_response() {
        let server = MockServer::start().await;

        Mock::given(method("POST"))
            .and(path("/v1/messages"))
            .and(header("x-api-key", "test-key"))
            .and(header("anthropic-version", "2023-06-01"))
            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                "content": [{ "type": "text", "text": "Hello from mock Anthropic!" }],
                "model": "claude-sonnet-4-6",
                "role": "assistant"
            })))
            .mount(&server)
            .await;

        let provider = AnthropicProvider::with_base_url(
            "test-key",
            format!("{}/v1/messages", server.uri()),
        );

        let result = provider
            .complete("Say hello", "claude-sonnet-4-6")
            .await
            .expect("complete() should succeed");

        assert_eq!(result, "Hello from mock Anthropic!");
    }

    #[tokio::test]
    async fn anthropic_complete_returns_error_on_non_200() {
        let server = MockServer::start().await;

        Mock::given(method("POST"))
            .and(path("/v1/messages"))
            .respond_with(ResponseTemplate::new(401).set_body_string("Unauthorized"))
            .mount(&server)
            .await;

        let provider = AnthropicProvider::with_base_url(
            "bad-key",
            format!("{}/v1/messages", server.uri()),
        );

        let result = provider.complete("test", "claude-sonnet-4-6").await;
        assert!(result.is_err(), "should fail on 401");
        let msg = result.unwrap_err().to_string();
        assert!(msg.contains("401"), "error should mention status code: {msg}");
    }

    #[tokio::test]
    async fn anthropic_complete_returns_error_when_content_missing() {
        let server = MockServer::start().await;

        // Response has no `content` array
        Mock::given(method("POST"))
            .and(path("/v1/messages"))
            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                "model": "claude-sonnet-4-6"
            })))
            .mount(&server)
            .await;

        let provider = AnthropicProvider::with_base_url(
            "test-key",
            format!("{}/v1/messages", server.uri()),
        );

        let result = provider.complete("test", "claude-sonnet-4-6").await;
        assert!(result.is_err(), "should fail when content array is absent");
    }

    // ── OpenAiProvider ────────────────────────────────────────────────────────

    #[tokio::test]
    async fn openai_complete_sends_correct_request_and_parses_response() {
        let server = MockServer::start().await;

        Mock::given(method("POST"))
            .and(path("/chat/completions"))
            .and(header("authorization", "Bearer test-openai-key"))
            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                "choices": [{
                    "message": { "role": "assistant", "content": "Hello from mock OpenAI!" },
                    "finish_reason": "stop"
                }]
            })))
            .mount(&server)
            .await;

        let provider = OpenAiProvider::with_base_url("test-openai-key", server.uri());

        let result = provider
            .complete("Say hello", "gpt-4o")
            .await
            .expect("complete() should succeed");

        assert_eq!(result, "Hello from mock OpenAI!");
    }

    #[tokio::test]
    async fn openai_complete_returns_error_on_non_200() {
        let server = MockServer::start().await;

        Mock::given(method("POST"))
            .and(path("/chat/completions"))
            .respond_with(ResponseTemplate::new(429).set_body_string("rate limited"))
            .mount(&server)
            .await;

        let provider = OpenAiProvider::with_base_url("test-key", server.uri());

        let result = provider.complete("test", "gpt-4o").await;
        assert!(result.is_err(), "should fail on 429");
        let msg = result.unwrap_err().to_string();
        assert!(msg.contains("429"), "error should mention status code: {msg}");
    }

    #[tokio::test]
    async fn openai_complete_returns_error_when_choices_empty() {
        let server = MockServer::start().await;

        Mock::given(method("POST"))
            .and(path("/chat/completions"))
            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
                "choices": []
            })))
            .mount(&server)
            .await;

        let provider = OpenAiProvider::with_base_url("test-key", server.uri());

        let result = provider.complete("test", "gpt-4o").await;
        assert!(result.is_err(), "should fail when choices array is empty");
    }
}