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
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 dashmap::DashMap;
use std::path::Path;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Instant;

use crate::proxy::token::types::ProxyToken;

pub(crate) fn remove_account(
    tokens: &DashMap<String, ProxyToken>,
    health_scores: &DashMap<String, f32>,
    rate_limit_tracker: &crate::proxy::rate_limit::RateLimitTracker,
    session_accounts: &DashMap<String, String>,
    preferred_account_id: &tokio::sync::RwLock<Option<String>>,
    account_id: &str,
) {
    if tokens.remove(account_id).is_some() {
        tracing::info!("[Proxy] Removed account {} from memory cache", account_id);
    }

    health_scores.remove(account_id);
    crate::proxy::token::rate::clear_rate_limit(rate_limit_tracker, account_id);
    session_accounts.retain(|_, v| v != account_id);

    if let Ok(mut preferred) = preferred_account_id.try_write() {
        if preferred.as_deref() == Some(account_id) {
            *preferred = None;
            tracing::info!(
                "[Proxy] Cleared preferred account status for {}",
                account_id
            );
        }
    }
}

pub(crate) async fn load_accounts(
    data_dir: &Path,
    tokens: &DashMap<String, ProxyToken>,
    current_index: &AtomicUsize,
    last_used_account: &tokio::sync::Mutex<Option<(String, Instant)>>,
    health_scores: &DashMap<String, f32>,
) -> Result<usize, String> {
    let accounts_dir = data_dir.join("accounts");

    if !accounts_dir.exists() {
        return Err(format!(
            "Account directory does not exist: {:?}",
            accounts_dir
        ));
    }

    tokens.clear();
    current_index.store(0, Ordering::SeqCst);
    {
        let mut last_used = last_used_account.lock().await;
        *last_used = None;
    }

    let entries = std::fs::read_dir(&accounts_dir)
        .map_err(|e| format!("Failed to read account directory: {}", e))?;

    let mut count = 0;
    for entry in entries {
        let entry = entry.map_err(|e| format!("Failed to read directory entry: {}", e))?;
        let path = entry.path();
        if path.extension().and_then(|s| s.to_str()) != Some("json") {
            continue;
        }

        match crate::proxy::token::loader::load_single_account(&path, health_scores).await {
            Ok(Some(token)) => {
                let account_id = token.account_id.clone();
                tokens.insert(account_id, token);
                count += 1;
            }
            Ok(None) => {}
            Err(e) => tracing::debug!("Failed to load account {:?}: {}", path, e),
        }
    }

    Ok(count)
}

pub(crate) async fn reload_account(
    data_dir: &Path,
    tokens: &DashMap<String, ProxyToken>,
    health_scores: &DashMap<String, f32>,
    rate_limit_tracker: &crate::proxy::rate_limit::RateLimitTracker,
    session_accounts: &DashMap<String, String>,
    preferred_account_id: &tokio::sync::RwLock<Option<String>>,
    account_id: &str,
) -> Result<(), String> {
    let path = data_dir
        .join("accounts")
        .join(format!("{}.json", account_id));
    if !path.exists() {
        return Err(format!("Account file does not exist: {:?}", path));
    }

    match crate::proxy::token::loader::load_single_account(&path, health_scores).await {
        Ok(Some(token)) => {
            tokens.insert(account_id.to_string(), token);
            crate::proxy::token::rate::clear_rate_limit(rate_limit_tracker, account_id);
            Ok(())
        }
        Ok(None) => {
            remove_account(
                tokens,
                health_scores,
                rate_limit_tracker,
                session_accounts,
                preferred_account_id,
                account_id,
            );
            Ok(())
        }
        Err(e) => Err(format!("Failed to sync account: {}", e)),
    }
}

pub(crate) async fn reload_all_accounts(
    data_dir: &Path,
    tokens: &DashMap<String, ProxyToken>,
    current_index: &AtomicUsize,
    last_used_account: &tokio::sync::Mutex<Option<(String, Instant)>>,
    health_scores: &DashMap<String, f32>,
    rate_limit_tracker: &crate::proxy::rate_limit::RateLimitTracker,
) -> Result<usize, String> {
    let count = load_accounts(
        data_dir,
        tokens,
        current_index,
        last_used_account,
        health_scores,
    )
    .await?;
    crate::proxy::token::rate::clear_all_rate_limits(rate_limit_tracker);
    Ok(count)
}