final updates

app/agents/adk_mathminds.py

@@ -21,6 +21,7 @@ from app.tools.python_executor import PythonInterpreter
 from app.tools.advanced_ocr import AdvancedOCR
 from app.tools.vision_analyzer import VisionAnalyzer
 from app.core.math_normalizer import MathQueryNormalizer
+from app.services.automation import automation_service
 
 logger = logging.getLogger(__name__)
 
@@ -152,13 +153,29 @@ class MathMindsADKAgent:
                 formatted += f"Problem: {item.get('problem_text')}\nSolution: {item.get('solution_text')}\n---\n"
             return formatted
 
+        async def trigger_automation(event_name: str, payload_json: str) -> str:
+            """
+            Trigger an external automation workflow (n8n). 
+            Use this for sending alerts, emails, Discord messages, or logging data.
+            Args:
+                event_name: Description of the event (e.g., 'complex_problem_solved').
+                payload_json: A JSON string containing the data to send.
+            """
+            try:
+                payload = json.loads(payload_json)
+                result = await automation_service.trigger(event_name, payload)
+                return f"Automation triggered: {result.get('status')}"
+            except Exception as e:
+                return f"Automation failed: {str(e)}"
+
         # ── Agent & Runner ────────────────────────────────────────────────────
         self.agent = Agent(
             name="math_minds_core",
             model=model_name,
             tools=[
                 web_search, math_solver, execute_python, 
-                find_similar_problems, image_interpreter, statistical_vision
+                find_similar_problems, image_interpreter, statistical_vision,
+                trigger_automation
             ],
             instruction=(
                 "You are MathMinds AI, a precise mathematical analytical assistant. "
@@ -175,7 +192,8 @@ class MathMindsADKAgent:
                 "In Python, you can use specialized libraries like `numpy`, `scipy`, or `sympy` for numerical and symbolic solutions."
                 "\n3. INTERPRET LATEX: Tool outputs (especially from SymPy) are often in raw LaTeX. "
                 "NEVER just display the raw LaTeX to the user. Always explain the steps in clear English. "
-                "Wrap LaTeX in `$ ... $` for inline or `$$ ... $$` for blocks so the UI renders it properly."
+                "Wrap LaTeX in `$ ... $` for inline or `$$ ... $$` for blocks so the UI renders it properly. "
+                "Example: Use '$x^2$' instead of 'x^2'."
                 "\n\nCRITICAL: Always explain your reasoning before and after using tools. If a tool fails, explain WHY and try a different approach."
             )
         )
@@ -245,6 +263,8 @@ class MathMindsADKAgent:
                     logger.error(f"Image decode failed: {e}")
 
             # ── 4. Run agent (Streaming) ──────────────────────────────────────────
+            yielded_text_len = 0
+            
             async for event in self.runner.run_async(
                 user_id=user_id,
                 session_id=session_id,
@@ -252,36 +272,41 @@ class MathMindsADKAgent:
                 run_config=RunConfig(streaming_mode=StreamingMode.SSE)
             ):
                 # ── Determine Event Type ──
-                # is_final_response() is usually True for the final user-facing text
                 try:
                     is_final = event.is_final_response()
                 except Exception:
                     is_final = False
                 
-                # ── Capture Content (Text) ──
+                # ── Capture Content (Text Delta) ──
                 if hasattr(event, "content") and event.content and event.content.parts:
