feature: strategy agent

python/configs/agent_cards/strategy_agent.json

@@ -0,0 +1,29 @@
+{
+  "name": "StrategyAgent",
+  "display_name": "Strategy Agent",
+  "description": "LLM-driven strategy composer that turns market features into normalized trade instructions. Includes a simple runtime for demo and testing.",
+  "capabilities": {
+    "streaming": true,
+    "push_notifications": true
+  },
+  "skills": [
+    {
+      "id": "strategy_run",
+      "name": "Run Strategy",
+      "description": "Start a strategy using the provided model, exchange and trading configuration.",
+      "examples": [
+        "Run strategy with DeepSeek model on BTC-USD and ETH-USD",
+        "Start a virtual backtest with $10,000 initial capital for BTC"
+      ],
+      "tags": ["strategy", "run", "trading", "compose"]
+    }
+  ],
+  "enabled": true,
+  "metadata": {
+    "planner_passthrough": true,
+    "version": "0.1.0",
+    "author": "ValueCell Team",
+    "tags": ["strategy", "trading", "llm", "demo"],
+    "notes": "This card is a lightweight example; replace model api_key and tune parameters for production use."
+  }
+}

python/pyproject.toml

@@ -28,6 +28,7 @@ dependencies = [
     "loguru>=0.7.3",
     "aiofiles>=24.1.0",
     "crawl4ai>=0.7.4",
+    "ccxt>=4.5.15",
 ]
 
 [project.optional-dependencies]

python/scripts/launch.py

@@ -32,12 +32,18 @@
 RESEARCH_AGENT_NAME = "ResearchAgent"
 AUTO_TRADING_AGENT_NAME = "AutoTradingAgent"
 NEWS_AGENT_NAME = "NewsAgent"
+STRATEGY_AGENT_NAME = "StrategyAgent"
 # AGENTS = list(MAP_NAME_ANALYST.keys()) + [
 #     TRADING_AGENTS_NAME,
 #     RESEARCH_AGENT_NAME,
 #     AUTO_TRADING_AGENT_NAME,
 # ]
-AGENTS = [RESEARCH_AGENT_NAME, AUTO_TRADING_AGENT_NAME, NEWS_AGENT_NAME]
+AGENTS = [
+    RESEARCH_AGENT_NAME,
+    AUTO_TRADING_AGENT_NAME,
+    NEWS_AGENT_NAME,
+    STRATEGY_AGENT_NAME,
+]
 
 PROJECT_DIR = Path(__file__).resolve().parent.parent.parent
 PYTHON_DIR = PROJECT_DIR / "python"
@@ -78,6 +84,9 @@
 MAP_NAME_COMMAND[NEWS_AGENT_NAME] = (
     f"uv run --env-file {ENV_PATH_STR} -m valuecell.agents.news_agent"
 )
+MAP_NAME_COMMAND[STRATEGY_AGENT_NAME] = (
+    f"uv run --env-file {ENV_PATH_STR} -m valuecell.agents.strategy_agent"
+)
 BACKEND_COMMAND = (
     f"cd {PYTHON_DIR_STR} && uv run --env-file {ENV_PATH_STR} -m valuecell.server.main"
 )

python/valuecell/agents/strategy_agent/agent.py

@@ -1,21 +1,26 @@
 from __future__ import annotations
 
+import asyncio
+from datetime import datetime
 from typing import AsyncGenerator, Dict, Optional
 
+from loguru import logger
+
 from valuecell.core.agent.responses import streaming
 from valuecell.core.types import BaseAgent, StreamResponse
+from valuecell.server.services import strategy_persistence
 
+from .models import (
+    ComponentType,
+    StrategyStatus,
+    StrategyStatusContent,
+    UserRequest,
+)
+from .runtime import create_strategy_runtime
 
