feat: Initialize Portfolio with Existing Positions and Enhance Data Fetching Reliability

This pull request introduces two major enhancements to the portfolio initialization process:
1. Initial Position Loading: The system now correctly loads and integrates any existing open positions into the PortfolioView at startup.
2. Robust Data Fetching: A retry mechanism has been implemented for fetching portfolio data to improve reliability against transient network or API errors.

Author: lukecold

python/valuecell/agents/common/trading/_internal/runtime.py

@@ -17,7 +17,7 @@
 )
 from ..models import Constraints, DecisionCycleResult, TradingMode, UserRequest
 from ..portfolio.in_memory import InMemoryPortfolioService
-from ..utils import fetch_free_cash_from_gateway
+from ..utils import fetch_free_cash_from_gateway, fetch_positions_from_gateway
 from .coordinator import DefaultDecisionCoordinator
 
 
@@ -32,6 +32,9 @@ async def _create_execution_gateway(request: UserRequest) -> BaseExecutionGatewa
                 execution_gateway, request.trading_config.symbols
             )
             request.trading_config.initial_capital = float(free_cash)
+            request.trading_config.initial_positions = (
+                await fetch_positions_from_gateway(execution_gateway)
+            )
     except Exception:
         # Log the error but continue - user might have set initial_capital manually
         logger.exception(
@@ -142,6 +145,7 @@ async def create_strategy_runtime(
     )
     portfolio_service = InMemoryPortfolioService(
         initial_capital=initial_capital,
+        initial_positions=request.trading_config.initial_positions,
         trading_mode=request.exchange_config.trading_mode,
         market_type=request.exchange_config.market_type,
         constraints=constraints,

python/valuecell/agents/common/trading/models.py

@@ -213,6 +213,10 @@ class TradingConfig(BaseModel):
         description="Initial capital for trading in USD",
         gt=0,
     )
+    initial_positions: Dict[str, "PositionSnapshot"] = Field(
+        default={},
+        description="Initial positions in portfolio",
+    )
     max_leverage: float = Field(
         default=DEFAULT_MAX_LEVERAGE,
         description="Maximum leverage",

python/valuecell/agents/common/trading/portfolio/in_memory.py

@@ -1,5 +1,5 @@
 from datetime import datetime, timezone
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from valuecell.agents.common.trading.models import (
     Constraints,
@@ -37,6 +37,7 @@ class InMemoryPortfolioService(BasePortfolioService):
     def __init__(
         self,
         initial_capital: float,
+        initial_positions: Dict[str, PositionSnapshot],
         trading_mode: TradingMode,
         market_type: MarketType,
         constraints: Optional[Constraints] = None,
@@ -45,16 +46,26 @@ def __init__(
         # Store owning strategy id on the view so downstream components
         # always see which strategy this portfolio belongs to.
         self._strategy_id = strategy_id
+        position_value = sum(
+            value.notional
+            for value in initial_positions.values()
+            if value.notional is not None
+        )
+        total_unrealized_pnl = sum(
+            value.unrealized_pnl
+            for value in initial_positions.values()
+            if value.unrealized_pnl is not None
+        )
         self._view = PortfolioView(
             strategy_id=strategy_id,
             ts=int(datetime.now(timezone.utc).timestamp() * 1000),
-            account_balance=initial_capital,
-            positions={},
-            gross_exposure=0.0,
-            net_exposure=0.0,
+            account_balance=initial_capital + position_value,
+            positions=initial_positions,
+            gross_exposure=position_value,
+            net_exposure=position_value,
             constraints=constraints or None,
-            total_value=initial_capital,
-            total_unrealized_pnl=0.0,
+            total_value=initial_capital + position_value,
+            total_unrealized_pnl=total_unrealized_pnl,
             total_realized_pnl=0.0,
             buying_power=initial_capital,
             free_cash=initial_capital,

python/valuecell/agents/common/trading/utils.py

@@ -9,11 +9,16 @@
     FEATURE_GROUP_BY_KEY,
     FEATURE_GROUP_BY_MARKET_SNAPSHOT,
 )
-from valuecell.agents.common.trading.models import FeatureVector
+from valuecell.agents.common.trading.models import (
+    FeatureVector,
+    InstrumentRef,
+    PositionSnapshot,
+    TradeType,
+)
 
 
 async def fetch_free_cash_from_gateway(
-    execution_gateway, symbols: list[str]
+    execution_gateway, symbols: list[str], retry_cnt: int = 0, max_retries: int = 3
 ) -> Tuple[float, float]:
     """Fetch exchange balance via `execution_gateway.fetch_balance()` and
     aggregate free cash for the given `symbols` (quote currencies).
@@ -26,7 +31,18 @@ async def fetch_free_cash_from_gateway(
         if not hasattr(execution_gateway, "fetch_balance"):
             return 0.0, 0.0
         balance = await execution_gateway.fetch_balance()
-    except Exception:
+    except Exception as e:
+        if retry_cnt < max_retries:
+            logger.warning(
+                f"Failed to fetch free cash from exchange, retrying... ({retry_cnt + 1}/{max_retries})"
+            )
+            execution_gateway.new_exchange()
+            return await fetch_free_cash_from_gateway(
+                execution_gateway, symbols, retry_cnt + 1
+            )
+        logger.error(
+            f"Failed to fetch free cash from exchange after {retry_cnt} retries, returning 0.0 {e}"
+        )
         return 0.0, 0.0
 
     logger.info(f"Raw balance response: {balance}")
@@ -94,6 +110,60 @@ async def fetch_free_cash_from_gateway(
     return float(free_cash), float(total_cash)
 
 
+async def fetch_positions_from_gateway(
+    execution_gateway, retry_cnt: int = 0, max_retries: int = 3
+) -> Dict[str, PositionSnapshot]:
+    """Fetch positions from exchange."""
+    logger.info("Fetching positions for LIVE trading mode")
+    try:
+        if not hasattr(execution_gateway, "fetch_positions"):
+            return {}
+        raw_positions = await execution_gateway.fetch_positions()
+    except Exception as e:
+        if retry_cnt < max_retries:
+            logger.warning(
+                f"Failed to fetch positions from exchange, retrying... ({retry_cnt + 1}/{max_retries})"
+            )
+            execution_gateway.new_exchange()
+            return await fetch_positions_from_gateway(execution_gateway, retry_cnt + 1)
+        logger.error(
+            f"Failed to fetch positions from exchange after {retry_cnt} retries, returning no positions {e}"
+        )
+        return {}
+
+    logger.debug(f"Raw positions response: {raw_positions}")
+    positions = {}
+    for position in raw_positions:
+        if "symbol" in position:
+            symbol = position.get("symbol").split(":")[0]
+            position = PositionSnapshot(
+                instrument=InstrumentRef(
+                    exchange_id=execution_gateway.exchange_id,
+                    symbol=symbol,
+                ),
+                quantity=abs(position.get("contracts")),
+                avg_price=position.get("entryPrice"),
+                mark_price=position.get("markPrice"),
+                unrealized_pnl=position.get("unrealizedPnl"),
+                notional=position.get("notional"),
+                leverage=position.get("leverage") or 1,
+                entry_ts=position.get("timestamp"),
+                trade_type=(
+                    TradeType.LONG
+                    if position.get("side") == "long"
+                    else TradeType.SHORT
+                ),
+            )
+            if position.notional != 0:
+                position.unrealized_pnl_pct = (
+                    position.unrealized_pnl / position.notional
+                )
+            positions[symbol] = position
+    logger.info(f"Fetched positions: {positions}")
+
+    return positions
+
+
 def extract_market_snapshot_features(
     features: List[FeatureVector],
 ) -> List[FeatureVector]: