patent 0.2.0

A prior-art search for your code ideas — has this dev tool already been shipped?
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

use patent::llm::Llm;
use patent::openai::OpenAi;
use serde_json::json;
use wiremock::matchers::{body_json_string, header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

fn chat_response(content: &str) -> serde_json::Value {
    json!({ "choices": [{ "message": { "role": "assistant", "content": content } }] })
}

#[tokio::test]
async fn generate_returns_message_content() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/chat/completions"))
        .respond_with(ResponseTemplate::new(200).set_body_json(chat_response("hi there")))
        .mount(&server)
        .await;

    let client = OpenAi::new(server.uri(), "gpt-4o-mini", None);
    assert_eq!(client.generate("say hi").await.unwrap(), "hi there");
}

#[tokio::test]
async fn generate_sends_model_and_user_message() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/chat/completions"))
        .and(body_json_string(
            json!({
                "model": "gpt-4o-mini",
                "messages": [{ "role": "user", "content": "say hi" }],
                "temperature": 0.0
            })
            .to_string(),
        ))
        .respond_with(ResponseTemplate::new(200).set_body_json(chat_response("ok")))
        .expect(1)
        .mount(&server)
        .await;

    OpenAi::new(server.uri(), "gpt-4o-mini", None)
        .generate("say hi")
        .await
        .unwrap();
}

#[tokio::test]
async fn generate_sends_bearer_auth_when_key_set() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/chat/completions"))
        .and(header("authorization", "Bearer sk-test"))
        .respond_with(ResponseTemplate::new(200).set_body_json(chat_response("ok")))
        .expect(1)
        .mount(&server)
        .await;

    OpenAi::new(server.uri(), "gpt-4o-mini", Some("sk-test".into()))
        .generate("hi")
        .await
        .unwrap();
}

#[tokio::test]
async fn generate_maps_connection_error_to_llm_unreachable() {
    let client = OpenAi::new("http://127.0.0.1:1", "gpt-4o-mini", None);
    let err = client.generate("hi").await.unwrap_err();
    assert!(
        matches!(err, patent::Error::LlmUnreachable(_)),
        "expected LlmUnreachable, got: {err:?}"
    );
}

#[tokio::test]
async fn generate_maps_http_error_to_llm_rejected() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/chat/completions"))
        .respond_with(
            ResponseTemplate::new(401)
                .set_body_json(json!({ "error": { "message": "Incorrect API key provided" } })),
        )
        .mount(&server)
        .await;

    let err = OpenAi::new(server.uri(), "gpt-4o-mini", None)
        .generate("hi")
        .await
        .unwrap_err();
    let patent::Error::LlmRejected(msg) = err else {
        panic!("expected LlmRejected, got: {err:?}");
    };
    assert!(
        msg.contains("Incorrect API key provided"),
        "should surface the API error message, got: {msg}"
    );
}

#[tokio::test]
async fn generate_maps_empty_choices_to_llm_rejected() {
    // A 200 with no usable content must degrade (recoverable), not abort the run.
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/chat/completions"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "choices": [] })))
        .mount(&server)
        .await;

    let err = OpenAi::new(server.uri(), "gpt-4o-mini", None)
        .generate("hi")
        .await
        .unwrap_err();
    assert!(
        matches!(err, patent::Error::LlmRejected(_)),
        "expected LlmRejected, got: {err:?}"
    );
}

#[tokio::test]
async fn generate_maps_non_json_success_body_to_llm_rejected() {
    // A proxy returning a 200 HTML page must degrade, not abort.
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/chat/completions"))
        .respond_with(ResponseTemplate::new(200).set_body_string("<html>proxy</html>"))
        .mount(&server)
        .await;

    let err = OpenAi::new(server.uri(), "gpt-4o-mini", None)
        .generate("hi")
        .await
        .unwrap_err();
    assert!(
        matches!(err, patent::Error::LlmRejected(_)),
        "expected LlmRejected, got: {err:?}"
    );
}