Add application file

.gitignore

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

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"]

app.py

@@ -0,0 +1,2007 @@
+# """# FastAPI application for JOBObike Chatbot API
+# Provides /chat and /chat-stream endpoints with rate limiting, CORS, and error handling
+# Updated with language context support
+# """
+# import os
+# import logging
+# import time
+# from typing import Optional
+# from collections import defaultdict
+# import resend
+
+# from fastapi import FastAPI, Request, HTTPException, status, Depends, Header
+# from fastapi.responses import StreamingResponse, JSONResponse
+# from fastapi.middleware.cors import CORSMiddleware
+# from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+# from pydantic import BaseModel
+# from slowapi import Limiter, _rate_limit_exceeded_handler
+# from slowapi.util import get_remote_address
+# from slowapi.errors import RateLimitExceeded
+# from slowapi.middleware import SlowAPIMiddleware
+# from dotenv import load_dotenv
+
+# from agents import Runner, RunContextWrapper
+# from agents.exceptions import InputGuardrailTripwireTriggered
+# from openai.types.responses import ResponseTextDeltaEvent
+# from chatbot.chatbot_agent import jobobike_assistant
+# from sessions.session_manager import session_manager
+
+# # Load environment variables
+# load_dotenv()
+
+# # Configure Resend
+# resend.api_key = os.getenv("RESEND_API_KEY")
+
+# # Configure logging
+# logging.basicConfig(
+#     level=logging.INFO,
+#     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+#     handlers=[
+#         logging.FileHandler('app.log'),
+#         logging.StreamHandler()
+#     ]
+# )
+# logger = logging.getLogger(__name__)
+
+# # Initialize rate limiter with enhanced security
+# limiter = Limiter(key_func=get_remote_address, default_limits=["100/day", "20/hour", "3/minute"])
+
+# # Create FastAPI app
+# app = FastAPI(
+#     title="JOBObike Chatbot API",
+#     description="AI-powered chatbot API for JOBObike services",
+#     version="1.0.0"
+# )
+
+# # Add rate limiter middleware
+# app.state.limiter = limiter
+# app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+# app.add_middleware(SlowAPIMiddleware)
+
+# # Configure CORS from environment variable
+# allowed_origins = os.getenv("ALLOWED_ORIGINS", "").split(",")
+# allowed_origins = [origin.strip() for origin in allowed_origins if origin.strip()]
+
+# if allowed_origins:
+#     app.add_middleware(
+#         CORSMiddleware,
+#         allow_origins=["*"] + allowed_origins,
+#         allow_credentials=True,
+#         allow_methods=["*"],
+#         allow_headers=["*"],
+#     )
+#     logger.info(f"CORS enabled for origins: {allowed_origins}")
+# else:
+#     logger.warning("No ALLOWED_ORIGINS set in .env - CORS disabled")
+
+# # Security setup
+# security = HTTPBearer()
+
+# # Enhanced rate limiting dictionaries
+# request_counts = defaultdict(list)  # Track requests per IP
+# TICKET_RATE_LIMIT = 5  # Max 5 tickets per hour per IP
+# TICKET_TIME_WINDOW = 3600  # 1 hour in seconds
+# MEETING_RATE_LIMIT = 3  # Max 3 meetings per hour per IP
+# MEETING_TIME_WINDOW = 3600  # 1 hour in seconds
+
+# # Request/Response models
+# class ChatRequest(BaseModel):
+#     message: str
+#     language: Optional[str] = "english"  # Default to English if not specified
+#     session_id: Optional[str] = None  # Session ID for chat history
+
+
+# class ChatResponse(BaseModel):
+#     response: str
+#     success: bool
+#     session_id: str  # Include session ID in response
+
+
+# class ErrorResponse(BaseModel):
+#     error: str
+#     detail: Optional[str] = None
+
+
+# class TicketRequest(BaseModel):
+#     name: str
+#     email: str
+#     message: str
+
+
+# class TicketResponse(BaseModel):
+#     success: bool
+#     message: str
+
+
+# class MeetingRequest(BaseModel):
+#     name: str
+#     email: str
+#     date: str  # ISO format date string
+#     time: str  # Time in HH:MM format
+#     timezone: str  # Timezone identifier
+#     duration: int  # Duration in minutes
+#     topic: str  # Meeting topic/title
+#     attendees: list[str]  # List of attendee emails
+#     description: Optional[str] = None  # Optional meeting description
+#     location: Optional[str] = "Google Meet"  # Meeting location/platform
+
+
+# class MeetingResponse(BaseModel):
+#     success: bool
+#     message: str
+#     meeting_id: Optional[str] = None  # Unique identifier for the meeting
+
+
+# # Security dependency for API key validation
+# async def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+#     """Verify API key for protected endpoints"""
+#     # In production, you would check against a database of valid keys
+#     # For now, we'll use an environment variable
+#     expected_key = os.getenv("API_KEY")
+#     if not expected_key or credentials.credentials != expected_key:
+#         raise HTTPException(
+#             status_code=status.HTTP_401_UNAUTHORIZED,
+#             detail="Invalid or missing API key",
+#         )
+#     return credentials.credentials
+
+
+# def is_ticket_rate_limited(ip_address: str) -> bool:
+#     """Check if an IP address has exceeded ticket submission rate limits"""
+#     current_time = time.time()
+#     # Clean old requests outside the time window
+#     request_counts[ip_address] = [
+#         req_time for req_time in request_counts[ip_address] 
+#         if current_time - req_time < TICKET_TIME_WINDOW
+#     ]
+    
+#     # Check if limit exceeded
+#     if len(request_counts[ip_address]) >= TICKET_RATE_LIMIT:
+#         return True
+    
+#     # Add current request
+#     request_counts[ip_address].append(current_time)
+#     return False
+
+
+# def is_meeting_rate_limited(ip_address: str) -> bool:
+#     """Check if an IP address has exceeded meeting scheduling rate limits"""
+#     current_time = time.time()
+#     # Clean old requests outside the time window
+#     request_counts[ip_address] = [
+#         req_time for req_time in request_counts[ip_address] 
+#         if current_time - req_time < MEETING_TIME_WINDOW
+#     ]
+    
+#     # Check if limit exceeded
+#     if len(request_counts[ip_address]) >= MEETING_RATE_LIMIT:
+#         return True
+    
+#     # Add current request
+#     request_counts[ip_address].append(current_time)
+#     return False
+
+
+# def query_jobobike_bot_stream(user_message: str, language: str = "english", session_id: Optional[str] = None):
+#     """
+#     Query the JOBObike bot with streaming - returns async generator.
+#     Now includes language context and session history.
+#     Implements fallback to non-streaming when streaming fails (e.g., with Gemini models).
+#     """
+#     logger.info(f"AGENT STREAM CALL: query_jobobike_bot_stream called with message='{user_message}', language='{language}', session_id='{session_id}'")
+    
+#     # Get session history if session_id is provided
+#     history = []
+#     if session_id:
+#         history = session_manager.get_session_history(session_id)
+#         logger.info(f"Retrieved {len(history)} history messages for session {session_id}")
+    
+#     try:
+#         # Create context with language preference and history
+#         context_data = {"language": language}
+#         if history:
+#             context_data["history"] = history
+            
+#         ctx = RunContextWrapper(context=context_data)
+        
+#         result = Runner.run_streamed(
+#             jobobike_assistant,
+#             input=user_message,
+#             context=ctx.context
+#         )
+
+#         async def generate_stream():
+#             try:
+#                 previous = ""
+#                 has_streamed = True
+
+#                 try:
+#                     # Attempt streaming with error handling for each event
+#                     async for event in result.stream_events():
+#                         try:
+#                             if event.type == "raw_response_event" and isinstance(event.data, ResponseTextDeltaEvent):
+#                                 delta = event.data.delta or ""
+
+#                                 # ---- Spacing Fix ----
+#                                 if (
+#                                     previous
+#                                     and not previous.endswith((" ", "\n"))
+#                                     and not delta.startswith((" ", ".", ",", "?", "!", ":", ";"))
+#                                 ):
+#                                     delta = " " + delta
+
+#                                 previous = delta
+#                                 # ---- End Fix ----
+
+#                                 yield f"data: {delta}\n\n"
+#                                 has_streamed = True
+#                         except Exception as event_error:
+#                             # Handle individual event errors (e.g., missing logprobs field)
+#                             logger.warning(f"Event processing error: {event_error}")
+#                             continue
+                    
+#                     yield "data: [DONE]\n\n"
+#                     logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream completed successfully")
+                
+#                 except Exception as stream_error:
+#                     # Fallback to non-streaming if streaming fails
+#                     logger.warning(f"Streaming failed, falling back to non-streaming: {stream_error}")
+                    
+#                     if not has_streamed:
+#                         # Get final output using the streaming result's final_output property
+#                         # Wait for the stream to complete to get final output
+#                         try:
+#                             # Use the non-streaming API as fallback
+#                             fallback_response = await Runner.run(
+#                                 jobobike_assistant,
+#                                 input=user_message,
+#                                 context=ctx.context
+#                             )
+                            
+#                             if hasattr(fallback_response, 'final_output'):
+#                                 final_output = fallback_response.final_output
+#                             else:
+#                                 final_output = fallback_response
+                            
+#                             if hasattr(final_output, 'content'):
+#                                 response_text = final_output.content
+#                             elif isinstance(final_output, str):
+#                                 response_text = final_output
+#                             else:
+#                                 response_text = str(final_output)
+                            
+#                             yield f"data: {response_text}\n\n"
+#                             yield "data: [DONE]\n\n"
+#                             logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream fallback completed successfully")
+#                         except Exception as fallback_error:
+#                             logger.error(f"Fallback also failed: {fallback_error}", exc_info=True)
+#                             yield f"data: [ERROR] Unable to complete request.\n\n"
+#                     else:
+#                         # Already streamed some content, just end gracefully
+#                         yield "data: [DONE]\n\n"
+
+#             except InputGuardrailTripwireTriggered as e:
+#                 logger.warning(f"Guardrail blocked query during streaming: {e}")
+#                 yield f"data: [ERROR] Query was blocked by content guardrail.\n\n"
+
+#             except Exception as e:
+#                 logger.error(f"Streaming error: {e}", exc_info=True)
+#                 yield f"data: [ERROR] {str(e)}\n\n"
+
+#         return generate_stream()
+
+#     except Exception as e:
+#         logger.error(f"Error setting up stream: {e}", exc_info=True)
+
+#         async def error_stream():
+#             yield f"data: [ERROR] Failed to initialize stream.\n\n"
+
+#         return error_stream()
+
+
+# async def query_jobobike_bot(user_message: str, language: str = "english", session_id: Optional[str] = None):
+#     """
+#     Query the JOBObike bot - returns complete response.
+#     Now includes language context and session history.
+#     """
+#     logger.info(f"AGENT CALL: query_jobobike_bot called with message='{user_message}', language='{language}', session_id='{session_id}'")
+    
+#     # Get session history if session_id is provided
+#     history = []
+#     if session_id:
+#         history = session_manager.get_session_history(session_id)
+#         logger.info(f"Retrieved {len(history)} history messages for session {session_id}")
+    
+#     try:
+#         # Create context with language preference and history
+#         context_data = {"language": language}
+#         if history:
+#             context_data["history"] = history
+            
+#         ctx = RunContextWrapper(context=context_data)
+        
+#         response = await Runner.run(
+#             jobobike_assistant,
+#             input=user_message,
+#             context=ctx.context
+#         )
+#         logger.info("AGENT RESULT: query_jobobike_bot completed successfully")
+#         return response.final_output
+
+#     except InputGuardrailTripwireTriggered as e:
+#         logger.warning(f"Guardrail blocked query: {e}")
+#         raise HTTPException(
+#             status_code=status.HTTP_403_FORBIDDEN,
+#             detail="Query was blocked by content guardrail. Please ensure your query is related to JOBObike services."
+#         )
+#     except Exception as e:
+#         logger.error(f"Error in query_jobobike_bot: {e}", exc_info=True)
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="An internal error occurred while processing your request."
+#         )
+
+
+# @app.get("/")
+# async def root():
+#     return {"status": "ok", "service": "JOBObike Chatbot API"}
+
+
+# @app.get("/health")
+# async def health():
+#     return {"status": "healthy"}
+
+
+# @app.post("/session")
+# async def create_session():
+#     """
+#     Create a new chat session
+#     Returns a session ID that can be used to maintain chat history
+#     """
+#     try:
+#         session_id = session_manager.create_session()
+#         logger.info(f"Created new session: {session_id}")
+#         return {"session_id": session_id, "message": "Session created successfully"}
+#     except Exception as e:
+#         logger.error(f"Error creating session: {e}", exc_info=True)
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="Failed to create session"
+#         )
+
+
+# @app.post("/chat", response_model=ChatResponse)
+# @limiter.limit("10/minute")  # Limit to 10 requests per minute per IP
+# async def chat(request: Request, chat_request: ChatRequest):
+#     """
+#     Standard chat endpoint with language support and session history.
+#     Accepts: {"message": "...", "language": "norwegian", "session_id": "optional-session-id"}
+#     """
+#     try:
+#         # Create or use existing session
+#         session_id = chat_request.session_id
+#         if not session_id:
+#             session_id = session_manager.create_session()
+#             logger.info(f"Created new session for chat: {session_id}")
+        
+#         logger.info(
+#             f"Chat request from {get_remote_address(request)}: "
+#             f"language={chat_request.language}, message={chat_request.message[:50]}..., session_id={session_id}"
+#         )
+
+#         # Add user message to session history
+#         session_manager.add_message_to_history(session_id, "user", chat_request.message)
+        
+#         # Pass language and session to the bot
+#         response = await query_jobobike_bot(
+#             chat_request.message, 
+#             language=chat_request.language,
+#             session_id=session_id
+#         )
+
+#         if hasattr(response, 'content'):
+#             response_text = response.content
+#         elif isinstance(response, str):
+#             response_text = response
+#         else:
+#             response_text = str(response)
+        
+#         # Add bot response to session history
+#         session_manager.add_message_to_history(session_id, "assistant", response_text)
+
+#         logger.info(f"Chat response generated successfully in {chat_request.language} for session {session_id}")
+
+#         return ChatResponse(
+#             response=response_text,
+#             success=True,
+#             session_id=session_id
+#         )
+
+#     except HTTPException:
+#         raise
+#     except Exception as e:
+#         logger.error(f"Unexpected error in /chat: {e}", exc_info=True)
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="An internal error occurred while processing your request."
+#         )
+
+
+# @app.post("/api/messages", response_model=ChatResponse)
+# @limiter.limit("10/minute")  # Same rate limit as /chat
+# async def api_messages(request: Request, chat_request: ChatRequest):
+#     """
+#     Frontend-friendly chat endpoint at /api/messages.
+#     Exactly mirrors /chat logic for session/history support.
+#     Expects: {"message": "...", "language": "english", "session_id": "optional"}
+#     """
+#     client_ip = get_remote_address(request)
+#     logger.info(f"API Messages request from {client_ip}: message='{chat_request.message[:50]}...', lang='{chat_request.language}', session='{chat_request.session_id}'")
+    
+#     try:
+#         # Create/use session (Firestore-backed)
+#         session_id = chat_request.session_id
+#         if not session_id:
+#             session_id = session_manager.create_session()
+#             logger.info(f"New session created for /api/messages: {session_id}")
+        
+#         # Save user message to history
+#         session_manager.add_message_to_history(session_id, "user", chat_request.message)
+        
+#         # Call your existing bot query function
+#         response = await query_jobobike_bot(
+#             user_message=chat_request.message,
+#             language=chat_request.language,
+#             session_id=session_id
+#         )
+        
+#         # Extract response text
+#         response_text = (
+#             response.content if hasattr(response, 'content')
+#             else response if isinstance(response, str)
+#             else str(response)
+#         )
+        
+#         # Save AI response to history
+#         session_manager.add_message_to_history(session_id, "assistant", response_text)
+        
+#         logger.info(f"API Messages success: Response sent for session {session_id}")
+        
+#         return ChatResponse(
+#             response=response_text,
+#             success=True,
+#             session_id=session_id
+#         )
+    
+#     except InputGuardrailTripwireTriggered as e:
+#         logger.warning(f"Guardrail blocked /api/messages: {e}")
+#         raise HTTPException(
+#             status_code=403,
+#             detail="Query blocked – please ask about JOBObike services."
+#         )
+#     except Exception as e:
+#         logger.error(f"Error in /api/messages: {e}", exc_info=True)
+#         raise HTTPException(
+#             status_code=500,
+#             detail="Internal error – try again."
+#         )
+
+# @app.post("/chat-stream")
+# @limiter.limit("10/minute")  # Limit to 10 requests per minute per IP
+# async def chat_stream(request: Request, chat_request: ChatRequest):
+#     """
+#     Streaming chat endpoint with language support and session history.
+#     Accepts: {"message": "...", "language": "norwegian", "session_id": "optional-session-id"}
+#     """
+#     try:
+#         # Create or use existing session
+#         session_id = chat_request.session_id
+#         if not session_id:
+#             session_id = session_manager.create_session()
+#             logger.info(f"Created new session for streaming chat: {session_id}")
+        
+#         logger.info(
+#             f"Stream request from {get_remote_address(request)}: "
+#             f"language={chat_request.language}, message={chat_request.message[:50]}..., session_id={session_id}"
+#         )
+
+#         # Add user message to session history
+#         session_manager.add_message_to_history(session_id, "user", chat_request.message)
+        
+#         # Pass language and session to the streaming bot
+#         stream_generator = query_jobobike_bot_stream(
+#             chat_request.message,
+#             language=chat_request.language,
+#             session_id=session_id
+#         )
+
+#         # Note: For streaming, we add the response to history after the stream completes
+#         # This would need to be handled in the frontend by making a separate call or
+#         # by modifying the stream generator to add the complete response to history
+        
+#         return StreamingResponse(
+#             stream_generator,
+#             media_type="text/event-stream",
+#             headers={
+#                 "Cache-Control": "no-cache",
+#                 "Connection": "keep-alive",
+#                 "X-Accel-Buffering": "no",
+#                 "Session-ID": session_id  # Include session ID in headers
+#             }
+#         )
+
+#     except HTTPException:
+#         raise
+#     except Exception as e:
+#         logger.error(f"Unexpected error in /chat-stream: {e}", exc_info=True)
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="An internal error occurred while processing your request."
+#         )
+
+
+# @app.post("/ticket", response_model=TicketResponse)
+# @limiter.limit("5/hour")  # Limit to 5 tickets per hour per IP
+# async def submit_ticket(request: Request, ticket_request: TicketRequest):
+#     """
+#     Submit a support ticket via email using Resend API.
+#     Accepts: {"name": "John Doe", "email": "john@example.com", "message": "Issue description"}
+#     """
+#     try:
+#         client_ip = get_remote_address(request)
+#         logger.info(f"Ticket submission request from {ticket_request.name} ({ticket_request.email}) - IP: {client_ip}")
+        
+#         # Additional rate limiting for tickets
+#         if is_ticket_rate_limited(client_ip):
+#             logger.warning(f"Rate limit exceeded for ticket submission from IP: {client_ip}")
+#             raise HTTPException(
+#                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+#                 detail="Too many ticket submissions. Please try again later."
+#             )
+        
+#         # Get admin email from environment variables or use a default
+#         admin_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+#         # Use a verified sender email (you need to verify this in your Resend account)
+#         # For testing purposes, you can use your Resend account's verified domain
+#         sender_email = os.getenv("SENDER_EMAIL", "onboarding@resend.dev")
+        
+#         # Prepare the email using Resend
+#         params = {
+#             "from": sender_email,
+#             "to": [admin_email],
+#             "subject": f"Support Ticket from {ticket_request.name}",
+#             "html": f"""
+#             <p>Hello Admin,</p>
+#             <p>A new support ticket has been submitted:</p>
+#             <p><strong>Name:</strong> {ticket_request.name}</p>
+#             <p><strong>Email:</strong> {ticket_request.email}</p>
+#             <p><strong>Message:</strong></p>
+#             <p>{ticket_request.message}</p>
+#             <p><strong>IP Address:</strong> {client_ip}</p>
+#             <br>
+#             <p>Best regards,<br>JOBObike Support Team</p>
+#             """
+#         }
+
+#         # Send the email
+#         email = resend.Emails.send(params)
+        
+#         logger.info(f"Ticket submitted successfully by {ticket_request.name} from IP: {client_ip}")
+        
+#         return TicketResponse(
+#             success=True,
+#             message="Ticket submitted successfully. We'll get back to you soon."
+#         )
+
+#     except HTTPException:
+#         raise
+#     except Exception as e:
+#         logger.error(f"Error submitting ticket: {e}", exc_info=True)
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="Failed to submit ticket. Please try again later."
+#         )
+
+
+# @app.post("/schedule-meeting", response_model=MeetingResponse)
+# @limiter.limit("3/hour")  # Limit to 3 meetings per hour per IP
+# async def schedule_meeting(request: Request, meeting_request: MeetingRequest):
+#     """
+#     Schedule a meeting and send email invitations using Resend API.
+#     Accepts meeting details and sends professional email invitations to organizer and attendees.
+#     """
+#     try:
+#         client_ip = get_remote_address(request)
+#         logger.info(f"Meeting scheduling request from {meeting_request.name} ({meeting_request.email}) - IP: {client_ip}")
+        
+#         # Additional rate limiting for meetings
+#         if is_meeting_rate_limited(client_ip):
+#             logger.warning(f"Rate limit exceeded for meeting scheduling from IP: {client_ip}")
+#             raise HTTPException(
+#                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+#                 detail="Too many meeting requests. Please try again later."
+#             )
+        
+#         # Generate a unique meeting ID
+#         meeting_id = f"mtg_{int(time.time())}"
+        
+#         # Get admin email from environment variables or use a default
+#         admin_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+#         # Use a verified sender email (you need to verify this in your Resend account)
+#         sender_email = os.getenv("SENDER_EMAIL", "onboarding@resend.dev")
+        
+#         # For Resend testing limitations, we can only send to the owner's email
+#         # In production, you would verify a domain and use that instead
+#         owner_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+#         # Format date and time for display
+#         formatted_datetime = f"{meeting_request.date} at {meeting_request.time} {meeting_request.timezone}"
+        
+#         # Create calendar link (Google Calendar link example)
+#         calendar_link = f"https://calendar.google.com/calendar/render?action=TEMPLATE&text={meeting_request.topic}&dates={meeting_request.date.replace('-', '')}T{meeting_request.time.replace(':', '')}00Z/{meeting_request.date.replace('-', '')}T{meeting_request.time.replace(':', '')}00Z&details={meeting_request.description or 'Meeting scheduled via JOBObike'}&location={meeting_request.location}"
+        
+#         # Combine all attendees (organizer + additional attendees)
+#         # Validate and format email addresses
+#         all_attendees = [meeting_request.email]
+        
+#         # Validate additional attendees - they must be valid email addresses
+#         for attendee in meeting_request.attendees:
+#             # Simple email validation
+#             if "@" in attendee and "." in attendee:
+#                 all_attendees.append(attendee)
+#             else:
+#                 # If not a valid email, skip or treat as name only
+#                 logger.warning(f"Invalid email format for attendee: {attendee}. Skipping.")
+        
+#         # Remove duplicates while preserving order
+#         seen = set()
+#         unique_attendees = []
+#         for email in all_attendees:
+#             if email not in seen:
+#                 seen.add(email)
+#                 unique_attendees.append(email)
+#         all_attendees = unique_attendees
+        
+#         # Prepare the professional HTML email template
+#         html_template = f"""
+#         <!DOCTYPE html>
+#         <html>
+#         <head>
+#             <meta charset="UTF-8">
+#             <meta name="viewport" content="width=device-width, initial-scale=1.0">
+#             <title>Meeting Scheduled - {meeting_request.topic}</title>
+#         </head>
+#         <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+#             <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; text-align: center; border-radius: 10px 10px 0 0;">
+#                 <h1 style="margin: 0; font-size: 28px;">Meeting Confirmed!</h1>
+#                 <p style="font-size: 18px; margin-top: 10px;">Your meeting has been successfully scheduled</p>
+#             </div>
+            
+#             <div style="background-color: #ffffff; padding: 30px; border: 1px solid #eaeaea; border-top: none; border-radius: 0 0 10px 10px;">
+#                 <h2 style="color: #333;">Meeting Details</h2>
+                
+#                 <div style="background-color: #f8f9fa; padding: 20px; border-radius: 8px; margin: 20px 0;">
+#                     <table style="width: 100%; border-collapse: collapse;">
+#                         <tr>
+#                             <td style="padding: 8px 0; font-weight: bold; width: 30%;">Topic:</td>
+#                             <td style="padding: 8px 0;">{meeting_request.topic}</td>
+#                         </tr>
+#                         <tr style="background-color: #f0f0f0;">
+#                             <td style="padding: 8px 0; font-weight: bold;">Date & Time:</td>
+#                             <td style="padding: 8px 0;">{formatted_datetime}</td>
+#                         </tr>
+#                         <tr>
+#                             <td style="padding: 8px 0; font-weight: bold;">Duration:</td>
+#                             <td style="padding: 8px 0;">{meeting_request.duration} minutes</td>
+#                         </tr>
+#                         <tr style="background-color: #f0f0f0;">
+#                             <td style="padding: 8px 0; font-weight: bold;">Location:</td>
+#                             <td style="padding: 8px 0;">{meeting_request.location}</td>
+#                         </tr>
+#                         <tr>
+#                             <td style="padding: 8px 0; font-weight: bold;">Organizer:</td>
+#                             <td style="padding: 8px 0;">{meeting_request.name} ({meeting_request.email})</td>
+#                         </tr>
+#                     </table>
+#                 </div>
+                
+#                 <div style="margin: 25px 0;">
+#                     <h3 style="color: #333;">Description</h3>
+#                     <p style="background-color: #f8f9fa; padding: 15px; border-radius: 8px; white-space: pre-wrap;">{meeting_request.description or 'No description provided.'}</p>
+#                 </div>
+                
+#                 <div style="margin: 25px 0;">
+#                     <h3 style="color: #333;">Attendees</h3>
+#                     <ul style="background-color: #f8f9fa; padding: 15px; border-radius: 8px;">
+#                         {''.join([f'<li>{attendee}</li>' for attendee in all_attendees])}
+#                     </ul>
+#                     <p style="font-size: 12px; color: #666; margin-top: 5px;">Note: Only valid email addresses will receive invitations.</p>
+#                 </div>
+                
+#                 <div style="text-align: center; margin: 30px 0;">
+#                     <a href="{calendar_link}" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 12px 25px; text-decoration: none; border-radius: 5px; font-weight: bold; display: inline-block;">Add to Calendar</a>
+#                 </div>
+                
+#                 <div style="background-color: #e3f2fd; padding: 15px; border-radius: 8px; margin-top: 25px;">
+#                     <p style="margin: 0;"><strong>Meeting ID:</strong> {meeting_id}</p>
+#                     <p style="margin: 10px 0 0 0; font-size: 14px; color: #666;">Need to make changes? Contact the organizer or reply to this email.</p>
+#                 </div>
+#             </div>
+            
+#             <div style="text-align: center; margin-top: 30px; color: #888; font-size: 14px;">
+#                 <p>This meeting was scheduled through JOBObike Chatbot Services</p>
+#                 <p><strong>Note:</strong> Due to Resend testing limitations, this email is only sent to the administrator. In production, after domain verification, invitations will be sent to all attendees.</p>
+#                 <p>© 2025 JOBObike. All rights reserved.</p>
+#             </div>
+#         </body>
+#         </html>
+#         """
+        
+#         # Send email to all attendees
+#         # Check if we have valid attendees to send to
+#         if not all_attendees:
+#             logger.warning("No valid email addresses found for meeting attendees")
+#             return MeetingResponse(
+#                 success=True,
+#                 message="Meeting scheduled successfully, but no valid email addresses found for invitations.",
+#                 meeting_id=meeting_id
+#             )
+        
+#         # For Resend testing limitations, we can only send to the owner's email
+#         # In production, you would verify a domain and send to all attendees
+#         owner_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+#         # Prepare email for owner with all attendee information
+#         attendee_list_html = ''.join([f'<li>{attendee}</li>' for attendee in all_attendees])
+#         # In a real implementation, you would send to all attendees after verifying your domain
+#         # For now, we're sending to the owner with information about all attendees
+        
+#         params = {
+#             "from": sender_email,
+#             "to": [owner_email],  # Only send to owner due to Resend testing limitations
+#             "subject": f"Meeting Scheduled: {meeting_request.topic}",
+#             "html": html_template
+#         }
+        
+#         # Send the email
+#         try:
+#             email = resend.Emails.send(params)
+#             logger.info(f"Email sent successfully to {len(all_attendees)} attendees")
+#         except Exception as email_error:
+#             logger.error(f"Failed to send email: {email_error}", exc_info=True)
+#             # Even if email fails, we still consider the meeting scheduled
+#             return MeetingResponse(
+#                 success=True,
+#                 message="Meeting scheduled successfully, but failed to send email invitations.",
+#                 meeting_id=meeting_id
+#             )
+        
+#         logger.info(f"Meeting scheduled successfully by {meeting_request.name} from IP: {client_ip}")
+        
+#         return MeetingResponse(
+#             success=True,
+#             message="Meeting scheduled successfully. Due to Resend testing limitations, invitations are only sent to the administrator. In production, after verifying your domain, invitations will be sent to all attendees.",
+#             meeting_id=meeting_id
+#         )
+
+#     except HTTPException:
+#         raise
+#     except Exception as e:
+#         logger.error(f"Error scheduling meeting: {e}", exc_info=True)
+#         raise HTTPException(
+#             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#             detail="Failed to schedule meeting. Please try again later."
+#         )
+
+
+# @app.exception_handler(Exception)
+# async def global_exception_handler(request: Request, exc: Exception):
+#     logger.error(
+#         f"Unhandled exception: {exc}",
+#         exc_info=True,
+#         extra={
+#             "path": request.url.path,
+#             "method": request.method,
+#             "client": get_remote_address(request)
+#         }
+#     )
+
+#     return JSONResponse(
+#         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+#         content={
+#             "error": "Internal server error",
+#             "detail": "An unexpected error occurred. Please try again later."
+#         }
+#     )
+
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+"""
+FastAPI application for JOBObike Chatbot API
+Provides /chat and /chat-stream endpoints with rate limiting, CORS, and error handling
+Updated with language context support and FIXED spacing issue in streaming
+"""
+import os
+import logging
+import time
+from typing import Optional
+from collections import defaultdict
+import resend
+
+from fastapi import FastAPI, Request, HTTPException, status, Depends, Header
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from pydantic import BaseModel
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+from slowapi.middleware import SlowAPIMiddleware
+from dotenv import load_dotenv
+
+from agents import Runner, RunContextWrapper
+from agents.exceptions import InputGuardrailTripwireTriggered
+from openai.types.responses import ResponseTextDeltaEvent
+from openai import BadRequestError as OpenAIBadRequestError
+from chatbot.chatbot_agent import jobobike_assistant
+from sessions.session_manager import session_manager
+
+# Load environment variables
+load_dotenv()
+
+# Configure Resend
+resend.api_key = os.getenv("RESEND_API_KEY")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Initialize rate limiter with enhanced security
+limiter = Limiter(key_func=get_remote_address, default_limits=["100/day", "20/hour", "3/minute"])
+
+# Create FastAPI app
+app = FastAPI(
+    title="JOBObike Chatbot API",
+    description="AI-powered chatbot API for JOBObike services",
+    version="1.0.0"
+)
+
+# Add rate limiter middleware
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+app.add_middleware(SlowAPIMiddleware)
+
+# Configure CORS from environment variable
+allowed_origins = os.getenv("ALLOWED_ORIGINS", "").split(",")
+allowed_origins = [origin.strip() for origin in allowed_origins if origin.strip()]
+
+# Always allow common localhost origins for development
+default_origins = [
+    "http://localhost:3000",
+    "http://localhost:3001", 
+    "http://localhost:5173",
+    "http://localhost:5174",
+    "http://127.0.0.1:3000",
+    "http://127.0.0.1:3001",
+    "http://127.0.0.1:5173",
+    "http://127.0.0.1:5174",
+]
+
+# Combine default origins with environment origins
+all_origins = default_origins + allowed_origins
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=all_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+logger.info(f"CORS enabled for origins: {all_origins}")
+
+# Security setup
+security = HTTPBearer()
+
+# Enhanced rate limiting dictionaries
+request_counts = defaultdict(list)  # Track requests per IP
+TICKET_RATE_LIMIT = 5  # Max 5 tickets per hour per IP
+TICKET_TIME_WINDOW = 3600  # 1 hour in seconds
+MEETING_RATE_LIMIT = 3  # Max 3 meetings per hour per IP
+MEETING_TIME_WINDOW = 3600  # 1 hour in seconds
+
+# Request/Response models
+class ChatRequest(BaseModel):
+    message: str
+    language: Optional[str] = "english"  # Default to English if not specified
+    session_id: Optional[str] = None  # Session ID for chat history
+
+
+class ChatResponse(BaseModel):
+    response: str
+    success: bool
+    session_id: str  # Include session ID in response
+
+
+class ErrorResponse(BaseModel):
+    error: str
+    detail: Optional[str] = None
+
+
+class TicketRequest(BaseModel):
+    name: str
+    email: str
+    message: str
+
+
+class TicketResponse(BaseModel):
+    success: bool
+    message: str
+
+
+class MeetingRequest(BaseModel):
+    name: str
+    email: str
+    date: str  # ISO format date string
+    time: str  # Time in HH:MM format
+    timezone: str  # Timezone identifier
+    duration: int  # Duration in minutes
+    topic: str  # Meeting topic/title
+    attendees: list[str]  # List of attendee emails
+    description: Optional[str] = None  # Optional meeting description
+    location: Optional[str] = "Google Meet"  # Meeting location/platform
+
+
+class MeetingResponse(BaseModel):
+    success: bool
+    message: str
+    meeting_id: Optional[str] = None  # Unique identifier for the meeting
+
+
+# Security dependency for API key validation
+async def verify_api_key(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    """Verify API key for protected endpoints"""
+    # In production, you would check against a database of valid keys
+    # For now, we'll use an environment variable
+    expected_key = os.getenv("API_KEY")
+    if not expected_key or credentials.credentials != expected_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or missing API key",
+        )
+    return credentials.credentials
+
+
+def is_ticket_rate_limited(ip_address: str) -> bool:
+    """Check if an IP address has exceeded ticket submission rate limits"""
+    current_time = time.time()
+    # Clean old requests outside the time window
+    request_counts[ip_address] = [
+        req_time for req_time in request_counts[ip_address] 
+        if current_time - req_time < TICKET_TIME_WINDOW
+    ]
+    
+    # Check if limit exceeded
+    if len(request_counts[ip_address]) >= TICKET_RATE_LIMIT:
+        return True
+    
+    # Add current request
+    request_counts[ip_address].append(current_time)
+    return False
+
+
+def is_meeting_rate_limited(ip_address: str) -> bool:
+    """Check if an IP address has exceeded meeting scheduling rate limits"""
+    current_time = time.time()
+    # Clean old requests outside the time window
+    request_counts[ip_address] = [
+        req_time for req_time in request_counts[ip_address] 
+        if current_time - req_time < MEETING_TIME_WINDOW
+    ]
+    
+    # Check if limit exceeded
+    if len(request_counts[ip_address]) >= MEETING_RATE_LIMIT:
+        return True
+    
+    # Add current request
+    request_counts[ip_address].append(current_time)
+    return False
+
+
+# def query_jobobike_bot_stream(user_message: str, language: str = "english", session_id: Optional[str] = None):
+#     """
+#     Query the JOBObike bot with streaming - returns async generator.
+#     Now includes language context and session history.
+#     FIXED: Proper spacing between words in streaming responses.
+#     Implements fallback to non-streaming when streaming fails (e.g., with Gemini models).
+#     """
+#     logger.info(f"AGENT STREAM CALL: query_jobobike_bot_stream called with message='{user_message}', language='{language}', session_id='{session_id}'")
+    
+#     # Get session history if session_id is provided
+#     history = []
+#     if session_id:
+#         history = session_manager.get_session_history(session_id)
+#         logger.info(f"Retrieved {len(history)} history messages for session {session_id}")
+    
+#     try:
+#         # Create context with language preference and history
+#         context_data = {"language": language}
+#         if history:
+#             context_data["history"] = history
+            
+#         ctx = RunContextWrapper(context=context_data)
+        
+#         result = Runner.run_streamed(
+#             jobobike_assistant,
+#             input=user_message,
+#             context=ctx.context
+#         )
+
+#         async def generate_stream():
+#             try:
+#                 accumulated_text = ""  # FIXED: Track full response for proper spacing
+#                 has_streamed = False
+
+#                 try:
+#                     # Attempt streaming with error handling for each event
+#                     async for event in result.stream_events():
+#                         try:
+#                             if event.type == "raw_response_event" and isinstance(event.data, ResponseTextDeltaEvent):
+#                                 delta = event.data.delta or ""
+
+#                                 # ---- Spacing Fix (CORRECTED) ----
+#                                 # Check against accumulated text, not just previous chunk
+#                                 if (
+#                                     accumulated_text  # Only add space if we have previous text
+#                                     and not accumulated_text.endswith((" ", "\n", "\t"))  # Previous doesn't end with whitespace
+#                                     and not delta.startswith((" ", ".", ",", "?", "!", ":", ";", "\n", "\t", ")", "]", "}", "'", '"'))  # Current doesn't start with punctuation/whitespace
+#                                     and delta  # Make sure delta isn't empty
+#                                 ):
+#                                     delta = " " + delta
+
+#                                 accumulated_text += delta  # Update accumulated text
+#                                 # ---- End Fix ----
+
+#                                 yield f"data: {delta}\n\n"
+#                                 has_streamed = True
+#                         except Exception as event_error:
+#                             # Handle individual event errors (e.g., missing logprobs field)
+#                             logger.warning(f"Event processing error: {event_error}")
+#                             continue
+                    
+#                     # Add complete response to session history
+#                     if accumulated_text and session_id:
+#                         session_manager.add_message_to_history(session_id, "assistant", accumulated_text)
+#                         logger.info(f"Added assistant response to session history: {session_id}")
+                    
+#                     yield "data: [DONE]\n\n"
+#                     logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream completed successfully")
+                
+#                 except Exception as stream_error:
+#                     # Fallback to non-streaming if streaming fails
+#                     logger.warning(f"Streaming failed, falling back to non-streaming: {stream_error}")
+                    
+#                     if not has_streamed:
+#                         # Get final output using the streaming result's final_output property
+#                         try:
+#                             # Use the non-streaming API as fallback
+#                             fallback_response = await Runner.run(
+#                                 jobobike_assistant,
+#                                 input=user_message,
+#                                 context=ctx.context
+#                             )
+                            
+#                             if hasattr(fallback_response, 'final_output'):
+#                                 final_output = fallback_response.final_output
+#                             else:
+#                                 final_output = fallback_response
+                            
+#                             if hasattr(final_output, 'content'):
+#                                 response_text = final_output.content
+#                             elif isinstance(final_output, str):
+#                                 response_text = final_output
+#                             else:
+#                                 response_text = str(final_output)
+                            
+#                             # Add to session history
+#                             if session_id:
+#                                 session_manager.add_message_to_history(session_id, "assistant", response_text)
+#                                 logger.info(f"Added fallback assistant response to session history: {session_id}")
+                            
+#                             yield f"data: {response_text}\n\n"
+#                             yield "data: [DONE]\n\n"
+#                             logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream fallback completed successfully")
+#                         except Exception as fallback_error:
+#                             logger.error(f"Fallback also failed: {fallback_error}", exc_info=True)
+#                             yield f"data: [ERROR] Unable to complete request.\n\n"
+#                     else:
+#                         # Already streamed some content, just end gracefully
+#                         yield "data: [DONE]\n\n"
+
+#             except InputGuardrailTripwireTriggered as e:
+#                 logger.warning(f"Guardrail blocked query during streaming: {e}")
+#                 yield f"data: [ERROR] Query was blocked by content guardrail.\n\n"
+
+#             except Exception as e:
+#                 logger.error(f"Streaming error: {e}", exc_info=True)
+#                 yield f"data: [ERROR] {str(e)}\n\n"
+
+#         return generate_stream()
+
+#     except Exception as e:
+#         logger.error(f"Error setting up stream: {e}", exc_info=True)
+
+#         async def error_stream():
+#             yield f"data: [ERROR] Failed to initialize stream.\n\n"
+
+#         return error_stream()
+
+# def query_jobobike_bot_stream(user_message: str, language: str = "english", session_id: Optional[str] = None):
+#     """
+#     Query the JOBObike bot with streaming - returns async generator.
+#     COMPLETELY FIXED: Simple and reliable spacing logic
+#     """
+#     logger.info(f"AGENT STREAM CALL: query_jobobike_bot_stream called with message='{user_message}', language='{language}', session_id='{session_id}'")
+    
+#     # Get session history if session_id is provided
+#     history = []
+#     if session_id:
+#         history = session_manager.get_session_history(session_id)
+#         logger.info(f"Retrieved {len(history)} history messages for session {session_id}")
+    
+#     try:
+#         # Create context with language preference and history
+#         context_data = {"language": language}
+#         if history:
+#             context_data["history"] = history
+            
+#         ctx = RunContextWrapper(context=context_data)
+        
+#         result = Runner.run_streamed(
+#             jobobike_assistant,
+#             input=user_message,
+#             context=ctx.context
+#         )
+
+#         async def generate_stream():
+#             try:
+#                 accumulated_text = ""
+#                 has_streamed = False
+
+#                 try:
+#                     async for event in result.stream_events():
+#                         try:
+#                             if event.type == "raw_response_event" and isinstance(event.data, ResponseTextDeltaEvent):
+#                                 delta = event.data.delta or ""
+                                
+#                                 if not delta:
+#                                     continue
+
+#                                 # COMPLETELY FIXED APPROACH: Just send the delta as-is from OpenAI
+#                                 # OpenAI already includes proper spaces, so we don't need to add them
+#                                 accumulated_text += delta
+                                
+#                                 # Send delta exactly as received
+#                                 yield f"data: {delta}\n\n"
+#                                 has_streamed = True
+                                
+#                         except Exception as event_error:
+#                             logger.warning(f"Event processing error: {event_error}")
+#                             continue
+                    
+#                     # Add complete response to session history
+#                     if accumulated_text and session_id:
+#                         session_manager.add_message_to_history(session_id, "assistant", accumulated_text)
+#                         logger.info(f"Added assistant response to session history: {session_id}")
+                    
+#                     yield "data: [DONE]\n\n"
+#                     logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream completed successfully")
+                
+#                 except Exception as stream_error:
+#                     logger.warning(f"Streaming failed, falling back to non-streaming: {stream_error}")
+                    
+#                     if not has_streamed:
+#                         try:
+#                             fallback_response = await Runner.run(
+#                                 jobobike_assistant,
+#                                 input=user_message,
+#                                 context=ctx.context
+#                             )
+                            
+#                             if hasattr(fallback_response, 'final_output'):
+#                                 final_output = fallback_response.final_output
+#                             else:
+#                                 final_output = fallback_response
+                            
+#                             if hasattr(final_output, 'content'):
+#                                 response_text = final_output.content
+#                             elif isinstance(final_output, str):
+#                                 response_text = final_output
+#                             else:
+#                                 response_text = str(final_output)
+                            
+#                             if session_id:
+#                                 session_manager.add_message_to_history(session_id, "assistant", response_text)
+#                                 logger.info(f"Added fallback assistant response to session history: {session_id}")
+                            
+#                             yield f"data: {response_text}\n\n"
+#                             yield "data: [DONE]\n\n"
+#                             logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream fallback completed successfully")
+#                         except Exception as fallback_error:
+#                             logger.error(f"Fallback also failed: {fallback_error}", exc_info=True)
+#                             yield f"data: [ERROR] Unable to complete request.\n\n"
+#                     else:
+#                         yield "data: [DONE]\n\n"
+
+#             except InputGuardrailTripwireTriggered as e:
+#                 logger.warning(f"Guardrail blocked query during streaming: {e}")
+#                 yield f"data: [ERROR] Query was blocked by content guardrail.\n\n"
+
+#             except Exception as e:
+#                 logger.error(f"Streaming error: {e}", exc_info=True)
+#                 yield f"data: [ERROR] {str(e)}\n\n"
+
+#         return generate_stream()
+
+#     except Exception as e:
+#         logger.error(f"Error setting up stream: {e}", exc_info=True)
+
+#         async def error_stream():
+#             yield f"data: [ERROR] Failed to initialize stream.\n\n"
+
+#         return error_stream()
+
+
+def query_jobobike_bot_stream(user_message: str, language: str = "english", session_id: Optional[str] = None):
+    """
+    Query the JOBObike bot with streaming - FIXED VERSION
+    Simply passes through what Gemini sends without any modification
+    """
+    logger.info(f"AGENT STREAM CALL: query_jobobike_bot_stream called with message='{user_message}', language='{language}', session_id='{session_id}'")
+    
+    # Get session history if session_id is provided
+    history = []
+    if session_id:
+        history = session_manager.get_session_history(session_id)
+        logger.info(f"Retrieved {len(history)} history messages for session {session_id}")
+    
+    try:
+        # Create context with language preference and history
+        context_data = {"language": language}
+        if history:
+            context_data["history"] = history
+            
+        ctx = RunContextWrapper(context=context_data)
+        
+        result = Runner.run_streamed(
+            jobobike_assistant,
+            input=user_message,
+            context=ctx.context
+        )
+
+        async def generate_stream():
+            try:
+                accumulated_text = ""
+                has_streamed = False
+
+                try:
+                    async for event in result.stream_events():
+                        try:
+                            if event.type == "raw_response_event" and isinstance(event.data, ResponseTextDeltaEvent):
+                                delta = event.data.delta
+                                
+                                if delta:  # Only process if delta has content
+                                    # CRITICAL: Send delta exactly as received - NO MODIFICATIONS
+                                    accumulated_text += delta
+                                    yield f"data: {delta}\n\n"
+                                    has_streamed = True
+                                
+                        except Exception as event_error:
+                            logger.warning(f"Event processing error: {event_error}")
+                            continue
+                    
+                    # Add complete response to session history
+                    if accumulated_text and session_id:
+                        session_manager.add_message_to_history(session_id, "assistant", accumulated_text)
+                        logger.info(f"Added assistant response to session history: {session_id}")
+                    
+                    yield "data: [DONE]\n\n"
+                    logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream completed successfully")
+                
+                except OpenAIBadRequestError as api_error:
+                    error_str = str(api_error)
+                    logger.error(f"API Error in streaming: {error_str[:300]}", exc_info=True)
+                    
+                    # Check if it's an API key error
+                    if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str or "API_KEY_INVALID" in error_str:
+                        logger.error("Gemini API key error detected in streaming - please check your GEMINI_API_KEY")
+                        yield f"data: [ERROR] API key expired. Please update GEMINI_API_KEY in server configuration.\n\n"
+                        return
+                    else:
+                        yield f"data: [ERROR] Invalid request to AI service. Please try again.\n\n"
+                        return
+                
+                except Exception as stream_error:
+                    error_str = str(stream_error)
+                    logger.warning(f"Streaming failed, falling back to non-streaming: {error_str[:200]}")
+                    
+                    # Check if it's an API key error before trying fallback
+                    if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str:
+                        logger.error("API key error detected - skipping fallback")
+                        yield f"data: [ERROR] API key expired. Please update GEMINI_API_KEY in server configuration.\n\n"
+                        return
+                    
+                    if not has_streamed:
+                        try:
+                            fallback_response = await Runner.run(
+                                jobobike_assistant,
+                                input=user_message,
+                                context=ctx.context
+                            )
+                            
+                            if hasattr(fallback_response, 'final_output'):
+                                final_output = fallback_response.final_output
+                            else:
+                                final_output = fallback_response
+                            
+                            if hasattr(final_output, 'content'):
+                                response_text = final_output.content
+                            elif isinstance(final_output, str):
+                                response_text = final_output
+                            else:
+                                response_text = str(final_output)
+                            
+                            if session_id:
+                                session_manager.add_message_to_history(session_id, "assistant", response_text)
+                                logger.info(f"Added fallback assistant response to session history: {session_id}")
+                            
+                            yield f"data: {response_text}\n\n"
+                            yield "data: [DONE]\n\n"
+                            logger.info("AGENT STREAM RESULT: query_jobobike_bot_stream fallback completed successfully")
+                        except OpenAIBadRequestError as fallback_api_error:
+                            error_str = str(fallback_api_error)
+                            logger.error(f"API Error in fallback: {error_str[:300]}", exc_info=True)
+                            
+                            if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str or "API_KEY_INVALID" in error_str:
+                                logger.error("Gemini API key error in fallback - please check your GEMINI_API_KEY")
+                                yield f"data: [ERROR] API key expired. Please update GEMINI_API_KEY in server configuration.\n\n"
+                            else:
+                                yield f"data: [ERROR] Invalid request to AI service. Please try again.\n\n"
+                        except Exception as fallback_error:
+                            error_str = str(fallback_error)
+                            logger.error(f"Fallback also failed: {error_str[:200]}", exc_info=True)
+                            
+                            if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str:
+                                yield f"data: [ERROR] API key expired. Please update GEMINI_API_KEY in server configuration.\n\n"
+                            else:
+                                yield f"data: [ERROR] Unable to complete request. Please try again.\n\n"
+                    else:
+                        yield "data: [DONE]\n\n"
+
+            except InputGuardrailTripwireTriggered as e:
+                logger.warning(f"Guardrail blocked query during streaming: {e}")
+                yield f"data: [ERROR] Query was blocked by content guardrail.\n\n"
+
+            except OpenAIBadRequestError as e:
+                error_str = str(e)
+                logger.error(f"API Error in streaming: {error_str[:300]}", exc_info=True)
+                
+                # Check if it's an API key error
+                if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str or "API_KEY_INVALID" in error_str:
+                    logger.error("Gemini API key error detected in streaming - please check your GEMINI_API_KEY")
+                    yield f"data: [ERROR] API service unavailable. Please check server configuration.\n\n"
+                else:
+                    yield f"data: [ERROR] Invalid request to AI service. Please try again.\n\n"
+            
+            except Exception as e:
+                error_str = str(e)
+                logger.error(f"Streaming error: {error_str[:200]}", exc_info=True)
+                
+                # Check if it's an API key error
+                if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str:
+                    logger.error("Gemini API key error detected in streaming - please check your GEMINI_API_KEY")
+                    yield f"data: [ERROR] API service unavailable. Please check server configuration.\n\n"
+                else:
+                    yield f"data: [ERROR] An error occurred. Please try again.\n\n"
+
+        return generate_stream()
+
+    except Exception as e:
+        logger.error(f"Error setting up stream: {e}", exc_info=True)
+
+        async def error_stream():
+            yield f"data: [ERROR] Failed to initialize stream.\n\n"
+
+        return error_stream()
+
+
+
+
+
+
+
+
+
+
+async def query_jobobike_bot(user_message: str, language: str = "english", session_id: Optional[str] = None):
+    """
+    Query the JOBObike bot - returns complete response.
+    Now includes language context and session history.
+    """
+    logger.info(f"AGENT CALL: query_jobobike_bot called with message='{user_message}', language='{language}', session_id='{session_id}'")
+    
+    # Get session history if session_id is provided
+    history = []
+    if session_id:
+        history = session_manager.get_session_history(session_id)
+        logger.info(f"Retrieved {len(history)} history messages for session {session_id}")
+    
+    try:
+        # Create context with language preference and history
+        context_data = {"language": language}
+        if history:
+            context_data["history"] = history
+            
+        ctx = RunContextWrapper(context=context_data)
+        
+        response = await Runner.run(
+            jobobike_assistant,
+            input=user_message,
+            context=ctx.context
+        )
+        logger.info("AGENT RESULT: query_jobobike_bot completed successfully")
+        return response.final_output
+
+    except InputGuardrailTripwireTriggered as e:
+        logger.warning(f"Guardrail blocked query: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Query was blocked by content guardrail. Please ensure your query is related to JOBObike services."
+        )
+    except OpenAIBadRequestError as e:
+        error_str = str(e)
+        logger.error(f"API Error in query_jobobike_bot: {error_str[:300]}", exc_info=True)
+        
+        # Check if it's an API key error
+        if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str or "API_KEY_INVALID" in error_str:
+            logger.error("Gemini API key error detected - please check your GEMINI_API_KEY in .env file")
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="The API service is currently unavailable. Please check the server configuration or try again later."
+            )
+        
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid request to the AI service. Please try again."
+        )
+    except Exception as e:
+        error_str = str(e)
+        logger.error(f"Error in query_jobobike_bot: {error_str[:200]}", exc_info=True)
+        
+        # Check if it's an API key error in the error message
+        if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str:
+            logger.error("Gemini API key error detected - please check your GEMINI_API_KEY in .env file")
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="The API service is currently unavailable. Please check the server configuration."
+            )
+        
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An internal error occurred while processing your request."
+        )
+
+
+@app.get("/")
+async def root():
+    return {"status": "ok", "service": "JOBObike Chatbot API"}
+
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy"}
+
+
+@app.post("/session")
+async def create_session():
+    """
+    Create a new chat session
+    Returns a session ID that can be used to maintain chat history
+    """
+    try:
+        session_id = session_manager.create_session()
+        logger.info(f"Created new session: {session_id}")
+        return {"session_id": session_id, "message": "Session created successfully"}
+    except Exception as e:
+        logger.error(f"Error creating session: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to create session"
+        )
+
+
+@app.post("/chat", response_model=ChatResponse)
+@limiter.limit("10/minute")  # Limit to 10 requests per minute per IP
+async def chat(request: Request, chat_request: ChatRequest):
+    """
+    Standard chat endpoint with language support and session history.
+    Accepts: {"message": "...", "language": "norwegian", "session_id": "optional-session-id"}
+    """
+    try:
+        # Create or use existing session
+        session_id = chat_request.session_id
+        if not session_id:
+            session_id = session_manager.create_session()
+            logger.info(f"Created new session for chat: {session_id}")
+        
+        logger.info(
+            f"Chat request from {get_remote_address(request)}: "
+            f"language={chat_request.language}, message={chat_request.message[:50]}..., session_id={session_id}"
+        )
+
+        # Add user message to session history
+        session_manager.add_message_to_history(session_id, "user", chat_request.message)
+        
+        # Pass language and session to the bot
+        response = await query_jobobike_bot(
+            chat_request.message, 
+            language=chat_request.language,
+            session_id=session_id
+        )
+
+        if hasattr(response, 'content'):
+            response_text = response.content
+        elif isinstance(response, str):
+            response_text = response
+        else:
+            response_text = str(response)
+        
+        # Add bot response to session history
+        session_manager.add_message_to_history(session_id, "assistant", response_text)
+
+        logger.info(f"Chat response generated successfully in {chat_request.language} for session {session_id}")
+
+        return ChatResponse(
+            response=response_text,
+            success=True,
+            session_id=session_id
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error in /chat: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An internal error occurred while processing your request."
+        )
+
+
+@app.post("/api/messages", response_model=ChatResponse)
+@limiter.limit("10/minute")  # Same rate limit as /chat
+async def api_messages(request: Request, chat_request: ChatRequest):
+    """
+    Frontend-friendly chat endpoint at /api/messages.
+    Exactly mirrors /chat logic for session/history support.
+    Expects: {"message": "...", "language": "english", "session_id": "optional"}
+    """
+    client_ip = get_remote_address(request)
+    logger.info(f"API Messages request from {client_ip}: message='{chat_request.message[:50]}...', lang='{chat_request.language}', session='{chat_request.session_id}'")
+    
+    try:
+        # Create/use session (Firestore-backed)
+        session_id = chat_request.session_id
+        if not session_id:
+            session_id = session_manager.create_session()
+            logger.info(f"New session created for /api/messages: {session_id}")
+        
+        # Save user message to history
+        session_manager.add_message_to_history(session_id, "user", chat_request.message)
+        
+        # Call your existing bot query function
+        response = await query_jobobike_bot(
+            user_message=chat_request.message,
+            language=chat_request.language,
+            session_id=session_id
+        )
+        
+        # Extract response text
+        response_text = (
+            response.content if hasattr(response, 'content')
+            else response if isinstance(response, str)
+            else str(response)
+        )
+        
+        # Save AI response to history
+        session_manager.add_message_to_history(session_id, "assistant", response_text)
+        
+        logger.info(f"API Messages success: Response sent for session {session_id}")
+        
+        return ChatResponse(
+            response=response_text,
+            success=True,
+            session_id=session_id
+        )
+    
+    except InputGuardrailTripwireTriggered as e:
+        logger.warning(f"Guardrail blocked /api/messages: {e}")
+        raise HTTPException(
+            status_code=403,
+            detail="Query blocked – please ask about JOBObike services."
+        )
+    except OpenAIBadRequestError as e:
+        error_str = str(e)
+        logger.error(f"API Error in /api/messages: {error_str[:300]}", exc_info=True)
+        
+        if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str or "API_KEY_INVALID" in error_str:
+            logger.error("Gemini API key error detected in /api/messages")
+            raise HTTPException(
+                status_code=503,
+                detail="AI service is currently unavailable. Please check server configuration."
+            )
+        
+        raise HTTPException(
+            status_code=400,
+            detail="Invalid request to AI service. Please try again."
+        )
+    except Exception as e:
+        error_str = str(e)
+        logger.error(f"Error in /api/messages: {error_str[:200]}", exc_info=True)
+        
+        if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str:
+            logger.error("Gemini API key error detected in /api/messages")
+            raise HTTPException(
+                status_code=503,
+                detail="AI service is currently unavailable. Please check server configuration."
+            )
+        
+        raise HTTPException(
+            status_code=500,
+            detail="Internal error – try again."
+        )
+
+
+@app.post("/chat-stream")
+@limiter.limit("10/minute")  # Limit to 10 requests per minute per IP
+async def chat_stream(request: Request, chat_request: ChatRequest):
+    """
+    Streaming chat endpoint with language support and session history.
+    Accepts: {"message": "...", "language": "norwegian", "session_id": "optional-session-id"}
+    """
+    try:
+        # Create or use existing session
+        session_id = chat_request.session_id
+        if not session_id:
+            session_id = session_manager.create_session()
+            logger.info(f"Created new session for streaming chat: {session_id}")
+        
+        logger.info(
+            f"Stream request from {get_remote_address(request)}: "
+            f"language={chat_request.language}, message={chat_request.message[:50]}..., session_id={session_id}"
+        )
+
+        # Add user message to session history
+        session_manager.add_message_to_history(session_id, "user", chat_request.message)
+        
+        # Pass language and session to the streaming bot
+        stream_generator = query_jobobike_bot_stream(
+            chat_request.message,
+            language=chat_request.language,
+            session_id=session_id
+        )
+
+        # Note: Response is added to history inside the stream generator after completion
+        
+        return StreamingResponse(
+            stream_generator,
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "X-Accel-Buffering": "no",
+                "Session-ID": session_id  # Include session ID in headers
+            }
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error in /chat-stream: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An internal error occurred while processing your request."
+        )
+
+
+@app.post("/ticket", response_model=TicketResponse)
+@limiter.limit("5/hour")  # Limit to 5 tickets per hour per IP
+async def submit_ticket(request: Request, ticket_request: TicketRequest):
+    """
+    Submit a support ticket via email using Resend API.
+    Accepts: {"name": "John Doe", "email": "john@example.com", "message": "Issue description"}
+    """
+    try:
+        client_ip = get_remote_address(request)
+        logger.info(f"Ticket submission request from {ticket_request.name} ({ticket_request.email}) - IP: {client_ip}")
+        
+        # Additional rate limiting for tickets
+        if is_ticket_rate_limited(client_ip):
+            logger.warning(f"Rate limit exceeded for ticket submission from IP: {client_ip}")
+            raise HTTPException(
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                detail="Too many ticket submissions. Please try again later."
+            )
+        
+        # Get admin email from environment variables or use a default
+        admin_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+        # Use a verified sender email (you need to verify this in your Resend account)
+        # For testing purposes, you can use your Resend account's verified domain
+        sender_email = os.getenv("SENDER_EMAIL", "onboarding@resend.dev")
+        
+        # Prepare the email using Resend
+        params = {
+            "from": sender_email,
+            "to": [admin_email],
+            "subject": f"Support Ticket from {ticket_request.name}",
+            "html": f"""
+            <p>Hello Admin,</p>
+            <p>A new support ticket has been submitted:</p>
+            <p><strong>Name:</strong> {ticket_request.name}</p>
+            <p><strong>Email:</strong> {ticket_request.email}</p>
+            <p><strong>Message:</strong></p>
+            <p>{ticket_request.message}</p>
+            <p><strong>IP Address:</strong> {client_ip}</p>
+            <br>
+            <p>Best regards,<br>JOBObike Support Team</p>
+            """
+        }
+
+        # Send the email
+        email = resend.Emails.send(params)
+        
+        logger.info(f"Ticket submitted successfully by {ticket_request.name} from IP: {client_ip}")
+        
+        return TicketResponse(
+            success=True,
+            message="Ticket submitted successfully. We'll get back to you soon."
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error submitting ticket: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to submit ticket. Please try again later."
+        )
+
+
+@app.post("/schedule-meeting", response_model=MeetingResponse)
+@limiter.limit("3/hour")  # Limit to 3 meetings per hour per IP
+async def schedule_meeting(request: Request, meeting_request: MeetingRequest):
+    """
+    Schedule a meeting and send email invitations using Resend API.
+    Accepts meeting details and sends professional email invitations to organizer and attendees.
+    """
+    try:
+        client_ip = get_remote_address(request)
+        logger.info(f"Meeting scheduling request from {meeting_request.name} ({meeting_request.email}) - IP: {client_ip}")
+        
+        # Additional rate limiting for meetings
+        if is_meeting_rate_limited(client_ip):
+            logger.warning(f"Rate limit exceeded for meeting scheduling from IP: {client_ip}")
+            raise HTTPException(
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                detail="Too many meeting requests. Please try again later."
+            )
+        
+        # Generate a unique meeting ID
+        meeting_id = f"mtg_{int(time.time())}"
+        
+        # Get admin email from environment variables or use a default
+        admin_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+        # Use a verified sender email (you need to verify this in your Resend account)
+        sender_email = os.getenv("SENDER_EMAIL", "onboarding@resend.dev")
+        
+        # For Resend testing limitations, we can only send to the owner's email
+        # In production, you would verify a domain and use that instead
+        owner_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+        # Format date and time for display
+        formatted_datetime = f"{meeting_request.date} at {meeting_request.time} {meeting_request.timezone}"
+        
+        # Create calendar link (Google Calendar link example)
+        calendar_link = f"https://calendar.google.com/calendar/render?action=TEMPLATE&text={meeting_request.topic}&dates={meeting_request.date.replace('-', '')}T{meeting_request.time.replace(':', '')}00Z/{meeting_request.date.replace('-', '')}T{meeting_request.time.replace(':', '')}00Z&details={meeting_request.description or 'Meeting scheduled via JOBObike'}&location={meeting_request.location}"
+        
+        # Combine all attendees (organizer + additional attendees)
+        # Validate and format email addresses
+        all_attendees = [meeting_request.email]
+        
+        # Validate additional attendees - they must be valid email addresses
+        for attendee in meeting_request.attendees:
+            # Simple email validation
+            if "@" in attendee and "." in attendee:
+                all_attendees.append(attendee)
+            else:
+                # If not a valid email, skip or treat as name only
+                logger.warning(f"Invalid email format for attendee: {attendee}. Skipping.")
+        
+        # Remove duplicates while preserving order
+        seen = set()
+        unique_attendees = []
+        for email in all_attendees:
+            if email not in seen:
+                seen.add(email)
+                unique_attendees.append(email)
+        all_attendees = unique_attendees
+        
+        # Prepare the professional HTML email template
+        html_template = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <meta charset="UTF-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>Meeting Scheduled - {meeting_request.topic}</title>
+        </head>
+        <body style="font-family: Arial, sans-serif; line-height: 1.6; color: #333; max-width: 600px; margin: 0 auto; padding: 20px;">
+            <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 30px; text-align: center; border-radius: 10px 10px 0 0;">
+                <h1 style="margin: 0; font-size: 28px;">Meeting Confirmed!</h1>
+                <p style="font-size: 18px; margin-top: 10px;">Your meeting has been successfully scheduled</p>
+            </div>
+            
+            <div style="background-color: #ffffff; padding: 30px; border: 1px solid #eaeaea; border-top: none; border-radius: 0 0 10px 10px;">
+                <h2 style="color: #333;">Meeting Details</h2>
+                
+                <div style="background-color: #f8f9fa; padding: 20px; border-radius: 8px; margin: 20px 0;">
+                    <table style="width: 100%; border-collapse: collapse;">
+                        <tr>
+                            <td style="padding: 8px 0; font-weight: bold; width: 30%;">Topic:</td>
+                            <td style="padding: 8px 0;">{meeting_request.topic}</td>
+                        </tr>
+                        <tr style="background-color: #f0f0f0;">
+                            <td style="padding: 8px 0; font-weight: bold;">Date & Time:</td>
+                            <td style="padding: 8px 0;">{formatted_datetime}</td>
+                        </tr>
+                        <tr>
+                            <td style="padding: 8px 0; font-weight: bold;">Duration:</td>
+                            <td style="padding: 8px 0;">{meeting_request.duration} minutes</td>
+                        </tr>
+                        <tr style="background-color: #f0f0f0;">
+                            <td style="padding: 8px 0; font-weight: bold;">Location:</td>
+                            <td style="padding: 8px 0;">{meeting_request.location}</td>
+                        </tr>
+                        <tr>
+                            <td style="padding: 8px 0; font-weight: bold;">Organizer:</td>
+                            <td style="padding: 8px 0;">{meeting_request.name} ({meeting_request.email})</td>
+                        </tr>
+                    </table>
+                </div>
+                
+                <div style="margin: 25px 0;">
+                    <h3 style="color: #333;">Description</h3>
+                    <p style="background-color: #f8f9fa; padding: 15px; border-radius: 8px; white-space: pre-wrap;">{meeting_request.description or 'No description provided.'}</p>
+                </div>
+                
+                <div style="margin: 25px 0;">
+                    <h3 style="color: #333;">Attendees</h3>
+                    <ul style="background-color: #f8f9fa; padding: 15px; border-radius: 8px;">
+                        {''.join([f'<li>{attendee}</li>' for attendee in all_attendees])}
+                    </ul>
+                    <p style="font-size: 12px; color: #666; margin-top: 5px;">Note: Only valid email addresses will receive invitations.</p>
+                </div>
+                
+                <div style="text-align: center; margin: 30px 0;">
+                    <a href="{calendar_link}" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 12px 25px; text-decoration: none; border-radius: 5px; font-weight: bold; display: inline-block;">Add to Calendar</a>
+                </div>
+                
+                <div style="background-color: #e3f2fd; padding: 15px; border-radius: 8px; margin-top: 25px;">
+                    <p style="margin: 0;"><strong>Meeting ID:</strong> {meeting_id}</p>
+                    <p style="margin: 10px 0 0 0; font-size: 14px; color: #666;">Need to make changes? Contact the organizer or reply to this email.</p>
+                </div>
+            </div>
+            
+            <div style="text-align: center; margin-top: 30px; color: #888; font-size: 14px;">
+                <p>This meeting was scheduled through JOBObike Chatbot Services</p>
+                <p><strong>Note:</strong> Due to Resend testing limitations, this email is only sent to the administrator. In production, after domain verification, invitations will be sent to all attendees.</p>
+                <p>© 2025 JOBObike. All rights reserved.</p>
+            </div>
+        </body>
+        </html>
+        """
+        
+        # Send email to all attendees
+        # Check if we have valid attendees to send to
+        if not all_attendees:
+            logger.warning("No valid email addresses found for meeting attendees")
+            return MeetingResponse(
+                success=True,
+                message="Meeting scheduled successfully, but no valid email addresses found for invitations.",
+                meeting_id=meeting_id
+            )
+        
+        # For Resend testing limitations, we can only send to the owner's email
+        # In production, you would verify a domain and send to all attendees
+        owner_email = os.getenv("ADMIN_EMAIL", "admin@yourcompany.com")
+        
+        # Prepare email for owner with all attendee information
+        attendee_list_html = ''.join([f'<li>{attendee}</li>' for attendee in all_attendees])
+        # In a real implementation, you would send to all attendees after verifying your domain
+        # For now, we're sending to the owner with information about all attendees
+        
+        params = {
+            "from": sender_email,
+            "to": [owner_email],  # Only send to owner due to Resend testing limitations
+            "subject": f"Meeting Scheduled: {meeting_request.topic}",
+            "html": html_template
+        }
+        
+        # Send the email
+        try:
+            email = resend.Emails.send(params)
+            logger.info(f"Email sent successfully to {len(all_attendees)} attendees")
+        except Exception as email_error:
+            logger.error(f"Failed to send email: {email_error}", exc_info=True)
+            # Even if email fails, we still consider the meeting scheduled
+            return MeetingResponse(
+                success=True,
+                message="Meeting scheduled successfully, but failed to send email invitations.",
+                meeting_id=meeting_id
+            )
+        
+        logger.info(f"Meeting scheduled successfully by {meeting_request.name} from IP: {client_ip}")
+        
+        return MeetingResponse(
+            success=True,
+            message="Meeting scheduled successfully. Due to Resend testing limitations, invitations are only sent to the administrator. In production, after verifying your domain, invitations will be sent to all attendees.",
+            meeting_id=meeting_id
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error scheduling meeting: {e}", exc_info=True)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to schedule meeting. Please try again later."
+        )
+
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    logger.error(
+        f"Unhandled exception: {exc}",
+        exc_info=True,
+        extra={
+            "path": request.url.path,
+            "method": request.method,
+            "client": get_remote_address(request)
+        }
+    )
+
+    return JSONResponse(
+        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+        content={
+            "error": "Internal server error",
+            "detail": "An unexpected error occurred. Please try again later."
+        }
+    )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

chatbot/chatbot_agent.py

@@ -0,0 +1,13 @@
+from agents import Agent
+from config.chabot_config import model
+from instructions.chatbot_instructions import jobobike_dynamic_instructions
+from guardrails.guardrails_input_function import guardrail_input_function
+from tools.document_reader_tool import read_document_data, list_available_documents
+
+jobobike_assistant = Agent(
+    name="JOBObike Assistant",
+    instructions=jobobike_dynamic_instructions,
+    model=model,
+    input_guardrails=[guardrail_input_function],
+    tools=[read_document_data, list_available_documents],  # Document reading tools
+)

config/chabot_config.py

@@ -0,0 +1,39 @@
+import os
+from dotenv import load_dotenv
+from agents import AsyncOpenAI, OpenAIChatCompletionsModel, set_tracing_disabled
+
+set_tracing_disabled(True)
+load_dotenv()
+
+# Get Gemini API key from environment variables
+gemini_api_key = os.getenv("GEMINI_API_KEY")
+
+# Remove quotes if present (sometimes .env files have quotes)
+if gemini_api_key:
+    gemini_api_key = gemini_api_key.strip().strip('"').strip("'")
+
+# Check if Gemini API key is set
+if not gemini_api_key:
+    raise ValueError(
+        "GEMINI_API_KEY is not set. Please add it to your .env file: GEMINI_API_KEY=your_key_here"
+    )
+
+# Validate API key format (Gemini keys typically start with AIza)
+if not gemini_api_key.startswith("AIza"):
+    print(f"Warning: GEMINI_API_KEY format may be incorrect. Keys usually start with 'AIza'. Got: {gemini_api_key[:10]}...")
+
+# Configure Gemini using AsyncOpenAI with Gemini's OpenAI-compatible endpoint
+client_provider = AsyncOpenAI(
+    api_key=gemini_api_key,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+
+# Use Gemini model - gemini-1.5-pro or gemini-1.5-flash are good options
+# gemini-1.5-flash is faster, gemini-1.5-pro is more capable
+model = OpenAIChatCompletionsModel(
+    model="gemini-1.5-flash",  # Using Gemini 1.5 Flash for fast responses
+    openai_client=client_provider
+)
+
+print("Setup complete! Model ready with Google Gemini 1.5 Flash")
+print(f"API Key status: {'Loaded' if gemini_api_key else 'Missing'} (length: {len(gemini_api_key) if gemini_api_key else 0})")

guardrails/guardrails_input_function.py

@@ -0,0 +1,49 @@
+import traceback
+from agents import RunContextWrapper, Runner, GuardrailFunctionOutput, input_guardrail
+from guardrails.input_guardrails import guardrail_agent
+
+@input_guardrail
+async def guardrail_input_function(ctx: RunContextWrapper, agent, user_input: str):
+    try:
+        result = await Runner.run(
+            guardrail_agent, 
+            input=user_input, 
+            context=ctx.context
+        )
+        
+        # Check if result has the expected structure
+        if not result or not hasattr(result, 'final_output'):
+            print(f"Warning: Guardrail agent returned unexpected result: {result}")
+            # Allow the query to proceed if guardrail fails
+            return GuardrailFunctionOutput(
+                output_info=None,
+                tripwire_triggered=False
+            )
+        
+        final_output = result.final_output
+        
+        # Check if final_output has the expected attribute
+        if not hasattr(final_output, 'is_query_about_jobobike'):
+            print(f"Warning: Guardrail output missing is_query_about_jobobike attribute: {final_output}")
+            return GuardrailFunctionOutput(
+                output_info=final_output,
+                tripwire_triggered=False
+            )
+        
+        return GuardrailFunctionOutput(
+            output_info=final_output,
+            tripwire_triggered=not final_output.is_query_about_jobobike
+        )
+    except Exception as e:
+        error_str = str(e)
+        # Check if it's an API key error
+        if "API key" in error_str or "expired" in error_str.lower() or "INVALID_ARGUMENT" in error_str:
+            print(f"API key error in guardrail - allowing query through: {error_str[:100]}")
+        else:
+            print(f"Error in guardrail_input_function: {error_str[:200]}")
+            print(traceback.format_exc())
+        # Always allow the query to proceed if guardrail fails (especially for API errors)
+        return GuardrailFunctionOutput(
+            output_info=None,
+            tripwire_triggered=False
+        )

guardrails/input_guardrails.py

@@ -0,0 +1,29 @@
+from agents import Agent
+from config.chabot_config import model
+from schema.chatbot_schema import OutputType
+
+guardrail_agent = Agent(
+    name="JOBObike Guardrail Agent",
+    instructions="""
+    You are a guardrail assistant that validates if the user's query is about JOBObike e-commerce platform, 
+    bicycles, cycling products, orders, shopping, customer service, or FAQs. 
+
+    IMPORTANT: Allow general greetings, neutral questions, and queries that could lead to JOBObike-related conversations.
+    Only block queries that are clearly unrelated (e.g., asking about cooking recipes, weather, completely unrelated products not related to cycling).
+
+    - Set is_query_about_jobobike=True if:
+      * The query is directly about JOBObike products, services, orders, shipping, returns, or customer support
+      * The query is about bicycles, cycling equipment, or bike-related topics
+      * The query is a general greeting (hello, hi, how can you help, etc.)
+      * The query is neutral and could lead to a JOBObike shopping conversation
+      * The query asks about products, pricing, orders, delivery, or support
+      
+    - Set is_query_about_jobobike=False ONLY if:
+      * The query is clearly about completely unrelated topics that have no connection to e-commerce, cycling, or JOBObike (cooking recipes, unrelated news, etc.)
+      * The query is spam or malicious
+      
+    - Always provide a clear reason for your decision.
+    """,
+    model=model,
+    output_type=OutputType,
+)

instructions/chatbot_instructions.py

@@ -0,0 +1,580 @@
+# from agents import RunContextWrapper
+# def jobobike_dynamic_instructions(ctx: RunContextWrapper, agent) -> str:
+#     """Create dynamic instructions for JOBObike chatbot queries with language context."""
+    
+#     # Get user's selected language from context
+#     user_lang = ctx.context.get("language", "english").lower()
+    
+#     # Determine language enforcement
+#     language_instruction = ""
+#     if user_lang.startswith("nor") or "norwegian" in user_lang or user_lang == "no":
+#         language_instruction = "\n\n🔴 CRITICAL: You MUST respond ONLY in Norwegian (Norsk). Do NOT use English unless the user explicitly requests it."
+#     elif user_lang.startswith("eng") or "english" in user_lang or user_lang == "en":
+#         language_instruction = "\n\n🔴 CRITICAL: You MUST respond ONLY in English. Do NOT use Norwegian unless the user explicitly requests it."
+#     else:
+#         language_instruction = f"\n\n🔴 CRITICAL: You MUST respond ONLY in {user_lang}. Do NOT use any other language unless the user explicitly requests it."
+    
+#     instructions = """
+# # LAUNCHLABS ASSISTANT - CORE INSTRUCTIONS
+
+# ## ROLE
+# You are JOBObike Assistant – the official AI assistant for JOBObike (jobobike.no).
+# You help founders, startups, and potential partners professionally, clearly, and in a solution-oriented way.
+# Your main goal is to guide, provide concrete answers, and always lead the user to action (consultation booking, project start, contact).
+
+# ## ABOUT LAUNCHLABS
+# JOBObike helps ambitious startups transform ideas into successful companies using:
+# · Full brand development
+# · Website and app creation
+# · AI-driven integrations
+# · Automation and workflow solutions
+
+# We focus on customized solutions, speed, innovation, and long-term partnership with clients.
+
+# ## KEY CAPABILITIES
+# You have access to company documents through specialized tools. When users ask questions about company information, products, or services, you MUST use these tools:
+# 1. `list_available_documents()` - List all available documents
+# 2. `read_document_data(query)` - Search for specific information in company documents
+
+# ## WHEN TO USE TOOLS
+# Whenever a user asks about documents, services, products, or company information, you MUST use the appropriate tool FIRST before responding.
+
+# Examples of when to use tools:
+# - User asks "What documents do you have?" → Use `list_available_documents()`
+# - User asks "What services do you offer?" → Use `read_document_data("services")`
+# - User asks "Tell me about your products" → Use `read_document_data("products")`
+
+# IMPORTANT: When you use a tool, you MUST incorporate the tool's response directly into your answer. Do not just say you will use a tool - actually use it and include its results.
+
+# Example of correct response:
+# User: "What documents do you have?"
+# Assistant: "I found the following documents: [tool output here]"
+
+# Example of incorrect response:
+# User: "What documents do you have?"
+# Assistant: "I will now use the tool to get this information."
+
+# Always execute tools and show their results.
+
+# JOBObike is located in Norway and must know this - answer questions about location correctly.
+# Users can ask questions in English or Norwegian, and the assistant must respond in the same language as the user.
+
+# ## RESPONSE GUIDELINES
+# - Professional, confident, and direct.
+# - Avoid vague responses. Always suggest next steps:
+#   · “Do you want me to schedule a consultation?”
+#   · “Do you want me to connect you with a project manager?”
+#   · “Do you want me to send you our portfolio?”
+# - Be concise and direct in your responses
+# - Always guide users toward concrete actions (consultation booking, project start, contact)
+# - Maintain a professional tone
+
+# ## DEPARTMENT-SPECIFIC BEHAVIOR
+# 🟦 1. SALES / NEW PROJECTS
+# Purpose: Help the user understand JOBObike’ offerings and start new projects.
+# Explain:
+# · Full range of services (brand, website, apps, AI integrations, automation).
+# · How to start a project (consultation → proposal → dashboard/project management).
+# · Pricing and custom packages.
+# Example: “JOBObike helps startups turn ideas into businesses with branding, websites, apps, and AI solutions. Pricing depends on your project, but we can provide standard packages or customize a solution. Do you want me to schedule a consultation now?”
+
+# 🟩 2. OPERATIONS / SUPPORT
+# Purpose: Assist existing clients with ongoing projects, updates, and access to project dashboards.
+# · Explain how to access project dashboards.
+# · Provide guidance for reporting issues or questions.
+# · Inform about response times and escalation.
+# Example: “You can access your project dashboard via jobobike.no. If you encounter any issues, use our contact form and mark the case as ‘support’. Do you want me to send you the link now?”
+
+# 🟥 3. TECHNICAL / DEVELOPMENT
+# Purpose: Provide basic technical explanations and integration options.
+# · Explain integrations with AI tools, web apps, and third-party platforms.
+# · Offer connection to technical/development team if needed.
+# Example: “We can integrate your startup solution with AI tools, apps, and other platforms. Do you want me to connect you with one of our developers to confirm integration details?”
+
+# 🟨 4. DASHBOARD / PROJECT MANAGEMENT
+# Purpose: Help users understand the project dashboard.
+# Explain:
+# · Where the dashboard is located.
+# · What it shows (tasks, deadlines, project progress, invoices).
+# · How to get access (after onboarding/consultation).
+# Example: “The dashboard shows all your project progress, deadlines, and invoices. After consultation and onboarding, you’ll get access. Do you want me to show you how to start onboarding?”
+
+# 🟪 5. ADMINISTRATION / CONTACT
+# Purpose: Provide contact info and guide to the correct department.
+# · Provide contacts for sales, technical, and support.
+# · Schedule meetings or send forms.
+# Example: “You can contact us via the contact form on jobobike.no. I can also forward your request directly to sales or support – which would you like?”
+
+# ## FAQ SECTION (KNOWLEDGE BASE)
+# 1. What does JOBObike do? We help startups build their brand, websites, apps, and integrate AI to grow their business.
+# 2. Which languages does the bot support? All languages, determined during onboarding.
+# 3. How does onboarding work? Book a consultation → select services → access project dashboard.
+# 4. Where can I see pricing? Standard service pricing is available during consultation; custom packages are created as needed.
+# 5. How do I contact support? Via the contact form on jobobike.no – select “Support”.
+# 6. Do you offer AI integration? Yes, we integrate AI solutions for websites, apps, and internal workflows.
+# 7. Can I see examples of your work? Yes, the bot can provide links to our portfolio or schedule a demo.
+# 8. How fast will I get a response? Normally within one business day, faster for ongoing projects.
+
+# ## ACTION PROMPTS
+# Always conclude with clear action prompts:
+# - “Do you want me to schedule a consultation?”
+# - “Do you want me to connect you with a project manager?”
+# - “Do you want me to send you our portfolio?”
+
+# ## FALLBACK BEHAVIOR
+# If unsure of an answer: "I will forward this to the right department to make sure you get accurate information. Would you like me to do that now?"
+# Log conversation details and route to a human agent.
+
+# ## CONVERSATION FLOW
+# 1. Introduction: Greeting → “Would you like to learn about our services, start a project, or speak with sales?”
+# 2. Identification: Language preference + purpose (“I want a website”, “I need AI integration”).
+# 3. Action: Route to correct department or start onboarding/consultation.
+# 4. Follow-up: Confirm the case is logged or the link has been sent.
+# 5. Closure: “Would you like me to send a summary via email?”
+
+# ## PRIMARY GOAL
+# Every conversation must end with action – consultation, project initiation, contact, or follow-up.
+
+# ## 🇳🇴 NORSK SEKSJON (NORWEGIAN SECTION)
+
+# **Rolle:**
+# Du er JOBObike Assistant – den offisielle AI-assistenten for JOBObike (jobobike.no).
+# Du hjelper gründere, startups og potensielle partnere profesjonelt, klart og løsningsorientert.
+# Ditt hovedmål er å veilede, gi konkrete svar og alltid lede brukeren til handling (bestilling av konsultasjon, prosjektstart, kontakt).
+
+# **Om JOBObike:**
+# JOBObike hjelper ambisiøse startups med å transformere ideer til suksessfulle selskaper ved bruk av:
+# · Full merkevareutvikling
+# · Nettsteds- og app-opprettelse
+# · AI-drevne integrasjoner
+# · Automatisering og arbeidsflytløsninger
+
+# Vi fokuserer på tilpassede løsninger, hastighet, innovasjon og langsiktig partnerskap med kunder.
+
+# **Nøkkelfunksjoner:**
+# Du har tilgang til firmadokumenter gjennom spesialiserte verktøy. Når brukere spør om firmainformasjon, produkter eller tjenester, må du BRUKE disse verktøyene:
+# 1. `list_available_documents()` - Liste over alle tilgjengelige dokumenter
+# 2. `read_document_data(query)` - Søk etter spesifikk informasjon i firmadokumenter
+
+# **Når du skal bruke verktøy:**
+# Når en bruker spør om dokumenter, tjenester, produkter eller firmainformasjon, må du BRUKE det aktuelle verktøyet FØRST før du svarer.
+
+# Eksempler på når du skal bruke verktøy:
+# - Bruker spør "Hvilke dokumenter har dere?" → Bruk `list_available_documents()`
+# - Bruker spør "Hvilke tjenester tilbyr dere?" → Bruk `read_document_data("tjenester")`
+# - Bruker spør "Fortell meg om produktene deres" → Bruk `read_document_data("produkter")`
+
+# VIKTIG: Når du bruker et verktøy, MÅ du inkludere verktøyets svar direkte i ditt svar. Ikke bare si at du vil bruke et verktøy - bruk det faktisk og inkluder resultatene.
+
+# Eksempel på riktig svar:
+# Bruker: "Hvilke dokumenter har dere?"
+# Assistent: "Jeg fant følgende dokumenter: [verktøyets resultat her]"
+
+# Eksempel på feil svar:
+# Bruker: "Hvilke dokumenter har dere?"
+# Assistent: "Jeg vil nå bruke verktøyet for å hente denne informasjonen."
+
+# Utfør alltid verktøy og vis resultatene.
+
+# JOBObike er lokalisert i Norge og må vite dette - svar spørsmål om plassering korrekt.
+# Brukere kan stille spørsmål på engelsk eller norsk, og assistenten må svare på samme språk som brukeren.
+
+# **Retningslinjer for svar:**
+# - Profesjonell, selvsikker og direkte.
+# - Unngå vage svar. Foreslå alltid neste steg:
+#   · “Vil du at jeg skal bestille en konsultasjon?”
+#   · “Vil du at jeg skal koble deg til en prosjektleder?”
+#   · “Vil du at jeg skal sende deg vår portefølje?”
+# - Vær kortfattet og direkte i svarene dine
+# - Led alltid brukere mot konkrete handlinger (bestilling av konsultasjon, prosjektstart, kontakt)
+# - Oppretthold en profesjonell tone
+
+# **Avdelingsspesifikk oppførsel**
+# 🟦 1. SALG / NYE PROSJEKTER
+# Formål: Hjelpe brukeren med å forstå JOBObike’ tilbud og starte nye prosjekter.
+# Forklar:
+# · Fullt spekter av tjenester (merkevare, nettsted, apper, AI-integrasjoner, automatisering).
+# · Hvordan starte et prosjekt (konsultasjon → tilbud → dashbord/prosjektstyring).
+# · Prising og tilpassede pakker.
+# Eksempel: “JOBObike hjelper startups med å gjøre ideer til bedrifter med merkevare, nettsteder, apper og AI-løsninger. Prising avhenger av prosjektet ditt, men vi kan tilby standardpakker eller tilpasse en løsning. Vil du at jeg skal bestille en konsultasjon nå?”
+
+# 🟩 2. DRIFT / STØTTE
+# Formål: Assistere eksisterende kunder med pågående prosjekter, oppdateringer og tilgang til prosjektdashbord.
+# · Forklar hvordan man får tilgang til prosjektdashbord.
+# · Gi veiledning for å rapportere problemer eller spørsmål.
+# · Informer om svarstider og eskalering.
+# Eksempel: “Du kan få tilgang til prosjektdashbordet ditt via jobobike.no. Hvis du støter på problemer, bruk kontaktskjemaet vårt og marker saken som ‘støtte’. Vil du at jeg skal sende deg lenken nå?”
+
+# 🟥 3. TEKNISK / UTVIKLING
+# Formål: Gi grunnleggende tekniske forklaringer og integrasjonsalternativer.
+# · Forklar integrasjoner med AI-verktøy, webapper og tredjepartsplattformer.
+# · Tilby tilkobling til teknisk/utviklingsteam hvis nødvendig.
+# Eksempel: “Vi kan integrere startup-løsningen din med AI-verktøy, apper og andre plattformer. Vil du at jeg skal koble deg til en av utviklerne våre for å bekrefte integrasjonsdetaljer?”
+
+# 🟨 4. DASHBORD / PROSJEKTSTYRING
+# Formål: Hjelpe brukere med å forstå prosjektdashbordet.
+# Forklar:
+# · Hvor dashbordet er plassert.
+# · Hva det viser (oppgaver, frister, prosjektfremdrift, fakturaer).
+# · Hvordan få tilgang (etter onboarding/konsultasjon).
+# Eksempel: “Dashbordet viser all prosjektfremdrift, frister og fakturaer. Etter konsultasjon og onboarding får du tilgang. Vil du at jeg skal vise deg hvordan du starter onboarding?”
+
+# 🟪 5. ADMINISTRASJON / KONTAKT
+# Formål: Gi kontaktinfo og veilede til riktig avdeling.
+# · Gi kontakter for salg, teknisk og støtte.
+# · Bestill møter eller send skjemaer.
+# Eksempel: “Du kan kontakte oss via kontaktskjemaet på jobobike.no. Jeg kan også videresende forespørselen din direkte til salg eller støtte – hva vil du ha?”
+
+# **FAQ-SEKSJON (KUNNSKAPSBASEN)**
+# 1. Hva gjør JOBObike? Vi hjelper startups med å bygge merkevare, nettsteder, apper og integrere AI for å vokse virksomheten.
+# 2. Hvilke språk støtter boten? Alle språk, bestemt under onboarding.
+# 3. Hvordan fungerer onboarding? Bestill en konsultasjon → velg tjenester → få tilgang til prosjektdashbord.
+# 4. Hvor kan jeg se prising? Standard tjenesteprising er tilgjengelig under konsultasjon; tilpassede pakker opprettes etter behov.
+# 5. Hvordan kontakter jeg støtte? Via kontaktskjemaet på jobobike.no – velg “Støtte”.
+# 6. Tilbyr dere AI-integrasjon? Ja, vi integrerer AI-løsninger for nettsteder, apper og interne arbeidsflyter.
+# 7. Kan jeg se eksempler på arbeidet deres? Ja, boten kan gi lenker til porteføljen vår eller bestille en demo.
+# 8. Hvor raskt får jeg svar? Normalt innen én virkedag, raskere for pågående prosjekter.
+
+# **Handlingsforespørsler**
+# Avslutt alltid med klare handlingsforespørsler:
+# - “Vil du at jeg skal bestille en konsultasjon?”
+# - “Vil du at jeg skal koble deg til en prosjektleder?”
+# - “Vil du at jeg skal sende deg vår portefølje?”
+
+# **Reserveløsning**
+# Hvis usikker på svaret: “Jeg vil videresende dette til riktig avdeling for å sikre at du får nøyaktig informasjon. Vil du at jeg skal gjøre det nå?”
+# Logg samtalen og rut til menneskelig agent.
+
+# **Samtaleflyt**
+# 1. Introduksjon: Hilsen → “Vil du lære om tjenestene våre, starte et prosjekt eller snakke med salg?”
+# 2. Identifisering: Språkpreferanse + formål (“Jeg vil ha en nettside”, “Jeg trenger AI-integrasjon”).
+# 3. Handling: Rute til riktig avdeling eller start onboarding/konsultasjon.
+# 4. Oppfølging: Bekreft at saken er logget eller lenken er sendt.
+# 5. Avslutning: “Vil du at jeg skal sende en oppsummering via e-post?”
+
+# **Hovedmål**
+# Hver samtale må avsluttes med handling – konsultasjon, prosjektinitiering, kontakt eller oppfølging.
+
+
+
+
+# ## FORMATTING RULE (CRITICAL)
+# - Respond in PLAIN TEXT only. Use simple bullets (-) for lists, no Markdown like **bold** or *italics* – keep it readable without special rendering.
+# - Example good response: "JOBObike helps startups with full brand development. We build websites and apps too. Want a consultation?"
+# - Avoid repetition: Keep answers under 200 words, no duplicate sentences.
+# - If using tools, summarize cleanly: "From our docs: [key points]."
+# Use proper spacing
+# - Write in clear paragraphs
+# - Do not remove spaces between words
+# - Keep responses concise and professional
+# """
+    
+#     # Append the critical language instruction at the end
+#     return instructions + language_instruction
+
+
+
+from agents import RunContextWrapper
+
+def jobobike_dynamic_instructions(ctx: RunContextWrapper, agent) -> str:
+    """Create dynamic instructions for JOBObike chatbot queries with language context."""
+    
+    # Get user's selected language from context
+    user_lang = ctx.context.get("language", "english").lower()
+    
+    # Determine language enforcement
+    language_instruction = ""
+    if user_lang.startswith("nor") or "norwegian" in user_lang or user_lang == "no":
+        language_instruction = "\n\n🔴 CRITICAL: You MUST respond ONLY in Norwegian (Norsk). Do NOT use English unless the user explicitly requests it."
+    elif user_lang.startswith("eng") or "english" in user_lang or user_lang == "en":
+        language_instruction = "\n\n🔴 CRITICAL: You MUST respond ONLY in English. Do NOT use Norwegian unless the user explicitly requests it."
+    else:
+        language_instruction = f"\n\n🔴 CRITICAL: You MUST respond ONLY in {user_lang}. Do NOT use any other language unless the user explicitly requests it."
+    
+    instructions = """
+# JOBOBIKE ASSISTANT - CORE INSTRUCTIONS
+
+## ROLE
+You are JOBObike Assistant – the official AI assistant for JOBObike e-commerce platform.
+You help customers with product information, orders, shopping assistance, and support professionally, clearly, and in a solution-oriented way.
+Your main goal is to guide customers, provide concrete answers about products and services, and always lead the user to action (making a purchase, checking order status, contacting support).
+
+## ABOUT JOBOBIKE
+JOBObike is an e-commerce platform specializing in bicycles and bike-related products. We offer:
+· Wide range of bicycles and cycling equipment
+· Quality products from trusted brands
+· Easy online shopping experience
+· Secure payment and fast delivery
+
+We focus on providing excellent customer service, competitive prices, and reliable delivery to ensure the best shopping experience.
+
+## KEY CAPABILITIES
+You have access to company documents through specialized tools. When users ask questions about company information, products, or services, you MUST use these tools:
+1. `list_available_documents()` - List all available documents
+2. `read_document_data(query)` - Search for specific information in company documents
+
+## WHEN TO USE TOOLS
+Whenever a user asks about documents, services, products, or company information, you MUST use the appropriate tool FIRST before responding.
+
+Examples of when to use tools:
+- User asks "What documents do you have?" → Use `list_available_documents()`
+- User asks "What services do you offer?" → Use `read_document_data("services")`
+- User asks "Tell me about your products" → Use `read_document_data("products")`
+
+IMPORTANT: When you use a tool, you MUST incorporate the tool's response directly into your answer. Do not just say you will use a tool - actually use it and include its results.
+
+Example of correct response:
+User: "What documents do you have?"
+Assistant: "I found the following documents: [tool output here]"
+
+Example of incorrect response:
+User: "What documents do you have?"
+Assistant: "I will now use the tool to get this information."
+
+Always execute tools and show their results.
+
+JOBObike serves customers globally and must know this - answer questions about location correctly.
+Users can ask questions in English or Norwegian, and the assistant must respond in the same language as the user.
+
+## RESPONSE GUIDELINES
+- Professional, friendly, and helpful
+- Avoid vague responses. Always suggest next steps:
+  · "Would you like to browse our product catalog?"
+  · "Can I help you find a specific product?"
+  · "Would you like to check your order status?"
+- Be concise and direct in your responses
+- Always guide users toward concrete actions (making a purchase, checking order, contacting support)
+- Maintain a friendly and professional tone suitable for e-commerce
+- Write naturally with proper spacing between words
+- Format responses in clear paragraphs with line breaks for readability
+- Use natural language flow like a friendly conversation
+
+## DEPARTMENT-SPECIFIC BEHAVIOR
+🟦 1. PRODUCT INQUIRIES / SHOPPING
+Purpose: Help customers find products and make purchases.
+Explain:
+· Product categories and availability
+· Product specifications and features
+· Pricing, discounts, and promotions
+· How to add items to cart and checkout
+Example: "We have a wide selection of bicycles, from mountain bikes to road bikes. I can help you find the perfect bike for your needs. What type of cycling are you interested in?"
+
+🟩 2. ORDER SUPPORT / TRACKING
+Purpose: Assist customers with existing orders and tracking.
+· Help customers check order status
+· Provide tracking information for shipments
+· Assist with order modifications or cancellations
+· Inform about delivery times and shipping options
+Example: "I can help you track your order. Please provide your order number, and I'll check the current status and estimated delivery date for you."
+
+🟥 3. PRODUCT SUPPORT / TECHNICAL QUESTIONS
+Purpose: Answer technical questions about products.
+· Explain product features and specifications
+· Help with product compatibility questions
+· Provide sizing and fit information
+· Assist with product comparisons
+Example: "I can help you compare different bike models and their features. What are you looking for in a bicycle - for commuting, racing, or off-road adventures?"
+
+🟨 4. ACCOUNT MANAGEMENT
+Purpose: Help customers manage their accounts.
+Explain:
+· How to create and manage an account
+· Order history and past purchases
+· Wishlist and saved items
+· Payment methods and billing information
+Example: "You can access your account dashboard to view your order history, track current orders, and manage your saved addresses. Would you like me to guide you through the account features?"
+
+🟪 5. RETURNS / REFUNDS / CUSTOMER SERVICE
+Purpose: Handle returns, refunds, and general customer service inquiries.
+· Explain return and refund policies
+· Process return requests
+· Handle customer complaints or issues
+· Provide contact information for specific departments
+Example: "We offer a hassle-free return policy. If you're not satisfied with your purchase, you can return it within [return period]. Would you like me to help you initiate a return?"
+
+## FAQ SECTION (KNOWLEDGE BASE)
+1. What is JOBObike? JOBObike is an e-commerce platform specializing in bicycles and cycling equipment. We offer a wide range of quality bikes and accessories for all types of cycling enthusiasts.
+2. Which languages does the bot support? The bot supports multiple languages including English and Norwegian. We aim to serve customers globally.
+3. How do I place an order? Simply browse our product catalog, add items to your cart, and proceed to checkout. You can create an account for faster checkout or checkout as a guest.
+4. Where can I see product prices? All product prices are displayed on our website. You can browse products by category or use the search function to find specific items.
+5. How do I contact customer support? You can reach us via the contact form on our website, email, or chat support. Our support team is available to help with any questions or issues.
+6. What is your shipping policy? We offer shipping to multiple locations. Shipping costs and delivery times vary by location. Free shipping may be available for orders above a certain amount.
+7. What is your return policy? We offer a return policy for unused items in original packaging. Please check our return policy page for specific terms and timeframes.
+8. How fast will I get a response? Our support team typically responds within 24 hours. For urgent matters, please use the chat support for immediate assistance.
+
+## ACTION PROMPTS
+Always conclude with clear action prompts:
+- "Would you like to browse our product catalog?"
+- "Can I help you find a specific product?"
+- "Would you like to check your order status?"
+- "Would you like to create an account for faster checkout?"
+
+## FALLBACK BEHAVIOR
+If unsure of an answer: "I will forward this to the right department to make sure you get accurate information. Would you like me to do that now?"
+Log conversation details and route to a human agent.
+
+## CONVERSATION FLOW
+1. Introduction: Greeting → "Welcome to JOBObike! How can I help you today? Are you looking for a specific product, or do you need help with an order?"
+2. Identification: Understand customer needs (product search, order inquiry, support request)
+3. Action: Help find products, check orders, or resolve issues
+4. Follow-up: Confirm information provided or action taken
+5. Closure: "Is there anything else I can help you with today?"
+
+## PRIMARY GOAL
+Every conversation should be helpful and guide customers toward making informed purchasing decisions, checking orders, or getting the support they need.
+
+## 🇳🇴 NORSK SEKSJON (NORWEGIAN SECTION)
+
+**Rolle:**
+Du er JOBObike Assistant – den offisielle AI-assistenten for JOBObike e-handelsplattform.
+Du hjelper kunder med produktinformasjon, bestillinger, shopping-assistanse og støtte profesjonelt, klart og løsningsorientert.
+Ditt hovedmål er å veilede kunder, gi konkrete svar om produkter og tjenester, og alltid lede brukeren til handling (gjøre et kjøp, sjekke ordrestatus, kontakte støtte).
+
+**Om JOBObike:**
+JOBObike er en e-handelsplattform som spesialiserer seg på sykler og sykkelutstyr. Vi tilbyr:
+· Stort utvalg av sykler og sykkelutstyr
+· Kvalitetsprodukter fra pålitelige merker
+· Enkel nettbutikkopplevelse
+· Sikker betaling og rask levering
+
+Vi fokuserer på å gi utmerket kundeservice, konkurransedyktige priser og pålitelig levering for å sikre den beste shoppingopplevelsen.
+
+**Nøkkelfunksjoner:**
+Du har tilgang til firmadokumenter gjennom spesialiserte verktøy. Når brukere spør om firmainformasjon, produkter eller tjenester, må du BRUKE disse verktøyene:
+1. `list_available_documents()` - Liste over alle tilgjengelige dokumenter
+2. `read_document_data(query)` - Søk etter spesifikk informasjon i firmadokumenter
+
+**Når du skal bruke verktøy:**
+Når en bruker spør om dokumenter, tjenester, produkter eller firmainformasjon, må du BRUKE det aktuelle verktøyet FØRST før du svarer.
+
+Eksempler på når du skal bruke verktøy:
+- Bruker spør "Hvilke dokumenter har dere?" → Bruk `list_available_documents()`
+- Bruker spør "Hvilke tjenester tilbyr dere?" → Bruk `read_document_data("tjenester")`
+- Bruker spør "Fortell meg om produktene deres" → Bruk `read_document_data("produkter")`
+
+VIKTIG: Når du bruker et verktøy, MÅ du inkludere verktøyets svar direkte i ditt svar. Ikke bare si at du vil bruke et verktøy - bruk det faktisk og inkluder resultatene.
+
+Eksempel på riktig svar:
+Bruker: "Hvilke dokumenter har dere?"
+Assistent: "Jeg fant følgende dokumenter: [verktøyets resultat her]"
+
+Eksempel på feil svar:
+Bruker: "Hvilke dokumenter har dere?"
+Assistent: "Jeg vil nå bruke verktøyet for å hente denne informasjonen."
+
+Utfør alltid verktøy og vis resultatene.
+
+JOBObike betjener kunder globalt og må vite dette - svar spørsmål om plassering korrekt.
+Brukere kan stille spørsmål på engelsk eller norsk, og assistenten må svare på samme språk som brukeren.
+
+**Retningslinjer for svar:**
+- Profesjonell, vennlig og hjelpsom
+- Unngå vage svar. Foreslå alltid neste steg:
+  · "Vil du se gjennom vårt produktkatalog?"
+  · "Kan jeg hjelpe deg med å finne et spesifikt produkt?"
+  · "Vil du sjekke ordrestatusen din?"
+- Vær kortfattet og direkte i svarene dine
+- Led alltid brukere mot konkrete handlinger (gjør et kjøp, sjekk ordre, kontakt støtte)
+- Oppretthold en vennlig og profesjonell tone som passer for e-handel
+- Skriv naturlig med riktig mellomrom mellom ord
+- Formater svar i klare avsnitt med linjeskift for lesbarhet
+- Bruk naturlig språkflyt som en vennlig samtale
+
+**Avdelingsspesifikk oppførsel**
+🟦 1. PRODUKTSPØRSMÅL / SHOPPING
+Formål: Hjelpe kunder med å finne produkter og gjøre kjøp.
+Forklar:
+· Produktkategorier og tilgjengelighet
+· Produktspecifikasjoner og funksjoner
+· Priser, rabatter og kampanjer
+· Hvordan legge til varer i handlekurven og sjekke ut
+Eksempel: "Vi har et stort utvalg av sykler, fra terrengsykler til landeveissykler. Jeg kan hjelpe deg med å finne den perfekte sykkelen for dine behov. Hva slags sykling er du interessert i?"
+
+🟩 2. ORDRE STØTTE / SPORING
+Formål: Assistere kunder med eksisterende bestillinger og sporing.
+· Hjelpe kunder med å sjekke ordrestatus
+· Gi sporingsinformasjon for forsendelser
+· Assistere med ordremodifikasjoner eller kanselleringer
+· Informere om leveringstider og fraktalternativer
+Eksempel: "Jeg kan hjelpe deg med å spore bestillingen din. Vennligst oppgi ordrenummeret ditt, så sjekker jeg gjeldende status og estimert leveringsdato for deg."
+
+🟥 3. PRODUKTSTØTTE / TEKNISKE SPØRSMÅL
+Formål: Svare på tekniske spørsmål om produkter.
+· Forklare produktfunksjoner og spesifikasjoner
+· Hjelpe med produktsammenligningsspørsmål
+· Gi størrelses- og passforminformasjon
+· Assistere med produktsammenligninger
+Eksempel: "Jeg kan hjelpe deg med å sammenligne ulike sykkelmodeller og deres funksjoner. Hva ser du etter i en sykkel - for pendling, racing eller offroad-eventyr?"
+
+🟨 4. KONTOSTYRING
+Formål: Hjelpe kunder med å administrere kontoene sine.
+Forklar:
+· Hvordan opprette og administrere en konto
+· Ordrehistorikk og tidligere kjøp
+· Ønskeliste og lagrede varer
+· Betalingsmetoder og faktureringsinformasjon
+Eksempel: "Du kan få tilgang til kontodashbordet ditt for å se ordrehistorikken din, spore gjeldende bestillinger og administrere lagrede adresser. Vil du at jeg skal veilede deg gjennom kontofunksjonene?"
+
+🟪 5. RETUR / REFUSJON / KUNDESERVICE
+Formål: Håndtere returer, refusjoner og generelle kundeserviceforespørsler.
+· Forklare retur- og refusjonspolicy
+· Behandle returforespørsler
+· Håndtere klager eller problemer
+· Gi kontaktinformasjon for spesifikke avdelinger
+Eksempel: "Vi tilbyr en problemfri returpolicy. Hvis du ikke er fornøyd med kjøpet ditt, kan du returnere det innen [returperiode]. Vil du at jeg skal hjelpe deg med å starte en retur?"
+
+**FAQ-SEKSJON (KUNNSKAPSBASEN)**
+1. Hva er JOBObike? JOBObike er en e-handelsplattform som spesialiserer seg på sykler og sykkelutstyr. Vi tilbyr et stort utvalg av kvalitetssykler og tilbehør for alle typer sykkelentusiaster.
+2. Hvilke språk støtter boten? Boten støtter flere språk, inkludert engelsk og norsk. Vi sikter mot å betjene kunder globalt.
+3. Hvordan legger jeg inn en bestilling? Bare bla gjennom produktkatalogen vår, legg til varer i handlekurven din, og fortsett til kassen. Du kan opprette en konto for raskere kasse eller sjekke ut som gjest.
+4. Hvor kan jeg se produktpriser? Alle produktpriser vises på nettsiden vår. Du kan bla gjennom produkter etter kategori eller bruke søkefunksjonen for å finne spesifikke varer.
+5. Hvordan kontakter jeg kundeservice? Du kan nå oss via kontaktskjemaet på nettsiden vår, e-post eller chatstøtte. Vårt supportteam er tilgjengelig for å hjelpe med spørsmål eller problemer.
+6. Hva er deres fraktpolicy? Vi tilbyr frakt til flere steder. Fraktkostnader og leveringstider varierer etter sted. Gratis frakt kan være tilgjengelig for bestillinger over et visst beløp.
+7. Hva er deres returpolicy? Vi tilbyr en returpolicy for ubrukte varer i originalemballasje. Vennligst sjekk vår returpolicyside for spesifikke vilkår og tidsrammer.
+8. Hvor raskt får jeg svar? Supportteamet vårt svarer vanligvis innen 24 timer. For presserende saker, vennligst bruk chatstøtten for umiddelbar assistanse.
+
+**Handlingsforespørsler**
+Avslutt alltid med klare handlingsforespørsler:
+- "Vil du se gjennom produktkatalogen vår?"
+- "Kan jeg hjelpe deg med å finne et spesifikt produkt?"
+- "Vil du sjekke ordrestatusen din?"
+- "Vil du opprette en konto for raskere kasse?"
+
+**Reserveløsning**
+Hvis usikker på svaret: "Jeg vil videresende dette til riktig avdeling for å sikre at du får nøyaktig informasjon. Vil du at jeg skal gjøre det nå?"
+Logg samtalen og rut til menneskelig agent.
+
+**Samtaleflyt**
+1. Introduksjon: Hilsen → "Velkommen til JOBObike! Hvordan kan jeg hjelpe deg i dag? Ser du etter et spesifikt produkt, eller trenger du hjelp med en bestilling?"
+2. Identifisering: Forstå kundens behov (produktsøk, ordrehenvendelse, støtteforespørsel)
+3. Handling: Hjelp med å finne produkter, sjekke bestillinger eller løse problemer
+4. Oppfølging: Bekreft informasjon gitt eller handling utført
+5. Avslutning: "Er det noe annet jeg kan hjelpe deg med i dag?"
+
+**Hovedmål**
+Hver samtale skal være hjelpsom og veilede kunder mot å ta informerte kjøpsbeslutninger, sjekke bestillinger eller få den støtten de trenger.
+
+## FORMATTING RULES (CRITICAL)
+- Write responses in clear, natural paragraphs with proper spacing between sentences
+- Use line breaks to separate different ideas or sections for better readability
+- Keep paragraphs concise (2-4 sentences each)
+- Use bullet points (-) for lists when appropriate, but write them naturally in conversation
+- Do NOT use Markdown formatting like **bold**, *italics*, or # headers
+- Do NOT use code blocks or special formatting characters
+- Write in a conversational, friendly tone as if speaking directly to the customer
+- Ensure proper spacing between words - never run words together
+- Break long responses into multiple paragraphs for better readability
+- Start each new topic or idea on a new line with proper spacing
+- Keep responses concise but informative (aim for 3-5 paragraphs maximum for longer answers)
+- Use natural transitions between ideas
+
+Example of good formatting:
+"JOBObike offers a wide selection of bicycles for every type of cyclist. Whether you're looking for a mountain bike, road bike, or city commuter, we have something for you.
+
+Our products come from trusted brands known for quality and reliability. We ensure all bikes are properly tested before shipping.
+
+Would you like me to help you find a specific type of bicycle? I can guide you through our catalog based on your needs."
+"""
+    
+    # Append the critical language instruction at the end
+    return instructions + language_instruction

