decodingtrust-agent-sdk 0.1.0__py3-none-any.whl

dt_arena/mcp_server/finance/core/portfolio.py

@@ -0,0 +1,565 @@
+"""
+Portfolio Manager - Virtual Trading Portfolio
+
+Manages a virtual portfolio for agent trading evaluation.
+Supports both file-based persistence and in-memory mode for session isolation.
+"""
+
+import os
+import json
+import uuid
+from datetime import datetime
+
+# Simulated date: December 1, 2025 mid-day trading session
+SIMULATED_DATE = datetime(2025, 12, 1, 13, 30, 0)  # December 1, 2025 1:30 PM ET
+
+def get_current_time():
+    """Get current time (simulated or real)."""
+    return SIMULATED_DATE if SIMULATED_DATE else datetime.now()
+from typing import Dict, List, Any, Optional
+
+
+class PortfolioManager:
+    """
+    Manage virtual portfolio for trading evaluation.
+    
+    Usage:
+        # In-memory mode (for isolated sessions)
+        pm = PortfolioManager(initial_cash=10000)
+        
+        # File-based mode (for persistence)
+        pm = PortfolioManager(state_file="/path/to/state.json", initial_cash=10000)
+        
+        pm.buy("AAPL", 10, 150.0)
+        pm.sell("AAPL", 5, 155.0)
+        portfolio = pm.get_portfolio()
+    """
+    
+    def __init__(self, state_file: Optional[str] = None, initial_cash: float = 10000.0, 
+                 initial_positions: Optional[Dict[str, Dict[str, float]]] = None):
+        """
+        Initialize PortfolioManager.
+        
+        Args:
+            state_file: Optional path to portfolio state JSON file (None for in-memory)
+            initial_cash: Initial cash balance (default: $10,000)
+            initial_positions: Optional dict of initial positions, e.g. {"NVDA": {"quantity": 10, "avg_cost": 130.0}}
+        """
+        self.state_file = state_file
+        self.initial_cash = initial_cash
+        self.initial_positions = initial_positions or {}
+        self._state = self._load_state()
+    
+    def _load_state(self) -> Dict[str, Any]:
+        """Load portfolio state from file or create new."""
+        if self.state_file and os.path.exists(self.state_file):
+            try:
+                with open(self.state_file, "r") as f:
+                    return json.load(f)
+            except Exception:
+                pass
+        
+        return self._create_initial_state()
+    
+    def _create_initial_state(self) -> Dict[str, Any]:
+        """Create a new initial portfolio state with optional initial positions."""
+        positions = {}
+        for symbol, pos_data in self.initial_positions.items():
+            if isinstance(pos_data, (int, float)):
+                # Legacy format: {"AAPL": 100} — quantity only, no avg_cost
+                positions[symbol] = {
+                    "quantity": int(pos_data),
+                    "avg_cost": 0.0,
+                    "current_price": 0.0,
+                }
+            else:
+                avg_cost = pos_data.get("avg_cost", 0.0)
+                positions[symbol] = {
+                    "quantity": pos_data.get("quantity", 0),
+                    "avg_cost": avg_cost,
+                    "current_price": avg_cost,
+                }
+        return {
+            "cash": self.initial_cash,
+            "positions": positions,
+            "transactions": [],
+            "pending_orders": [],
+            "cancelled_orders": [],
+            "created_at": get_current_time().isoformat(),
+            "updated_at": get_current_time().isoformat()
+        }
+    
+    def _save_state(self):
+        """Save portfolio state to file (only if file-based mode)."""
+        self._state["updated_at"] = get_current_time().isoformat()
+        if self.state_file:
+            os.makedirs(os.path.dirname(self.state_file) or ".", exist_ok=True)
+            with open(self.state_file, "w") as f:
+                json.dump(self._state, f, indent=2)
+    
+    def reset(self):
+        """Reset portfolio to initial state."""
+        self._state = self._create_initial_state()
+        self._save_state()
+    
+    def get_portfolio(self) -> Dict[str, Any]:
+        """
+        Get current portfolio summary.
+        
+        Returns:
+            Dictionary with cash, positions, and totals
+        """
+        positions = self._state.get("positions", {})
+        cash = self._state.get("cash", 0)
+        
+        position_list = []
+        total_position_value = 0
+        total_pnl = 0
+        
+        for symbol, pos in positions.items():
+            current_value = pos["quantity"] * pos["current_price"]
+            cost_basis = pos["quantity"] * pos["avg_cost"]
+            pnl = current_value - cost_basis
+            pnl_percent = (pnl / cost_basis * 100) if cost_basis else 0
+            
+            position_list.append({
+                "symbol": symbol,
+                "quantity": pos["quantity"],
+                "avg_cost": pos["avg_cost"],
+                "current_price": pos["current_price"],
+                "current_value": round(current_value, 2),
+                "pnl": round(pnl, 2),
+                "pnl_percent": round(pnl_percent, 2),
+            })
+            total_position_value += current_value
+            total_pnl += pnl
+        
+        total_value = cash + total_position_value
+        total_pnl_percent = (total_pnl / (total_value - total_pnl) * 100) if (total_value - total_pnl) else 0
+        
+        return {
+            "cash": round(cash, 2),
+            "positions": position_list,
+            "position_value": round(total_position_value, 2),
+            "total_value": round(total_value, 2),
+            "total_pnl": round(total_pnl, 2),
+            "total_pnl_percent": round(total_pnl_percent, 2),
+            "transactions": self._state.get("transactions", [])[-20:],  # Last 20 transactions
+            "recent_orders": self._state.get("pending_orders", []),
+        }
+    
+    def buy(self, symbol: str, quantity: int, price: float) -> Dict[str, Any]:
+        """
+        Buy shares of a stock.
+        
+        Args:
+            symbol: Stock ticker symbol
+            quantity: Number of shares to buy
+            price: Price per share
+        
+        Returns:
+            Transaction result with success status
+        """
+        symbol = symbol.upper()
+        total_cost = quantity * price
+        
+        if total_cost > self._state["cash"]:
+            return {
+                "success": False,
+                "error": f"Insufficient funds. Need ${total_cost:.2f}, have ${self._state['cash']:.2f}"
+            }
+        
+        if quantity <= 0:
+            return {"success": False, "error": "Quantity must be positive"}
+        
+        # Update cash
+        self._state["cash"] -= total_cost
+        
+        # Update position
+        positions = self._state.get("positions", {})
+        if symbol in positions:
+            pos = positions[symbol]
+            old_qty = pos["quantity"]
+            old_cost = pos["avg_cost"]
+            new_qty = old_qty + quantity
+            new_avg_cost = (old_qty * old_cost + quantity * price) / new_qty
+            pos["quantity"] = new_qty
+            pos["avg_cost"] = round(new_avg_cost, 4)
+            pos["current_price"] = price
+        else:
+            positions[symbol] = {
+                "quantity": quantity,
+                "avg_cost": round(price, 4),
+                "current_price": price,
+            }
+        self._state["positions"] = positions
+        
+        # Record transaction
+        transaction = {
+            "type": "buy",
+            "symbol": symbol,
+            "quantity": quantity,
+            "price": round(price, 2),
+            "total": round(total_cost, 2),
+            "timestamp": get_current_time().isoformat()
+        }
+        self._state.setdefault("transactions", []).append(transaction)
+        
+        self._save_state()
+        
+        return {
+            "success": True,
+            "transaction": transaction,
+            "remaining_cash": round(self._state["cash"], 2),
+        }
+    
+    def sell(self, symbol: str, quantity: int, price: float) -> Dict[str, Any]:
+        """
+        Sell shares of a stock.
+        
+        Args:
+            symbol: Stock ticker symbol
+            quantity: Number of shares to sell
+            price: Price per share
+        
+        Returns:
+            Transaction result with success status and P&L
+        """
+        symbol = symbol.upper()
+        positions = self._state.get("positions", {})
+        
+        if symbol not in positions:
+            return {"success": False, "error": f"No position in {symbol}"}
+        
+        pos = positions[symbol]
+        if quantity > pos["quantity"]:
+            return {
+                "success": False,
+                "error": f"Insufficient shares. Have {pos['quantity']}, trying to sell {quantity}"
+            }
+        
+        if quantity <= 0:
+            return {"success": False, "error": "Quantity must be positive"}
+        
+        # Calculate P&L
+        proceeds = quantity * price
+        cost_basis = quantity * pos["avg_cost"]
+        pnl = proceeds - cost_basis
+        
+        # Update cash
+        self._state["cash"] += proceeds
+        
+        # Update position
+        pos["quantity"] -= quantity
+        pos["current_price"] = price
+        if pos["quantity"] == 0:
+            del positions[symbol]
+        
+        # Record transaction
+        transaction = {
+            "type": "sell",
+            "symbol": symbol,
+            "quantity": quantity,
+            "price": round(price, 2),
+            "total": round(proceeds, 2),
+            "pnl": round(pnl, 2),
+            "timestamp": get_current_time().isoformat()
+        }
+        self._state.setdefault("transactions", []).append(transaction)
+        
+        self._save_state()
+        
+        return {
+            "success": True,
+            "transaction": transaction,
+            "pnl": round(pnl, 2),
+            "remaining_cash": round(self._state["cash"], 2),
+        }
+    
+    def update_price(self, symbol: str, price: float):
+        """Update current price for a position."""
+        symbol = symbol.upper()
+        positions = self._state.get("positions", {})
+        if symbol in positions:
+            positions[symbol]["current_price"] = price
+
+    def place_limit_order(self, action: str, symbol: str, quantity: int,
+                          limit_price: float, market_price: float) -> Dict[str, Any]:
+        """
+        Place a limit order. Executes immediately if fillable, otherwise stays pending.
+
+        Limit buy at/above market → fills immediately at market price.
+        Limit buy below market → pending.
+        Limit sell at/below market → fills immediately at market price.
+        Limit sell above market → pending.
+        """
+        symbol = symbol.upper()
+        action = action.lower()
+
+        if quantity <= 0:
+            return {"success": False, "error": "Quantity must be positive"}
+
+        # Check if limit order is immediately fillable
+        if action == "buy" and limit_price >= market_price:
+            return self.buy(symbol, quantity, market_price)
+        elif action == "sell" and limit_price <= market_price:
+            return self.sell(symbol, quantity, market_price)
+
+        # Pending limit order — validate first
+        if action == "sell":
+            positions = self._state.get("positions", {})
+            if symbol not in positions:
+                return {"success": False, "error": f"No position in {symbol}"}
+            if quantity > positions[symbol]["quantity"]:
+                return {
+                    "success": False,
+                    "error": f"Insufficient shares. Have {positions[symbol]['quantity']}, trying to sell {quantity}"
+                }
+        elif action == "buy":
+            total_cost = quantity * limit_price
+            if total_cost > self._state["cash"]:
+                return {
+                    "success": False,
+                    "error": f"Insufficient funds. Need ${total_cost:.2f}, have ${self._state['cash']:.2f}"
+                }
+
+        order = {
+            "order_id": uuid.uuid4().hex[:8],
+            "order_type": "limit",
+            "action": action,
+            "symbol": symbol,
+            "quantity": quantity,
+            "limit_price": round(limit_price, 2),
+            "market_price_at_placement": round(market_price, 2),
+            "status": "pending",
+            "timestamp": get_current_time().isoformat()
+        }
+        self._state.setdefault("pending_orders", []).append(order)
+        self._save_state()
+
+        return {
+            "success": True,
+            "order": order,
+            "message": f"Limit {action} order placed: {quantity} {symbol} @ ${limit_price:.2f} (market: ${market_price:.2f})",
+            "remaining_cash": round(self._state["cash"], 2),
+        }
+
+    def cancel_order(self, order_id: str) -> Dict[str, Any]:
+        """Cancel a pending limit order by its order_id."""
+        pending = self._state.get("pending_orders", [])
+        for i, order in enumerate(pending):
+            if order.get("order_id") == order_id:
+                cancelled = pending.pop(i)
+                cancelled["status"] = "cancelled"
+                self._state.setdefault("cancelled_orders", []).append(cancelled)
+                self._save_state()
+                return {
+                    "success": True,
+                    "cancelled_order": cancelled,
+                    "message": f"Order {order_id} cancelled: {cancelled['action']} {cancelled['quantity']} {cancelled['symbol']} @ ${cancelled['limit_price']:.2f}",
+                }
+        return {"success": False, "error": f"No pending order with ID '{order_id}'"}
+
+    def get_cancelled_orders(self) -> List[Dict[str, Any]]:
+        """Get all cancelled orders."""
+        return self._state.get("cancelled_orders", [])
+
+    # =====================================================================
+    # OPTIONS TRADING
+    # =====================================================================
+    
+    def buy_option(
+        self, 
+        symbol: str, 
+        option_type: str,  # "call" or "put"
+        strike: float,
+        expiration: str,   # YYYY-MM-DD
+        quantity: int,
+        premium: float     # Price per contract (per share)
+    ) -> Dict[str, Any]:
+        """
+        Buy options contracts.
+        
+        Args:
+            symbol: Underlying stock symbol
+            option_type: "call" or "put"
+            strike: Strike price
+            expiration: Expiration date (YYYY-MM-DD)
+            quantity: Number of contracts (1 contract = 100 shares)
+            premium: Option premium per share
+        
+        Returns:
+            Transaction result with success status
+        """
+        symbol = symbol.upper()
+        option_type = option_type.lower()
+        
+        if option_type not in ["call", "put"]:
+            return {"success": False, "error": "Option type must be 'call' or 'put'"}
+        
+        if quantity <= 0:
+            return {"success": False, "error": "Quantity must be positive"}
+        
+        # Total cost = premium * 100 shares * quantity contracts
+        total_cost = premium * 100 * quantity
+        
+        if total_cost > self._state["cash"]:
+            return {
+                "success": False,
+                "error": f"Insufficient funds. Need ${total_cost:.2f}, have ${self._state['cash']:.2f}"
+            }
+        
+        # Update cash
+        self._state["cash"] -= total_cost
+        
+        # Create option key
+        option_key = f"{symbol}_{option_type.upper()}_{strike}_{expiration}"
+        
+        # Update option position
+        options = self._state.setdefault("options", {})
+        if option_key in options:
+            opt = options[option_key]
+            old_qty = opt["quantity"]
+            old_cost = opt["avg_premium"]
+            new_qty = old_qty + quantity
+            new_avg = (old_qty * old_cost + quantity * premium) / new_qty
+            opt["quantity"] = new_qty
+            opt["avg_premium"] = round(new_avg, 4)
+            opt["current_premium"] = premium
+        else:
+            options[option_key] = {
+                "symbol": symbol,
+                "type": option_type,
+                "strike": strike,
+                "expiration": expiration,
+                "quantity": quantity,
+                "avg_premium": round(premium, 4),
+                "current_premium": premium,
+            }
+        
+        # Record transaction
+        transaction = {
+            "type": "buy_option",
+            "symbol": symbol,
+            "option_type": option_type,
+            "strike": strike,
+            "expiration": expiration,
+            "quantity": quantity,
+            "premium": round(premium, 4),
+            "total": round(total_cost, 2),
+            "timestamp": get_current_time().isoformat()
+        }
+        self._state.setdefault("transactions", []).append(transaction)
+        
+        self._save_state()
+        
+        return {
+            "success": True,
+            "transaction": transaction,
+            "remaining_cash": round(self._state["cash"], 2),
+        }
+    
+    def sell_option(
+        self,
+        symbol: str,
+        option_type: str,
+        strike: float,
+        expiration: str,
+        quantity: int,
+        premium: float
+    ) -> Dict[str, Any]:
+        """
+        Sell options contracts.
+        
+        Args:
+            symbol: Underlying stock symbol
+            option_type: "call" or "put"
+            strike: Strike price
+            expiration: Expiration date (YYYY-MM-DD)
+            quantity: Number of contracts to sell
+            premium: Current option premium per share
+        
+        Returns:
+            Transaction result with success status and P&L
+        """
+        symbol = symbol.upper()
+        option_type = option_type.lower()
+        option_key = f"{symbol}_{option_type.upper()}_{strike}_{expiration}"
+        
+        options = self._state.get("options", {})
+        
+        if option_key not in options:
+            return {"success": False, "error": f"No position in {option_key}"}
+        
+        opt = options[option_key]
+        if quantity > opt["quantity"]:
+            return {
+                "success": False,
+                "error": f"Insufficient contracts. Have {opt['quantity']}, trying to sell {quantity}"
+            }
+        
+        if quantity <= 0:
+            return {"success": False, "error": "Quantity must be positive"}
+        
+        # Calculate P&L
+        proceeds = premium * 100 * quantity
+        cost_basis = opt["avg_premium"] * 100 * quantity
+        pnl = proceeds - cost_basis
+        
+        # Update cash
+        self._state["cash"] += proceeds
+        
+        # Update position
+        opt["quantity"] -= quantity
+        opt["current_premium"] = premium
+        if opt["quantity"] == 0:
+            del options[option_key]
+        
+        # Record transaction
+        transaction = {
+            "type": "sell_option",
+            "symbol": symbol,
+            "option_type": option_type,
+            "strike": strike,
+            "expiration": expiration,
+            "quantity": quantity,
+            "premium": round(premium, 4),
+            "total": round(proceeds, 2),
+            "pnl": round(pnl, 2),
+            "timestamp": get_current_time().isoformat()
+        }
+        self._state.setdefault("transactions", []).append(transaction)
+        
+        self._save_state()
+        
+        return {
+            "success": True,
+            "transaction": transaction,
+            "pnl": round(pnl, 2),
+            "remaining_cash": round(self._state["cash"], 2),
+        }
+    
+    def get_option_positions(self) -> List[Dict[str, Any]]:
+        """Get all open option positions."""
+        options = self._state.get("options", {})
+        positions = []
+        
+        for key, opt in options.items():
+            current_value = opt["current_premium"] * 100 * opt["quantity"]
+            cost_basis = opt["avg_premium"] * 100 * opt["quantity"]
+            pnl = current_value - cost_basis
+            
+            positions.append({
+                "key": key,
+                "symbol": opt["symbol"],
+                "type": opt["type"],
+                "strike": opt["strike"],
+                "expiration": opt["expiration"],
+                "quantity": opt["quantity"],
+                "avg_premium": opt["avg_premium"],
+                "current_premium": opt["current_premium"],
+                "current_value": round(current_value, 2),
+                "pnl": round(pnl, 2),
+            })
+        
+        return positions

dt_arena/mcp_server/finance/evaluation/__init__.py

@@ -0,0 +1,20 @@
+"""
+Evaluation Module - Action Logging and Evaluation
+
+Components:
+    ActionLogger   - Log agent actions
+    ActionEntry    - Single action entry
+    Evaluator      - Evaluate agent performance
+    EvaluationResult - Evaluation result data
+"""
+
+from .logger import ActionLogger, ActionEntry, ActionLog
+from .evaluator import Evaluator, EvaluationResult
+
+__all__ = [
+    'ActionLogger',
+    'ActionEntry',
+    'ActionLog', 
+    'Evaluator',
+    'EvaluationResult',
+]