update for the new web data source

backend/agents/critic.py

@@ -16,11 +16,12 @@ errors compared to self-evaluation by the same model.
 """
 from __future__ import annotations
 import json
+import re
 from datetime import datetime, timezone
 
-from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.messages import SystemMessage, HumanMessage
 
+from ..core.llm import get_llm
 from ..state.graph_state import (
     WorkflowState, TaskStatus, AgentRole, make_agent_event
 )
@@ -29,71 +30,16 @@ from ..core.logger import get_logger
 
 log = get_logger(__name__)
 
-CRITIC_SYSTEM = """You are a rigorous quality critic for AI task execution. Your job is to evaluate whether a task was completed correctly and completely.
-
-## Evaluation criteria
-1. **Completeness** (0–25): Did the agent address ALL aspects of the task?
-2. **Accuracy** (0–25): Are the facts/calculations correct? Are there hallucinations?
-3. **Usefulness** (0–25): Is the output actually helpful for the user's goal?
-4. **Quality** (0–25): Is the output well-structured, clear, and actionable?
-
-## Decision thresholds
-- Score ≥ 80: APPROVE — task well completed
-- Score 60–79: APPROVE with suggestions
-- Score < 60: REQUEST_REPLAN — major issues need fixing
-
-## Output format (JSON only)
-{
-  "thinking": "Your detailed evaluation reasoning",
-  "score": 0-100,
-  "decision": "approve" | "request_replan",
-  "critique": "Specific issues found (if any)",
-  "suggestions": ["suggestion 1", "suggestion 2"],
-  "completeness_score": 0-25,
-  "accuracy_score": 0-25,
-  "usefulness_score": 0-25,
-  "quality_score": 0-25
-}
-
-## Critical rules
-- Be HONEST and SPECIFIC — vague critiques don't help
-- If output is good, approve it — don't invent problems
-- Only request replan for REAL deficiencies
-- Point to SPECIFIC missing or incorrect elements"""
-
-
-CRITIC_TOOL = {
-    "type": "function",
-    "function": {
-        "name": "submit_critique",
-        "description": "Submit quality evaluation and decision",
-        "parameters": {
-            "type": "object",
-            "required": ["thinking", "score", "decision", "critique"],
-            "properties": {
-                "thinking": {"type": "string"},
-                "score": {"type": "integer", "minimum": 0, "maximum": 100},
-                "decision": {"type": "string", "enum": ["approve", "request_replan"]},
-                "critique": {"type": "string"},
-                "suggestions": {"type": "array", "items": {"type": "string"}},
-                "completeness_score": {"type": "integer", "minimum": 0, "maximum": 25},
-                "accuracy_score": {"type": "integer", "minimum": 0, "maximum": 25},
-                "usefulness_score": {"type": "integer", "minimum": 0, "maximum": 25},
-                "quality_score": {"type": "integer", "minimum": 0, "maximum": 25},
-            },
-        },
-    },
-}
+CRITIC_SYSTEM = """Evaluate task completion. Score 0-100. Approve if score>=60, else request_replan.
+
+You MUST respond with valid JSON only - no extra text, no markdown fences:
+{"thinking":"one line","score":75,"decision":"approve","critique":"none","suggestions":[]}"""
 
 
 def critic_node(state: WorkflowState) -> WorkflowState:
-    """LangGraph node — runs the Critic agent for reflection."""
+    """LangGraph node - runs the Critic agent for reflection."""
     settings = get_settings()
-    llm = ChatGoogleGenerativeAI(
-        model=settings.critic_model,
-        temperature=0.1,
-        google_api_key=settings.google_api_key,
-    )
+    llm = get_llm("critic", temperature=0.1)
 
     log.info("Critic running", task_id=state["task_id"])
 
@@ -121,45 +67,38 @@ def critic_node(state: WorkflowState) -> WorkflowState:
         result_str = json.dumps(result, default=str)
         results_summary[step_id] = result_str[:400]
 
-    eval_context = f"""
-ORIGINAL TASK:
-{state["task"]}
-
-EXECUTION PLAN ({len(completed_steps)}/{len(state["plan"])} steps completed):
-{chr(10).join(f"  [{s['status']}] {s['title']}: {s['description'][:100]}" for s in state["plan"])}
-
-FAILED STEPS: {len(failed_steps)}
-{chr(10).join(f"  - {s['title']}: {s.get('error', '')}" for s in failed_steps) if failed_steps else "  None"}
-
-STEP RESULTS:
-{json.dumps(results_summary, indent=2)[:2000]}
-
-FINAL OUTPUT:
-{state.get("final_output", "NOT YET GENERATED")[:1500]}
-"""
+    steps_summary = ", ".join(f"[{s['status']}]{s['title']}" for s in state["plan"])
+    eval_context = (
+        f"TASK: {state['task']}\n"
+        f"STEPS: {steps_summary}\n"
+        f"FAILED: {len(failed_steps)}\n"
+        f"OUTPUT: {str(state.get('final_output', 'none'))[:600]}"
+    )
 
     try:
+        # No tool calling — plain JSON text is more reliable across providers
         response = llm.invoke(
             [SystemMessage(content=CRITIC_SYSTEM), HumanMessage(content=eval_context)],
-            tools=[CRITIC_TOOL],
         )
 
         tokens = response.usage_metadata.get("total_tokens", 0) if response.usage_metadata else 0
-        tool_call = response.tool_calls[0] if response.tool_calls else None
-
-        # Gemini Flash Lite sometimes returns JSON text instead of a tool call — parse it as fallback
-        if not tool_call:
-            text = response.content or ""
-            # Strip markdown code fences if present
-            stripped = text.strip().removeprefix("```json").removeprefix("```").removesuffix("```").strip()
-            try:
-                parsed = json.loads(stripped)
-                tool_call = {"args": parsed}
-                log.info("Critic: parsed JSON text fallback")
-            except Exception:
-                raise ValueError(f"No critique tool call and JSON parse failed. Response: {text[:200]}")
-
-        c = tool_call["args"]
+        text = response.content or ""
+
+        # Strip markdown fences and extract JSON
+        stripped = text.strip()
+        for fence in ("```json", "```"):
+            stripped = stripped.removeprefix(fence)
+        stripped = stripped.removesuffix("```").strip()
+
+        # Find first {...} block in case model adds prose
+        match = re.search(r'\{.*\}', stripped, re.DOTALL)
+        if match:
+            stripped = match.group(0)
+
+        try:
+            c = json.loads(stripped)
+        except Exception:
+            raise ValueError(f"Critic JSON parse failed. Response: {text[:200]}")
         score = int(c.get("score", 70))
         decision = c.get("decision", "approve")
         critique = c.get("critique", "")

backend/agents/executor.py

@@ -17,9 +17,9 @@ import json
 import time
 from datetime import datetime, timezone
 
-from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.messages import SystemMessage, HumanMessage
 
+from ..core.llm import get_llm
 from ..state.graph_state import (
     WorkflowState, TaskStatus, StepStatus, AgentRole, make_agent_event
 )
@@ -29,30 +29,10 @@ from ..core.logger import get_logger
 
 log = get_logger(__name__)
 
-EXECUTOR_SYSTEM = """You are a precise task executor. You execute ONE step at a time using the available tools.
+EXECUTOR_SYSTEM = """Execute ONE step using the available tools. Choose the right tool and args. Always call a tool."""
 