main.py

@@ -0,0 +1,238 @@
+# # example_usage.py
+# import asyncio
+# import traceback
+# from agents import Runner, RunContextWrapper
+# from agents.exceptions import InputGuardrailTripwireTriggered
+# from openai.types.responses import ResponseTextDeltaEvent
+# from chatbot.chatbot_agent import innscribe_assistant
+
+# async def query_innscribe_bot(user_message: str, stream: bool = True):
+#     """
+#     Query the Innoscribe bot with optional streaming (ChatGPT-style chunk-by-chunk output).
+    
+#     Args:
+#         user_message: The user's message/query
+#         stream: If True, stream responses chunk by chunk like ChatGPT. If False, wait for complete response.
+    
+#     Returns:
+#         The final output from the agent
+#     """
+#     try:
+#         ctx = RunContextWrapper(context={})
+        
+#         if stream:
+#             # ChatGPT-style streaming: clean output, text appears chunk by chunk
+#             result = Runner.run_streamed(
+#                 innscribe_assistant,
+#                 input=user_message,
+#                 context=ctx.context
+#             )
+            
+#             # Stream text chunk by chunk in real-time (like ChatGPT)
+#             async for event in result.stream_events():
+#                 if event.type == "raw_response_event" and isinstance(event.data, ResponseTextDeltaEvent):
+#                     delta = event.data.delta
+#                     if delta:
+#                         # Print each chunk immediately as it arrives (ChatGPT-style)
+#                         print(delta, end="", flush=True)
+            
+#             print("\n")  # New line after streaming completes
+#             return result.final_output
+#         else:
+#             # Non-streaming mode: wait for complete response
+#             response = await Runner.run(
+#                 innscribe_assistant,
+#                 input=user_message,
+#                 context=ctx.context
+#             )
+#             return response.final_output
+            
+#     except InputGuardrailTripwireTriggered as e:
+#         print(f"\n⚠️  Guardrail blocked the query: {e}")
+#         if hasattr(e, 'result') and hasattr(e.result, 'output_info'):
+#             print(f"Guardrail reason: {e.result.output_info}")
+#         print("The query was determined to be unrelated to Innoscribe services.")
+#         return None
+#     except Exception as e:
+#         print(f"\n❌ Error: {e}")
+#         print(traceback.format_exc())
+#         raise
+
+# async def interactive_chat():
+#     """
+#     Interactive ChatGPT-style conversation loop.
+#     Type 'exit', 'quit', or 'bye' to end the conversation.
+#     """
+#     print("=" * 60)
+#     print("🤖 Innoscribe Assistant - ChatGPT-style Chat")
+#     print("Type 'exit', 'quit', or 'bye' to end the conversation")
+#     print("=" * 60)
+#     print()
+    
+#     while True:
+#         try:
+#             user_message = input("👤 You: ").strip()
+            
+#             # Check for exit commands
+#             if user_message.lower() in ['exit', 'quit', 'bye', '']:
+#                 print("\n👋 Goodbye! Have a great day!")
+#                 break
+            
+#             # Display assistant prefix and stream response
+#             print("🤖 Assistant: ", end="", flush=True)
+            
+#             # Stream response chunk by chunk (ChatGPT-style)
+#             response = await query_innscribe_bot(user_message, stream=True)
+            
+#             print()  # Empty line between messages
+            
+#         except KeyboardInterrupt:
+#             print("\n\n👋 Conversation interrupted. Goodbye!")
+#             break
+#         except Exception as e:
+#             print(f"\n❌ Error: {e}")
+#             print("Please try again or type 'exit' to quit.\n")
+
+# async def main():
+#     try:
+#         # Option 1: Single message example (ChatGPT-style streaming)
+#         user_message = "Hello, how can I help you?"
+        
+#         print(f"👤 You: {user_message}\n")
+#         print("🤖 Assistant: ", end="", flush=True)
+        
+#         # Stream response chunk by chunk (ChatGPT-style)
+#         response = await query_innscribe_bot(user_message, stream=True)
+        
+#         # Option 2: Uncomment below to use interactive chat mode instead
+#         # await interactive_chat()
+        
+#     except Exception as e:
+#         print(f"\n❌ Error: {e}")
+#         print(traceback.format_exc())
+
+# if __name__ == "__main__":
+#     try:
+#         asyncio.run(main())
+#     except Exception as e:
+#         print(f"Fatal error: {e}")
+#         print(traceback.format_exc())
+# example_usage.py
+import asyncio
+import traceback
+from agents import Runner, RunContextWrapper
+from agents.exceptions import InputGuardrailTripwireTriggered
+from openai.types.responses import ResponseTextDeltaEvent
+from chatbot.chatbot_agent import jobobike_assistant
+
+async def query_jobobike_bot(user_message: str, stream: bool = True):
+    """
+    Query the JOBObike bot with optional streaming (ChatGPT-style chunk-by-chunk output).
+    
+    Args:
+        user_message: The user's message/query
+        stream: If True, stream responses chunk by chunk like ChatGPT. If False, wait for complete response.
+    
+    Returns:
+        The final output from the agent
+    """
+    try:
+        ctx = RunContextWrapper(context={})
+        
+        if stream:
+            # ChatGPT-style streaming: clean output, text appears chunk by chunk
+            result = Runner.run_streamed(
+                jobobike_assistant,
+                input=user_message,
+                context=ctx.context
+            )
+            
+            # Stream text chunk by chunk in real-time (like ChatGPT)
+            async for event in result.stream_events():
+                if event.type == "raw_response_event" and isinstance(event.data, ResponseTextDeltaEvent):
+                    delta = event.data.delta
+                    if delta:
+                        # Print each chunk immediately as it arrives (ChatGPT-style)
+                        print(delta, end="", flush=True)
+            
+            print("\n")  # New line after streaming completes
+            return result.final_output
+        else:
+            # Non-streaming mode: wait for complete response
+            response = await Runner.run(
+                jobobike_assistant,
+                input=user_message,
+                context=ctx.context
+            )
+            return response.final_output
+            
+    except InputGuardrailTripwireTriggered as e:
+        print(f"\n⚠️  Guardrail blocked the query: {e}")
+        if hasattr(e, 'result') and hasattr(e.result, 'output_info'):
+            print(f"Guardrail reason: {e.result.output_info}")
+        print("The query was determined to be unrelated to JOBObike services.")
+        return None
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        print(traceback.format_exc())
+        raise
+
+async def interactive_chat():
+    """
+    Interactive ChatGPT-style conversation loop.
+    Type 'exit', 'quit', or 'bye' to end the conversation.
+    """
+    print("=" * 60)
+    print("🤖 JOBObike Assistant - ChatGPT-style Chat")
+    print("Type 'exit', 'quit', or 'bye' to end the conversation")
+    print("=" * 60)
+    print()
+    
+    while True:
+        try:
+            user_message = input("👤 You: ").strip()
+            
+            # Check for exit commands
+            if user_message.lower() in ['exit', 'quit', 'bye', '']:
+                print("\n👋 Goodbye! Have a great day!")
+                break
+            
+            # Display assistant prefix and stream response
+            print("🤖 Assistant: ", end="", flush=True)
+            
+            # Stream response chunk by chunk (ChatGPT-style)
+            response = await query_jobobike_bot(user_message, stream=True)
+            
+            print()  # Empty line between messages
+            
+        except KeyboardInterrupt:
+            print("\n\n👋 Conversation interrupted. Goodbye!")
+            break
+        except Exception as e:
+            print(f"\n❌ Error: {e}")
+            print("Please try again or type 'exit' to quit.\n")
+
+async def main():
+    try:
+        # Option 1: Single message example (ChatGPT-style streaming)
+        user_message = "Hello, tell me about your services."
+        
+        print(f"👤 You: {user_message}\n")
+        print("🤖 Assistant: ", end="", flush=True)
+        
+        # Stream response chunk by chunk (ChatGPT-style)
+        response = await query_jobobike_bot(user_message, stream=True)
+        
+        # Option 2: Uncomment below to use interactive chat mode instead
+        # await interactive_chat()
+        
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        print(traceback.format_exc())
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except Exception as e:
+        print(f"Fatal error: {e}")
+        print(traceback.format_exc())

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+openai-agents
+python-dotenv
+slowapi
+firebase-admin
+python-docx
+PyPDF2
+resend

