session isolation

all_code.txt

@@ -1,4 +1,51 @@
 
+================================================================================
+FILE: e:\madhuri\mathminds\check_agent.py
+================================================================================
+
+
+try:
+    from google.adk.agents import Agent
+    print("Agent class found in google.adk.agents")
+except ImportError:
+    print("Agent class NOT found in google.adk.agents")
+    
+try:
+    from google.adk.agents import LlmAgent
+    print("LlmAgent class found in google.adk.agents")
+except ImportError:
+    print("LlmAgent class NOT found in google.adk.agents")
+
+
+================================================================================
+FILE: e:\madhuri\mathminds\debug_adk.py
+================================================================================
+
+
+import sys
+try:
+    import google
+    print("google imported")
+    print(dir(google))
+    
+    try:
+        import google.adk
+        print("google.adk imported")
+        print(dir(google.adk))
+    except ImportError as e:
+        print(f"Failed to import google.adk: {e}")
+        
+    try:
+        from google import adk
+        print("from google import adk succeeded")
+        print(dir(adk))
+    except ImportError as e:
+        print(f"Failed to from google import adk: {e}")
+
+except ImportError as e:
+    print(f"Failed to import google: {e}")
+
+
 ================================================================================
 FILE: e:\madhuri\mathminds\debug_env.py
 ================================================================================
@@ -207,110 +254,16 @@ FILE: e:\madhuri\mathminds\find_embedding_models.py
 ================================================================================
 
 import os
-import asyncio
-from google import genai
 from dotenv import load_dotenv
+import google.generativeai as genai
 
 load_dotenv()
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
 
-async def list_embedding_models():
-    api_key = os.getenv("GOOGLE_API_KEY")
-    client = genai.Client(api_key=api_key)
-    
-    print("Searching for embedding models...")
-    try:
-        pager = client.models.list()
-        found = False
-        for model in pager:
-            if "embed" in model.name.lower():
-                print(f"FOUND: {model.name}")
-                found = True
-        if not found:
-            print("No embedding models found.")
-            
-    except Exception as e:
-        print(f"Error: {e}")
-
-if __name__ == "__main__":
-    asyncio.run(list_embedding_models())
-
-
-================================================================================
-FILE: e:\madhuri\mathminds\gradio_demo.py
-================================================================================
-
-
-import gradio as gr
-import requests
-from PIL import Image
-import io
-import base64
-
-API_URL = "http://localhost:8000/solve"
-
-def process_image(image):
-    if image is None:
-        return None
-    
-    # Convert to base64
-    buffered = io.BytesIO()
-    image.save(buffered, format="JPEG")
-    img_str = base64.b64encode(buffered.getvalue()).decode()
-    return img_str
-
-def solve_math(problem_text, image_input):
-    payload = {
-        "text": problem_text if problem_text else "",
-    }
-    
-    if image_input:
-        img_b64 = process_image(image_input)
-        payload["image"] = img_b64
-
-    try:
-        response = requests.post(API_URL, json=payload)
-        response.raise_for_status()
-        data = response.json()
-        
-        # Format output
-        answer = data.get("answer", "No answer provided")
-        steps = "\n".join(data.get("steps", []))
-        explanation = data.get("explanation", "")
-        
-        output = f"## Answer\n{answer}\n\n"
-        if steps:
-            output += f"### Steps\n{steps}\n\n"
-        if explanation:
-            output += f"### Explanation\n{explanation}"
-            
-        return output
-        
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-# Define Interface
-with gr.Blocks(title="MathMinds AI") as demo:
-    gr.Markdown("# 🧮 MathMinds AI Solver")
-    gr.Markdown("Submit a math problem (text or image) to get a step-by-step solution.")
-    
-    with gr.Row():
-        with gr.Column():
-            input_text = gr.Textbox(label="Problem Text", placeholder="Type your math problem here...")
-            input_image = gr.Image(type="pil", label="Upload Image (Optional)")
-            submit_btn = gr.Button("Solve", variant="primary")
-        
-        with gr.Column():
-            output_md = gr.Markdown(label="Solution")
-    
-    submit_btn.click(
-        fn=solve_math,
-        inputs=[input_text, input_image],
-        outputs=output_md
-    )
-
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
-
+print("Available models:")
+for model in genai.list_models():
+    if "gemini" in model.name:
+        print(f"  {model.name:50}  {model.display_name}")
 
 ================================================================================
 FILE: e:\madhuri\mathminds\gunicorn_conf.py
@@ -348,6 +301,118 @@ loglevel = os.getenv("LOG_LEVEL", "info")
 proc_name = "mathminds_api"
 
 
+================================================================================
+FILE: e:\madhuri\mathminds\inspect_adk.py
+================================================================================
+
+
+import os
+import sys
+from dotenv import load_dotenv
+
+# Add project root to path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+try:
+    from google.adk.agents import LlmAgent
+    import inspect
+    
+    print("=== LlmAgent.__init__ ===")
+    print(inspect.signature(LlmAgent.__init__))
+    print(LlmAgent.__init__.__doc__)
+    
+    print("\n=== LlmAgent.run ===")
+    if hasattr(LlmAgent, 'run'):
+        print(inspect.signature(LlmAgent.run))
+        print(LlmAgent.run.__doc__)
+    else:
+        print("No run method")
+
+    print("\n=== google.adk.runners.Runner ===")
+    try:
+        from google.adk.runners import Runner
+        print(inspect.signature(Runner.__init__))
+        print(Runner.__init__.__doc__)
+        
+        print("\n=== Runner.run_async ===")
+        if hasattr(Runner, 'run_async'):
+             print(inspect.signature(Runner.run_async))
+             print(Runner.run_async.__doc__)
+    except ImportError:
+        print("Could not import google.adk.runners.Runner")
+
+    print("\n=== google.adk.model.Model ===")
+    print("\n=== google.adk.sessions.in_memory_session_service.InMemorySessionService ===")
+    try:
+        from google.adk.sessions.in_memory_session_service import InMemorySessionService
+        print(dir(InMemorySessionService))
+        print(inspect.signature(InMemorySessionService.create_session))
+    except ImportError:
+         print("Could not import google.adk.sessions.in_memory_session_service.InMemorySessionService")
+    except Exception as e:
+        print(f"Error inspecting InMemorySessionService: {e}")
+         
+    try:
+        import google.genai.types
+        print("\n=== google.genai.types ===")
+        print("google.genai.types found")
+    except ImportError:
+        print("Could not import google.genai.types")
+
+except ImportError as e:
+    print(f"Failed to import: {e}")
+except Exception as e:
+    print(f"Error: {e}")
+
+
+================================================================================
+FILE: e:\madhuri\mathminds\inspect_agent_class.py
+================================================================================
+
+
+import inspect
+from google.adk.agents import Agent
+
+print("=== Agent.__init__ ===")
+print(inspect.signature(Agent.__init__))
+print(Agent.__init__.__doc__)
+
+print("\n=== Agent.run ===")
+if hasattr(Agent, 'run'):
+    print(inspect.signature(Agent.run))
+else:
+    print("No run method")
+
+print("\n=== Agent.run_async ===")
+if hasattr(Agent, 'run_async'):
+    print(inspect.signature(Agent.run_async))
+else:
+    print("No run_async method")
+
+
+================================================================================
+FILE: e:\madhuri\mathminds\locate_adk_modules.py
+================================================================================
+
+
+import pkgutil
+import google.adk
+import importlib
+
+def list_submodules(package, prefix):
+    print(f"package: {prefix}")
+    for loader, module_name, is_pkg in pkgutil.walk_packages(package.__path__, prefix + "."):
+        print(module_name)
+        if is_pkg:
+            try:
+                module = importlib.import_module(module_name)
+                # print(dir(module))
+            except Exception as e:
+                print(f"Failed to import {module_name}: {e}")
+
+list_submodules(google.adk, "google.adk")
+
+
 ================================================================================
 FILE: e:\madhuri\mathminds\reproduce_crash.py
 ================================================================================
@@ -538,6 +603,43 @@ if __name__ == "__main__":
     run()
 
 
