hyper_agent_ai/tools/

mod.rs

use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

use hyper_exchange::ExchangeClient;
use hyper_risk::risk::{record_risk_alert, AccountState, OrderRequest, RiskGuard};
use motosan_chat_tool::{Tool, ToolContext, ToolDef, ToolResult, Value};

use hyper_agent_core::position_manager::PositionManager;

pub struct GetPositionsTool {
    position_manager: Arc<PositionManager>,
}

impl GetPositionsTool {
    pub fn new(position_manager: Arc<PositionManager>) -> Self {
        Self { position_manager }
    }
}

impl Tool for GetPositionsTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "get_positions".to_string(),
            description: "Get current open positions and account equity".to_string(),
            input_schema: serde_json::json!({"type": "object", "properties": {}}),
        }
    }

    fn call(
        &self,
        _args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        let pm = self.position_manager.clone();
        Box::pin(async move {
            match pm.list_open().await {
                Ok(positions) => {
                    let count = positions.len();
                    let pos_json: Vec<serde_json::Value> = positions
                        .iter()
                        .map(|p| {
                            serde_json::json!({
                                "id": p.id,
                                "market": p.market,
                                "side": p.side,
                                "size": p.size,
                                "entry_price": p.entry_price,
                                "current_price": p.current_price,
                                "pnl": p.pnl,
                                "mode": p.mode,
                            })
                        })
                        .collect();
                    ToolResult::json(serde_json::json!({"positions": pos_json, "count": count}))
                }
                Err(e) => ToolResult::error(format!("Failed to list positions: {}", e)),
            }
        })
    }
}

pub struct PlaceOrderTool {
    risk_guard: RiskGuard,
    account_state: AccountState,
}

impl PlaceOrderTool {
    pub fn new(risk_guard: RiskGuard, account_state: AccountState) -> Self {
        Self {
            risk_guard,
            account_state,
        }
    }
}

impl Tool for PlaceOrderTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "place_order".to_string(),
            description: "Submit a place order request".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "asset": {"type": "number"},
                    "is_buy": {"type": "boolean"},
                    "price": {"type": ["string", "number"]},
                    "size": {"type": ["string", "number"]}
                },
                "required": ["asset", "is_buy", "price", "size"]
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let order_req = order_request_from_args(&args);
            match self.risk_guard.check_order(&order_req, &self.account_state) {
                Ok(()) => ToolResult::json(serde_json::json!({
                    "status": "accepted",
                    "request": args,
                })),
                Err(violation) => {
                    record_risk_alert(&violation);
                    ToolResult::error(violation.to_string())
                }
            }
        })
    }
}

pub struct CancelOrderTool {
    risk_guard: RiskGuard,
    account_state: AccountState,
}

impl CancelOrderTool {
    pub fn new(risk_guard: RiskGuard, account_state: AccountState) -> Self {
        Self {
            risk_guard,
            account_state,
        }
    }
}

impl Tool for CancelOrderTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "cancel_order".to_string(),
            description: "Cancel an existing order by id".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {"order_id": {"type": ["string", "number"]}},
                "required": ["order_id"]
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let synthetic_request = OrderRequest {
                symbol: "unknown".to_string(),
                side: "sell".to_string(),
                size: 0.0,
                price: 0.0,
            };
            match self
                .risk_guard
                .check_order(&synthetic_request, &self.account_state)
            {
                Ok(()) => ToolResult::json(serde_json::json!({
                    "status": "accepted",
                    "request": args,
                })),
                Err(violation) => {
                    record_risk_alert(&violation);
                    ToolResult::error(violation.to_string())
                }
            }
        })
    }
}

pub struct DoNothingTool;

impl Tool for DoNothingTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "do_nothing".to_string(),
            description: "Return hold/no-action decision".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {"reason": {"type": "string"}}
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            ToolResult::json(serde_json::json!({
                "status": "noop",
                "reason": args.get("reason").and_then(|v| v.as_str()).unwrap_or("No action")
            }))
        })
    }
}

