systemprompt-api 0.6.0

Axum-based HTTP server and API gateway for systemprompt.io AI governance infrastructure. Exposes governed agents, MCP, A2A, and admin endpoints with rate limiting and RBAC.
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

use axum::http::StatusCode;
use bytes::Bytes;
use systemprompt_ai::models::ai_request_record::AiRequestRecord;
use systemprompt_ai::repository::{
    AiRequestPayloadRepository, AiRequestRepository, UpsertPayloadParams,
};
use systemprompt_identifiers::{AiRequestId, UserId};
use systemprompt_runtime::AppContext;

use super::extract::RejectionPartial;

pub(super) async fn persist_rejection(
    ctx: &AppContext,
    ai_request_id: &AiRequestId,
    partial: &RejectionPartial,
    status: StatusCode,
    message: &str,
) {
    let repo = match AiRequestRepository::new(ctx.db_pool()) {
        Ok(r) => r,
        Err(e) => {
            tracing::warn!(error = %e, "rejection audit: repo unavailable");
            return;
        },
    };

    let record = build_rejection_record(ai_request_id, partial);
    write_rejection_record(&repo, ai_request_id, &record, status, message).await;

    if let Some(body) = partial.body.as_ref() {
        write_rejection_payload(ctx, ai_request_id, body).await;
    }
}

fn build_rejection_record(
    ai_request_id: &AiRequestId,
    partial: &RejectionPartial,
) -> AiRequestRecord {
    let user_id = partial
        .user_id
        .clone()
        .unwrap_or_else(|| UserId::new("anonymous"));
    let provider = partial
        .provider
        .clone()
        .unwrap_or_else(|| "unknown".to_string());
    let model = partial
        .model
        .clone()
        .unwrap_or_else(|| "unknown".to_string());

    let mut builder = AiRequestRecord::builder(ai_request_id.clone(), user_id)
        .provider(provider)
        .model(model)
        .streaming(partial.is_streaming);
    if let Some(t) = &partial.tenant_id {
        builder = builder.tenant_id(t.clone());
    }
    if let Some(s) = &partial.session_id {
        builder = builder.session_id(s.clone());
    }
    if let Some(t) = &partial.trace_id {
        builder = builder.trace_id(t.clone());
    }
    if let Some(mt) = partial.max_tokens {
        builder = builder.max_tokens(mt);
    }
    builder.build().unwrap_or_else(|e| {
        tracing::warn!(error = %e, "rejection audit: build failed");
        AiRequestRecord::minimal_fallback(ai_request_id.clone())
    })
}

async fn write_rejection_record(
    repo: &AiRequestRepository,
    ai_request_id: &AiRequestId,
    record: &AiRequestRecord,
    status: StatusCode,
    message: &str,
) {
    if let Err(e) = repo.insert_with_id(ai_request_id, record).await {
        tracing::warn!(error = %e, ai_request_id = %ai_request_id, "rejection audit: insert failed");
        return;
    }
    let err_msg = format!("HTTP {}: {message}", status.as_u16());
    if let Err(e) = repo.update_error(ai_request_id, &err_msg).await {
        tracing::warn!(error = %e, ai_request_id = %ai_request_id, "rejection audit: update_error failed");
    }
}

async fn write_rejection_payload(ctx: &AppContext, ai_request_id: &AiRequestId, body: &Bytes) {
    let payloads = match AiRequestPayloadRepository::new(ctx.db_pool()) {
        Ok(p) => p,
        Err(e) => {
            tracing::warn!(error = %e, "rejection audit: payload repo unavailable");
            return;
        },
    };
    let bytes_len = body.len().min(i32::MAX as usize) as i32;
    let body_json = serde_json::from_slice::<serde_json::Value>(body).ok();
    let excerpt = if body_json.is_none() {
        Some(String::from_utf8_lossy(body).to_string())
    } else {
        None
    };
    if let Err(e) = payloads
        .upsert_request(
            ai_request_id,
            UpsertPayloadParams {
                body: body_json.as_ref(),
                excerpt: excerpt.as_deref(),
                truncated: false,
                bytes: Some(bytes_len),
            },
        )
        .await
    {
        tracing::warn!(error = %e, ai_request_id = %ai_request_id, "rejection audit: payload insert failed");
    }
}