"Vibe-Trading: Your Personal Trading Agent"
Python ai-agentalgorithmic-tradingbacktestingfintechllmmcpmulti-agentpythonquantitative-financetrading
fix(tools): handle loader payloads without sampling indicator inputs (#1005)
卫斯李ada460fa9335
diff --git a/agent/src/tools/technical_indicator_tool.py b/agent/src/tools/technical_indicator_tool.pyindex 3c0c2a62d..2f58aee28 100644--- a/agent/src/tools/technical_indicator_tool.py+++ b/agent/src/tools/technical_indicator_tool.py@@ -32,6 +32,61 @@ _DEFAULT_LOOKBACK = 200_MAX_LOOKBACK = 500+_CLOSE_KEYS = ("close", "Close", "CLOSE", "adj_close")+_DATE_KEYS = ("trade_date", "date", "datetime", "timestamp", "time")+++def _extract_close_series(payload: Any) -> pd.Series | None:+ """Extract the close-price series from a loader payload.++ Loader results can be a ``DataFrame``, a plain column mapping, or the+ ``list[dict]`` shape returned by :func:`fetch_market_data`. Preserve a real+ date index when one is available; a payload without dates intentionally+ keeps a ``RangeIndex`` so callers do not report a row number as a date.+ """+ if isinstance(payload, list):+ if not payload or not isinstance(payload[0], dict):+ return None+ frame = pd.DataFrame(payload)+ elif isinstance(payload, dict):+ inner = payload.get("data")+ if isinstance(inner, list):+ return _extract_close_series(inner)+ try:+ frame = pd.DataFrame(payload)+ except ValueError:+ return None+ elif isinstance(payload, pd.DataFrame):+ frame = payload.copy()+ else:+ return None++ close_key = next((key for key in _CLOSE_KEYS if key in frame.columns), None)+ if close_key is None:+ return None++ close = pd.to_numeric(frame[close_key], errors="coerce")+ date_key = next((key for key in _DATE_KEYS if key in frame.columns), None)+ if date_key is not None:+ dates = pd.to_datetime(frame[date_key], errors="coerce")+ elif isinstance(frame.index, pd.DatetimeIndex):+ dates = pd.Series(frame.index, index=frame.index)+ elif not isinstance(frame.index, pd.RangeIndex) and not pd.api.types.is_integer_dtype(+ frame.index.dtype+ ):+ dates = pd.Series(pd.to_datetime(frame.index, errors="coerce"), index=frame.index)+ else:+ return close.dropna().reset_index(drop=True).astype(float)++ valid = close.notna() & dates.notna()+ normalized = pd.Series(+ close.loc[valid].to_numpy(dtype=float),+ index=pd.DatetimeIndex(dates.loc[valid]),+ dtype=float,+ )+ return normalized.sort_index(kind="stable")++def _compute_sma(close: pd.Series, period: int) -> float | None:"""Simple moving average over the last *period* bars."""if len(close) < period:@@ -166,30 +221,35 @@ class TechnicalIndicatorTool(BaseTool):start_date=start_date,end_date=end_date,interval=interval,- max_rows=lookback,+ # Indicators require consecutive bars. ``max_rows=lookback``+ # would make the shared helper even-stride sample long windows.+ max_rows=0,)except Exception as exc:logger.debug("fetch_market_data failed for %s: %s", symbol, exc)return json.dumps({"ok": False, "error": f"Failed to fetch data: {exc}"})df = data.get(symbol)- if df is None or df.empty:+ if df is None:+ return json.dumps({"ok": False, "error": f"No data returned for {symbol}"})+ if isinstance(df, pd.DataFrame) and df.empty:+ return json.dumps({"ok": False, "error": f"No data returned for {symbol}"})+ if isinstance(df, list) and not df:return json.dumps({"ok": False, "error": f"No data returned for {symbol}"})+ if isinstance(df, dict) and not df:+ return json.dumps({"ok": False, "error": f"No data returned for {symbol}"})+ if isinstance(df, dict) and df.get("truncated") is True:+ return json.dumps(+ {+ "ok": False,+ "error": "Indicator calculation requires consecutive, untruncated bars",+ }+ )- close = df.get("close") if isinstance(df, pd.DataFrame) else None- if close is None:- # Some loaders return a dict-like structure; try common key names.- if hasattr(df, "to_dict"):- d = df.to_dict() if callable(df.to_dict) else dict(df)- for key in ("close", "Close", "CLOSE", "adj_close"):- if key in d:- close = pd.Series(d[key])- break- if close is None:+ close = _extract_close_series(df)+ if close is None or close.empty:return json.dumps({"ok": False, "error": "No close price column in data"})-- if not isinstance(close, pd.Series):- close = pd.Series(close)+ close = close.sort_index(kind="stable").tail(lookback)# ── Compute indicators ────────────────────────────────────────────indicators: dict[str, Any] = {@@ -202,7 +262,11 @@ class TechnicalIndicatorTool(BaseTool):indicators[f"ema_{_EMA_PERIOD}"] = _compute_ema(close, _EMA_PERIOD)latest_close = float(close.iloc[-1]) if len(close) > 0 else None- latest_date = str(close.index[-1])[:10] if hasattr(close, "index") and len(close) > 0 else None+ latest_date = (+ str(close.index[-1])[:10]+ if isinstance(close.index, pd.DatetimeIndex) and len(close) > 0+ else None+ )return json.dumps({diff --git a/agent/tests/test_technical_indicator_tool.py b/agent/tests/test_technical_indicator_tool.pyindex 39ae6029b..aaf1d90ba 100644--- a/agent/tests/test_technical_indicator_tool.py+++ b/agent/tests/test_technical_indicator_tool.py@@ -156,7 +156,7 @@ class TestTechnicalIndicatorToolIntegration:assert result["indicators"]["sma_200"] is not Noneassert result["indicators"]["ema_20"] is not Noneassert result["latest_close"] == 349.0- assert result["latest_date"] is not None+ assert result["latest_date"] == str(sample_df.index[-1].date())def test_execute_dataframe_with_adj_close(self, monkeypatch, sample_close):"""Loader returns 'adj_close' instead of 'close'."""@@ -220,3 +220,148 @@ class TestTechnicalIndicatorToolIntegration:assert result["indicators"]["bollinger"] is None# But SMA 20 should be null, SMA 50/200 null — only EMA 20 needs 20 bars, null tooassert result["indicators"]["sma_20"] is None+++class TestLoaderPayloadShapes:+ """Regression: #1002 — loader payloads arrive as list[dict], not DataFrame."""++ def _records(self, n: int = 30) -> list[dict]:+ """Simulate fetch_market_data's real return shape: list of OHLCV dicts."""+ return [+ {+ "trade_date": pd.Timestamp("2026-01-01") + pd.Timedelta(days=i),+ "open": float(100 + i),+ "high": float(101 + i),+ "low": float(99 + i),+ "close": float(100 + i),+ "volume": 1_000_000 + i,+ }+ for i in range(n)+ ]++ def test_list_of_dicts_success(self, monkeypatch):+ """Real fetch_market_data payload (list[dict]) must not crash (#1002)."""+ payload = {"MSFT": self._records()}+ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ lambda **kw: payload,+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT"))+ assert result["ok"] is True+ assert result["indicators"]["rsi_14"] is not None+ assert result["latest_close"] == 129.0+ assert result["latest_date"] == "2026-01-30"++ def test_wrapped_capped_payload_is_rejected(self, monkeypatch):+ """A discontinuous capped payload must never produce indicators."""+ payload = {+ "MSFT": {+ "rows": 42,+ "returned": 30,+ "truncated": True,+ "policy": "every-14th-row",+ "hint": "narrow the date range",+ "data": self._records(),+ }+ }+ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ lambda **kw: payload,+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT"))+ assert result["ok"] is False+ assert "consecutive" in result["error"]++ def test_fetches_uncapped_then_sorts_and_tails_locally(self, monkeypatch):+ """Long windows use the latest consecutive bars, not even-stride samples."""+ records = self._records(600)+ observed: dict[str, int] = {}++ def _mock_fetch(**kwargs):+ observed["max_rows"] = kwargs["max_rows"]+ if kwargs["max_rows"]:+ step = len(records) // kwargs["max_rows"]+ return {"MSFT": records[::step]}+ return {"MSFT": list(reversed(records))}++ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ _mock_fetch,+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT", lookback=30))+ assert observed["max_rows"] == 0+ assert result["ok"] is True+ assert result["latest_close"] == 699.0+ assert result["latest_date"] == "2027-08-23"+ assert result["indicators"]["sma_20"] == pytest.approx(689.5)++ def test_list_of_dicts_uppercase_key(self, monkeypatch):+ """Loader with Close key (case variant) still resolves."""+ records = self._records()+ records[0]["Close"] = records[0].pop("close")+ for r in records[1:]:+ r["Close"] = r.pop("close")+ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ lambda **kw: {"MSFT": records},+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT"))+ assert result["ok"] is True+ assert result["indicators"]["rsi_14"] is not None+ assert result["latest_date"] == "2026-01-30"++ def test_empty_list(self, monkeypatch):+ """Empty list payload → clean error, not AttributeError."""+ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ lambda **kw: {"MSFT": []},+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT"))+ assert result["ok"] is False++ def test_list_missing_close(self, monkeypatch):+ """Records without any close key → clean error."""+ records = self._records()+ for r in records:+ r.pop("close")+ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ lambda **kw: {"MSFT": records},+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT"))+ assert result["ok"] is False+ assert "close" in result["error"].lower()++ def test_dict_payload_success(self, monkeypatch):+ """dict-like payload with 'close' key still works."""+ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ lambda **kw: {"MSFT": {"close": [float(100 + i) for i in range(30)]}},+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT"))+ assert result["ok"] is True+ assert result["indicators"]["rsi_14"] is not None+ assert result["latest_date"] is None++ def test_dataframe_payload_still_works(self, monkeypatch):+ """DataFrame payload keeps working (existing loader contract)."""+ close = pd.Series(+ [float(100 + i) for i in range(30)],+ index=pd.date_range("2026-01-01", periods=30, freq="D"),+ )+ monkeypatch.setattr(+ "src.tools.technical_indicator_tool.fetch_market_data",+ lambda **kw: {"MSFT": pd.DataFrame({"close": close})},+ )+ tool = TechnicalIndicatorTool()+ result = json.loads(tool.execute(symbol="MSFT"))+ assert result["ok"] is True+ assert result["indicators"]["rsi_14"] is not None+ assert result["latest_date"] == "2026-01-30"