pub struct SetStopLossTool;

impl Tool for SetStopLossTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "set_stop_loss".to_string(),
            description: "Set a stop-loss trigger on an existing position. Triggers a market close when the price reaches the specified trigger price.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Trading pair symbol, e.g. BTC-PERP"},
                    "trigger_price": {"type": "number", "description": "Price at which the stop-loss triggers"}
                },
                "required": ["symbol", "trigger_price"]
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let symbol = args
                .get("symbol")
                .and_then(|v| v.as_str())
                .unwrap_or("unknown");
            let trigger_price = args
                .get("trigger_price")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.0);
            ToolResult::json(serde_json::json!({
                "status": "accepted",
                "trigger_type": "stop_loss",
                "symbol": symbol,
                "trigger_price": trigger_price
            }))
        })
    }
}

pub struct SetTakeProfitTool;

impl Tool for SetTakeProfitTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "set_take_profit".to_string(),
            description: "Set a take-profit trigger on an existing position. Triggers a market close when the price reaches the specified trigger price.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Trading pair symbol, e.g. BTC-PERP"},
                    "trigger_price": {"type": "number", "description": "Price at which the take-profit triggers"}
                },
                "required": ["symbol", "trigger_price"]
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let symbol = args
                .get("symbol")
                .and_then(|v| v.as_str())
                .unwrap_or("unknown");
            let trigger_price = args
                .get("trigger_price")
                .and_then(|v| v.as_f64())
                .unwrap_or(0.0);
            ToolResult::json(serde_json::json!({
                "status": "accepted",
                "trigger_type": "take_profit",
                "symbol": symbol,
                "trigger_price": trigger_price
            }))
        })
    }
}

pub struct GetOpenOrdersTool {
    is_mainnet: bool,
}

impl GetOpenOrdersTool {
    pub fn new(is_mainnet: bool) -> Self {
        Self { is_mainnet }
    }
}

impl Tool for GetOpenOrdersTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "get_open_orders".to_string(),
            description: "List all open (pending/resting) orders. Optionally filter by a specific trading pair symbol. Returns order details including price, size, side, and order ID.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Optional trading pair symbol to filter by, e.g. BTC-PERP"}
                }
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let symbol_filter = args.get("symbol").and_then(|v| v.as_str());
            match fetch_open_orders(symbol_filter, self.is_mainnet).await {
                Ok(info) => ToolResult::json(info),
                Err(e) => ToolResult::error(format!("Failed to fetch open orders: {}", e)),
            }
        })
    }
}

/// Fetch open orders from Hyperliquid public API.
///
/// Requires a user address. Since this tool runs inside the agent loop,
/// we return a placeholder result. The real execution happens in `execute_tool`.
pub async fn fetch_open_orders(
    symbol_filter: Option<&str>,
    _is_mainnet: bool,
) -> Result<serde_json::Value, String> {
    // This is a stub — actual exchange queries require the user address,
    // which is resolved at the agent_loop / execute_tool level.
    // The tool definition is used by the LLM; execution is handled by execute_tool.
    Ok(serde_json::json!({
        "orders": [],
        "symbol_filter": symbol_filter,
        "message": "Open orders query accepted"
    }))
}

pub struct CloseAllPositionsTool;

impl Tool for CloseAllPositionsTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "close_all_positions".to_string(),
            description: "Emergency: close ALL open positions immediately with market orders. Use when circuit breaker triggers or emergency situations arise.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "reason": {"type": "string", "description": "Reason for the emergency close"}
                },
                "required": ["reason"]
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let reason = args
                .get("reason")
                .and_then(|v| v.as_str())
                .unwrap_or("emergency");
            ToolResult::json(serde_json::json!({
                "status": "accepted",
                "action": "close_all_positions",
                "reason": reason
            }))
        })
    }
}

pub struct GetFundingRateTool {
    is_mainnet: bool,
}

