Upload folder using huggingface_hub

src/market-analyst/backend/aagents/fundamental_analyst.py

@@ -23,11 +23,10 @@ def get_fundamental_analyst(model_client):
         
         DO NOT proceed without calling ALL THREE tools.
         
-        STEP 4: Evaluate Valuation & Growth
-        - P/E Ratio: <15 (Undervalued), 15-25 (Fair), >25 (Premium).
-        - PEG Ratio: <1.0 (Cheap Growth), >2.0 (Expensive).
-        - EPS Trend: Forward > Trailing? (Growth).
-        - Dividend Yield: >4% (Income).
+        STEP 4: Evaluate Valuation & Growth (USE 'valuation_score' & 'quality_score')
+        - If UNDERVALUED: Bullish Factor.
+        - If PREMIUM: Bearish/Neutral Factor (unless High Growth).
+        - If HIGH_QUALITY: Bullish Factor.
         
         STEP 5: Assess Financial Health
         - Debt/Equity Ratio: <0.5 (Safe), >1.0 (Risky).

src/market-analyst/backend/aagents/market_analyst.py

@@ -28,33 +28,24 @@ def get_technical_analyst(model_client):
         - If SPY is BEARISH, bias is SHORT/HEDGE.
         - If VIX is HIGH (>30), bias is CAUTION.
         
-        STEP 5: Analyze Stock Trend Structure
-        - Price vs SMA200: Above = Bullish bias, Below = Bearish bias
-        - SMA20 vs SMA50 vs SMA200: Check for golden/death crosses
-        - Price vs EMA20: Short-term trend strength
-        
-        STEP 6: Momentum Analysis
-        - RSI: >70 = Overbought, <30 = Oversold, 40-60 = Neutral
-        - MACD: Signal line crossover (Bullish if MACD > Signal, Bearish if MACD < Signal)
-        - MACD Histogram: Increasing = Momentum building, Decreasing = Momentum fading
-        
-        STEP 7: Support & Resistance
-        - Identify key levels from SMA interaction
-        - Note if price is at/near major support or resistance
-        
-        STEP 8: Summarize Chart Health
-        Classify as one of:
-        - "Strong Bullish" (price > all SMAs, RSI 50-70, MACD bullish)
-        - "Weak Bullish" (price > SMA200 but mixed signals)
-        - "Consolidating" (price between SMAs, RSI neutral)
-        - "Weak Bearish" (price < SMA200 but mixed signals)
-        - "Strong Bearish" (price < all SMAs, RSI 30-50, MACD bearish)
-        
-        Output a clear, structured summary with:
+        STEP 5: Analyze Trend & Structure (USE 'trend_signal' from tool)
+        - If 'trend_signal' is STRONG_BULLISH/BULLISH -> Bullish Bias
+        - If 'trend_signal' is STRONG_BEARISH/BEARISH -> Bearish Bias
+        - Reference SMA/EMA levels as support/resistance.
+        
+        STEP 6: Momentum Analysis (USE 'rsi_signal' & 'macd_signal')
+        - Check RSI status (OVERSOLD/OVERBOUGHT/NEUTRAL).
+        - Check MACD Crossover status.
+        
+        STEP 7: Summarize Chart Health
+        - Use the specific signals found.
+        - Classify Trend based on 'trend_signal'.
+        
+        STEP 8: Output Structured Summary
         - Current Price
-        - Trend Classification
+        - Trend Classification (e.g., STRONG_BULLISH)
+        - Momentum Assessment (RSI/MACD signals)
         - Key Technical Levels
-        - Momentum Assessment
-        - Recommendation for next analyst (e.g., "Volatility should check if IV is elevated given this strong trend")
+        - Recommendation for next analyst
         """
     )

src/market-analyst/backend/aagents/risk_manager.py

@@ -6,71 +6,79 @@ def get_risk_manager(model_client):
         name="RiskManager",
         model_client=model_client,
         system_message="""
