hyper_agent_client/

client.rs

use crate::error::ClientError;
use crate::types::*;
use hyper_agent_runtime::daemon;

pub struct HyperAgentClient {
    base_url: String,
    http: reqwest::Client,
    token: String,
}

impl HyperAgentClient {
    pub fn new(base_url: &str, token: &str) -> Self {
        Self {
            base_url: base_url.to_string(),
            http: reqwest::Client::new(),
            token: token.to_string(),
        }
    }

    pub fn from_port_file() -> Result<Self, ClientError> {
        let port = daemon::read_port().ok_or(ClientError::NotRunning)?;
        let token = daemon::read_token().ok_or(ClientError::NotRunning)?;
        Ok(Self::new(&format!("http://127.0.0.1:{}", port), &token))
    }

    // Management
    pub async fn health(&self) -> Result<HealthResponse, ClientError> {
        self.get("/health").await
    }

    pub async fn status(&self) -> Result<ServerStatus, ClientError> {
        self.get("/status").await
    }

    pub async fn shutdown(&self) -> Result<(), ClientError> {
        self.post_empty("/shutdown").await
    }

    // Strategy
    pub async fn run_strategy(&self, req: &RunStrategyRequest) -> Result<(), ClientError> {
        let _: serde_json::Value = self.post("/strategies/run", req).await?;
        Ok(())
    }

    pub async fn stop_strategy(&self, id: &str) -> Result<(), ClientError> {
        self.post_empty(&format!("/strategies/{}/stop", id)).await
    }

    pub async fn list_strategies(&self) -> Result<Vec<StrategyInfo>, ClientError> {
        self.get("/strategies").await
    }

    // Orders
    pub async fn place_order(&self, req: &PlaceOrderRequest) -> Result<OrderResponse, ClientError> {
        self.post("/orders", req).await
    }

    pub async fn cancel_order(&self, id: &str) -> Result<(), ClientError> {
        self.delete(&format!("/orders/{}", id)).await
    }

    pub async fn list_orders(&self) -> Result<Vec<PositionInfo>, ClientError> {
        self.get("/orders").await
    }

    // Positions
    pub async fn get_positions(&self) -> Result<Vec<PositionInfo>, ClientError> {
        self.get("/positions").await
    }

    pub async fn close_all(&self) -> Result<(), ClientError> {
        self.post_empty("/positions/close-all").await
    }

    // Agent history
    pub async fn agent_history(
        &self,
        agent_id: &str,
        limit: usize,
    ) -> Result<Vec<hyper_agent_ai::agent_loop::AgentLoopLog>, ClientError> {
        self.get(&format!("/agents/{}/history?limit={}", agent_id, limit))
            .await
    }

    // Agent adjustment history
    pub async fn agent_adjustments(
        &self,
        agent_id: &str,
        limit: usize,
    ) -> Result<Vec<hyper_agent_ai::adjustment_history::AdjustmentRecord>, ClientError> {
        self.get(&format!("/agents/{}/adjustments?limit={}", agent_id, limit))
            .await
    }

    // Dashboard
    pub async fn dashboard_stats(&self) -> Result<DashboardStats, ClientError> {
        self.get("/dashboard/stats").await
    }

    pub async fn pnl_history(&self) -> Result<Vec<PnlPoint>, ClientError> {
        self.get("/dashboard/pnl").await
    }

    pub async fn execution_quality(&self) -> Result<ExecutionQuality, ClientError> {
        self.get("/dashboard/execution-quality").await
    }

    // Risk
    pub async fn get_risk_exposure(&self) -> Result<serde_json::Value, ClientError> {
        self.get("/risk/exposure").await
    }

    pub async fn get_circuit_breaker(&self) -> Result<serde_json::Value, ClientError> {
        self.get("/risk/circuit-breaker").await
    }

    // HTTP helpers
    async fn get<T: serde::de::DeserializeOwned>(&self, path: &str) -> Result<T, ClientError> {
        let resp = self
            .http
            .get(format!("{}{}", self.base_url, path))
            .header("Authorization", format!("Bearer {}", self.token))
            .send()
            .await
            .map_err(ClientError::Http)?;
        if !resp.status().is_success() {
            let status = resp.status().as_u16();
            let text = resp.text().await.unwrap_or_default();
            return Err(ClientError::Server {
                status,
                message: text,
            });
        }
        resp.json().await.map_err(ClientError::Http)
    }

    async fn post<B: serde::Serialize, T: serde::de::DeserializeOwned>(
        &self,
        path: &str,
        body: &B,
    ) -> Result<T, ClientError> {
        let resp = self
            .http
            .post(format!("{}{}", self.base_url, path))
            .header("Authorization", format!("Bearer {}", self.token))
            .json(body)
            .send()
            .await
            .map_err(ClientError::Http)?;
        if !resp.status().is_success() {
            let status = resp.status().as_u16();
            let text = resp.text().await.unwrap_or_default();
            return Err(ClientError::Server {
                status,
                message: text,
            });
        }
        resp.json().await.map_err(ClientError::Http)
    }

    async fn post_empty(&self, path: &str) -> Result<(), ClientError> {
        let resp = self
            .http
            .post(format!("{}{}", self.base_url, path))
            .header("Authorization", format!("Bearer {}", self.token))
            .send()
            .await
            .map_err(ClientError::Http)?;
        if !resp.status().is_success() {
            let status = resp.status().as_u16();
            let text = resp.text().await.unwrap_or_default();
            return Err(ClientError::Server {
                status,
                message: text,
            });
        }
        Ok(())
    }

    async fn delete(&self, path: &str) -> Result<(), ClientError> {
        let resp = self
            .http
            .delete(format!("{}{}", self.base_url, path))
            .header("Authorization", format!("Bearer {}", self.token))
            .send()
            .await
            .map_err(ClientError::Http)?;
        if !resp.status().is_success() {
            let status = resp.status().as_u16();
            let text = resp.text().await.unwrap_or_default();
            return Err(ClientError::Server {
                status,
                message: text,
            });
        }
        Ok(())
    }
}

// Re-export ensure_daemon from core
pub use hyper_agent_runtime::client::ensure_daemon;