schema/chatbot_schema.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+class OutputType(BaseModel):
+    is_query_about_jobobike: bool
+    reason: str

serviceAccount.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "jobobike-aeb6c",
+  "private_key_id": "4e2e42cf3c7c0dd3bf652346873a4c0ec235d2f2",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC/0awb++o0FUr6\n4JjYaPnUl+flkPcRxMalGH61ZPytEND/Iy7a3EWDPu17u7UnzQDbGtuyPuejF2GS\nt6m1JbW9V71Gchqg/cq6OA6QTM3KR9meYZSr4iTjOlijSi2DjIzHiCjYwfsGwQJ/\nMENAFqCKLDR37S0D6YR52WuD2ulnK3vrJs3uRyeM6EGHTs+2k2VVOfX4SuTqGbeB\nVOo1Y91bHnhOcvlC2L7kgXo0dJTBjTe0LxjogoZSuf+dQ2Q9SCnbgQuuqTmSXOwd\njFf+J0GJma/kMy/m0jzGPyrrWwNkqMV689jeIx2sc+7YBNbOs8crHtg+tecEfOQ4\n4fNttNgzAgMBAAECggEADVEBvEQBIdJNzSkOo1nb6JgOt5KyFeM0KsQoQ7257Uyk\nd00arlBdaQhs1Zd8TFuNUPV5eNN1Vdt3lCDSk/dR7LRsuOyOw0w39ZtfpqfjH3hc\n3lBshE3XFrx3TweFLZByOexOpAgJCvjj2S8uDZxxUumEgpDa4t5XkPTFluoTJJ//\nfeyKyWMh+1KAFPMF5K6O5eSSsN/waJYVKzkOaG7nNFqX9/yYXJOrBWx7inM2WjIt\n3r/Dhlmh3Bbs75XoXInxiWnTxxPmdyZ3r973lWLlvYFzd7m1P5Hc24VOW2vHHaNJ\nuwDVerNJmZZ6fgs6OPUZWbFXg1qNYkLnwVa8Yy/mqQKBgQD6F2xaM+PGgCcb9aLX\n6yzfhhCIemuRtnabfqm9lTsqa0s4j6zN3Qr7Ii4eKP7CMc7WCUVJHUg8BlWRuB0r\nY4kuab9n2GcE1rJXf+f46OoJQ3LlpSHKjkpZA1bCJTAMYCEQbq7hty4kLCH4RSiT\nYox4jWe2GT74IuHWiQdaqQi8+wKBgQDEWc/OEcatDvSetzaO0ludEqxS1cnfBO4W\nm8J787oNc3f3De1z5lypXr+4rRAf5R9Dw/kSqUuTNWKnyb6eq2Xzm9XRaF0pSoK5\nZUmE2L9AnNlRHumYATEePbU9q/Tcl/es85et+APOg6nmKMF58NvuR/KEiS2WHl0n\nGEaIej98KQKBgQChT7pz9ERXJRIU1rvSyb6H7tF7Nntr4WVfprOVtUwUcGB0ezfb\nEVij48gbbBXm7HmdVR17q4eMMAnBlCA8fFdfuJXdRZgtZs5h4f6ebp2GnBrgRUMm\ng+EwyRaM46+6S8cH8lya+qyoaE8A9JrXdhllKNBchKw5IUbKOlikAaPBQQKBgQCq\nPxUnH9KcCvOfCkyL2WkF8ELqL+QxMx0dDUC8KL+RGiVSWQkiDQMa98RUY/ovLYLG\nRw2XWKLmqMs5oHtfKE3lw6DJSSw9uRVPmrr8LNLnOxhSdfMkkSP9jJOxPX+6JSnj\nE/LYLMtgLFkL7xqSmHyZRljJAgg8uWcblrjRbO3OwQKBgQDggbkmXzUW9SOFWdaY\nVHhKex0ViW5ErImeloqJv0OSi9wScpWfLXKrGx5av8PD0lmWRTwAmSXXbLIB7pR8\nNByBYZuX1qAf2b6TNjJJEsoG1J0aVgLjxfRa/gUhQWVs9sQHovzrLJLzk9Hwzke/\nFlM2hUUBEnVmz7aB1O0CzuUn8Q==\n-----END PRIVATE KEY-----\n",
+  "client_email": "firebase-adminsdk-fbsvc@jobobike-aeb6c.iam.gserviceaccount.com",
+  "client_id": "101863747332067729398",
+  "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%40jobobike-aeb6c.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