-        You are the Chief Risk Officer. Your role is to make the FINAL TRADE/WAIT decision.
-        
-        WORKFLOW (2 ROUNDS):
-        
-        ROUND 1 (CRITIQUE):
-        - StrategyAdvisor will provide a "DRAFT_STRATEGY".
-        - You MUST critique it. Challenge assumptions.
-        - CHECK DIRECTION MAPPING:
-          * "Bear Put/Call Spread" = BEARISH.
-          * "Bull Call/Put Spread" = BULLISH.
-          * "Iron Condor/Butterfly" = NEUTRAL.
-        - COMPARE WITH MARKET:
-          * If Strategy=Bearish and SPY Trend=Bullish -> "SEVERE CONFLICT".
-        - Output: "RISK REVIEW: [Your critique]. REQUEST REVISION."
-        - DO NOT OUTPUT "APPROVED".
-        
-        ROUND 2 (DECISION):
-        - StrategyAdvisor will provide "FINAL_STRATEGY".
-        - You must CALCULATE the Final Confidence Score (0-100):
-          * Trend Alignment (Market + Stock + Strategy Direction): 30 pts
-             (e.g., Bearish Strategy in Bearish Market = Full Points)
-          * Fundamentals (Valuation/Safety): 20 pts
-          * Volatility (IV Check): 20 pts
-          * Sentiment Context: 15 pts
-          * Risk/Reward Math (>2.0): 15 pts
-          
-        - DECISION THRESHOLD:
-          * Score >= 70 -> TRADE
-          * Score < 70 -> WAIT
-        
+        You are the Chief Risk Officer. Your mission is to enforce a STRICT DECISION MATRIX. 
+        Different AI models have different biases; you must ignore "vibes" and follow these quantitative rules.
+
+        1. THE SCORING RUBRIC (Total 100 points)
+        You MUST calculate and display this score in your reasoning:
+        - Technical Alignment (40 pts): Does the TechnicalAnalyst's trend (BULLISH/BEARISH) match the Strategy's Direction? 
+          * Match = 40 pts. Mismatch = 0 pts.
+        - Fundamentals/Safety (20 pts): Based on P/E, PEG, and Analyst Consensus.
+          * Rating 'SAFE'/'UNDERVALUED' = 20 pts. 'PREMIUM'/'RISKY' = 5 pts.
+        - Volatility/IV Regime (20 pts): 
+          * Strategy works for current Regime (e.g., Credit in High Vol) = 20 pts.
+        - Sentiment/News (20 pts): 
+          * Positive news = 20 pts. Negative/Old news = 5 pts.
+
+        2. THE DETERMINISTIC HARD GATES (BYPASS ALL OTHER LOGIC)
+        - GATE 1 (Trend Conflict): If Technical Tool says 'STRONG_BEARISH' and Strategy is 'BULLISH', Decision MUST be 'WAIT' (Override score).
+        - GATE 2 (Fear Gauge): If VIX > 35, Decision MUST be 'WAIT'.
+        - GATE 3 (Threshold): Score < 70 MUST be 'WAIT'.
+
+        IF THE DECISION IS WAIT:
+        - Set 'final_decision' to 'WAIT'.
+        - Set 'strategy_type' to 'WAIT'.
+        - Set 'entry_price', 'max_profit', 'max_loss' to 0.
+        - Set 'direction' to 'NEUTRAL'.
+        - Set 'entry_signal' to 'N/A'.
+
         OUTPUT FORMAT (ROUND 2 ONLY):
