refactor: use envy crate for structured environment configuration (#3662)

* refactor: use envy crate for structured environment configuration

Extract environment configuration into dedicated `env.rs` modules for
each proxy crate (llm-proxy, transcribe-proxy, api-subscription) and
use serde deserialization via the envy crate.

This is a pure refactor with no behavior changes expected. The env
variables and their semantics remain identical.

* fix

Author: yujonglee

Cargo.lock

@@ -197,6 +197,7 @@ clap_mangen = "0.2"
 codes-iso-639 = "0.1.5"
 dirs = "6.0.0"
 dotenvy = "0.15.7"
+envy = "0.4"
 include_url_macro = "0.1.0"
 indoc = "2"
 isolang = "2.4"

Cargo.toml

@@ -22,6 +22,7 @@ serde_json = { workspace = true }
 url = { workspace = true }
 
 dotenvy = { workspace = true }
+envy = { workspace = true }
 jsonwebtoken = { workspace = true }
 sentry = { workspace = true, features = ["tower", "tower-axum-matched-path", "tracing"] }
 tower = { workspace = true }

apps/ai/Cargo.toml

@@ -1,82 +1,41 @@
-use std::collections::HashMap;
 use std::path::Path;
 use std::sync::OnceLock;
 
-use owhisper_client::Provider;
+use serde::Deserialize;
 
+fn default_port() -> u16 {
+    3001
+}
+
+fn filter_empty<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let s: Option<String> = Option::deserialize(deserializer)?;
+    Ok(s.filter(|s| !s.is_empty()))
+}
+
+#[derive(Deserialize)]
 pub struct Env {
+    #[serde(default = "default_port")]
     pub port: u16,
+    #[serde(default, deserialize_with = "filter_empty")]
     pub sentry_dsn: Option<String>,
+    #[serde(default, deserialize_with = "filter_empty")]
     pub posthog_api_key: Option<String>,
     pub supabase_url: String,
-    pub openrouter_api_key: String,
-    api_keys: HashMap<Provider, String>,
+
+    #[serde(flatten)]
+    pub llm: hypr_llm_proxy::Env,
+    #[serde(flatten)]
+    pub stt: hypr_transcribe_proxy::Env,
 }
 
 static ENV: OnceLock<Env> = OnceLock::new();
 
 pub fn env() -> &'static Env {
     ENV.get_or_init(|| {
         let _ = dotenvy::from_path(Path::new(env!("CARGO_MANIFEST_DIR")).join(".env"));
-        Env::from_env()
+        envy::from_env().expect("Failed to load environment")
     })
 }
-
-impl Env {
-    fn from_env() -> Self {
-        let providers = [
-            Provider::Deepgram,
-            Provider::AssemblyAI,
-            Provider::Soniox,
-            Provider::Fireworks,
-            Provider::OpenAI,
-            Provider::Gladia,
-        ];
-        let api_keys: HashMap<Provider, String> = providers
-            .into_iter()
-            .filter_map(|p| optional(p.env_key_name()).map(|key| (p, key)))
-            .collect();
-
-        Self {
-            port: parse_or("PORT", 3001),
-            sentry_dsn: optional("SENTRY_DSN"),
-            posthog_api_key: optional("POSTHOG_API_KEY"),
-            supabase_url: required("SUPABASE_URL"),
-            openrouter_api_key: required("OPENROUTER_API_KEY"),
-            api_keys,
-        }
-    }
-
-    pub fn api_keys(&self) -> HashMap<Provider, String> {
-        self.api_keys.clone()
-    }
-
-    pub fn configured_providers(&self) -> Vec<Provider> {
-        self.api_keys.keys().copied().collect()
-    }
-
-    pub fn log_configured_providers(&self) {
-        let providers: Vec<_> = self.configured_providers();
-        if providers.is_empty() {
-            tracing::warn!("no_stt_providers_configured");
-        } else {
-            let names: Vec<_> = providers.iter().map(|p| format!("{:?}", p)).collect();
-            tracing::info!(providers = ?names, "stt_providers_configured");
-        }
-    }
-}
-
-fn required(key: &str) -> String {
-    std::env::var(key).unwrap_or_else(|_| panic!("{key} is required"))
-}
-
-fn optional(key: &str) -> Option<String> {
-    std::env::var(key).ok().filter(|s| !s.is_empty())
-}
-
-fn parse_or<T: std::str::FromStr>(key: &str, default: T) -> T {
-    std::env::var(key)
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(default)
-}