impl GetFundingRateTool {
    pub fn new(is_mainnet: bool) -> Self {
        Self { is_mainnet }
    }
}

impl Tool for GetFundingRateTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "get_funding_rate".to_string(),
            description: "Get current funding rate for a perpetual contract symbol. Use to assess overnight holding cost.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Trading pair symbol, e.g. BTC-PERP"}
                },
                "required": ["symbol"]
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let symbol = match args.get("symbol").and_then(|v| v.as_str()) {
                Some(s) => s,
                None => return ToolResult::error("Missing required parameter: symbol"),
            };

            match fetch_funding_rate(symbol, self.is_mainnet).await {
                Ok(info) => ToolResult::json(info),
                Err(e) => ToolResult::error(format!("Failed to fetch funding rate: {}", e)),
            }
        })
    }
}

/// Fetch the current funding rate for a symbol from Hyperliquid public API.
///
/// Returns a JSON value with funding rate details.
pub async fn fetch_funding_rate(
    symbol: &str,
    is_mainnet: bool,
) -> Result<serde_json::Value, String> {
    let client = ExchangeClient::new(is_mainnet);

    // Hyperliquid uses the metaAndAssetCtxs endpoint to get funding rates
    let request = serde_json::json!({
        "type": "metaAndAssetCtxs"
    });

    let response = client
        .post_info(request)
        .await
        .map_err(|e| format!("API error: {}", e))?;

    // Parse the response: [metaObj, [assetCtx, ...]]
    let arr = response
        .as_array()
        .ok_or_else(|| "Invalid response format".to_string())?;

    if arr.len() < 2 {
        return Err("Incomplete response from API".to_string());
    }

    let meta_obj = &arr[0];
    let asset_ctxs = arr[1]
        .as_array()
        .ok_or_else(|| "Invalid asset contexts format".to_string())?;

    let universe = meta_obj
        .get("universe")
        .and_then(|u| u.as_array())
        .ok_or_else(|| "Missing universe in meta".to_string())?;

    // Strip suffix to get coin name
    let coin = symbol
        .replace("-PERP", "")
        .replace("-USDC", "")
        .replace("-USD", "");

    let idx = universe
        .iter()
        .position(|item| item.get("name").and_then(|n| n.as_str()) == Some(&coin))
        .ok_or_else(|| format!("Symbol {} not found", symbol))?;

    if idx >= asset_ctxs.len() {
        return Err(format!("Asset context not found for {}", symbol));
    }

    let ctx = &asset_ctxs[idx];

    let funding_rate = ctx
        .get("funding")
        .and_then(|v| v.as_str())
        .and_then(|s| s.parse::<f64>().ok())
        .unwrap_or(0.0);

    let mark_price = ctx
        .get("markPx")
        .and_then(|v| v.as_str())
        .and_then(|s| s.parse::<f64>().ok())
        .unwrap_or(0.0);

    let open_interest = ctx
        .get("openInterest")
        .and_then(|v| v.as_str())
        .and_then(|s| s.parse::<f64>().ok())
        .unwrap_or(0.0);

    // Annualized rate: funding is per 8h, so multiply by 3*365
    let annualized_rate = funding_rate * 3.0 * 365.0;

    Ok(serde_json::json!({
        "symbol": symbol,
        "funding_rate": funding_rate,
        "funding_rate_pct": format!("{:.4}%", funding_rate * 100.0),
        "annualized_rate_pct": format!("{:.2}%", annualized_rate * 100.0),
        "mark_price": mark_price,
        "open_interest": open_interest,
        "direction": if funding_rate > 0.0 { "longs_pay_shorts" } else if funding_rate < 0.0 { "shorts_pay_longs" } else { "neutral" }
    }))
}

pub struct GetMarketDataTool {
    is_mainnet: bool,
}

impl GetMarketDataTool {
    pub fn new(is_mainnet: bool) -> Self {
        Self { is_mainnet }
    }
}