-class StrategyAgent(BaseAgent):
-    """Minimal StrategyAgent entry for system integration.
-
-    This is a placeholder agent that streams a short greeting and completes.
-    It can be extended to wire the Strategy Agent decision loop
-    (data -> features -> composer -> execution -> history/digest).
-    """
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+class StrategyAgent(BaseAgent):
+    """Top-level Strategy Agent integrating the decision coordinator."""
 
     async def stream(
         self,
@@ -24,8 +29,96 @@ async def stream(
         task_id: str,
         dependencies: Optional[Dict] = None,
     ) -> AsyncGenerator[StreamResponse, None]:
-        # Minimal streaming lifecycle: one message and done
-        yield streaming.message_chunk(
-            "StrategyAgent is online. Decision pipeline will be wired here."
+        try:
+            request = UserRequest.model_validate_json(query)
+        except ValueError as exc:
+            logger.exception("StrategyAgent received invalid payload")
+            yield streaming.message_chunk(str(exc))
+            yield streaming.done()
+            return
+
+        runtime = create_strategy_runtime(request)
+        strategy_id = runtime.strategy_id
+        logger.info(
+            "Created runtime for strategy_id={} conversation={} task={}",
+            strategy_id,
+            conversation_id,
+            task_id,
+        )
+        initial_payload = StrategyStatusContent(
+            strategy_id=strategy_id,
+            status=StrategyStatus.RUNNING,
+        )
+        yield streaming.component_generator(
+            content=initial_payload.model_dump_json(),
+            component_type=ComponentType.STATUS.value,
         )
-        yield streaming.done()
+
+        # Wait until strategy is marked as running in persistence layer
+        since = datetime.now()
+        while not strategy_persistence.strategy_running(strategy_id):
+            if (datetime.now() - since).total_seconds() > 300:
+                logger.error(
+                    "Timeout waiting for strategy_id={} to be marked as running",
+                    strategy_id,
+                )
+                break
+
+            await asyncio.sleep(1)
+            logger.info(
+                "Waiting for strategy_id={} to be marked as running", strategy_id
+            )
+
+        try:
+            logger.info("Starting decision loop for strategy_id={}", strategy_id)
+            while True:
+                if not strategy_persistence.strategy_running(strategy_id):
+                    logger.info(
+                        "Strategy_id={} is no longer running, exiting decision loop",
+                        strategy_id,
+                    )
+                    break
+
+                result = await runtime.run_cycle()
+                logger.info(
+                    "Run cycle completed for strategy={} trades_count={}",
+                    strategy_id,
+                    len(result.trades),
+                )
+                # Persist and stream trades
+                for trade in result.trades:
+                    item = strategy_persistence.persist_trade_history(
+                        strategy_id, trade
+                    )
+                    if item:
+                        logger.info(
+                            "Persisted trade {} for strategy={}",
+                            getattr(trade, "trade_id", None),
+                            strategy_id,
+                        )
+
+                # Persist portfolio snapshot (positions)
+                ok = strategy_persistence.persist_portfolio_view(result.portfolio_view)
+                if ok:
+                    logger.info(
+                        "Persisted portfolio view for strategy={}",
+                        strategy_id,
+                    )
+
+                # Persist strategy summary
+                ok = strategy_persistence.persist_strategy_summary(
+                    result.strategy_summary
+                )
+                if ok:
+                    logger.info(
+                        "Persisted strategy summary for strategy={}",
+                        strategy_id,
+                    )
+
+        except asyncio.CancelledError:
+            raise
+        except Exception as err:  # noqa: BLE001
+            logger.exception("StrategyAgent stream failed: {}", err)
+            yield streaming.message_chunk(f"StrategyAgent error: {err}")
+        finally:
+            yield streaming.done()

python/valuecell/agents/strategy_agent/constants.py

@@ -9,3 +9,4 @@
 DEFAULT_MAX_POSITIONS = 5
 DEFAULT_MAX_SYMBOLS = 5
 DEFAULT_MAX_LEVERAGE = 10.0
+DEFAULT_CAP_FACTOR = 1.5