apps/ai/src/env.rs

@@ -20,19 +20,20 @@ use env::env;
 pub use auth::DEVICE_FINGERPRINT_HEADER;
 
 fn app() -> Router {
+    let env = env();
+
     let analytics = {
         let mut builder = AnalyticsClientBuilder::default();
-        if let Some(key) = &env().posthog_api_key {
+        if let Some(key) = &env.posthog_api_key {
             builder = builder.with_posthog(key);
         }
         Arc::new(builder.build())
     };
 
-    let llm_config = hypr_llm_proxy::LlmProxyConfig::new(&env().openrouter_api_key)
-        .with_analytics(analytics.clone());
-    let stt_config =
-        hypr_transcribe_proxy::SttProxyConfig::new(env().api_keys()).with_analytics(analytics);
-    let auth_state = AuthState::new(&env().supabase_url);
+    let llm_config =
+        hypr_llm_proxy::LlmProxyConfig::new(&env.llm).with_analytics(analytics.clone());
+    let stt_config = hypr_transcribe_proxy::SttProxyConfig::new(&env.stt).with_analytics(analytics);
+    let auth_state = AuthState::new(&env.supabase_url);
 
     let protected_routes = Router::new()
         .merge(hypr_transcribe_proxy::listen_router(stt_config.clone()))
@@ -170,7 +171,7 @@ fn main() -> std::io::Result<()> {
         .with(sentry::integrations::tracing::layer())
         .init();
 
-    env.log_configured_providers();
+    hypr_transcribe_proxy::ApiKeys::from(&env.stt).log_configured_providers();
 
     tokio::runtime::Builder::new_multi_thread()
         .enable_all()

apps/ai/src/main.rs

@@ -0,0 +1,10 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Env {
+    pub supabase_url: String,
+    pub supabase_anon_key: String,
+    pub stripe_api_key: String,
+    pub stripe_monthly_price_id: String,
+    pub stripe_yearly_price_id: String,
+}

crates/api-subscription/src/env.rs

@@ -1,10 +1,12 @@
 mod config;
+mod env;
 mod error;
 mod routes;
 mod state;
 mod supabase;
 
 pub use config::SubscriptionConfig;
+pub use env::Env;
 pub use error::{Result, SubscriptionError};
 pub use routes::{openapi, router};
 pub use state::AppState;

crates/api-subscription/src/lib.rs

@@ -2,6 +2,7 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use crate::analytics::AnalyticsReporter;
+use crate::env::ApiKey;
 use crate::provider::{OpenRouterProvider, Provider};
 
 const DEFAULT_TIMEOUT_MS: u64 = 120_000;
@@ -35,9 +36,9 @@ pub struct LlmProxyConfig {
 }
 
 impl LlmProxyConfig {
-    pub fn new(api_key: impl Into<String>) -> Self {
+    pub fn new(api_key: impl Into<ApiKey>) -> Self {
         Self {
-            api_key: api_key.into(),
+            api_key: api_key.into().0,
             timeout: Duration::from_millis(DEFAULT_TIMEOUT_MS),
             models_tool_calling: vec![
                 "moonshotai/kimi-k2-0905:exacto".into(),

crates/llm-proxy/src/config.rs

@@ -0,0 +1,26 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Env {
+    pub openrouter_api_key: String,
+}
+
+pub struct ApiKey(pub String);
+
+impl From<&Env> for ApiKey {
+    fn from(env: &Env) -> Self {
+        Self(env.openrouter_api_key.clone())
+    }
+}
+
+impl From<&str> for ApiKey {
+    fn from(s: &str) -> Self {
+        Self(s.to_string())
+    }
+}
+
+impl From<String> for ApiKey {
+    fn from(s: String) -> Self {
+        Self(s)
+    }
+}

crates/llm-proxy/src/env.rs

@@ -1,12 +1,14 @@
 mod analytics;
 mod config;
+mod env;
 mod handler;
 mod openapi;
 pub mod provider;
 mod types;
 
 pub use analytics::{AnalyticsReporter, GenerationEvent};
 pub use config::*;
+pub use env::{ApiKey, Env};
 pub use handler::{chat_completions_router, router};
 pub use hypr_analytics::{AuthenticatedUserId, DeviceFingerprint};
 pub use openapi::openapi;