+        You MUST include a "score_card" object in your JSON.
         ```json
         {
           "final_decision": "TRADE",
-          "strategy_type": "Bull Call Spread",
-          "direction": "BULLISH",
+          "strategy_type": "Iron Condor",
+          "direction": "NEUTRAL",
           "confidence": 85,
-          "actionable_recommendation": "Execute Bull Call Spread...",
-          "entry_signal": "Net Debit",
-          "entry_price": 1.30,
-          "max_profit": 370,
-          "max_loss": 130,
-          "risk_warning": "Monitor RSI for overbought conditions. Set stop-loss at $0.80 debit."
+          "score_card": {
+            "technicals": 40,
+            "fundamentals": 20,
+            "volatility": 15,
+            "sentiment": 10,
+            "total": 85
+          },
+          "actionable_recommendation": "Execute Trade...",
+          "entry_signal": "Credit",
+          "entry_price": 1.50,
+          "max_profit": 150,
+          "max_loss": 350,
+          "risk_warning": "..."
         }
         ```
-        
-        IF DECISION IS WAIT:
+        (Note: max_profit/max_loss MUST be multiplied by 100 for a standard lot).
+
+        IF DECISION IS WAIT EXAMPLE:
         ```json
         {
           "final_decision": "WAIT",
           "strategy_type": "WAIT",
           "direction": "NEUTRAL",
           "confidence": 45,
-          "actionable_recommendation": "Stay in Cash. Risk Score too low.",
+          "score_card": { "technicals": 0, "fundamentals": 20, "volatility": 15, "sentiment": 10, "total": 45 },
+          "actionable_recommendation": "Re-evaluate market conditions. Risk score too low.",
           "entry_signal": "N/A",
           "entry_price": 0,
           "max_profit": 0,
           "max_loss": 0,
-          "risk_warning": "Market Trend (Bearish) conflicts with Strategy (Bullish). High VIX."
+          "risk_warning": "High conflict between technicals and sentiment."
         }
         ```
+
         APPROVED
-        
+
         CRITICAL:
-        1. "risk_warning" MUST be specific to the analysis.
+        1. Always show your math before the JSON.
         2. Output 'APPROVED' ONLY after the JSON in Round 2.
