prodex 0.48.0

OpenAI profile pooling and safe auto-rotate for Codex CLI and Claude Code
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

use serde::{Deserialize, Serialize};
use std::path::PathBuf;

use super::SecretBackendKind;

pub(crate) const PRODEX_POLICY_FILE_NAME: &str = "policy.toml";
pub(crate) const PRODEX_POLICY_VERSION: u32 = 1;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "lowercase")]
pub(crate) enum RuntimeLogFormat {
    Text,
    Json,
}

impl RuntimeLogFormat {
    pub(crate) fn as_str(self) -> &'static str {
        match self {
            Self::Text => "text",
            Self::Json => "json",
        }
    }

    pub(crate) fn parse(value: &str) -> Option<Self> {
        match value.trim().to_ascii_lowercase().as_str() {
            "text" => Some(Self::Text),
            "json" => Some(Self::Json),
            _ => None,
        }
    }
}

#[derive(Debug, Clone, Serialize)]
pub(crate) struct RuntimePolicySummary {
    pub(crate) path: PathBuf,
    pub(crate) version: u32,
}

#[derive(Debug, Clone)]
pub(crate) struct RuntimePolicyConfig {
    pub(crate) path: PathBuf,
    pub(crate) version: u32,
    pub(crate) runtime: RuntimePolicyRuntimeSettings,
    pub(crate) runtime_proxy: RuntimePolicyProxySettings,
    pub(crate) secrets: RuntimePolicySecretsSettings,
}

#[derive(Debug, Clone, Default)]
pub(crate) struct RuntimePolicyRuntimeSettings {
    pub(crate) log_format: Option<RuntimeLogFormat>,
    pub(crate) log_dir: Option<PathBuf>,
}

#[derive(Debug, Clone, Default)]
pub(crate) struct RuntimePolicySecretsSettings {
    pub(crate) backend: Option<SecretBackendKind>,
    pub(crate) keyring_service: Option<String>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct RuntimePolicyProxySettings {
    pub(crate) worker_count: Option<usize>,
    pub(crate) long_lived_worker_count: Option<usize>,
    pub(crate) probe_refresh_worker_count: Option<usize>,
    pub(crate) async_worker_count: Option<usize>,
    pub(crate) long_lived_queue_capacity: Option<usize>,
    pub(crate) active_request_limit: Option<usize>,
    pub(crate) profile_inflight_soft_limit: Option<usize>,
    pub(crate) profile_inflight_hard_limit: Option<usize>,
    pub(crate) responses_active_limit: Option<usize>,
    pub(crate) compact_active_limit: Option<usize>,
    pub(crate) websocket_active_limit: Option<usize>,
    pub(crate) standard_active_limit: Option<usize>,
    pub(crate) http_connect_timeout_ms: Option<u64>,
    pub(crate) stream_idle_timeout_ms: Option<u64>,
    pub(crate) sse_lookahead_timeout_ms: Option<u64>,
    pub(crate) prefetch_backpressure_retry_ms: Option<u64>,
    pub(crate) prefetch_backpressure_timeout_ms: Option<u64>,
    pub(crate) prefetch_max_buffered_bytes: Option<usize>,
    pub(crate) websocket_connect_timeout_ms: Option<u64>,
    pub(crate) websocket_happy_eyeballs_delay_ms: Option<u64>,
    pub(crate) websocket_precommit_progress_timeout_ms: Option<u64>,
    pub(crate) broker_ready_timeout_ms: Option<u64>,
    pub(crate) broker_health_connect_timeout_ms: Option<u64>,
    pub(crate) broker_health_read_timeout_ms: Option<u64>,
    pub(crate) websocket_previous_response_reuse_stale_ms: Option<u64>,
    pub(crate) admission_wait_budget_ms: Option<u64>,
    pub(crate) pressure_admission_wait_budget_ms: Option<u64>,
    pub(crate) long_lived_queue_wait_budget_ms: Option<u64>,
    pub(crate) pressure_long_lived_queue_wait_budget_ms: Option<u64>,
    pub(crate) sync_probe_pressure_pause_ms: Option<u64>,
    pub(crate) responses_critical_floor_percent: Option<i64>,
    pub(crate) startup_sync_probe_warm_limit: Option<usize>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct RuntimePolicyFile {
    pub(crate) version: u32,
    #[serde(default)]
    pub(crate) runtime: RuntimePolicyRuntimeFile,
    #[serde(default)]
    pub(crate) runtime_proxy: RuntimePolicyProxySettings,
    #[serde(default)]
    pub(crate) secrets: RuntimePolicySecretsFile,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct RuntimePolicyRuntimeFile {
    pub(crate) log_format: Option<RuntimeLogFormat>,
    pub(crate) log_dir: Option<String>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct RuntimePolicySecretsFile {
    pub(crate) backend: Option<String>,
    pub(crate) keyring_service: Option<String>,
}