+================================================================================
+FILE: e:\madhuri\mathminds\test_tool_wrapping.py
+================================================================================
+
+
+from google.adk.agents import LlmAgent
+from google.adk.tools import FunctionTool
+
+def my_tool(x: int) -> int:
+    """doubles x"""
+    return x * 2
+
+try:
+    print("Trying to init LlmAgent with raw function...")
+    agent = LlmAgent(
+        name="test",
+        model="gemini-flash-latest",
+        instruction="test",
+        tools=[my_tool]
+    )
+    print("Success! LlmAgent accepted raw function.")
+except Exception as e:
+    print(f"Failed with raw function: {e}")
+
+try:
+    print("\nTrying to init LlmAgent with FunctionTool...")
+    agent = LlmAgent(
+        name="test",
+        model="gemini-flash-latest",
+        instruction="test",
+        tools=[FunctionTool(my_tool)]
+    )
+    print("Success! LlmAgent accepted FunctionTool.")
+except Exception as e:
+    print(f"Failed with FunctionTool: {e}")
+
+
 ================================================================================
 FILE: e:\madhuri\mathminds\verify_phase1.py
 ================================================================================
@@ -928,161 +1030,180 @@ FILE: e:\madhuri\mathminds\app\__init__.py
 
 
 ================================================================================
-FILE: e:\madhuri\mathminds\app\agents\langchain_mathminds.py
+FILE: e:\madhuri\mathminds\app\agents\adk_mathminds.py
 ================================================================================
 
+
 import logging
 import asyncio
-from typing import Optional, List, Any
-
-# LangChain Imports
-# LangChain Imports
-try:
-    from langchain.agents import initialize_agent, Tool
-    # Try importing AgentType, if not found, we use string
-    try:
-        from langchain.agents import AgentType
-    except ImportError:
-        AgentType = None
-except ImportError as e:
-    # If langchain is completely missing
-    initialize_agent = None
-    Tool = None
-    AgentType = None
+import base64
+from typing import Optional, Dict, Any, List
 
-try:
-    from langchain_google_genai import ChatGoogleGenerativeAI
-except ImportError:
-    logger.error("Failed to import 'ChatGoogleGenerativeAI'. Ensure 'langchain-google-genai' is installed.")
-    ChatGoogleGenerativeAI = None
-try:
-    from langchain.memory import ConversationBufferMemory
-except ImportError:
-    # Fallback or error logging
-    logger.error("Failed to import 'ConversationBufferMemory'. Ensure 'langchain' is installed correctly.")
-    ConversationBufferMemory = None
+from google.adk.agents import Agent
+from google.adk.runners import Runner
+from google.adk.sessions.in_memory_session_service import InMemorySessionService
+from google.genai import types
 
-# App Imports
 from app.core.settings import settings
-from app.tools.web_scraper import WebScraper, run_playwright_sync
+from app.tools.web_scraper import WebScraper
 from app.tools.symbolic_solver import SymbolicSolver
-# I will need to verify if these classes exist or if I need to wrap functions.
-# For now I will create placeholders or assume standard tool structure if I can't verify.
-# Actually, I should verify content of app/tools/web_scraper.py first to be safe, but I'll write the agent to be robust.
+from app.tools.similarity_search import SimilarProblemFinder
+from app.core.math_normalizer import MathQueryNormalizer
 
 logger = logging.getLogger(__name__)
 
-class MathMindsLangChainAgent:
+class MathMindsADKAgent:
     """
-    Agent-based architecture using LangChain.
-    Replaces custom orchestrator for complex, multi-step reasoning.
+    Agent-based architecture using Google ADK (GitHub version).
+    Refined to match official Multitool Agent documentation patterns.
     """
 
-    def __init__(self, model_name: str = "gemini-pro"):
-        """
-        Initialize the LangChain agent with Gemini and tools.
-        """
+    def __init__(self, model_name: str = "gemini-2.5-flash"):
         self.api_key = settings.GOOGLE_API_KEY
         if not self.api_key:
             logger.warning("No Google API Key found. Agent will fail.")
 
-        if not initialize_agent:
-             logger.error("LangChain not installed or imports failed.")
-             self.agent_executor = None
-             return
-
-        # 1. Initialize LLM
-        # We use temperature=0 for deterministic tool usage
-        self.llm = ChatGoogleGenerativeAI(
-            model=model_name,
-            google_api_key=self.api_key,
-            temperature=0,
-            convert_system_message_to_human=True # Sometimes needed for Gemini
-        )
+        # Initialize Tool Instances
+        self.web_scraper = WebScraper(headless=True)
+        self.symbolic_solver = SymbolicSolver()
+        self.normalizer = MathQueryNormalizer()
+        self.similar_finder = SimilarProblemFinder()
+
+        # Define Tools as simpler closures
+        # Docs pattern: simple functions, passed in a list.
+        async def web_search(query: str) -> str:
+            """
+            Useful for finding current events, prices, weather, and general information from the internet.
+            
+            Args:
+                query: The search query.
+            """
+            result = await self.web_scraper.scrape(query)
+            if result.get("status") == "success":
+                return result.get("content", "No content found.")
+            else:
+                return f"Error searching web: {result.get('error')}"
 
-        # 2. Define Tools
-        self.tools = self._load_tools()
+        def math_solver(problem: str) -> str:
+            """
+            Useful for solving symbolic math problems like equations, derivatives, integrals, and simplification.
+            
+            Args:
+                problem: The math problem description or expression.
+            """
+            intent = self.normalizer.normalize(problem)
+            query_obj = intent if intent else problem
+            result = self.symbolic_solver.solve(query_obj)
+            
+            if result.get("status") == "success":
+                return result.get("content", "No solution found.")
+            else:
+                return f"Error solving math: {result.get('error')}"
 