+        3. For Llama/Groq models: YOU MUST wrap the JSON object in a triple-backtick markdown block: ```json { ... } ```
         """
     )

src/market-analyst/backend/aagents/strategy_advisor.py

@@ -37,7 +37,11 @@ def get_strategy_advisor(model_client):
         STEP 5: Validate Risk/Reward (MANDATORY)
         - For Debit Spreads: Ensure Max Profit > Max Loss (Reward/Risk > 1.0).
         - For Credit Spreads: Ensure Probability of Profit is high (Delta checks).
-        - If Risk/Reward is poor, search for better strikes or switch to WAIT.
+        - METRICS SUMMARY: You MUST summarize your case using these labels before the JSON:
+          * METRIC: Trend=[BULLISH/BEARISH]
+          * METRIC: Volatility=[HIGH/LOW]
+          * METRIC: Sentiment=[POSITIVE/NEGATIVE]
+          * METRIC: Safety=[SAFE/PREMIUM]
         
         STEP 6: TEAM COLLABORATION (2 ROUNDS)
         
@@ -49,7 +53,9 @@ def get_strategy_advisor(model_client):
         
         ROUND 2 (TEAMS FINALIZATION):
         - Review Risk Manager's critique.
-        - If rejected, switch to WAIT or adjust strikes.
+        - If rejected, or if you switch to WAIT for any reason, you MUST:
+          1. Set "strategy" to "WAIT"
+          2. Set "estimated_entry_price", "max_profit", and "max_loss" to 0.
         - If accepted, Output "FINAL_STRATEGY".
         - Calculate Final Score (Standardized Rubric).
         - GENERATE THE FINAL JSON BLOCK.
@@ -69,6 +75,7 @@ def get_strategy_advisor(model_client):
           "breakeven": 146.30
         }
         ```
+        (Note: max_profit/max_loss are calculated for 100 shares/1 contract).
         
         EXAMPLE OUTPUT (WAIT):
         ```json
@@ -93,6 +100,8 @@ def get_strategy_advisor(model_client):
         4. ALL fields are REQUIRED
         5. Show your confidence calculation explicitly
         6. Be verbose - explain your reasoning step-by-step before JSON
+        7. LOT-BASED MATH: All profit/loss values (max_profit, max_loss) MUST be multiplied by 100 (standard lot size).
+           Example: A $1.50 credit spread = $150 Max Profit.
 
         FALLBACK PROCEDURE:
         If get_option_chain_snapshot fails or returns "No options data found":

src/market-analyst/backend/aagents/volatility_analyst.py

@@ -31,12 +31,10 @@ def get_volatility_analyst(model_client):
         - VIX 20-30: Elevated fear, caution advised
         - VIX > 30: High fear, extreme volatility
         
-        STEP 5: Determine Volatility Regime
-        Classify as:
-        - "Extremely Low Vol" (IV < 20%, VIX < 15): Buy debit spreads or long options
-        - "Low Vol" (IV 20-30%, VIX 15-20): Neutral, directional trades
-        - "Elevated Vol" (IV 30-50%, VIX 20-30): Sell credit spreads
-        - "High Vol" (IV > 50%, VIX > 30): Sell iron condors or wait
+        STEP 5: Determine Volatility Regime (USE 'volatility_regime' from tool)
+        - If LOW_VOL: Buy debit spreads or long options.
+        - If ELEVATED_VOL: Sell credit spreads.
+        - If HIGH_RISK_VOL: Sell Iron Condors or WAIT.
         
         STEP 6: Assess Option Liquidity
         - Check bid-ask spreads from option chain

src/market-analyst/backend/main.py

@@ -149,6 +149,12 @@ async def analyze(ticker: str, provider: str = "openai"):
                 raw_source = getattr(message, 'source', 'System')
                 content = getattr(message, 'content', '')
                 
+                # Check for tool_calls if content is empty (Explains 0-len messages)
+                if not content:
+                    tool_calls = getattr(message, 'tool_calls', None)
+                    if tool_calls:
+                         content = f"[Tool Call] Executing {len(tool_calls)} function(s)."
+                
                 # Handle non-string content (e.g., ToolCalls/FunctionCalls)
                 if not isinstance(content, str):
                     try:
@@ -167,14 +173,21 @@ async def analyze(ticker: str, provider: str = "openai"):
                     "source": raw_source,
                     "content": content
                 }
-                print(f"[STREAM] Sent: {raw_source} (len: {len(content)})")
+                
+                # If RiskManager, try to extract structured JSON for the frontend
+                if raw_source == 'RiskManager':
+                    structured = extract_json(content)
+                    if structured:
+                        payload["structured_result"] = structured
+
+                print(f"[DEBUG] Sent: {raw_source} (len: {len(content)})")
                 yield f"data: {json.dumps(payload)}\n\n"
         except Exception as e:
             print(f"[STREAM ERROR] {str(e)}")
             error_msg = f"Analysis execution failed: {str(e)}"
             yield f"data: {json.dumps({'source': 'Error', 'content': error_msg})}\n\n"
             
-        print("[STREAM] Done.")
+        print("[DEBUG] Done.")
         # Cleanup
         if analysis_id in active_analyses:
             del active_analyses[analysis_id]

src/market-analyst/backend/tools/market_data.py

@@ -78,7 +78,8 @@ def get_historical_volatility(symbol: str, period: str = "1mo") -> dict:
             "ticker_used": symbol,
             "annualized_volatility": round(volatility * 100, 2),
             "period": period,
-            "vix_reference": round(vix_price, 2) if vix_price else "N/A"
+            "vix_reference": round(vix_price, 2) if vix_price else "N/A",
+            "volatility_regime": "HIGH_RISK_VOL" if (vix_price and vix_price > 30) else "ELEVATED_VOL" if (vix_price and vix_price > 20) else "LOW_VOL" if (vix_price and vix_price < 15) else "NORMAL_VOL"
         }
     except Exception as e:
         return {"error": str(e)}
@@ -225,43 +226,48 @@ def get_technical_indicators(symbol: str) -> dict:
             hist['RSI_14'] = pd.Series([None] * len(hist), index=hist.index)
         
         current_data = hist.iloc[-1]
-        
-        # Interpretation RSI
+        price = current_data['Close']
         rsi_val = current_data.get('RSI_14')
-        rsi_signal = "Neutral"
-        if rsi_val is not None and not pd.isna(rsi_val):
-            rsi_val = round(rsi_val, 2)
-            if rsi_val > 70: rsi_signal = "Overbought"
-            elif rsi_val < 30: rsi_signal = "Oversold"
-        
-        # Interpretation MACD
         macd_val = current_data.get('MACD')
         signal_val = current_data.get('Signal_Line')
-        macd_signal = "Neutral"
-        if macd_val is not None and signal_val is not None:
-            if macd_val > signal_val: macd_signal = "Bullish Crossover"
-            else: macd_signal = "Bearish Crossover"
-
-        price = current_data['Close']
-        trend = "Neutral"
         sma200 = current_data.get('SMA_200')
+        if pd.isna(sma200): sma200 = None
+
+        # Interpretation RSI
+        # Deterministic Signals
+        rsi_signal = "NEUTRAL"
+        if rsi_val is not None and not pd.isna(rsi_val):
+             if rsi_val > 70: rsi_signal = "OVERBOUGHT"
+             elif rsi_val < 30: rsi_signal = "OVERSOLD"
         
-        if sma200 is not None and not pd.isna(sma200):
-            if price > sma200: trend = "Bullish Long-term"
-            else: trend = "Bearish Long-term"
-            
+        macd_signal = "NEUTRAL"
+        if macd_val is not None and signal_val is not None and not pd.isna(macd_val) and not pd.isna(signal_val):
+             if macd_val > signal_val: macd_signal = "BULLISH_CROSS"
+             elif macd_val < signal_val: macd_signal = "BEARISH_CROSS"
+             
+        trend_signal = "NEUTRAL"
+        sma50 = current_data.get('SMA_50')
+        sma20 = current_data.get('SMA_20')
+        
+        # Check all components for trend signal
+        if sma200 is not None and sma50 is not None and sma20 is not None and not pd.isna(sma50) and not pd.isna(sma20):
+             if price > sma20 > sma50 > sma200: trend_signal = "STRONG_BULLISH"
+             elif price < sma20 < sma50 < sma200: trend_signal = "STRONG_BEARISH"
+             elif price > sma200: trend_signal = "BULLISH"
+             elif price < sma200: trend_signal = "BEARISH"
+
         return {
             "ticker": symbol,
             "current_price": round(price, 2),
             "sma_20": round(current_data['SMA_20'], 2) if not pd.isna(current_data.get('SMA_20')) else "N/A",
             "ema_20": round(current_data['EMA_20'], 2) if not pd.isna(current_data.get('EMA_20')) else "N/A",
             "sma_50": round(current_data['SMA_50'], 2) if not pd.isna(current_data.get('SMA_50')) else "N/A",
-            "sma_200": round(sma200, 2) if sma200 is not None and not pd.isna(sma200) else "N/A",
-            "rsi_14": rsi_val or "N/A",
-            "macd": round(macd_val, 2) if macd_val is not None else "N/A",
+            "sma_200": round(sma200, 2) if (sma200 is not None and not pd.isna(sma200)) else "N/A",
+            "rsi_14": round(rsi_val, 2) if (rsi_val is not None and not pd.isna(rsi_val)) else "N/A",
+            "macd": round(macd_val, 2) if (macd_val is not None and not pd.isna(macd_val)) else "N/A",
             "macd_signal": macd_signal,
             "rsi_signal": rsi_signal,
-            "trend_signal": trend
+            "trend_signal": trend_signal
         }
         
     except Exception as e:
@@ -309,7 +315,9 @@ def get_fundamental_data(symbol: str) -> dict:
             "dividend_yield": f"{round(dividend_yield * 100, 2)}%" if dividend_yield else "N/A",
             "market_cap": info.get('marketCap', "N/A"),
             "sector": info.get('sector', "N/A"),
-            "next_earnings_date": next_earnings
+            "next_earnings_date": next_earnings,
+            "valuation_score": "UNDERVALUED" if (pe_ratio and pe_ratio < 15) else "PREMIUM" if (pe_ratio and pe_ratio > 30) else "FAIR_VALUE",
+            "quality_score": "HIGH_QUALITY" if (profit_margin and profit_margin > 0.20) else "LOW_MARGIN" if (profit_margin and profit_margin < 0.10) else "AVERAGE"
         }
     except Exception as e:
         return {"error": str(e)}

src/market-analyst/backend/tools/news_data.py

@@ -1,9 +1,14 @@
 from ddgs import DDGS
 from transformers import pipeline
 import torch
-import requests
+from curl_cffi import requests
 from bs4 import BeautifulSoup
+import yfinance as yf
+import datetime
+import time
 from typing import Optional
+from pydantic import BaseModel, Field
+import concurrent.futures
 
 # Global variable for lazy loading
 _sentiment_pipeline = None
@@ -24,43 +29,36 @@ def get_sentiment_pipeline():
             return None
     return _sentiment_pipeline
 
-def _fetch_page_content(url: str, timeout: int = 5) -> Optional[str]:
+def _fetch_page_content(url: str, timeout: int = 15) -> Optional[str]:
     """Fetch and extract text content from a web page."""
-    print(f"[DEBUG] fetch_page_content called with: {url} - timeout: {timeout}")
+    print(f"[DEBUG] Fetching: {url}")
+    start_time = time.time()
     try:
-        headers = {
-            'User-Agent': (
-                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) '
-                'AppleWebKit/537.36 (KHTML, like Gecko) '
-                'Chrome/91.0.4472.124 Safari/537.36'
-            )
-        }
-        response = requests.get(url, headers=headers, timeout=timeout)
+        # Use curl_cffi to impersonate Chrome 110 (Bypasses TLS Fingerprinting)
+        # Headers are auto-managed by impersonate
+        response = requests.get(url, timeout=timeout, impersonate="chrome110")
         response.raise_for_status()
-
+        
         soup = BeautifulSoup(response.content, 'html.parser')
-
-        # Remove irrelevant elements
-        for tag in soup(["script", "style", "nav", "footer", "header", "aside"]):
+        
+        # Remove ads, popups, and non-content elements
+        # Targeted classes: .ad, .popup, .modal, .cookie-banner, etc.
+        for tag in soup.select("script, style, nav, footer, header, aside, form, iframe, .ad, .popup, .modal, .cookie-banner, [id*='popup'], [class*='popup'], [class*='ad-'], [class*='banner']"):
             tag.decompose()
-
+            
         # Extract text
-        text = soup.get_text(separator='\n', strip=True)
-
-        # Clean whitespace
-        lines = (line.strip() for line in text.splitlines())
-        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
-        text = '\n'.join(chunk for chunk in chunks if chunk)
-        
+        text = soup.get_text(separator=' ', strip=True)
+        duration = round(time.time() - start_time, 2)
+        print(f"[DEBUG] Fetch success ({duration}s): {url}")
         return text
     except Exception as e:
-        print(f"[WARNING] Failed to fetch content from {url}: {str(e)}")
+        msg = str(e)
+        if "403" in msg:
+             print(f"[INFO] Access denied (403) for {url}. Falling back to snippet.")
+        else:
+             print(f"[WARNING] Failed to fetch content from {url}: {msg}")
         return None
 
-from pydantic import BaseModel, Field
-from typing import Optional
-import concurrent.futures
-
 # Validation Model
 class NewsArticle(BaseModel):
     title: str = Field(..., description="The headline of the news article.")
@@ -80,72 +78,94 @@ def search_news(ticker: str) -> str:
             return "No ticker provided for news search."
             
         ticker = ticker.upper().strip()
-        query = f"{ticker} stock news financial"
+        articles_pool = []
         
-        results = []
-        sentiment_pipe = get_sentiment_pipeline()
+        # 1. Fetch from Yahoo Finance API (Reliable)
+        try:
+             print("[DEBUG] Fetching YF API news...")
+             yf_ticker = yf.Ticker(ticker)
+             yf_raw = yf_ticker.news
+             if yf_raw:
+                 for item in yf_raw:
+                     ts = item.get('providerPublishTime')
+                     date_str = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d') if ts else 'Unknown'
+                     articles_pool.append(NewsArticle(
+                         title=item.get('title', 'No Title'),
+                         link=item.get('link', ''),
+                         snippet=f"Source: {item.get('publisher')} - {date_str}",
+                         datetime=date_str
+                     ))
+        except Exception as e:
+             print(f"[WARNING] YF API failed: {e}")
+             
+        # 2. Add DuckDuckGo Targeted Search (Secondary)
+        # Targeted sites: CNBC, Bloomberg, Investing.com, MarketWatch
+        query = f"{ticker} stock news (site:cnbc.com OR site:bloomberg.com OR site:investing.com OR site:marketwatch.com)"
         
         with DDGS() as ddgs:
-            # Use 'news' backend
-            raw_results = list(ddgs.news(query, max_results=5))
-            
-            if not raw_results:
-                 return f"No recent news found for {ticker}."
-            
-            # Helper to process one item (fetch + analyze)
-            def process_news_item(raw_item):
+            raw_results = list(ddgs.news(query, max_results=10))
+            for raw_item in raw_results:
                 try:
-                    # Validate / Map Raw Dict to Pydantic Model
-                    # DDGS returns: 'title', 'url', 'body', 'date', 'source'
-                    # We map them to our requested schema
-                    article = NewsArticle(
+                    articles_pool.append(NewsArticle(
                         title=raw_item.get('title', 'No Title'),
                         link=raw_item.get('url', ''),
                         snippet=raw_item.get('body', ''),
-                        datetime=raw_item.get('date', 'Unknown Date')
-                    )
-                except Exception as validation_err:
-                    print(f"[WARNING] Skipping invalid news item: {validation_err}")
-                    return None
-
-                # Processing using Validated Object
-                source = raw_item.get('source', 'Unknown Source') # Keep source for display
-                
-                # FinBERT Analysis
-                sentiment_tag = ""
-                if sentiment_pipe:
-                    try:
-                        # 1. Try to fetch full content
-                        content_to_analyze = article.title
-                        analysis_type = "Headline"
-                        
-                        if article.link:
-                            full_text = _fetch_page_content(article.link)
-                            if full_text and len(full_text) > 100:
-                                content_to_analyze = full_text
-                                analysis_type = "Full Text"
-                        
-                        # 2. Truncate for FinBERT
-                        score = sentiment_pipe(content_to_analyze[:2000])[0]
-                        label = score['label']
-                        conf = round(score['score'], 2)
-                        
-                        sentiment_tag = f" [FinBERT ({analysis_type}): {label} ({conf})]"
-                        print(f"[DEBUG] FinBERT analysis for {article.title}: {sentiment_tag}")
-                    except Exception as e:
-                        sentiment_tag = f" [FinBERT: Error ({str(e)[:50]})]"
-
-                return f"- [{source} | {article.datetime}] {article.title}{sentiment_tag}"
+                        datetime=raw_item.get('date', 'Unknown')
+                    ))
+                except: continue
 
-            # Run in parallel
-            with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
-                # filter out None results from validation failures
-                results = [r for r in executor.map(process_news_item, raw_results) if r is not None]
+        if not articles_pool:
+             return f"No recent news found for {ticker}."
+             
+        # Deduplicate by Title
+        seen_titles = set()
+        unique_articles = []
+        for a in articles_pool:
+            if a.title not in seen_titles:
+                seen_titles.add(a.title)
+                unique_articles.append(a)
         
-        if not results:
-            return f"No recent news found for {ticker}."
+        # Analyze Top 5
+        top_articles = unique_articles[:5]
+        sentiment_pipe = get_sentiment_pipeline()
+        
+        results = []
+        
+        # Helper to process
+        def process_article(article):
+            # FinBERT Analysis
+            sentiment_tag = ""
+            if sentiment_pipe:
+                try:
+                    # Prefer full text fetch, fallback to Snippet
+                    content = article.snippet if article.snippet else article.title
+                    analysis_type = "Snippet" if article.snippet else "Headline"
+                    
+                    
+                    # Try fetch full text with improved headers
+                    if article.link:
+                        full_text = _fetch_page_content(article.link)
+                        if full_text and len(full_text) > 100:
+                             content = full_text
+                             analysis_type = "Full Text"
+                        else:
+                             # Fallback log
+                             print(f"[DEBUG] Content too short/failed for {article.title[:30]}... using Snippet.")
+                    
+                    # Truncate for BERT
+                    score = sentiment_pipe(content[:2000])[0]
+                    label = score['label']
+                    conf = round(score['score'], 2)
+                    sentiment_tag = f" [FinBERT ({analysis_type}): {label} ({conf})]"
+                except Exception as e:
+                    sentiment_tag = f" [FinBERT: Error]"
+            
+            return f"- [{article.datetime}] {article.title}{sentiment_tag}"
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+            results = list(executor.map(process_article, top_articles))
             
-        return f"Recent News for {ticker} (with FinBERT Analysis):\n" + "\n".join(results)
+        return f"Recent News for {ticker} (Sources: YF, CNBC, Bloomberg, Investing):\n" + "\n".join(results)
         
     except Exception as e:
         return f"Error fetching news for {ticker}: {str(e)}"

src/market-analyst/frontend/src/App.vue

@@ -211,22 +211,31 @@ const analyzeTicker = (symbol) => {
         scrollToBottom()
       }
 
-      // If RiskManager output, try to parse JSON for summary
+      // Use backend-provided structured result if available (highly recommended for Groq/Llama)
       if (data.source === 'RiskManager') {
-        const jsonMatch = data.content.match(/```json\s*([\s\S]*?)\s*```/) || data.content.match(/\{[\s\S]*"final_decision"[\s\S]*\}/)
-        if (jsonMatch) {
-          try {
-            const rawJson = jsonMatch[1] || jsonMatch[0]
-            const parsed = JSON.parse(rawJson)
-            
+        if (data.structured_result) {
+            console.log("Using backend-provided structured result");
             pendingResult.value = {
                 ticker: symbol,
                 model: providers.find(p => p.id === provider.value)?.name || provider.value,
-                ...parsed
+                ...data.structured_result
+            }
+        } else {
+            // Fallback to local regex if structured_result is missing
+            const jsonMatch = data.content.match(/```json\s*([\s\S]*?)\s*```/) || data.content.match(/\{[\s\S]*"final_decision"[\s\S]*\}/)
+            if (jsonMatch) {
+                try {
+                    const rawJson = jsonMatch[1] || jsonMatch[0]
+                    const parsed = JSON.parse(rawJson)
+                    pendingResult.value = {
+                        ticker: symbol,
+                        model: providers.find(p => p.id === provider.value)?.name || provider.value,
+                        ...parsed
+                    }
+                } catch (e) {
+                    console.log("Failed to parse result JSON", e)
+                }
             }
-          } catch (e) {
-             console.log("Failed to parse result JSON", e)
-          }
         }
       }
     } catch (e) {
@@ -785,6 +794,16 @@ onMounted(() => {
   color: var(--text-primary);
 }
 
+.header-hint {
+  font-size: 11px;
+  color: var(--text-tertiary);
+  background: rgba(255, 255, 255, 0.05);
+  padding: 2px 8px;
+  border-radius: 4px;
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+
 .log-viewport {
   flex: 1;
   overflow-y: auto;