Upload folder using huggingface_hub

README.md

@@ -34,3 +34,11 @@ This chatbot helps you perform **market research tasks** using AI.
 ### Notes
 - Make sure your API keys are configured in the Space secrets
 - Built using Streamlit and deployed as a Docker Space
+
+### References
+
+https://openai.github.io/openai-agents-python/
+
+
+https://github.com/openai/openai-agents-python/tree/main/examples/mcp
+

appagents/InputValidationAgent.py

@@ -0,0 +1,76 @@
+import os
+from agents import Agent, OpenAIChatCompletionsModel, Runner, GuardrailFunctionOutput
+from pydantic import BaseModel
+import json
+from openai import AsyncOpenAI
+
+class ValidatedOutput(BaseModel):
+    is_valid: bool
+    reasoning: str
+
+class InputValidationAgent:
+    """
+    Encapsulates the AI agent definition for conducting comprehensive web searches and synthesizing information.
+    """
+
+    @staticmethod
+    def create():
+        """
+        Returns a configured Agent instance ready for use.
+        """
+
+        instructions = """
+            You are a highly efficient and specialized **Agent** 🌐. Your sole function is to validate the user inputs.
+            
+            ## Core Directives & Priorities
+            1. You should flag if the user uses unparaliamentary language ONLY.
+            2. You MUST give reasoning for the same.
+            
+            ## Rules
+            - If it contains any of these, mark `"is_valid": false` and explain **why** in `"reasoning"`.
+            - Otherwise, mark `"is_valid": true` with reasoning like "The input follows respectful communication guidelines."
+
+
+            ## Output Format (MANDATORY)
+            * Return a JSON object with the following structure:
+            {
+                "is_valid": <boolean>,
+                "reasoning": <string>
+            }
+
+        """
+
+
+        GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
+        google_api_key = os.getenv('GOOGLE_API_KEY')
+        gemini_client = AsyncOpenAI(base_url=GEMINI_BASE_URL, api_key=google_api_key)
+        gemini_model = OpenAIChatCompletionsModel(model="gemini-2.0-flash", openai_client=gemini_client) 
+
+        agent = Agent(
+            name="Guardrail Input Validation Agent",
+            instructions=instructions,
+            model=gemini_model,
+            output_type=ValidatedOutput,
+        )
+        return agent
+    
+async def input_validation_guardrail(ctx, agent, input_data):
+    result = await Runner.run(InputValidationAgent.create(), input_data, context=ctx.context)
+    raw_output = result.final_output
+
+    # print("Raw Output from Guardrail Model:", raw_output)
+
+    # Handle different return shapes gracefully
+    if isinstance(raw_output, ValidatedOutput):
+        final_output = raw_output
+        print("Parsed ValidatedOutput:", final_output)
+    else:
+        final_output = ValidatedOutput(
+            is_valid=False,
+            reasoning=f"Unexpected output type: {type(raw_output)}"
+        )
+
+    return GuardrailFunctionOutput(
+        output_info=final_output,
+        tripwire_triggered=not final_output.is_valid,
+    )

appagents/OrchestratorAgent.py

@@ -1,68 +1,167 @@
+import os
+import asyncio
 from appagents.FinancialAgent import FinancialAgent
 from appagents.NewsAgent import NewsAgent
 from appagents.SearchAgent import SearchAgent
-import os
-from agents import Agent, OpenAIChatCompletionsModel
+from appagents.InputValidationAgent import input_validation_guardrail
+from agents import Agent, OpenAIChatCompletionsModel, InputGuardrail
 from openai import AsyncOpenAI
 
+
 class OrchestratorAgent:
     """
-    The OrchestratorAgent coordinates multiple specialized agents
-    (financial, news, and search) to provide accurate and up-to-date
-    market research insights.
+    The OrchestratorAgent coordinates multiple specialized sub-agents
+    (Financial, News, and Search) to provide accurate, up-to-date,
+    and well-routed market research insights.
     """
 
+    MAX_RETRIES = 2
+
+    # ----------------------------------------------------------
+    # MAIN CREATION METHOD
+    # ----------------------------------------------------------
     @staticmethod
     def create(model: str = "gpt-4o-mini"):
         """
-        Creates and returns a configured Agent instance with
-        predefined instructions and connected sub-agents.
+        Creates and returns a configured Orchestrator agent.
         """
 
-        # Define sub-agents for specialized handoffs
+        # --- Sub-agent setup ---
         handoffs = [
             FinancialAgent.create(),
             NewsAgent.create(),
-            SearchAgent.create()
+            SearchAgent.create(),
         ]
 
