systemprompt-models 0.48.0

Foundation data models for systemprompt.io AI governance infrastructure. Shared DTOs, config, and domain types consumed by every layer of the MCP governance pipeline.
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

//! `OpenAI` Chat Completions wire codec.
//!
//! Builds an `OpenAI` Chat upstream request from a
//! [`crate::wire::canonical::CanonicalRequest`], parses the buffered reply into
//! a [`crate::wire::canonical::CanonicalResponse`], and maps SSE bytes to a
//! stream of [`crate::wire::canonical::CanonicalEvent`]s. Also serves
//! OpenAI-compatible providers exposing the same surface. Auth-header and
//! transport concerns stay with the gateway adapter; this module is pure wire
//! translation.
//!
//! Reasoning models bill internal reasoning from the same completion budget as
//! visible output, so a caller `max_tokens` — which on the inbound Anthropic
//! surface bounds only visible output — can be consumed entirely by reasoning
//! and trigger an upstream output-limit rejection. `output_token_ceiling`
//! therefore uses the full model-card cap as the budget for these families;
//! `is_reasoning_model` identifies them, either from the model card's
//! `limits.max_thinking_budget` or, for families that reason without one, from
//! a name prefix (`gpt-5*`, `o1*`, `o3*`, `o4*`). For
//! every other model it clamps the caller's `max_tokens` *down* to the cap when
//! one is known (never raising it) — keeping the upstream within the model's
//! real output limit and giving operators a per-request TPM lever via the
//! model card's `limits.max_output_tokens`. Both `OpenAI` codecs (Chat
//! Completions and Responses) share these.
//!
//! Copyright (c) systemprompt.io — Business Source License 1.1.
//! See <https://systemprompt.io> for licensing details.

mod request;
mod response;
mod stream_delta;
mod streaming;

pub use request::build_request_body;
pub use response::{buffered_defect, parse_response};
pub use streaming::sse_to_canonical_events;

use crate::services::ai::ModelLimits;
use crate::wire::canonical::CanonicalRequest;

// Why: Reasoning models charge thought tokens against the completion budget.
pub(crate) fn is_reasoning_model(model: &str, limits: Option<ModelLimits>) -> bool {
    const REASONING_PREFIXES: [&str; 4] = ["gpt-5", "o1", "o3", "o4"];
    if limits
        .and_then(|l| l.max_thinking_budget)
        .is_some_and(|b| b > 0)
    {
        return true;
    }
    REASONING_PREFIXES
        .iter()
        .any(|prefix| model.starts_with(prefix))
}

pub(crate) fn output_token_ceiling(
    request: &CanonicalRequest,
    upstream_model: &str,
    limits: Option<ModelLimits>,
) -> u32 {
    passthrough_output_tokens(request.max_tokens, upstream_model, limits)
}

#[must_use]
pub fn passthrough_output_tokens(
    requested: u32,
    upstream_model: &str,
    limits: Option<ModelLimits>,
) -> u32 {
    let max_output_tokens = limits.map(|l| l.max_output_tokens);
    match max_output_tokens {
        Some(cap) if cap > 0 && is_reasoning_model(upstream_model, limits) => cap,
        _ => super::clamp_output_tokens(requested, max_output_tokens),
    }
}