impl Tool for GetMarketDataTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "get_market_data".to_string(),
            description: "Get orderbook (bids/asks) for a symbol. Use to check spread and liquidity before placing limit orders.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Trading pair symbol, e.g. BTC-PERP"},
                    "depth": {"type": "integer", "description": "Number of orderbook levels to return (default 5)"}
                },
                "required": ["symbol"]
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let symbol = match args.get("symbol").and_then(|v| v.as_str()) {
                Some(s) => s,
                None => return ToolResult::error("Missing required parameter: symbol"),
            };
            let depth = args.get("depth").and_then(|v| v.as_u64()).unwrap_or(5) as usize;

            match fetch_market_data(symbol, depth, self.is_mainnet).await {
                Ok(info) => ToolResult::json(info),
                Err(e) => ToolResult::error(format!("Failed to fetch market data: {}", e)),
            }
        })
    }
}

/// Fetch L2 orderbook data for a symbol from Hyperliquid public API.
///
/// Returns top bids/asks and the spread. `depth` controls how many levels to return.
pub async fn fetch_market_data(
    symbol: &str,
    depth: usize,
    is_mainnet: bool,
) -> Result<serde_json::Value, String> {
    let client = ExchangeClient::new(is_mainnet);

    // Strip suffix to get coin name for the API
    let coin = symbol
        .replace("-PERP", "")
        .replace("-USDC", "")
        .replace("-USD", "");

    let request = serde_json::json!({
        "type": "l2Book",
        "coin": coin
    });

    let response = client
        .post_info(request)
        .await
        .map_err(|e| format!("API error: {}", e))?;

    // Parse the L2 book response: {"levels": [[{px, sz, n}, ...], [{px, sz, n}, ...]]}
    let levels = response
        .get("levels")
        .and_then(|l| l.as_array())
        .ok_or_else(|| "Invalid L2 book response format".to_string())?;

    if levels.len() < 2 {
        return Err("Incomplete L2 book response".to_string());
    }

    let raw_bids = levels[0]
        .as_array()
        .ok_or_else(|| "Invalid bids format".to_string())?;
    let raw_asks = levels[1]
        .as_array()
        .ok_or_else(|| "Invalid asks format".to_string())?;

    let depth = depth.min(20); // cap at 20 levels max

    let parse_level = |entry: &serde_json::Value| -> Option<serde_json::Value> {
        let px = entry
            .get("px")
            .and_then(|v| v.as_str())?
            .parse::<f64>()
            .ok()?;
        let sz = entry
            .get("sz")
            .and_then(|v| v.as_str())?
            .parse::<f64>()
            .ok()?;
        let n = entry.get("n").and_then(|v| v.as_u64()).unwrap_or(0);
        Some(serde_json::json!({
            "price": px,
            "size": sz,
            "num_orders": n
        }))
    };

    let bids: Vec<serde_json::Value> = raw_bids
        .iter()
        .take(depth)
        .filter_map(parse_level)
        .collect();
    let asks: Vec<serde_json::Value> = raw_asks
        .iter()
        .take(depth)
        .filter_map(parse_level)
        .collect();

    // Calculate spread
    let best_bid = bids
        .first()
        .and_then(|b| b.get("price"))
        .and_then(|v| v.as_f64());
    let best_ask = asks
        .first()
        .and_then(|a| a.get("price"))
        .and_then(|v| v.as_f64());

    let (spread, spread_pct, mid_price) = match (best_bid, best_ask) {
        (Some(bid), Some(ask)) => {
            let s = ask - bid;
            let mid = (ask + bid) / 2.0;
            let pct = if mid > 0.0 { s / mid * 100.0 } else { 0.0 };
            (Some(s), Some(pct), Some(mid))
        }
        _ => (None, None, None),
    };

    Ok(serde_json::json!({
        "symbol": symbol,
        "bids": bids,
        "asks": asks,
        "best_bid": best_bid,
        "best_ask": best_ask,
        "mid_price": mid_price,
        "spread": spread,
        "spread_pct": spread_pct.map(|p| format!("{:.4}%", p)),
        "depth": depth
    }))
}

