Address Gemini round 6: fix indicator fallback, consistent _safe_get usage

HIGH: Unknown indicator now returns clear error with supported list instead of
  silently falling back to technicals() which has a different response structure
MEDIUM: Use _safe_get consistently in get_sentiment_score (was data.get)

tradingagents/dataflows/interface.py

@@ -30,12 +30,13 @@ from .polaris import (
     get_balance_sheet as get_polaris_balance_sheet,
     get_cashflow as get_polaris_cashflow,
     get_income_statement as get_polaris_income_statement,
-    get_insider_transactions as get_polaris_insider_transactions,
+    get_sec_filings as get_polaris_sec_filings,
     get_news as get_polaris_news,
     get_global_news as get_polaris_global_news,
     get_sentiment_score as get_polaris_sentiment_score,
     get_sector_analysis as get_polaris_sector_analysis,
     get_news_impact as get_polaris_news_impact,
+    get_technicals as get_polaris_technicals,
 )
 
 # Configuration and routing logic
@@ -52,7 +53,8 @@ TOOLS_CATEGORIES = {
     "technical_indicators": {
         "description": "Technical analysis indicators",
         "tools": [
-            "get_indicators"
+            "get_indicators",
+            "get_technicals"
         ]
     },
     "fundamental_data": {
@@ -70,6 +72,7 @@ TOOLS_CATEGORIES = {
             "get_news",
             "get_global_news",
             "get_insider_transactions",
+            "get_sec_filings",
         ]
     },
     "sentiment_analysis": {
@@ -137,7 +140,9 @@ VENDOR_METHODS = {
     "get_insider_transactions": {
         "alpha_vantage": get_alpha_vantage_insider_transactions,
         "yfinance": get_yfinance_insider_transactions,
-        "polaris": get_polaris_insider_transactions,
+    },
+    "get_sec_filings": {
+        "polaris": get_polaris_sec_filings,
     },
     # sentiment_analysis (Polaris-exclusive)
     "get_sentiment_score": {
@@ -149,6 +154,9 @@ VENDOR_METHODS = {
     "get_news_impact": {
         "polaris": get_polaris_news_impact,
     },
+    "get_technicals": {
+        "polaris": get_polaris_technicals,
+    },
 }
 
 def get_category_for_method(method: str) -> str:

tradingagents/dataflows/polaris.py

@@ -7,7 +7,7 @@ feeds, every Polaris response includes confidence scores, bias analysis, and
 NLP-derived metadata that enriches agent decision-making.
 
 Setup:
-    pip install polaris-news
+    pip install polaris-news cachetools
     export POLARIS_API_KEY=pr_live_xxx  # Free: 1,000 credits/month at thepolarisreport.com
 
 API docs: https://thepolarisreport.com/api-reference
@@ -18,12 +18,7 @@ import threading
 from typing import Annotated
 from datetime import datetime
 
-try:
-    from cachetools import TTLCache
-except ImportError:
-    # Fallback if cachetools not installed
-    from functools import lru_cache
-    TTLCache = None
+from cachetools import TTLCache
 
 # ---------------------------------------------------------------------------
 # Configuration
@@ -32,13 +27,8 @@ except ImportError:
 _CACHE_TTL = 300  # 5 minutes
 _CACHE_MAX = 500
 
-# Thread-safe TTL cache (preferred) with fallback to simple dict
-if TTLCache is not None:
-    _cache = TTLCache(maxsize=_CACHE_MAX, ttl=_CACHE_TTL)
-    _cache_lock = threading.Lock()
-else:
-    _cache = {}
-    _cache_lock = threading.Lock()
+_cache = TTLCache(maxsize=_CACHE_MAX, ttl=_CACHE_TTL)
+_cache_lock = threading.Lock()
 
 _client_instance = None
 _client_lock = threading.Lock()
@@ -59,7 +49,12 @@ def _get_client():
                 "polaris-news is required for the Polaris data vendor. "
                 "Install it with: pip install polaris-news"
             )
-        api_key = os.environ.get("POLARIS_API_KEY", "demo")
+        api_key = os.environ.get("POLARIS_API_KEY")
+        if not api_key:
+            raise EnvironmentError(
+                "POLARIS_API_KEY environment variable is required. "
+                "Get a free key at https://thepolarisreport.com/pricing"
+            )
         _client_instance = PolarisClient(api_key=api_key)
         return _client_instance
 
@@ -70,12 +65,48 @@ def _cached(key: str):
         return _cache.get(key)
 
 
-def _set_cache(key: str, data: str):
+def _set_cache(key: str, data):
     """Store data in cache (thread-safe)."""
     with _cache_lock:
         _cache[key] = data
 
 
+# ---------------------------------------------------------------------------
+# Shared helpers
+# ---------------------------------------------------------------------------
+
+def _safe_get(obj, key, default='N/A'):
+    """Get attribute from dict or object, returning default if missing or None."""
+    if isinstance(obj, dict):
+        val = obj.get(key, default)
+        return default if val is None else val
+    val = getattr(obj, key, default)
+    return default if val is None else val
+
+
+def _days_to_range(days: int) -> str:
+    """Convert a day count to a Polaris range string."""
+    if days <= 30:
+        return "1mo"
+    elif days <= 90:
+        return "3mo"
+    elif days <= 180:
+        return "6mo"
+    elif days <= 365:
+        return "1y"
+    elif days <= 730:
+        return "2y"
+    else:
+        return "5y"
+
+
+def _extract_briefs(data) -> list:
+    """Extract briefs list from API response (handles both dict and typed objects)."""
+    if not isinstance(data, dict):
+        data = vars(data) if hasattr(data, '__dict__') else {}
+    return data.get("briefs", [])
+
+
 # ---------------------------------------------------------------------------
 # Core Stock APIs
 # ---------------------------------------------------------------------------
@@ -93,23 +124,12 @@ def get_stock_data(
 
     client = _get_client()
 
-    # Determine range from date span
     start = datetime.strptime(start_date, "%Y-%m-%d")
     end = datetime.strptime(end_date, "%Y-%m-%d")
     days = (end - start).days
-
-    if days <= 30:
-        range_param = "1mo"
-    elif days <= 90:
-        range_param = "3mo"
-    elif days <= 180:
-        range_param = "6mo"
-    elif days <= 365:
-        range_param = "1y"
-    elif days <= 730:
-        range_param = "2y"
-    else:
-        range_param = "5y"
+    if days <= 0:
+        return f"Invalid date range: start_date ({start_date}) must be before end_date ({end_date})"
+    range_param = _days_to_range(days)
 
     try:
         data = client.candles(symbol, interval="1d", range=range_param)
@@ -123,16 +143,19 @@ def get_stock_data(
     # Filter to requested date range
     candles = [c for c in candles if start_date <= c["date"] <= end_date]
 
-    # Format as CSV (matching yfinance output format)
-    header = f"# Stock data for {symbol.upper()} from {start_date} to {end_date}\n"
-    header += f"# Source: Polaris Knowledge API (multi-provider: Yahoo/TwelveData/FMP)\n"
-    header += f"# Total records: {len(candles)}\n\n"
+    lines = [
+        f"# Stock data for {symbol.upper()} from {start_date} to {end_date}",
+        f"# Source: Polaris Knowledge API (multi-provider: Yahoo/TwelveData/FMP)",
+        f"# Total records: {len(candles)}",
+        "",
+        "Date,Open,High,Low,Close,Volume",
+    ]
+    lines.extend(
+        f"{c['date']},{c['open']},{c['high']},{c['low']},{c['close']},{c['volume']}"
+        for c in candles
+    )
 
-    csv = "Date,Open,High,Low,Close,Volume\n"
-    for c in candles:
-        csv += f"{c['date']},{c['open']},{c['high']},{c['low']},{c['close']},{c['volume']}\n"
-
-    result = header + csv
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result
 
@@ -147,7 +170,10 @@ def get_indicators(
     curr_date: Annotated[str, "Current trading date, YYYY-mm-dd"],
     look_back_days: Annotated[int, "how many days to look back"],
 ) -> str:
-    """Fetch technical indicators from Polaris (20 indicators + signal summary)."""
+    """Fetch technical indicators from Polaris (20 indicators + signal summary).
+
+    Uses curr_date and look_back_days to determine the data range.
+    """
     cache_key = f"indicators:{symbol}:{indicator}:{curr_date}:{look_back_days}"
     cached = _cached(cache_key)
     if cached:
@@ -155,6 +181,10 @@ def get_indicators(
 
     client = _get_client()
 
+    # Use curr_date to determine if we need historical vs current data
+    today = datetime.now().strftime("%Y-%m-%d")
+    is_historical = curr_date < today if curr_date else False
+
     # Map common indicator names to Polaris types
     indicator_map = {
         "close_50_sma": "sma", "close_20_sma": "sma", "close_200_sma": "sma",
@@ -170,62 +200,67 @@ def get_indicators(
 
     polaris_type = indicator_map.get(indicator.lower(), indicator.lower())
 
-    # Determine range
-    if look_back_days <= 30:
-        range_param = "1mo"
-    elif look_back_days <= 90:
-        range_param = "3mo"
-    elif look_back_days <= 180:
-        range_param = "6mo"
+    # If historical, we need enough range to cover curr_date - look_back_days
+    if is_historical:
+        days_from_now = (datetime.strptime(today, "%Y-%m-%d") - datetime.strptime(curr_date, "%Y-%m-%d")).days
+        range_param = _days_to_range(days_from_now + look_back_days)
     else:
-        range_param = "1y"
+        range_param = _days_to_range(look_back_days)
+
+    known_types = {
+        "sma", "ema", "rsi", "macd", "bollinger", "atr",
+        "stochastic", "adx", "obv", "vwap", "williams_r",
+        "cci", "mfi", "roc", "ppo", "trix", "donchian",
+        "parabolic_sar", "ichimoku", "fibonacci",
+    }
 
-    # Try specific indicator first, fall back to full technicals
     try:
-        if polaris_type in ["sma", "ema", "rsi", "macd", "bollinger", "atr",
-                            "stochastic", "adx", "obv", "vwap", "williams_r",
-                            "cci", "mfi", "roc", "ppo", "trix", "donchian",
-                            "parabolic_sar", "ichimoku", "fibonacci"]:
+        if polaris_type in known_types:
             data = client.indicators(symbol, type=polaris_type, range=range_param)
         else:
-            data = client.technicals(symbol, range=range_param)
+            # Unknown indicator — return an error rather than silently falling back
+            # to client.technicals() which returns a different structure
+            return (
+                f"Unknown indicator '{indicator}' for {symbol}. "
+                f"Supported: {', '.join(sorted(known_types))}"
+            )
     except Exception as e:
         return f"Error fetching indicators for {symbol}: {e}"
 
     values = data.get("values", [])
 
-    header = f"# Technical Indicator: {indicator} for {symbol.upper()}\n"
-    header += f"# Source: Polaris Knowledge API\n"
-    header += f"# Period: {range_param} | Data points: {len(values)}\n\n"
+    lines = [
+        f"# Technical Indicator: {indicator} for {symbol.upper()}",
+        f"# Source: Polaris Knowledge API",
+        f"# Period: {range_param} | Data points: {len(values) if isinstance(values, list) else 'N/A'}",
+        "",
+    ]
 
     if isinstance(values, list) and values:
-        # Format based on indicator type
         first = values[0]
         if "value" in first:
-            csv = "Date,Value\n"
-            for v in values:
-                csv += f"{v['date']},{v['value']}\n"
+            lines.append("Date,Value")
+            lines.extend(f"{v['date']},{v.get('value', '')}" for v in values)
         elif "macd" in first:
-            csv = "Date,MACD,Signal,Histogram\n"
-            for v in values:
-                csv += f"{v['date']},{v.get('macd','')},{v.get('signal','')},{v.get('histogram','')}\n"
+            lines.append("Date,MACD,Signal,Histogram")
+            lines.extend(f"{v['date']},{v.get('macd', '')},{v.get('signal', '')},{v.get('histogram', '')}" for v in values)
         elif "upper" in first:
-            csv = "Date,Upper,Middle,Lower\n"
-            for v in values:
-                csv += f"{v['date']},{v.get('upper','')},{v.get('middle','')},{v.get('lower','')}\n"
+            lines.append("Date,Upper,Middle,Lower")
+            lines.extend(f"{v['date']},{v.get('upper', '')},{v.get('middle', '')},{v.get('lower', '')}" for v in values)
         elif "k" in first:
-            csv = "Date,K,D\n"
-            for v in values:
-                csv += f"{v['date']},{v.get('k','')},{v.get('d','')}\n"
+            lines.append("Date,K,D")
+            lines.extend(f"{v['date']},{v.get('k', '')},{v.get('d', '')}" for v in values)
         else:
-            csv = str(values)
+            keys = list(first.keys())
+            lines.append(",".join(keys))
+            lines.extend(",".join(str(v.get(k, '')) for k in keys) for v in values)
     elif isinstance(values, dict):
-        # Fibonacci or similar
-        csv = str(values)
+        for k, v in values.items():
+            lines.append(f"{k}: {v}")
     else:
-        csv = "No indicator data available"
+        lines.append("No indicator data available")
 
-    result = header + csv
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result
 
@@ -260,23 +295,27 @@ def get_fundamentals(
     except Exception as e:
         return f"Error fetching fundamentals for {symbol}: {e}"
 
-    result = f"# Company Fundamentals: {data.get('company_name', symbol)}\n"
-    result += f"# Source: Polaris Knowledge API\n\n"
-    result += f"Sector: {data.get('sector', 'N/A')}\n"
-    result += f"Industry: {data.get('industry', 'N/A')}\n"
-    result += f"Market Cap: {data.get('market_cap_formatted', 'N/A')}\n"
-    result += f"P/E Ratio: {data.get('pe_ratio', 'N/A')}\n"
-    result += f"Forward P/E: {data.get('forward_pe', 'N/A')}\n"
-    result += f"EPS: {data.get('eps', 'N/A')}\n"
-    result += f"Revenue: {data.get('revenue_formatted', 'N/A')}\n"
-    result += f"EBITDA: {data.get('ebitda_formatted', 'N/A')}\n"
-    result += f"Profit Margin: {data.get('profit_margin', 'N/A')}\n"
-    result += f"Debt/Equity: {data.get('debt_to_equity', 'N/A')}\n"
-    result += f"ROE: {data.get('return_on_equity', 'N/A')}\n"
-    result += f"Beta: {data.get('beta', 'N/A')}\n"
-    result += f"52-Week High: {data.get('fifty_two_week_high', 'N/A')}\n"
-    result += f"52-Week Low: {data.get('fifty_two_week_low', 'N/A')}\n"
+    lines = [
+        f"# Company Fundamentals: {data.get('company_name', symbol)}",
+        f"# Source: Polaris Knowledge API",
+        "",
+        f"Sector: {_safe_get(data, 'sector')}",
+        f"Industry: {_safe_get(data, 'industry')}",
+        f"Market Cap: {_safe_get(data, 'market_cap_formatted')}",
+        f"P/E Ratio: {_safe_get(data, 'pe_ratio')}",
+        f"Forward P/E: {_safe_get(data, 'forward_pe')}",
+        f"EPS: {_safe_get(data, 'eps')}",
+        f"Revenue: {_safe_get(data, 'revenue_formatted')}",
+        f"EBITDA: {_safe_get(data, 'ebitda_formatted')}",
+        f"Profit Margin: {_safe_get(data, 'profit_margin')}",
+        f"Debt/Equity: {_safe_get(data, 'debt_to_equity')}",
+        f"ROE: {_safe_get(data, 'return_on_equity')}",
+        f"Beta: {_safe_get(data, 'beta')}",
+        f"52-Week High: {_safe_get(data, 'fifty_two_week_high')}",
+        f"52-Week Low: {_safe_get(data, 'fifty_two_week_low')}",
+    ]
 
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result
 
@@ -285,17 +324,27 @@ def get_balance_sheet(
     symbol: Annotated[str, "ticker symbol of the company"],
 ) -> str:
     """Fetch balance sheet from Polaris."""
+    cache_key = f"balance_sheet:{symbol}"
+    cached = _cached(cache_key)
+    if cached:
+        return cached
+
     try:
         data = _get_financials_cached(symbol)
     except Exception as e:
         return f"Error fetching balance sheet for {symbol}: {e}"
 
     sheets = data.get("balance_sheets", [])
-    result = f"# Balance Sheet: {symbol.upper()}\n# Source: Polaris Knowledge API\n\n"
-    result += "Date,Total Assets,Total Liabilities,Total Equity\n"
-    for s in sheets:
-        result += f"{s['date']},{s['total_assets']},{s['total_liabilities']},{s['total_equity']}\n"
+    lines = [
+        f"# Balance Sheet: {symbol.upper()}",
+        f"# Source: Polaris Knowledge API",
+        "",
+        "Date,Total Assets,Total Liabilities,Total Equity",
+    ]
+    lines.extend(f"{s['date']},{s['total_assets']},{s['total_liabilities']},{s['total_equity']}" for s in sheets)
 
+    result = "\n".join(lines) + "\n"
+    _set_cache(cache_key, result)
     return result
 
 
@@ -303,13 +352,33 @@ def get_cashflow(
     symbol: Annotated[str, "ticker symbol of the company"],
 ) -> str:
     """Fetch cash flow data from Polaris."""
+    cache_key = f"cashflow:{symbol}"
+    cached = _cached(cache_key)
+    if cached:
+        return cached
+
     try:
         data = _get_financials_cached(symbol)
     except Exception as e:
         return f"Error fetching cashflow for {symbol}: {e}"
 
-    result = f"# Cash Flow: {symbol.upper()}\n# Source: Polaris Knowledge API\n\n"
-    result += f"Free Cash Flow: {data.get('free_cash_flow', 'N/A')}\n"
+    statements = data.get("cash_flow_statements", [])
+    lines = [
+        f"# Cash Flow: {symbol.upper()}",
+        f"# Source: Polaris Knowledge API",
+        "",
+    ]
+    if statements:
+        lines.append("Date,Operating Cash Flow,Capital Expenditure,Free Cash Flow")
+        lines.extend(
+            f"{s.get('date', '')},{s.get('operating_cash_flow', '')},{s.get('capital_expenditure', '')},{s.get('free_cash_flow', '')}"
+            for s in statements
+        )
+    else:
+        lines.append(f"Free Cash Flow: {_safe_get(data, 'free_cash_flow')}")
+
+    result = "\n".join(lines) + "\n"
+    _set_cache(cache_key, result)
     return result
 
 
@@ -317,17 +386,27 @@ def get_income_statement(
     symbol: Annotated[str, "ticker symbol of the company"],
 ) -> str:
     """Fetch income statement from Polaris."""
+    cache_key = f"income_stmt:{symbol}"
+    cached = _cached(cache_key)
+    if cached:
+        return cached
+
     try:
         data = _get_financials_cached(symbol)
     except Exception as e:
         return f"Error fetching income statement for {symbol}: {e}"
 
     stmts = data.get("income_statements", [])
-    result = f"# Income Statement: {symbol.upper()}\n# Source: Polaris Knowledge API\n\n"
-    result += "Date,Revenue,Net Income,Gross Profit\n"
-    for s in stmts:
-        result += f"{s['date']},{s['revenue']},{s['net_income']},{s['gross_profit']}\n"
+    lines = [
+        f"# Income Statement: {symbol.upper()}",
+        f"# Source: Polaris Knowledge API",
+        "",
+        "Date,Revenue,Net Income,Gross Profit",
+    ]
+    lines.extend(f"{s['date']},{s['revenue']},{s['net_income']},{s['gross_profit']}" for s in stmts)
 
+    result = "\n".join(lines) + "\n"
+    _set_cache(cache_key, result)
     return result
 
 
@@ -335,6 +414,37 @@ def get_income_statement(
 # News & Intelligence (Polaris advantage — sentiment-scored, not raw headlines)
 # ---------------------------------------------------------------------------
 
+def _format_brief_detail(b, lines: list) -> None:
+    """Format a single brief into output lines (shared by get_news)."""
+    prov = _safe_get(b, "provenance", {})
+    if not isinstance(prov, dict):
+        prov = {}
+    lines.append(f"--- Brief: {_safe_get(b, 'id', '')} ---")
+    lines.append(f"Date: {_safe_get(b, 'published_at', '')}")
+    lines.append(f"Headline: {_safe_get(b, 'headline', '')}")
+    lines.append(f"Summary: {_safe_get(b, 'summary', '')}")
+    lines.append(f"Category: {_safe_get(b, 'category', '')}")
+    lines.append(f"Confidence: {_safe_get(prov, 'confidence_score')}")
+    lines.append(f"Bias Score: {_safe_get(prov, 'bias_score')}")
+    lines.append(f"Review Status: {_safe_get(prov, 'review_status')}")
+    lines.append(f"Sentiment: {_safe_get(b, 'sentiment')}")
+    lines.append(f"Impact Score: {_safe_get(b, 'impact_score')}")
+
+    entities = _safe_get(b, "entities_enriched", [])
+    if isinstance(entities, list) and entities:
+        ent_str = ", ".join(
+            f"{_safe_get(e, 'name', '?')}({_safe_get(e, 'sentiment_score', '?')})"
+            for e in entities[:5]
+        )
+        lines.append(f"Entities: {ent_str}")
+
+    ca = _safe_get(b, "counter_argument", None)
+    if ca and ca != 'N/A':
+        lines.append(f"Counter-Argument: {str(ca)[:200]}...")
+
+    lines.append("")
+
+
 def get_news(
     symbol: Annotated[str, "ticker symbol of the company"],
     start_date: Annotated[str, "Start date in yyyy-mm-dd format"],
@@ -355,56 +465,24 @@ def get_news(
 
     client = _get_client()
     try:
-        data = client.search(symbol, per_page=20)
-        # Handle both dict and typed response objects
-        if hasattr(data, '__dict__') and not isinstance(data, dict):
-            data = data.__dict__ if hasattr(data, '__dict__') else {}
-        if isinstance(data, dict):
-            briefs = data.get("briefs", [])
-        else:
-            briefs = getattr(data, 'briefs', [])
+        data = client.search(symbol, per_page=20, from_date=start_date, to_date=end_date)
+        briefs = _extract_briefs(data)
     except Exception as e:
         return f"Error fetching news for {symbol}: {e}"
     if not briefs:
-        return f"No intelligence briefs found for {symbol}"
+        return f"No intelligence briefs found for {symbol} between {start_date} and {end_date}"
 
-    result = f"# Intelligence Briefs for {symbol.upper()}\n"
-    result += f"# Source: Polaris Knowledge API (sentiment-scored, bias-analyzed)\n"
-    result += f"# Total: {len(briefs)} briefs\n\n"
-
-    def _get(obj, key, default='N/A'):
-        """Get attribute from dict or object."""
-        if isinstance(obj, dict):
-            return obj.get(key, default)
-        return getattr(obj, key, default)
+    lines = [
+        f"# Intelligence Briefs for {symbol.upper()} ({start_date} to {end_date})",
+        f"# Source: Polaris Knowledge API (sentiment-scored, bias-analyzed)",
+        f"# Total: {len(briefs)} briefs",
+        "",
+    ]
 
     for b in briefs:
-        prov = _get(b, "provenance", {})
-        result += f"--- Brief: {_get(b, 'id', '')} ---\n"
-        result += f"Date: {_get(b, 'published_at', '')}\n"
-        result += f"Headline: {_get(b, 'headline', '')}\n"
-        result += f"Summary: {_get(b, 'summary', '')}\n"
-        result += f"Category: {_get(b, 'category', '')}\n"
-        result += f"Confidence: {_get(prov, 'confidence_score', 'N/A')}\n"
-        result += f"Bias Score: {_get(prov, 'bias_score', 'N/A')}\n"
-        result += f"Review Status: {_get(prov, 'review_status', 'N/A')}\n"
-        result += f"Sentiment: {_get(b, 'sentiment', 'N/A')}\n"
-        result += f"Impact Score: {_get(b, 'impact_score', 'N/A')}\n"
-
-        entities = _get(b, "entities_enriched", []) or []
-        if entities:
-            ent_str = ", ".join(
-                f"{_get(e, 'name', '?')}({_get(e, 'sentiment_score', '?')})"
-                for e in (entities[:5] if isinstance(entities, list) else [])
-            )
-            result += f"Entities: {ent_str}\n"
-
-        ca = _get(b, "counter_argument", None)
-        if ca:
-            result += f"Counter-Argument: {str(ca)[:200]}...\n"
-
-        result += "\n"
+        _format_brief_detail(b, lines)
 
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result
 
@@ -421,41 +499,48 @@ def get_global_news(
 
     client = _get_client()
     try:
-        data = client.feed(per_page=20)
-        if hasattr(data, '__dict__') and not isinstance(data, dict):
-            data = data.__dict__ if hasattr(data, '__dict__') else {}
-        if isinstance(data, dict):
-            briefs = data.get("briefs", [])
-        else:
-            briefs = getattr(data, 'briefs', [])
+        data = client.feed(per_page=20, from_date=start_date, to_date=end_date)
+        briefs = _extract_briefs(data)
     except Exception as e:
         return f"Error fetching global news: {e}"
-    result = f"# Global Intelligence Feed\n"
-    result += f"# Source: Polaris Knowledge API\n"
-    result += f"# Briefs: {len(briefs)}\n\n"
 
-    def _get2(obj, key, default='N/A'):
-        if isinstance(obj, dict):
-            return obj.get(key, default)
-        return getattr(obj, key, default)
+    if not briefs:
+        return f"No intelligence briefs found between {start_date} and {end_date}"
+
+    lines = [
+        f"# Global Intelligence Feed ({start_date} to {end_date})",
+        f"# Source: Polaris Knowledge API",
+        f"# Briefs: {len(briefs)}",
+        "",
+    ]
 
     for b in briefs:
-        prov = _get2(b, "provenance", {})
-        pub = str(_get2(b, 'published_at', ''))[:10]
-        result += f"[{pub}] [{_get2(b, 'category', '')}] "
-        result += f"{_get2(b, 'headline', '')} "
-        result += f"(confidence={_get2(prov, 'confidence_score', '?')}, "
-        result += f"bias={_get2(prov, 'bias_score', '?')}, "
-        result += f"sentiment={_get2(b, 'sentiment', '?')})\n"
+        prov = _safe_get(b, "provenance", {})
+        if not isinstance(prov, dict):
+            prov = {}
+        pub = str(_safe_get(b, 'published_at', ''))[:10]
+        lines.append(
+            f"[{pub}] [{_safe_get(b, 'category', '')}] "
+            f"{_safe_get(b, 'headline', '')} "
+            f"(confidence={_safe_get(prov, 'confidence_score')}, "
+            f"bias={_safe_get(prov, 'bias_score')}, "
+            f"sentiment={_safe_get(b, 'sentiment')})"
+        )
 
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result
 
 
-def get_insider_transactions(
+def get_sec_filings(
     symbol: Annotated[str, "ticker symbol of the company"],
 ) -> str:
-    """Fetch SEC EDGAR earnings filings via Polaris."""
+    """Fetch SEC EDGAR earnings filings (8-K, 10-Q, 10-K) via Polaris."""
+    cache_key = f"sec_filings:{symbol}"
+    cached = _cached(cache_key)
+    if cached:
+        return cached
+
     client = _get_client()
     try:
         data = client.transcripts(symbol, days=365)
@@ -463,18 +548,26 @@ def get_insider_transactions(
         return f"Error fetching filings for {symbol}: {e}"
 
     filings = data.get("filings", [])
-    result = f"# SEC Filings for {symbol.upper()}\n"
-    result += f"# Source: Polaris Knowledge API (SEC EDGAR)\n\n"
-    result += "Date,Form,Description,URL\n"
-    for f in filings[:20]:
-        result += f"{f.get('date', '')},{f.get('form', '')},{f.get('description', '')},{f.get('filing_url', '')}\n"
+    lines = [
+        f"# SEC Filings for {symbol.upper()}",
+        f"# Source: Polaris Knowledge API (SEC EDGAR)",
+        "",
+        "Date,Form,Description,URL",
+    ]
+    lines.extend(
+        f"{_safe_get(f, 'date', '')},{_safe_get(f, 'form', '')},{_safe_get(f, 'description', '')},{_safe_get(f, 'filing_url', '')}"
+        for f in filings[:20]
+    )
 
+    result = "\n".join(lines) + "\n"
+    _set_cache(cache_key, result)
     return result
 
 
+
 # ---------------------------------------------------------------------------
 # Polaris-Exclusive: Sentiment & Trading Signals
-# (Not available from Yahoo Finance or Alpha Vantage)
+# (Complements price/fundamental data from yfinance and Alpha Vantage)
 # ---------------------------------------------------------------------------
 
 def get_sentiment_score(
@@ -488,7 +581,7 @@ def get_sentiment_score(
     - Coverage velocity (20% weight)
     - Event proximity (15% weight)
 
-    Not available from any other data vendor.
+    Polaris-exclusive: complements price data from other vendors with intelligence signals.
     """
     cache_key = f"sentiment:{symbol}"
     cached = _cached(cache_key)
@@ -501,24 +594,26 @@ def get_sentiment_score(
     except Exception as e:
         return f"Error fetching sentiment score for {symbol}: {e}"
 
-    result = f"# Composite Trading Signal: {symbol.upper()}\n"
-    result += f"# Source: Polaris Knowledge API (exclusive)\n\n"
-    result += f"Signal: {data.get('signal', 'N/A')}\n"
-    result += f"Composite Score: {data.get('composite_score', 'N/A')}\n\n"
+    components = _safe_get(data, "components", {})
+    sent = _safe_get(components, "sentiment", {})
+    mom = _safe_get(components, "momentum", {})
+    vol = _safe_get(components, "volume", {})
+    evt = _safe_get(components, "events", {})
 
-    components = data.get("components", {})
-    sent = components.get("sentiment", {})
-    result += f"Sentiment (40%): current_24h={sent.get('current_24h')}, week_avg={sent.get('week_avg')}\n"
-
-    mom = components.get("momentum", {})
-    result += f"Momentum (25%): {mom.get('direction', 'N/A')} (value={mom.get('value')})\n"
-
-    vol = components.get("volume", {})
-    result += f"Volume (20%): {vol.get('briefs_24h')} briefs/24h, velocity={vol.get('velocity_change_pct')}%\n"
-
-    evt = components.get("events", {})
-    result += f"Events (15%): {evt.get('count_7d')} events, latest={evt.get('latest_type')}\n"
+    lines = [
+        f"# Composite Trading Signal: {symbol.upper()}",
+        f"# Source: Polaris Knowledge API",
+        "",
+        f"Signal: {_safe_get(data, 'signal')}",
+        f"Composite Score: {_safe_get(data, 'composite_score')}",
+        "",
+        f"Sentiment (40%): current_24h={_safe_get(sent, 'current_24h')}, week_avg={_safe_get(sent, 'week_avg')}",
+        f"Momentum (25%): {_safe_get(mom, 'direction')} (value={_safe_get(mom, 'value')})",
+        f"Volume (20%): {_safe_get(vol, 'briefs_24h')} briefs/24h, velocity={_safe_get(vol, 'velocity_change_pct')}%",
+        f"Events (15%): {_safe_get(evt, 'count_7d')} events, latest={_safe_get(evt, 'latest_type')}",
+    ]
 
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result
 
@@ -526,8 +621,11 @@ def get_sentiment_score(
 def get_sector_analysis(
     symbol: Annotated[str, "ticker symbol of the company"],
 ) -> str:
-    """Get competitor intelligence for a ticker — same-sector peers with live data."""
-    cache_key = f"competitors:{symbol}"
+    """Get competitor intelligence — same-sector peers with live price, RSI, sentiment, and news coverage.
+
+    Polaris-exclusive: complements price data from other vendors with intelligence signals.
+    """
+    cache_key = f"sector_analysis:{symbol}"
     cached = _cached(cache_key)
     if cached:
         return cached
@@ -538,13 +636,24 @@ def get_sector_analysis(
     except Exception as e:
         return f"Error fetching sector analysis for {symbol}: {e}"
 
-    result = f"# Competitor Analysis: {symbol.upper()} ({data.get('sector', 'N/A')})\n"
-    result += f"# Source: Polaris Knowledge API (exclusive)\n\n"
-    result += "Ticker,Name,Price,RSI,Sentiment_7d,Briefs_7d\n"
+    peers = data.get("competitors", [])
+    lines = [
+        f"# Sector & Peer Analysis: {symbol.upper()} ({_safe_get(data, 'sector')})",
+        f"# Source: Polaris Knowledge API",
+        f"# Peers: {len(peers)}",
+        "",
+        "Ticker,Name,Price,Change%,RSI(14),Sentiment_7d,Briefs_7d,Signal",
+    ]
 
-    for c in data.get("competitors", []):
-        result += f"{c.get('ticker')},{c.get('entity_name')},{c.get('price')},{c.get('rsi_14')},{c.get('sentiment_7d')},{c.get('briefs_7d')}\n"
+    for c in peers:
+        lines.append(
+            f"{_safe_get(c, 'ticker')},{_safe_get(c, 'entity_name')},"
+            f"{_safe_get(c, 'price')},{_safe_get(c, 'change_pct', '')},"
+            f"{_safe_get(c, 'rsi_14')},{_safe_get(c, 'sentiment_7d')},"
+            f"{_safe_get(c, 'briefs_7d')},{_safe_get(c, 'signal', 'N/A')}"
+        )
 
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result
 
@@ -552,7 +661,10 @@ def get_sector_analysis(
 def get_news_impact(
     symbol: Annotated[str, "ticker symbol of the company"],
 ) -> str:
-    """Measure how news moved the stock price — brief-to-price causation analysis."""
+    """Measure how news moved the stock price — brief-to-price causation analysis.
+
+    Polaris-exclusive: complements price data from other vendors with intelligence signals.
+    """
     cache_key = f"impact:{symbol}"
     cached = _cached(cache_key)
     if cached:
@@ -564,19 +676,86 @@ def get_news_impact(
     except Exception as e:
         return f"Error fetching news impact for {symbol}: {e}"
 
-    result = f"# News Impact Analysis: {symbol.upper()}\n"
-    result += f"# Source: Polaris Knowledge API (exclusive)\n\n"
-    result += f"Briefs Analyzed: {data.get('briefs_analyzed', 0)}\n"
-    result += f"Avg 1-Day Impact: {data.get('avg_impact_1d_pct', 'N/A')}%\n"
-    result += f"Avg 3-Day Impact: {data.get('avg_impact_3d_pct', 'N/A')}%\n\n"
+    best = data.get("best_impact", {}) or {}
+    worst = data.get("worst_impact", {}) or {}
+
+    lines = [
+        f"# News Impact Analysis: {symbol.upper()}",
+        f"# Source: Polaris Knowledge API",
+        "",
+        f"Briefs Analyzed: {_safe_get(data, 'briefs_analyzed', 0)}",
+        f"Avg 1-Day Impact: {_safe_get(data, 'avg_impact_1d_pct')}%",
+        f"Avg 3-Day Impact: {_safe_get(data, 'avg_impact_3d_pct')}%",
+        "",
+    ]
 
-    best = data.get("best_impact", {})
     if best:
-        result += f"Best Impact: {best.get('headline', '')[:60]} (+{best.get('impact_1d_pct')}%)\n"
-
-    worst = data.get("worst_impact", {})
+        lines.append(f"Best Impact: {_safe_get(best, 'headline', '')[:60]} (+{_safe_get(best, 'impact_1d_pct')}%)")
     if worst:
-        result += f"Worst Impact: {worst.get('headline', '')[:60]} ({worst.get('impact_1d_pct')}%)\n"
+        lines.append(f"Worst Impact: {_safe_get(worst, 'headline', '')[:60]} ({_safe_get(worst, 'impact_1d_pct')}%)")
 
+    result = "\n".join(lines) + "\n"
+    _set_cache(cache_key, result)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Polaris-Exclusive: Technical Analysis
+# (Complements price/fundamental data from yfinance and Alpha Vantage)
+# ---------------------------------------------------------------------------
+
+def get_technicals(
+    symbol: Annotated[str, "ticker symbol of the company"],
+) -> str:
+    """Get full technical analysis with 20 indicators and buy/sell/neutral signal.
+
+    Returns all indicators at once: SMA, EMA, RSI, MACD, Bollinger, ATR,
+    Stochastic, ADX, OBV, VWAP, Williams %R, CCI, MFI, ROC, and more.
+    Includes a composite signal summary with buy/sell/neutral recommendation.
+
+    Polaris-exclusive: complements price data from other vendors with intelligence signals.
+    """
+    cache_key = f"technicals:{symbol}"
+    cached = _cached(cache_key)
+    if cached:
+        return cached
+
+    client = _get_client()
+    try:
+        data = client.technicals(symbol, range="6mo")
+    except Exception as e:
+        return f"Error fetching technicals for {symbol}: {e}"
+
+    latest = data.get("latest", {}) or {}
+    signal = data.get("signal_summary", {}) or {}
+    macd = latest.get("macd", {}) or {}
+    boll = latest.get("bollinger", {}) or {}
+    stoch = latest.get("stochastic", {}) or {}
+
+    lines = [
+        f"# Technical Analysis: {symbol.upper()}",
+        f"# Source: Polaris Knowledge API (20 indicators)",
+        "",
+        f"Signal: {_safe_get(signal, 'overall', 'N/A').upper()}",
+        f"Buy signals: {_safe_get(signal, 'buy_count', 0)} | Sell signals: {_safe_get(signal, 'sell_count', 0)} | Neutral: {_safe_get(signal, 'neutral_count', 0)}",
+        "",
+        f"Price: {_safe_get(latest, 'price')}",
+        f"RSI(14): {_safe_get(latest, 'rsi_14')}",
+        f"MACD: {_safe_get(macd, 'macd')} (signal={_safe_get(macd, 'signal')}, hist={_safe_get(macd, 'histogram')})",
+        f"SMA(20): {_safe_get(latest, 'sma_20')} | SMA(50): {_safe_get(latest, 'sma_50')}",
+        f"EMA(12): {_safe_get(latest, 'ema_12')} | EMA(26): {_safe_get(latest, 'ema_26')}",
+        f"Bollinger: upper={_safe_get(boll, 'upper')}, middle={_safe_get(boll, 'middle')}, lower={_safe_get(boll, 'lower')}",
+        f"ATR(14): {_safe_get(latest, 'atr_14')}",
+        f"Stochastic: K={_safe_get(stoch, 'k')}, D={_safe_get(stoch, 'd')}",
+        f"ADX(14): {_safe_get(latest, 'adx_14')}",
+        f"Williams %R(14): {_safe_get(latest, 'williams_r_14')}",
+        f"CCI(20): {_safe_get(latest, 'cci_20')}",
+        f"MFI(14): {_safe_get(latest, 'mfi_14')}",
+        f"ROC(12): {_safe_get(latest, 'roc_12')}",
+        f"OBV: {_safe_get(latest, 'obv')}",
+        f"VWAP: {_safe_get(latest, 'vwap')}",
+    ]
+
+    result = "\n".join(lines) + "\n"
     _set_cache(cache_key, result)
     return result