sessions/__init__.py

@@ -0,0 +1 @@
+"""Sessions module for the JOBObike chatbot."""

sessions/session_manager.py

@@ -0,0 +1,181 @@
+"""
+Session Manager for JOBObike Chatbot
+Handles chat history persistence using Firebase Firestore
+"""
+
+import uuid
+import time
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional, Any
+from tools.firebase_config import db
+
+class SessionManager:
+    """Manages chat sessions and history using Firebase Firestore"""
+    
+    def __init__(self, collection_name: str = "chat_sessions"):
+        """
+        Initialize the session manager
+        
+        Args:
+            collection_name: Name of the Firestore collection to store sessions
+        """
+        self.collection_name = collection_name
+        self.sessions_collection = db.collection(collection_name) if db else None
+        
+    def create_session(self, user_id: Optional[str] = None) -> str:
+        """
+        Create a new chat session
+        
+        Args:
+            user_id: Optional user identifier
+            
+        Returns:
+            Session ID
+        """
+        if not self.sessions_collection:
+            return str(uuid.uuid4())
+            
+        session_id = str(uuid.uuid4())
+        session_data = {
+            "session_id": session_id,
+            "user_id": user_id or "anonymous",
+            "created_at": datetime.utcnow(),
+            "last_active": datetime.utcnow(),
+            "history": [],
+            "expired": False
+        }
+        
+        try:
+            self.sessions_collection.document(session_id).set(session_data)
+            return session_id
+        except Exception as e:
+            print(f"Warning: Failed to create session in Firestore: {e}")
+            return session_id
+    
+    def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve a session by ID
+        
+        Args:
+            session_id: Session identifier
+            
+        Returns:
+            Session data or None if not found
+        """
+        if not self.sessions_collection:
+            return None
+            
+        try:
+            doc = self.sessions_collection.document(session_id).get()
+            if doc.exists:
+                session_data = doc.to_dict()
+                # Convert timestamp strings back to datetime objects
+                if "created_at" in session_data and isinstance(session_data["created_at"], str):
+                    session_data["created_at"] = datetime.fromisoformat(session_data["created_at"].replace("Z", "+00:00"))
+                if "last_active" in session_data and isinstance(session_data["last_active"], str):
+                    session_data["last_active"] = datetime.fromisoformat(session_data["last_active"].replace("Z", "+00:00"))
+                return session_data
+            return None
+        except Exception as e:
+            print(f"Warning: Failed to retrieve session from Firestore: {e}")
+            return None
+    
+    def add_message_to_history(self, session_id: str, role: str, content: str) -> bool:
+        """
+        Add a message to the chat history
+        
+        Args:
+            session_id: Session identifier
+            role: Role of the message sender (user/assistant)
+            content: Message content
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        if not self.sessions_collection:
+            return False
+            
+        try:
+            # Get current session data
+            session_doc = self.sessions_collection.document(session_id)
+            session_data = session_doc.get().to_dict()
+            
+            if not session_data:
+                return False
+                
+            # Add new message to history
+            message = {
+                "role": role,
+                "content": content,
+                "timestamp": datetime.utcnow()
+            }
+            
+            # Update session data
+            session_data["history"].append(message)
+            session_data["last_active"] = datetime.utcnow()
+            
+            # Keep only the last 20 messages to prevent document bloat
+            if len(session_data["history"]) > 20:
+                session_data["history"] = session_data["history"][-20:]
+            
+            # Update in Firestore
+            session_doc.update({
+                "history": session_data["history"],
+                "last_active": session_data["last_active"]
+            })
+            
+            return True
+        except Exception as e:
+            print(f"Warning: Failed to add message to session history: {e}")
+            return False
+    
+    def get_session_history(self, session_id: str) -> List[Dict[str, str]]:
+        """
+        Get the chat history for a session
+        
+        Args:
+            session_id: Session identifier
+            
+        Returns:
+            List of message dictionaries
+        """
+        session_data = self.get_session(session_id)
+        if session_data and "history" in session_data:
+            # Return only role and content for each message
+            return [{"role": msg["role"], "content": msg["content"]} 
+                   for msg in session_data["history"]]
+        return []
+    
+    def cleanup_expired_sessions(self, expiry_hours: int = 24) -> int:
+        """
+        Clean up expired sessions
+        
+        Args:
+            expiry_hours: Number of hours after which sessions expire
+            
+        Returns:
+            Number of sessions cleaned up
+        """
+        if not self.sessions_collection:
+            return 0
+            
+        try:
+            cutoff_time = datetime.utcnow() - timedelta(hours=expiry_hours)
+            expired_sessions = self.sessions_collection.where(
+                "last_active", "<", cutoff_time
+            ).where("expired", "==", False).stream()
+            
+            count = 0
+            for session in expired_sessions:
+                self.sessions_collection.document(session.id).update({
+                    "expired": True
+                })
+                count += 1
+                
+            return count
+        except Exception as e:
+            print(f"Warning: Failed to clean up expired sessions: {e}")
+            return 0
+
+# Global session manager instance
+session_manager = SessionManager()