-                    for part in event.content.parts:
-                        if hasattr(part, "text") and part.text:
-                            # Stream ALL text to the main answer window
-                            # This fixes the "empty answer until refresh" issue.
-                            yield {"type": "answer", "content": part.text}
-                            
-                            # Log terminal responses separately if needed for logic
-                            if is_final:
-                                logger.debug(f"Final response chunk received: {part.text[:50]}...")
+                    # ✅ Safer handling: Ensure we only join STRINGS (handle None indices from tool parts)
+                    full_turn_text = "".join((getattr(part, "text", "") or "") for part in event.content.parts)
+                    
+                    # Handle buffer reset (happens after tool calls)
+                    if len(full_turn_text) < yielded_text_len:
+                        yielded_text_len = 0
+                    
+                    # Stream delta
+                    if len(full_turn_text) > yielded_text_len:
+                        delta = full_turn_text[yielded_text_len:]
+                        yielded_text_len = len(full_turn_text)
+                        yield {"type": "answer", "content": delta}
+                        
+                        if is_final:
+                            logger.debug(f"Final response chunk received: {delta[:50]}...")
                 
                 # ── Capture Tool Usage (Reasoning) ──
                 for fc in event.get_function_calls():
                     yield {
-                        "type": "action", 
-                        "content": f"Using tool: {fc.name}"
+                        "type": "thought",  # Changed from action to thought for UI consistency
+                        "content": f"⚙️ {fc.name}"
                     }
 
                 # ── Capture Tool Response ──
                 for fr in event.get_function_responses():
                      yield {
-                        "type": "observation", 
-                        "content": f"Obtained result from {fr.name}"
+                        "type": "thought", # Changed from observation to thought for UI consistency
+                        "content": f"👁️ Result from {fr.name}"
                     }
 
         except Exception as e:

app/api/main.py

