gephyr 1.16.18

Gephyr is a headless local AI relay/proxy API handling OpenAI, Claude, and Gemini-compatible APIs
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

use axum::{
    http::{HeaderMap, StatusCode},
    Json,
};
use serde::Serialize;

use super::audit;
use crate::proxy::admin::ErrorResponse;
use crate::proxy::state::AdminState;

pub(crate) type AdminError = (StatusCode, Json<ErrorResponse>);

#[derive(Debug, Clone, Copy, Serialize)]
#[serde(rename_all = "snake_case")]
pub(crate) enum RuntimeApplyPolicy {
    AlwaysHotApplied,
    HotAppliedWhenSafe,
    RequiresRestart,
}

#[derive(Debug, Clone, Serialize)]
pub(crate) struct RuntimeApplyResult {
    pub policy: RuntimeApplyPolicy,
    pub applied: bool,
    pub requires_restart: bool,
}

#[derive(Debug, Clone)]
pub(crate) struct ProxyPatchResult {
    pub actor: super::audit_event::ActorIdentity,
    pub before: crate::proxy::config::ProxyConfig,
    pub after: crate::proxy::config::ProxyConfig,
    pub runtime_apply_policy: RuntimeApplyPolicy,
}

impl ProxyPatchResult {
    pub(crate) fn runtime_apply_result(&self, applied: bool) -> RuntimeApplyResult {
        RuntimeApplyResult {
            policy: self.runtime_apply_policy,
            applied,
            requires_restart: matches!(
                self.runtime_apply_policy,
                RuntimeApplyPolicy::RequiresRestart
            ),
        }
    }
}

pub(crate) fn supported_runtime_apply_policies() -> [RuntimeApplyPolicy; 3] {
    [
        RuntimeApplyPolicy::AlwaysHotApplied,
        RuntimeApplyPolicy::HotAppliedWhenSafe,
        RuntimeApplyPolicy::RequiresRestart,
    ]
}

pub(crate) async fn patch_proxy_config<F>(
    state: &AdminState,
    headers: &HeaderMap,
    runtime_apply_policy: RuntimeApplyPolicy,
    patch_fn: F,
) -> Result<ProxyPatchResult, AdminError>
where
    F: FnOnce(&mut crate::proxy::config::ProxyConfig) -> Result<(), String>,
{
    let actor = audit::resolve_admin_actor(state, headers).await;
    let mut app_config =
        crate::modules::system::config::load_app_config().map_err(internal_error)?;
    let before = app_config.proxy.clone();

    patch_fn(&mut app_config.proxy).map_err(bad_request)?;

    if let Err(errors) = crate::modules::system::validation::validate_app_config(&app_config) {
        let message = errors
            .iter()
            .map(|e| e.to_string())
            .collect::<Vec<_>>()
            .join("\n");
        return Err(bad_request(message));
    }

    crate::modules::system::config::save_app_config(&app_config).map_err(internal_error)?;
    let after = app_config.proxy.clone();

    Ok(ProxyPatchResult {
        actor,
        before,
        after,
        runtime_apply_policy,
    })
}

pub(crate) fn bad_request(error: impl Into<String>) -> AdminError {
    (
        StatusCode::BAD_REQUEST,
        Json(ErrorResponse {
            error: error.into(),
        }),
    )
}

pub(crate) fn internal_error(error: impl Into<String>) -> AdminError {
    (
        StatusCode::INTERNAL_SERVER_ERROR,
        Json(ErrorResponse {
            error: error.into(),
        }),
    )
}