Skip to content
Python

feat: replace per-agent BM25 memory with persistent decision log (#578, #563, #564, #579)

Yijia-Xiaoebd2e12e6761
diff --cc tests/test_memory_log.py
index 000000000,c299e7fa5..915bc3b15
mode 000000,100644..100644
--- a/tests/test_memory_log.py
+++ b/tests/test_memory_log.py
@@@ -1,0 -1,648 +1,667 @@@
+ """Tests for TradingMemoryLog — storage, deferred reflection, PM injection, legacy removal."""
+
+ import pytest
+ import pandas as pd
+ from unittest.mock import MagicMock, patch
+
+ from tradingagents.agents.utils.memory import TradingMemoryLog
+ from tradingagents.graph.reflection import Reflector
+ from tradingagents.graph.trading_graph import TradingAgentsGraph
+ from tradingagents.graph.propagation import Propagator
+ from tradingagents.agents.managers.portfolio_manager import create_portfolio_manager
+
+ _SEP = TradingMemoryLog._SEPARATOR
+
+ DECISION_BUY = "Rating: Buy\nEnter at $189-192, 6% portfolio cap."
+ DECISION_OVERWEIGHT = (
+ "Rating: Overweight\n"
+ "Executive Summary: Moderate position, await confirmation.\n"
+ "Investment Thesis: Strong fundamentals but near-term headwinds."
+ )
+ DECISION_SELL = "Rating: Sell\nExit position immediately."
+ DECISION_NO_RATING = (
+ "Executive Summary: Complex situation with multiple competing factors.\n"
+ "Investment Thesis: No clear directional signal at this time."
+ )
+
+
+ # ---------------------------------------------------------------------------
+ # Shared helpers
+ # ---------------------------------------------------------------------------
+
+ def make_log(tmp_path, filename="trading_memory.md"):
+ config = {"memory_log_path": str(tmp_path / filename)}
+ return TradingMemoryLog(config)
+
+
+ def _seed_completed(tmp_path, ticker, date, decision_text, reflection_text, filename="trading_memory.md"):
+ """Write a completed entry directly to file, bypassing the API."""
+ entry = (
+ f"[{date} | {ticker} | Buy | +1.0% | +0.5% | 5d]\n\n"
+ f"DECISION:\n{decision_text}\n\n"
+ f"REFLECTION:\n{reflection_text}"
+ + _SEP
+ )
+ with open(tmp_path / filename, "a", encoding="utf-8") as f:
+ f.write(entry)
+
+
+ def _resolve_entry(log, ticker, date, decision, reflection="Good call."):
+ """Store a decision then immediately resolve it via the API."""
+ log.store_decision(ticker, date, decision)
+ log.update_with_outcome(ticker, date, 0.05, 0.02, 5, reflection)
+
+
+ def _price_df(prices):
+ """Minimal DataFrame matching yfinance .history() output shape."""
+ return pd.DataFrame({"Close": prices})
+
+
+ def _make_pm_state(past_context=""):
+ """Minimal AgentState dict for portfolio_manager_node."""
+ return {
+ "company_of_interest": "NVDA",
+ "past_context": past_context,
+ "risk_debate_state": {
+ "history": "Risk debate history.",
+ "aggressive_history": "",
+ "conservative_history": "",
+ "neutral_history": "",
+ "judge_decision": "",
+ "current_aggressive_response": "",
+ "current_conservative_response": "",
+ "current_neutral_response": "",
+ "count": 1,
+ },
+ "market_report": "Market report.",
+ "sentiment_report": "Sentiment report.",
+ "news_report": "News report.",
+ "fundamentals_report": "Fundamentals report.",
+ "investment_plan": "Research plan.",
+ "trader_investment_plan": "Trader plan.",
+ }
+
+
+ # ---------------------------------------------------------------------------
+ # Core: storage and read path
+ # ---------------------------------------------------------------------------
+
+ class TestTradingMemoryLogCore:
+
+ def test_store_creates_file(self, tmp_path):
+ log = make_log(tmp_path)
+ assert not (tmp_path / "trading_memory.md").exists()
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ assert (tmp_path / "trading_memory.md").exists()
+
+ def test_store_appends_not_overwrites(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ log.store_decision("AAPL", "2026-01-11", DECISION_OVERWEIGHT)
+ entries = log.load_entries()
+ assert len(entries) == 2
+ assert entries[0]["ticker"] == "NVDA"
+ assert entries[1]["ticker"] == "AAPL"
+
+ def test_store_decision_idempotent(self, tmp_path):
+ """Calling store_decision twice with same (ticker, date) stores only one entry."""
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ assert len(log.load_entries()) == 1
+
+ def test_batch_update_resolves_multiple_entries(self, tmp_path):
+ """batch_update_with_outcomes resolves multiple pending entries in one write."""
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-05", DECISION_BUY)
+ log.store_decision("NVDA", "2026-01-12", DECISION_SELL)
+
+ updates = [
+ {"ticker": "NVDA", "trade_date": "2026-01-05",
+ "raw_return": 0.05, "alpha_return": 0.02, "holding_days": 5,
+ "reflection": "First correct."},
+ {"ticker": "NVDA", "trade_date": "2026-01-12",
+ "raw_return": -0.03, "alpha_return": -0.01, "holding_days": 5,
+ "reflection": "Second correct."},
+ ]
+ log.batch_update_with_outcomes(updates)
+
+ entries = log.load_entries()
+ assert len(entries) == 2
+ assert all(not e["pending"] for e in entries)
+ assert entries[0]["reflection"] == "First correct."
+ assert entries[1]["reflection"] == "Second correct."
+
+ def test_pending_tag_format(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ text = (tmp_path / "trading_memory.md").read_text(encoding="utf-8")
+ assert "[2026-01-10 | NVDA | Buy | pending]" in text
+
+ # Rating parsing
+
+ def test_rating_parsed_buy(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ assert log.load_entries()[0]["rating"] == "Buy"
+
+ def test_rating_parsed_overweight(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("AAPL", "2026-01-11", DECISION_OVERWEIGHT)
+ assert log.load_entries()[0]["rating"] == "Overweight"
+
+ def test_rating_fallback_hold(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("MSFT", "2026-01-12", DECISION_NO_RATING)
+ assert log.load_entries()[0]["rating"] == "Hold"
+
+ def test_rating_priority_over_prose(self, tmp_path):
+ """'Rating: X' label wins even when an opposing rating word appears earlier in prose."""
+ decision = (
+ "The sell thesis is weak. The hold case is marginal.\n\n"
+ "Rating: Buy\n\n"
+ "Executive Summary: Strong fundamentals support the position."
+ )
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", decision)
+ assert log.load_entries()[0]["rating"] == "Buy"
+
+ # Delimiter robustness
+
+ def test_decision_with_markdown_separator(self, tmp_path):
+ """LLM decision containing '---' must not corrupt the entry."""
+ decision = "Rating: Buy\n\n---\n\nRisk: elevated volatility."
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", decision)
+ entries = log.load_entries()
+ assert len(entries) == 1
+ assert "Risk: elevated volatility" in entries[0]["decision"]
+
+ # load_entries
+
+ def test_load_entries_empty_file(self, tmp_path):
+ log = make_log(tmp_path)
+ assert log.load_entries() == []
+
+ def test_load_entries_single(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ entries = log.load_entries()
+ assert len(entries) == 1
+ e = entries[0]
+ assert e["date"] == "2026-01-10"
+ assert e["ticker"] == "NVDA"
+ assert e["rating"] == "Buy"
+ assert e["pending"] is True
+ assert e["raw"] is None
+
+ def test_load_entries_multiple(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ log.store_decision("AAPL", "2026-01-11", DECISION_OVERWEIGHT)
+ log.store_decision("MSFT", "2026-01-12", DECISION_NO_RATING)
+ entries = log.load_entries()
+ assert len(entries) == 3
+ assert [e["ticker"] for e in entries] == ["NVDA", "AAPL", "MSFT"]
+
+ def test_decision_content_preserved(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ assert log.load_entries()[0]["decision"] == DECISION_BUY.strip()
+
+ # get_pending_entries
+
+ def test_get_pending_returns_pending_only(self, tmp_path):
+ log = make_log(tmp_path)
+ _seed_completed(tmp_path, "NVDA", "2026-01-05", "Buy NVDA.", "Correct.")
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ pending = log.get_pending_entries()
+ assert len(pending) == 1
+ assert pending[0]["ticker"] == "NVDA"
+ assert pending[0]["date"] == "2026-01-10"
+
+ # get_past_context
+
+ def test_get_past_context_empty(self, tmp_path):
+ log = make_log(tmp_path)
+ assert log.get_past_context("NVDA") == ""
+
+ def test_get_past_context_pending_excluded(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ assert log.get_past_context("NVDA") == ""
+
+ def test_get_past_context_same_ticker(self, tmp_path):
+ log = make_log(tmp_path)
+ _seed_completed(tmp_path, "NVDA", "2026-01-05", "Buy NVDA — AI capex thesis intact.", "Directionally correct.")
+ ctx = log.get_past_context("NVDA")
+ assert "Past analyses of NVDA" in ctx
+ assert "Buy NVDA" in ctx
+
+ def test_get_past_context_cross_ticker(self, tmp_path):
+ log = make_log(tmp_path)
+ _seed_completed(tmp_path, "AAPL", "2026-01-05", "Buy AAPL — Services growth.", "Correct.")
+ ctx = log.get_past_context("NVDA")
+ assert "Recent cross-ticker lessons" in ctx
+ assert "Past analyses of NVDA" not in ctx
+
+ def test_n_same_limit_respected(self, tmp_path):
+ """Only the n_same most recent same-ticker entries are included."""
+ log = make_log(tmp_path)
+ for i in range(6):
+ _seed_completed(tmp_path, "NVDA", f"2026-01-{i+1:02d}", f"Buy entry {i}.", "Correct.")
+ ctx = log.get_past_context("NVDA", n_same=5)
+ assert "Buy entry 0" not in ctx
+ assert "Buy entry 5" in ctx
+
+ def test_n_cross_limit_respected(self, tmp_path):
+ """Only the n_cross most recent cross-ticker entries are included."""
+ log = make_log(tmp_path)
+ for i, ticker in enumerate(["AAPL", "MSFT", "GOOG", "META"]):
+ _seed_completed(tmp_path, ticker, f"2026-01-{i+1:02d}", f"Buy {ticker}.", "Correct.")
+ ctx = log.get_past_context("NVDA", n_cross=3)
+ assert "AAPL" not in ctx
+ assert "META" in ctx
+
+ # No-op when config is None
+
+ def test_no_log_path_is_noop(self):
+ log = TradingMemoryLog(config=None)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ assert log.load_entries() == []
+ assert log.get_past_context("NVDA") == ""
+
+ # Rating parsing: markdown bold and numbered list formats
+
+ def test_rating_parsed_from_bold_markdown(self, tmp_path):
- """**Rating**: Buy — markdown bold wrapper must not prevent parsing."""
++ """**Rating**: Buy — markdown bold around the label must not prevent parsing."""
+ decision = "**Rating**: Buy\nEnter at $190."
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", decision)
+ assert log.load_entries()[0]["rating"] == "Buy"
+
++ def test_rating_parsed_from_bold_value(self, tmp_path):
++ """Rating: **Sell** — markdown bold around the value must not prevent parsing."""
++ decision = "Rating: **Sell**\nExit immediately."
++ log = make_log(tmp_path)
++ log.store_decision("NVDA", "2026-01-10", decision)
++ assert log.load_entries()[0]["rating"] == "Sell"
++
++ def test_rating_label_wins_over_prose_with_markdown(self, tmp_path):
++ """Rating: **Sell** must win even when prose contains a conflicting rating word."""
++ decision = (
++ "The buy thesis is weakened by guidance.\n"
++ "Rating: **Sell**\n"
++ "Exit before earnings."
++ )
++ log = make_log(tmp_path)
++ log.store_decision("NVDA", "2026-01-10", decision)
++ assert log.load_entries()[0]["rating"] == "Sell"
++
+ def test_rating_parsed_from_numbered_list(self, tmp_path):
+ """1. Rating: Buy — numbered list prefix must not prevent parsing."""
+ decision = "1. Rating: Buy\nEnter at $190."
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", decision)
+ assert log.load_entries()[0]["rating"] == "Buy"
+
+
+ # ---------------------------------------------------------------------------
+ # Deferred reflection: update_with_outcome, Reflector, _fetch_returns
+ # ---------------------------------------------------------------------------
+
+ class TestDeferredReflection:
+
+ # update_with_outcome
+
+ def test_update_replaces_pending_tag(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ log.update_with_outcome("NVDA", "2026-01-10", 0.042, 0.021, 5, "Momentum confirmed.")
+ text = (tmp_path / "trading_memory.md").read_text(encoding="utf-8")
+ assert "[2026-01-10 | NVDA | Buy | pending]" not in text
+ assert "+4.2%" in text
+ assert "+2.1%" in text
+ assert "5d" in text
+
+ def test_update_appends_reflection(self, tmp_path):
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ log.update_with_outcome("NVDA", "2026-01-10", 0.042, 0.021, 5, "Momentum confirmed.")
+ entries = log.load_entries()
+ assert len(entries) == 1
+ e = entries[0]
+ assert e["pending"] is False
+ assert e["reflection"] == "Momentum confirmed."
+ assert e["decision"] == DECISION_BUY.strip()
+
+ def test_update_preserves_other_entries(self, tmp_path):
+ """Only the matching entry is modified; all other entries remain unchanged."""
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ log.store_decision("AAPL", "2026-01-11", "Rating: Hold\nHold AAPL.")
+ log.store_decision("MSFT", "2026-01-12", DECISION_SELL)
+ log.update_with_outcome("AAPL", "2026-01-11", 0.01, -0.01, 5, "Neutral result.")
+ entries = log.load_entries()
+ assert len(entries) == 3
+ nvda, aapl, msft = entries
+ assert nvda["ticker"] == "NVDA" and nvda["pending"] is True
+ assert aapl["ticker"] == "AAPL" and aapl["pending"] is False
+ assert aapl["reflection"] == "Neutral result."
+ assert msft["ticker"] == "MSFT" and msft["pending"] is True
+
+ def test_update_atomic_write(self, tmp_path):
+ """A pre-existing .tmp file is overwritten; the log is correctly updated."""
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ stale_tmp = tmp_path / "trading_memory.tmp"
+ stale_tmp.write_text("GARBAGE CONTENT — should be overwritten", encoding="utf-8")
+ log.update_with_outcome("NVDA", "2026-01-10", 0.042, 0.021, 5, "Correct.")
+ assert not stale_tmp.exists()
+ entries = log.load_entries()
+ assert len(entries) == 1
+ assert entries[0]["reflection"] == "Correct."
+ assert entries[0]["pending"] is False
+
+ def test_update_noop_when_no_log_path(self):
+ log = TradingMemoryLog(config=None)
+ log.update_with_outcome("NVDA", "2026-01-10", 0.05, 0.02, 5, "Reflection")
+
+ def test_formatting_roundtrip_after_update(self, tmp_path):
+ """All fields intact and blank line between tag and DECISION preserved after update."""
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-10", DECISION_BUY)
+ log.update_with_outcome("NVDA", "2026-01-10", 0.042, 0.021, 5, "Momentum confirmed.")
+ entries = log.load_entries()
+ assert len(entries) == 1
+ e = entries[0]
+ assert e["pending"] is False
+ assert e["decision"] == DECISION_BUY.strip()
+ assert e["reflection"] == "Momentum confirmed."
+ assert e["raw"] == "+4.2%"
+ assert e["alpha"] == "+2.1%"
+ assert e["holding"] == "5d"
+ raw_text = (tmp_path / "trading_memory.md").read_text(encoding="utf-8")
+ assert "[2026-01-10 | NVDA | Buy | +4.2% | +2.1% | 5d]\n\nDECISION:" in raw_text
+
+ # Reflector.reflect_on_final_decision
+
+ def test_reflect_on_final_decision_returns_llm_output(self):
+ mock_llm = MagicMock()
+ mock_llm.invoke.return_value.content = "Directionally correct. Thesis confirmed."
+ reflector = Reflector(mock_llm)
+ result = reflector.reflect_on_final_decision(
+ final_decision=DECISION_BUY, raw_return=0.042, alpha_return=0.021
+ )
+ assert result == "Directionally correct. Thesis confirmed."
+ mock_llm.invoke.assert_called_once()
+
+ def test_reflect_on_final_decision_includes_returns_in_prompt(self):
+ """Return figures are present in the human message sent to the LLM."""
+ mock_llm = MagicMock()
+ mock_llm.invoke.return_value.content = "Incorrect call."
+ reflector = Reflector(mock_llm)
+ reflector.reflect_on_final_decision(
+ final_decision=DECISION_SELL, raw_return=-0.08, alpha_return=-0.05
+ )
+ messages = mock_llm.invoke.call_args[0][0]
+ human_content = next(content for role, content in messages if role == "human")
+ assert "-8.0%" in human_content
+ assert "-5.0%" in human_content
+ assert "Exit position immediately." in human_content
+
+ # TradingAgentsGraph._fetch_returns
+
+ def test_fetch_returns_valid_ticker(self):
+ stock_prices = [100.0, 102.0, 104.0, 103.0, 105.0, 106.0]
+ spy_prices = [400.0, 402.0, 404.0, 403.0, 405.0, 406.0]
+ mock_graph = MagicMock(spec=TradingAgentsGraph)
+ with patch("yfinance.Ticker") as mock_ticker_cls:
+ def _make_ticker(sym):
+ m = MagicMock()
+ m.history.return_value = _price_df(spy_prices if sym == "SPY" else stock_prices)
+ return m
+ mock_ticker_cls.side_effect = _make_ticker
+ raw, alpha, days = TradingAgentsGraph._fetch_returns(mock_graph, "NVDA", "2026-01-05")
+ assert raw is not None and alpha is not None and days is not None
+ assert isinstance(raw, float) and isinstance(alpha, float) and isinstance(days, int)
+ assert days == 5
+
+ def test_fetch_returns_too_recent(self):
+ """Only 1 data point available → returns (None, None, None), no crash."""
+ mock_graph = MagicMock(spec=TradingAgentsGraph)
+ with patch("yfinance.Ticker") as mock_ticker_cls:
+ m = MagicMock()
+ m.history.return_value = _price_df([100.0])
+ mock_ticker_cls.return_value = m
+ raw, alpha, days = TradingAgentsGraph._fetch_returns(mock_graph, "NVDA", "2026-04-19")
+ assert raw is None and alpha is None and days is None
+
+ def test_fetch_returns_delisted(self):
+ """Empty DataFrame → returns (None, None, None), no crash."""
+ mock_graph = MagicMock(spec=TradingAgentsGraph)
+ with patch("yfinance.Ticker") as mock_ticker_cls:
+ m = MagicMock()
+ m.history.return_value = pd.DataFrame({"Close": []})
+ mock_ticker_cls.return_value = m
+ raw, alpha, days = TradingAgentsGraph._fetch_returns(mock_graph, "XXXXXFAKE", "2026-01-10")
+ assert raw is None and alpha is None and days is None
+
+ def test_fetch_returns_spy_shorter_than_stock(self):
+ """SPY having fewer rows than the stock must not raise IndexError."""
+ stock_prices = [100.0, 102.0, 104.0, 103.0, 105.0, 106.0]
+ spy_prices = [400.0, 402.0, 403.0]
+ mock_graph = MagicMock(spec=TradingAgentsGraph)
+ with patch("yfinance.Ticker") as mock_ticker_cls:
+ def _make_ticker(sym):
+ m = MagicMock()
+ m.history.return_value = _price_df(spy_prices if sym == "SPY" else stock_prices)
+ return m
+ mock_ticker_cls.side_effect = _make_ticker
+ raw, alpha, days = TradingAgentsGraph._fetch_returns(mock_graph, "NVDA", "2026-01-05")
+ assert raw is not None and alpha is not None and days is not None
+ assert days == 2
+
+ # TradingAgentsGraph._resolve_pending_entries
+
+ def test_resolve_skips_other_tickers(self, tmp_path):
+ """Pending AAPL entry is not resolved when the run is for NVDA."""
+ log = make_log(tmp_path)
+ log.store_decision("AAPL", "2026-01-10", DECISION_BUY)
+ mock_graph = MagicMock(spec=TradingAgentsGraph)
+ mock_graph.memory_log = log
+ mock_graph._fetch_returns = MagicMock(return_value=(0.05, 0.02, 5))
+ TradingAgentsGraph._resolve_pending_entries(mock_graph, "NVDA")
+ mock_graph._fetch_returns.assert_not_called()
+ assert len(log.get_pending_entries()) == 1
+
+ def test_resolve_marks_entry_completed(self, tmp_path):
+ """After resolve, get_pending_entries() is empty and the entry has a REFLECTION."""
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-05", DECISION_BUY)
+ mock_reflector = MagicMock()
+ mock_reflector.reflect_on_final_decision.return_value = "Momentum confirmed."
+ mock_graph = MagicMock(spec=TradingAgentsGraph)
+ mock_graph.memory_log = log
+ mock_graph.reflector = mock_reflector
+ mock_graph._fetch_returns = MagicMock(return_value=(0.05, 0.02, 5))
+ TradingAgentsGraph._resolve_pending_entries(mock_graph, "NVDA")
+ assert log.get_pending_entries() == []
+ entries = log.load_entries()
+ assert len(entries) == 1
+ assert entries[0]["pending"] is False
+ assert entries[0]["reflection"] == "Momentum confirmed."
+ assert "+5.0%" in entries[0]["raw"]
+ assert "+2.0%" in entries[0]["alpha"]
+
+
+ # ---------------------------------------------------------------------------
+ # Portfolio Manager injection: past_context in state and prompt
+ # ---------------------------------------------------------------------------
+
+ class TestPortfolioManagerInjection:
+
+ # past_context in initial state
+
+ def test_past_context_in_initial_state(self):
+ propagator = Propagator()
+ state = propagator.create_initial_state("NVDA", "2026-01-10", past_context="some context")
+ assert "past_context" in state
+ assert state["past_context"] == "some context"
+
+ def test_past_context_defaults_to_empty(self):
+ propagator = Propagator()
+ state = propagator.create_initial_state("NVDA", "2026-01-10")
+ assert state["past_context"] == ""
+
+ # PM prompt
+
+ def test_pm_prompt_includes_past_context(self):
+ captured = {}
+ mock_llm = MagicMock()
+ mock_llm.invoke.side_effect = lambda prompt: (
+ captured.__setitem__("prompt", prompt) or MagicMock(content="Rating: Hold\nHold.")
+ )
+ pm_node = create_portfolio_manager(mock_llm)
+ state = _make_pm_state(past_context="[2026-01-05 | NVDA | Buy | +5.0% | +2.0% | 5d]\nGreat call.")
+ pm_node(state)
- assert "Past decisions on this stock" in captured["prompt"]
++ assert "Lessons from prior decisions and outcomes" in captured["prompt"]
+ assert "Great call." in captured["prompt"]
++ assert "and the lessons from prior decisions" in captured["prompt"]
+
+ def test_pm_no_past_context_no_section(self):
+ """PM prompt omits the lessons section entirely when past_context is empty."""
+ captured = {}
+ mock_llm = MagicMock()
+ mock_llm.invoke.side_effect = lambda prompt: (
+ captured.__setitem__("prompt", prompt) or MagicMock(content="Rating: Hold\nHold.")
+ )
+ pm_node = create_portfolio_manager(mock_llm)
+ state = _make_pm_state(past_context="")
+ pm_node(state)
- assert "Past decisions on this stock" not in captured["prompt"]
- assert "lessons learned" not in captured["prompt"]
++ assert "Lessons from prior decisions" not in captured["prompt"]
++ assert "and the lessons from prior decisions" not in captured["prompt"]
+
+ # get_past_context ordering and limits
+
+ def test_same_ticker_prioritised(self, tmp_path):
+ """Same-ticker entries in same-ticker section; cross-ticker entries in cross-ticker section."""
+ log = make_log(tmp_path)
+ _resolve_entry(log, "NVDA", "2026-01-05", DECISION_BUY, "Momentum confirmed.")
+ _resolve_entry(log, "AAPL", "2026-01-06", DECISION_SELL, "Overvalued.")
+ result = log.get_past_context("NVDA")
+ assert "Past analyses of NVDA" in result
+ assert "Recent cross-ticker lessons" in result
+ same_block, cross_block = result.split("Recent cross-ticker lessons")
+ assert "NVDA" in same_block
+ assert "AAPL" in cross_block
+
+ def test_cross_ticker_reflection_only(self, tmp_path):
+ """Cross-ticker entries show only the REFLECTION text, not the full DECISION."""
+ log = make_log(tmp_path)
+ _resolve_entry(log, "AAPL", "2026-01-06", DECISION_SELL, "Overvalued correction.")
+ result = log.get_past_context("NVDA")
+ assert "Overvalued correction." in result
+ assert "Exit position immediately." not in result
+
+ def test_n_same_limit_respected(self, tmp_path):
+ """More than 5 same-ticker completed entries → only 5 injected."""
+ log = make_log(tmp_path)
+ for i in range(7):
+ _resolve_entry(log, "NVDA", f"2026-01-{i+1:02d}", DECISION_BUY, f"Lesson {i}.")
+ result = log.get_past_context("NVDA", n_same=5)
+ lessons_present = sum(1 for i in range(7) if f"Lesson {i}." in result)
+ assert lessons_present == 5
+
+ def test_n_cross_limit_respected(self, tmp_path):
+ """More than 3 cross-ticker completed entries → only 3 injected."""
+ log = make_log(tmp_path)
+ tickers = ["AAPL", "MSFT", "TSLA", "AMZN", "GOOG"]
+ for i, ticker in enumerate(tickers):
+ _resolve_entry(log, ticker, f"2026-01-{i+1:02d}", DECISION_BUY, f"{ticker} lesson.")
+ result = log.get_past_context("NVDA", n_cross=3)
+ cross_count = sum(result.count(f"{t} lesson.") for t in tickers)
+ assert cross_count == 3
+
+ # Full A→B→C integration cycle
+
+ def test_full_cycle_store_resolve_inject(self, tmp_path):
+ """store pending → resolve with outcome → past_context non-empty for PM."""
+ log = make_log(tmp_path)
+ log.store_decision("NVDA", "2026-01-05", DECISION_BUY)
+ assert len(log.get_pending_entries()) == 1
+ assert log.get_past_context("NVDA") == ""
+ log.update_with_outcome("NVDA", "2026-01-05", 0.05, 0.02, 5, "Correct call.")
+ assert log.get_pending_entries() == []
+ past_ctx = log.get_past_context("NVDA")
+ assert past_ctx != ""
+ assert "NVDA" in past_ctx
+ assert "Correct call." in past_ctx
+ assert "DECISION:" in past_ctx
+ assert "REFLECTION:" in past_ctx
+
+
+ # ---------------------------------------------------------------------------
+ # Legacy removal: BM25 / FinancialSituationMemory fully gone
+ # ---------------------------------------------------------------------------
+
+ class TestLegacyRemoval:
+
+ def test_financial_situation_memory_removed(self):
+ """FinancialSituationMemory must not be importable from the memory module."""
+ import tradingagents.agents.utils.memory as m
+ assert not hasattr(m, "FinancialSituationMemory")
+
+ def test_bm25_not_imported(self):
+ """rank_bm25 must not be present in the memory module namespace."""
+ import tradingagents.agents.utils.memory as m
+ assert not hasattr(m, "BM25Okapi")
+
+ def test_reflect_and_remember_removed(self):
+ """TradingAgentsGraph must not expose reflect_and_remember."""
+ assert not hasattr(TradingAgentsGraph, "reflect_and_remember")
+
+ def test_portfolio_manager_no_memory_param(self):
+ """create_portfolio_manager accepts only llm; passing memory= raises TypeError."""
+ mock_llm = MagicMock()
+ create_portfolio_manager(mock_llm)
+ with pytest.raises(TypeError):
+ create_portfolio_manager(mock_llm, memory=MagicMock())
+
+ def test_full_pipeline_no_regression(self, tmp_path):
+ """propagate() completes without AttributeError after legacy cleanup."""
+ fake_state = {
+ "final_trade_decision": "Rating: Buy\nBuy NVDA.",
+ "company_of_interest": "NVDA",
+ "trade_date": "2026-01-10",
+ "market_report": "",
+ "sentiment_report": "",
+ "news_report": "",
+ "fundamentals_report": "",
+ "investment_debate_state": {
+ "bull_history": "", "bear_history": "", "history": "",
+ "current_response": "", "judge_decision": "",
+ },
+ "investment_plan": "",
+ "trader_investment_plan": "",
+ "risk_debate_state": {
+ "aggressive_history": "", "conservative_history": "",
+ "neutral_history": "", "history": "", "judge_decision": "",
+ "current_aggressive_response": "", "current_conservative_response": "",
+ "current_neutral_response": "", "count": 1, "latest_speaker": "",
+ },
+ }
+ mock_graph = MagicMock()
+ mock_graph.memory_log = TradingMemoryLog({"memory_log_path": str(tmp_path / "mem.md")})
+ mock_graph.log_states_dict = {}
+ mock_graph.debug = False
+ mock_graph.config = {"results_dir": str(tmp_path)}
+ mock_graph.graph.invoke.return_value = fake_state
+ mock_graph.propagator.create_initial_state.return_value = fake_state
+ mock_graph.propagator.get_graph_args.return_value = {}
+ mock_graph.signal_processor.process_signal.return_value = "Buy"
+ TradingAgentsGraph.propagate(mock_graph, "NVDA", "2026-01-10")
+ entries = mock_graph.memory_log.load_entries()
+ assert len(entries) == 1
+ assert entries[0]["ticker"] == "NVDA"
+ assert entries[0]["pending"] is True
diff --cc tradingagents/agents/managers/portfolio_manager.py
index 5d4631b82,215236156..6780c7dc1
--- a/tradingagents/agents/managers/portfolio_manager.py
+++ b/tradingagents/agents/managers/portfolio_manager.py
@@@ -15,23 -15,11 +15,16 @@@ def create_portfolio_manager(llm)
research_plan = state["investment_plan"]
trader_plan = state["trader_investment_plan"]
- curr_situation = f"{market_research_report}\n\n{sentiment_report}\n\n{news_report}\n\n{fundamentals_report}"
- past_memories = memory.get_memories(curr_situation, n_matches=2)
-
- past_memory_str = ""
- for i, rec in enumerate(past_memories, 1):
- past_memory_str += rec["recommendation"] + "\n\n"
-
+ past_context = state.get("past_context", "")
lessons_line = (
- f"- Lessons from past decisions: **{past_memory_str.strip()}**\n"
- if past_memories
- else ""
- f"- Past decisions on this stock and lessons learned:\n{past_context}\n"
++ f"- Lessons from prior decisions and outcomes:\n{past_context}\n"
+ if past_context else ""
)
+ thesis_instruction = (
- "3. **Investment Thesis**: Detailed reasoning anchored in the analysts' debate and past reflections."
- if past_memories
++ "3. **Investment Thesis**: Detailed reasoning anchored in the analysts' debate and the lessons from prior decisions."
++ if past_context
+ else "3. **Investment Thesis**: Detailed reasoning anchored in the analysts' debate."
+ )
prompt = f"""As the Portfolio Manager, synthesize the risk analysts' debate and deliver the final trading decision.
diff --cc tradingagents/agents/utils/memory.py
index 2aefa7a38,fd14449e3..199cb8946
--- a/tradingagents/agents/utils/memory.py
+++ b/tradingagents/agents/utils/memory.py
@@@ -9,136 -5,268 +5,268 @@@ from pathlib import Pat
import re
- class FinancialSituationMemory:
- """Memory system for storing and retrieving financial situations using BM25."""
+ class TradingMemoryLog:
+ """Append-only markdown log of trading decisions and reflections."""
- def __init__(self, name: str, config: dict = None):
- """Initialize the memory system.
+ RATINGS = {"buy", "overweight", "hold", "underweight", "sell"}
+ # HTML comment: cannot appear in LLM prose output, safe as a hard delimiter
+ _SEPARATOR = "\n\n<!-- ENTRY_END -->\n\n"
+ # Precompiled patterns — avoids re-compilation on every load_entries() call
+ _DECISION_RE = re.compile(r"DECISION:\n(.*?)(?=\nREFLECTION:|\Z)", re.DOTALL)
+ _REFLECTION_RE = re.compile(r"REFLECTION:\n(.*?)$", re.DOTALL)
- _RATING_LABEL_RE = re.compile(r"rating.*?[:\-]\s*(\w+)", re.IGNORECASE)
++ _RATING_LABEL_RE = re.compile(r"rating.*?[:\-][\s*]*(\w+)", re.IGNORECASE)
- Args:
- name: Name identifier for this memory instance
- config: Configuration dict (kept for API compatibility, not used for BM25)
- """
- self.name = name
- self.documents: List[str] = []
- self.recommendations: List[str] = []
- self.bm25 = None
+ def __init__(self, config: dict = None):
+ self._log_path = None
+ path = (config or {}).get("memory_log_path")
+ if path:
+ self._log_path = Path(path).expanduser()
+ self._log_path.parent.mkdir(parents=True, exist_ok=True)
- def _tokenize(self, text: str) -> List[str]:
- """Tokenize text for BM25 indexing.
+ # --- Write path (Phase A) ---
- Simple whitespace + punctuation tokenization with lowercasing.
- """
- # Lowercase and split on non-alphanumeric characters
- tokens = re.findall(r'\b\w+\b', text.lower())
- return tokens
-
- def _rebuild_index(self):
- """Rebuild the BM25 index after adding documents."""
- if self.documents:
- tokenized_docs = [self._tokenize(doc) for doc in self.documents]
- self.bm25 = BM25Okapi(tokenized_docs)
- else:
- self.bm25 = None
-
- def add_situations(self, situations_and_advice: List[Tuple[str, str]]):
- """Add financial situations and their corresponding advice.
-
- Args:
- situations_and_advice: List of tuples (situation, recommendation)
+ def store_decision(
+ self,
+ ticker: str,
+ trade_date: str,
+ final_trade_decision: str,
+ ) -> None:
+ """Append pending entry at end of propagate(). No LLM call."""
+ if not self._log_path:
+ return
+ # Idempotency guard: fast raw-text scan instead of full parse
+ if self._log_path.exists():
+ raw = self._log_path.read_text(encoding="utf-8")
+ for line in raw.splitlines():
+ if line.startswith(f"[{trade_date} | {ticker} |") and line.endswith("| pending]"):
+ return
+ rating = self._parse_rating(final_trade_decision)
+ tag = f"[{trade_date} | {ticker} | {rating} | pending]"
+ entry = f"{tag}\n\nDECISION:\n{final_trade_decision}{self._SEPARATOR}"
+ with open(self._log_path, "a", encoding="utf-8") as f:
+ f.write(entry)
+
+ # --- Read path (Phase A) ---
+
+ def load_entries(self) -> List[dict]:
+ """Parse all entries from log. Returns list of dicts."""
+ if not self._log_path or not self._log_path.exists():
+ return []
+ text = self._log_path.read_text(encoding="utf-8")
+ raw_entries = [e.strip() for e in text.split(self._SEPARATOR) if e.strip()]
+ entries = []
+ for raw in raw_entries:
+ parsed = self._parse_entry(raw)
+ if parsed:
+ entries.append(parsed)
+ return entries
+
+ def get_pending_entries(self) -> List[dict]:
+ """Return entries with outcome:pending (for Phase B)."""
+ return [e for e in self.load_entries() if e.get("pending")]
+
+ def get_past_context(self, ticker: str, n_same: int = 5, n_cross: int = 3) -> str:
+ """Return formatted past context string for agent prompt injection."""
+ entries = [e for e in self.load_entries() if not e.get("pending")]
+ if not entries:
+ return ""
+
+ same, cross = [], []
+ for e in reversed(entries):
+ if len(same) >= n_same and len(cross) >= n_cross:
+ break
+ if e["ticker"] == ticker and len(same) < n_same:
+ same.append(e)
+ elif e["ticker"] != ticker and len(cross) < n_cross:
+ cross.append(e)
+
+ if not same and not cross:
+ return ""
+
+ parts = []
+ if same:
+ parts.append(f"Past analyses of {ticker} (most recent first):")
+ parts.extend(self._format_full(e) for e in same)
+ if cross:
+ parts.append("Recent cross-ticker lessons:")
+ parts.extend(self._format_reflection_only(e) for e in cross)
+ return "\n\n".join(parts)
+
+ # --- Update path (Phase B) ---
+
+ def update_with_outcome(
+ self,
+ ticker: str,
+ trade_date: str,
+ raw_return: float,
+ alpha_return: float,
+ holding_days: int,
+ reflection: str,
+ ) -> None:
+ """Replace pending tag and append REFLECTION section using atomic write.
+
+ Finds the first pending entry matching (trade_date, ticker), updates
+ its tag with return figures, and appends a REFLECTION section. Uses
+ a temp-file + os.replace() so a crash mid-write never corrupts the log.
"""
- for situation, recommendation in situations_and_advice:
- self.documents.append(situation)
- self.recommendations.append(recommendation)
+ if not self._log_path or not self._log_path.exists():
+ return
+
+ text = self._log_path.read_text(encoding="utf-8")
+ blocks = text.split(self._SEPARATOR)
+
+ pending_prefix = f"[{trade_date} | {ticker} |"
+ raw_pct = f"{raw_return:+.1%}"
+ alpha_pct = f"{alpha_return:+.1%}"
- # Rebuild BM25 index with new documents
- self._rebuild_index()
+ updated = False
+ new_blocks = []
+ for block in blocks:
+ stripped = block.strip()
+ if not stripped:
+ new_blocks.append(block)
+ continue
- def get_memories(self, current_situation: str, n_matches: int = 1) -> List[dict]:
- """Find matching recommendations using BM25 similarity.
+ lines = stripped.splitlines()
+ tag_line = lines[0].strip()
- Args:
- current_situation: The current financial situation to match against
- n_matches: Number of top matches to return
+ if (
+ not updated
+ and tag_line.startswith(pending_prefix)
+ and tag_line.endswith("| pending]")
+ ):
+ # Parse rating from the existing pending tag
+ fields = [f.strip() for f in tag_line[1:-1].split("|")]
+ rating = fields[2]
+ new_tag = (
+ f"[{trade_date} | {ticker} | {rating}"
+ f" | {raw_pct} | {alpha_pct} | {holding_days}d]"
+ )
+ rest = "\n".join(lines[1:])
+ new_blocks.append(
+ f"{new_tag}\n\n{rest.lstrip()}\n\nREFLECTION:\n{reflection}"
+ )
+ updated = True
+ else:
+ new_blocks.append(block)
- Returns:
- List of dicts with matched_situation, recommendation, and similarity_score
+ if not updated:
+ return
+
+ new_text = self._SEPARATOR.join(new_blocks)
+ tmp_path = self._log_path.with_suffix(".tmp")
+ tmp_path.write_text(new_text, encoding="utf-8")
+ tmp_path.replace(self._log_path)
+
+ def batch_update_with_outcomes(self, updates: List[dict]) -> None:
+ """Apply multiple outcome updates in a single read + atomic write.
+
+ Each element of updates must have keys: ticker, trade_date,
+ raw_return, alpha_return, holding_days, reflection.
"""
- if not self.documents or self.bm25 is None:
- return []
+ if not self._log_path or not self._log_path.exists() or not updates:
+ return
+
+ text = self._log_path.read_text(encoding="utf-8")
+ blocks = text.split(self._SEPARATOR)
+
+ # Build lookup keyed by (trade_date, ticker) for O(1) dispatch
+ update_map = {(u["trade_date"], u["ticker"]): u for u in updates}
+
+ new_blocks = []
+ for block in blocks:
+ stripped = block.strip()
+ if not stripped:
+ new_blocks.append(block)
+ continue
+
+ lines = stripped.splitlines()
+ tag_line = lines[0].strip()
+
+ matched = False
+ for (trade_date, ticker), upd in list(update_map.items()):
+ pending_prefix = f"[{trade_date} | {ticker} |"
+ if tag_line.startswith(pending_prefix) and tag_line.endswith("| pending]"):
+ fields = [f.strip() for f in tag_line[1:-1].split("|")]
+ rating = fields[2]
+ raw_pct = f"{upd['raw_return']:+.1%}"
+ alpha_pct = f"{upd['alpha_return']:+.1%}"
+ new_tag = (
+ f"[{trade_date} | {ticker} | {rating}"
+ f" | {raw_pct} | {alpha_pct} | {upd['holding_days']}d]"
+ )
+ rest = "\n".join(lines[1:])
+ new_blocks.append(
+ f"{new_tag}\n\n{rest.lstrip()}\n\nREFLECTION:\n{upd['reflection']}"
+ )
+ del update_map[(trade_date, ticker)]
+ matched = True
+ break
+
+ if not matched:
+ new_blocks.append(block)
+
+ new_text = self._SEPARATOR.join(new_blocks)
+ tmp_path = self._log_path.with_suffix(".tmp")
+ tmp_path.write_text(new_text, encoding="utf-8")
+ tmp_path.replace(self._log_path)
+
+ # --- Helpers ---
+
+ def _parse_rating(self, text: str) -> str:
+ # First pass: explicit "Rating: X" label — search handles markdown bold/numbered lists
+ for line in text.splitlines():
+ m = self._RATING_LABEL_RE.search(line)
+ if m and m.group(1).lower() in self.RATINGS:
+ return m.group(1).capitalize()
+ # Fallback: first rating word found anywhere in the text
+ for line in text.splitlines():
+ for word in line.lower().split():
+ clean = word.strip("*:.,")
+ if clean in self.RATINGS:
+ return clean.capitalize()
+ return "Hold"
+
+ def _parse_entry(self, raw: str) -> Optional[dict]:
+ lines = raw.strip().splitlines()
+ if not lines:
+ return None
+ tag_line = lines[0].strip()
+ if not (tag_line.startswith("[") and tag_line.endswith("]")):
+ return None
+ fields = [f.strip() for f in tag_line[1:-1].split("|")]
+ if len(fields) < 4:
+ return None
+ entry = {
+ "date": fields[0],
+ "ticker": fields[1],
+ "rating": fields[2],
+ "pending": fields[3] == "pending",
+ "raw": fields[3] if fields[3] != "pending" else None,
+ "alpha": fields[4] if len(fields) > 4 else None,
+ "holding": fields[5] if len(fields) > 5 else None,
+ }
+ body = "\n".join(lines[1:]).strip()
+ decision_match = self._DECISION_RE.search(body)
+ reflection_match = self._REFLECTION_RE.search(body)
+ entry["decision"] = decision_match.group(1).strip() if decision_match else ""
+ entry["reflection"] = reflection_match.group(1).strip() if reflection_match else ""
+ return entry
+
+ def _format_full(self, e: dict) -> str:
+ raw = e["raw"] or "n/a"
+ alpha = e["alpha"] or "n/a"
+ holding = e["holding"] or "n/a"
+ tag = f"[{e['date']} | {e['ticker']} | {e['rating']} | {raw} | {alpha} | {holding}]"
+ parts = [tag, f"DECISION:\n{e['decision']}"]
+ if e["reflection"]:
+ parts.append(f"REFLECTION:\n{e['reflection']}")
+ return "\n\n".join(parts)
- # Tokenize query
- query_tokens = self._tokenize(current_situation)
-
- # Get BM25 scores for all documents
- scores = self.bm25.get_scores(query_tokens)
-
- # Get top-n indices sorted by score (descending)
- top_indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:n_matches]
-
- # Build results
- results = []
- max_score = float(scores.max()) if len(scores) > 0 and scores.max() > 0 else 1.0
-
- for idx in top_indices:
- # Normalize score to 0-1 range for consistency
- normalized_score = scores[idx] / max_score if max_score > 0 else 0
- results.append({
- "matched_situation": self.documents[idx],
- "recommendation": self.recommendations[idx],
- "similarity_score": normalized_score,
- })
-
- return results
-
- def clear(self):
- """Clear all stored memories."""
- self.documents = []
- self.recommendations = []
- self.bm25 = None
-
-
- if __name__ == "__main__":
- # Example usage
- matcher = FinancialSituationMemory("test_memory")
-
- # Example data
- example_data = [
- (
- "High inflation rate with rising interest rates and declining consumer spending",
- "Consider defensive sectors like consumer staples and utilities. Review fixed-income portfolio duration.",
- ),
- (
- "Tech sector showing high volatility with increasing institutional selling pressure",
- "Reduce exposure to high-growth tech stocks. Look for value opportunities in established tech companies with strong cash flows.",
- ),
- (
- "Strong dollar affecting emerging markets with increasing forex volatility",
- "Hedge currency exposure in international positions. Consider reducing allocation to emerging market debt.",
- ),
- (
- "Market showing signs of sector rotation with rising yields",
- "Rebalance portfolio to maintain target allocations. Consider increasing exposure to sectors benefiting from higher rates.",
- ),
- ]
-
- # Add the example situations and recommendations
- matcher.add_situations(example_data)
-
- # Example query
- current_situation = """
- Market showing increased volatility in tech sector, with institutional investors
- reducing positions and rising interest rates affecting growth stock valuations
- """
-
- try:
- recommendations = matcher.get_memories(current_situation, n_matches=2)
-
- for i, rec in enumerate(recommendations, 1):
- print(f"\nMatch {i}:")
- print(f"Similarity Score: {rec['similarity_score']:.2f}")
- print(f"Matched Situation: {rec['matched_situation']}")
- print(f"Recommendation: {rec['recommendation']}")
-
- except Exception as e:
- print(f"Error during recommendation: {str(e)}")
+ def _format_reflection_only(self, e: dict) -> str:
+ tag = f"[{e['date']} | {e['ticker']} | {e['rating']} | {e['raw'] or 'n/a'}]"
+ if e["reflection"]:
+ return f"{tag}\n{e['reflection']}"
+ text = e["decision"][:300]
+ suffix = "..." if len(e["decision"]) > 300 else ""
+ return f"{tag}\n{text}{suffix}"
diff --cc tradingagents/default_config.py
index a9b75e4be,274c29a51..19dbe1c7a
--- a/tradingagents/default_config.py
+++ b/tradingagents/default_config.py
@@@ -6,6 -6,7 +6,7 @@@ DEFAULT_CONFIG =
"project_dir": os.path.abspath(os.path.join(os.path.dirname(__file__), ".")),
"results_dir": os.getenv("TRADINGAGENTS_RESULTS_DIR", os.path.join(_TRADINGAGENTS_HOME, "logs")),
"data_cache_dir": os.getenv("TRADINGAGENTS_CACHE_DIR", os.path.join(_TRADINGAGENTS_HOME, "cache")),
- "memory_log_path": os.path.join(_TRADINGAGENTS_HOME, "memory", "trading_memory.md"),
++ "memory_log_path": os.getenv("TRADINGAGENTS_MEMORY_LOG_PATH", os.path.join(_TRADINGAGENTS_HOME, "memory", "trading_memory.md")),
# LLM settings
"llm_provider": "openai",
"deep_think_llm": "gpt-5.4",
diff --cc tradingagents/graph/trading_graph.py
index 78bc13e5f,cf5662598..4f92b1889
--- a/tradingagents/graph/trading_graph.py
+++ b/tradingagents/graph/trading_graph.py
@@@ -189,6 -184,77 +184,80 @@@ class TradingAgentsGraph
),
}
+ def _fetch_returns(
+ self, ticker: str, trade_date: str, holding_days: int = 5
+ ) -> Tuple[Optional[float], Optional[float], Optional[int]]:
+ """Fetch raw and alpha return for ticker over holding_days from trade_date.
+
+ Returns (raw_return, alpha_return, actual_holding_days) or
+ (None, None, None) if price data is unavailable (too recent, delisted,
+ or network error).
+ """
+ try:
+ start = datetime.strptime(trade_date, "%Y-%m-%d")
+ end = start + timedelta(days=holding_days + 7) # buffer for weekends/holidays
+ end_str = end.strftime("%Y-%m-%d")
+
+ stock = yf.Ticker(ticker).history(start=trade_date, end=end_str)
+ spy = yf.Ticker("SPY").history(start=trade_date, end=end_str)
+
+ if len(stock) < 2 or len(spy) < 2:
+ return None, None, None
+
+ actual_days = min(holding_days, len(stock) - 1, len(spy) - 1)
+ raw = float(
+ (stock["Close"].iloc[actual_days] - stock["Close"].iloc[0])
+ / stock["Close"].iloc[0]
+ )
+ spy_ret = float(
+ (spy["Close"].iloc[actual_days] - spy["Close"].iloc[0])
+ / spy["Close"].iloc[0]
+ )
+ alpha = raw - spy_ret
+ return raw, alpha, actual_days
+ except Exception as e:
- logger.debug("_fetch_returns failed for %s@%s: %s", ticker, trade_date, e)
++ logger.warning(
++ "Could not resolve outcome for %s on %s (will retry next run): %s",
++ ticker, trade_date, e,
++ )
+ return None, None, None
+
+ def _resolve_pending_entries(self, ticker: str) -> None:
+ """Resolve pending log entries for ticker at the start of a new run.
+
+ Fetches returns for each same-ticker pending entry, generates reflections,
+ then writes all updates in a single atomic batch write to avoid redundant I/O.
+ Skips entries whose price data is not yet available (too recent or delisted).
+
+ Trade-off: only same-ticker entries are resolved per run. Entries for
+ other tickers accumulate until that ticker is run again.
+ """
+ pending = [e for e in self.memory_log.get_pending_entries() if e["ticker"] == ticker]
+ if not pending:
+ return
+
+ updates = []
+ for entry in pending:
+ raw, alpha, days = self._fetch_returns(ticker, entry["date"])
+ if raw is None:
+ continue # price not available yet — try again next run
+ reflection = self.reflector.reflect_on_final_decision(
+ final_decision=entry.get("decision", ""),
+ raw_return=raw,
+ alpha_return=alpha,
+ )
+ updates.append({
+ "ticker": ticker,
+ "trade_date": entry["date"],
+ "raw_return": raw,
+ "alpha_return": alpha,
+ "holding_days": days,
+ "reflection": reflection,
+ })
+
+ if updates:
+ self.memory_log.batch_update_with_outcomes(updates)
+
def propagate(self, company_name, trade_date):
"""Run the trading agents graph for a company on a specific date."""