tools/README.md

@@ -0,0 +1,169 @@
+# Document Reader Tools
+
+This module provides function tools for your Innoscribe chatbot agent to read documents from local files (PDF, DOCX) and Firebase Firestore.
+
+## Features
+
+- **Read Local Documents**: Automatically reads `data.docx` and any PDF files from the root directory
+- **Read Firestore Documents**: Reads documents from the `data` collection in Firebase Firestore
+- **Auto Mode**: Tries local files first, then falls back to Firestore
+- **List Available Documents**: Shows all available documents from both sources
+
+## Setup
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+Required packages:
+- `firebase-admin` - For Firebase Firestore integration
+- `python-docx` - For reading DOCX files
+- `PyPDF2` - For reading PDF files
+
+### 2. Firebase Configuration
+
+Make sure your `serviceAccount.json` file is in the root directory of the project. This file is used to authenticate with Firebase.
+
+### 3. Document Storage
+
+**Local Documents:**
+- Place your `data.docx` file in the root directory
+- Place any PDF files in the root directory
+
+**Firestore Documents:**
+- Upload documents to the `data` collection in Firebase Firestore
+- Each document should have a `content`, `text`, or `data` field containing the text
+- Optionally include a `name` field for identification
+
+## Usage
+
+### Basic Integration with Agent
+
+```python
+from agents import Agent
+from config.chabot_config import model
+from instructions.chatbot_instructions import innscribe_dynamic_instructions
+from tools.document_reader_tool import read_document_data, list_available_documents
+
+# Create agent with document reading tools
+innscribe_assistant = Agent(
+    name="Innoscribe Assistant",
+    instructions=innscribe_dynamic_instructions,
+    model=model,
+    tools=[read_document_data, list_available_documents]
+)
+```
+
+### Tool Functions
+
+#### `read_document_data(query: str, source: str = "auto")`
+
+Reads and searches for information from documents.
+
+**Parameters:**
+- `query`: The search query or topic to look for
+- `source`: Where to read from - `"local"`, `"firestore"`, or `"auto"` (default)
+
+**Returns:** Formatted content from matching documents
+
+**Example:**
+```python
+result = read_document_data("product information", source="auto")
+```
+
+#### `list_available_documents()`
+
+Lists all available documents from both local storage and Firestore.
+
+**Returns:** Formatted list of available documents
+
+**Example:**
+```python
+docs = list_available_documents()
+print(docs)
+```
+
+## How It Works
+
+### Automatic Fallback Strategy
+
+1. **Auto Mode (default)**: 
+   - First tries to read from local files (data.docx, *.pdf)
+   - If no data found, tries Firebase Firestore
+   - Returns combined results if both sources have data
+
+2. **Local Mode**:
+   - Only reads from local files
+
+3. **Firestore Mode**:
+   - Only reads from Firebase Firestore
+
+### Agent Behavior
+
+When a user asks a question requiring document data, the agent will:
+
+1. Detect that document information is needed
+2. Automatically call `read_document_data()` with the relevant query
+3. Search through local files and/or Firestore
+4. Return the relevant information to answer the user's question
+
+## Example User Interactions
+
+**User:** "What information do you have about our company?"
+- Agent calls: `read_document_data("company information")`
+- Returns relevant content from documents
+
+**User:** "List all available documents"
+- Agent calls: `list_available_documents()`
+- Returns formatted list of all documents
+
+**User:** "Tell me about product pricing"
+- Agent calls: `read_document_data("product pricing")`
+- Returns pricing information from documents
+
+## Firestore Collection Structure
+
+Your Firestore `data` collection should have documents structured like:
+
+```json
+{
+  "name": "Product Catalog",
+  "content": "This is the product information...",
+  "type": "product",
+  "created_at": "2024-01-01"
+}
+```
+
+Or simply:
+
+```json
+{
+  "text": "Document content here..."
+}
+```
+
+The tool will look for `content`, `text`, or `data` fields to extract the document text.
+
+## Testing
+
+Run the example usage file to test the tools:
+
+```bash
+python tools/example_usage.py
+```
+
+## Troubleshooting
+
+**Firebase not initializing:**
+- Check that `serviceAccount.json` exists in the root directory
+- Verify the service account has Firestore permissions
+
+**Documents not found:**
+- Verify `data.docx` or PDF files exist in the root directory
+- Check Firestore collection is named `data`
+- Ensure documents have `content`, `text`, or `data` fields
+
+**Import errors:**
+- Make sure all dependencies are installed: `pip install -r requirements.txt`