pub struct GetTradeHistoryTool {
    is_mainnet: bool,
}

impl GetTradeHistoryTool {
    pub fn new(is_mainnet: bool) -> Self {
        Self { is_mainnet }
    }
}

impl Tool for GetTradeHistoryTool {
    fn def(&self) -> ToolDef {
        ToolDef {
            name: "get_trade_history".to_string(),
            description: "Get recent trade fills (executed trades) for the current user. Optionally filter by symbol and limit the number of results.".to_string(),
            input_schema: serde_json::json!({
                "type": "object",
                "properties": {
                    "symbol": {"type": "string", "description": "Optional trading pair symbol to filter by, e.g. BTC-PERP"},
                    "limit": {"type": "integer", "description": "Maximum number of fills to return (default: all)"}
                }
            }),
        }
    }

    fn call(
        &self,
        args: Value,
        _ctx: &ToolContext,
    ) -> Pin<Box<dyn Future<Output = ToolResult> + Send + '_>> {
        Box::pin(async move {
            let symbol_filter = args.get("symbol").and_then(|v| v.as_str());
            let limit = args
                .get("limit")
                .and_then(|v| v.as_u64())
                .map(|l| l as usize);
            match fetch_trade_history(symbol_filter, limit, self.is_mainnet).await {
                Ok(info) => ToolResult::json(info),
                Err(e) => ToolResult::error(format!("Failed to fetch trade history: {}", e)),
            }
        })
    }
}

/// Fetch trade history (user fills) from Hyperliquid public API.
///
/// This is a stub — actual exchange queries require the user address,
/// which is resolved at the agent_loop / execute_tool level.
/// The tool definition is used by the LLM; execution is handled by execute_tool.
pub async fn fetch_trade_history(
    symbol_filter: Option<&str>,
    limit: Option<usize>,
    _is_mainnet: bool,
) -> Result<serde_json::Value, String> {
    Ok(serde_json::json!({
        "fills": [],
        "symbol_filter": symbol_filter,
        "limit": limit,
        "message": "Trade history query accepted"
    }))
}