-## Your job
-1. Understand exactly what the current step requires
-2. Choose the RIGHT tool and RIGHT arguments
-3. If tool results are insufficient, try a different approach
-4. Be specific — vague tool inputs produce vague results
-
-## Key rules
-- Read the step description CAREFULLY
-- Use context from previous step results when relevant
-- For "synthesize" steps: write_file first, then provide the complete answer
-- If a tool returns an error, try a different approach
-- Output only what is needed — do not hallucinate results
-
-## Response format
-Always call a tool. Do not respond without calling a tool."""
-
-SYNTHESIZE_SYSTEM = """You are a synthesis agent. Your job is to produce the FINAL comprehensive answer.
-
-Using all the results collected during task execution, write a complete, well-structured response to the original task.
-
-Format your response clearly. Use headers, bullet points, or numbered lists where appropriate.
-Be thorough but concise. Cite specific findings where relevant."""
+SYNTHESIZE_SYSTEM = """Write the final answer to the task using the collected results. Be concise and clear.
+Use plain text only - no LaTeX, no $\\boxed{}, no math notation. Write numbers as regular text (e.g. "1040" not "$\\boxed{1040}$")."""
 
 
 def _build_context(state: WorkflowState) -> str:
@@ -105,11 +85,7 @@ def executor_node(state: WorkflowState) -> WorkflowState:
         else:
             updated_plan.append(s)
 
-    llm = ChatGoogleGenerativeAI(
-        model=settings.executor_model,
-        temperature=0.1,
-        google_api_key=settings.google_api_key,
-    )
+    llm = get_llm("executor", temperature=0.1)
 
     context = _build_context(state)
     user_msg = (
@@ -187,11 +163,7 @@ async def _safe_tool_call(name: str, args: dict) -> dict:
 
 def _handle_synthesize(state: WorkflowState, step: dict, settings) -> WorkflowState:
     """Handle the special synthesize step — produces final answer."""
-    llm = ChatGoogleGenerativeAI(
-        model=settings.executor_model,
-        temperature=0.3,
-        google_api_key=settings.google_api_key,
-    )
+    llm = get_llm("executor", temperature=0.3)
 
     context = _build_context(state)
     response = llm.invoke([

backend/agents/memory_agent.py

@@ -14,12 +14,8 @@ Memory types:
 """
 from __future__ import annotations
 import asyncio
-import json
 from datetime import datetime, timezone
 
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_core.messages import SystemMessage, HumanMessage
-
 from ..state.graph_state import WorkflowState, AgentRole, make_agent_event, make_memory_entry
 from ..memory.memory_store import long_term, short_term
 from ..core.config import get_settings
@@ -27,31 +23,6 @@ from ..core.logger import get_logger
 
 log = get_logger(__name__)
 
-MEMORY_RETRIEVE_SYSTEM = """You are a memory retrieval assistant. Given a task, identify what past knowledge would be most relevant.
-
-Output a JSON list of search queries to retrieve relevant memories:
-{
-  "queries": ["query 1", "query 2", "query 3"]
-}
-
-Focus on: similar past tasks, relevant domain knowledge, successful strategies."""
-
-MEMORY_STORE_SYSTEM = """You are a memory extraction assistant. Given a completed task execution, extract valuable learnings to remember for the future.
-
-Output a JSON list of memories to store:
-{
-  "memories": [
-    {
-      "content": "The memory content — be specific and actionable",
-      "memory_type": "episodic|semantic|procedural",
-      "importance": 0.0-1.0,
-      "tags": ["tag1", "tag2"]
-    }
-  ]
-}
-
-Extract: key findings, successful approaches, useful facts, things to avoid."""
-
 
 def memory_retrieve_node(state: WorkflowState) -> WorkflowState:
     """Run at start of workflow — retrieve relevant memories."""
