aiclient-api 0.1.0

A unified AI gateway daemon exposing OpenAI-compatible and Anthropic-compatible API endpoints, backed by GitHub Copilot and Kiro (AWS CodeWhisperer)
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

use aiclient_api::providers::OutputFormat;
use aiclient_api::util::error::AppError;
use axum::http::StatusCode;

// ---------------------------------------------------------------------------
// status_and_message
// ---------------------------------------------------------------------------

#[test]
fn test_status_and_message_unauthorized() {
    let err = AppError::Unauthorized("invalid token".into());
    let (status, message) = err.status_and_message();
    assert_eq!(status, StatusCode::UNAUTHORIZED);
    assert_eq!(message, "invalid token");
}

#[test]
fn test_status_and_message_unavailable() {
    let err = AppError::Unavailable("copilot is down".into());
    let (status, message) = err.status_and_message();
    assert_eq!(status, StatusCode::SERVICE_UNAVAILABLE);
    assert_eq!(message, "copilot is down");
}

#[test]
fn test_status_and_message_bad_request() {
    let err = AppError::BadRequest("missing model field".into());
    let (status, message) = err.status_and_message();
    assert_eq!(status, StatusCode::BAD_REQUEST);
    assert_eq!(message, "missing model field");
}

#[test]
fn test_status_and_message_rate_limited() {
    let err = AppError::RateLimited;
    let (status, _message) = err.status_and_message();
    assert_eq!(status, StatusCode::TOO_MANY_REQUESTS);
}

#[test]
fn test_status_and_message_upstream() {
    let err = AppError::Upstream {
        status: 502,
        body: "bad gateway from upstream".into(),
    };
    let (status, message) = err.status_and_message();
    assert_eq!(status, StatusCode::BAD_GATEWAY);
    assert_eq!(message, "bad gateway from upstream");
}

#[test]
fn test_status_and_message_provider() {
    let err = AppError::Provider(anyhow::anyhow!("something went wrong internally"));
    let (status, _message) = err.status_and_message();
    assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
}

// ---------------------------------------------------------------------------
// openai_error
// ---------------------------------------------------------------------------

#[tokio::test]
async fn test_openai_error_format() {
    let response = AppError::openai_error(StatusCode::UNAUTHORIZED, "bad key");
    let (parts, body) = response.into_parts();

    assert_eq!(parts.status, StatusCode::UNAUTHORIZED);

    let bytes = axum::body::to_bytes(body, 1024 * 1024).await.unwrap();
    let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();

    assert_eq!(json["error"]["message"], "bad key");
    assert_eq!(json["error"]["type"], "authentication_error");
    assert_eq!(json["error"]["code"], serde_json::Value::Null);
}

// ---------------------------------------------------------------------------
// anthropic_error
// ---------------------------------------------------------------------------

#[tokio::test]
async fn test_anthropic_error_format() {
    let response = AppError::anthropic_error(StatusCode::UNAUTHORIZED, "bad key");
    let (parts, body) = response.into_parts();

    assert_eq!(parts.status, StatusCode::UNAUTHORIZED);

    let bytes = axum::body::to_bytes(body, 1024 * 1024).await.unwrap();
    let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();

    assert_eq!(json["type"], "error");
    assert_eq!(json["error"]["type"], "authentication_error");
    assert_eq!(json["error"]["message"], "bad key");
}

// ---------------------------------------------------------------------------
// format_error
// ---------------------------------------------------------------------------

#[tokio::test]
async fn test_format_error_delegates_to_openai() {
    let response =
        AppError::format_error(StatusCode::BAD_REQUEST, "bad request", OutputFormat::OpenAI);
    let (parts, body) = response.into_parts();

    assert_eq!(parts.status, StatusCode::BAD_REQUEST);

    let bytes = axum::body::to_bytes(body, 1024 * 1024).await.unwrap();
    let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();

    // OpenAI format has a top-level "error" object
    assert!(json.get("error").is_some(), "expected top-level 'error' key");
    assert_eq!(json["error"]["type"], "invalid_request_error");
    assert_eq!(json["error"]["message"], "bad request");
    assert_eq!(json["error"]["code"], serde_json::Value::Null);
    // Anthropic's top-level "type" key must not be present
    assert!(json.get("type").is_none(), "unexpected 'type' key (Anthropic format)");
}

#[tokio::test]
async fn test_format_error_delegates_to_anthropic() {
    let response = AppError::format_error(
        StatusCode::SERVICE_UNAVAILABLE,
        "provider down",
        OutputFormat::Anthropic,
    );
    let (parts, body) = response.into_parts();

    assert_eq!(parts.status, StatusCode::SERVICE_UNAVAILABLE);

    let bytes = axum::body::to_bytes(body, 1024 * 1024).await.unwrap();
    let json: serde_json::Value = serde_json::from_slice(&bytes).unwrap();

    // Anthropic format has a top-level "type": "error"
    assert_eq!(json["type"], "error");
    assert_eq!(json["error"]["type"], "api_error");
    assert_eq!(json["error"]["message"], "provider down");
    // OpenAI's nested "code" key must not be present
    assert!(
        json["error"].get("code").is_none(),
        "unexpected 'code' key (OpenAI format)"
    );
}