tools/__init__.py

@@ -0,0 +1 @@
+"""Tools module for the Innoscribe chatbot agent."""

tools/document_reader_tool.py

@@ -0,0 +1,212 @@
+import os
+import io
+import requests
+import logging
+from typing import Optional
+from agents import function_tool
+from docx import Document
+import PyPDF2
+from .firebase_config import db
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
+
+@function_tool
+def read_document_data(query: str, source: str = "auto") -> str:
+    """
+    Read and search for information from documents stored locally or in Firebase Firestore.
+    
+    Args:
+        query: The search query or topic to look for in the documents
+        source: Data source - "local" for local files, "firestore" for Firebase, or "auto" to try both
+    
+    Returns:
+        The relevant content from the document(s) matching the query
+    """
+    logger.info(f"TOOL CALL: read_document_data called with query='{query}', source='{source}'")
+    
+    result = []
+    
+    # Try local files first if source is "local" or "auto"
+    if source in ["local", "auto"]:
+        local_content = _read_local_documents(query)
+        if local_content:
+            result.append(f"=== Local Documents ===\n{local_content}")
+    
+    # Try Firestore if source is "firestore" or "auto" (and local didn't return results)
+    if source in ["firestore", "auto"] and (not result or source == "firestore"):
+        firestore_content = _read_firestore_documents(query)
+        if firestore_content:
+            result.append(f"=== Firestore Documents ===\n{firestore_content}")
+    
+    if result:
+        response = "\n\n".join(result)
+        logger.info(f"TOOL RESULT: read_document_data found {len(result)} result(s)")
+        return response
+    else:
+        response = f"No relevant information found for query: '{query}'. Please check if documents are available."
+        logger.info(f"TOOL RESULT: read_document_data found no results for query='{query}'")
+        return response
+
+def _read_local_documents(query: str) -> Optional[str]:
+    """Read from local PDF and DOCX files in the root directory."""
+    root_dir = os.path.dirname(os.path.dirname(__file__))
+    content_parts = []
+    
+    # Try to read DOCX file
+    docx_path = os.path.join(root_dir, "data.docx")
+    if os.path.exists(docx_path):
+        try:
+            doc = Document(docx_path)
+            full_text = []
+            for paragraph in doc.paragraphs:
+                if paragraph.text.strip():
+                    full_text.append(paragraph.text)
+            
+            docx_content = "\n".join(full_text)
+            if docx_content:
+                content_parts.append(f"[From data.docx]\n{docx_content}")
+        except Exception as e:
+            content_parts.append(f"Error reading data.docx: {str(e)}")
+    
+    # Try to read PDF files
+    for file in os.listdir(root_dir):
+        if file.endswith(".pdf"):
+            pdf_path = os.path.join(root_dir, file)
+            try:
+                with open(pdf_path, "rb") as pdf_file:
+                    pdf_reader = PyPDF2.PdfReader(pdf_file)
+                    pdf_text = []
+                    for page in pdf_reader.pages:
+                        text = page.extract_text()
+                        if text.strip():
+                            pdf_text.append(text)
+                    
+                    if pdf_text:
+                        content_parts.append(f"[From {file}]\n" + "\n".join(pdf_text))
+            except Exception as e:
+                content_parts.append(f"Error reading {file}: {str(e)}")
+    
+    return "\n\n".join(content_parts) if content_parts else None
+
+
+def _read_firestore_documents(query: str) -> Optional[str]:
+    """Read documents from Firebase Firestore 'data' collection."""
+    if not db:
+        return "Firebase Firestore is not initialized. Please check your serviceAccount.json file."
+    
+    try:
+        # Query the 'data' collection
+        docs_ref = db.collection("data")
+        docs = docs_ref.stream()
+        
+        content_parts = []
+        for doc in docs:
+            doc_data = doc.to_dict()
+            
+            # Check if document field contains a URL to a file
+            document_url = doc_data.get("document")
+            
+            if document_url:
+                # Download and read the document from URL
+                try:
+                    doc_name = doc_data.get("name", doc.id)
+                    content = _read_document_from_url(document_url, doc_name)
+                    if content:
+                        content_parts.append(f"[From Firestore: {doc_name}]\n{content}")
+                except Exception as e:
+                    content_parts.append(f"[Error reading {doc.id}]: {str(e)}")
+            else:
+                # Fallback: Try to extract content from different possible field names
+                doc_content = (
+                    doc_data.get("content") or 
+                    doc_data.get("text") or 
+                    doc_data.get("data")
+                )
+                
+                if doc_content:
+                    doc_name = doc_data.get("name", doc.id)
+                    content_parts.append(f"[From Firestore: {doc_name}]\n{doc_content}")
+        
+        return "\n\n".join(content_parts) if content_parts else None
+    
+    except Exception as e:
+        return f"Error reading from Firestore: {str(e)}"
+
+
+def _read_document_from_url(url: str, doc_name: str) -> Optional[str]:
+    """Download and read a document (DOCX or PDF) from a URL."""
+    try:
+        # Download the file from URL
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        
+        # Determine file type from URL
+        if url.lower().endswith('.docx') or 'docx' in url.lower():
+            # Read DOCX from bytes
+            doc = Document(io.BytesIO(response.content))
+            full_text = []
+            for paragraph in doc.paragraphs:
+                if paragraph.text.strip():
+                    full_text.append(paragraph.text)
+            return "\n".join(full_text)
+        
+        elif url.lower().endswith('.pdf') or 'pdf' in url.lower():
+            # Read PDF from bytes
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(response.content))
+            pdf_text = []
+            for page in pdf_reader.pages:
+                text = page.extract_text()
+                if text.strip():
+                    pdf_text.append(text)
+            return "\n".join(pdf_text)
+        
+        else:
+            return f"Unsupported file type for URL: {url}"
+    
+    except Exception as e:
+        raise Exception(f"Failed to download/read document from {url}: {str(e)}")
+
+
+@function_tool
+def list_available_documents() -> str:
+    """    
+    List all available documents from both local storage and Firestore.
+    
+    Returns:
+        A formatted list of available documents from all sources
+    """
+    logger.info("TOOL CALL: list_available_documents called")
+    
+    result = []
+    
+    # List local documents
+    root_dir = os.path.dirname(os.path.dirname(__file__))
+    local_docs = []
+    
+    if os.path.exists(os.path.join(root_dir, "data.docx")):
+        local_docs.append("- data.docx")
+    
+    for file in os.listdir(root_dir):
+        if file.endswith(".pdf"):
+            local_docs.append(f"- {file}")
+    
+    if local_docs:
+        result.append("=== Local Documents ===\n" + "\n".join(local_docs))
+    
+    # List Firestore documents
+    if db:
+        try:
+            docs_ref = db.collection("data")
+            docs = docs_ref.stream()
+            firestore_docs = [f"- {doc.id}" for doc in docs]
+            
+            if firestore_docs:
+                result.append("=== Firestore Documents ===\n" + "\n".join(firestore_docs))
+        except Exception as e:
+            result.append(f"Error listing Firestore documents: {str(e)}")
+    
+    response = "\n\n".join(result) if result else "No documents found in any source."
+    logger.info(f"TOOL RESULT: list_available_documents found {len(result)} source(s) with documents")
+    return response

