feat: add /health and /ready endpoints

crates/agentic-server/Cargo.toml

@@ -11,6 +11,7 @@ agentic-core = { path = "../agentic-core" }
 axum = "0.8"
 clap = { version = "4", features = ["derive", "env"] }
 http = "1"
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls"] }
 serde_json = "1"
 tokio = { version = "1", features = ["full"] }
 tower-http = { version = "0.6", features = ["cors"] }

crates/agentic-server/src/app.rs

@@ -1,11 +1,13 @@
 use agentic_core::proxy::ProxyState;
 use axum::Router;
-use axum::routing::post;
+use axum::routing::{get, post};
 
-use crate::handler::proxy_responses;
+use crate::handler::{health, proxy_responses, ready};
 
 pub fn build_router(state: ProxyState) -> Router {
     Router::new()
+        .route("/health", get(health))
+        .route("/ready", get(ready))
         .route("/v1/responses", post(proxy_responses))
         .with_state(state)
 }

crates/agentic-server/src/handler.rs

@@ -1,11 +1,52 @@
 use agentic_core::proxy::{ProxyBody, ProxyRequest, ProxyResponse, ProxyState, error_response};
 use axum::body::Body;
 use axum::extract::State;
-use axum::response::Response;
+use axum::response::{IntoResponse, Response};
 use http::StatusCode;
+use tracing::warn;
 
 const MAX_BODY_SIZE: usize = 10 * 1024 * 1024;
 
+pub async fn health() -> impl IntoResponse {
+    StatusCode::OK
+}
+
+pub async fn ready(State(state): State<ProxyState>) -> impl IntoResponse {
+    let base = state.config.llm_api_base.trim_end_matches('/');
+    let url = format!("{base}/health");
+
+    let mut headers = reqwest::header::HeaderMap::new();
+    if let Some(key) = state.config.openai_api_key.as_deref() {
+        let trimmed = key.trim();
+        if !trimmed.is_empty() {
+            if let Ok(v) = reqwest::header::HeaderValue::from_str(&format!("Bearer {trimmed}")) {
+                headers.insert(reqwest::header::AUTHORIZATION, v);
+            }
+        }
+    }
+
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(2))
+        .default_headers(headers)
+        .build();
+
+    let Ok(client) = client else {
+        return StatusCode::SERVICE_UNAVAILABLE;
+    };
+
+    match client.get(&url).send().await {
+        Ok(resp) if resp.status().is_success() => StatusCode::OK,
+        Ok(resp) => {
+            warn!("LLM backend not ready: status {}", resp.status());
+            StatusCode::SERVICE_UNAVAILABLE
+        }
+        Err(e) => {
+            warn!("LLM backend unreachable: {e}");
+            StatusCode::SERVICE_UNAVAILABLE
+        }
+    }
+}
+
 fn convert_response(resp: ProxyResponse) -> Response {
     let mut builder = Response::builder().status(resp.status);
     for (name, value) in &resp.headers {