@@ -294,15 +294,15 @@ async def solve_problem(
 
     async def event_generator():
         try:
-            async for chunk in orchestrator.process_problem(
-                text=solve_req.effective_text, 
+            async for event in orchestrator.solve_problem_stream(
+                query=solve_req.effective_text, 
                 image=solve_req.image, 
-                request_id=final_request_id,
-                model_preference=solve_req.model_preference,
+                user_id=current_user["uid"], 
                 session_id=solve_req.session_id,
-                user_id=current_user.get("uid")
+                request_id=final_request_id
             ):
-                yield json.dumps(chunk) + "\n"
+                # ✅ STRICT SSE FORMAT
+                yield f"data: {json.dumps(event)}\n\n"
         except Exception as e:
             logger.error(f"Streaming error: {e}")
             yield json.dumps({"type": "error", "content": "Internal processing error"}) + "\n"
@@ -313,7 +313,15 @@ async def solve_problem(
                 except Exception:
                     pass
 
-    return StreamingResponse(event_generator(), media_type="application/x-ndjson")
+    return StreamingResponse(
+        event_generator(), 
+        media_type="text/event-stream",
+        headers={
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "X-Accel-Buffering": "no" # Prevent Nginx buffering
+        }
+    )
 
 # --- Chat History Endpoints ---
 

app/core/orchestrator.py

@@ -43,9 +43,9 @@ class Orchestrator:
             logger.critical(f"Failed to initialize Orchestrator: {e}")
             raise
 
-    async def process_problem(
+    async def solve_problem_stream(
         self,
-        text: Optional[str] = None,
+        query: Optional[str] = None,
         image: Optional[str] = None,
         request_id: Optional[str] = None,
         model_preference: str = "fast",
@@ -71,7 +71,7 @@ class Orchestrator:
 
         try:
             # ── 1. Input processing ───────────────────────────────────────────
-            processed = self.input_processor.process_compound(text_input=text, image_input=image)
+            processed = self.input_processor.process_compound(text_input=query, image_input=image)
             if not processed.is_valid:
                 yield {"type": "error", "content": processed.error_message}
                 return
@@ -79,12 +79,16 @@ class Orchestrator:
             query = processed.cleaned_content
             image_data = processed.metadata.get("image_data")
 
-            # Background: Persist user message
+            # 1.5. Persist user message (Safety Check: Don't duplicate)
             if user_id and session_id:
-                asyncio.create_task(self._persist_message(
-                    user_id=user_id, session_id=session_id, role="user", 
-                    content=text or "Uploaded an image", image_data=image_data
-                ))
+                # Check if this exact request already exists in DB to prevent duplicates
+                history = self.db_manager.get_chat_history(user_id, session_id) or []
+                if not any(m.get("request_id") == request_id for m in history):
+                    await self._persist_message(
+                        user_id=user_id, session_id=session_id, role="user", 
+                        content=query or "Uploaded an image", image_data=image_data,
+                        request_id=request_id
+                    )
 
             # ── 2. Cache lookup ───────────────────────────────────────────────
             if settings.ENABLE_CACHE and not image_data:
@@ -93,12 +97,9 @@ class Orchestrator:
                 if cached:
                     yield {"type": "thought", "content": "Retrieving answer from memory..."}
                     yield {"type": "answer", "content": cached.get("answer")}
-                    # Background: Persist assistant response
+                    # Persist assistant response
                     if user_id and session_id:
-                        asyncio.create_task(self._persist_message(
-                            user_id=user_id, session_id=session_id, role="assistant",
-                            content=cached.get("answer"), metadata=cached.get("metadata")
-                        ))
+                        await self._persist_log(query, {"answer": cached.get("answer"), "metadata": cached.get("metadata")}, user_id, session_id, cache_key)
                     return
             else:
                 cache_key = None
@@ -116,7 +117,7 @@ class Orchestrator:
                         "metadata": {"model": "sympy", "tools_used": ["sympy"]}
                     })
                     
-                    self._fire_and_forget_log(query, result_schema, user_id, session_id, cache_key)
+                    await self._persist_log(query, result_schema, user_id, session_id, cache_key, request_id=request_id)
                     return
 
             # ── 4. Agentic Streaming Loop ─────────────────────────────────────
@@ -149,7 +150,8 @@ class Orchestrator:
             result_schema["metadata"]["latency_ms"] = int((time.time() - start_time) * 1000)
             
             if full_answer:
-                self._fire_and_forget_log(query, result_schema, user_id, session_id, cache_key)
+                # AWAIT the final log instead of fire-and-forget to prevent race conditions with UI reloads.
+                await self._persist_log(query, result_schema, user_id, session_id, cache_key, request_id=request_id)
 
         except Exception as e:
             logger.error(f"Orchestrator Error: {e}")
@@ -162,18 +164,15 @@ class Orchestrator:
         except Exception as e:
             logger.error(f"Failed to persist message: {e}")
 
-    def _fire_and_forget_log(self, query, schema, user_id, session_id, cache_key):
-        """Fire and forget persistence to avoid blocking the stream completion."""
-        asyncio.create_task(self._persist_log(query, schema, user_id, session_id, cache_key))
-
-    async def _persist_log(self, query, schema, user_id, session_id, cache_key):
+    async def _persist_log(self, query, schema, user_id, session_id, cache_key, request_id=None):
         """Internal awaitable helper."""
         # Map logic_trace to reasoning for frontend consistency
         reasoning = "\n".join(schema["metadata"].get("logic_trace", []))
         
         await self._persist_message(
             user_id=user_id, session_id=session_id, role="assistant",
-            content=schema["answer"], reasoning=reasoning, metadata=schema["metadata"]
+            content=schema["answer"], reasoning=reasoning, metadata=schema["metadata"],
+            request_id=request_id
         )
         if settings.ENABLE_CACHE and cache_key:
             self.cache_manager.set_cached_answer(cache_key, schema)

app/core/settings.py

@@ -44,6 +44,7 @@ class Settings(BaseSettings):
     SUPABASE_URL: Optional[str] = None
     SUPABASE_KEY: Optional[str] = None
     WOLFRAM_APP_ID: Optional[str] = None
+    N8N_WEBHOOK_URL: Optional[str] = None
 
     # Security
     JWT_SECRET_KEY: str = "super_secret_key_change_me"

app/services/automation.py

@@ -0,0 +1,53 @@
+import logging
+import httpx
+from typing import Dict, Any, Optional
+from app.core.settings import settings
+
+logger = logging.getLogger(__name__)
+
+class AutomationService:
+    """
+    Service for integrating with n8n via webhooks.
+    Used for external notifications, data logging, and low-code workflows.
+    """
+
+    def __init__(self, webhook_url: Optional[str] = None):
+        self.webhook_url = webhook_url or settings.N8N_WEBHOOK_URL
+
+    async def trigger(self, event_name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Triggers an n8n workflow by sending a POST request to a webhook.
+        """
+        if not self.webhook_url:
+            logger.warning("n8n automation triggered but no N8N_WEBHOOK_URL is configured.")
+            return {"status": "skipped", "reason": "no_webhook_url"}
+
+        try:
+            # Add metadata to the payload
+            data = {
+                "event": event_name,
+                "timestamp": settings.datetime.now().isoformat() if hasattr(settings, 'datetime') else None,
+                "environment": settings.ENV,
+                "data": payload
+            }
+
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    self.webhook_url,
+                    json=data,
+                    timeout=10.0
+                )
+            
+            if response.status_code in (200, 201):
+                logger.info(f"n8n automation triggered successfully: {event_name}")
+                return {"status": "success", "response": response.json() if response.content else "OK"}
+            else:
+                logger.error(f"n8n automation failed with status {response.status_code}: {response.text}")
+                return {"status": "error", "code": response.status_code, "detail": response.text}
+
+        except Exception as e:
+            logger.error(f"Error triggering n8n automation: {e}")
+            return {"status": "error", "detail": str(e)}
+
+# Singleton instance
+automation_service = AutomationService()

db_diag.py

@@ -0,0 +1,21 @@
+import os
+from pymongo import MongoClient
+from dotenv import load_dotenv
+
+load_dotenv()
+
+mongo_uri = os.getenv("MONGO_URI")
+client = MongoClient(mongo_uri)
+db = client.mathminds_db
+# FIXED COLLECTION NAME
+sessions = db.chat_sessions
+
+print("LAST 3 SESSIONS:")
+for s in sessions.find().sort("created_at", -1).limit(3):
+    print(f"Session: {s.get('session_id')} | User: {s.get('user_id')}")
+    print(f"Title: {s.get('title')}")
+    msgs = s.get("messages", [])
+    print(f"Messages Count: {len(msgs)}")
+    for m in msgs[-10:]:
+        print(f"  [{m.get('role')}] {m.get('content')[:100]} (RID: {m.get('request_id')})")
+    print("-" * 20)

docker-compose.yml

@@ -21,7 +21,7 @@ services:
       - mathminds_net
     restart: unless-stopped
     healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      test: [ "CMD", "curl", "-f", "http://localhost:8000/health" ]
       interval: 30s
       timeout: 10s
       retries: 3
@@ -47,7 +47,7 @@ services:
     restart: unless-stopped
 
   frontend:
-    build: 
+    build:
       context: .
       dockerfile: frontend/Dockerfile
     container_name: mathminds_frontend
@@ -64,7 +64,7 @@ services:
       - mathminds_net
     restart: unless-stopped
     healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:8501/_stcore/health"]
+      test: [ "CMD", "curl", "-f", "http://localhost:8501/_stcore/health" ]
       interval: 30s
       timeout: 10s
       retries: 3
@@ -81,7 +81,7 @@ services:
       - mathminds_net
     restart: unless-stopped
     healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
+      test: [ "CMD", "redis-cli", "ping" ]
       interval: 10s
       timeout: 5s
       retries: 5
@@ -97,11 +97,28 @@ services:
       - mathminds_net
     restart: unless-stopped
     healthcheck:
-      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+      test: [ "CMD", "mongosh", "--eval", "db.adminCommand('ping')" ]
       interval: 10s
       timeout: 5s
       retries: 5
 
+  n8n:
+    image: n8nio/n8n:latest
+    container_name: mathminds_n8n
+    ports:
+      - "5678:5678"
+    environment:
+      - N8N_HOST=localhost
+      - N8N_PORT=5678
+      - N8N_PROTOCOL=http
+      - NODE_ENV=production
+      - WEBHOOK_URL=http://localhost:5678/
+    volumes:
+      - n8n_data:/home/node/.n8n
+    networks:
+      - mathminds_net
+    restart: unless-stopped
+
 networks:
   mathminds_net:
     driver: bridge
@@ -109,3 +126,4 @@ networks:
 volumes:
   redis_data:
   mongo_data:
+  n8n_data:

frontend/app.py

@@ -1,5 +1,6 @@
 import streamlit as st
 import requests
+import json
 import base64
 from PIL import Image
 import io
@@ -206,7 +207,35 @@ def load_messages(session_id):
             headers=headers, timeout=30
         )
         if response.status_code == 200:
-            st.session_state.messages = response.json()
+            server_messages = response.json()
+            local_messages = st.session_state.get("messages", [])
+
+            # ✅ INDESTRUCTIBLE MERGE LOGIC
+            # 1. Start with server messages as the definitive baseline.
+            merged = []
+            server_keys = set()
+            for m in server_messages:
+                merged.append(m)
+                rid = m.get("request_id")
+                role = m.get("role")
+                if rid and role:
+                    server_keys.add((role, rid))
+
+            # 2. Append local messages that have NOT yet reached the server.
+            # This protects local "optimistic" messages from vanishing if DB is slow.
+            for lm in local_messages:
+                rid = lm.get("request_id")
+                role = lm.get("role")
+                if rid and role:
+                    if (role, rid) not in server_keys:
+                        merged.append(lm)
+                elif not rid:
+                    # Fallback for messages without IDs (should be rare)
+                    content_prefix = str(lm.get("content", ""))[:50]
+                    if not any(str(sm.get("content", "")).startswith(content_prefix) for sm in server_messages):
+                        merged.append(lm)
+
+            st.session_state.messages = merged
         elif response.status_code == 404:
             # Session doesn't belong to this user — clear silently
             st.session_state.messages = []
@@ -216,6 +245,7 @@ def load_messages(session_id):
             st.session_state.messages = []
             st.error(f"Failed to load messages: {response.status_code}")
     except Exception as e:
+        logger.error(f"Error loading messages: {e}")
         st.error(f"Error loading messages: {e}")
         st.session_state.messages = []
 
@@ -227,9 +257,15 @@ def get_active_session():
     return None
 
 
-def add_message(role, content, sent_to_api=False, **kwargs):
+def add_message(role, content, sent_to_api=False, request_id=None, **kwargs):
     """Optimistic UI update only — persistence happens in the backend via /solve."""
-    msg = {"role": role, "content": content, "timestamp": time.time(), "sent_to_api": sent_to_api}
+    msg = {
+        "role": role, 
+        "content": content, 
+        "timestamp": time.time(), 
+        "sent_to_api": sent_to_api,
+        "request_id": request_id
+    }
     msg.update(kwargs)
     st.session_state.messages.append(msg)
 
@@ -476,9 +512,7 @@ def chat_interface():
                     if badges:
                         st.markdown(badges, unsafe_allow_html=True)
 
-                if msg.get("reasoning") or msg.get("explanation"):
-                    with st.expander("Show Reasoning Steps"):
-                        st.markdown(msg.get("reasoning") or msg.get("explanation"))
+                # Reasoning display removed as per user request
 
                 content = msg["content"]
                 if isinstance(content, dict) and "final_answer" in content:
@@ -547,78 +581,94 @@ def chat_interface():
         and not st.session_state.messages[-1].get("sent_to_api", False)
     ):
         last = st.session_state.messages[-1]
-        current_request_id = last.get("request_id") or str(uuid.uuid4())
-        last["request_id"]  = current_request_id
+        request_id = last.get("request_id") or str(uuid.uuid4())
+        last["request_id"]  = request_id
+        # ✅ CRITICAL: Mark as sent immediately to prevent re-triggering during streaming
+        last["sent_to_api"] = True
 
         with st.chat_message("assistant", avatar="🤖"):
-            status_msg = st.status("Thinking...", expanded=True)
-            logic_placeholder = status_msg.empty()
+            status_msg = st.status("Thinking...", expanded=False)
             answer_placeholder = st.empty()
             
             full_answer = ""
             logic_trace = []
             
             try:
-                last["sent_to_api"] = True
+                # Prepare SSE Session
                 payload = {
-                    "text":       last["content"],
-                    "image":      last.get("image_data"),
+                    "text": last["content"],
+                    "image": last.get("image_data"),
                     "session_id": st.session_state.active_session_id,
-                    "request_id": current_request_id,
+                    "request_id": request_id
                 }
                 headers = get_auth_headers()
-                
-                with requests.post(API_URL, json=payload, headers=headers, stream=True, timeout=360) as r:
+                with requests.post(f"{BACKEND_URL}/solve", json=payload, headers=headers, stream=True, timeout=360) as r:
                     if r.status_code == 200:
-                        for raw_line in r.iter_lines(decode_unicode=True):
-                            if raw_line:
-                                try:
-                                    line = raw_line.strip()
-                                    # Handle optional "data: " prefix if SSE is used
-                                    if line.startswith("data: "):
-                                        line = line[6:].strip()
+                        line_buffer = ""
+                        last_ui_update = time.time()
+                        
+                        # ✅ ZERO-BUFFER BYTE STREAMING
+                        for chunk in r.iter_content(chunk_size=None, decode_unicode=True):
+                            if chunk:
+                                line_buffer += chunk
+                                while "\n" in line_buffer:
+                                    line, line_buffer = line_buffer.split("\n", 1)
+                                    line = line.strip()
+                                    if not line: continue
+                                    
+                                    try:
+                                        if line.startswith("data:"):
+                                            line = line[len("data:"):].strip()
                                         
-                                    data = json.loads(line)
-                                    if data["type"] == "thought":
-                                        logic_trace.append(data["content"])
-                                    elif data["type"] == "action":
-                                        logic_trace.append(f"⚙️ {data['content']}")
-                                    elif data["type"] == "observation":
-                                        logic_trace.append(f"👁️ {data['content']}")
-                                    elif data["type"] == "answer":
-                                        full_answer += data["content"]
-                                        answer_placeholder.markdown(full_answer)
-                                    elif data["type"] == "error":
-                                        st.error(data["content"])
+                                        data = json.loads(line)
+                                        ev_type = data.get("type", "")
                                         
-                                    # Update logic trace UI
-                                    logic_placeholder.markdown("\n".join(logic_trace))
-                                except Exception:
-                                    continue
+                                        if ev_type == "answer":
+                                            content = data.get("content", "")
+                                            full_answer += content
+                                            # ✅ RATE-LIMITED UI UPDATE (Smooth @ 20fps)
+                                            if time.time() - last_ui_update > 0.05:
+                                                answer_placeholder.markdown(full_answer + "▌")
+                                                last_ui_update = time.time()
+                                        elif ev_type in ("thought", "action", "observation"):
+                                            content = data.get("content", "")
+                                            if content:
+                                                logic_trace.append(content)
+                                                status_msg.update(label=f"⚙️ {content}", state="running", expanded=False)
+                                    except Exception:
+                                        continue
                         
+                        # ✅ FINAL FLUSH
+                        if line_buffer.strip():
+                            try:
+                                line = line_buffer.strip()
+                                if line.startswith("data:"): line = line[len("data:"):].strip()
+                                data = json.loads(line)
+                                if data.get("type") == "answer":
+                                    full_answer += data.get("content", "")
+                            except Exception: pass
+
+                        # Finalize
+                        answer_placeholder.markdown(full_answer if full_answer else "No answer received.")
                         status_msg.update(label="Solved!", state="complete", expanded=False)
                         
-                        # Force sync with database to ensure UI has the latest persisted state
-                        if st.session_state.active_session_id:
-                            load_messages(st.session_state.active_session_id)
-                        load_sessions() # Refresh titles
-                    elif r.status_code == 401:
-                        _clear_user_state()
-                        st.session_state.user = None
-                        st.error("Session expired. Please log in again.")
+                        # Save & FINAL SYNC
+                        add_message("assistant", full_answer, request_id=request_id)
+                        time.sleep(0.1)
+                        load_messages(st.session_state.active_session_id)
+                        st.rerun()
                     else:
-                        st.error(f"Error: {r.status_code}")
-
+                        st.error(f"Backend Error: {r.status_code}")
             except Exception as e:
-                st.error(f"Connection error: {e}")
+                logger.error(f"Streaming Exception: {e}")
+                st.error(f"Connection lost or error: {e}")
             finally:
+                # ✅ CRITICAL: Always release processing lock
                 st.session_state.is_processing = False
-                # Final check for unsent user message cleanup
-                if st.session_state.messages and st.session_state.messages[-1].get("role") == "user":
-                    st.session_state.messages[-1]["sent_to_api"] = True
                 st.rerun()
 
 
+
 # ====================================================
 # Sidebar
 # ====================================================

test_api.py

@@ -0,0 +1,21 @@
+import requests
+import json
+import time
+
+url = "http://localhost:8000/solve"
+payload = {
+    "text": "what is 2+2?",
+    "session_id": "test_session",
+    "request_id": "test_rid_" + str(time.time())
+}
+
+print(f"Calling {url}...")
+headers = {"Authorization": "Bearer mock_token_123"}
+try:
+    with requests.post(url, json=payload, headers=headers, stream=True, timeout=30) as r:
+        print(f"Status: {r.status_code}")
+        for chunk in r.iter_content(chunk_size=1, decode_unicode=True):
+            if chunk:
+                print(chunk, end="", flush=True)
+except Exception as e:
+    print(f"\nFAILED: {e}")

test_orch.py

@@ -0,0 +1,27 @@
+import asyncio
+import os
+os.environ["DISABLE_MODEL_SOURCE_CHECK"] = "True"
+import json
+import sys
+
+# Add current dir to path
+sys.path.append(os.getcwd())
+
+from app.core.orchestrator import Orchestrator
+
+async def test_stream():
+    # Mock dependencies
+    orch = Orchestrator()
+    print("Orchestrator initialized.")
+    
+    query = "what is 9^3?"
+    print(f"Solving: {query}")
+    
+    try:
+        async for event in orch.solve_problem_stream(query=query, request_id="test-rid"):
+            print(f"EVENT: {event}")
+    except Exception as e:
+        print(f"FAILED: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_stream())

verify_scraper.py

@@ -0,0 +1,33 @@
+import asyncio
+import logging
+from app.tools.web_scraper import run_playwright_sync
+
+logging.basicConfig(level=logging.INFO)
+
+def test_scraper():
+    print("Starting WebScraper Verification...")
+    
+    # Test query: something that definitely has tables
+    query = "gold rate in bangalore"
+    print(f"Query: {query}")
+    
+    result = run_playwright_sync(query, headless=True)
+    
+    if result.get("status") == "success":
+        print(f"Success! Targeted URL: {result.get('url')}")
+        content = result.get("content", "")
+        
+        # Check for Table Preservation
+        has_tables = "[TABLE START]" in content
+        print(f"Table Preservation: {'DETECTED' if has_tables else 'NOT FOUND'}")
+        
+        # Check for dynamic search (should not be DuckDuckGo URL if successful)
+        is_ddg = "duckduckgo" in result.get("url", "").lower()
+        print(f"Dynamic Search: {'WORKING' if not is_ddg else 'FALLBACK TO DDG'}")
+        
+        print(f"Content Preview (first 200 chars):\n{content[:200]}...")
+    else:
+        print(f"Error: {result.get('error')}")
+
+if __name__ == "__main__":
+    test_scraper()