@@ -67,19 +38,8 @@ def memory_retrieve_node(state: WorkflowState) -> WorkflowState:
         log.info("Restored from short-term cache")
         return {**state, **cached_state, "task_id": state["task_id"]}
 
-    try:
-        llm = ChatGoogleGenerativeAI(
-            model=settings.memory_model, temperature=0,
-            google_api_key=settings.google_api_key,
-        )
-        response = llm.invoke([
-            SystemMessage(content=MEMORY_RETRIEVE_SYSTEM),
-            HumanMessage(content=f"Task: {state['task']}"),
-        ])
-        parsed = json.loads(response.content)
-        queries = parsed.get("queries", [state["task"][:50]])
-    except Exception:
-        queries = [state["task"][:50]]
+    # Use task text directly — no LLM call needed to generate queries
+    queries = [state["task"][:80]]
 
     # Retrieve from long-term memory
     all_memories = []
@@ -133,30 +93,7 @@ def memory_store_node(state: WorkflowState) -> WorkflowState:
         except Exception as e:
             log.warning("Memory store failed", error=str(e))
 
-    # Also extract memories from execution via LLM (if task completed well)
-    if (state.get("quality_score", 0) or 0) >= 70 and state.get("final_output"):
-        try:
-            llm = ChatGoogleGenerativeAI(
-                model=settings.memory_model, temperature=0,
-                google_api_key=settings.google_api_key,
-            )
-            context = f"""Task: {state['task']}
-Final output (first 800 chars): {str(state.get('final_output', ''))[:800]}
-Quality score: {state.get('quality_score', 0)}
-Steps taken: {', '.join(s['title'] for s in state['plan'] if s['status']=='done')}"""
-
-            response = llm.invoke([
-                SystemMessage(content=MEMORY_STORE_SYSTEM),
-                HumanMessage(content=context),
-            ])
-
-            parsed = json.loads(response.content)
-            for mem in parsed.get("memories", [])[:4]:
-                asyncio.run(long_term.store(mem, task_id=state["task_id"]))
-                memories_stored += 1
-
-        except Exception as e:
-            log.warning("Auto-memory extraction failed", error=str(e))
+    # No extra LLM call — critic already added memory entries to new_memories
 
     log.info("Memories stored", count=memories_stored)
 

backend/agents/planner.py

@@ -17,70 +17,32 @@ import json
 import uuid
 from datetime import datetime, timezone
 
-from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.messages import SystemMessage, HumanMessage
 
+from ..core.llm import get_llm
 from ..state.graph_state import (
     WorkflowState, TaskStatus, AgentRole,
     make_plan_step, make_agent_event,
 )
-from ..core.config import get_settings
 from ..core.logger import get_logger
 
 log = get_logger(__name__)
 
-PLANNER_SYSTEM = """You are a strategic task planner AI. Your job is to decompose complex tasks into clear, executable steps.
-
-## Your responsibilities
-1. Analyze the task and identify sub-goals
-2. Create a MINIMAL but COMPLETE plan (3–8 steps max)
-3. Assign the right tool to each step
-4. Specify dependencies between steps
-5. Be concrete — vague steps fail
-
-## Available tools for steps
-- web_search: Search for information online
-- fetch_url: Read content from a specific URL
-- calculate: Perform mathematical calculations
-- run_python: Execute Python code for data processing
-- write_file: Save results or drafts to files
-- read_file: Read previously saved content
-- get_datetime: Get current date/time
-- synthesize: Combine all results into final answer (ALWAYS last step)
-
-## Output format (JSON)
-Return ONLY a JSON object:
-{
-  "thinking": "Brief analysis of the task",
-  "plan": [
-    {
-      "step_id": "step_1",
-      "title": "Short title",
-      "description": "What to do and why",
-      "tool": "tool_name",
-      "depends_on": []
-    }
-  ],
-  "estimated_complexity": "low|medium|high"
-}
+PLANNER_SYSTEM = """You are a task planner. Decompose the task into 2-4 steps MAX.
 
