Upload folder using huggingface_hub

Dockerfile

@@ -21,7 +21,7 @@ COPY uv.lock .
 
 # Copy required folders
 COPY common/ ./common/
-COPY src/chatbot/ ./src/chatbot/
+COPY src/chatbot_v2/ ./src/chatbot_v2/
 
 # Install dependencies using uv, then export and install with pip to system
 RUN uv sync --frozen --no-dev && \
@@ -32,4 +32,4 @@ COPY run.py .
 
 EXPOSE 7860
 
-CMD ["python", "run.py", "chatbot", "--port", "7860"]
+CMD ["python", "run.py", "chatbot_v2", "--port", "7860"]

pyproject.toml

@@ -33,6 +33,16 @@ dependencies = [
     "html2text>=2025.4.15",
     "traceloop-sdk>=0.33.0",
 
+    # =======================
+    # MICROSOFT AGENT FRAMEWORK
+    # =======================
+    #"agent-framework==1.0.0b251204",
+    #"agent-framework-azure-ai==1.0.0b251204",
+    #"azure-ai-projects",
+    #"azure-ai-agents",
+    #"azure-ai-agents>=1.2.0b5",
+    #"agent-framework-azure-ai",
+
     # =======================
     # VECTOR DB / INDEXING
     # =======================
@@ -94,6 +104,11 @@ dependencies = [
     "reportlab>=4.4.5",
     "fastapi",
     "Pillow",
+    "python-docx",
+    "matplotlib",
+    "fpdf",
+    "extra-streamlit-components",
+    "nest_asyncio",
 
     # =======================
     # AUDIO / VIDEO

run.py

@@ -58,6 +58,11 @@ APP_REGISTRY: Dict[str, Dict[str, str]] = {
         "entry": "app.py",
         "description": "General Chatbot - Multi-purpose conversational AI"
     },
+    "chatbot_v2": {
+        "path": "src/chatbot_v2",
+        "entry": "app.py",
+        "description": "Layered Chatbot (ReAct) - Advanced Architecture"
+    },
     "accessibility": {
         "path": "src/accessibility",
         "entry": "app.py",
@@ -77,6 +82,11 @@ APP_REGISTRY: Dict[str, Dict[str, str]] = {
         "path": "src/image-generator",
         "entry": "app.py",
         "description": "Image Generator - Multi-agent image generation tool"
+    },
+    "interview-assistant": {
+        "path": "src/interview-assistant",
+        "entry": "app.py",
+        "description": "Interview Assistant - Multi-agent interview tool"
     }
 }
 

src/chatbot_v2/Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.12-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    DEBIAN_FRONTEND=noninteractive \
+    PYTHONPATH=/app:/app/common:$PYTHONPATH
+
+WORKDIR /app
+
+# System deps
+RUN apt-get update && apt-get install -y \
+    git build-essential curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install uv
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
+ENV PATH="/root/.local/bin:$PATH"
+
+# Copy project metadata
+COPY pyproject.toml .
+COPY uv.lock .
+
+# Copy required folders
+COPY common/ ./common/
+COPY src/chatbot_v2/ ./src/chatbot_v2/
+
+# Install dependencies using uv, then export and install with pip to system
+RUN uv sync --frozen --no-dev && \
+    uv pip install -e . --system
+
+# Copy entry point
+COPY run.py .
+
+EXPOSE 7860
+
+CMD ["python", "run.py", "chatbot_v2", "--port", "7860"]

src/chatbot_v2/README.md

@@ -0,0 +1,223 @@
+---
+title: AI Chatbot
+emoji: 🤖
+colorFrom: pink
+colorTo: yellow
+sdk: docker
+sdk_version: "0.0.1"
+app_file: app.py
+pinned: false
+license: mit
+tags:
+  - text-generation
+  - agentic-ai
+  - openai-sdk
+short_description: An Experimental Agentic Chatbot (uses OpenAI Agent SDK)
+---
+
+# AI Chatbot
+
+This is an experimental chatbot for chatting with AI. It is equipped with agents & tools to give you realtime data from the web. It uses **OpenAI - SDK** and **OpenAI - Agents**...
+
+## Features
+- Predefined prompts for quick analysis
+- Chat interface with AI responses
+- Enter key support and responsive design
+- Latest messages appear on top
+
+## Usage
+1. Type a message or select a predefined prompt
+2. Press **Enter** or click **Send**
+3. AI responses appear instantly in the chat interface
+
+## Supported APIs
+- OpenAI
+- Google
+- GROQ
+- SERPER
+- News API
+
+## 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
+
+## Project Folder Structure
+
+```
+chatbot/
+├── app.py                    # Main Streamlit chatbot interface
+├── appagents/
+│   ├── __init__.py               # Package initialization
+│   ├── OrchestratorAgent.py      # Main orchestrator - coordinates all agents
+│   ├── FinancialAgent.py         # Financial data and analysis agent
+│   ├── NewsAgent.py              # News retrieval and summarization agent
+│   ├── SearchAgent.py            # General web search agent
+│   └── InputValidationAgent.py   # Input validation and sanitization agent
+├── core/
+│   ├── __init__.py               # Package initialization
+│   └── logger.py                 # Centralized logging configuration
+├── tools/
+│   ├── __init__.py               # Package initialization
+│   ├── google_tools.py           # Google search API wrapper
+│   ├── yahoo_tools.py            # Yahoo Finance API wrapper
+│   ├── news_tools.py             # News API wrapper
+│   └── time_tools.py             # Time-related utility functions
+├── prompts/
+│   ├── economic_news.txt         # Prompt for economic news analysis
+│   ├── market_sentiment.txt      # Prompt for market sentiment analysis
+│   ├── news_headlines.txt        # Prompt for news headline summarization
+│   ├── trade_recommendation.txt  # Prompt for trade recommendations
+│   └── upcoming_earnings.txt     # Prompt for upcoming earnings alerts
+├── Dockerfile                     # Docker configuration for container deployment
+├── pyproject.toml                 # Project metadata and dependencies (copied from root)
+├── uv.lock                        # Locked dependency versions (copied from root)
+├── README.md                      # Project documentation
+└── run.py                         # Script to run the application locally
+```
+
+## File Descriptions
+
+### UI Layer
+- **app.py** - Main Streamlit chatbot interface that provides:
+  - Chat message display with user and AI messages
+  - Text input for user queries
+  - Predefined prompt buttons for quick analysis
+  - Real-time AI responses
+  - Support for Enter key submission
+  - Responsive design with latest messages appearing first
+
+### Agents (`appagents/`)
+- **OrchestratorAgent.py** - Main orchestrator that:
+  - Coordinates communication between all specialized agents
+  - Routes user queries to appropriate agents
+  - Manages conversation flow and context
+  - Integrates tool responses
+
+- **FinancialAgent.py** - Financial data and analysis:
+  - Retrieves stock prices and financial metrics
+  - Performs financial analysis using Yahoo Finance API
+  - Provides market insights and recommendations
+  - Integrates with yahoo_tools for data fetching
+
+- **NewsAgent.py** - News retrieval and summarization:
+  - Fetches latest news articles
+  - Summarizes news content
+  - Integrates with News API for real-time updates
+  - Provides news-based market insights
+
+- **SearchAgent.py** - General web search:
+  - Performs web searches for general queries
+  - Integrates with Google Search / Serper API
+  - Returns relevant search results
+  - Supports multi-source data gathering
+
+- **InputValidationAgent.py** - Input validation:
+  - Sanitizes user input
+  - Validates query format and content
+  - Prevents malicious inputs
+  - Ensures appropriate content
+
+### Core Utilities (`core/`)
+- **logger.py** - Centralized logging configuration:
+  - Provides consistent logging across agents
+  - Handles different log levels
+  - Formats log messages for clarity
+
+### Tools (`tools/`)
+- **google_tools.py** - Google Search API wrapper:
+  - Executes web searches via Google Search / Serper API
+  - Parses and returns search results
+  - Handles API authentication
+
+- **yahoo_tools.py** - Yahoo Finance API integration:
+  - Retrieves stock price data
+  - Fetches financial metrics and indicators
+  - Provides historical price data
+  - Returns earnings information
+
+- **news_tools.py** - News API integration:
+  - Fetches latest news articles
+  - Filters news by category and keywords
+  - Returns news headlines and summaries
+  - Provides market-related news feeds
+
+- **time_tools.py** - Time utility functions:
+  - Provides current time information
+  - Formats timestamps
+  - Handles timezone conversions
+
+### Prompts (`prompts/`)
+Predefined prompts for specialized analysis:
+- **economic_news.txt** - Analyzes economic news and implications
+- **market_sentiment.txt** - Analyzes market sentiment trends
+- **news_headlines.txt** - Summarizes and explains news headlines
+- **trade_recommendation.txt** - Provides trading recommendations
+- **upcoming_earnings.txt** - Alerts about upcoming earnings reports
+
+### Configuration Files
+- **Dockerfile** - Container deployment:
+  - Builds Docker image with Python 3.12
+  - Installs dependencies using `uv`
+  - Sets up Streamlit server on port 8501
+  - Configures PYTHONPATH for module imports
+
+- **pyproject.toml** - Project metadata:
+  - Package name: "agents"
+  - Python version requirement: 3.12
+  - Lists all dependencies (OpenAI, LangChain, Streamlit, etc.)
+
+- **uv.lock** - Dependency lock file:
+  - Ensures reproducible builds
+  - Pins exact versions of all dependencies
+
+## Key Technologies
+
+| Component | Technology | Purpose |
+|-----------|-----------|---------|
+| LLM Framework | OpenAI Agents | Multi-agent orchestration |
+| Chat Interface | Streamlit | User interaction and display |
+| Web Search | Google Search / Serper API | Web search results |
+| Financial Data | Yahoo Finance API | Stock prices and metrics |
+| News Data | News API | Latest news articles |
+| Async Operations | AsyncIO | Parallel agent execution |
+| Dependencies | UV | Fast Python package management |
+| Containerization | Docker | Cloud deployment |
+
+## Predefined Prompts
+
+The chatbot includes quick-access buttons for common analysis:
+
+1. **Economic News** - Analyzes current economic trends and news
+2. **Market Sentiment** - Provides market sentiment analysis
+3. **News Headlines** - Summarizes latest news headlines
+4. **Trade Recommendation** - Suggests trading strategies
+5. **Upcoming Earnings** - Lists upcoming company earnings
+
+## Running Locally
+
+```bash
+# Install dependencies
+uv sync
+
+# Set environment variables defined in .env.name file
+export OPENAI_API_KEY="your-key"
+export SERPER_API_KEY="your-key"
+export NEWS_API_KEY="your-key"
+
+# Run the Streamlit app (from the root)
+python run.py chatbot
+```
+
+## Deployment
+
+The project is deployed on Hugging Face Spaces as a Docker container:
+- **Space**: https://huggingface.co/spaces/mishrabp/chatbot-app
+- **URL**: https://mishrabp-chatbot-app.hf.space
+- **Trigger**: Automatic deployment on push to `main` branch
+- **Configuration**: `.github/workflows/chatbot-app-hf.yml`

src/chatbot_v2/app.py

@@ -0,0 +1,274 @@
+import os
+import glob
+import uuid
+import asyncio
+import logging
+import streamlit as st
+
+# Import the new Orchestrator Pattern
+from src.chatbot_v2.patterns.orchestrator import ChatbotOrchestrator
+
+# -----------------------------
+# Configuration & Utils
+# -----------------------------
+st.set_page_config(
+    page_title="Layered AI Assistant",
+    layout="wide",
+    page_icon="🧠"
+)
+
+def load_prompts(folder="prompts"):
+    prompts = []
+    prompt_labels = []
+    if os.path.exists(folder):
+        for file_path in glob.glob(os.path.join(folder, "*.txt")):
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read().strip()
+                if content:
+                    prompts.append(content)
+
+            prompt_labels.append(os.path.basename(file_path).replace("_", " ").replace(".txt", "").title())
+    return prompts, prompt_labels
+
+prompts, prompt_labels = load_prompts()
+
+# -----------------------------
+# Session State
+# -----------------------------
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Initialize the Agent
+if "agent" not in st.session_state:
+    st.session_state.agent = ChatbotOrchestrator()
+
+# -----------------------------
+# Premium Styling
+# -----------------------------
+st.markdown("""
+<style>
+    /* ---------------------------------------------------------------------
+       1. GLOBAL & RESET
+       --------------------------------------------------------------------- */
+    * {
+        box-sizing: border-box;
+    }
+    
+    .stApp, [data-testid="stAppViewContainer"] {
+        /* Standard Streamlit background */
+        background-color: #f8f9fa;
+        font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji';
+    }
+    
+    html {
+        -webkit-text-size-adjust: 100%; /* Prevent iOS font boosting */
+    }
+    
+    /* ---------------------------------------------------------------------
+       2. LAYOUT & HERO BANNER
+       --------------------------------------------------------------------- */
+    
+    /* Mobile font optimization */
+    @media (max-width: 768px) {
+        /* Target all markdown text specifically */
+        .stMarkdown p, .stMarkdown li, .stChatMessage p, .message-content, .stDataFrame, .stTable {
+            font-size: 16px !important;
+            line-height: 1.6 !important;
+            color: #1a1a1a !important;
+        }
+        
+        h1, h2, h3, h4, h5, h6 {
+            color: #1a1a1a !important;
+        }
+    }
+    
+    /* Desktop Layout */
+    @media (min-width: 769px) {
+        .block-container {
+            padding-top: 0 !important;
+            padding-bottom: 2rem !important;
+            padding-left: 5rem !important;
+            padding-right: 5rem !important;
+            max-width: 100% !important;
+        }
+        
+        .hero-container {
+            margin-top: -3rem;
+            margin-left: -5rem;
+            margin-right: -5rem;
+            /* Simple negative margins to pull edge-to-edge */
+            padding: 2.5rem 1rem 2rem 1rem; /* Compact desktop padding */
+        }
+    }
+    
+    /* Mobile Layout */
+    @media (max-width: 768px) {
+        .block-container {
+            padding-left: 1rem !important;
+            padding-right: 1rem !important;
+            padding-top: 0 !important;
+            padding-bottom: 0rem !important;
+        }
+        
+        .hero-container {
+            margin-top: -2rem;
+            margin-left: -1rem;
+            margin-right: -1rem;
+            /* Break out of the 1rem padding */
+            padding: 2rem 1rem 1.5rem 1rem; /* Compact mobile padding */
+            border-radius: 0 0 12px 12px;
+        }
+    }
+
+    /* Hero Styling */
+    .hero-container {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        text-align: center;
+        border-radius: 0 0 16px 16px;
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        margin-bottom: 2rem;
+    }
+
+    .hero-title {
+        font-size: 2rem; /* Slightly smaller */
+        font-weight: 700;
+        margin-bottom: 0.25rem;
+        color: white !important;
+    }
+    .hero-subtitle {
+        font-size: 1rem;
+        opacity: 0.95;
+        font-weight: 400;
+        color: rgba(255,255,255,0.95) !important;
+    }
+    
+    /* Remove Header Decoration */
+    header[data-testid="stHeader"] {
+        background-color: transparent !important;
+        height: 0 !important;
+        z-index: 100;
+    }
+    div[data-testid="stDecoration"] { display: none; }
+    
+    /* ---------------------------------------------------------------------
+       3. COMPONENT STYLING (Healthcare-like)
+       --------------------------------------------------------------------- */
+    
+    /* Chat Bubbles - Clean & Readable */
+    .stChatMessage {
+        background-color: white;
+        border-radius: 12px;
+        border: 1px solid #e5e5e5;
+        box-shadow: 0 1px 2px rgba(0,0,0,0.05);
+        padding: 1rem;
+    }
+    
+    .stChatMessage[data-testid="stChatMessage"]:nth-of-type(odd) {
+         background-color: #f8f9fa;
+    }
+    
+    /* Input Fields */
+    .stTextInput input {
+        border-radius: 20px; /* Matching healthcare-assistant roundness */
+        border: 1px solid #ddd;
+        padding: 0.75rem 1rem;
+    }
+    
+    /* Buttons */
+    .stButton button {
+        border-radius: 20px; /* Matching healthcare-assistant */
+        min-height: 48px;
+        font-weight: 500;
+    }
+
+    /* Sidebar */
+    section[data-testid="stSidebar"] {
+        background-color: #ffffff;
+        border-right: 1px solid #eaeaea;
+    }
+    
+    /* Minimize Sidebar Top Padding */
+    section[data-testid="stSidebar"] .block-container {
+        padding-top: 0rem !important;
+        padding-bottom: 0rem !important;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# -----------------------------
+# Logic
+# -----------------------------
+async def get_ai_response(prompt: str) -> str:
+    try:
+        agent: ChatbotOrchestrator = st.session_state.agent
+        
+        # We pass the *previous* history (messages excluding the latest one which we just appended)
+        # Actually, st.session_state.messages ALREADY has the new user message appended below.
+        # So we pass messages[:-1] as "history"
+        history = st.session_state.messages[:-1]
+        
+        result = await agent.run(user_input=prompt, external_history=history)
+        return result
+    except Exception as e:
+        return f"❌ **Error**: {str(e)}"
+
+# -----------------------------
+# Sidebar - Quick Actions
+# -----------------------------
+with st.sidebar:
+    st.markdown("### ⚡ Quick Starters")
+    st.markdown("Select a prompt to start:")
+    
+    # We use a trick with st.button to act as input triggers
+    # If a button is clicked, we'll handle it in the main loop logic
+    selected_prompt = None
+    for idx, prompt_text in enumerate(prompts):
+        label = prompt_labels[idx] if idx < len(prompt_labels) else f"Prompt {idx+1}"
+        if st.button(label, key=f"sidebar_btn_{idx}", use_container_width=True):
+            # Reset conversation
+            st.session_state.messages = []
+            st.session_state.agent = ChatbotOrchestrator() # Reset agent memory too
+            selected_prompt = prompt_text
+
+    st.markdown("---")
+    if st.button("🗑️ Clear Conversation", use_container_width=True):
+        st.session_state.messages = []
+        st.session_state.agent = ChatbotOrchestrator()
+        st.rerun()
+
+# -----------------------------
+# Main Content
+# -----------------------------
+
+# Hero Banner (Always visible & Sticky)
+st.markdown("""
+    <div class="hero-container" role="banner">
+        <div class="hero-title">🧠 Layered AI Agent</div>
+        <div class="hero-subtitle">Architecture: Perception ➜ Cognition ➜ Action</div>
+    </div>
+""", unsafe_allow_html=True)
+
+# Display Chat History
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"], unsafe_allow_html=True)
+
+# Chat Input Handling
+# We handle both the chat input widget and the sidebar selection here
+if prompt := (st.chat_input("Type your message...") or selected_prompt):
+    # User Message
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    # Assistant Response
+    with st.chat_message("assistant"):
+        with st.spinner("🧠 Thinking (Layers Active)..."):
+            response_text = asyncio.run(get_ai_response(prompt))
+            st.markdown(response_text, unsafe_allow_html=True)
+
+    st.session_state.messages.append({"role": "assistant", "content": response_text})
+    
+    if selected_prompt:
+        st.rerun()

src/chatbot_v2/core/__init__.py

@@ -0,0 +1,4 @@
+
+from .model import get_model_client
+
+__all__ = ["get_model_client"]

src/chatbot_v2/core/model.py

@@ -0,0 +1,36 @@
+from common.utility.openai_model_factory  import OpenAIModelFactory
+
+def get_model_client(provider:str = "openai"):
+    if provider.lower() == "google":
+        return OpenAIModelFactory.get_model(
+            provider="google",
+            model_name="gemini-2.5-flash",
+            temperature=0
+    )
+    elif provider.lower() == "openai":
+        return OpenAIModelFactory.get_model(
+            provider="openai",
+            model_name="gpt-4o-mini",
+            temperature=0
+    )
+    elif provider.lower() == "azure":
+        return OpenAIModelFactory.get_model(
+            provider="azure",
+            model_name="gpt-4o-mini",
+            temperature=0
+    )
+    elif provider.lower() == "groq":
+        return OpenAIModelFactory.get_model(
+            provider="groq",
+            model_name="gpt-4o-mini",
+            temperature=0
+    )
+    elif provider.lower() == "ollama":
+        return OpenAIModelFactory.get_model(
+            provider="ollama",
+            model_name="gpt-4o-mini",
+            temperature=0
+    )
+    else: 
+        raise  ValueError(f"Unsupported provider: {provider}")
+

src/chatbot_v2/layers/action.py

@@ -0,0 +1,71 @@
+import asyncio
+from typing import Any, Dict, List
+from agents import Runner
+from common.aagents.search_agent import search_agent
+from common.aagents.news_agent import news_agent
+from common.aagents.yf_agent import yf_agent
+
+class ActionLayer:
+    """
+    The 'Hands' of the agent.
+    Responsibility: Execute specific, well-defined tools or side-effects.
+    Does NOT reason about 'why'.
+    """
+    
+    def __init__(self):
+        # Register available tools
+        self.tools = {
+            "web_search": self._tool_web_search,
+            "financial_data": self._tool_financial_data,
+            "news_search": self._tool_news_search,
+            "broadcast_research": self._tool_broadcast_research
+        }
+    
+    async def execute(self, tool_name: str, args: Dict[str, Any]) -> str:
+        if tool_name not in self.tools:
+            return f"Error: Tool '{tool_name}' not found."
+        
+        print(f"[Action] Executing tool: {tool_name} with args: {args}")
+        try:
+            return await self.tools[tool_name](**args)
+        except Exception as e:
+            return f"Error executing {tool_name}: {str(e)}"
+
+    async def _tool_web_search(self, query: str) -> str:
+        result = await Runner.run(search_agent, query)
+        return f"Web Search Result:\n{result.final_output}"
+
+    async def _tool_financial_data(self, query: str) -> str:
+        result = await Runner.run(yf_agent, query)
+        return f"Financial Data:\n{result.final_output}"
+
+    async def _tool_news_search(self, query: str) -> str:
+        result = await Runner.run(news_agent, query)
+        return f"News Result:\n{result.final_output}"
+
+    async def _tool_broadcast_research(self, query: str, include_finance: bool = True, include_news: bool = True, include_search: bool = True) -> str:
+        """
+        Broadcasts the search query to selected specialized agents in parallel and aggregates their responses.
+        """
+        active_agents = []
+        if include_finance: active_agents.append(("YahooFinanceAgent", Runner.run(yf_agent, query)))
+        if include_news: active_agents.append(("NewsAgent", Runner.run(news_agent, query)))
+        if include_search: active_agents.append(("WebSearchAgent", Runner.run(search_agent, query)))
+
+        if not active_agents:
+            return "No agents were selected for this query."
+
+        # Run in parallel
+        agent_names = [name for name, _ in active_agents]
+        coroutines = [coro for _, coro in active_agents]
+        
+        results = await asyncio.gather(*coroutines, return_exceptions=True)
+        
+        outputs = []
+        for name, res in zip(agent_names, results):
+            if isinstance(res, Exception):
+                outputs.append(f"❌ {name} Error: {str(res)}")
+            else:
+                outputs.append(f"✅ {name} Report:\n{res.final_output}")
+                
+        return "\n--- START OF AGENT REPORTS ---\n\n" + "\n\n-----------------------------------\n\n".join(outputs) + "\n\n--- END OF AGENT REPORTS ---"

src/chatbot_v2/layers/cognition.py

@@ -0,0 +1,111 @@
+import json
+import os
+from typing import List, Dict, Optional
+from common.utility.openai_model_factory import OpenAIModelFactory
+from openai import OpenAI, AsyncOpenAI
+
+class CognitiveOutput:
+    def __init__(self, thought: str, action: Optional[str] = None, action_input: Optional[Dict] = None, final_answer: Optional[str] = None):
+        self.thought = thought
+        self.action = action
+        self.action_input = action_input
+        self.final_answer = final_answer
+
+class CognitionLayer:
+    """
+    The 'Brain' of the agent.
+    Uses OpenAI GPT-4o (via OpenAIModelFactory) to reason and decide which tools to use.
+    """
+    
+    
+    def __init__(self):
+        # Direct OpenAI client usage for maximum compatibility
+        # We circumvent the factory wrapper to access the raw client directly for JSON mode
+        api_key = os.environ.get("OPENAI_API_KEY")
+        self.client = OpenAI(api_key=api_key) if api_key else None
+        
+        # If we wanted to use the factory strictly, we'd need to know the exact internal attribute
+        # self.model_wrapper = OpenAIModelFactory.get_model(...)
+        # self.client = self.model_wrapper.client  # guessing 'client' vs 'openai_client'
+        # But to be safe and fix the user's error immediately:
+        from openai import AsyncOpenAI
+        self.client = AsyncOpenAI(api_key=api_key)
+
+        self.model_name = "gpt-4o"
+        
+        self.system_prompt = """
+You are the **AI Chat Orchestrator**. 
+Your goal is to provide a comprehensive, multi-perspective answer by synthesizing data from specialized sub-agents.
+
+**Available Tools**:
+1. `broadcast_research(query: str, include_finance: bool, include_news: bool, include_search: bool)`: 
+   Broadcasts the query to specialized agents (Finance, News, Web Search). Use this for complex queries needing external info.
+2. `web_search(query: str)`: Single web search.
+3. `financial_data(query: str)`: Single financial check.
+4. `news_search(query: str)`: Single news check.
+
+**Workflow**:
+1.  **Analyze Request**: Understand the user's question.
+2.  **Determine Needs**: Decide calls are needed.
+    *   **Finance**: For stock prices, market trends, company financials.
+    *   **News**: For recent events, headlines.
+    *   **Web Search**: For general knowledge, history.
+3.  **Action**: 
+    If you need external info, PREFER `broadcast_research` to query multiple sources in parallel.
+    If it's a simple greeting or general chat not requiring data, just answer.
+4.  **Synthesize Results**: 
+    When you receive tool outputs ("Agent Reports"), combine them into a clear, professional summary.
+    Do NOT simply paste the reports. Synthesize them.
+
+**Output Format**:
+You must output valid JSON only:
+{
+  "thought": "Reasoning...",
+  "action": "tool_name_or_null",
+  "action_input": { "arg": "value" } or null,
+  "final_answer": "Final output to user" or null
+}
+"""
+
+    async def decide(self, history: List[Dict[str, str]]) -> CognitiveOutput:
+        # 1. Construct Messages
+        messages = [{"role": "system", "content": self.system_prompt}]
+        
+        for entry in history:
+            role = entry['role']
+            content = entry['content']
+            
+            # Map roles. 'system' in our history layer usually means tool output.
+            if role == 'user':
+                messages.append({"role": "user", "content": content})
+            elif role == 'assistant':
+                messages.append({"role": "assistant", "content": content})
+            elif role == 'system':
+                messages.append({"role": "user", "content": f"Observation/Tool Output: {content}"})
+
+        # 2. Call LLM (Async)
+        try:
+            completion = await self.client.chat.completions.create(
+                model=self.model_name,
+                messages=messages,
+                response_format={"type": "json_object"}
+            )
+            
+            response_text = completion.choices[0].message.content
+            if response_text.startswith("```"):
+                response_text = response_text.strip("`").replace("json", "").strip()
+
+            data = json.loads(response_text)
+            
+            return CognitiveOutput(
+                thought=data.get("thought", ""),
+                action=data.get("action"),
+                action_input=data.get("action_input"),
+                final_answer=data.get("final_answer")
+            )
+            
+        except Exception as e:
+            return CognitiveOutput(
+                thought=f"Error: {str(e)}",
+                final_answer="I encountered an error processing your request."
+            )

src/chatbot_v2/layers/memory.py

@@ -0,0 +1,20 @@
+from typing import List, Dict
+
+class MemoryLayer:
+    """
+    The 'Memory' of the agent.
+    Responsibility: Store and retrieve conversation history.
+    """
+    
+    def __init__(self):
+        self.history: List[Dict[str, str]] = []
+
+    def add_entry(self, role: str, content: str):
+        self.history.append({"role": role, "content": content})
+
+    def get_history(self) -> List[Dict[str, str]]:
+        return self.history
+    
+    def set_history(self, messages: List[Dict[str, str]]):
+        """Allows initializing/overwriting memory from external source (e.g. Streamlit session)"""
+        self.history = messages

src/chatbot_v2/layers/perception.py

@@ -0,0 +1,79 @@
+import json
+import os
+import datetime
+from dataclasses import dataclass
+from openai import OpenAI
+
+@dataclass
+class EnvironmentState:
+    user_input: str
+    timestamp: str
+    source: str
+
+class PerceptionLayer:
+    """
+    The 'Sensors' of the agent. 
+    Responsibility: Accept raw data, clean it, validate it (Guardrails), and package it.
+    """
+    
+    def __init__(self):
+         api_key = os.environ.get("OPENAI_API_KEY")
+         self.client = OpenAI(api_key=api_key) if api_key else None
+         self.model_name = "gpt-4o"
+    
+    def perceive(self, raw_text: str, source: str = "user_input") -> EnvironmentState:
+        # 1. Basic Cleaning
+        clean_text = raw_text.strip()
+        
+        # 2. Guardrail Check (Input Validation)
+        # We run this BEFORE accepting the input into the system state.
+        if self.client and clean_text:
+            validation = self._run_guardrail(clean_text)
+            if not validation["is_valid"]:
+                raise ValueError(f"Guardrail tripped: {validation['reasoning']}")
+
+        return EnvironmentState(
+            user_input=clean_text,
+            timestamp=datetime.datetime.now().isoformat(),
+            source=source
+        )
+
+    def _run_guardrail(self, text: str) -> dict:
+        """
+        Validates if logic contains unparliamentary language.
+        """
+        system_prompt = """
+        You are a highly efficient Guardrail Agent. 
+        
+        **Goal**: Validate that the user input is safe and polite.
+        
+        **PASS / VALID Criteria**:
+        - The input is technical, professional, or casual.
+        - The input contains complex instructions, code features, or formatting instructions.
+        - The input is a valid request for information or action.
+        
+        **FAIL / INVALID Criteria**:
+        - The input contains HATE SPEECH, EXPLICIT PROFANITY, or THREATS.
+        - The input is aggressive, insulting, or unparliamentary.
+        
+        **Output Format**:
+        Return JSON only: { "is_valid": boolean, "reasoning": string }
+        
+        If unsure, lean towards VALID.
+        """
+        
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": text}
+                ],
+                response_format={"type": "json_object"}
+            )
+            content = response.choices[0].message.content
+            return json.loads(content)
+        except Exception as e:
+            # On failure, fail open or closed? Let's log and allow for now to prevent blocking on API errors.
+            print(f"Guardrail check failed: {e}")
+            return {"is_valid": True, "reasoning": "Guardrail check failed, allowing input."}

src/chatbot_v2/patterns/orchestrator.py

@@ -0,0 +1,66 @@
+from src.chatbot_v2.layers.perception import PerceptionLayer
+from src.chatbot_v2.layers.cognition import CognitionLayer, CognitiveOutput
+from src.chatbot_v2.layers.action import ActionLayer
+from src.chatbot_v2.layers.memory import MemoryLayer
+from typing import List, Dict
+
+class ChatbotOrchestrator:
+    """
+    DESIGN PATTERN: ReAct (Reason + Act) - Orchestrator
+    
+    Structure:
+    1. Loop:
+       - Update Perception
+       - Consult Cognition (Reasoning)
+       - If Action needed -> Call Action Layer -> Loop
+       - If Final Answer -> Return
+    """
+    
+    def __init__(self):
+        # Initialize the 'Organs' (Layers)
+        self.perception = PerceptionLayer()
+        self.brain = CognitionLayer()
+        self.hands = ActionLayer()
+        self.memory = MemoryLayer()
+        
+    async def run(self, user_input: str, external_history: List[Dict[str, str]] = None):
+        """
+        Runs the agent loop.
+        Args:
+            user_input: The new message from the user.
+            external_history: Existing chat history (e.g. from Streamlit).
+        """
+        # 1. Sync Memory
+        if external_history:
+            self.memory.set_history(list(external_history)) # Copy
+        
+        # 2. Perception Layer (Input)
+        env_state = self.perception.perceive(user_input)
+        self.memory.add_entry("user", env_state.user_input)
+        
+        # Max steps to prevent infinite loops
+        for step in range(5):
+            print(f"\n--- Step {step+1} (ReAct Loop) ---")
+            
+            # 3. Cognition Layer (Reasoning)
+            history = self.memory.get_history()
+            decision: CognitiveOutput = await self.brain.decide(history)
+            
+            print(f"[Think]: {decision.thought}")
+            
+            # 4. Handling Decision
+            if decision.final_answer:
+                print(f"[Final Answer]: {decision.final_answer}")
+                self.memory.add_entry("assistant", decision.final_answer)
+                return decision.final_answer
+                
+            if decision.action:
+                # 5. Action Layer (Execution)
+                print(f"[Action Needed]: Call {decision.action} with {decision.action_input}")
+                tool_result = await self.hands.execute(decision.action, decision.action_input or {})
+                
+                # 6. Feedback Loop
+                print(f"[Observation]: {tool_result}")
+                self.memory.add_entry("system", f"Tool {decision.action} returned: {tool_result}")
+                
+        return "I apologize, but I got stuck in a loop trying to answer your request."

src/chatbot_v2/prompts/economic_news.txt

@@ -0,0 +1,27 @@
+##### Task
+Provide a concise update on **major economic indicators released recently** in USA.
+
+###### Include
+- **Interest Rates**: Latest central bank decisions, current policy rates, and forward guidance.
+- **Labor Market**: Unemployment rate, job creation figures, and key labor metrics (if available).
+- **Inflation**: CPI, PCE, or other inflation data with MoM and YoY changes.
+- **Growth Indicators**: GDP, PMIs, or industrial production released recently.
+- **Market Reaction**: Brief impact on equities, bonds, FX, and commodities.
+
+###### Guidelines
+- Compare results against forecasts and prior releases
+- Highlight notable surprises and their implications
+- Keep the summary brief, factual, and structured
+- **Always retrieve numerical data from primary or authoritative sources**
+
+###### Fallback
+- If no relevant data was released recently, explicitly state **“No major economic indicators were released during this period.”**
+- If data is partially unavailable, summarize what is available and clearly note missing indicators.
+- Do not infer or fabricate numbers under any circumstance.
+
+###### Output Style
+- Concise, factual, and well-structured
+- Use clear bullet points or short paragraphs
+- Avoid speculation unless explicitly labeled as interpretation
+- **Cite data sources clearly**
+- Use color and emoji to make it more engaging.

src/chatbot_v2/prompts/entertainment_updates.txt

@@ -0,0 +1,26 @@
+##### Task
+Provide the **top 5 recent movie or series updates** that are trending or newly released in USA.
+
+###### For each title, include:
+- **Title in bold** and optionally use **color or emojis** to make it fun (e.g., 🎬, 🍿, 🌟)  
+- A **short, 2–3 line snippet** that generates excitement or humor about the plot, cast, or vibe  
+- **Platform or source** where it can be watched (Netflix, Prime, Disney+, etc.)  
+- **Release date or premiere date**  
+
+###### Requirements / Guidelines
+- Focus on **recent releases** (last 2–4 weeks) or currently trending content  
+- Keep the tone **fun, witty, and engaging**, like a friend recommending a show  
+- Use **emojis liberally** to emphasize excitement, genre, or humor
+- Call out the **main actors and actresses** to build the interest  
+- Where possible, add a **light humorous quip or pun** about the movie/series  
+- If color is supported, use HTML span tags, e.g., `<span style="color:orange">Title</span>` for emphasis
+
+###### Fallback
+- If fewer than 5 titles are available, provide what is available and indicate:  
+  **“Only X recent releases found.”**  
+- Do not fabricate platforms or release dates — only use verified sources
+
+###### Output Style
+- List format (1–5) sorted by **popularity or release date**  
+- **Title + snippet + watch source + release date** per entry  
+- Use **color, emojis, and humor** to make the output visually appealing and fun to read

src/chatbot_v2/prompts/india_news.txt

@@ -0,0 +1,26 @@
+##### Task
+Tell me the **top 3 headlines from India**.
+
+###### For each headline, provide:
+- **Title in bold**
+- A **3‑line summary**
+- **Publish date and time**
+- A **link to the exact source URL**
+
+###### Requirements
+- Use authoritative news sources (e.g., major national/regional news outlets)
+- Headlines should be **recent (last 24 hours)**
+- Provide timestamps in **UTC**
+- If publish date/time is not available, indicate “Date/Time not provided”
+
+###### Fallback
+- If fewer than 3 headlines are found, provide what is available and state:
+  **“Only X recent headlines found for India.”**
+- Do not fabricate headlines, dates, or URLs
+
+###### Output Style
+- Structured list sorted by **most recent first**
+- Clear and concise formatting as requested
+- Use color and emoji to make it more engaging.
+- Use `<span style="color:...">` for coloring the title if the renderer supports it
+- Keep the output **concise, factual, and visually engaging**

src/chatbot_v2/prompts/market_sentiment.txt

@@ -0,0 +1,34 @@
+##### Task
+Act as a **Senior Market Analyst** and provide a concise market sentiment update for the **US Stock Market / S&P 500**.
+
+###### Steps
+1. **Data Gathering**: Search for the **top 5 financial news headlines** from the last 24 hours related to the [US Stock Market / S&P 500].
+2. **Market Check**: Retrieve the **current value** and **today’s percentage change** for:
+   - **S&P 500 (SPX)**
+   - **VIX (Volatility Index)**
+3. **Synthesis**: Based on the **tone of the news headlines** and the **index performance**, determine whether the **current market sentiment** is:
+   - **Bullish**
+   - **Bearish**
+   - **Neutral**
+4. **Output**: Provide a:
+   - **Sentiment Score (1–10)**
+   - **Top 3 key drivers** influencing this sentiment
+
+###### Guidelines
+- Prioritize **reliable financial news sources** (e.g., Bloomberg, Reuters, WSJ, CNBC)
+- Use **accurate, real-time market data** for indices
+- Base sentiment on both **news tone** and **market movement**
+- Avoid subjective or unsupported judgments
+
+###### Fallback
+- If no relevant financial headlines are found in the last 24 hours, clearly state:  
+  **“No significant market news available in the last 24 hours.”**
+- If either index value or change is unavailable, report available data and note missing values explicitly
+- Do not invent or estimate values — only use verified data
+
+###### Output Style
+- Concise, factual, and structured
+- Use clear bullet points or short paragraphs
+- Include numerical values and data timestamps
+- Provide **sources for headlines and index data**
+- Use color and emoji to make it more engaging.

src/chatbot_v2/prompts/news_headlines.txt

@@ -0,0 +1,28 @@
+##### Task
+Tell me the **top 3 USA headlines**. Use **emojis** and, where supported, **HTML color tags** to make the output engaging.
+
+###### For each headline, provide:
+- **Title in bold** and optionally in color, e.g., `<span style="color:blue">Title</span>`  
+- A **3-line summary** with an emoji indicating the type of news:
+  - 📰 Politics
+  - 💼 Business
+  - 🌎 World
+  - ⚡ Breaking news
+- **Publish date and time** (UTC)
+- A **link to the exact source URL**
+
+###### Requirements
+- Use **credible news sources** (Reuters, AP, BBC, Guardian, etc.)
+- Headlines should be **recent (last 24 hours)**
+- If publish time is unavailable, indicate **“Time not provided”**
+
+###### Fallback
+- If fewer than 3 headlines are found, state:  
+  **“Only X recent headlines found for the USA.”**
+- Do not fabricate headlines, dates, or URLs
+
+###### Output Style
+- Structured list sorted by **most recent first**
+- Use emojis consistently to indicate news type
+- Use `<span style="color:...">` for coloring the title if the renderer supports it
+- Keep the output **concise, factual, and visually engaging**

src/chatbot_v2/prompts/odia_news.txt

@@ -0,0 +1,26 @@
+##### Task
+Tell me the **top 3 headlines from Odisha**.
+
+###### For each headline, provide:
+- **Title in bold**
+- A **3‑line summary**
+- **Publish date and time**
+- A **link to the exact source URL**
+
+###### Requirements
+- Use authoritative news sources (e.g., major national/regional news outlets)
+- Headlines should be **recent (last 24 hours)**
+- Provide timestamps in **UTC**
+- If publish date/time is not available, indicate “Date/Time not provided”
+
+###### Fallback
+- If fewer than 3 headlines are found, provide what is available and state:
+  **“Only X recent headlines found for Odisha.”**
+- Do not fabricate headlines, dates, or URLs
+
+###### Output Style
+- Structured list sorted by **most recent first**
+- Clear and concise formatting as requested
+- Use color and emoji to make it more engaging.
+- Use `<span style="color:...">` for coloring the title if the renderer supports it
+- Keep the output **concise, factual, and visually engaging**

src/chatbot_v2/prompts/trade_recommendation.txt

@@ -0,0 +1,40 @@
+##### Task
+Recommend **three option spreads** with **>80% probability of profit**. Perform a thorough analysis of each underlying’s **3-month price trend** and current **market sentiment** before selecting spreads.
+
+###### Steps
+1. **Stock selection & analysis**
+   - Analyze the **last 3 months** of price action (trend, volatility, support/resistance).
+   - Assess market sentiment from the **last 7 days** of headlines and social/analyst tone.
+2. **Spread construction**
+   - For each of the **3 recommended spreads**, specify:
+     - **Underlying ticker**
+     - **Spread type** (e.g., bull put, bear call, iron condor)
+     - **Exact expiry date** (YYYY-MM-DD)
+     - **Each leg**: side (sell/buy), option type (put/call), **strike price**
+     - **Premium entry**: exact net credit/debit per share (use live bid/ask midpoint)
+     - **Position size guidance** (risk per trade as % of portfolio) — optional
+3. **Probability & rationale**
+   - Provide a **quantitative probability of profit (%)** (clearly state model/method used).
+   - Give a concise **rationale** linking 3-month trend, implied volatility, and sentiment to the spread choice.
+   - Show key supporting numbers: current spot, IV30, recent volatility, and relevant news headlines (with timestamps).
+
+###### Requirements / Guidelines
+- Target **>80% probability of profit** for each spread. Explain how the probability was computed (IV-based log-normal, normal approximation, or risk-neutral model).
+- **Always** use live option-chain quotes (bid/ask midpoint) and authoritative sources for prices/IV (e.g., exchange data, major market data providers).
+- Compare outcomes **vs. forecasts / recent range** and note any idiosyncratic risk (earnings, events).
+- Include **exact timestamps** (UTC) for all quoted prices.
+- Provide **sources** for price, IV, and headlines.
+
+###### Fallback
+- If live option-chain or price data is unavailable, state: **“Live market data unavailable — cannot generate exact strike/premium. Provide analysis based on most recent available snapshot.”**
+- If sentiment or 3-month history is incomplete, present what is available and **explicitly list missing items**.
+- **Do not fabricate** strikes, premiums, probabilities, or news — only use verified data.
+
+###### Output Style
+- For each spread, use a compact block with:
+  - Ticker — Spread type — Expiry (YYYY-MM-DD) — Net premium — PO P (%)
+  - Legs: bullet list of exact leg details (sell/buy, put/call, strike, premium)
+  - Rationale: 2–3 short sentences linking trend & sentiment to the trade
+  - Sources & timestamps
+- Keep language concise, factual, and machine/agent friendly for downstream parsing.
+- Use color and emoji to make it more engaging.

src/chatbot_v2/prompts/upcoming_earnings.txt

@@ -0,0 +1,27 @@
+##### Task
+Search for **upcoming critical earnings announcements** in the stock market.
+
+###### Include
+- **Ticker**
+- **Company name**
+- **Earnings date & time**
+- **Expected EPS & revenue consensus**
+- **Last quarter’s actual EPS & revenue**
+- **Implied volatility trend ahead of earnings**
+
+###### Requirements / Guidelines
+- Focus on **high‑impact names** (large cap, high volume, sector leaders)
+- Include **earnings expected within the next 7 calendar days**
+- Use **primary/authoritative sources** for earnings dates and estimates (e.g., exchange calendars, Bloomberg/Refinitiv/Estimize)
+- Show **timestamped data** (UTC)
+
+###### Fallback
+- If no critical earnings are found in the next 7 days, state:  
+  **“No upcoming critical earnings announcements found within the specified period.”**
+- If consensus estimates are unavailable, list the earnings date/time and note missing metrics.
+
+###### Output Style
+- Structured list sorted by **earnings date**
+- Use clear bullet points or short paragraphs
+- Provide **sources** for each item
+- Use color and emoji to make it more engaging.

src/chatbot_v2/trace_config.py

@@ -0,0 +1,37 @@
+# trace_config.py
+import openai
+from langsmith.wrappers import wrap_openai
+import os
+
+print("🔌 APPLYING LANGSMITH TRACE PATCH...")
+
+# 1. Save original classes
+_OriginalOpenAI = openai.OpenAI
+_OriginalAsyncOpenAI = openai.AsyncOpenAI
+
+# 2. Define the shim
+def PatchedOpenAI(*args, **kwargs):
+    print("✨ Creating Wrapped OpenAI Client (Sync)") # Debug print
+    client = _OriginalOpenAI(*args, **kwargs)
+    return wrap_openai(client)
+
+def PatchedAsyncOpenAI(*args, **kwargs):
+    print("✨ Creating Wrapped OpenAI Client (Async)") # Debug print
+    client = _OriginalAsyncOpenAI(*args, **kwargs)
+    return wrap_openai(client)
+
+# 3. Apply patch
+openai.OpenAI = PatchedOpenAI
+openai.AsyncOpenAI = PatchedAsyncOpenAI
+
+from langsmith import traceable
+
+# You can't decorate the class directly with @traceable, 
+# but you can use this helper to wrap all methods:
+
+def instrument_class(cls):
+    for attr_name, attr_value in cls.__dict__.items():
+        if callable(attr_value) and not attr_name.startswith("__"):
+            setattr(cls, attr_name, traceable(attr_value, run_type="tool"))
+    return cls
+