mirror of
https://github.com/farcasclaudiu/TradingAgents.git
synced 2026-06-22 07:01:21 +03:00
Yijia-Xiao
bba147798f
Extends the canonical structured-output pattern from the Portfolio Manager to the other two decision-making agents. Each of the three agents now returns a typed Pydantic instance via llm.with_structured_output() in a single primary call, and a render helper turns the result into the same markdown shape downstream agents and saved reports already consume. - ResearchPlan: 5-tier recommendation, conversational rationale, concrete strategic actions for the trader. - TraderProposal: 3-tier action (transaction direction is naturally Buy / Hold / Sell — position sizing happens later at the Portfolio Manager), reasoning, and optional entry_price / stop_loss / position_sizing. Rendered output preserves the trailing "FINAL TRANSACTION PROPOSAL: **BUY/HOLD/SELL**" line for backward compatibility with the analyst stop-signal text. - PortfolioDecision: 5-tier rating, executive summary, investment thesis, optional price_target / time_horizon (unchanged). The shared try-structured-then-fallback pattern is extracted into tradingagents/agents/utils/structured.py (bind_structured + invoke_structured_or_freetext) so all three agents go through the same code path and log the same warning when a provider lacks structured output and the agent falls back to free-text generation. Net effect for users: every saved markdown report (research/manager.md, trading/trader.md, portfolio/decision.md) now has consistent section headers across runs and providers, easier to scan. Net effect for the runtime: the rating extraction round-trip is gone — the rating comes from the structured response itself, not a second LLM call. SignalProcessor was already simplified to a heuristic adapter in the previous commit. 11 new tests in tests/test_structured_agents.py cover the Trader and Research Manager render functions, structured-output happy paths, and free-text fallback. Full suite: 88 tests pass in ~2s without API keys.
74 lines
2.6 KiB
Python
74 lines
2.6 KiB
Python
"""Shared helpers for invoking an agent with structured output and a graceful fallback.
|
|
|
|
The Portfolio Manager, Trader, and Research Manager all follow the same
|
|
canonical pattern:
|
|
|
|
1. At agent creation, wrap the LLM with ``with_structured_output(Schema)``
|
|
so the model returns a typed Pydantic instance. If the provider does
|
|
not support structured output (rare; mostly older Ollama models), the
|
|
wrap is skipped and the agent uses free-text generation instead.
|
|
2. At invocation, run the structured call and render the result back to
|
|
markdown. If the structured call itself fails for any reason
|
|
(malformed JSON from a weak model, transient provider issue), fall
|
|
back to a plain ``llm.invoke`` so the pipeline never blocks.
|
|
|
|
Centralising the pattern here keeps the agent factories small and ensures
|
|
all three agents log the same warnings when fallback fires.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from typing import Any, Callable, Optional, TypeVar
|
|
|
|
from pydantic import BaseModel
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
T = TypeVar("T", bound=BaseModel)
|
|
|
|
|
|
def bind_structured(llm: Any, schema: type[T], agent_name: str) -> Optional[Any]:
|
|
"""Return ``llm.with_structured_output(schema)`` or ``None`` if unsupported.
|
|
|
|
Logs a warning when the binding fails so the user understands the agent
|
|
will use free-text generation for every call instead of one-shot fallback.
|
|
"""
|
|
try:
|
|
return llm.with_structured_output(schema)
|
|
except (NotImplementedError, AttributeError) as exc:
|
|
logger.warning(
|
|
"%s: provider does not support with_structured_output (%s); "
|
|
"falling back to free-text generation",
|
|
agent_name, exc,
|
|
)
|
|
return None
|
|
|
|
|
|
def invoke_structured_or_freetext(
|
|
structured_llm: Optional[Any],
|
|
plain_llm: Any,
|
|
prompt: Any,
|
|
render: Callable[[T], str],
|
|
agent_name: str,
|
|
) -> str:
|
|
"""Run the structured call and render to markdown; fall back to free-text on any failure.
|
|
|
|
``prompt`` is whatever the underlying LLM accepts (a string for chat
|
|
invocations, a list of message dicts for chat models that take that
|
|
shape). The same value is forwarded to the free-text path so the
|
|
fallback sees the same input the structured call did.
|
|
"""
|
|
if structured_llm is not None:
|
|
try:
|
|
result = structured_llm.invoke(prompt)
|
|
return render(result)
|
|
except Exception as exc:
|
|
logger.warning(
|
|
"%s: structured-output invocation failed (%s); retrying once as free text",
|
|
agent_name, exc,
|
|
)
|
|
|
|
response = plain_llm.invoke(prompt)
|
|
return response.content
|