-        # Core behavioral and ethical instructions
+        # --- Behavioral instructions ---
         instructions = """
-        You are an AI research assistant designed to deliver accurate,
-        concise, and verifiable answers.
-
-        **Your Core Priorities**
-        1. **Current Awareness:** Always use the Time Tool to maintain awareness
-           of the current date and time for contextual accuracy.
-        2. **Accuracy and Recency:** Base all responses on the latest and most
-           reliable data available.
-        3. **Tool Usage:** For questions involving current events, statistics,
-           or factual updates, invoke the appropriate tools (Search, News, APIs)
-           to confirm or refresh information before responding.
-        4. **Synthesis:** When using multiple data sources, integrate findings
-           into a coherent, factual, and reader-friendly summary.
-        5. **Source Transparency:** Always cite your sources clearly (e.g., URLs,
-           named publications, or APIs).
-        6. **Clarity and Brevity:** Use professional, direct language. Avoid
-           speculation, filler text, or redundancy.
-        7. **Simplification:** Present complex topics in simple, accessible terms
-           suitable for a general audience.
-        8. **Verification:** If information cannot be confirmed, explicitly state
-           that the data could not be verified or is unavailable.
-
-        ⚠️ Do **not fabricate** or infer details without verifiable evidence.
+        You are the Orchestrator Agent responsible for coordinating specialized sub-agents 
+        to generate accurate and well-rounded market research responses.
+
+        **Your Core Responsibilities**
+        1. **Task Routing:** Determine which sub-agent (Financial, News, or Search) is best suited 
+           to handle each user query based on intent and context.
+        2. **Delegation:** Forward the request to the appropriate sub-agent and wait for its result.
+        3. **Synthesis:** When multiple agents provide responses, summarize and merge their findings 
+           into a clear, concise, and accurate overall answer.
+        4. **Recency and Accuracy:** Prioritize the most up-to-date, verifiable data from sub-agents.
+        5. **Transparency:** Clearly identify which insights came from which sub-agent when relevant.
+        6. **Error Handling:** If a sub-agent fails or provides insufficient data, attempt fallback 
+           strategies such as rerouting the query or notifying the user.
+        7. **Clarity:** Always present the final response in a professional, well-structured, 
+           and easy-to-understand format.
+
+        ⚠️ Do **not** perform the underlying data analysis or external lookup yourself — 
+        ALWAYS delegate those tasks to the respective sub-agents.
         """
 
+        # --- Model setup ---
         GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
-        google_api_key = os.getenv('GOOGLE_API_KEY')
+        google_api_key = os.getenv("GOOGLE_API_KEY")
         gemini_client = AsyncOpenAI(base_url=GEMINI_BASE_URL, api_key=google_api_key)
-        gemini_model = OpenAIChatCompletionsModel(model="gemini-2.0-flash", openai_client=gemini_client) 
+        gemini_model = OpenAIChatCompletionsModel(
+            model="gemini-2.0-flash",
+            openai_client=gemini_client
+        )
 
-        # Create and return the configured agent
+        # --- Create orchestrator agent ---
         agent = Agent(
             name="AI Market Research Assistant",
             handoffs=handoffs,
             instructions=instructions.strip(),
-            model=gemini_model
+            model=gemini_model,
+            # input_guardrails=[
+            #     InputGuardrail(
+            #         name="Input Validation Guardrail",
+            #         guardrail_function=input_validation_guardrail,
+            #     )
+            # ],
         )
+
+        # Attach orchestration logic
+        agent.respond = lambda prompt: OrchestratorAgent.respond(prompt, handoffs, gemini_model)
         return agent
