'code'

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,11 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.env

Dockerfile

@@ -0,0 +1,18 @@
+# Base image
+FROM python:3.11-slim
+
+# Set work directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Expose the port Hugging Face expects
+EXPOSE 7860
+
+# Command to run FastAPI with uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

agent_architect.py

@@ -0,0 +1,639 @@
+# agent_architect.py
+"""
+Smart Business-Specific Agent Builder
+Automatically detects business domain and creates relevant tools
+"""
+import asyncio
+import json
+from typing import Dict, Any, List, Optional, Tuple
+from datetime import datetime
+from pydantic import BaseModel, Field
+from firebase_admin import db
+from agents import Agent, AsyncOpenAI as AgentsAsyncOpenAI, OpenAIChatCompletionsModel, function_tool
+from web_search_tool import web_search
+
+# ------------------------
+# Models
+# ------------------------
+class ToolDefinition(BaseModel):
+    name: str
+    description: str
+    function_code: str
+    parameters: dict = Field(default_factory=dict)
+    class Config:
+        extra = "forbid"
+
+class AgentConfiguration(BaseModel):
+    agent_id: str
+    name: str
+    instructions: str
+    model: str
+    tools: List[ToolDefinition]
+    tone: str
+    business_context: Dict[str, Any]
+    deployment_ready: bool = True
+    class Config:
+        extra = "forbid"
+
+class AgentBuildResult(BaseModel):
+    status: str
+    agent_config: Optional[AgentConfiguration] = None
+    agent_instance: Optional[Any] = None
+    agent_test_response: Optional[str] = None
+    deployment_code: Optional[str] = None
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+# ------------------------
+# Smart Business Domain Detector
+# ------------------------
+class BusinessDomainDetector:
+    """Detects business domain from extraction data"""
+    
+    DOMAIN_KEYWORDS = {
+        "pharmacy": ["pharmacy", "pharma", "drug", "medicine", "prescription", "medication", "patient", "medical", "healthcare"],
+        "ecommerce": ["ecommerce", "shop", "retail", "store", "product", "cart", "checkout", "order", "delivery"],
+        "restaurant": ["restaurant", "food", "menu", "order", "reservation", "dining", "kitchen", "waiter", "chef"],
+        "education": ["education", "school", "student", "teacher", "course", "class", "learn", "exam", "tutor"],
+        "real_estate": ["real estate", "property", "house", "apartment", "rent", "buy", "mortgage", "realtor"],
+        "agriculture": ["agriculture", "farm", "crop", "harvest", "soil", "fertilizer", "irrigation", "farming"],
+        "finance": ["finance", "bank", "loan", "investment", "account", "transaction", "payment", "credit"],
+        "logistics": ["logistics", "delivery", "shipping", "warehouse", "transport", "tracking", "freight"],
+        "hotel": ["hotel", "booking", "room", "reservation", "guest", "check-in", "hospitality"],
+        "fitness": ["fitness", "gym", "workout", "exercise", "trainer", "health", "nutrition", "sports"],
+        "saas": ["saas", "software", "subscription", "cloud", "platform", "app", "application", "users", "billing"],
+        "school": ["school", "student", "teacher", "classroom", "curriculum", "lesson", "grade", "homework", "attendance"],
+        "climate": ["climate", "carbon", "emissions", "sustainability", "environmental", "greenhouse", "renewable", "footprint", "advisor"],
+        "agritech": ["agritech", "precision", "farming", "drone", "sensor", "iot", "yield", "monitoring", "smart"],
+        "weather": ["weather", "forecast", "temperature", "precipitation", "humidity", "wind", "meteorology", "prediction"]
+    }
+    
+    @classmethod
+    def detect(cls, business_name: str, industry: str, features: List[str], query: str) -> str:
+        """Detect business domain from multiple sources"""
+        combined_text = f"{business_name} {industry} {query} {' '.join(features)}".lower()
+        
+        scores = {}
+        for domain, keywords in cls.DOMAIN_KEYWORDS.items():
+            score = sum(1 for keyword in keywords if keyword in combined_text)
+            if score > 0:
+                scores[domain] = score
+        
+        if scores:
+            return max(scores, key=scores.get)
+        return "generic"
+
+
+# ------------------------
+# Dynamic Tool Factory
+# ------------------------
+class DynamicToolFactory:
+    """Creates business-specific tools based on domain"""
+    
+    @staticmethod
+    def create_pharmacy_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """Pharmacy management tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def manage_prescription(action: str, prescription_id: str = None, patient_id: str = None, medication: str = None) -> dict:
+            """Manage prescriptions - check, refill, or create"""
+            return {"prescription_id": prescription_id or f"RX-{datetime.now().strftime('%Y%m%d%H%M')}", 
+                    "action": action, "status": "Processed", "refills": 3}
+        
+        @function_tool
+        async def check_drug_inventory(medication_name: str) -> dict:
+            """Check medication stock and expiry"""
+            return {"medication": medication_name, "in_stock": True, "quantity": 250, "expiry": "2026-06-15"}
+        
+        @function_tool
+        async def get_patient_info(patient_id: str) -> dict:
+            """Retrieve patient records and allergies"""
+            return {"patient_id": patient_id, "allergies": ["Penicillin"], "medications": ["Metformin"]}
+        
+        tools = [manage_prescription, check_drug_inventory, get_patient_info, web_search]
+        defs = [
+            ToolDefinition(name="manage_prescription", description="Manage prescriptions", 
+                          function_code="@function_tool\nasync def manage_prescription(...): ...",
+                          parameters={"type": "object", "properties": {"action": {"type": "string"}, "prescription_id": {"type": "string"}}}),
+            ToolDefinition(name="check_drug_inventory", description="Check medication stock",
+                          function_code="@function_tool\nasync def check_drug_inventory(...): ...",
+                          parameters={"type": "object", "properties": {"medication_name": {"type": "string"}}, "required": ["medication_name"]}),
+            ToolDefinition(name="get_patient_info", description="Get patient info",
+                          function_code="@function_tool\nasync def get_patient_info(...): ...",
+                          parameters={"type": "object", "properties": {"patient_id": {"type": "string"}}, "required": ["patient_id"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_ecommerce_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """E-commerce tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def search_products(query: str, category: str = None) -> dict:
+            """Search product catalog"""
+            return {"query": query, "results": [{"id": "P001", "name": query, "price": 49.99, "stock": 50}]}
+        
+        @function_tool
+        async def track_order(order_id: str) -> dict:
+            """Track order status and delivery"""
+            return {"order_id": order_id, "status": "In Transit", "eta": "2025-11-20", "location": "Distribution Center"}
+        
+        @function_tool
+        async def manage_cart(action: str, product_id: str = None, quantity: int = 1) -> dict:
+            """Add, remove, or view cart items"""
+            return {"action": action, "product_id": product_id, "cart_total": 149.99, "items": 3}
+        
+        tools = [search_products, track_order, manage_cart, web_search]
+        defs = [
+            ToolDefinition(name="search_products", description="Search products", function_code="...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}),
+            ToolDefinition(name="track_order", description="Track order", function_code="...",
+                          parameters={"type": "object", "properties": {"order_id": {"type": "string"}}, "required": ["order_id"]}),
+            ToolDefinition(name="manage_cart", description="Manage shopping cart", function_code="...",
+                          parameters={"type": "object", "properties": {"action": {"type": "string", "enum": ["add", "remove", "view"]}}}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_restaurant_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """Restaurant management tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def manage_reservation(action: str, customer_name: str = None, date: str = None, party_size: int = 2) -> dict:
+            """Create, modify, or cancel restaurant reservations"""
+            return {"reservation_id": f"RES-{datetime.now().strftime('%Y%m%d%H%M')}", 
+                    "customer": customer_name, "date": date, "party_size": party_size, "status": "Confirmed"}
+        
+        @function_tool
+        async def view_menu(category: str = None) -> dict:
+            """View restaurant menu by category"""
+            return {"category": category or "All", "items": [
+                {"name": "Burger", "price": 12.99, "available": True},
+                {"name": "Pizza", "price": 15.99, "available": True}
+            ]}
+        
+        @function_tool
+        async def track_order_status(order_id: str) -> dict:
+            """Check kitchen order status and estimated time"""
+            return {"order_id": order_id, "status": "Preparing", "estimated_time": "15 minutes", "items_ready": 2, "items_pending": 1}
+        
+        tools = [manage_reservation, view_menu, track_order_status, web_search]
+        defs = [
+            ToolDefinition(name="manage_reservation", description="Manage reservations", function_code="...",
+                          parameters={"type": "object", "properties": {"action": {"type": "string", "enum": ["create", "modify", "cancel"]}, "customer_name": {"type": "string"}}}),
+            ToolDefinition(name="view_menu", description="View menu", function_code="...",
+                          parameters={"type": "object", "properties": {"category": {"type": "string"}}}),
+            ToolDefinition(name="track_order_status", description="Track order", function_code="...",
+                          parameters={"type": "object", "properties": {"order_id": {"type": "string"}}, "required": ["order_id"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_education_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """Education platform tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def search_courses(subject: str, level: str = "beginner") -> dict:
+            """Search available courses"""
+            return {"subject": subject, "level": level, "courses": [{"id": "C001", "title": f"{subject} Basics", "duration": "8 weeks", "price": 49.99}]}
+        
+        @function_tool
+        async def enroll_student(student_id: str, course_id: str) -> dict:
+            """Enroll student in course"""
+            return {"enrollment_id": f"ENR-{datetime.now().timestamp()}", "student_id": student_id, "course_id": course_id, "status": "Enrolled", "start_date": "2025-12-01"}
+        
+        @function_tool
+        async def check_progress(student_id: str, course_id: str) -> dict:
+            """Check student progress in course"""
+            return {"student_id": student_id, "course_id": course_id, "progress": "65%", "completed_lessons": 13, "total_lessons": 20, "grade": "B+"}
+        
+        tools = [search_courses, enroll_student, check_progress, web_search]
+        defs = [
+            ToolDefinition(name="search_courses", description="Search courses", function_code="...",
+                          parameters={"type": "object", "properties": {"subject": {"type": "string"}, "level": {"type": "string"}}, "required": ["subject"]}),
+            ToolDefinition(name="enroll_student", description="Enroll in course", function_code="...",
+                          parameters={"type": "object", "properties": {"student_id": {"type": "string"}, "course_id": {"type": "string"}}, "required": ["student_id", "course_id"]}),
+            ToolDefinition(name="check_progress", description="Check progress", function_code="...",
+                          parameters={"type": "object", "properties": {"student_id": {"type": "string"}, "course_id": {"type": "string"}}, "required": ["student_id", "course_id"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_saas_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """SaaS platform tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def manage_subscription(action: str, user_id: str, plan: str = None) -> dict:
+            """Manage user subscriptions"""
+            return {"user_id": user_id, "action": action, "plan": plan or "pro", "status": "active", "next_billing": "2025-12-01"}
+        
+        @function_tool
+        async def track_usage_metrics(user_id: str) -> dict:
+            """Track user engagement metrics"""
+            return {"user_id": user_id, "daily_active": 42, "monthly_active": 1250, "feature_usage": {"dashboard": 95, "reports": 76, "api": 34}}
+        
+        @function_tool
+        async def handle_billing_inquiry(user_id: str, inquiry_type: str) -> dict:
+            """Handle billing and payment inquiries"""
+            return {"user_id": user_id, "inquiry_type": inquiry_type, "balance": 29.99, "due_date": "2025-12-01", "payment_methods": ["card", "paypal"]}
+        
+        tools = [manage_subscription, track_usage_metrics, handle_billing_inquiry, web_search]
+        defs = [
+            ToolDefinition(name="manage_subscription", description="Manage user subscriptions", function_code="...",
+                          parameters={"type": "object", "properties": {"action": {"type": "string", "enum": ["upgrade", "downgrade", "cancel"]}, "user_id": {"type": "string"}, "plan": {"type": "string"}}, "required": ["action", "user_id"]}),
+            ToolDefinition(name="track_usage_metrics", description="Track user engagement metrics", function_code="...",
+                          parameters={"type": "object", "properties": {"user_id": {"type": "string"}}, "required": ["user_id"]}),
+            ToolDefinition(name="handle_billing_inquiry", description="Handle billing inquiries", function_code="...",
+                          parameters={"type": "object", "properties": {"user_id": {"type": "string"}, "inquiry_type": {"type": "string", "enum": ["balance", "payment", "refund"]}}, "required": ["user_id", "inquiry_type"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_school_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """School management tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def manage_student_record(action: str, student_id: str, data: dict = None) -> dict:
+            """Manage student records"""
+            return {"student_id": student_id, "action": action, "status": "updated", "updated_fields": list(data.keys()) if data else []}
+        
+        @function_tool
+        async def schedule_class(teacher_id: str, subject: str, date: str, duration: int) -> dict:
+            """Schedule classes and manage timetable"""
+            return {"teacher_id": teacher_id, "subject": subject, "date": date, "duration": duration, "room": "A101", "status": "scheduled"}
+        
+        @function_tool
+        async def track_attendance(class_id: str, date: str) -> dict:
+            """Track student attendance"""
+            return {"class_id": class_id, "date": date, "present": 25, "absent": 3, "late": 2}
+        
+        tools = [manage_student_record, schedule_class, track_attendance, web_search]
+        defs = [
+            ToolDefinition(name="manage_student_record", description="Manage student records", function_code="...",
+                          parameters={"type": "object", "properties": {"action": {"type": "string", "enum": ["create", "update", "delete"]}, "student_id": {"type": "string"}, "data": {"type": "object"}}, "required": ["action", "student_id"]}),
+            ToolDefinition(name="schedule_class", description="Schedule classes", function_code="...",
+                          parameters={"type": "object", "properties": {"teacher_id": {"type": "string"}, "subject": {"type": "string"}, "date": {"type": "string", "format": "date"}, "duration": {"type": "integer"}}, "required": ["teacher_id", "subject", "date", "duration"]}),
+            ToolDefinition(name="track_attendance", description="Track student attendance", function_code="...",
+                          parameters={"type": "object", "properties": {"class_id": {"type": "string"}, "date": {"type": "string", "format": "date"}}, "required": ["class_id", "date"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_climate_advisor_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """Climate advisory tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def calculate_carbon_footprint(industry: str, energy_usage: float, transport_km: float) -> dict:
+            """Calculate carbon footprint"""
+            return {"industry": industry, "carbon_kg": energy_usage * 0.5 + transport_km * 0.2, "rating": "B", "offset_suggestion": "Plant 5 trees"}
+        
+        @function_tool
+        async def recommend_sustainability_measures(company_size: str, industry: str) -> dict:
+            """Recommend sustainability measures"""
+            return {"company_size": company_size, "industry": industry, "recommendations": ["Switch to LED lighting", "Implement recycling program", "Use renewable energy"], "roi_months": 18}
+        
+        @function_tool
+        async def track_env_progress(goal_id: str) -> dict:
+            """Track environmental progress"""
+            return {"goal_id": goal_id, "current_value": 45, "target_value": 100, "progress_percent": 45, "milestones": ["Baseline established", "20% reduction achieved"]}
+        
+        tools = [calculate_carbon_footprint, recommend_sustainability_measures, track_env_progress, web_search]
+        defs = [
+            ToolDefinition(name="calculate_carbon_footprint", description="Calculate carbon footprint", function_code="...",
+                          parameters={"type": "object", "properties": {"industry": {"type": "string"}, "energy_usage": {"type": "number"}, "transport_km": {"type": "number"}}, "required": ["industry", "energy_usage", "transport_km"]}),
+            ToolDefinition(name="recommend_sustainability_measures", description="Recommend sustainability measures", function_code="...",
+                          parameters={"type": "object", "properties": {"company_size": {"type": "string"}, "industry": {"type": "string"}}, "required": ["company_size", "industry"]}),
+            ToolDefinition(name="track_env_progress", description="Track environmental progress", function_code="...",
+                          parameters={"type": "object", "properties": {"goal_id": {"type": "string"}}, "required": ["goal_id"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_agritech_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """Agritech tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def analyze_crop_health(field_id: str, sensor_data: dict) -> dict:
+            """Analyze crop health from sensor data"""
+            return {"field_id": field_id, "health_index": 85, "issues": ["minor pest infestation"], "recommendations": ["Apply organic pesticide"]}
+        
+        @function_tool
+        async def predict_yield(crop_type: str, field_area: float, weather_forecast: dict) -> dict:
+            """Predict crop yield"""
+            return {"crop_type": crop_type, "predicted_yield": field_area * 2.5, "confidence": 0.85, "optimal_harvest_date": "2026-06-15"}
+        
+        @function_tool
+        async def irrigation_schedule(field_id: str, soil_moisture: float, forecast_rain: float) -> dict:
+            """Optimize irrigation schedule"""
+            return {"field_id": field_id, "irrigate": soil_moisture < 30 and forecast_rain < 10, "amount_mm": 25, "timing": "early morning"}
+        
+        tools = [analyze_crop_health, predict_yield, irrigation_schedule, web_search]
+        defs = [
+            ToolDefinition(name="analyze_crop_health", description="Analyze crop health", function_code="...",
+                          parameters={"type": "object", "properties": {"field_id": {"type": "string"}, "sensor_data": {"type": "object"}}, "required": ["field_id", "sensor_data"]}),
+            ToolDefinition(name="predict_yield", description="Predict crop yield", function_code="...",
+                          parameters={"type": "object", "properties": {"crop_type": {"type": "string"}, "field_area": {"type": "number"}, "weather_forecast": {"type": "object"}}, "required": ["crop_type", "field_area", "weather_forecast"]}),
+            ToolDefinition(name="irrigation_schedule", description="Optimize irrigation schedule", function_code="...",
+                          parameters={"type": "object", "properties": {"field_id": {"type": "string"}, "soil_moisture": {"type": "number"}, "forecast_rain": {"type": "number"}}, "required": ["field_id", "soil_moisture", "forecast_rain"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_weather_tools() -> Tuple[List[callable], List[ToolDefinition]]:
+        """Weather forecasting tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def get_forecast(location: str, days: int = 7) -> dict:
+            """Get weather forecast"""
+            return {"location": location, "days": days, "forecast": [{"date": "2025-12-12", "high": 22, "low": 15, "condition": "partly cloudy"}]}
+        
+        @function_tool
+        async def severe_weather_alert(location: str) -> dict:
+            """Check for severe weather alerts"""
+            return {"location": location, "alerts": [], "severity": "none", "preparedness_tips": ["Normal precautions"]}
+        
+        @function_tool
+        async def historical_weather_comparison(location: str, date: str) -> dict:
+            """Compare current weather to historical data"""
+            return {"location": location, "date": date, "current_temp": 20, "historical_avg": 18, "difference": 2, "percentile": 65}
+        
+        tools = [get_forecast, severe_weather_alert, historical_weather_comparison, web_search]
+        defs = [
+            ToolDefinition(name="get_forecast", description="Get weather forecast", function_code="...",
+                          parameters={"type": "object", "properties": {"location": {"type": "string"}, "days": {"type": "integer", "default": 7}}, "required": ["location"]}),
+            ToolDefinition(name="severe_weather_alert", description="Check for severe weather alerts", function_code="...",
+                          parameters={"type": "object", "properties": {"location": {"type": "string"}}, "required": ["location"]}),
+            ToolDefinition(name="historical_weather_comparison", description="Compare weather to historical data", function_code="...",
+                          parameters={"type": "object", "properties": {"location": {"type": "string"}, "date": {"type": "string", "format": "date"}}, "required": ["location", "date"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @staticmethod
+    def create_generic_business_tools(business_name: str) -> Tuple[List[callable], List[ToolDefinition]]:
+        """Generic business tools"""
+        tools, defs = [], []
+        
+        @function_tool
+        async def generate_analytics(metric: str, time_range: str) -> dict:
+            """Generate business analytics"""
+            return {"metric": metric, "time_range": time_range, "value": 12500, "trend": "+15%", "insights": f"{metric} growing"}
+        
+        @function_tool
+        async def send_notification(recipient: str, message: str, channel: str = "email") -> dict:
+            """Send notifications"""
+            return {"recipient": recipient, "message": message, "channel": channel, "status": "Sent"}
+        
+        tools = [generate_analytics, send_notification, web_search]
+        defs = [
+            ToolDefinition(name="generate_analytics", description=f"Generate {business_name} analytics", function_code="...",
+                          parameters={"type": "object", "properties": {"metric": {"type": "string"}, "time_range": {"type": "string"}}, "required": ["metric", "time_range"]}),
+            ToolDefinition(name="send_notification", description="Send notifications", function_code="...",
+                          parameters={"type": "object", "properties": {"recipient": {"type": "string"}, "message": {"type": "string"}}, "required": ["recipient", "message"]}),
+            ToolDefinition(name="web_search", description="Perform a web search for current information",
+                          function_code="@function_tool\ndef web_search(query: str): ...",
+                          parameters={"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]})
+        ]
+        return tools, defs
+    
+    @classmethod
+    def create_tools_for_domain(cls, domain: str, business_name: str) -> Tuple[List[callable], List[ToolDefinition]]:
+        """Factory method to create tools based on domain"""
+        factory_map = {
+            "pharmacy": cls.create_pharmacy_tools,
+            "ecommerce": cls.create_ecommerce_tools,
+            "restaurant": cls.create_restaurant_tools,
+            "education": cls.create_education_tools,
+            "saas": cls.create_saas_tools,
+            "school": cls.create_school_tools,
+            "climate": cls.create_climate_advisor_tools,
+            "agritech": cls.create_agritech_tools,
+            "weather": cls.create_weather_tools,
+            "generic": lambda: cls.create_generic_business_tools(business_name)
+        }
+        
+        factory = factory_map.get(domain, lambda: cls.create_generic_business_tools(business_name))
+        return factory()
+
+
+# ------------------------
+# Live Agent Architect
+# ------------------------
+class LiveAgentArchitect:
+    """Smart agent builder with domain detection"""
+    
+    def __init__(self, session_id: str):
+        self.session_id = session_id
+        self.detector = BusinessDomainDetector()
+        self.tool_factory = DynamicToolFactory()
+        
+    async def _emit_log(self, message: str, type: str = "log"):
+        try:
+            ref = db.reference(f'sessions/{self.session_id}/logs')
+            ref.push({'message': message, 'type': type, 'timestamp': datetime.now().isoformat()})
+        except Exception as e:
+            print(f"Log error: {e}")
+    
+    def _generate_comprehensive_instructions(self, extraction: Dict[str, Any], domain: str) -> str:
+        """Generate domain-specific comprehensive instructions"""
+        business = extraction.get('business', {})
+        agent_spec = extraction.get('agent', {})
+        
+        business_name = business.get('business_name', 'Business')
+        industry = business.get('industry', 'Industry')
+        capabilities = agent_spec.get('capabilities', [])
+        agent_name = agent_spec.get('agent_name', 'AI Assistant')
+        core_problem = business.get('core_problem', '')
+        solution = business.get('solution', '')
+        
+        instructions = f"""You are the MASTER {industry} expert for {business_name} with comprehensive knowledge across ALL operational domains.
+
+**Your Identity:**
+Name: {agent_name}
+Domain: {domain.title()}
+Specialization: {industry}
+
+**Your Expertise Covers:**
+"""
+        for cap in capabilities:
+            instructions += f"- {cap}\n"
+        
+        instructions += f"""
+**The Problem You Solve:**
+{core_problem}
+
+**Your Solution Approach:**
+{solution}
+
+**Response Structure (MANDATORY):**
+Always format your answers in this order:
+1. 🎯 **Direct Answer** – Clear, one-sentence response
+2. 📚 **Detailed Explanation** – Simple explanation with reasoning
+3. 📏 **Practical Steps** – Specific actions, numbers, timings
+4. 🌍 **Context & Tips** – Best practices, compliance, regional advice
+5. 🔒 **Prevention & Next Steps** – Warnings, monitoring, escalation
+
+**Response Rules:**
+1. **Always Use Tools First**: Fetch real-time data before answering
+2. **Be Specific**: Provide exact numbers, dates, quantities
+3. **Simple Language**: Explain complex topics simply
+4. **Actionable**: Every response must have clear next steps
+5. **Safety**: Include warnings and when to seek help
+
+**Tool Usage:**
+- Use tools proactively for accurate data
+- Combine multiple tools for comprehensive answers
+- Validate responses before presenting
+- Handle tool failures gracefully
+
+**Communication:**
+- Warm and supportive
+- Acknowledge concerns
+- Provide immediate + long-term solutions
+- Use examples and analogies
+
+**Always be the expert every user needs!**
+"""
+        return instructions
+    
+    async def build_agent(self, extraction: Dict[str, Any], model: str, api_key: str) -> AgentBuildResult:
+        """Build domain-specific agent"""
+        try:
+            await self._emit_log("🏗️ Building smart business agent...", "system")
+            
+            business = extraction.get('business', {})
+            agent_spec = extraction.get('agent', {})
+            
+            business_name = business.get('business_name', 'Business')
+            industry = business.get('industry', '')
+            features = business.get('key_features', [])
+            query = business.get('query', '')
+            
+            # Detect domain
+            domain = self.detector.detect(business_name, industry, features, query)
+            await self._emit_log(f"📊 Detected domain: {domain.upper()}", "success")
+            
+            # Create domain-specific tools
+            tools, tool_defs = self.tool_factory.create_tools_for_domain(domain, business_name)
+            await self._emit_log(f"✅ Created {len(tools)} {domain}-specific tools", "success")
+            
+            # Generate instructions
+            instructions = self._generate_comprehensive_instructions(extraction, domain)
+            await self._emit_log("✅ Generated instructions", "success")
+            
+            # Setup model client
+            if "gemini" in model.lower():
+                client = AgentsAsyncOpenAI(api_key=api_key, 
+                                          base_url="https://generativelanguage.googleapis.com/v1beta/openai/")
+                model_name = "gemini-2.0-flash-exp"
+            elif "grok" in model.lower():
+                client = AgentsAsyncOpenAI(api_key=api_key, base_url="https://api.x.ai/v1")
+                model_name = "grok-beta"
+            else:
+                client = AgentsAsyncOpenAI(api_key=api_key)
+                model_name = "gpt-4o"
+            
+            MODEL = OpenAIChatCompletionsModel(model=model_name, openai_client=client)
+            
+            # Create agent
+            agent_name = agent_spec.get('agent_name', f"{business_name} AI")
+            agent_instance = Agent(name=agent_name, instructions=instructions, model=MODEL, tools=tools)
+            
+            await self._emit_log("✅ Agent created!", "success")
+            
+            agent_id = f"agent_{domain}_{business_name.lower().replace(' ', '_')}_{int(datetime.now().timestamp())}"
+            
+            agent_config = AgentConfiguration(
+                agent_id=agent_id,
+                name=agent_name,
+                instructions=instructions,
+                model=model,
+                tools=tool_defs,
+                tone="professional",
+                business_context={
+                    "business_name": business_name,
+                    "industry": industry,
+                    "domain": domain,
+                    "capabilities": agent_spec.get('capabilities', [])
+                },
+                deployment_ready=True
+            )
+            
+            deployment_code = f'''# {agent_name} - {domain.title()} Agent
+from agents import Agent, AsyncOpenAI, OpenAIChatCompletionsModel, function_tool
+
+client = AsyncOpenAI(api_key="YOUR_KEY")
+MODEL = OpenAIChatCompletionsModel(model="{model_name}", openai_client=client)
+
+# ... tools here ...
+
+{agent_name.replace(' ', '_')} = Agent(
+    name="{agent_name}",
+    instructions="""...""",
+    model=MODEL,
+    tools=[...]
+)
+'''
+            
+            return AgentBuildResult(
+                status="success",
+                agent_config=agent_config,
+                agent_instance=agent_instance,
+                agent_test_response=f"{agent_name} ready with {len(tools)} {domain} tools!",
+                deployment_code=deployment_code,
+                metadata={"session_id": self.session_id, "domain": domain, "tools_count": len(tools)}
+            )
+            
+        except Exception as e:
+            await self._emit_log(f"❌ Failed: {str(e)}", "error")
+            return AgentBuildResult(status="error", error=str(e), metadata={})
+
+
+class AgentDeployer:
+    @staticmethod
+    async def save_to_firebase(session_id: str, agent_config: AgentConfiguration):
+        try:
+            ref = db.reference(f'sessions/{session_id}/agent')
+            ref.set(agent_config.model_dump())
+            agents_ref = db.reference(f'agents/{agent_config.agent_id}')
+            agents_ref.set({**agent_config.model_dump(), 'session_id': session_id, 'created_at': datetime.now().isoformat()})
+            return True
+        except Exception as e:
+            print(f"Error: {e}")
+            return False

confg.py

@@ -0,0 +1,23 @@
+import os
+from dotenv import load_dotenv
+from agents import AsyncOpenAI,OpenAIChatCompletionsModel,set_tracing_disabled
+from tavily import TavilyClient
+
+set_tracing_disabled(True)
+load_dotenv()
+gemini_api_key = os.getenv("GEMINI_API_KEY")
+tavily_api_key = os.getenv("TAVILY_SECRET_KEY")
+
+
+tavily_client = TavilyClient(api_key=tavily_api_key)
+
+client_provider = AsyncOpenAI(
+    api_key=gemini_api_key,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+
+model = OpenAIChatCompletionsModel(
+    model="gemini-2.5-flash",
+    openai_client=client_provider
+)
+

extractor_agent_runner.py

@@ -0,0 +1,397 @@
+# extractor_agent_runner.py
+import asyncio
+import json
+from typing import Dict, Any, Optional
+from datetime import datetime
+from openai import AsyncOpenAI
+from pydantic import BaseModel, Field
+from firebase_admin import db
+
+# ------------------------
+# Pydantic Models for Structured Outputs
+# ------------------------
+class BusinessExtraction(BaseModel):
+    """Extracted business information"""
+    business_name: str = Field(description="Name of the business idea")
+    industry: str = Field(description="Industry or sector")
+    target_audience: str = Field(description="Target customer base")
+    core_problem: str = Field(description="Main problem being solved")
+    solution: str = Field(description="Proposed solution")
+    key_features: list[str] = Field(description="List of key features or capabilities")
+    tech_stack: list[str] = Field(description="Recommended technology stack")
+    estimated_complexity: str = Field(description="Low, Medium, or High")
+    
+    class Config:
+        extra = "forbid"
+    
+class AgentSpecification(BaseModel):
+    """AI Agent specifications"""
+    agent_name: str = Field(description="Name of the AI agent")
+    agent_purpose: str = Field(description="Main purpose of the agent")
+    capabilities: list[str] = Field(description="List of agent capabilities")
+    integrations: list[str] = Field(description="Required integrations or APIs")
+    data_requirements: list[str] = Field(description="Data needed for the agent")
+    deployment_model: str = Field(description="e.g., Cloud, On-premise, Hybrid")
+    
+    class Config:
+        extra = "forbid"
+    
+class Phase(BaseModel):
+    """Single implementation phase"""
+    phase: str = Field(description="Phase name")
+    duration: str = Field(description="Time duration")
+    tasks: list[str] = Field(description="List of tasks in this phase")
+    
+    class Config:
+        extra = "forbid"
+
+class ImplementationPlan(BaseModel):
+    """Implementation roadmap"""
+    phases: list[Phase] = Field(description="Implementation phases with timeline")
+    estimated_timeline: str = Field(description="Overall timeline (e.g., 3-6 months)")
+    team_requirements: list[str] = Field(description="Required team members and roles")
+    estimated_cost: str = Field(description="Estimated cost range")
+    risks: list[str] = Field(description="Potential risks and challenges")
+    success_metrics: list[str] = Field(description="KPIs to measure success")
+    
+    class Config:
+        extra = "forbid"
+
+class CompleteExtraction(BaseModel):
+    """Complete extraction result"""
+    business: BusinessExtraction
+    agent: AgentSpecification
+    implementation: ImplementationPlan
+    summary: str = Field(description="Executive summary of the entire plan")
+    
+    class Config:
+        extra = "forbid"
+
+
+# ------------------------
+# Agent Orchestrator
+# ------------------------
+class AgentOrchestrator:
+    """
+    Orchestrates multiple AI agents for business idea extraction.
+    Supports OpenAI GPT, Google Gemini, and xAI Grok models.
+    """
+    
+    def __init__(self, session_id: str):
+        self.session_id = session_id
+        self.client: Optional[AsyncOpenAI] = None
+        self.model: str = ""
+        
+    async def _emit_log(self, message: str, type: str = "log"):
+        """Emit log to Firebase"""
+        try:
+            ref = db.reference(f'sessions/{self.session_id}/logs')
+            ref.push({
+                'message': message,
+                'type': type,
+                'timestamp': datetime.now().isoformat()
+            })
+        except Exception as e:
+            print(f"Error emitting log: {e}")
+    
+    def _setup_client(self, model: str, api_key: str):
+        """Setup appropriate client based on model type"""
+        model_lower = model.lower()
+        
+        if "gpt" in model_lower or "o1" in model_lower:
+            # OpenAI models
+            self.client = AsyncOpenAI(api_key=api_key)
+            self.model = model
+            
+        elif "grok" in model_lower:
+            # xAI Grok models (OpenAI-compatible)
+            self.client = AsyncOpenAI(
+                api_key=api_key,
+                base_url="https://api.x.ai/v1"
+            )
+            self.model = model
+            
+        elif "gemini" in model_lower:
+            # Google Gemini - use direct API
+            self.client = None  # Will handle separately
+            self.model = model
+            
+        else:
+            raise ValueError(f"Unsupported model: {model}")
+    
+    async def _call_openai_structured(self, system_prompt: str, user_prompt: str, response_format: type[BaseModel]) -> BaseModel:
+        """Call OpenAI with structured output"""
+        try:
+            response = await self.client.beta.chat.completions.parse(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                response_format=response_format,
+                temperature=0.7
+            )
+            return response.choices[0].message.parsed
+        except Exception as e:
+            raise Exception(f"OpenAI API call failed: {str(e)}")
+    
+    async def _call_gemini_structured(self, system_prompt: str, user_prompt: str, api_key: str, response_format: type[BaseModel]) -> BaseModel:
+        """Call Gemini and parse JSON response into Pydantic model"""
+        try:
+            import google.generativeai as genai
+            genai.configure(api_key=api_key)
+            
+            model = genai.GenerativeModel(self.model)
+            
+            # Get schema for structured output
+            schema_example = response_format.model_json_schema()
+            
+            full_prompt = f"""{system_prompt}
+
+User Query: {user_prompt}
+
+Respond ONLY with valid JSON matching this schema:
+{json.dumps(schema_example, indent=2)}
+
+Important: No markdown, no backticks, just pure JSON."""
+            
+            response = await model.generate_content_async(full_prompt)
+            
+            # Extract JSON from response
+            text = response.text.strip()
+            if text.startswith("```json"):
+                text = text[7:]
+            if text.startswith("```"):
+                text = text[3:]
+            if text.endswith("```"):
+                text = text[:-3]
+            text = text.strip()
+            
+            # Parse and validate with Pydantic
+            data = json.loads(text)
+            return response_format(**data)
+            
+        except Exception as e:
+            raise Exception(f"Gemini API call failed: {str(e)}")
+    
+    async def _extract_business_info(self, query: str, api_key: str) -> BusinessExtraction:
+        """Extract business information from query"""
+        await self._emit_log("🔍 Analyzing business idea...", "system")
+        
+        system_prompt = """You are a business analyst expert. Extract detailed business information from the user's query.
+Be thorough and specific. If information is not explicitly stated, make reasonable inferences based on the context."""
+        
+        user_prompt = f"""Analyze this business idea and extract key information:
+
+Query: {query}
+
+Provide detailed extraction including:
+- Business name (create a suitable name if not provided)
+- Industry classification
+- Target audience
+- Core problem being solved
+- Proposed solution
+- Key features (at least 3-5)
+- Recommended tech stack
+- Estimated complexity (Low/Medium/High)"""
+        
+        if "gemini" in self.model.lower():
+            # Gemini: Parse JSON manually
+            return await self._call_gemini_structured(system_prompt, user_prompt, api_key, BusinessExtraction)
+        else:
+            # OpenAI/Grok: Use structured outputs
+            return await self._call_openai_structured(system_prompt, user_prompt, BusinessExtraction)
+    
+    async def _extract_agent_specs(self, query: str, business: BusinessExtraction, api_key: str) -> AgentSpecification:
+        """Extract AI agent specifications"""
+        await self._emit_log("🤖 Designing AI agent specifications...", "system")
+        
+        system_prompt = """You are an AI agent architect. Design detailed specifications for an AI agent based on the business requirements.
+Be specific about capabilities, integrations, and technical requirements."""
+        
+        user_prompt = f"""Design an AI agent for this business:
+
+Business: {business.business_name}
+Industry: {business.industry}
+Problem: {business.core_problem}
+Solution: {business.solution}
+
+Create detailed agent specifications including:
+- Agent name
+- Primary purpose
+- Specific capabilities (at least 5)
+- Required integrations (APIs, databases, services)
+- Data requirements
+- Deployment model (Cloud/On-premise/Hybrid)"""
+        
+        if "gemini" in self.model.lower():
+            return await self._call_gemini_structured(system_prompt, user_prompt, api_key, AgentSpecification)
+        else:
+            return await self._call_openai_structured(system_prompt, user_prompt, AgentSpecification)
+    
+    async def _create_implementation_plan(self, query: str, business: BusinessExtraction, agent: AgentSpecification, api_key: str) -> ImplementationPlan:
+        """Create implementation roadmap"""
+        await self._emit_log("📋 Creating implementation roadmap...", "system")
+        
+        system_prompt = """You are a project manager and implementation strategist. Create a detailed implementation plan.
+Include realistic timelines, resource requirements, and risk assessments."""
+        
+        user_prompt = f"""Create an implementation plan for:
+
+Business: {business.business_name}
+Complexity: {business.estimated_complexity}
+Agent: {agent.agent_name}
+Capabilities: {', '.join(agent.capabilities)}
+
+Provide:
+- Implementation phases (at least 3-4 phases with specific tasks)
+- Overall timeline estimate
+- Team requirements (specific roles)
+- Cost estimate range
+- Potential risks (at least 3-5)
+- Success metrics (KPIs)"""
+        
+        if "gemini" in self.model.lower():
+            return await self._call_gemini_structured(system_prompt, user_prompt, api_key, ImplementationPlan)
+        else:
+            return await self._call_openai_structured(system_prompt, user_prompt, ImplementationPlan)
+    
+    async def _create_summary(self, business: BusinessExtraction, agent: AgentSpecification, implementation: ImplementationPlan, api_key: str) -> str:
+        """Create executive summary"""
+        await self._emit_log("📝 Generating executive summary...", "system")
+        
+        system_prompt = "You are an executive summary writer. Create a concise, compelling summary."
+        
+        user_prompt = f"""Create an executive summary (2-3 paragraphs) for:
+
+Business: {business.business_name}
+Industry: {business.industry}
+Solution: {business.solution}
+Agent: {agent.agent_name}
+Timeline: {implementation.estimated_timeline}
+Cost: {implementation.estimated_cost}
+
+Make it compelling and actionable."""
+        
+        if "gemini" in self.model.lower():
+            import google.generativeai as genai
+            genai.configure(api_key=api_key)
+            model = genai.GenerativeModel(self.model)
+            response = await model.generate_content_async(f"{system_prompt}\n\n{user_prompt}")
+            return response.text.strip()
+        else:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.7,
+                max_tokens=500
+            )
+            return response.choices[0].message.content.strip()
+    
+    async def run(self, query: str, model: str, api_key: str) -> Dict[str, Any]:
+        """
+        Main orchestration method - runs all extraction agents in sequence.
+        
+        Args:
+            query: User's business idea query
+            model: Model to use (gpt-4o, gemini-2.0-flash-exp, grok-beta, etc.)
+            api_key: API key for the model
+            
+        Returns:
+            Dict with extraction results or error information
+        """
+        try:
+            await self._emit_log(f"🚀 Starting extraction with {model}...", "system")
+            
+            # Setup client
+            self._setup_client(model, api_key)
+            
+            # Step 1: Extract business information
+            await self._emit_log("Step 1/4: Business Analysis", "system")
+            business = await self._extract_business_info(query, api_key)
+            await self._emit_log(f"✅ Identified: {business.business_name}", "success")
+            
+            # Step 2: Design agent specifications
+            await self._emit_log("Step 2/4: Agent Design", "system")
+            agent = await self._extract_agent_specs(query, business, api_key)
+            await self._emit_log(f"✅ Agent designed: {agent.agent_name}", "success")
+            
+            # Step 3: Create implementation plan
+            await self._emit_log("Step 3/4: Implementation Planning", "system")
+            implementation = await self._create_implementation_plan(query, business, agent, api_key)
+            await self._emit_log(f"✅ Timeline: {implementation.estimated_timeline}", "success")
+            
+            # Step 4: Generate summary
+            await self._emit_log("Step 4/4: Summary Generation", "system")
+            summary = await self._create_summary(business, agent, implementation, api_key)
+            await self._emit_log("✅ Extraction complete!", "success")
+            
+            # Compile results
+            complete_extraction = CompleteExtraction(
+                business=business,
+                agent=agent,
+                implementation=implementation,
+                summary=summary
+            )
+            
+            return {
+                "status": "success",
+                "stage": "complete",
+                "extraction": complete_extraction.model_dump(),
+                "metadata": {
+                    "model_used": model,
+                    "timestamp": datetime.now().isoformat(),
+                    "session_id": self.session_id
+                }
+            }
+            
+        except Exception as e:
+            error_msg = str(e)
+            await self._emit_log(f"❌ Error: {error_msg}", "error")
+            
+            return {
+                "status": "error",
+                "stage": "extraction",
+                "message": error_msg,
+                "metadata": {
+                    "model_used": model,
+                    "timestamp": datetime.now().isoformat(),
+                    "session_id": self.session_id
+                }
+            }
+
+
+# ------------------------
+# Testing
+# ------------------------
+if __name__ == "__main__":
+    import os
+    from dotenv import load_dotenv
+    load_dotenv()
+    
+    async def test_orchestrator():
+        # Mock session ID
+        test_session = "test-session-123"
+        
+        # Test query
+        query = "Create an AI agent for pharmacy inventory management that tracks medication expiry dates and auto-orders stock"
+        
+        # Get API key from env
+        api_key = os.getenv("OPENAI_API_KEY", "")
+        if not api_key:
+            print("❌ OPENAI_API_KEY not found in .env")
+            return
+        
+        # Run orchestrator
+        orchestrator = AgentOrchestrator(session_id=test_session)
+        result = await orchestrator.run(query, "gpt-4o", api_key)
+        
+        print("\n" + "="*50)
+        print("EXTRACTION RESULT")
+        print("="*50)
+        print(json.dumps(result, indent=2))
+    
+    asyncio.run(test_orchestrator())

firebase/serviceAccountKey.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "agentic-ai-startup",
+  "private_key_id": "33d3281d2fd931599c8dec6415aaf7936e5ba62f",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDImwVM6WzkWIbL\n2qGvi/y0nO/wTnxhHeET/Kv9z1p0zIG7XIsg+jaFFnfN3rPIt6y+soT4jNAzMi1Z\nvL+dtWDvurIwWMnV574vbJg1Owaf5F0FcoY/Qy50eNcGx8DwQHOO/ZkfSw3+TKNn\nzwC6r2nKP7JePaRRSHApPGOGsZt+BWld6iI7i6mH2BrWWqETgewMZskr75yH8HUD\nrCd3sg+w7yP+rlFDRypZLpmpKIknNgFVejzIsgOY2+E1IvQ6q2pDXZh9U1Y36vVY\nTanDwt08lRuxiCGewJ0Emb8k58exawc9Hv+QnggdFq/3BrJyIo92wQzI0ON9WOKQ\nIyiF6tNhAgMBAAECgf8u2lttO0JTktmTgzIq7hHM8q/s+xJ8cZ4Vgk4pWY9RovIp\n8H4OQGJmHc6dfAZBkE9TEB7pGPpc+rsyL64RXOuRvOkhTEYtJOh76xZ3AvI+e00T\n7fZXkDlUEA/TZZQ1M4MfQoZ2PfFmvj+WtKJW9+FIJi24FRhBDnTOghbnaVQHz+b9\ndIcW2vJ8xO82D83vbkSBOKvoMWxdVFE5+V8GQCCtmHZ+kFDEbvX6yVECv9ZyOYiI\nxveVN51TdiTtcI7iRSvqSGSuP4y+UDIuYwWOtjOZV1Hkx6U79eso2lsylGLTXnPc\n1y7+5OuOotPBFLOOuXSMTjqQ67/og6HSo9hZzBkCgYEA8nLh9rZpGKGO0TTrSLMx\nxnn89icB1LTZaP+0FYTPgLrLuxe97vXJQFZCzkeYWCz4Vy0L4T8go8YWk5JmjvPo\nVMhEct6LcC1osZcBPPeCWtE9EwBSJ9GrBRnzO8Sic/HsipFIiyUjVfhY3VGRaLL1\nkzvRg54BEDSYmNA1k02h26kCgYEA09Fq7RGtj0EON1bhoYgovo5bgueJtnOi2GXp\nBgCiwTfnOLTftw0YUjX0Vq+ZC+zzXFaOGzMl2PK8J2YUDNVSooNSVzFaRKCXkypg\nbcADdX4/8Nor/xe8RpaIeYa47WWPff+tlQ3YLfsc3lrs02mBfaZ2d7LSwUixITzj\nw//WTPkCgYEAq499tF3ZupNAA2xF/fjHhSH3TZvGoOSkX7dpkDydtQL5fVfMkBae\npYck2OEyvVp9FPsMSASqrRlUCnLzXb7crXnVbc9qriODzP8E4kZmmKstY4+7ku+7\n6+00ABwhtJgBgQBTbBsIiSImh93bXlIckmYm2NLq/7OoM6JJ9wVdPpkCgYEAlSiV\nSVf3hjdjkWim/p7pQjbxDh+KBGctt4EcNNPhyHpbYr1MBJU+GTZRV3HULmevf8ib\nzV+ZOUrFYGEroVXfGP2s0CW60TTdSA7BVMewJ969nBemf73xISwD8sACHXo1L58K\nVzomj0qTq6kPuFhFjXvZVLUiYGWWBjfglDbma9ECgYEA75ABFZnNJPElBSEaCDvJ\nauuaB2HtC/3OAYdDUMj9Iw2MPB6aBnD6icpYkQqk/zIVRr7HkWGCS+2xSUst0/em\ncF/WmSlb6tbBWqGJHf0PL24q7O2bf8YtrhS0RW2z1zrgs9lVrYhkogFDwR9wBbdi\nlxXBV3u80vROmdsdYXyw4lk=\n-----END PRIVATE KEY-----\n",
+  "client_email": "firebase-adminsdk-fbsvc@agentic-ai-startup.iam.gserviceaccount.com",
+  "client_id": "105928991960207433542",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-fbsvc%40agentic-ai-startup.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

main.py

@@ -0,0 +1,378 @@
+import os
+import uuid
+import time
+import json
+import asyncio
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional
+import socketio
+from firebase_admin import db, initialize_app, credentials, _apps
+from dotenv import load_dotenv
+from cryptography.fernet import Fernet
+from validation_agent import run_validation_agent
+from extractor_agent_runner import AgentOrchestrator
+from agent_architect import LiveAgentArchitect, AgentDeployer
+from agents import Runner, SQLiteSession, OpenAIChatCompletionsModel, Agent
+from openai import AsyncOpenAI as AgentsAsyncOpenAI
+
+load_dotenv()
+
+# --- Encryption setup ---
+ENCRYPTION_KEY = os.getenv("ENCRYPTION_KEY")
+if not ENCRYPTION_KEY:
+    raise ValueError("ENCRYPTION_KEY not set in .env")
+fernet = Fernet(ENCRYPTION_KEY.encode())
+
+def encrypt_api_key(api_key: str) -> str:
+    return fernet.encrypt(api_key.encode()).decode()
+
+def decrypt_api_key(encrypted_key: str) -> str:
+    return fernet.decrypt(encrypted_key.encode()).decode()
+
+# --- Firebase initialization ---
+cred = credentials.Certificate("firebase/serviceAccountKey.json")
+if not _apps:
+    initialize_app(cred, {'databaseURL': os.getenv("FIREBASE_DB_URL")})
+
+# --- FastAPI + Socket.IO setup ---
+app = FastAPI(title="AgentForge API", version="1.0.0")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+sio = socketio.AsyncServer(async_mode='asgi', cors_allowed_origins="*", max_http_buffer_size=10**8)
+socket_app = socketio.ASGIApp(sio, app)
+
+# --- Request/Response Models ---
+class ValidateRequest(BaseModel):
+    model: str = Field(..., description="Model name")
+    api_key: str = Field(..., description="API key to validate")
+
+class ValidateResponse(BaseModel):
+    is_valid: bool
+    error: Optional[str] = None
+    model: str
+
+class RunSessionRequest(BaseModel):
+    query: str = Field(..., description="User's business idea")
+    model: str = Field(default="gpt-4o", description="Model to use")
+    api_key: str = Field(default=os.getenv("OPENAI_API_KEY"), description="API key")
+
+class SessionResponse(BaseModel):
+    session_id: str
+    status: str = "created"
+
+class RunResponse(BaseModel):
+    status: str
+    result: dict
+
+class ChatWithAgentRequest(BaseModel):
+    agent_id: str = Field(..., description="Agent ID from build result")
+    message: str = Field(..., description="User message to the agent")
+    session_id: str = Field(..., description="Session ID")
+
+
+# --- Helper functions ---
+async def emit_log(session_id: str, message: str, type: str = "log"):
+    """Emit log to Firebase and Socket.IO"""
+    try:
+        ref = db.reference(f'sessions/{session_id}/logs')
+        ref.push({
+            'message': message,
+            'type': type,
+            'timestamp': time.time()
+        })
+        await sio.emit('log_update', {
+            'message': message, 
+            'type': type,
+            'timestamp': time.time()
+        }, room=session_id)
+    except Exception as e:
+        print(f"Error emitting log: {e}")
+
+async def save_session_result(session_id: str, result: dict):
+    """Save session result to Firebase"""
+    try:
+        ref = db.reference(f'sessions/{session_id}/result')
+        ref.set(result)
+    except Exception as e:
+        print(f"Error saving session result: {e}")
+
+
+# --- API Endpoints ---
+@app.get("/", tags=["Health"])
+async def root():
+    return {
+        "status": "AgentForge API Online",
+        "version": "1.0.0",
+        "features": ["validation", "extraction", "live_agent_builder"],
+        "socket_io": "initialized"
+    }
+
+@app.post("/validate", response_model=ValidateResponse, tags=["Validation"])
+async def validate_key(request: ValidateRequest) -> ValidateResponse:
+    try:
+        result = await run_validation_agent(request.model, request.api_key)
+        return ValidateResponse(
+            is_valid=result.is_valid,
+            error=result.error,
+            model=request.model
+        )
+    except Exception as e:
+        return ValidateResponse(
+            is_valid=False,
+            error=f"Validation error: {str(e)}",
+            model=request.model
+        )
+
+@app.post("/start", response_model=SessionResponse, tags=["Sessions"])
+async def start_session() -> SessionResponse:
+    session_id = str(uuid.uuid4())
+    try:
+        db.reference(f'sessions/{session_id}').set({
+            'status': 'awaiting_query',
+            'created_at': time.time(),
+            'logs': [],
+            'api_keys': {}
+        })
+        await emit_log(session_id, "Session started. Ready to receive query.", "system")
+        return SessionResponse(session_id=session_id, status="created")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to create session: {str(e)}")
+
+@app.post("/session/{sid}/run", response_model=RunResponse, tags=["Sessions"])
+async def run_agents(sid: str, request_data: RunSessionRequest) -> RunResponse:
+    """
+    Complete pipeline: Validation → Extraction → Live Agent Build
+    """
+    query = request_data.query
+    model = request_data.model.lower()
+    api_key = request_data.api_key
+
+    if not query or not model or not api_key:
+        await emit_log(sid, "Error: Missing required fields", "error")
+        raise HTTPException(status_code=400, detail="query, model, and api_key are required")
+
+    try:
+        # Step 1: Log start
+        await emit_log(sid, f"💬 User Query: {query}", "user")
+        await emit_log(sid, f"🤖 Model: {model}", "system")
+
+        # Step 2: Encrypt & store key
+        encrypted_key = encrypt_api_key(api_key)
+        db.reference(f'sessions/{sid}/api_keys/{model}').set(encrypted_key)
+        await emit_log(sid, f"🔐 API key encrypted", "success")
+        api_key_decrypted = decrypt_api_key(encrypted_key)
+
+        # Step 3: Validate API key
+        await emit_log(sid, "🔍 Validating API key...", "system")
+        validation = await run_validation_agent(model, api_key_decrypted)
+        
+        if not validation.is_valid:
+            await emit_log(sid, f"❌ Validation failed: {validation.error}", "error")
+            return RunResponse(
+                status="error",
+                result={"stage": "validation", "message": validation.error}
+            )
+        
+        await emit_log(sid, "✅ API key validated", "success")
+
+        # Step 4: Run extraction
+        await emit_log(sid, "🚀 Starting extraction...", "system")
+        orchestrator = AgentOrchestrator(session_id=sid)
+        extraction_result = await orchestrator.run(query, model, api_key_decrypted)
+
+        if extraction_result["status"] != "success":
+            await emit_log(sid, f"❌ Extraction failed", "error")
+            db.reference(f'sessions/{sid}').update({'status': 'error'})
+            return RunResponse(status="error", result=extraction_result)
+
+        await emit_log(sid, "✅ Extraction complete!", "success")
+        
+        # Step 5: BUILD LIVE AGENT (This is the missing part!)
+        await emit_log(sid, "🏗️ Building live OpenAI agent...", "system")
+        await emit_log(sid, "⚙️ Mapping features to tools...", "system")
+        
+        architect = LiveAgentArchitect(session_id=sid)
+        extraction_data = extraction_result.get('extraction', {})
+        
+        # Build the agent
+        agent_result = await architect.build_agent(extraction_data, model, api_key_decrypted)
+        
+        # Add agent build results to response
+        if agent_result.status == "success":
+            # Save to Firebase
+            await AgentDeployer.save_to_firebase(sid, agent_result.agent_config)
+            
+            # Deployment code is already in agent_result
+            deployment_code = agent_result.deployment_code
+            
+            # Add to result
+            extraction_result["agent_build"] = {
+                "status": "success",
+                "agent_id": agent_result.agent_config.agent_id,
+                "agent_name": agent_result.agent_config.name,
+                "model": agent_result.agent_config.model,
+                "tools": [
+                    {
+                        "name": tool.name,
+                        "description": tool.description,
+                        "parameters": tool.parameters
+                    } for tool in agent_result.agent_config.tools
+                ],
+                "tools_count": len(agent_result.agent_config.tools),
+                "tone": agent_result.agent_config.tone,
+                "instructions": agent_result.agent_config.instructions,
+                "test_response": agent_result.agent_test_response,
+                "deployment_code": deployment_code,
+                "business_context": agent_result.agent_config.business_context
+            }
+            
+            await emit_log(sid, f"✅ Agent '{agent_result.agent_config.name}' built!", "success")
+            await emit_log(sid, f"🆔 Agent ID: {agent_result.agent_config.agent_id}", "info")
+            await emit_log(sid, f"🔧 Tools: {len(agent_result.agent_config.tools)}", "info")
+            await emit_log(sid, f"🎭 Tone: {agent_result.agent_config.tone}", "info")
+            await emit_log(sid, f"\n💬 Test: {agent_result.agent_test_response[:100]}...", "info")
+            await emit_log(sid, "\n🎉 LIVE AGENT READY FOR DEPLOYMENT!", "success")
+        else:
+            await emit_log(sid, f"⚠️ Agent build failed: {agent_result.error}", "warning")
+            extraction_result["agent_build"] = {
+                "status": "error",
+                "error": agent_result.error
+            }
+
+        # Save final result
+        await save_session_result(sid, extraction_result)
+        
+        # Summary logs
+        business = extraction_data.get('business', {})
+        await emit_log(sid, f"\n📊 Business: {business.get('business_name')}", "result")
+        await emit_log(sid, f"🏭 Industry: {business.get('industry')}", "result")
+        
+        if extraction_result.get("agent_build", {}).get("status") == "success":
+            agent_build = extraction_result["agent_build"]
+            await emit_log(sid, f"\n🤖 Live Agent: {agent_build['agent_name']}", "success")
+            await emit_log(sid, f"🔧 Tools Available: {agent_build['tools_count']}", "success")
+            await emit_log(sid, "\n✅ Complete! Agent is live and ready.", "success")
+        
+        db.reference(f'sessions/{sid}').update({'status': 'completed'})
+        return RunResponse(status="success", result=extraction_result)
+
+    except Exception as e:
+        error_msg = str(e)
+        await emit_log(sid, f"💥 Error: {error_msg}", "error")
+        db.reference(f'sessions/{sid}').update({'status': 'error'})
+        raise HTTPException(status_code=500, detail=error_msg)
+
+
+@app.post("/agent/chat", tags=["Agent Execution"])
+async def chat_with_agent(request: ChatWithAgentRequest):
+    try:
+        agent_id = request.agent_id
+        user_message = request.message
+        session_id = request.session_id
+        
+        # Get agent configuration from Firebase
+        agent_ref = db.reference(f'agents/{agent_id}')
+        agent_data = agent_ref.get()
+        
+        if not agent_data:
+            raise HTTPException(status_code=404, detail="Agent not found")
+        
+        # Get encrypted API key from session
+        session_ref = db.reference(f'sessions/{session_id}/api_keys')
+        api_keys = session_ref.get()
+        
+        model = agent_data.get('model', 'gpt-4o')
+        model_key = model.split('-')[0] if '-' in model else model
+        
+        encrypted_key = None
+        for key_name, key_value in (api_keys or {}).items():
+            if model_key in key_name:
+                encrypted_key = key_value
+                break
+        
+        if not encrypted_key:
+            raise HTTPException(status_code=400, detail="API key not found for this model")
+        
+        api_key = decrypt_api_key(encrypted_key)
+        
+        # Setup OpenAI client
+        if "gemini" in model.lower():
+            client = AgentsAsyncOpenAI(api_key=api_key, base_url="https://generativelanguage.googleapis.com/v1beta/openai/")
+            model_name = "gemini-2.0-flash-exp"
+        elif "grok" in model.lower():
+            client = AgentsAsyncOpenAI(api_key=api_key, base_url="https://api.x.ai/v1")
+            model_name = "grok-beta"
+        else:
+            client = AgentsAsyncOpenAI(api_key=api_key)
+            model_name = "gpt-4o"
+        
+        MODEL = OpenAIChatCompletionsModel(model=model_name, openai_client=client)
+        
+        # === FIXED PART: Recreate tools safely using domain ===
+        from agent_architect import DynamicToolFactory
+        
+        domain = agent_data['business_context']['domain']
+        business_name = agent_data['business_context'].get('business_name', 'Agent')
+        
+        tools, _ = DynamicToolFactory.create_tools_for_domain(domain, business_name)
+        
+        agent = Agent(
+            name=agent_data['name'],
+            instructions=agent_data['instructions'],
+            model=MODEL,
+            tools=tools
+        )
+        # ======================================================
+
+        runner = Runner()
+        temp_session = SQLiteSession(f":memory:")
+        response = await runner.run(agent, user_message, session=temp_session)
+        final_output = str(response.final_output) if hasattr(response, 'final_output') else str(response)
+        
+        await emit_log(session_id, f"User: {user_message}", "user")
+        await emit_log(session_id, f"{agent_data['name']}: {final_output[:200]}...", "agent")
+        
+        return {
+            "status": "success",
+            "agent_id": agent_id,
+            "agent_name": agent_data['name'],
+            "user_message": user_message,
+            "agent_response": final_output,
+            "tools_used": [tool['name'] for tool in agent_data.get('tools', [])],
+            "timestamp": time.time()
+        }
+        
+    except Exception as e:
+        error_msg = str(e)
+        await emit_log(session_id, f"Agent error: {error_msg}", "error")
+        raise HTTPException(status_code=500, detail=error_msg)
+
+# --- Socket.IO Events ---
+@sio.event
+async def connect(sid, environ):
+    print(f"✅ Client connected: {sid}")
+
+@sio.event
+async def disconnect(sid):
+    print(f"❌ Client disconnected: {sid}")
+
+@sio.event
+async def join(sid, data):
+    session_id = data.get('session_id')
+    if session_id:
+        await sio.enter_room(sid, session_id)
+        print(f"👥 Client {sid} joined room: {session_id}")
+        await sio.emit('joined', {'session_id': session_id}, room=sid)
+
+
+# Mount Socket.IO - IMPORTANT: Do this LAST
+app.mount("/", socket_app)
+

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+python-multipart
+openai-agents
+PyMuPDF
+reportlab
+python-dotenv
+requests
+pydantic

schemas.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class ValidationResult(BaseModel):
+    is_valid: bool = Field(default=False, description="If API key is valid for model")
+    error: str = Field(default="", description="Validation error if any")
+
+class ExtractionResult(BaseModel):
+    business_type: str = Field(default="", description="Detected business type (1-3 words)")
+    core_actions: List[str] = Field(default_factory=list, description="List of 2-4 key actions")
+    required_tools: List[str] = Field(default_factory=list, description="Snake_case tool names")
+    tone: str = Field(default="friendly", description="friendly | professional | casual")
+    error: str = Field(default="", description="Extraction error if any")

test/test_connection.py

@@ -0,0 +1,70 @@
+import asyncio
+import json
+import httpx
+import socketio
+import time
+from firebase_admin import credentials, db, initialize_app
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+database_url = os.getenv("FIREBASE_DB_URL")
+
+
+cred = credentials.Certificate("firebase/serviceAccountKey.json")
+initialize_app(cred, {
+    'databaseURL': database_url
+})
+
+BASE_URL = "http://127.0.0.1:8000"
+
+async def test_full_flow():
+    print("TESTING DAY 1 CONNECTION...\n")
+
+    print("1. Creating session...")
+    resp = httpx.post(f"{BASE_URL}/start")
+    data = resp.json()
+    session_id = data["session_id"]
+    print(f"   Session ID: {session_id}")
+
+    print("\n2. Connecting to Socket.IO...")
+    sio = socketio.AsyncClient()
+
+    @sio.event
+    async def connect():
+        print("   Connected!")
+        await sio.emit('join', {'session_id': session_id})
+
+    @sio.on('log_update')
+    async def on_log(data):
+        print(f"   [{data['type']}] {data['message']}")
+
+    await sio.connect(BASE_URL)
+    print("   Joined room")
+
+    # 3. Send Query
+    print("\n3. Sending query...")
+    httpx.post(
+        f"{BASE_URL}/session/{session_id}/query",
+        json={
+            "query": "I want an agent for my online pharmacy that checks prescription validity and sends SMS confirmations",
+            "api_key": os.getenv("OPENAI_API_KEY")
+        }
+    )
+
+    print("\n4. Receiving live logs...\n")
+    await asyncio.sleep(8)
+
+    print("\n5. Verifying Firebase Realtime DB...")
+    ref = db.reference(f'sessions/{session_id}')
+    fb_data = ref.get()
+    print(f"   Status: {fb_data.get('status')}")
+    print(f"   Logs count: {len(fb_data.get('logs', []))}")
+    print(f"   User query: {fb_data.get('user_query')}")
+
+    await sio.disconnect()
+    print("\nDAY 1 CONNECTION: PASSED!")
+    print(f"   Firebase URL: https://console.firebase.google.com/project/_/database/realtime/data/sessions/{session_id}")
+
+if __name__ == "__main__":
+    asyncio.run(test_full_flow())

test/test_validation.py

@@ -0,0 +1,18 @@
+import asyncio
+from validation_agent import run_validation_agent
+
+async def main():
+    # Try different providers
+    print("Testing GPT...")
+    result_gpt = await run_validation_agent("gpt", "sk-test-valid")
+    print(result_gpt)
+
+    print("\nTesting Gemini...")
+    result_gemini = await run_validation_agent("gemini", "fake-key")
+    print(result_gemini)
+
+    print("\nTesting Grok...")
+    result_grok = await run_validation_agent("grok", "xai-valid-key")
+    print(result_grok)
+
+asyncio.run(main())

validation_agent.py

@@ -0,0 +1,190 @@
+# run_validation_agent.py
+import asyncio
+from openai import AsyncOpenAI
+from schemas import ValidationResult
+
+# ------------------------
+# GPT validation via OpenAI SDK (Direct)
+# ------------------------
+async def validate_gpt_key(api_key: str, model: str = "gpt-4o") -> ValidationResult:
+    """
+    Validates a GPT API key using OpenAI SDK directly.
+    """
+    try:
+        # Create OpenAI client
+        client = AsyncOpenAI(api_key=api_key)
+        
+        # Simple completion test
+        response = await client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are an API key validator."},
+                {"role": "user", "content": "ping"}
+            ],
+            max_tokens=10,
+            temperature=0
+        )
+        
+        # Check if we got a valid response
+        if response.choices and response.choices[0].message.content:
+            return ValidationResult(is_valid=True)
+        
+        return ValidationResult(
+            is_valid=False, 
+            error="No valid response from OpenAI API"
+        )
+
+    except Exception as e:
+        error_msg = str(e)
+        # Provide more specific error messages
+        if "invalid_api_key" in error_msg.lower():
+            error_msg = "Invalid API key"
+        elif "rate_limit" in error_msg.lower():
+            error_msg = "Rate limit exceeded"
+        elif "insufficient_quota" in error_msg.lower():
+            error_msg = "Insufficient quota/credits"
+        
+        return ValidationResult(
+            is_valid=False, 
+            error=f"GPT validation failed: {error_msg}"
+        )
+
+
+# ------------------------
+# Gemini (Google Generative AI) validation
+# ------------------------
+async def validate_gemini_key(api_key: str, model: str = "gemini-2.0-flash-exp") -> ValidationResult:
+    """
+    Validates a Gemini API key.
+    """
+    try:
+        import google.generativeai as genai
+        
+        # Configure with API key
+        genai.configure(api_key=api_key)
+        
+        # Try to generate content
+        model_instance = genai.GenerativeModel(model)
+        response = await model_instance.generate_content_async("ping")
+        
+        if response and response.text:
+            return ValidationResult(is_valid=True)
+        
+        return ValidationResult(
+            is_valid=False, 
+            error="No valid response from Gemini API"
+        )
+        
+    except Exception as e:
+        error_msg = str(e)
+        if "API_KEY_INVALID" in error_msg or "invalid" in error_msg.lower():
+            error_msg = "Invalid API key"
+        
+        return ValidationResult(
+            is_valid=False, 
+            error=f"Gemini validation failed: {error_msg}"
+        )
+
+
+# ------------------------
+# Grok (xAI) validation
+# ------------------------
+async def validate_grok_key(api_key: str, model: str = "grok-beta") -> ValidationResult:
+    """
+    Validates a Grok API key using OpenAI-compatible endpoint.
+    """
+    try:
+        # Grok uses OpenAI-compatible API
+        client = AsyncOpenAI(
+            api_key=api_key,
+            base_url="https://api.x.ai/v1"
+        )
+        
+        response = await client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": "You are an API key validator."},
+                {"role": "user", "content": "ping"}
+            ],
+            max_tokens=10,
+            temperature=0
+        )
+        
+        if response.choices and response.choices[0].message.content:
+            return ValidationResult(is_valid=True)
+        
+        return ValidationResult(
+            is_valid=False, 
+            error="No valid response from Grok API"
+        )
+        
+    except Exception as e:
+        error_msg = str(e)
+        if "invalid_api_key" in error_msg.lower():
+            error_msg = "Invalid API key"
+        
+        return ValidationResult(
+            is_valid=False, 
+            error=f"Grok validation failed: {error_msg}"
+        )
+
+
+# ------------------------
+# Main runner
+# ------------------------
+async def run_validation_agent(model: str, api_key: str) -> ValidationResult:
+    """
+    Validates API keys for GPT, Gemini, or Grok.
+    Routes to appropriate validator based on model name.
+    """
+    model_lower = model.lower()
+    
+    try:
+        if "gpt" in model_lower or "o1" in model_lower:
+            return await validate_gpt_key(api_key, model)
+        elif "gemini" in model_lower:
+            return await validate_gemini_key(api_key, model)
+        elif "grok" in model_lower:
+            return await validate_grok_key(api_key, model)
+        else:
+            return ValidationResult(
+                is_valid=False, 
+                error=f"Unsupported model: {model}"
+            )
+    except Exception as e:
+        return ValidationResult(
+            is_valid=False, 
+            error=f"Validation error: {str(e)}"
+        )
+
+
+# ------------------------
+# Optional test runner
+# ------------------------
+if __name__ == "__main__":
+    import os
+    from dotenv import load_dotenv
+    load_dotenv()
+
+    async def main():
+        tests = [
+            ("gpt-4o", "OPENAI_API_KEY"),
+            ("gemini-2.0-flash-exp", "GEMINI_API_KEY"),
+            ("grok-beta", "GROK_API_KEY")
+        ]
+        
+        for model, key_env in tests:
+            key = os.getenv(key_env, "")
+            if not key:
+                print(f"⚠️  {model.upper()}: No API key found in env ({key_env})\n")
+                continue
+                
+            print(f"Testing {model.upper()} key...")
+            result = await run_validation_agent(model, key)
+            
+            if result.is_valid:
+                print(f"✅ Valid\n")
+            else:
+                print(f"❌ Invalid | {result.error}\n")
+
+    asyncio.run(main())

web_search_agent.py

@@ -0,0 +1,20 @@
+from agents import Agent
+from confg import model
+from web_search_tool import web_search
+
+web_search_agent = Agent(
+    name = "Web Search Assistant",
+    instructions = (
+    "You are a web search assistant."
+    "For ANY query about current events, news, movies, weather, finance, or recent information,"
+    "you MUST call the `web_search` tool."
+    "Do not rely only on your internal knowledge."
+    "After searching, summarize the top results clearly and concisely in this format:\n\n"
+    "1. [Title] - short snippet (URL)\n"
+    "2. [Title] - short snippet (URL)\n"
+    "3. [Title] - short snippet (URL)\n\n"
+    "If no relevant results are found, politely say so."
+    ),
+    model = model,
+    tools = [web_search]
+)

web_search_tool.py

@@ -0,0 +1,10 @@
+from agents import function_tool
+from confg import tavily_client
+
+@function_tool
+def web_search(query: str):
+    """
+    Perform a deep web search using Tavily and return structured results.
+    """
+    response =tavily_client.search(query)
+    return f"Response {response}"