fn order_request_from_args(args: &Value) -> OrderRequest {
    let symbol = args
        .get("asset")
        .and_then(|v| v.as_u64())
        .map(|a| a.to_string())
        .or_else(|| {
            args.get("symbol")
                .and_then(|v| v.as_str())
                .map(|s| s.to_string())
        })
        .unwrap_or_else(|| "unknown".to_string());

    let side = args
        .get("is_buy")
        .and_then(|v| v.as_bool())
        .map(|b| if b { "buy" } else { "sell" }.to_string())
        .or_else(|| {
            args.get("side")
                .and_then(|v| v.as_str())
                .map(ToString::to_string)
        })
        .unwrap_or_else(|| "buy".to_string());

    let size = args
        .get("size")
        .and_then(|v| {
            v.as_str()
                .and_then(|s| s.parse().ok())
                .or_else(|| v.as_f64())
        })
        .unwrap_or(0.0);

    let price = args
        .get("price")
        .and_then(|v| {
            v.as_str()
                .and_then(|s| s.parse().ok())
                .or_else(|| v.as_f64())
        })
        .unwrap_or(0.0);

    OrderRequest {
        symbol,
        side,
        size,
        price,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::VecDeque;
    use std::sync::{Arc, Mutex};

    use async_trait::async_trait;
    use futures_util::stream;
    use hyper_agent_core::position_manager::PositionManager;
    use motosan_chat_agent::{AgentError, AgentLoop, LlmClient, LlmResponse, LlmStream, Message};
    use motosan_chat_core::{Channel, ChatType, IncomingEvent, IncomingEventKind, Thread};
    use motosan_chat_tool::ToolDef;
    use tokio::sync::mpsc;

    fn test_position_manager() -> Arc<PositionManager> {
        Arc::new(PositionManager::new(":memory:").expect("in-memory position manager"))
    }

    #[derive(Clone)]
    struct ScriptedLlm {
        responses: Arc<Mutex<VecDeque<LlmResponse>>>,
    }

    #[async_trait]
    impl LlmClient for ScriptedLlm {
        async fn chat(
            &self,
            _messages: Vec<Message>,
            _tools: &[ToolDef],
        ) -> motosan_chat_tool::Result<LlmResponse> {
            self.responses
                .lock()
                .expect("responses mutex")
                .pop_front()
                .ok_or_else(|| motosan_chat_tool::Error::new("no scripted response"))
        }

        async fn stream(&self, _messages: Vec<Message>) -> LlmStream {
            Box::pin(stream::iter(Vec::<String>::new()))
        }
    }

    struct TestChannel;

    #[async_trait]
    impl Channel for TestChannel {
        fn name(&self) -> &str {
            "test"
        }

        async fn listen(&self, _tx: mpsc::Sender<IncomingEvent>) -> motosan_chat_core::Result<()> {
            Ok(())
        }

        async fn stream_chunk(
            &self,
            _user_id: &str,
            _chunk: &str,
        ) -> motosan_chat_core::Result<()> {
            Ok(())
        }

        async fn stream_done(&self, _user_id: &str) -> motosan_chat_core::Result<()> {
            Ok(())
        }

        async fn send(&self, _user_id: &str, _text: &str) -> motosan_chat_core::Result<()> {
            Ok(())
        }
    }

    fn test_thread() -> Thread {
        Thread::new(
            IncomingEvent {
                id: "evt-1".to_string(),
                platform: "test".to_string(),
                user_id: "u1".to_string(),
                channel_id: "c1".to_string(),
                text: "hello".to_string(),
                reply_token: None,
                attachments: vec![],
                chat_type: ChatType::DirectMessage,
                kind: IncomingEventKind::Message,
            },
            Arc::new(TestChannel),
        )
    }

    fn scripted_llm(responses: Vec<LlmResponse>) -> ScriptedLlm {
        ScriptedLlm {
            responses: Arc::new(Mutex::new(VecDeque::from(responses))),
        }
    }

    #[test]
    fn place_order_tool_blocks_risk_violations() {
        let risk_guard = RiskGuard::new(hyper_risk::risk::RiskConfig::default());
        let tool = PlaceOrderTool::new(risk_guard, AccountState::default());

        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({"asset": 0, "is_buy": true, "price": "65000", "size": "10000000"}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));

        assert!(output.is_error);
    }

    #[test]
    fn do_nothing_tool_returns_noop_json() {
        let tool = DoNothingTool;
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({"reason": "wait"}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));

        assert!(!output.is_error);
    }

    #[test]
    fn order_request_parser_handles_string_numbers() {
        let req = order_request_from_args(&serde_json::json!({
            "asset": 0,
            "is_buy": false,
            "price": "100.5",
            "size": "2.0"
        }));

        assert_eq!(req.symbol, "0");
        assert_eq!(req.side, "sell");
        assert!((req.price - 100.5).abs() < f64::EPSILON);
        assert!((req.size - 2.0).abs() < f64::EPSILON);
    }

    #[tokio::test]
    async fn integration_single_tool_call_then_final_answer() {
        let llm = scripted_llm(vec![
            LlmResponse::ToolCall {
                id: "tc-1".to_string(),
                name: "get_positions".to_string(),
                args: serde_json::json!({}),
            },
            LlmResponse::Message("do_nothing".to_string()),
        ]);

        let loop_engine = AgentLoop::builder()
            .tool(GetPositionsTool::new(test_position_manager()))
            .tool(DoNothingTool)
            .max_iterations(5)
            .build();

        let result = loop_engine
            .run(&llm, &test_thread(), vec![Message::user("status")])
            .await
            .expect("agent loop should succeed");

        assert_eq!(result.tool_calls.len(), 1);
        assert_eq!(result.tool_calls[0].0, "get_positions");
        assert_eq!(result.answer, "do_nothing");
    }

    #[tokio::test]
    async fn integration_positions_then_place_order_then_final_reasoning() {
        let llm = scripted_llm(vec![
            LlmResponse::ToolCall {
                id: "tc-1".to_string(),
                name: "get_positions".to_string(),
                args: serde_json::json!({}),
            },
            LlmResponse::ToolCall {
                id: "tc-2".to_string(),
                name: "place_order".to_string(),
                args: serde_json::json!({"asset": 0, "is_buy": true, "price": "65000", "size": "0.01"}),
            },
            LlmResponse::Message("placed".to_string()),
        ]);

        let risk_guard = RiskGuard::new(hyper_risk::risk::RiskConfig::default());
        let loop_engine = AgentLoop::builder()
            .tool(GetPositionsTool::new(test_position_manager()))
            .tool(PlaceOrderTool::new(risk_guard, AccountState::default()))
            .max_iterations(5)
            .build();

        let result = loop_engine
            .run(&llm, &test_thread(), vec![Message::user("trade")])
            .await
            .expect("agent loop should succeed");

        assert_eq!(result.tool_calls.len(), 2);
        assert_eq!(result.tool_calls[0].0, "get_positions");
        assert_eq!(result.tool_calls[1].0, "place_order");
        assert_eq!(result.answer, "placed");
    }

    #[tokio::test]
    async fn integration_risk_blocked_then_llm_adjusts_to_do_nothing() {
        let llm = scripted_llm(vec![
            LlmResponse::ToolCall {
                id: "tc-1".to_string(),
                name: "place_order".to_string(),
                args: serde_json::json!({"asset": 0, "is_buy": true, "price": "65000", "size": "10000000"}),
            },
            LlmResponse::ToolCall {
                id: "tc-2".to_string(),
                name: "do_nothing".to_string(),
                args: serde_json::json!({"reason": "risk_blocked"}),
            },
            LlmResponse::Message("hold".to_string()),
        ]);

        let risk_guard = RiskGuard::new(hyper_risk::risk::RiskConfig::default());
        let loop_engine = AgentLoop::builder()
            .tool(PlaceOrderTool::new(risk_guard, AccountState::default()))
            .tool(DoNothingTool)
            .max_iterations(5)
            .build();

        let result = loop_engine
            .run(&llm, &test_thread(), vec![Message::user("oversized")])
            .await
            .expect("agent loop should succeed");

        assert_eq!(result.tool_calls.len(), 2);
        assert_eq!(result.tool_calls[0].0, "place_order");
        assert_eq!(result.tool_calls[1].0, "do_nothing");
        assert_eq!(result.answer, "hold");
    }

    #[tokio::test]
    async fn integration_max_iterations_guard_triggers_error() {
        let llm = scripted_llm(vec![
            LlmResponse::ToolCall {
                id: "tc-1".to_string(),
                name: "do_nothing".to_string(),
                args: serde_json::json!({}),
            },
            LlmResponse::ToolCall {
                id: "tc-2".to_string(),
                name: "do_nothing".to_string(),
                args: serde_json::json!({}),
            },
            LlmResponse::ToolCall {
                id: "tc-3".to_string(),
                name: "do_nothing".to_string(),
                args: serde_json::json!({}),
            },
        ]);

        let loop_engine = AgentLoop::builder()
            .tool(DoNothingTool)
            .max_iterations(2)
            .build();

        let result = loop_engine
            .run(&llm, &test_thread(), vec![Message::user("loop")])
            .await;

        assert!(matches!(result, Err(AgentError::MaxIterations(2))));
    }

    #[test]
    fn close_all_positions_tool_def_is_valid() {
        let tool = CloseAllPositionsTool;
        let def = tool.def();
        assert_eq!(def.name, "close_all_positions");
        assert!(!def.description.is_empty());
        assert!(def.description.contains("Emergency"));
        assert_eq!(def.input_schema["type"], "object");
        assert!(def.input_schema["properties"].get("reason").is_some());
    }

    #[test]
    fn close_all_positions_tool_returns_accepted() {
        let tool = CloseAllPositionsTool;
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({"reason": "circuit_breaker"}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));

        assert!(!output.is_error);
    }

    #[test]
    fn get_funding_rate_tool_def_is_valid() {
        let tool = GetFundingRateTool::new(true);
        let def = tool.def();
        assert_eq!(def.name, "get_funding_rate");
        assert!(!def.description.is_empty());
        assert!(def.description.contains("funding rate"));
        assert_eq!(def.input_schema["type"], "object");
        assert!(def.input_schema.get("properties").is_some());
        assert!(def.input_schema["properties"].get("symbol").is_some());
    }

    #[test]
    fn get_funding_rate_tool_missing_symbol_returns_error() {
        let tool = GetFundingRateTool::new(true);
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));
        assert!(output.is_error);
    }

    #[test]
    fn get_market_data_tool_def_is_valid() {
        let tool = GetMarketDataTool::new(true);
        let def = tool.def();
        assert_eq!(def.name, "get_market_data");
        assert!(!def.description.is_empty());
        assert!(def.description.contains("orderbook"));
        assert_eq!(def.input_schema["type"], "object");
        assert!(def.input_schema.get("properties").is_some());
        assert!(def.input_schema["properties"].get("symbol").is_some());
        assert!(def.input_schema["properties"].get("depth").is_some());
    }

    #[test]
    fn get_market_data_tool_missing_symbol_returns_error() {
        let tool = GetMarketDataTool::new(true);
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));
        assert!(output.is_error);
    }

    #[test]
    fn get_open_orders_tool_def_is_valid() {
        let tool = GetOpenOrdersTool::new(true);
        let def = tool.def();
        assert_eq!(def.name, "get_open_orders");
        assert!(!def.description.is_empty());
        assert!(def.description.contains("open"));
        assert_eq!(def.input_schema["type"], "object");
        assert!(def.input_schema.get("properties").is_some());
        assert!(def.input_schema["properties"].get("symbol").is_some());
    }

    #[test]
    fn get_open_orders_tool_returns_result_without_symbol() {
        let tool = GetOpenOrdersTool::new(true);
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));
        assert!(!output.is_error);
    }

    #[test]
    fn get_trade_history_tool_def_is_valid() {
        let tool = GetTradeHistoryTool::new(true);
        let def = tool.def();
        assert_eq!(def.name, "get_trade_history");
        assert!(!def.description.is_empty());
        assert!(def.description.contains("trade fills"));
        assert_eq!(def.input_schema["type"], "object");
        assert!(def.input_schema.get("properties").is_some());
        assert!(def.input_schema["properties"].get("symbol").is_some());
        assert!(def.input_schema["properties"].get("limit").is_some());
    }

    #[test]
    fn get_trade_history_tool_returns_result_without_params() {
        let tool = GetTradeHistoryTool::new(true);
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));
        assert!(!output.is_error);
    }

    #[test]
    fn get_trade_history_tool_returns_result_with_symbol_and_limit() {
        let tool = GetTradeHistoryTool::new(true);
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({"symbol": "BTC-PERP", "limit": 10}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));
        assert!(!output.is_error);
    }

    #[test]
    fn get_open_orders_tool_returns_result_with_symbol() {
        let tool = GetOpenOrdersTool::new(true);
        let runtime = tokio::runtime::Runtime::new().expect("runtime");
        let output = runtime.block_on(tool.call(
            serde_json::json!({"symbol": "BTC-PERP"}),
            &ToolContext {
                caller_id: "test".to_string(),
                platform: "test".to_string(),
                extra: Default::default(),
            },
        ));
        assert!(!output.is_error);
    }
}