-## Rules
-- First step depends_on: []
-- Later steps list their prerequisites in depends_on
-- Always end with a "synthesize" step that depends on all prior steps
-- If replanning after critique, address the specific issues raised
-- NEVER include steps for things already completed"""
+Tools: web_search, fetch_url, calculate, run_python, write_file, read_file, get_datetime, synthesize
+Always end with a synthesize step.
 
+Return ONLY JSON:
+{"thinking":"one line","plan":[{"step_id":"step_1","title":"short","description":"what to do","tool":"tool_name","depends_on":[]}],"estimated_complexity":"low|medium|high"}
 
-REPLAN_ADDITION = """
-## Replanning context
-Previous plan failed or received critique. Address these issues:
-{critique}
+Rules: minimal steps, no redundancy, synthesize last, depends_on lists prerequisite step_ids."""
 
-Completed steps so far:
-{completed_steps}
 
-Do NOT repeat completed steps. Only plan remaining/corrective actions."""
+REPLAN_ADDITION = """
+Replanning — fix these issues: {critique}
+Already done: {completed_steps}
+Only plan remaining steps."""
 
 
 PLANNING_TOOL = {
@@ -119,12 +81,9 @@ def planner_node(state: WorkflowState) -> WorkflowState:
     LangGraph node — runs the Planner agent.
     Called at start and whenever Critic requests replanning.
     """
+    from ..core.config import get_settings
     settings = get_settings()
-    llm = ChatGoogleGenerativeAI(
-        model=settings.planner_model,
-        temperature=0.2,
-        google_api_key=settings.google_api_key,
-    )
+    llm = get_llm("planner", temperature=0.2)
 
     log.info("Planner running", task_id=state["task_id"], iteration=state["iteration"])
 
@@ -158,7 +117,7 @@ def planner_node(state: WorkflowState) -> WorkflowState:
         response = llm.invoke(
             [SystemMessage(content=system_content), HumanMessage(content=user_msg)],
             tools=[PLANNING_TOOL],
-            tool_choice="submit_plan",
+            tool_choice={"type": "function", "function": {"name": "submit_plan"}},
         )
 
         tool_call = response.tool_calls[0] if response.tool_calls else None
@@ -168,9 +127,10 @@ def planner_node(state: WorkflowState) -> WorkflowState:
         plan_data = tool_call["args"]
         thinking = plan_data.get("thinking", "")
 
-        # Convert to plan steps
+        # Convert to plan steps (hard cap)
         new_plan = []
-        for step in plan_data.get("plan", []):
+        raw_steps = plan_data.get("plan", [])[:settings.max_plan_steps]
+        for step in raw_steps:
             new_plan.append(make_plan_step(
                 step_id=step.get("step_id", f"step_{len(new_plan)+1}"),
                 title=step.get("title", ""),

backend/core/config.py

@@ -1,38 +1,56 @@
-"""backend/core/config.py"""
+"""backend/core/config.py — All non-secret config lives here. Secrets come from .env."""
 from functools import lru_cache
-from typing import Literal
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(env_file=".env", extra="ignore", case_sensitive=False)
 
-    # LLM
+    # ── Secrets (from .env) ───────────────────────────────────────────────────
     google_api_key: str = ""
-    planner_model: str = "gemini-2.5-flash"
-    executor_model: str = "gemini-2.5-flash"
-    critic_model: str = "gemini-2.5-flash"
-    memory_model: str = "gemini-2.5-flash"
+    groq_api_key: str = ""
+    serper_api_key: str = ""
 
-    # Redis
-    redis_url: str = "redis://localhost:6379"
-    redis_ttl: int = 86400          # 24h default
-
-    # DB
-    database_url: str = "sqlite+aiosqlite:///./agent_system.db"
-
-    # App
+    # ── App ───────────────────────────────────────────────────────────────────
     app_env: str = "development"
     app_host: str = "0.0.0.0"
     app_port: int = 8000
     log_level: str = "INFO"
+    frontend_url: str = "http://localhost:5500"
+
+    # ── Database ──────────────────────────────────────────────────────────────
+    database_url: str = "sqlite+aiosqlite:///./agent_system.db"
+
+    # ── Redis ─────────────────────────────────────────────────────────────────
+    redis_host: str = "localhost"
+    redis_port: int = 6379
+    redis_db: int = 0
+    redis_url: str = "redis://localhost:6379"
+    redis_ttl: int = 86400
+
+    # ── LLM provider: "gemini" or "groq" ─────────────────────────────────────
+    llm_provider: str = "groq"
+
+    # Gemini models
+    planner_model: str = "gemini-2.5-flash"
+    executor_model: str = "gemini-2.5-flash"
+    critic_model: str = "gemini-2.5-flash"
+    memory_model: str = "gemini-2.5-flash"
 
-    # Agent config
-    max_iterations: int = 10        # Max planner loops
-    max_retries: int = 3            # Per-step retry limit
-    step_timeout: int = 120         # Seconds per step
-    enable_reflection: bool = True  # Critic reflection pass
-    enable_memory: bool = True      # Memory persistence
+    # Groq models
+    groq_planner_model: str = "llama-3.3-70b-versatile"
+    groq_executor_model: str = "llama-3.3-70b-versatile"
+    groq_critic_model: str = "llama-3.1-8b-instant"
+    groq_memory_model: str = "llama-3.1-8b-instant"
+
+    # ── Agent behaviour ───────────────────────────────────────────────────────
+    max_iterations: int = 3
+    max_retries: int = 1
+    step_timeout: int = 60
+    enable_reflection: bool = True
+    enable_memory: bool = True
+    max_plan_steps: int = 4
+    max_output_tokens: int = 512
 
     @property
     def is_dev(self) -> bool:

backend/core/llm.py

@@ -0,0 +1,45 @@
+"""backend/core/llm.py — LLM factory supporting Gemini and Grok."""
+from __future__ import annotations
+
+
+def get_llm(role: str, temperature: float = 0.1):
+    """
+    Return the right LLM based on LLM_PROVIDER in .env.
+    role: "planner" | "executor" | "critic" | "memory"
+    """
+    from .config import get_settings
+    settings = get_settings()
+
+    max_tokens = settings.max_output_tokens
+
+    if settings.llm_provider == "groq":
+        from langchain_groq import ChatGroq
+
+        model_map = {
+            "planner": settings.groq_planner_model,
+            "executor": settings.groq_executor_model,
+            "critic": settings.groq_critic_model,
+            "memory": settings.groq_memory_model,
+        }
+        return ChatGroq(
+            model=model_map.get(role, "llama-3.3-70b-versatile"),
+            temperature=temperature,
+            api_key=settings.groq_api_key,
+            max_tokens=max_tokens,
+        )
+
+    else:  # gemini (default)
+        from langchain_google_genai import ChatGoogleGenerativeAI
+
+        model_map = {
+            "planner": settings.planner_model,
+            "executor": settings.executor_model,
+            "critic": settings.critic_model,
+            "memory": settings.memory_model,
+        }
+        return ChatGoogleGenerativeAI(
+            model=model_map.get(role, settings.planner_model),
+            temperature=temperature,
+            google_api_key=settings.google_api_key,
+            max_output_tokens=max_tokens,
+        )

backend/tools/registry.py

@@ -33,22 +33,45 @@ def err(message: str, details: str = "") -> dict:
 # ── Web search ────────────────────────────────────────────────────────────────
 
 async def web_search(query: str, max_results: int = 5) -> dict:
-    """Search the web using DuckDuckGo DDGS (avoids rate-limit issues of DuckDuckGoSearchRun)."""
+    """Search via Serper (Google), falling back to DuckDuckGo if unavailable."""
+    from ..core.config import get_settings
+    settings = get_settings()
+
+    # ── Primary: Serper (Google Search API) ──────────────────────────────────
+    if settings.serper_api_key:
+        try:
+            async with httpx.AsyncClient(timeout=10) as c:
+                r = await c.post(
+                    "https://google.serper.dev/search",
+                    headers={"X-API-KEY": settings.serper_api_key, "Content-Type": "application/json"},
+                    json={"q": query, "num": int(max_results)},
+                )
+            if r.status_code == 200:
+                data = r.json()
+                items = data.get("organic", [])
+                formatted = "\n\n".join(
+                    f"**{item.get('title', '')}**\n{item.get('link', '')}\n{item.get('snippet', '')}"
+                    for item in items
+                )
+                return ok({"query": query, "results": formatted[:3000], "count": len(items), "source": "serper"})
+        except Exception:
+            pass  # fall through to DuckDuckGo
+
+    # ── Fallback: DuckDuckGo ──────────────────────────────────────────────────
     try:
         from duckduckgo_search import DDGS
         loop = asyncio.get_event_loop()
 
         def _search():
             with DDGS() as ddgs:
-                results = list(ddgs.text(query, max_results=int(max_results)))
-            return results
+                return list(ddgs.text(query, max_results=int(max_results)))
 
         results = await loop.run_in_executor(None, _search)
         formatted = "\n\n".join(
             f"**{r.get('title', '')}**\n{r.get('href', '')}\n{r.get('body', '')}"
             for r in results
         )
-        return ok({"query": query, "results": formatted[:3000], "count": len(results)})
+        return ok({"query": query, "results": formatted[:3000], "count": len(results), "source": "duckduckgo"})
     except Exception as e:
         return err(f"Search failed: {e}", str(e))
 
@@ -124,28 +147,41 @@ def list_files() -> dict:
 
 def run_python(code: str) -> dict:
     """
-    Execute Python code in a restricted sandbox.
-    Returns stdout output (captured) or error.
-    PRODUCTION NOTE: Use Docker sandbox / e2b in real deployment.
+    Execute Python code in a sandbox with common data-science libs available.
+    Blocks truly dangerous ops (os, subprocess, socket, open).
     """
-    import io, sys, contextlib
-    # Block dangerous imports
-    blocked = ["os", "sys", "subprocess", "socket", "requests", "open", "__import__"]
+    import io, contextlib, builtins
+    # Block dangerous modules only
+    blocked = ["subprocess", "socket", "requests"]
     for b in blocked:
-        if f"import {b}" in code or f"({b}" in code:
+        if f"import {b}" in code:
             return err(f"Blocked: '{b}' not allowed in sandbox")
+    if "open(" in code:
+        return err("Blocked: file 'open()' not allowed in sandbox")
+
+    # Allow standard builtins + safe data libs
+    import math, json
+    from datetime import datetime as _dt
+    safe_globals = {
+        "__builtins__": builtins,   # full builtins so import works
+        "math": math,
+        "json": json,
+        "datetime": _dt,
+    }
+    # Try to inject optional libs if installed
+    for lib in ["pandas", "numpy", "matplotlib"]:
+        try:
+            import importlib
+            safe_globals[lib.split(".")[0]] = importlib.import_module(lib)
+        except ImportError:
+            pass
 
     stdout_capture = io.StringIO()
     try:
         with contextlib.redirect_stdout(stdout_capture):
-            exec(code, {"__builtins__": {"print": print, "range": range,
-                                          "len": len, "str": str, "int": int,
-                                          "float": float, "list": list, "dict": dict,
-                                          "enumerate": enumerate, "zip": zip,
-                                          "sorted": sorted, "sum": sum, "min": min,
-                                          "max": max, "abs": abs, "round": round}})
+            exec(code, safe_globals)
         output = stdout_capture.getvalue()
-        return ok({"output": output[:2000], "code": code[:500]})
+        return ok({"output": output[:2000] or "(no output)", "code": code[:500]})
     except Exception as e:
         return err(f"Execution error: {type(e).__name__}: {e}", code[:200])
 

check_api.py

@@ -0,0 +1,79 @@
+"""Check Gemini API key, available models, and rate limits."""
+import asyncio, os, sys
+from dotenv import load_dotenv
+import httpx
+
+load_dotenv()
+KEY = os.getenv("GOOGLE_API_KEY", "")
+
+BASE = "https://generativelanguage.googleapis.com/v1beta"
+MODELS_TO_TEST = [
+    "gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "gemini-2.0-flash",
+    "gemini-1.5-flash",
+    "gemini-1.5-pro",
+]
+
+
+async def main():
+    if not KEY:
+        print("[X] GOOGLE_API_KEY not set in .env")
+        sys.exit(1)
+    print(f"Key: ...{KEY[-6:]}\n")
+
+    async with httpx.AsyncClient(timeout=20) as c:
+
+        # 1) List all available models
+        print("=" * 55)
+        print("AVAILABLE MODELS")
+        print("=" * 55)
+        r = await c.get(f"{BASE}/models?key={KEY}")
+        if r.status_code != 200:
+            print(f"[X] Could not list models: {r.status_code} {r.text[:200]}")
+        else:
+            models = r.json().get("models", [])
+            gen_models = [m for m in models if "generateContent" in m.get("supportedGenerationMethods", [])]
+            for m in gen_models:
+                name = m["name"].replace("models/", "")
+                limit = m.get("description", "")[:60]
+                print(f"  {name:<35} rpm={m.get('rpmLimit','?'):>6}  tpm={m.get('tpmLimit','?'):>10}")
+
+        # 2) Test each target model with a tiny call
+        print("\n" + "=" * 55)
+        print("MODEL PING TEST")
+        print("=" * 55)
+        body = {"contents": [{"parts": [{"text": "Say OK"}]}],
+                "generationConfig": {"maxOutputTokens": 5}}
+        for model in MODELS_TO_TEST:
+            url = f"{BASE}/models/{model}:generateContent?key={KEY}"
+            r = await c.post(url, json=body)
+            if r.status_code == 200:
+                status = "[OK]"
+            elif r.status_code == 429:
+                status = "[429 rate limit]"
+            elif r.status_code == 404:
+                status = "[404 not found]"
+            elif r.status_code == 403:
+                status = "[403 denied]"
+            else:
+                status = f"[{r.status_code}]"
+            print(f"  {model:<30} {status}")
+
+        # 3) Quota info from a real call on the working model
+        print("\n" + "=" * 55)
+        print("RATE LIMITS (from API metadata)")
+        print("=" * 55)
+        r = await c.get(f"{BASE}/models/gemini-2.5-flash?key={KEY}")
+        if r.status_code == 200:
+            m = r.json()
+            print(f"  Model        : {m.get('displayName','')}")
+            print(f"  Input limit  : {m.get('inputTokenLimit','?'):,} tokens")
+            print(f"  Output limit : {m.get('outputTokenLimit','?'):,} tokens")
+            print(f"  RPM limit    : {m.get('rpmLimit', 'see https://ai.dev/rate-limit')}")
+            print(f"  TPM limit    : {m.get('tpmLimit', 'see https://ai.dev/rate-limit')}")
+            print(f"\n  Free tier caps: 15 RPM / 1,000,000 TPM / 1,500 RPD")
+            print(f"  Full limits  : https://ai.google.dev/gemini-api/docs/rate-limits")
+
+
+asyncio.run(main())

frontend/app.js

@@ -1,5 +1,7 @@
 /* ─── Config ──────────────────────────────────────────────────────────────── */
-const API_BASE = 'http://localhost:8000';
+// Empty string = same origin (works on HF Spaces and any deployment).
+// Falls back to localhost only when running locally on a different port.
+const API_BASE = window.location.hostname === 'localhost' ? 'http://localhost:8000' : '';
 
 /* ─── State ───────────────────────────────────────────────────────────────── */
 const state = {
@@ -397,9 +399,14 @@ async function runBatch(task) {
 }
 
 /* ─── Show output ────────────────────────────────────────────────────────── */
+function cleanOutput(text) {
+  // Strip LaTeX boxing that Llama sometimes outputs
+  return (text || '').replace(/\$\\boxed\{([^}]+)\}\$/g, '$1').replace(/\\boxed\{([^}]+)\}/g, '$1');
+}
+
 function showOutput(text, score) {
   outputCard.style.display = '';
-  outputContent.textContent = text;
+  outputContent.textContent = cleanOutput(text);
   if (score != null) {
     const s = Math.round(score);
     qualityBadge.textContent = `${s}/100`;

frontend/index.html

@@ -22,7 +22,7 @@
         </svg>
         <span class="logo-text">Multi-Agent System</span>
       </div>
-      <span class="powered-by">Powered by <span class="gemini-badge">Gemini 2.5 Flash Lite</span></span>
+      <span class="powered-by">Powered by <span class="gemini-badge">Groq · Llama 3.3 70B</span></span>
     </div>
     <div class="header-right">
       <div class="health-indicator" id="healthDot" title="Backend status"></div>

frontend/style.css

@@ -139,15 +139,20 @@ body {
 /* ─── Main Layout ─────────────────────────────────────────────────────────── */
 .layout {
   display: grid;
-  grid-template-columns: 300px 1fr 270px;
+  grid-template-columns: 280px 1fr 260px;
+  grid-template-rows: 1fr;
   gap: 0;
   flex: 1;
+  min-height: 0;
+  height: 0;        /* forces grid rows to respect flex parent height */
   overflow: hidden;
 }
 
 .panel {
   display: flex;
   flex-direction: column;
+  min-height: 0;
+  height: 100%;
   overflow: hidden;
   background: var(--bg-panel);
 }
@@ -168,6 +173,9 @@ body {
 
 .panel-right {
   border-left: 1px solid var(--border);
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
   overflow-y: auto;
 }
 
@@ -327,7 +335,7 @@ textarea::placeholder { color: var(--text-dim); }
 .btn-icon-arrow { flex-shrink: 0; }
 
 /* ─── Left Panel: History ─────────────────────────────────────────────────── */
-.history-section { padding: 16px; flex: 1; }
+.history-section { padding: 16px; flex: 1; overflow-y: auto; min-height: 0; }
 
 .task-history { display: flex; flex-direction: column; gap: 6px; }
 
@@ -415,13 +423,13 @@ textarea::placeholder { color: var(--text-dim); }
 .status-badge.failed { background: rgba(239,68,68,0.15); color: var(--red); border-color: rgba(239,68,68,0.3); }
 
 /* ─── Agent Graph ─────────────────────────────────────────────────────────── */
-.agent-graph { padding: 20px 16px; overflow-x: auto; }
+.agent-graph { padding: 16px; overflow-x: auto; }
 
 .graph-track {
   display: flex;
   align-items: center;
   gap: 0;
-  min-width: fit-content;
+  min-width: max-content;
   margin: 0 auto;
 }
 
@@ -430,11 +438,12 @@ textarea::placeholder { color: var(--text-dim); }
   flex-direction: column;
   align-items: center;
   gap: 4px;
-  padding: 12px 14px;
+  padding: 10px 12px;
   background: var(--bg-input);
   border: 1.5px solid var(--border);
   border-radius: var(--radius);
-  min-width: 80px;
+  min-width: 88px;
+  width: 88px;
   transition: all var(--transition);
   cursor: default;
 }
@@ -464,9 +473,13 @@ textarea::placeholder { color: var(--text-dim); }
   font-size: 9px;
   font-weight: 600;
   text-transform: uppercase;
-  letter-spacing: 0.05em;
-  padding: 1px 6px;
+  letter-spacing: 0.04em;
+  padding: 2px 6px;
   border-radius: 99px;
+  white-space: nowrap;
+  max-width: 100%;
+  overflow: hidden;
+  text-overflow: ellipsis;
 }
 .node-state.idle { background: var(--bg-card); color: var(--text-dim); }
 .node-state.running { background: rgba(124,58,237,0.2); color: var(--purple-light); animation: blink 1s step-start infinite; }
@@ -571,7 +584,8 @@ textarea::placeholder { color: var(--text-dim); }
   color: var(--text);
   white-space: pre-wrap;
   word-break: break-word;
-  max-height: 400px;
+  min-height: 80px;
+  max-height: 600px;
   overflow-y: auto;
 }
 
@@ -579,10 +593,10 @@ textarea::placeholder { color: var(--text-dim); }
 .events-section {
   padding: 14px;
   border-bottom: 1px solid var(--border);
-  flex: 1;
   display: flex;
   flex-direction: column;
-  min-height: 0;
+  min-height: 200px;
+  max-height: 45vh;
 }
 
 .btn-ghost-sm {
@@ -605,7 +619,6 @@ textarea::placeholder { color: var(--text-dim); }
   flex-direction: column;
   gap: 4px;
   min-height: 0;
-  max-height: 300px;
 }
 
 .event-item {
@@ -638,7 +651,7 @@ textarea::placeholder { color: var(--text-dim); }
 .event-msg { font-size: 11px; color: var(--text-muted); line-height: 1.4; }
 
 /* ─── Right Panel: Metrics ────────────────────────────────────────────────── */
-.metrics-section { padding: 14px; border-bottom: 1px solid var(--border); }
+.metrics-section { padding: 14px; border-bottom: 1px solid var(--border); flex-shrink: 0; }
 
 .metrics-grid {
   display: grid;
@@ -668,7 +681,7 @@ textarea::placeholder { color: var(--text-dim); }
 .metric-label { font-size: 9px; color: var(--text-dim); text-transform: uppercase; letter-spacing: 0.06em; }
 
 /* ─── Right Panel: Tools ──────────────────────────────────────────────────── */
-.tools-section { padding: 14px; }
+.tools-section { padding: 14px; flex-shrink: 0; }
 
 .tool-list { display: flex; flex-direction: column; gap: 3px; }
 .tool-item {
@@ -718,12 +731,17 @@ textarea::placeholder { color: var(--text-dim); }
 }
 
 /* ─── Responsive ──────────────────────────────────────────────────────────── */
-@media (max-width: 1100px) {
-  .layout { grid-template-columns: 260px 1fr 240px; }
+@media (max-width: 1200px) {
+  .layout { grid-template-columns: 240px 1fr 220px; }
+  .agent-node { min-width: 78px; width: 78px; }
+}
+@media (max-width: 960px) {
+  .layout { grid-template-columns: 220px 1fr; }
+  .panel-right { display: none; }
 }
-@media (max-width: 860px) {
+@media (max-width: 680px) {
   .layout { grid-template-columns: 1fr; }
-  .panel-left, .panel-right { display: none; }
+  .panel-left { display: none; }
   body { overflow: auto; }
   .panel-center { min-height: 100vh; }
 }

test.py

@@ -0,0 +1,201 @@
+"""Quick smoke test for the multi-agent system.
+
+Checks:
+  1. GOOGLE_API_KEY is set and reachable
+  2. Core imports work (state, tools, orchestrator)
+  3. WorkflowState initialisation is correct
+  4. Routing logic behaves as expected
+
+Run:
+    .venv/Scripts/python test.py
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+
+try:
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+except Exception:
+    pass
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+SEP = "=" * 60
+
+
+def check_env() -> bool:
+    key = os.getenv("GOOGLE_API_KEY", "")
+    print(SEP)
+    print("GOOGLE_API_KEY set :", bool(key), f"(...{key[-4:]})" if key else "")
+    print("PLANNER_MODEL      :", os.getenv("PLANNER_MODEL", "gemini-2.5-flash"))
+    print("DATABASE_URL       :", os.getenv("DATABASE_URL", "(not set)"))
+    print("REDIS_URL          :", os.getenv("REDIS_URL", "(not set)"))
+    print(SEP)
+    if not key:
+        print("[X] No GOOGLE_API_KEY found — set it in .env")
+        return False
+    return True
+
+
+async def check_gemini(key: str) -> bool:
+    import httpx
+
+    model = os.getenv("PLANNER_MODEL", "gemini-2.5-flash")
+    url = (
+        f"https://generativelanguage.googleapis.com/v1beta/models/"
+        f"{model}:generateContent?key={key}"
+    )
+    body = {"contents": [{"parts": [{"text": "Reply with exactly: API key works"}]}]}
+    async with httpx.AsyncClient(timeout=15) as c:
+        r = await c.post(url, json=body)
+
+    print(f"\n[1] Gemini live call -> HTTP {r.status_code}")
+    if r.status_code >= 300:
+        print("    error:", r.text[:400])
+        print("\n[X] Common causes:")
+        print("    400 API_KEY_INVALID        -> wrong/expired key")
+        print("    403 PERMISSION_DENIED      -> 'Generative Language API' not enabled,")
+        print("                                  OR Google project access denied —")
+        print("                                  create a new key at https://aistudio.google.com/apikey")
+        print("    404 model not found        -> check PLANNER_MODEL in .env")
+        print("    429                        -> rate/quota limit, try again shortly")
+        return False
+
+    try:
+        reply = r.json()["candidates"][0]["content"]["parts"][0]["text"].strip()
+    except Exception:
+        reply = r.text[:200]
+    print("    model reply:", reply)
+    print("[OK] Gemini API key is working.\n")
+    return True
+
+
+def check_imports() -> bool:
+    print("[2] Checking imports ...")
+    try:
+        from backend.state.graph_state import (  # noqa: F401
+            WorkflowState, TaskStatus, StepStatus, AgentRole,
+            create_initial_state, make_plan_step, make_agent_event,
+        )
+        from backend.agents.orchestrator import (  # noqa: F401
+            build_workflow, route_after_executor,
+            route_after_critic, route_after_planner,
+        )
+        print("    backend.state        OK")
+        print("    backend.orchestrator OK")
+    except ImportError as e:
+        print(f"    [X] Import failed: {e}")
+        return False
+
+    try:
+        from backend.tools.registry import execute_tool, calculate  # noqa: F401
+        print("    backend.tools        OK")
+    except ImportError as e:
+        print(f"    [X] tools import failed: {e}")
+        return False
+
+    print("[OK] All imports succeeded.\n")
+    return True
+
+
+def check_state() -> bool:
+    print("[3] WorkflowState smoke test ...")
+    from backend.state.graph_state import (
+        create_initial_state, TaskStatus, make_plan_step, StepStatus,
+    )
+
+    state = create_initial_state("Write a hello-world script")
+    assert state["task"] == "Write a hello-world script"
+    assert state["status"] == TaskStatus.PENDING
+    assert state["plan"] == []
+    assert state["iteration"] == 0
+    assert state["total_tokens"] == 0
+    assert len(state["events"]) == 1
+
+    step = make_plan_step("s1", "Write code", "Create hello.py", tool="run_python")
+    assert step["status"] == StepStatus.PENDING
+    assert step["attempts"] == 0
+
+    print("    initial state    OK")
+    print("    make_plan_step   OK")
+    print("[OK] State checks passed.\n")
+    return True
+
+
+def check_routing() -> bool:
+    print("[4] Routing logic smoke test ...")
+    from backend.state.graph_state import create_initial_state, TaskStatus, StepStatus
+    from backend.agents.orchestrator import (
+        route_after_executor, route_after_critic, route_after_planner,
+    )
+
+    def _state(status, plan=None, needs_replanning=False):
+        s = create_initial_state("test")
+        s["status"] = status
+        s["plan"] = plan or []
+        s["needs_replanning"] = needs_replanning
+        return s
+
+    # executor → critic when REFLECTING
+    assert route_after_executor(_state(TaskStatus.REFLECTING)) == "critic"
+    # executor → self when steps pending
+    assert route_after_executor(
+        _state(TaskStatus.EXECUTING, [{"step_id": "s1", "status": StepStatus.PENDING}])
+    ) == "executor"
+    # executor → end on FAILED
+    assert route_after_executor(_state(TaskStatus.FAILED)) == "end"
+    # critic → planner on needs_replanning
+    assert route_after_critic(_state(TaskStatus.PLANNING, needs_replanning=True)) == "planner"
+    # critic → memory_store when approved
+    assert route_after_critic(_state(TaskStatus.COMPLETED)) == "memory_store"
+    # planner → end with empty plan
+    assert route_after_planner(_state(TaskStatus.EXECUTING, plan=[])) == "end"
+    # planner → executor with valid plan
+    assert route_after_planner(
+        _state(TaskStatus.EXECUTING, [{"step_id": "s1", "status": StepStatus.PENDING}])
+    ) == "executor"
+
+    print("    route_after_executor OK")
+    print("    route_after_critic   OK")
+    print("    route_after_planner  OK")
+    print("[OK] Routing checks passed.\n")
+    return True
+
+
+async def main() -> None:
+    ok = check_env()
+    if not ok:
+        sys.exit(1)
+
+    key = os.getenv("GOOGLE_API_KEY", "")
+    gemini_ok = await check_gemini(key)
+
+    imports_ok = check_imports()
+    state_ok = check_state() if imports_ok else False
+    routing_ok = check_routing() if imports_ok else False
+
+    print(SEP)
+    print("Summary")
+    print(SEP)
+    print("  Gemini API   :", "[OK]" if gemini_ok else "[FAIL]")
+    print("  Imports      :", "[OK]" if imports_ok else "[FAIL]")
+    print("  State        :", "[OK]" if state_ok else "[FAIL]")
+    print("  Routing      :", "[OK]" if routing_ok else "[FAIL]")
+    print(SEP)
+
+    system_ok = imports_ok and state_ok and routing_ok
+    if system_ok and gemini_ok:
+        print("\nAll checks passed. The system is ready.")
+    elif system_ok:
+        print("\nSystem checks passed. Fix the Gemini API key to enable LLM calls.")
+    else:
+        print("\nSystem checks failed. See above for details.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())