Skip to content

"Vibe-Trading: Your Personal Trading Agent"

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.py
index 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.py
index 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 None
assert result["indicators"]["ema_20"] is not None
assert 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 too
assert 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"