tools/example_usage.py

@@ -0,0 +1,53 @@
+"""
+Example usage of the document reader tools with the agent.
+
+This file demonstrates how to integrate the document reading tools
+with your Innoscribe chatbot agent.
+"""
+
+from agents import Agent
+from config.chabot_config import model
+from instructions.chatbot_instructions import innscribe_dynamic_instructions
+from guardrails.guardrails_input_function import guardrail_input_function
+from tools.document_reader_tool import read_document_data, list_available_documents
+
+
+# Example 1: Agent with document reading capabilities
+innscribe_assistant_with_docs = Agent(
+    name="Innoscribe Assistant with Document Access",
+    instructions=innscribe_dynamic_instructions,
+    model=model,
+    input_guardrails=[guardrail_input_function],
+    tools=[read_document_data, list_available_documents]  # Add the document tools here
+)
+
+
+# Example 2: How the agent will use the tools
+"""
+When a user asks a question that requires information from documents:
+
+User: "What information do you have about our products?"
+
+The agent will automatically:
+1. Try to read from local data.docx and any PDF files first
+2. If not found or insufficient, try to read from Firebase Firestore
+3. Return the relevant information
+
+User: "List all available documents"
+The agent will use list_available_documents() to show all docs
+"""
+
+
+# Example 3: Manual tool usage (for testing)
+if __name__ == "__main__":
+    # Test reading documents
+    print("Testing document reader tool...")
+    result = read_document_data("company information", source="auto")
+    print(result)
+    
+    print("\n" + "="*50 + "\n")
+    
+    # Test listing documents
+    print("Testing list documents tool...")
+    docs = list_available_documents()
+    print(docs)

tools/firebase_config.py

@@ -0,0 +1,27 @@
+import os
+import firebase_admin
+from firebase_admin import credentials, firestore
+
+# Initialize Firebase Admin SDK
+def initialize_firebase():
+    """Initialize Firebase Admin SDK with service account credentials."""
+    # Get the path to serviceAccount.json in the root directory
+    service_account_path = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)), 
+        "serviceAccount.json"
+    )
+    
+    # Check if Firebase is already initialized
+    if not firebase_admin._apps:
+        cred = credentials.Certificate(service_account_path)
+        firebase_admin.initialize_app(cred)
+    
+    # Return Firestore client
+    return firestore.client()
+
+# Create a global Firestore client instance
+try:
+    db = initialize_firebase()
+except Exception as e:
+    print(f"Warning: Failed to initialize Firebase: {e}")
+    db = None