+
+    # ----------------------------------------------------------
+    # RESPONSE HANDLING + SELF-CORRECTION
+    # ----------------------------------------------------------
+    @staticmethod
+    async def respond(prompt: str, handoffs: list, model) -> str:
+        """
+        Routes prompt to the most relevant agent, retries if output seems irrelevant.
+        """
+        attempted_agents = set()
+
+        for attempt in range(OrchestratorAgent.MAX_RETRIES):
+            # Step 1: Route intelligently
+            chosen_agent = await OrchestratorAgent._route_to_agent(prompt, handoffs, attempted_agents)
+            if not chosen_agent:
+                return "⚠️ No available agent could handle this query."
+
+            print(f"🤖 Attempt {attempt+1}: Sending query to {chosen_agent.name}")
+
+            # Step 2: Run agent
+            try:
+                response = await chosen_agent.run(prompt)
+            except Exception as e:
+                print(f"⚠️ Agent {chosen_agent.name} failed: {e}")
+                attempted_agents.add(chosen_agent.name)
+                continue
+
+            # Step 3: Evaluate if relevant
+            if await OrchestratorAgent._is_relevant(prompt, response, model):
+                return f"✅ {chosen_agent.name} handled this successfully:\n\n{response}"
+
+            print(f"🔁 {chosen_agent.name}'s response deemed irrelevant. Re-routing...")
+            attempted_agents.add(chosen_agent.name)
+
+        return "⚠️ Could not find a relevant answer after multiple attempts."
+
+    # ----------------------------------------------------------
+    # ROUTING LOGIC
+    # ----------------------------------------------------------
+    @staticmethod
+    async def _route_to_agent(prompt: str, handoffs: list, attempted_agents: set):
+        """
+        Determines the best-fit agent for the given prompt.
+        Avoids previously tried agents.
+        """
+        lowered = prompt.lower()
+        available = [a for a in handoffs if a.name not in attempted_agents]
+
+        if not available:
+            return None
+
+        if any(k in lowered for k in ["finance", "stock", "market", "earnings"]):
+            return next((a for a in available if "financial" in a.name.lower()), available[0])
+        elif any(k in lowered for k in ["news", "headline", "press release"]):
+            return next((a for a in available if "news" in a.name.lower()), available[0])
+        elif any(k in lowered for k in ["search", "find", "lookup", "discover"]):
+            return next((a for a in available if "search" in a.name.lower()), available[0])
+        else:
+            # fallback — first available agent
+            return available[0]
+
+    # ----------------------------------------------------------
+    # LLM-BASED EVALUATOR
+    # ----------------------------------------------------------
+    @staticmethod
+    async def _is_relevant(prompt: str, response: str, model) -> bool:
+        """
+        Uses the model itself to check if the response matches the prompt intent.
+        """
+        eval_prompt = f"""
+        You are an evaluator checking multi-agent responses.
+        User asked: "{prompt}"
+        Agent responded: "{response}"
+
+        Does this response accurately and completely answer the user's intent?
+        Reply with only 'yes' or 'no'.
+        """
+        try:
+            eval_result = await model.run(eval_prompt)
+            print(f"🧠 Evaluation result: {eval_result}")
+            return "yes" in eval_result.lower()
+        except Exception as e:
+            print(f"⚠️ Evaluation failed: {e}")
+            return False

appagents/SearchAgent.py

@@ -1,6 +1,5 @@
 from tools.google_tools import GoogleTools
 from tools.time_tools import TimeTools
-from agents import Agent, WebSearchTool # Assuming WebSearchTool is the same as GoogleTools
 import os
 from agents import Agent, OpenAIChatCompletionsModel
 from openai import AsyncOpenAI

requirements.txt

@@ -1,11 +1,11 @@
-openai>=1.85.0
+openai>=2.6.1
     # via
     #   agents (pyproject.toml)
     #   autogen-ext
     #   langchain-openai
     #   openai-agents
     #   semantic-kernel
-openai-agents>=0.0.17
+openai-agents>=0.4.2
     # via agents (pyproject.toml)
 python-dotenv>=1.0.1
 requests>=2.31.0

ui/app.py

@@ -9,6 +9,8 @@ sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
 from appagents.OrchestratorAgent import OrchestratorAgent
 from agents import Runner, trace, SQLiteSession
+from agents.exceptions import InputGuardrailTripwireTriggered
+
 
 # -----------------------------
 # Load predefined prompts
@@ -165,20 +167,39 @@ if "auto_send_prompt" not in st.session_state:
     st.session_state.auto_send_prompt = None
 
 # Create (or reuse) a persistent SQLite session
+import uuid
+
+# Generate a unique session ID for this browser session
+if "ai_session_id" not in st.session_state:
+    st.session_state.ai_session_id = str(uuid.uuid4())
+
+session_id = st.session_state.ai_session_id
+
+# Create a unique SQLite session per user
 if "ai_session" not in st.session_state:
-    st.session_state.ai_session = SQLiteSession("conversation_123")
+    st.session_state.ai_session = SQLiteSession(f"conversation_{session_id}.db")
 
 session = st.session_state.ai_session
 
 
+
 # -----------------------------
 # Async AI response
 # -----------------------------
 async def get_ai_response(prompt: str) -> str:
-    agent = OrchestratorAgent.create()
-    with trace("Chatbot Search Agent Run"):
-        result = await Runner.run(agent, prompt, session=session)
-        return result.final_output
+    try:
+        agent = OrchestratorAgent.create()
+        with trace("Chatbot Search Agent Run"):
+            result = await Runner.run(agent, prompt, session=session)
+            return result.final_output
+    except InputGuardrailTripwireTriggered as e:
+        reasoning = getattr(e, "reasoning", None) \
+            or getattr(getattr(e, "output", None), "reasoning", None) \
+            or getattr(getattr(e, "guardrail_output", None), "reasoning", None) \
+            or "Guardrail triggered, but no reasoning provided."
+
+        return f"⚠️ Guardrail Blocked Input:\n\n**Reason:** {reasoning}"
+
 
 # -----------------------------
 # Desktop Sidebar Quick Prompts