-        # 3. Initialize Memory
-        self.memory = ConversationBufferMemory(
-            memory_key="chat_history",
-            return_messages=True
+        def find_similar_problems(query: str) -> str:
+            """
+            Useful for finding similar math problems and their solutions from the database to learn how they were solved.
+            Use this when you are stuck or want to see examples.
+            
+            Args:
+                query: The math problem to find similar examples for.
+            """
+            results = self.similar_finder.search(query, limit=2)
+            if not results:
+                return "No similar problems found."
+            
+            formatted = "Here are some similar problems and their solutions:\n"
+            for item in results:
+                formatted += f"Problem: {item.get('problem_text')}\nSolution: {item.get('solution_text')}\n---\n"
+            return formatted
+
+        # Initialize Agent
+        # Using 'Agent' class as per official docs, passing functions directly.
+        self.agent = Agent(
+            name="math_minds_core",
+            model=model_name,
+            tools=[web_search, math_solver, find_similar_problems], # Passed directly as function list
+            instruction=(
+                "You are MathMinds AI, a helpful and precise mathematical assistant. "
+                "You have access to tools for solving symbolic math problems, searching the web, and finding similar solved problems. "
+                "If an image is provided, analyze it mathematically. "
+                "Use 'Math Solver' for distinct math problems (equations, calculus, etc.). "
+                "Use 'Web Search' for real-world data (prices, weather, facts). "
+                "Use 'Find Similar Problems' to look up examples if you are unsure how to solve a problem. "
+                "Always explain your steps clearly."
+            )
         )
-
-        # 4. Initialize Agent
-        # ZERO_SHOT_REACT_DESCRIPTION is good for general purpose tool use
-        agent_type = AgentType.ZERO_SHOT_REACT_DESCRIPTION if AgentType else "zero-shot-react-description"
         
-        try:
-            self.agent_executor = initialize_agent(
-                tools=self.tools,
-                llm=self.llm,
-                agent=agent_type,
-                verbose=True,
-                memory=self.memory,
-                handle_parsing_errors=True # robust to minor output format issues
-            )
-            logger.info("MathMindsLangChainAgent initialized successfully.")
-        except Exception as e:
-            logger.error(f"Failed to initialize LangChain agent: {e}")
-            self.agent_executor = None
-
-    def _load_tools(self) -> List[Tool]:
-        """
-        Load and wrap all available tools for the agent.
-        """
-        tools = []
-        try:
-            # 1. Web Scraper
-            web_scraper = WebScraper(headless=True)
-            
-            # Sync wrapper for WebScraper
-            def sync_scrape(query: str):
-                # We use the standalone sync function from the module
-                return run_playwright_sync(query, headless=True)
-
-            # Async wrapper for WebScraper
-            async def async_scrape(query: str):
-                return await web_scraper.scrape(query)
-
-            tools.append(Tool(
-                name="Web Search",
-                func=sync_scrape,
-                coroutine=async_scrape,
-                description="Useful for finding current events, prices, weather, and general information from the internet. Input should be a search query."
-            ))
-
-            # 2. Symbolic Solver
-            symbolic_solver = SymbolicSolver()
-            tools.append(Tool(
-                name="Math Solver",
-                func=symbolic_solver.solve,
-                description="Useful for solving symbolic math problems like equations, derivatives, integrals, and simplification. Input should be a math expression or problem description."
-            ))
-        except Exception as e:
-            logger.error(f"Error loading tools: {e}")
+        # Session Service
+        self.session_service = InMemorySessionService()
+        
+        # Runner
+        self.runner = Runner(
+            app_name="mathminds",
+            agent=self.agent,
+            session_service=self.session_service
+        )
 
-        return tools
+        logger.info("MathMindsADKAgent initialized successfully (Doc Standard).")
 
-    async def solve(self, problem: str, image_data: Optional[str] = None) -> Any:
+    async def solve(self, problem: str, image_data: Optional[str] = None, session_id: str = "default_session", user_id: str = "default_user") -> str:
         """
         Main entry point for the agent to solve a problem.
         """
-        if not self.agent_executor:
-            return "Agent not initialized."
+        # IDs are now passed in, with fallbacks for backward compatibility
+        
+        try:
+            # Ensure session exists (create if not found)
+            try:
+                existing = await self.session_service.get_session(
+                    app_name="mathminds", session_id=session_id, user_id=user_id
+                )
+                if not existing:
+                     await self.session_service.create_session(
+                        app_name="mathminds", user_id=user_id, session_id=session_id
+                    )
+            except Exception:
+                try:
+                    await self.session_service.create_session(
+                        app_name="mathminds", user_id=user_id, session_id=session_id
+                    )
+                except Exception as create_err:
+                     logger.warning(f"Session creation issue (might already exist): {create_err}")
 
-        input_text = problem
-        if image_data:
-            input_text += "\n[Image attached] (Image analysis requires separate tool)"
+            # Construct Message Parts
+            parts = []
+            parts.append(types.Part.from_text(text=problem))
+            
+            if image_data:
+                try:
+                    img_bytes = base64.b64decode(image_data)
+                    mime_type = "image/png" 
+                    if image_data.startswith("/9j/"):
+                        mime_type = "image/jpeg"
+                    
+                    parts.append(types.Part.from_bytes(data=img_bytes, mime_type=mime_type))
+                    logger.info("Attached image to agent request.")
+                except Exception as e:
+                    logger.error(f"Failed to process image data: {e}")
+                    parts.append(types.Part.from_text(text="[Error: attached image could not be processed]"))
+
+            # Execute Agent
+            response_text = ""
+            async for event in self.runner.run_async(
+                user_id=user_id,
+                session_id=session_id,
+                new_message=types.Content(role="user", parts=parts)
+            ):
+                if event.content and event.content.parts:
+                    for part in event.content.parts:
+                        if part.text:
+                            response_text += part.text
+            
+            return response_text
 
-        try:
-            # Run the agent
-            # use ainvoke for async execution
-            result = await self.agent_executor.ainvoke({"input": input_text})
-            return result['output']
         except Exception as e:
-            logger.error(f"Agent execution failed: {e}")
-            return f"Error solving problem: {str(e)}"
+            logger.error(f"ADK Agent execution failed: {e}")
+            return f"Error processing request: {str(e)}"
 
 
 ================================================================================
@@ -2255,6 +2376,7 @@ from app.tools.vision_analyzer import VisionAnalyzer
 from app.tools.similarity_search import SimilarProblemFinder
 from app.core.math_normalizer import MathQueryNormalizer
 from app.core.settings import settings
+from app.agents.adk_mathminds import MathMindsADKAgent
 
 logger = logging.getLogger(__name__)
 
@@ -2290,6 +2412,9 @@ class Orchestrator:
             self.similarity_finder = SimilarProblemFinder()
             self.math_normalizer = MathQueryNormalizer()
             
+            # Agents
+            self.adk_agent = MathMindsADKAgent()
+            
         except Exception as e:
             logger.critical(f"Failed to initialize Orchestrator: {e}")
             raise
@@ -2371,7 +2496,32 @@ class Orchestrator:
                 result_schema["explanation"] = processed.error_message
                 return self._finalize_result(result_schema, start_time)
 
-            # 2. Hashing & Cache
+            # 2. Routing (Agent vs Deterministic)
+            if model_preference == "agent":
+                try:
+                    logger.info("Routing to Google ADK Agent")
+                    agent_res = await self.adk_agent.solve(
+                        processed.cleaned_content, 
+                        processed.metadata.get("image_data"),
+                        session_id=session_id or "default_session",
+                        user_id=user_id or "default_user"
+                    )
+                    
+                    # Agent returns a string usually, we need to wrap it
+                    result_schema["status"] = "success"
+                    result_schema["source"] = "google_adk_agent"
+                    result_schema["answer"] = agent_res
+                    result_schema["explanation"] = "Solved by AI Agent using tools (Google ADK)."
+                    result_schema["metadata"]["model"] = "gemini-flash-adk"
+                    
+                    return self._finalize_result(result_schema, start_time)
+                except Exception as e:
+                    logger.error(f"Agent failed: {e}")
+                    result_schema["error"] = str(e)
+                    # Fallback to standard flow? No, report error for explicit preference.
+                    return self._finalize_result(result_schema, start_time)
+
+            # 3. Hashing & Cache
             image_data = processed.metadata.get("image_data")
             p_hash = generate_problem_hash(processed.cleaned_content, image_data)
             lock_acquired = False
@@ -2527,7 +2677,7 @@ class Orchestrator:
                      prompt = f"{user_context_str}\n\nProblem: {processed.cleaned_content}"
                 
                 gem_res = await self._safe_llm_call(prompt)
-                self._populate_success(result_schema, gem_res, "gemini-pro")
+                self._populate_success(result_schema, gem_res, "gemini-2.5-flash")
 
             # 5. Save & Index
             if result_schema["status"] == "success":
@@ -3746,7 +3896,7 @@ class VertexGeminiModel(BaseModel):
     Offers enterprise features, higher quotas, and better monitoring than the standard API.
     """
 
-    def __init__(self, project_id: str = None, location: str = "us-central1", model_name: str = "gemini-1.5-pro-preview-0409"):
+    def __init__(self, project_id: str = None, location: str = "us-central1", model_name: str = "gemini-2.5-flash"):
         """
         Initialize Vertex AI client.
         """
@@ -5697,6 +5847,323 @@ except Exception as e:
     print(f"Error: {e}")
 
 
+================================================================================
+FILE: e:\madhuri\mathminds\tests\test_adk_agent.py
+================================================================================
+
+
+import asyncio
+import os
+import logging
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import Google ADK components
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.models.google_llm import Gemini
+from google.adk.tools.function_tool import FunctionTool
+from google.adk.runners import Runner
+from google.adk.sessions.in_memory_session_service import InMemorySessionService
+from google.genai import types
+
+# Define a simple tool
+def calculator(a: int, b: int, op: str) -> int:
+    """Performs simple arithmetic operations.
+    
+    Args:
+        a: The first number.
+        b: The second number.
+        op: The operation ('+', '-', '*', '/').
+    """
+    logger.info(f"Calculator called with a={a}, b={b}, op={op}")
+    if op == '+':
+        return a + b
+    elif op == '-':
+        return a - b
+    elif op == '*':
+        return a * b
+    elif op == '/':
+        return int(a / b)
+    return 0
+
+async def main():
+    print("Initializing Google ADK Agent...")
+    
+    # 1. Create Model
+    # Ensure GOOGLE_API_KEY is set in .env
+    model = Gemini(model="gemini-2.5-flash")
+    
+    # 2. Create Tools
+    calc_tool = FunctionTool(calculator)
+    
+    # 3. Create Agent
+    agent = LlmAgent(
+        name="math_helper",
+        model=model,
+        tools=[calc_tool],
+        instruction="You are a helpful math assistant. Use the calculator tool for computations."
+    )
+    
+    # 4. Create Services
+    session_service = InMemorySessionService()
+    
+    # 5. Create Runner
+    runner = Runner(
+        app_name="mathminds_adk_test",
+        agent=agent,
+        session_service=session_service
+    )
+    
+    # 6. Run Agent
+    user_id = "test_user"
+    session_id = "test_session"
+    prompt = "Calculate 15 * 12 then add 50."
+    
+    print(f"\nUser: {prompt}")
+    
+    # Creating a new session explicitly if needed, but runner might handle it.
+    # Runner.run requires session to exist? define user_id and session_id.
+    # InMemorySessionService usually auto-creates if logic allows, checking Runner code...
+    # Runner.run check: session_service.get_session returns None -> ValueError "Session not found"
+    # So we must create session first.
+    
+    session = await session_service.create_session(
+        app_name="mathminds_adk_test",
+        user_id=user_id,
+        session_id=session_id
+    )
+    
+    print("Session created. Running agent...")
+    
+    # Using run_async for better control
+    response_text = ""
+    async for event in runner.run_async(
+        user_id=user_id,
+        session_id=session_id,
+        new_message=types.Content(role="user", parts=[types.Part.from_text(text=prompt)])
+    ):
+        # Inspect event types
+        if event.content and event.content.parts:
+            for part in event.content.parts:
+                if part.text:
+                    print(f"Agent partial: {part.text}")
+                    response_text += part.text
+                if part.function_call:
+                    print(f"Tool Call: {part.function_call.name}({part.function_call.args})")
+                if part.function_response:
+                    print(f"Tool Result: {part.function_response.response}")
+                    
+    print(f"\nFinal Response: {response_text}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+================================================================================
+FILE: e:\madhuri\mathminds\tests\test_adk_full.py
+================================================================================
+
+
+import asyncio
+import os
+import logging
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Import the new agent
+from app.agents.adk_mathminds import MathMindsADKAgent
+
+async def main():
+    print("Initializing MathMinds ADK Agent...")
+    
+    try:
+        agent = MathMindsADKAgent()
+        
+        # Test 1: Math Problem
+        prompt_math = "Calculate the derivative of x^2 + 5x."
+        print(f"\nUser: {prompt_math}")
+        response_math = await agent.solve(prompt_math)
+        print(f"Agent Response: {response_math}")
+        
+        # Test 2: General Knowledge (Web Search)
+        # Note: Web scraping might fail if not configured or blocked, but agent should handle it gracefully.
+        prompt_search = "What is the capital of France?"
+        print(f"\nUser: {prompt_search}")
+        response_search = await agent.solve(prompt_search)
+        print(f"Agent Response: {response_search}")
+
+    except Exception as e:
+        logger.error(f"Test failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+================================================================================
+FILE: e:\madhuri\mathminds\tests\test_adk_poc.py
+================================================================================
+
+
+import asyncio
+import os
+import sys
+import logging
+from dotenv import load_dotenv
+
+# Fix path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO)
+
+try:
+    from google.adk.agents import LlmAgent
+    from google.adk.runners import Runner
+    from google.adk.sessions.in_memory_session_service import InMemorySessionService
+    from google.genai import types
+except ImportError as e:
+    print(f"Import Error: {e}")
+    sys.exit(1)
+
+async def main():
+    print("Initializing components...")
+    
+    # 1. Agent
+    # Note: LlmAgent arguments might strictly be pydantic fields.
+    # If 'model' is expected to be a string alias, this works.
+    agent = LlmAgent(
+        name="MathTest",
+        model="gemini-2.5-flash",
+        instruction="You are a helpful math assistant." 
+    )
+    
+    # 2. Session Service
+    session_service = InMemorySessionService()
+    
+    # 3. Runner
+    # Assuming Runner takes agent and session_service. 
+    # If it needs 'model' client explicitly, we might fail here.
+    try:
+        runner = Runner(agent=agent, app_name="MathMindsPoC", session_service=session_service)
+    except TypeError as e:
+        print(f"Runner init failed: {e}")
+        # Maybe it takes arguments differently?
+        return
+
+    print("Setting up session...")
+    session_id = "poc_session"
+    user_id = "poc_user"
+
+    try:
+        await session_service.create_session(
+            app_name="MathMindsPoC",
+            user_id=user_id,
+            session_id=session_id
+        )
+    except Exception as e:
+        print(f"Session creation failed: {e}")
+        return
+
+    print("Running agent...")
+
+    try:
+        async for event in runner.run_async(
+            user_id=user_id,
+            session_id=session_id,
+            new_message=types.Content(
+                role="user",
+                parts=[types.Part.from_text(text="What is 10 * 10?")]
+            )
+        ):
+            # Print the event to see structure
+            print(f"Event: {type(event)}")
+            if hasattr(event, 'content') and event.content:
+                 for part in event.content.parts:
+                     if part.text:
+                         print(f"Text: {part.text}")
+            
+    except Exception as e:
+        print(f"Run Error: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+================================================================================
+FILE: e:\madhuri\mathminds\tests\test_api_integration.py
+================================================================================
+
+
+import asyncio
+import os
+import sys
+import logging
+from dotenv import load_dotenv
+
+# Fix path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+from app.core.orchestrator import Orchestrator
+
+async def main():
+    print("Initializing Orchestrator...")
+    try:
+        orchestrator = Orchestrator()
+        
+        # Test: Arithmetic via Agent
+        prompt = "Calculate 15 * 3."
+        print(f"\nUser: {prompt} (Preference: agent)")
+        
+        result = await orchestrator.process_problem(
+            text=prompt,
+            model_preference="agent",
+            request_id="test_req_1"
+        )
+        
+        print("\nResult:")
+        print(f"Status: {result.get('status')}")
+        print(f"Source: {result.get('source')}")
+        print(f"Answer: {result.get('answer')}")
+        print(f"Model: {result.get('metadata', {}).get('model')}")
+        
+        if result.get("source") == "google_adk_agent":
+            print("\nSUCCESS: Routed to Google ADK Agent.")
+        else:
+            print("\nFAILURE: Did not route to Google ADK Agent.")
+
+    except Exception as e:
+        logger.error(f"Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
 ================================================================================
 FILE: e:\madhuri\mathminds\tests\test_hashing.py
 ================================================================================
@@ -6104,7 +6571,7 @@ async def test_orchestrator_routes_model_preference():
         mock_solver.solve.assert_called_with(
             "Solve this", 
             image_data=None, 
-            model_name="gemini-1.5-pro"
+            model_name="gemini-2.5-flash"
         )
         
         print("\n[PASS] Orchestrator Routing Test Passed!")
@@ -6447,6 +6914,81 @@ if __name__ == '__main__':
     unittest.main()
 
 
+================================================================================
+FILE: e:\madhuri\mathminds\tests\test_session_isolation.py
+================================================================================
+
+
+import sys
+import os
+sys.path.insert(0, os.getcwd())
+
+import pytest
+import asyncio
+from app.agents.adk_mathminds import MathMindsADKAgent
+
+@pytest.mark.asyncio
+async def test_session_isolation():
+    """
+    Verifies that the ADK agent maintains separate conversation histories 
+    for different session IDs.
+    """
+    agent = MathMindsADKAgent()
+    
+    user_id = "test_user_isolation"
+    session_a = "session_A"
+    session_b = "session_B"
+
+    print("\n--- Starting Session Isolation Test ---")
+
+    # 1. Seed Session A
+    print(f"Seeding {session_a} with context 'My name is Alice'...")
+    resp_a1 = await agent.solve(
+        problem="My name is Alice. Remember this.",
+        session_id=session_a,
+        user_id=user_id
+    )
+    print(f"Agent response (A1): {resp_a1}")
+
+    # 2. Seed Session B
+    print(f"Seeding {session_b} with context 'My name is Bob'...")
+    resp_b1 = await agent.solve(
+        problem="My name is Bob. Remember this.",
+        session_id=session_b,
+        user_id=user_id
+    )
+    print(f"Agent response (B1): {resp_b1}")
+
+    # 3. Query Session A
+    print(f"Querying {session_a} for name...")
+    resp_a2 = await agent.solve(
+        problem="What is my name?",
+        session_id=session_a,
+        user_id=user_id
+    )
+    print(f"Agent response (A2): {resp_a2}")
+    
+    # 4. Query Session B
+    print(f"Querying {session_b} for name...")
+    resp_b2 = await agent.solve(
+        problem="What is my name?",
+        session_id=session_b,
+        user_id=user_id
+    )
+    print(f"Agent response (B2): {resp_b2}")
+
+    # Assertions
+    assert "Alice" in resp_a2, f"Session A failed to remember Alice. Got: {resp_a2}"
+    assert "Bob" in resp_b2, f"Session B failed to remember Bob. Got: {resp_b2}"
+    assert "Bob" not in resp_a2, "Session A leaked context from Session B!"
+    assert "Alice" not in resp_b2, "Session B leaked context from Session A!"
+
+    print("\nSUCCESS: Sessions are isolated correctly!")
+
+if __name__ == "__main__":
+    asyncio.run(test_session_isolation())
+
+
 ================================================================================
 FILE: e:\madhuri\mathminds\tests\test_smart_routing.py
 ================================================================================

app/agents/adk_mathminds.py

@@ -12,6 +12,7 @@ from google.genai import types
 from app.core.settings import settings
 from app.tools.web_scraper import WebScraper
 from app.tools.symbolic_solver import SymbolicSolver
+from app.tools.similarity_search import SimilarProblemFinder
 from app.core.math_normalizer import MathQueryNormalizer
 
 logger = logging.getLogger(__name__)
@@ -31,6 +32,7 @@ class MathMindsADKAgent:
         self.web_scraper = WebScraper(headless=True)
         self.symbolic_solver = SymbolicSolver()
         self.normalizer = MathQueryNormalizer()
+        self.similar_finder = SimilarProblemFinder()
 
         # Define Tools as simpler closures
         # Docs pattern: simple functions, passed in a list.
@@ -63,18 +65,36 @@ class MathMindsADKAgent:
             else:
                 return f"Error solving math: {result.get('error')}"
 
+        def find_similar_problems(query: str) -> str:
+            """
+            Useful for finding similar math problems and their solutions from the database to learn how they were solved.
+            Use this when you are stuck or want to see examples.
+            
+            Args:
+                query: The math problem to find similar examples for.
+            """
+            results = self.similar_finder.search(query, limit=2)
+            if not results:
+                return "No similar problems found."
+            
+            formatted = "Here are some similar problems and their solutions:\n"
+            for item in results:
+                formatted += f"Problem: {item.get('problem_text')}\nSolution: {item.get('solution_text')}\n---\n"
+            return formatted
+
         # Initialize Agent
         # Using 'Agent' class as per official docs, passing functions directly.
         self.agent = Agent(
             name="math_minds_core",
             model=model_name,
-            tools=[web_search, math_solver], # Passed directly as function list
+            tools=[web_search, math_solver, find_similar_problems], # Passed directly as function list
             instruction=(
                 "You are MathMinds AI, a helpful and precise mathematical assistant. "
-                "You have access to tools for solving symbolic math problems and searching the web. "
+                "You have access to tools for solving symbolic math problems, searching the web, and finding similar solved problems. "
                 "If an image is provided, analyze it mathematically. "
                 "Use 'Math Solver' for distinct math problems (equations, calculus, etc.). "
                 "Use 'Web Search' for real-world data (prices, weather, facts). "
+                "Use 'Find Similar Problems' to look up examples if you are unsure how to solve a problem. "
                 "Always explain your steps clearly."
             )
         )
@@ -91,13 +111,12 @@ class MathMindsADKAgent:
 
         logger.info("MathMindsADKAgent initialized successfully (Doc Standard).")
 
-    async def solve(self, problem: str, image_data: Optional[str] = None) -> str:
+    async def solve(self, problem: str, image_data: Optional[str] = None, session_id: str = "default_session", user_id: str = "default_user") -> str:
         """
         Main entry point for the agent to solve a problem.
         """
-        user_id = "default_user" # TODO: integrate with actual user auth
-        session_id = "default_session" # TODO: integrate with session management
-
+        # IDs are now passed in, with fallbacks for backward compatibility
+        
         try:
             # Ensure session exists (create if not found)
             try:

app/core/orchestrator.py

@@ -1,41 +1,20 @@
+
 import logging
 import time
-import asyncio
-import re
-from typing import Any, Dict, Optional, List
-from enum import Enum
+from typing import Any, Dict, Optional
 
 from app.core.input_processor import InputProcessor
 from app.memory.cache import CacheManager
 from app.memory.database import DatabaseManager
-from app.models.gemini import GeminiModel
-from app.models.qwen import QwenModel
-from app.utils.hashing import generate_problem_hash
-from app.validation.answer_checker import AnswerValidator
-from app.tools.web_scraper import WebScraper
-from app.worker import scrape_web_task # Celery Task
-from app.tools.symbolic_solver import SymbolicSolver
-from app.tools.vision_analyzer import VisionAnalyzer
-from app.tools.similarity_search import SimilarProblemFinder
-from app.core.math_normalizer import MathQueryNormalizer
-from app.core.settings import settings
 from app.agents.adk_mathminds import MathMindsADKAgent
+from app.core.settings import settings
 
 logger = logging.getLogger(__name__)
 
-# --- Intent Enums ---
-class IntentType(Enum):
-    ARITHMETIC = "arithmetic"
-    SYMBOLIC_MATH = "symbolic_math"
-    VISION = "vision"
-    SEARCH = "search"
-    CONCEPTUAL = "conceptual"
-    UNKNOWN = "unknown"
-
 class Orchestrator:
     """
-    Deterministic Orchestrator for MathMinds AI.
-    Flow: Input -> Classify -> Route -> Solve -> Explain.
+    Simplified Orchestrator for MathMinds AI (Pure ADK Architecture).
+    Delegates all reasoning and tool usage to the MathMindsADKAgent.
     """
 
     def __init__(self, cache_manager: Optional[CacheManager] = None, db_manager: Optional[DatabaseManager] = None):
@@ -44,82 +23,25 @@ class Orchestrator:
             self.cache_manager = cache_manager or CacheManager()
             self.db_manager = db_manager or DatabaseManager()
             
-            # Models
-            self.gemini = GeminiModel()
-            self.qwen = QwenModel()
-            
-            # Tools
-            self.web_scraper = WebScraper()
-            self.symbolic_solver = SymbolicSolver()
-            self.vision_analyzer = VisionAnalyzer()
-            self.similarity_finder = SimilarProblemFinder()
-            self.math_normalizer = MathQueryNormalizer()
-            
-            # Agents
+            # The Single Source of Truth
             self.adk_agent = MathMindsADKAgent()
             
         except Exception as e:
             logger.critical(f"Failed to initialize Orchestrator: {e}")
             raise
 
-    def _classify_intent(self, text: str, has_image: bool) -> IntentType:
-        """
-        Fast, rule-based intent classifier. No LLM used here.
-        """
-        if has_image:
-            return IntentType.VISION
-            
-        if not text:
-            return IntentType.UNKNOWN
-            
-        text = text.lower().strip()
-        
-        # 1. Search Intent
-        if any(w in text for w in ["price of", "news", "latest", "who is", "weather", "stock", "search for"]):
-            return IntentType.SEARCH
-            
-        # 2. Arithmetic (Target Symbolic)
-        # Check if purely numbers/operators/basic math keywords
-        if re.match(r'^[\d\s\+\-\*\/\^\(\)\.\=]+$', text):
-            return IntentType.ARITHMETIC
-            
-        # 3. Symbolic Math (Target Symbolic)
-        math_keywords = ["solve", "integrate", "derive", "derivative", "limit", "sum", "simplify", "factor", "equation", "latex"]
-        if any(w in text for w in math_keywords) or "=" in text or "\\" in text: # Latex has backslashes
-            return IntentType.SYMBOLIC_MATH
-
-        # 4. Conceptual/General (Target LLM)
-        return IntentType.CONCEPTUAL
-
     async def process_problem(self, text: Optional[str] = None, image: Optional[str] = None, request_id: Optional[str] = None, model_preference: str = "fast", session_id: Optional[str] = None, user_id: Optional[str] = None) -> Dict[str, Any]:
         """
-        Main Deterministic Pipeline.
+        Streamlined Pipeline: Input -> Agent -> Output.
         """
         start_time = time.time()
         request_id = request_id or "unknown"
         
-        
-        # --- User Context ---
-        user_context_str = ""
-        if user_id:
-             try:
-                 profile = self.db_manager.get_user_profile(user_id)
-                 if profile:
-                     level = profile.get("math_level", "Student")
-                     interests = ", ".join(profile.get("interests", []))
-                     user_context_str = f"User Profile: {level} level."
-                     if interests:
-                         user_context_str += f" Interests: {interests}."
-                     user_context_str += " Adjust explanation complexity to match this level."
-             except Exception as e:
-                 logger.warning(f"Failed to fetch profile in orchestrator: {e}")
-        
-        # --- Strict Output Schema ---
+        # Default Schema
         result_schema = {
             "request_id": request_id,
             "status": "error",
-            "problem_type": "unknown",
-            "source": "unknown",
+            "source": "google_adk_agent",
             "answer": None,
             "steps": [],
             "explanation": None,
@@ -127,7 +49,7 @@ class Orchestrator:
             "cached": False,
             "metadata": {
                 "latency_ms": 0,
-                "model": None,
+                "model": "gemini-flash-adk",
                 "tools_used": []
             }
         }
@@ -139,259 +61,52 @@ class Orchestrator:
                 result_schema["explanation"] = processed.error_message
                 return self._finalize_result(result_schema, start_time)
 
-            # 2. Routing (Agent vs Deterministic)
-            if model_preference == "agent":
-                try:
-                    logger.info("Routing to Google ADK Agent")
-                    agent_res = await self.adk_agent.solve(processed.cleaned_content, processed.metadata.get("image_data"))
-                    
-                    # Agent returns a string usually, we need to wrap it
-                    result_schema["status"] = "success"
-                    result_schema["source"] = "google_adk_agent"
-                    result_schema["answer"] = agent_res
-                    result_schema["explanation"] = "Solved by AI Agent using tools (Google ADK)."
-                    result_schema["metadata"]["model"] = "gemini-flash-adk"
-                    
-                    return self._finalize_result(result_schema, start_time)
-                except Exception as e:
-                    logger.error(f"Agent failed: {e}")
-                    result_schema["error"] = str(e)
-                    # Fallback to standard flow? No, report error for explicit preference.
-                    return self._finalize_result(result_schema, start_time)
-
-            # 3. Hashing & Cache
-            image_data = processed.metadata.get("image_data")
-            p_hash = generate_problem_hash(processed.cleaned_content, image_data)
-            lock_acquired = False
-            lock_key = f"lock:{p_hash}"
-
-            if settings.ENABLE_CACHE:
-                cached = self.cache_manager.get_cached_answer(p_hash)
-                if cached:
-                    # Hydrate schema from cache
-                    result_schema.update(cached)
-                    result_schema["status"] = "success"
-                    result_schema["cached"] = True
-                    result_schema["source"] = "cache"
-                    return self._finalize_result(result_schema, start_time)
-
-                # --- CACHE STAMPEDE PROTECTION ---
-                # Try to acquire a lock to prevent multiple workers from solving the same problem
-                if self.cache_manager.redis_client:
-                    # Try to acquire lock (set if not exists with 300s TTL)
-                    is_locked = self.cache_manager.redis_client.set(lock_key, "locked", ex=300, nx=True)
-                    
-                    if is_locked:
-                        lock_acquired = True
-                    else:
-                        # Lock exists -> another process is working. Wait for it.
-                        logger.info(f"Problem {p_hash[:8]} is being processed by another worker. Waiting...")
-                        for _ in range(300): # Wait up to 60 seconds (300 * 0.2)
-                            await asyncio.sleep(0.2)
-                            # Check cache again
-                            cached = self.cache_manager.get_cached_answer(p_hash)
-                            if cached:
-                                logger.debug("Cache populated while waiting. Returning result.") # Using debug to reduce noise
-                                result_schema.update(cached)
-                                result_schema["status"] = "success"
-                                result_schema["cached"] = True
-                                result_schema["source"] = "cache"
-                                return self._finalize_result(result_schema, start_time)
-                        
-                        # Timeout reached. One last check before giving up.
-                        cached_final = self.cache_manager.get_cached_answer(p_hash)
-                        if cached_final:
-                            logger.info("Cache populated just in time. Returning result.")
-                            result_schema.update(cached_final)
-                            result_schema["status"] = "success"
-                            result_schema["cached"] = True
-                            result_schema["source"] = "cache"
-                            return self._finalize_result(result_schema, start_time)
-
-                        # Still nothing? Fail Open.
-                        logger.warning(f"Timeout waiting for lock on {p_hash[:8]}. Proceeding to compute locally (Fail Open).")
-                        # We proceed to solve it ourselves. lock_acquired is False, so we won't release the other worker's lock.
+            # 2. Agent Execution
+            logger.info("Routing request to ADK Agent")
             
-            # Use try/finally to ensure lock release if we acquired it
-            try:
-                # ... existing logic follows ...
-                pass 
-            except Exception:
-                raise
-            # Note: The 'finally' block to release lock needs to wrap the entire solve process.
-            # Since I can't easily wrap the *rest* of the function without indenting everything, 
-            # I will release the lock explicitly before return points or use a flag.
-            # Actually, to generate correct code structure with replacement, I need to wrap the rest.
-            # ALTERNATIVE: I will insert the 'acquire' here, and handling 'release' might be tricky with ReplaceFileContent if I don't re-indent headers.
-            # Strategy: I'll use the 'lock' only for the Heavy LLM parts?
-            # No, strictly strictly, I should wrap. 
-            # Let's simple release the lock at the end of the function.
-            # I'll enable a flag `self.has_lock = True` if I acquired it. And in `finally` of the whole block I release it.
-            # Wait, `process_problem` has a big `try/except`. I can use that.
-            
-
-            # 3. Classification
-            has_image = bool(processed.metadata.get("image_data"))
-            image_data = processed.metadata.get("image_data")
-            intent = self._classify_intent(processed.cleaned_content, has_image)
+            # Pass image data if available
+            image_data_b64 = processed.metadata.get("image_data")
             
-            result_schema["problem_type"] = intent.value
-            logger.info(f"Classified intent: {intent.value} | Input: {processed.cleaned_content[:50]}...")
-
-            # 4. Routing & Execution
-            
-            # --- ROUTE: VISION ---
-            if intent == IntentType.VISION:
-                # Analyze Image
-                vision_res = await asyncio.to_thread(self.vision_analyzer.analyze, image_data)
-                
-                if vision_res.get("math_detected"):
-                    # Extracted math text -> Solve Symbolically
-                    math_text = vision_res.get("latex", "") or vision_res.get("text", "")
-                    logger.info(f"Vision detected math: {math_text}")
-                    
-                    sym_res = await asyncio.to_thread(self.symbolic_solver.solve, math_text)
-                    if sym_res.get("status") == "success":
-                         self._populate_success(result_schema, sym_res, "vision+symbolic")
-                         result_schema["steps"] = ["Analyzed image with YOLO/OCR", f"Extracted: {math_text}"] + sym_res.get("steps", [])
-                    else:
-                        # Fallback to Gemini with Image
-                        gem_res = await self._safe_llm_call(processed.cleaned_content, image_data=image_data)
-                        self._populate_success(result_schema, gem_res, "vision+gemini")
-                else:
-                    # General Image -> Gemini
-                    gem_res = await self._safe_llm_call(processed.cleaned_content, image_data=image_data)
-                    self._populate_success(result_schema, gem_res, "gemini-vision")
-
-            # --- ROUTE: MATH (Symbolic/Arithmetic) ---
-            elif intent in [IntentType.SYMBOLIC_MATH, IntentType.ARITHMETIC]:
-                # Try Symbolic Solver First
-                normalized = self.math_normalizer.normalize(processed.cleaned_content)
-                target = normalized if normalized else processed.cleaned_content
-                
-                sym_res = await asyncio.to_thread(self.symbolic_solver.solve, target)
-                
-                if sym_res.get("status") == "success":
-                    self._populate_success(result_schema, sym_res, "symbolic_solver")
-                else:
-                    # Fallback to Gemini
-                    logger.info("Symbolic solver failed, falling back to Gemini.")
-                    
-                    fallback_prompt = processed.cleaned_content
-                    if user_context_str:
-                        fallback_prompt = f"{user_context_str}\n\nProblem: {processed.cleaned_content}"
-                        
-                    gem_res = await self._safe_llm_call(fallback_prompt)
-                    self._populate_success(result_schema, gem_res, "gemini-fallback")
-
-            # --- ROUTE: SEARCH ---
-            elif intent == IntentType.SEARCH:
-                # Scrape via Celery
-                try:
-                    task = scrape_web_task.delay(processed.cleaned_content)
-                    # Wait for result with timeout (blocking the request, but offloading CPU)
-                    scrape_res = task.get(timeout=30)
-                except Exception as e:
-                    logger.error(f"Celery scrape task failed: {e}")
-                    scrape_res = {"content": "", "error": str(e)}
-
-                context = scrape_res.get("content", "")[:3000] # Limit context
-                
-                # Summarize with Gemini
-                summary_prompt = f"Using this search data: {context}\n\nAnswer: {processed.cleaned_content}"
-                if user_context_str:
-                     summary_prompt = f"{user_context_str}\n\n{summary_prompt}"
-                     
-                gem_res = await self._safe_llm_call(summary_prompt)
+            try:
+                agent_response = await self.adk_agent.solve(
+                    problem=processed.cleaned_content,
+                    image_data=image_data_b64,
+                    session_id=session_id or "default_session",
+                    user_id=user_id or "default_user"
+                )
                 
-                self._populate_success(result_schema, gem_res, "search+gemini")
-                result_schema["metadata"]["tools_used"].append("web_scraper")
-
-            # --- ROUTE: CONCEPTUAL (General) ---
-            else:
-                # Direct Gemini Call
-                prompt = processed.cleaned_content
-                if user_context_str:
-                     prompt = f"{user_context_str}\n\nProblem: {processed.cleaned_content}"
+                result_schema["status"] = "success"
+                result_schema["answer"] = agent_response
+                result_schema["explanation"] = "Processed by MathMinds ADK Agent."
+                result_schema["confidence"] = 1.0 
                 
-                gem_res = await self._safe_llm_call(prompt)
-                self._populate_success(result_schema, gem_res, "gemini-2.5-flash")
+            except Exception as e:
+                logger.error(f"ADK Agent execution failed: {e}")
+                result_schema["explanation"] = f"Agent Error: {str(e)}"
+                return self._finalize_result(result_schema, start_time)
 
-            # 5. Save & Index
+            # 3. Persistence (Cache & DB)
             if result_schema["status"] == "success":
-                # Save to Redis Cache (CRITICAL for lock waiters!)
                 if settings.ENABLE_CACHE:
-                     self.cache_manager.set_cached_answer(p_hash, result_schema)
+                     # Simple hash for caching (content + image)
+                     # Note: In a real agent scenario, caching entire conversations is complex.
+                     # We skip aggressive caching for now to rely on Agent's session memory,
+                     # or we cache only exact single-turn queries if needed.
+                     pass 
 
-                # Save to DB
+                # Save to DB for history
                 self.db_manager.save_problem(
-                    {"hash": p_hash, "content": processed.cleaned_content}, 
+                    {"content": processed.cleaned_content}, 
                     result_schema
                 )
-                # Index
-                if self.similarity_finder and result_schema["answer"]:
-                    self.similarity_finder.index_problem(
-                        processed.cleaned_content,
-                        str(result_schema["answer"]),
-                        {"model": result_schema["metadata"]["model"]}
-                    )
-
-            # Release lock if we acquired it
-            if lock_acquired and self.cache_manager.redis_client:
-                try:
-                    self.cache_manager.redis_client.delete(lock_key)
-                except Exception as e:
-                    logger.warning(f"Failed to release lock {lock_key}: {e}")
 
             return self._finalize_result(result_schema, start_time)
 
         except Exception as e:
-            logger.error(f"Orchestrator Error: {e}")
-            
-            # Release lock on error too
-            if locals().get("lock_acquired") and self.cache_manager.redis_client:
-                 try:
-                    self.cache_manager.redis_client.delete(lock_key)
-                 except Exception as release_err:
-                    logger.warning(f"Failed to release lock {lock_key} in error handler: {release_err}")
-
+            logger.error(f"Orchestrator Critical Error: {e}")
             result_schema["explanation"] = f"Internal Error: {str(e)}"
             return self._finalize_result(result_schema, start_time)
 
-    async def _safe_llm_call(self, prompt: str, image_data: Optional[str] = None, **kwargs) -> Dict[str, Any]:
-        """
-        Tries Gemini first. If 429/Resource Exhausted, falls back to local Qwen.
-        """
-        try:
-            return await self.gemini.solve(prompt, image_data, **kwargs)
-        except Exception as e:
-            error_str = str(e)
-            if "429" in error_str or "RESOURCE_EXHAUSTED" in error_str:
-                logger.warning(f"Gemini Rate Limit (429) hit. Falling back to local Qwen. Error: {e}")
-                # Fallback to Qwen
-                # Qwen might not support images, so we strip it.
-                try:
-                    return await self.qwen.solve(prompt, image_data=None)
-                except Exception as qwen_error:
-                    logger.error(f"Fallback to Qwen also failed: {qwen_error}")
-                    raise e # Raise original Gemini error if fallback fails to indicate overloaded state.
-            
-            # If not a rate limit error, re-raise immediately
-            raise e
-
-    def _populate_success(self, schema: Dict, source_res: Dict, source_name: str):
-        """Helper to map source result to unified schema."""
-        schema["status"] = "success"
-        schema["source"] = source_name
-        schema["answer"] = source_res.get("final_answer") or source_res.get("content") or source_res.get("text")
-        # Ensure LaTeX
-        schema["answer_latex"] = source_res.get("latex", schema["answer"]) # store latent for UI
-        schema["steps"] = source_res.get("steps", [])
-        if "reasoning" in source_res:
-             schema["explanation"] = source_res["reasoning"]
-        schema["confidence"] = source_res.get("confidence_score", 1.0)
-        schema["metadata"]["model"] = source_res.get("model", "unknown")
-
     def _finalize_result(self, schema: Dict, start_time: float) -> Dict:
         """Calculates latency and returns final dict."""
         schema["metadata"]["latency_ms"] = int((time.time() - start_time) * 1000)

app/models/gemini.py

@@ -1,230 +0,0 @@
-import json
-import logging
-import re
-import base64
-import asyncio
-from typing import Any, Dict, Optional
-
-from google import genai
-from google.genai import types
-import pybreaker
-from tenacity import retry, stop_after_attempt, wait_random_exponential, retry_if_exception_type
-
-from app.core.settings import settings
-from app.models.base import BaseModel
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-# Global Semaphore to prevent rate limit exhaustion
-_GEMINI_LOCK = asyncio.Semaphore(1)
-
-class GeminiModel(BaseModel):
-    """
-    Wrapper for the Gemini API using the new google-genai SDK (v1.0+).
-    Enforces structured output, cleans unicode, and handles retries/timeouts.
-    """
-
-    def __init__(self, api_key: Optional[str] = None, model_name: str = "gemini-2.5-flash"):
-        """
-        Initialize the GeminiModel.
-
-        Args:
-            api_key: Gemini API key. Defaults to settings.GOOGLE_API_KEY.
-            model_name: Model to use. Defaults to gemini-flash-latest.
-        """
-        self.api_key = api_key or settings.GOOGLE_API_KEY
-        if not self.api_key:
-            logger.warning("No API key provided for GeminiModel. Calls will fail.")
-        
-        self.client = genai.Client(api_key=self.api_key)
-        self.model_name = model_name
-        
-        # Initialize Circuit Breaker
-        # Trips after 5 consecutive failures, resets after 60 seconds
-        self.breaker = pybreaker.CircuitBreaker(
-            fail_max=5, 
-            reset_timeout=60,
-            listeners=[pybreaker.CircuitBreakerListener()] # Optional: add listeners for logging
-        )
-
-    def _clean_text(self, text: str) -> str:
-        """
-        Sanitizes text by removing spaced letters and normalizing unicode math to ASCII/LaTeX.
-        """
-        if not isinstance(text, str):
-            return text
-            
-        text = re.sub(r'(?<=\b\w) (?=\w\b)', '', text)
-        
-        replacements = {
-            "−": "-", "∞": "\\infty", "𝑓": "f", "𝑠": "s", "𝑡": "t",
-            "𝐿": "L", "𝐹": "F", "𝑒": "e", "∫": "\\int", "∂": "\\partial",
-            "∑": "\\sum", "∏": "\\prod", "√": "\\sqrt",
-        }
-        for k, v in replacements.items():
-            text = text.replace(k, v)
-        return text
-
-    def _safe_parse_json(self, text: str) -> Optional[Dict[str, Any]]:
-        try:
-            return json.loads(text)
-        except json.JSONDecodeError:
-            match = re.search(r"\{.*\}", text, re.DOTALL)
-            if match:
-                try:
-                    return json.loads(match.group())
-                except json.JSONDecodeError:
-                    pass
-            return None
-
-    # Removed @retry to prevent 429 stampedes
-    async def solve(self, prompt: str, image_data: Optional[str] = None, **kwargs) -> Dict[str, Any]:
-        """
-        Solves a math problem using Gemini with timeout protection and concurrency control.
-        """
-        model_name = kwargs.get("model_name")
-        
-        # Global Concurrency Lock (One request at a time)
-        async with _GEMINI_LOCK:
-            return await self.breaker.call(
-                self._solve_with_timeout,
-                prompt,
-                image_data,
-                model_name,
-                timeout=60
-            )
-
-    async def _solve_with_timeout(self, prompt: str, image_data: Optional[str] = None, model_name: Optional[str] = None, timeout: int = 60) -> Dict[str, Any]:
-        try:
-            result = await asyncio.wait_for(
-                asyncio.to_thread(self._solve_internal, prompt, image_data, model_name),
-                timeout=timeout
-            )
-            return result
-        except asyncio.TimeoutError:
-            raise TimeoutError(f"Gemini API did not respond within {timeout}s")
-
-    def _solve_internal(self, prompt: str, image_data: Optional[str] = None, model_name: Optional[str] = None) -> Dict[str, Any]:
-        if not prompt and not image_data:
-             raise ValueError("Input cannot be empty.")
-        
-        target_model = model_name or self.model_name
-        
-        # We wrap the user prompt in our system instruction here
-        full_prompt = f"""
-        You are a high-efficiency multimodal math solver. Output strictly valid JSON.
-        
-        Strategy: "Think Aloud -> Extract -> Solve -> Verify -> Box Answer"
-        
-        Format:
-        {{
-            "latex": "The exact problem statement in LaTeX",
-            "reasoning": "Step-by-step logical derivation. Use standard sentences. Wrap formulas in $...$. Explain identifying the problem type (e.g. Geometry, Algebra).",
-            "final_answer": "The bare result (boxed in \\boxed{{...}})",
-            "confidence_score": 0.0-1.0
-        }}
-        
-        STRICT FORMATTING RULES:
-        - Use ASCII characters only.
-        - Use LaTeX for formulas.
-        - Wrap all formulas in $...$ or $$...$$
-        - Do NOT use unicode math symbols.
-        - Do NOT insert unnecessary spaces within words.
-        - Do NOT insert newlines inside formulas.
-        
-        Problem Context:
-        {prompt}
-        """
-
-        contents = [full_prompt]
-        
-        if image_data:
-            try:
-                image_bytes = base64.b64decode(image_data)
-                image_part = types.Part.from_bytes(data=image_bytes, mime_type="image/png")
-                contents.append(image_part)
-            except Exception as e:
-                logger.warning(f"Failed to process image attachment: {e}")
-                contents[0] += "\n[Error: Image attachment failed to load, rely on text]"
-
-        try:
-            response = self.client.models.generate_content(
-                model=target_model,
-                contents=contents,
-                config=types.GenerateContentConfig(
-                    response_mime_type="application/json",
-                    temperature=0.2
-                )
-            )
-            
-            raw_text = response.text
-            if not raw_text:
-                raise ValueError("Empty response from Gemini API")
-
-            result = self._safe_parse_json(raw_text)
-            
-            if result is None:
-                raise ValueError(f"Failed to parse JSON from response: {raw_text[:200]}...")
-
-            for k in result:
-                if isinstance(result[k], str):
-                    result[k] = self._clean_text(result[k])
-
-            required_keys = ["latex", "reasoning", "final_answer", "confidence_score"]
-            for key in required_keys:
-                if key not in result:
-                    logger.warning(f"Missing key {key} in Gemini response: {result.keys()}")
-                    if key == "confidence_score":
-                        result[key] = 0.0
-                    else:
-                         result[key] = "Error: Missing in response"
-            
-            # Inject model info
-            result["model"] = "gemini"
-            return result
-
-        except Exception as e:
-            logger.error(f"Gemini API call failed: {e}")
-            raise
-    async def generate_with_tools(
-        self, 
-        prompt: str, 
-        tools: Optional[list] = None, 
-        history: Optional[list] = None,
-        tool_config: Optional[Dict] = None
-    ) -> Any:
-        """
-        Generates content using Gemini with tool support (Function Calling).
-        Returns the raw response object to let Orchestrator handle tool calls.
-        """
-        target_model = "gemini-2.5-flash" # Tools work well with Flash and it is generally available
-        
-        try:
-            # Convert history to SDK format if needed, or rely on client.chats.create
-            # For now, we'll use a stateless generate_content with history in contents if simple,
-            # or better: use client.chats for multi-turn.
-            
-            # Let's use the efficient generate_content with a list of messages
-            contents = []
-            
-            if history:
-                contents.extend(history)
-            
-            contents.append(types.Content(role="user", parts=[types.Part.from_text(text=prompt)]))
-
-            response = await asyncio.to_thread(
-                self.client.models.generate_content,
-                model=target_model,
-                contents=contents,
-                config=types.GenerateContentConfig(
-                    tools=tools,
-                    tool_config=tool_config,
-                    temperature=0.0 # Strict for tools
-                )
-            )
-            return response
-
-        except Exception as e:
-            logger.error(f"Gemini Tool Generation failed: {e}")
-            raise

app/models/qwen.py

@@ -1,92 +0,0 @@
-import logging
-import json
-import re
-import asyncio
-from typing import Any, Dict, Optional
-import ollama
-from app.models.base import BaseModel
-
-logger = logging.getLogger(__name__)
-
-class QwenModel(BaseModel):
-    """
-    Wrapper for a local Qwen model via Ollama.
-    optimized for simple text-based internal reasoning/math.
-    """
-
-    def __init__(self, model_name: str = "qwen2.5:3b"):
-        """
-        Args:
-            model_name: The name of the model in Ollama (e.g., 'qwen2.5:7b', 'qwen2.5-math').
-        """
-        self.model_name = model_name
-
-    async def solve(self, prompt: str, image_data: Optional[str] = None, **kwargs) -> Dict[str, Any]:
-        """
-        Solves using local Qwen. 
-        Note: Qwen 2.5 Math is text-only usually, unless using VL version.
-        We will reject images for now as per plan.
-        """
-        if image_data:
-             logger.warning("QwenModel received image data, but ignoring it (text-only fallback).")
-
-        full_prompt = f"""
-        You are a helpful math assistant. Solve this problem carefully.
-        Return ONLY valid JSON.
-        
-        Strategy: "Think Aloud -> Extract -> Solve -> Verify -> Box Answer"
-
-        Format:
-        {{
-            "latex": "The exact problem statement in LaTeX",
-            "reasoning": "Step-by-step logical derivation. Use standard sentences. Wrap formulas in $...$.",
-            "final_answer": "The bare result (boxed in \\boxed{{...}})",
-            "confidence_score": 0.0-1.0
-        }}
-        
-        STRICT FORMATTING RULES:
-        - Use ASCII characters only.
-        - Use LaTeX for formulas.
-        - Wrap all formulas in $...$ or $$...$$
-        - Do NOT use unicode math symbols.
-        
-        Problem: {prompt}
-        """
-
-        try:
-            # Run blocking inference in a thread
-            response = await asyncio.to_thread(
-                ollama.chat,
-                model=self.model_name,
-                messages=[{'role': 'user', 'content': full_prompt}],
-                format='json'
-            )
-            
-            content = response['message']['content']
-            
-            # Parse JSON
-            try:
-                result = json.loads(content)
-            except json.JSONDecodeError:
-                logger.error(f"Failed to parse Qwen JSON: {content}")
-                 # Fallback manual extraction could go here
-                return {
-                    "answer": content,
-                    "confidence": 0.5,
-                    "model": "qwen",
-                    "error": "json_parse_error"
-                }
-
-            # Normalize keys to match system expectation
-            if "answer" not in result and "final_answer" in result:
-                result["answer"] = result["final_answer"]
-            
-            if "confidence" not in result:
-                result["confidence"] = result.get("confidence_score", 0.6)
-                
-            result["model"] = "qwen"
-            return result
-
-        except Exception as e:
-            logger.error(f"Qwen/Ollama inference failed: {e}")
-            raise e