first commit

.gitignore

@@ -0,0 +1,4 @@
+.env
+ai-schedule
+flask_session
+credentials.json

DockerFile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["python", "app.py"]

all_tools.py

@@ -0,0 +1,1678 @@
+# import json
+# import os
+# import requests
+# import base64
+# import msal
+# import time
+# from typing import Type, Optional, List
+
+# from dotenv import load_dotenv
+# from pydantic.v1 import BaseModel, Field
+# from msal import ConfidentialClientApplication
+
+# from langchain_core.tools import BaseTool
+# from slack_sdk.errors import SlackApiError
+# from datetime import datetime
+# from google_auth_oauthlib.flow import InstalledAppFlow
+# from googleapiclient.discovery import build
+# from google.oauth2.credentials import Credentials
+# from google.auth.transport.requests import Request
+# from services import construct_google_calendar_client
+# from config import client
+# from datetime import datetime, timedelta
+# import pytz
+# from typing import List, Dict, Optional
+# from collections import defaultdict
+# from slack_sdk.errors import SlackApiError
+# from config import owner_id_pref, all_users_preload, GetAllUsers
+# load_dotenv()
+# calendar_service = None
+# MICROSOFT_CLIENT_SECRET = os.getenv("MICROSOFT_CLIENT_SECRET")
+# MICROSOFT_AUTHORITY = "https://login.microsoftonline.com/common"
+# MICROSOFT_SCOPES = ["User.Read", "Calendars.ReadWrite"]
+# MICROSOFT_REDIRECT_URI = os.getenv("MICROSOFT_REDIRECT_URI", "https://clear-muskox-grand.ngrok-free.app/microsoft_callback")
+# # Enhanced GetAllUsers function (not a tool) to fetch email as well
+# MICROSOFT_CLIENT_ID = "855e4571-d92a-4d51-802e-e712a879c00b"
+
+
+# # Pydantic models for tool arguments
+# class DirectDMArgs(BaseModel):
+#     message: str = Field(description="The message to be sent to the Slack user")
+#     user_id: str = Field(description="The Slack user ID")
+
+# class DateTimeTool(BaseTool):
+#     name: str = "current_date_time"
+#     description: str = "Provides the current date and time."
+
+#     def _run(self):
+#         return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+# # Tool to get a single user's Slack ID based on their name
+# class GetSingleUserSlackIDArgs(BaseModel):
+#     name: str = Field(description="The real name of the user whose Slack ID is needed")
+
+# class GetSingleUserSlackID(BaseTool):
+#     name: str = "gets_slack_id_single_user"
+#     description: str = "Gets the Slack ID of a user based on their real name"
+#     args_schema: Type[BaseModel] = GetSingleUserSlackIDArgs
+
+#     def _run(self, name: str):
+#         if not all_users_preload:
+#             print("Getting the users")
+#             all_users = GetAllUsers()  # Fetch all users again
+#         else:
+#             print("Fetching the users")
+#             all_users = all_users_preload
+
+#         # Iterate through all_users to find a matching name
+#         for uid, info in all_users.items():
+#             if info["name"].lower() == name.lower():
+#                 return uid, info['email']
+        
+#         return "User not found"
+
+# # Tool to get a single user's Slack name based on their ID
+# class GetSingleUserSlackNameArgs(BaseModel):
+#     id: str = Field(description="The Slack user ID")
+
+# class GetSingleUserSlackName(BaseTool):
+#     name: str = "gets_slack_name_single_user"
+#     description: str = "Gets the Slack real name of a user based on their slack ID"
+#     args_schema: Type[BaseModel] = GetSingleUserSlackNameArgs
+
+#     def _run(self, id: str):  
+
+#         # Check if preload returns empty dict or "User not found"
+#         if not all_users_preload or all_users_preload == {}:
+#             all_users = GetAllUsers()  # Fetch all users again
+#         else:
+#             all_users = all_users_preload
+
+#         user = all_users.get(id)
+#         print(all_users)
+        
+#         if user:
+#             return user["name"], user['email']
+        
+#         return "User not found"
+
+# class MultiDMArgs(BaseModel):
+#     message: str
+#     user_ids: List[str]
+
+# class MultiDirectDMTool(BaseTool):
+#     name: str = "send_multiple_dms"
+#     description: str = "Sends direct messages to multiple Slack users"
+#     args_schema: Type[BaseModel] = MultiDMArgs
+
+#     def _run(self, message: str, user_ids: List[str]):
+#         results = {}
+#         for user_id in user_ids:
+#             try:
+#                 client.chat_postMessage(channel=user_id, text=message)
+#                 results[user_id] = "Message sent successfully"
+#             except SlackApiError as e:
+#                 results[user_id] = f"Error: {e.response['error']}"
+#         return results
+# # Direct DM tool for sending messages within Slack
+# class DirectDMTool(BaseTool):
+#     name: str = "send_direct_dm"
+#     description: str = "Sends direct messages to Slack users"
+#     args_schema: Type[BaseModel] = DirectDMArgs
+
+#     def _run(self, message: str, user_id: str):
+#         try:
+#             client.chat_postMessage(channel=user_id, text=message)
+#             return "Message sent successfully"
+#         except SlackApiError as e:
+#             return f"Error sending message: {e.response['error']}"
+# def send_dm(user_id: str, message: str) -> bool:
+#     """Send a direct message to a user"""
+#     try:
+#         client.chat_postMessage(channel=user_id, text=message)
+#         return True
+#     except SlackApiError as e:
+#         print(f"Error sending DM: {e.response['error']}")
+#         return False
+
+# def handle_event_modification(event_id: str, action: str) -> str:
+#     """Handle event modification (update/delete)"""
+#     # You'll need to implement the actual modification logic
+#     if action == "delete":
+#         result = GoogleDeleteCalendarEvent().run(event_id=event_id)
+#     else:
+#         result = GoogleUpdateCalendarEvent().run(event_id=event_id)
+    
+#     if result.get("status") == "success":
+#         return f"Event {action}d successfully!"
+#     return f"Failed to {action} event: {result.get('message', 'Unknown error')}"
+# # Google Calendar Tools
+# PT = pytz.timezone('America/Los_Angeles')
+
+# def convert_to_pt(dt: datetime) -> datetime:
+#     """Convert a datetime object to PT timezone"""
+#     if dt.tzinfo is None:
+#         dt = pytz.utc.localize(dt)
+#     return dt.astimezone(PT)
+# class GoogleCalendarList(BaseTool):
+#     name: str = "list_calendar_list"
+#     description: str = "Lists available calendars in the user's Google Calendar account"
+    
+#     def _run(self, user_id: str, max_capacity: int = 200):
+#         if not calendar_service:
+#             calendar_service = construct_google_calendar_client(user_id)
+#         else:
+#             return "Token should be refreshed in Google Calendar"
+
+#         all_calendars = []
+#         next_page_token = None
+#         capacity_tracker = 0
+
+#         while capacity_tracker < max_capacity:
+#             results = calendar_service.calendarList().list(
+#                 maxResults=min(200, max_capacity - capacity_tracker),
+#                 pageToken=next_page_token
+#             ).execute()
+#             calendars = results.get('items', [])
+#             all_calendars.extend(calendars)
+#             capacity_tracker += len(calendars)
+#             next_page_token = results.get('nextPageToken')
+#             if not next_page_token:
+#                 break
+
+#         return [{
+#             'id': cal['id'],
+#             'name': cal['summary'],
+#             'description': cal.get('description', '')
+#         } for cal in all_calendars]
+
+# class GoogleCalendarEvents(BaseTool):
+#     name: str = "list_calendar_events"
+#     description: str = "Lists and gets events from a specific Google Calendar"
+    
+#     def _run(self, user_id: str, calendar_id: str = "primary", max_capacity: int = 20):
+        
+#         calendar_service = construct_google_calendar_client(user_id)
+
+#         all_events = []
+#         next_page_token = None
+#         capacity_tracker = 0
+
+#         while capacity_tracker < max_capacity:
+#             results = calendar_service.events().list(
+#                 calendarId=calendar_id,
+#                 maxResults=min(250, max_capacity - capacity_tracker),
+#                 pageToken=next_page_token
+#             ).execute()
+#             events = results.get('items', [])
+#             all_events.extend(events)
+#             capacity_tracker += len(events)
+#             next_page_token = results.get('nextPageToken')
+#             if not next_page_token:
+#                 break
+
+#         return all_events
+
+# class GoogleCreateCalendar(BaseTool):
+#     name: str = "create_calendar_list"
+#     description: str = "Creates a new calendar in Google Calendar"
+    
+#     def _run(self, user_id: str, calendar_name: str):
+        
+#         calendar_service = construct_google_calendar_client(user_id)
+
+#         calendar_body = {'summary': calendar_name}
+#         created_calendar = calendar_service.calendars().insert(body=calendar_body).execute()
+#         return f"Created calendar: {created_calendar['id']}"
+
+# # Updated Event Creation Tool with guest options, meeting agenda, and invite link support
+# class GoogleAddCalendarEventArgs(BaseModel):
+#     calendar_id: str = Field(default="primary", description="Calendar ID (default 'primary')")
+#     summary: str = Field(description="Event title (should include meeting agenda if needed)")
+#     user_id: str = Field(default="user", description="User slack Id which should be matched to name")
+#     description: str = Field(default="", description="Event description or agenda")
+#     start_time: str = Field(description="Start time in ISO 8601 format")
+#     end_time: str = Field(description="End time in ISO 8601 format")
+#     location: str = Field(default="", description="Event location")
+#     invite_link: str = Field(default="", description="Invite link for the meeting")
+#     guests: List[str] = Field(default=None, description="List of guest emails to invite")
+
+# class GoogleAddCalendarEvent(BaseTool):
+#     name: str = "google_add_calendar_event"
+#     description: str = "Creates an event in a Google Calendar with comprehensive meeting details and guest options"
+#     args_schema: Type[BaseModel] = GoogleAddCalendarEventArgs
+
+#     def _run(self, user_id: str, summary: str, start_time: str, end_time: str, 
+#              description: str = "", calendar_id: str = 'primary', location: str = "", 
+#              invite_link: str = "", guests: List[str] = None):
+#         calendar_service = construct_google_calendar_client(user_id)
+
+#         # Append invite link to description if provided
+#         if invite_link:
+#             description = f"{description}\nInvite Link: {invite_link}"
+        
+#         event = {
+#             'summary': summary,
+#             'description': description,
+#             'start': {'dateTime': start_time, 'timeZone': 'America/Los_Angeles'},
+#             'end': {'dateTime': end_time, 'timeZone': 'America/Los_Angeles'},
+#             'location': location,
+#         }
+
+#         # Add guests if provided
+#         if guests:
+#             event['attendees'] = [{'email': guest} for guest in guests]
+
+#         try:
+#             print("I am here registering the event")
+#             created_event = calendar_service.events().insert(
+#                 calendarId=calendar_id,
+#                 body=event,
+#                 sendUpdates='all'  # Send invitations to guests
+#             ).execute()
+#             return {
+#                 "status": "success",
+#                 "event_id": created_event['id'],
+#                 "link": created_event.get('htmlLink', '')
+#             }
+#         except Exception as e:
+#             return {"status": "error", "message": str(e)}
+
+# # Updated Tool: Update an existing calendar event including guest options
+# class GoogleUpdateCalendarEventArgs(BaseModel):
+#     calendar_id: str = Field(default="primary", description="Calendar ID (default 'primary')")
+#     user_id: str = Field(default="user", description="User slack Id which should be matched to name")
+#     event_id: str = Field(description="The event ID to update")
+#     summary: str = Field(default=None, description="Updated event title or agenda")
+#     description: Optional[str] = Field(default=None, description="Updated event description or agenda")
+#     start_time: Optional[str] = Field(default=None, description="Updated start time in ISO 8601 format")
+#     end_time: Optional[str] = Field(default=None, description="Updated end time in ISO 8601 format")
+#     location: Optional[str] = Field(default=None, description="Updated event location")
+#     invite_link: str = Field(default=None, description="Updated invite link for the meeting")
+#     guests: List[str] = Field(default=None, description="Updated list of guest emails")
+
+# class GoogleUpdateCalendarEvent(BaseTool):
+#     name: str = "google_update_calendar_event"
+#     description: str = "Updates an existing event in a Google Calendar, including guest options"
+#     args_schema: Type[BaseModel] = GoogleUpdateCalendarEventArgs
+
+#     def _run(self, user_id: str, event_id: str, calendar_id: str = "primary", 
+#              summary: Optional[str] = None, description: Optional[str] = None,
+#              start_time: Optional[str] = None, end_time: Optional[str] = None,
+#              location: Optional[str] = None, invite_link: Optional[str] = None,
+#              guests: Optional[List[str]] = None):
+        
+#         calendar_service = construct_google_calendar_client(user_id)
+        
+#         # Retrieve the existing event
+#         try:
+#             event = calendar_service.events().get(calendarId=calendar_id, eventId=event_id).execute()
+#         except Exception as e:
+#             return {"status": "error", "message": f"Event retrieval failed: {str(e)}"}
+
+#         # Update fields if provided
+#         if summary:
+#             event['summary'] = summary
+#         if description:
+#             event['description'] = description
+#         if invite_link:
+#             # Append invite link to the description
+#             current_desc = event.get('description', '')
+#             event['description'] = f"{current_desc}\nInvite Link: {invite_link}"
+#         if start_time:
+#             event['start'] = {'dateTime': start_time, 'timeZone': 'UTC'}
+#         if end_time:
+#             event['end'] = {'dateTime': end_time, 'timeZone': 'UTC'}
+#         if location:
+#             event['location'] = location
+#         if guests is not None:
+#             event['attendees'] = [{'email': guest} for guest in guests]
+
+#         try:
+#             updated_event = calendar_service.events().update(
+#                 calendarId=calendar_id,
+#                 eventId=event_id,
+#                 body=event
+#             ).execute()
+#             return {"status": "success", "event_id": updated_event['id']}
+#         except Exception as e:
+#             return {"status": "error", "message": f"Update failed: {str(e)}"}
+
+# # New Tool: Delete a calendar event
+# class GoogleDeleteCalendarEventArgs(BaseModel):
+#     calendar_id: str = Field(default="primary", description="Calendar ID (default 'primary')")
+#     event_id: str = Field(description="The event ID to delete")
+#     user_id: str = Field(default="user", description="User slack Id which should be matched to name")
+
+# class GoogleDeleteCalendarEvent(BaseTool):
+#     name: str = "google_delete_calendar_event"
+#     description: str = "Deletes an event from a Google Calendar"
+#     args_schema: Type[BaseModel] = GoogleDeleteCalendarEventArgs
+
+#     def _run(self, user_id: str, event_id: str, calendar_id: str = "primary"):
+        
+#         calendar_service = construct_google_calendar_client(user_id)
+#         try:
+#             calendar_service.events().delete(calendarId=calendar_id, eventId=event_id).execute()
+#             return {"status": "success", "message": f"Deleted event {event_id}"}
+#         except Exception as e:
+#             return {"status": "error", "message": f"Deletion failed: {str(e)}"}
+
+
+# # New Tool: Search Events by User
+# class SearchUserEventsArgs(BaseModel):
+#     user_id: str
+#     lookback_days: int = Field(default=30)
+# class SearchUserEventsTool(BaseTool):
+#     name: str = "search_events_by_user"
+#     description: str = "Finds calendar events associated with a specific user"
+#     args_schema: Type[BaseModel] = SearchUserEventsArgs
+
+#     def _run(self, user_id: str, lookback_days: int = 30):
+#         # Get user info which may be a tuple (name, email) or "User not found"
+#         user_info = GetSingleUserSlackName().run(user_id)
+        
+#         # Handle case where user is not found
+#         if user_info == "User not found":
+#             return []
+        
+#         # Extract user_name from tuple
+#         user_name, user_email = user_info
+        
+#         # Fetch events for the user
+#         events = GoogleCalendarEvents().run(user_id)
+        
+#         # Ensure 'now' is timezone-aware (using UTC)
+#         now = datetime.now(pytz.UTC)
+        
+#         relevant_events = []
+#         for event in events:
+#             # Ensure event_time is timezone-aware
+#             event_time_str = event['start'].get('dateTime')
+#             if not event_time_str:
+#                 continue  # Skip events without a valid start time
+            
+#             event_time = datetime.fromisoformat(event_time_str)
+#             if event_time.tzinfo is None:
+#                 # If event_time is naive, make it timezone-aware (assuming UTC)
+#                 event_time = pytz.UTC.localize(event_time)
+            
+#             # Check if the event is within the lookback period
+#             if (now - event_time).days > lookback_days:
+#                 continue
+            
+#             # Check if the user's name is in the event summary or description
+#             if user_name in event.get('summary', '') or user_name in event.get('description', ''):
+#                 relevant_events.append({
+#                     'id': event['id'],
+#                     'title': event['summary'],
+#                     'time': event_time.strftime("%Y-%m-%d %H:%M"),
+#                     'calendar_id': event['organizer']['email']
+#                 })
+        
+#         return relevant_events
+# # Enhanced Agent Logic
+# def handle_update_delete(user_id, text):
+#     events = SearchUserEventsTool().run(user_id)
+    
+#     if not events:
+#         return "No recent events found for you."
+        
+#     if len(events) > 1:
+#         options = [{"text": f"{e['title']} ({e['time']})", "value": e['id']} for e in events]
+#         return {
+#             "response_type": "ephemeral",
+#             "blocks": [{
+#                 "type": "section",
+#                 "text": {"type": "mrkdwn", "text": "Multiple events found:"},
+#                 "accessory": {
+#                     "type": "static_select",
+#                     "options": options,
+#                     "action_id": "select_event_to_modify"
+#                 }
+#             }]
+#         }
+    
+#     # If single event, proceed directly
+#     return handle_event_modification(events[0]['id'])
+
+
+# # State Management
+# from collections import defaultdict
+# meeting_coordination = defaultdict(dict)
+
+# class CreatePollArgs(BaseModel):
+#     time_slots: List[str]
+#     channel_id: str
+#     initiator_id: str
+
+# class CoordinateDMsArgs(BaseModel):
+#     user_ids: List[str]
+#     time_slots: List[str]
+# # Poll Creation Tool
+# class CoordinateDMsTool(BaseTool):
+#     name:str = "coordinate_dm_responses"
+#     description:str = "Manages DM responses for meeting coordination"
+#     args_schema: Type[BaseModel] = CoordinateDMsArgs
+#     def _run(self, user_ids: List[str], time_slots: List[str]) -> Dict:
+#         session_id = f"dm_coord_{datetime.now().timestamp()}"
+#         message = "Please choose a time slot by replying with the number:\n" + \
+#                  "\n".join([f"{i+1}. {slot}" for i, slot in enumerate(time_slots)])
+        
+#         for uid in user_ids:
+#             if not send_dm(uid, message):
+#                 return {"status": "error", "message": f"Failed to send DM to user {uid}"}
+        
+#         meeting_coordination[session_id] = {
+#             "responses": {},
+#             "required": len(user_ids),
+#             "slots": time_slots,
+#             "participants": user_ids,
+#             "created_at": datetime.now()
+#         }
+        
+#         return {
+#             "status": "success",
+#             "session_id": session_id,
+#             "message": "DMs sent to all participants"
+#         }
+
+# # Poll Management
+
+
+
+# # Zoom Meeting Tool
+# # class ZoomCreateMeetingArgs(BaseModel):
+# #     topic: str = Field(description="Meeting topic")
+# #     start_time: str = Field(description="Start time in ISO 8601 format and PT timezone")
+# #     duration: int = Field(description="Duration in minutes")
+# #     agenda: Optional[str] = Field(default="", description="Meeting agenda")
+# #     timezone: str = Field(default="UTC", description="Timezone for the meeting")
+
+# # class ZoomCreateMeetingTool(BaseTool):
+# #     name:str = "create_zoom_meeting"
+# #     description:str = "Creates a Zoom meeting using configured credentials"
+# #     args_schema: Type[BaseModel] = ZoomCreateMeetingArgs
+
+# #     def _run(self, topic: str, start_time: str, duration: int = 30, 
+# #             agenda: str = "", timezone: str = "UTC"):
+# #         # Get owner's credentials
+# #         owner_id = "owner_id_pref"
+# #         if not owner_id:
+# #             return "Workspace owner not found"
+            
+# #         prefs_path = os.path.join('preferences', f'preferences_{owner_id}.json')
+# #         if not os.path.exists(prefs_path):
+# #             return "Zoom credentials not configured"
+            
+# #         with open(prefs_path) as f:
+# #             prefs = json.load(f)
+            
+# #         if prefs['zoom_config']['mode'] == 'manual':
+# #             return {"link": prefs.get('zoom_link'), "message": "Using manual Zoom link"}
+            
+# #         # Automatic Zoom creation
+# #         auth_str = f"{prefs['zoom_config']['client_id']}:{prefs['zoom_config']['client_secret']}"
+# #         auth_bytes = base64.b64encode(auth_str.encode()).decode()
+        
+# #         headers = {
+# #             "Authorization": f"Basic {auth_bytes}",
+# #             "Content-Type": "application/x-www-form-urlencoded"
+# #         }
+        
+# #         data = {
+# #             "grant_type": "account_credentials",
+# #             "account_id": prefs['zoom_config']['account_id']
+# #         }
+        
+# #         # Get access token
+# #         token_res = requests.post(
+# #             "https://zoom.us/oauth/token", 
+# #             headers=headers, 
+# #             data=data
+# #         )
+        
+# #         if token_res.status_code != 200:
+# #             return "Zoom authentication failed"
+            
+# #         access_token = token_res.json()["access_token"]
+        
+# #         # Create meeting
+# #         meeting_data = {
+# #             "topic": topic,
+# #             "type": 2,
+# #             "start_time": start_time,
+# #             "duration": duration,
+# #             "timezone": timezone,
+# #             "agenda": agenda,
+# #             "settings": {
+# #                 "host_video": True,
+# #                 "participant_video": True,
+# #                 "join_before_host": False
+# #             }
+# #         }
+        
+# #         headers = {
+# #             "Authorization": f"Bearer {access_token}",
+# #             "Content-Type": "application/json"
+# #         }
+        
+# #         meeting_res = requests.post(
+# #             "https://api.zoom.us/v2/users/me/meetings",
+# #             headers=headers,
+# #             json=meeting_data
+# #         )
+        
+# #         if meeting_res.status_code == 201:
+# #             return {
+# #                 "meeting_id": meeting_res.json()["id"],
+# #                 "join_url": meeting_res.json()["join_url"],
+# #                 'passcode':meeting_res.json()["password"],
+# #                 'duration':duration
+# #             }
+# #         return f"Zoom meeting creation failed: {meeting_res.text}"
+# from langchain.tools import BaseTool
+# from pydantic import BaseModel, Field
+# from typing import Optional, Type
+# import os
+# import json
+# import time
+# import requests
+# import base64
+
+# class ZoomCreateMeetingArgs(BaseModel):
+#     topic: str = Field(description="Meeting topic")
+#     start_time: str = Field(description="Start time in ISO 8601 format and PT timezone")
+#     duration: int = Field(description="Duration in minutes")
+#     agenda: Optional[str] = Field(default="", description="Meeting agenda")
+#     timezone: str = Field(default="UTC", description="Timezone for the meeting")
+
+# from config import get_workspace_owner_id, load_preferences
+# import os
+# # ZOOM_REDIRECT_URI = os.environ['ZOOM_REDIRECT_URI']
+# CLIENT_SECRET = os.environ['ZOOM_CLIENT_SECRET']
+# CLIENT_ID = os.environ['ZOOM_CLIENT_ID']
+# ZOOM_TOKEN_API = os.environ['ZOOM_TOKEN_API']
+# # ZOOM_OAUTH_AUTHORIZE_API = os.environ['ZOOM_OAUTH_AUTHORIZE_API']
+# class ZoomCreateMeetingTool(BaseTool):
+#     name: str = "create_zoom_meeting"
+#     description: str = "Creates a Zoom meeting using configured credentials"
+#     args_schema: Type[BaseModel] = ZoomCreateMeetingArgs
+
+#     def _run(self, topic: str, start_time: str, duration: int = 30, 
+#          agenda: str = "", timezone: str = "UTC"):
+#     # Get workspace owner's ID
+#         owner_id = get_workspace_owner_id()
+#         if not owner_id:
+#             return "Workspace owner not found"
+
+#         # Load preferences to check Zoom mode
+#         prefs = load_preferences(owner_id)
+#         zoom_config = prefs.get("zoom_config", {"mode": "manual", "link": None})
+
+#         # Handle manual mode
+#         if zoom_config["mode"] == "manual":
+#             link = zoom_config.get("link")
+#             if link:
+#                 return f"Please join the meeting using this link: {link}"
+#             else:
+#                 return "Manual Zoom link not configured"
+
+#         # Automatic mode
+#         token_path = f'token_files/zoom_{owner_id}.json'
+#         if not os.path.exists(token_path):
+#             return "Zoom not configured for automatic mode"
+
+#         with open(token_path) as f:
+#             token_data = json.load(f)
+
+#         access_token = token_data.get("access_token")
+#         if not access_token:
+#             return "Invalid Zoom token"
+
+#         # Check if token is expired and refresh if necessary
+#         expires_at = token_data.get("expires_at")
+#         if expires_at and time.time() > expires_at:
+#             refresh_token = token_data.get("refresh_token")
+#             if not refresh_token:
+#                 return "Zoom token expired and no refresh token available"
+#             params = {
+#                 "grant_type": "refresh_token",
+#                 "refresh_token": refresh_token
+#             }
+#             auth_str = f"{CLIENT_ID}:{CLIENT_SECRET}"
+#             auth_bytes = base64.b64encode(auth_str.encode()).decode()
+#             headers = {
+#                 "Authorization": f"Basic {auth_bytes}",
+#                 "Content-Type": "application/x-www-form-urlencoded"
+#             }
+#             response = requests.post(ZOOM_TOKEN_API, data=params, headers=headers)
+#             if response.status_code == 200:
+#                 new_token_data = response.json()
+#                 token_data.update(new_token_data)
+#                 token_data["expires_at"] = time.time() + new_token_data["expires_in"]
+#                 with open(token_path, 'w') as f:
+#                     json.dump(token_data, f)
+#                 access_token = new_token_data["access_token"]
+#             else:
+#                 return "Failed to refresh Zoom token"
+
+#         # Create Zoom meeting
+#         meeting_data = {
+#             "topic": topic,
+#             "type": 2,  # Scheduled meeting
+#             "start_time": start_time,
+#             "duration": duration,
+#             "timezone": timezone,
+#             "agenda": agenda,
+#             "settings": {
+#                 "host_video": True,
+#                 "participant_video": True,
+#                 "join_before_host": False
+#             }
+#         }
+#         headers = {
+#             "Authorization": f"Bearer {access_token}",
+#             "Content-Type": "application/json"
+#         }
+#         meeting_res = requests.post(
+#             "https://api.zoom.us/v2/users/me/meetings",
+#             headers=headers,
+#             json=meeting_data
+#         )
+#         if meeting_res.status_code == 201:
+#             meeting_info = meeting_res.json()
+            
+#             # Extract meeting details
+#             meeting_id = meeting_info["id"]
+#             join_url = meeting_info["join_url"]
+#             password = meeting_info.get("password", "")
+#             dial_in_numbers = meeting_info["settings"].get("global_dial_in_numbers", [])
+#             print(meeting_info['settings'])
+#             print(dial_in_numbers)
+#             # Format one-tap mobile numbers (up to 2 US numbers)
+#             us_numbers = [num for num in dial_in_numbers if num["country"] == "US"]
+#             one_tap_strs = []
+#             for num in us_numbers[:2]:
+#                 clean_number = ''.join(num["number"].split())  # Remove spaces, e.g., "+1 305 224 1968" -> "+13052241968"
+#                 one_tap = f"{clean_number},,{meeting_id}#,,,,*{password}# US"
+#                 one_tap_strs.append(one_tap)
+
+#             # Format dial-in numbers
+#             dial_in_strs = []
+#             for num in dial_in_numbers:
+#                 country = num["country"]
+#                 city = num.get("city", "")
+#                 number = num["number"]
+#                 if city:
+#                     dial_in_strs.append(f"• {number} {country} ({city})")
+#                 else:
+#                     dial_in_strs.append(f"• {number} {country}")
+
+#             # Construct the invitation text
+#             invitation = "Citrusbug Technolabs is inviting you to a scheduled Zoom meeting.\n\n"
+#             invitation += f"Join Zoom Meeting\n{join_url}\n\n"
+#             invitation += f"Meeting ID: {meeting_id}\nPasscode: {password}\n\n"
+#             invitation += "---\n\n"
+#             if one_tap_strs:
+#                 invitation += "One tap mobile\n"
+#                 invitation += "\n".join(one_tap_strs) + "\n\n"
+#             invitation += "---\n\n"
+#             invitation += "Dial by your location\n"
+#             invitation += "\n".join(dial_in_strs) + "\n\n"
+#             invitation += f"Meeting ID: {meeting_id}\nPasscode: {password}\n"
+#             invitation += "Find your local number: https://zoom.us/zoomconference"
+
+#             return invitation
+#         else:
+#             return f"Zoom meeting creation failed: {meeting_res.text}"
+# class MicrosoftBaseTool(BaseTool):
+#     """Base class for Microsoft tools with common auth handling"""
+
+#     def get_microsoft_client(self, user_id: str):
+#         """Get authenticated Microsoft client for a user"""
+#         token_path = os.path.join('token_files', f'microsoft_{user_id}.json')
+#         if not os.path.exists(token_path):
+#             return None, "Microsoft credentials not configured"
+
+#         with open(token_path) as f:
+#             token_data = json.load(f)
+
+#         if time.time() > token_data['expires_at']:
+#             # Handle token refresh
+#             app = ConfidentialClientApplication(
+#                 MICROSOFT_CLIENT_ID,
+#                 authority=MICROSOFT_AUTHORITY,
+#                 client_credential=MICROSOFT_CLIENT_SECRET
+#             )
+#             result = app.acquire_token_by_refresh_token(
+#                 token_data['refresh_token'],
+#                 scopes=MICROSOFT_SCOPES
+#             )
+#             if "access_token" not in result:
+#                 return None, "Token refresh failed"
+
+#             token_data.update(result)
+#             with open(token_path, 'w') as f:
+#                 json.dump(token_data, f)
+
+#         headers = {
+#             "Authorization": f"Bearer {token_data['access_token']}",
+#             "Content-Type": "application/json"
+#         }
+#         return headers, None
+
+# # Pydantic models for Microsoft tools
+# class MicrosoftAddCalendarEventArgs(BaseModel):
+#     user_id: str = Field(description="Slack user ID of the calendar owner")
+#     subject: str = Field(description="Event title/subject")
+#     start_time: str = Field(description="Start time in ISO 8601 format")
+#     end_time: str = Field(description="End time in ISO 8601 format")
+#     content: str = Field(default="", description="Event description/content")
+#     location: str = Field(default="", description="Event location")
+#     attendees: List[str] = Field(default=[], description="List of attendee emails")
+
+# class MicrosoftUpdateCalendarEventArgs(MicrosoftAddCalendarEventArgs):
+#     event_id: str = Field(description="Microsoft event ID to update")
+
+# class MicrosoftDeleteCalendarEventArgs(BaseModel):
+#     user_id: str = Field(description="Slack user ID of the calendar owner")
+#     event_id: str = Field(description="Microsoft event ID to delete")
+
+# # Microsoft Calendar Tools
+# class MicrosoftListCalendarEvents(MicrosoftBaseTool):
+#     name:str = "microsoft_calendar_list_events"
+#     description:str = "Lists events from Microsoft Calendar"
+
+#     def _run(self, user_id: str, max_results: int = 10):
+#         headers, error = self.get_microsoft_client(user_id)
+#         if error:
+#             return error
+
+#         endpoint = "https://graph.microsoft.com/v1.0/me/events"
+#         params = {
+#             "$top": max_results,
+#             "$orderby": "start/dateTime desc"
+#         }
+
+#         response = requests.get(endpoint, headers=headers, params=params)
+#         if response.status_code != 200:
+#             return f"Error fetching events: {response.text}"
+
+#         events = response.json().get('value', [])
+#         return [{
+#             'id': e['id'],
+#             'subject': e.get('subject'),
+#             'start': e['start'].get('dateTime'),
+#             'end': e['end'].get('dateTime'),
+#             'webLink': e.get('webUrl')
+#         } for e in events]
+
+# class MicrosoftAddCalendarEvent(MicrosoftBaseTool):
+#     name:str = "microsoft_calendar_add_event"
+#     description:str = "Creates an event in Microsoft Calendar"
+#     args_schema: Type[BaseModel] = MicrosoftAddCalendarEventArgs
+
+#     def _run(self, user_id: str, subject: str, start_time: str, end_time: str,
+#              content: str = "", location: str = "", attendees: List[str] = []):
+#         headers, error = self.get_microsoft_client(user_id)
+#         if error:
+#             return error
+
+#         event_payload = {
+#             "subject": subject,
+#             "body": {
+#                 "contentType": "HTML",
+#                 "content": content
+#             },
+#             "start": {
+#                 "dateTime": start_time,
+#                 "timeZone": "America/Los_Angeles"
+#             },
+#             "end": {
+#                 "dateTime": end_time,
+#                 "timeZone": "America/Los_Angeles"
+#             },
+#             "location": {"displayName": location},
+#             "attendees": [{"emailAddress": {"address": email}} for email in attendees]
+#         }
+
+#         response = requests.post(
+#             "https://graph.microsoft.com/v1.0/me/events",
+#             headers=headers,
+#             json=event_payload
+#         )
+
+#         if response.status_code == 201:
+#             return {
+#                 "status": "success",
+#                 "event_id": response.json()['id'],
+#                 "link": response.json().get('webUrl')
+#             }
+#         return f"Error creating event: {response.text}"
+
+# class MicrosoftUpdateCalendarEvent(MicrosoftBaseTool):
+#     name:str = "microsoft_calendar_update_event"
+#     description:str = "Updates an existing Microsoft Calendar event"
+#     args_schema: Type[BaseModel] = MicrosoftUpdateCalendarEventArgs
+
+#     def _run(self, user_id: str, event_id: str, **kwargs):
+#         headers, error = self.get_microsoft_client(user_id)
+#         if error:
+#             return error
+
+#         get_response = requests.get(
+#             f"https://graph.microsoft.com/v1.0/me/events/{event_id}",
+#             headers=headers
+#         )
+#         if get_response.status_code != 200:
+#             return f"Error finding event: {get_response.text}"
+
+#         existing_event = get_response.json()
+
+#         update_payload = {
+#             "subject": kwargs.get('subject', existing_event.get('subject')),
+#             "body": {
+#                 "content": kwargs.get('content', existing_event.get('body', {}).get('content')),
+#                 "contentType": "HTML"
+#             },
+#             "start": {
+#                 "dateTime": kwargs.get('start_time', existing_event['start']['dateTime']),
+#                 "timeZone": "UTC"
+#             },
+#             "end": {
+#                 "dateTime": kwargs.get('end_time', existing_event['end']['dateTime']),
+#                 "timeZone": "UTC"
+#             },
+#             "location": {"displayName": kwargs.get('location', existing_event.get('location', {}).get('displayName'))},
+#             "attendees": [{"emailAddress": {"address": email}} for email in
+#                            kwargs.get('attendees', [a['emailAddress']['address'] for a in existing_event.get('attendees', [])])]
+#         }
+
+#         response = requests.patch(
+#             f"https://graph.microsoft.com/v1.0/me/events/{event_id}",
+#             headers=headers,
+#             json=update_payload
+#         )
+
+#         if response.status_code == 200:
+#             return {"status": "success", "event_id": event_id}
+#         return f"Error updating event: {response.text}"
+
+# class MicrosoftDeleteCalendarEvent(MicrosoftBaseTool):
+#     name:str = "microsoft_calendar_delete_event"
+#     description:str = "Deletes an event from Microsoft Calendar"
+#     args_schema: Type[BaseModel] = MicrosoftDeleteCalendarEventArgs
+
+#     def _run(self, user_id: str, event_id: str):
+#         headers, error = self.get_microsoft_client(user_id)
+#         if error:
+#             return error
+
+#         response = requests.delete(
+#             f"https://graph.microsoft.com/v1.0/me/events/{event_id}",
+#             headers=headers
+#         )
+
+#         if response.status_code == 204:
+#             return {"status": "success", "message": f"Deleted event {event_id}"}
+#         return f"Error deleting event: {response.text}"
+
+
+
+
+# tools = [
+#     DirectDMTool(),
+#     ZoomCreateMeetingTool(),
+#     # GetSingleUserSlackName(),
+#     # GetSingleUserSlackID(),
+# # CoordinateDMsTool(),
+#     SearchUserEventsTool(),
+#     # DateTimeTool(),
+#     GoogleCalendarList(),
+#     GoogleCalendarEvents(),
+#     GoogleCreateCalendar(),
+#     GoogleAddCalendarEvent(),
+#     GoogleUpdateCalendarEvent(),
+#     GoogleDeleteCalendarEvent(),
+#     # MicrosoftListCalendarEvents(),
+#     MicrosoftAddCalendarEvent(),
+#     MicrosoftUpdateCalendarEvent(),
+#     MicrosoftDeleteCalendarEvent(),
+#     MultiDirectDMTool()
+# ]
+# calendar_prompt_tools = [
+#   MicrosoftListCalendarEvents(), 
+#   GoogleCalendarEvents()
+
+# ]
+# dm_tools = [
+#     DirectDMTool(),
+#     ZoomCreateMeetingTool(),
+#     # CoordinateDMsTool(),
+#     SearchUserEventsTool(),
+#     GetSingleUserSlackName(),
+#     GetSingleUserSlackID(),
+#     # DateTimeTool(),
+#     GoogleCalendarList(),
+#     GoogleCalendarEvents(),
+#     GoogleCreateCalendar(),
+#     GoogleAddCalendarEvent(),
+#     GoogleUpdateCalendarEvent(),
+#     GoogleDeleteCalendarEvent(),
+#     MicrosoftListCalendarEvents(),
+#     MicrosoftAddCalendarEvent(),
+#     MicrosoftUpdateCalendarEvent(),
+#     MicrosoftDeleteCalendarEvent()
+# ]
+
+# dm_group_tools = [
+#     GoogleCalendarEvents(),
+#     MicrosoftListCalendarEvents(),
+#     DateTimeTool(),
+    
+# ]
+import json
+import os
+import requests
+import base64
+import msal
+import time
+from typing import Type, Optional, List
+
+from dotenv import load_dotenv
+from pydantic.v1 import BaseModel, Field
+from msal import ConfidentialClientApplication
+
+from langchain_core.tools import BaseTool
+from slack_sdk.errors import SlackApiError
+from datetime import datetime
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import build
+from google.oauth2.credentials import Credentials
+from google.auth.transport.requests import Request
+from config import client, get_workspace_owner_id, load_preferences, load_token, save_token
+from datetime import datetime, timedelta
+import pytz
+from collections import defaultdict
+from config import all_users_preload, GetAllUsers
+
+load_dotenv()
+
+# Load credentials from environment variables
+MICROSOFT_CLIENT_SECRET = os.getenv("MICROSOFT_CLIENT_SECRET")
+MICROSOFT_AUTHORITY = "https://login.microsoftonline.com/common"
+MICROSOFT_SCOPES = ["User.Read", "Calendars.ReadWrite"]
+MICROSOFT_REDIRECT_URI = os.getenv("MICROSOFT_REDIRECT_URI", "https://clear-muskox-grand.ngrok-free.app/microsoft_callback")
+MICROSOFT_CLIENT_ID = "855e4571-d92a-4d51-802e-e712a879c00b"
+ZOOM_CLIENT_SECRET = os.getenv("ZOOM_CLIENT_SECRET")
+ZOOM_CLIENT_ID = os.getenv("ZOOM_CLIENT_ID")
+ZOOM_TOKEN_API = os.getenv("ZOOM_TOKEN_API", "https://zoom.us/oauth/token")
+
+# Pydantic models for tool arguments
+class DirectDMArgs(BaseModel):
+    message: str = Field(description="The message to be sent to the Slack user")
+    user_id: str = Field(description="The Slack user ID")
+
+class DateTimeTool(BaseTool):
+    name: str = "current_date_time"
+    description: str = "Provides the current date and time."
+
+    def _run(self):
+        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+# Slack Tools
+class GetSingleUserSlackIDArgs(BaseModel):
+    name: str = Field(description="The real name of the user whose Slack ID is needed")
+
+class GetSingleUserSlackID(BaseTool):
+    name: str = "gets_slack_id_single_user"
+    description: str = "Gets the Slack ID of a user based on their real name"
+    args_schema: Type[BaseModel] = GetSingleUserSlackIDArgs
+
+    def _run(self, name: str):
+        if not all_users_preload:
+            all_users = GetAllUsers()
+        else:
+            all_users = all_users_preload
+
+        for uid, info in all_users.items():
+            if info["name"].lower() == name.lower():
+                return uid, info['email']
+        return "User not found"
+
+class GetSingleUserSlackNameArgs(BaseModel):
+    id: str = Field(description="The Slack user ID")
+
+class GetSingleUserSlackName(BaseTool):
+    name: str = "gets_slack_name_single_user"
+    description: str = "Gets the Slack real name of a user based on their Slack ID"
+    args_schema: Type[BaseModel] = GetSingleUserSlackNameArgs
+
+    def _run(self, id: str):
+        if not all_users_preload or all_users_preload == {}:
+            all_users = GetAllUsers()
+        else:
+            all_users = all_users_preload
+
+        user = all_users.get(id)
+        if user:
+            return user["name"], user['email']
+        return "User not found"
+
+class MultiDMArgs(BaseModel):
+    message: str
+    user_ids: List[str]
+
+class MultiDirectDMTool(BaseTool):
+    name: str = "send_multiple_dms"
+    description: str = "Sends direct messages to multiple Slack users"
+    args_schema: Type[BaseModel] = MultiDMArgs
+
+    def _run(self, message: str, user_ids: List[str]):
+        results = {}
+        for user_id in user_ids:
+            try:
+                client.chat_postMessage(channel=user_id, text=message)
+                results[user_id] = "Message sent successfully"
+            except SlackApiError as e:
+                results[user_id] = f"Error: {e.response['error']}"
+        return results
+
+class DirectDMTool(BaseTool):
+    name: str = "send_direct_dm"
+    description: str = "Sends direct messages to Slack users"
+    args_schema: Type[BaseModel] = DirectDMArgs
+
+    def _run(self, message: str, user_id: str):
+        try:
+            client.chat_postMessage(channel=user_id, text=message)
+            return "Message sent successfully"
+        except SlackApiError as e:
+            return f"Error sending message: {e.response['error']}"
+
+def send_dm(user_id: str, message: str) -> bool:
+    try:
+        client.chat_postMessage(channel=user_id, text=message)
+        return True
+    except SlackApiError as e:
+        print(f"Error sending DM: {e.response['error']}")
+        return False
+
+# Google Calendar Tools
+PT = pytz.timezone('America/Los_Angeles')
+
+def construct_google_calendar_client(team_id: str, user_id: str):
+    token_data = load_token(team_id, user_id, 'google')
+    if not token_data:
+        return None
+    creds = Credentials(
+        token=token_data.get('access_token'),
+        refresh_token=token_data.get('refresh_token'),
+        token_uri="https://oauth2.googleapis.com/token",
+        client_id=os.getenv("GOOGLE_CLIENT_ID"),
+        client_secret=os.getenv("GOOGLE_CLIENT_SECRET"),
+        scopes=["https://www.googleapis.com/auth/calendar"]
+    )
+    if creds.expired and creds.refresh_token:
+        creds.refresh(Request())
+        token_data.update({
+            "access_token": creds.token,
+            "refresh_token": creds.refresh_token,
+            "expires_at": creds.expiry.timestamp()
+        })
+        save_token(team_id, user_id, 'google', token_data)
+    return build('calendar', 'v3', credentials=creds)
+
+class GoogleCalendarList(BaseTool):
+    name: str = "list_calendar_list"
+    description: str = "Lists available calendars in the user's Google Calendar account"
+
+    def _run(self, team_id: str, user_id: str, max_capacity: int = 200):
+        calendar_service = construct_google_calendar_client(team_id, user_id)
+        if not calendar_service:
+            return "Google Calendar not configured or token invalid."
+
+        all_calendars = []
+        next_page_token = None
+        capacity_tracker = 0
+
+        while capacity_tracker < max_capacity:
+            results = calendar_service.calendarList().list(
+                maxResults=min(200, max_capacity - capacity_tracker),
+                pageToken=next_page_token
+            ).execute()
+            calendars = results.get('items', [])
+            all_calendars.extend(calendars)
+            capacity_tracker += len(calendars)
+            next_page_token = results.get('nextPageToken')
+            if not next_page_token:
+                break
+
+        return [{
+            'id': cal['id'],
+            'name': cal['summary'],
+            'description': cal.get('description', '')
+        } for cal in all_calendars]
+
+class GoogleCalendarEvents(BaseTool):
+    name: str = "list_calendar_events"
+    description: str = "Lists and gets events from a specific Google Calendar"
+
+    def _run(self, team_id: str, user_id: str, calendar_id: str = "primary", max_capacity: int = 20):
+        calendar_service = construct_google_calendar_client(team_id, user_id)
+        if not calendar_service:
+            return "Google Calendar not configured or token invalid."
+
+        all_events = []
+        next_page_token = None
+        capacity_tracker = 0
+
+        while capacity_tracker < max_capacity:
+            results = calendar_service.events().list(
+                calendarId=calendar_id,
+                maxResults=min(250, max_capacity - capacity_tracker),
+                pageToken=next_page_token
+            ).execute()
+            events = results.get('items', [])
+            all_events.extend(events)
+            capacity_tracker += len(events)
+            next_page_token = results.get('nextPageToken')
+            if not next_page_token:
+                break
+
+        return all_events
+
+class GoogleCreateCalendar(BaseTool):
+    name: str = "create_calendar_list"
+    description: str = "Creates a new calendar in Google Calendar"
+
+    def _run(self, team_id: str, user_id: str, calendar_name: str):
+        calendar_service = construct_google_calendar_client(team_id, user_id)
+        if not calendar_service:
+            return "Google Calendar not configured or token invalid."
+
+        calendar_body = {'summary': calendar_name}
+        created_calendar = calendar_service.calendars().insert(body=calendar_body).execute()
+        return f"Created calendar: {created_calendar['id']}"
+
+class GoogleAddCalendarEventArgs(BaseModel):
+    team_id: str = Field(description="Team id here")
+    user_id: str = Field(description="User id here")
+
+    calendar_id: str = Field(default="primary", description="Calendar ID (default 'primary')")
+    summary: str = Field(description="Event title")
+    description: str = Field(default="", description="Event description or agenda")
+    start_time: str = Field(description="Start time in ISO 8601 format")
+    end_time: str = Field(description="End time in ISO 8601 format")
+    location: str = Field(default="", description="Event location")
+    invite_link: str = Field(default="", description="Invite link for the meeting")
+    guests: List[str] = Field(default=None, description="List of guest emails to invite")
+
+class GoogleAddCalendarEvent(BaseTool):
+    name: str = "google_add_calendar_event"
+    description: str = "Creates an event in a Google Calendar"
+    args_schema: Type[BaseModel] = GoogleAddCalendarEventArgs
+
+    def _run(self, team_id: str, user_id: str, summary: str, start_time: str, end_time: str,
+             description: str = "", calendar_id: str = 'primary', location: str = "",
+             invite_link: str = "", guests: List[str] = None):
+        calendar_service = construct_google_calendar_client(team_id, user_id)
+        if not calendar_service:
+            return "Google Calendar not configured or token invalid."
+
+        if invite_link:
+            description = f"{description}\nInvite Link: {invite_link}"
+
+        event = {
+            'summary': summary,
+            'description': description,
+            'start': {'dateTime': start_time, 'timeZone': 'America/Los_Angeles'},
+            'end': {'dateTime': end_time, 'timeZone': 'America/Los_Angeles'},
+            'location': location,
+        }
+
+        if guests:
+            event['attendees'] = [{'email': guest} for guest in guests]
+
+        try:
+            created_event = calendar_service.events().insert(
+                calendarId=calendar_id,
+                body=event,
+                sendUpdates='all'
+            ).execute()
+            return {
+                "status": "success",
+                "event_id": created_event['id'],
+                "link": created_event.get('htmlLink', '')
+            }
+        except Exception as e:
+            return {"status": "error", "message": str(e)}
+
+class GoogleUpdateCalendarEventArgs(BaseModel):
+    team_id: str = Field(description="Team id here")
+    user_id: str = Field(description="User id here")
+    calendar_id: str = Field(default="primary", description="Calendar ID (default 'primary')")
+    event_id: str = Field(description="The event ID to update")
+    summary: str = Field(default=None, description="Updated event title")
+    description: Optional[str] = Field(default=None, description="Updated event description")
+    start_time: Optional[str] = Field(default=None, description="Updated start time in ISO 8601 format")
+    end_time: Optional[str] = Field(default=None, description="Updated end time in ISO 8601 format")
+    location: Optional[str] = Field(default=None, description="Updated event location")
+    invite_link: str = Field(default=None, description="Updated invite link")
+    guests: List[str] = Field(default=None, description="Updated list of guest emails")
+
+class GoogleUpdateCalendarEvent(BaseTool):
+    name: str = "google_update_calendar_event"
+    description: str = "Updates an existing event in a Google Calendar"
+    args_schema: Type[BaseModel] = GoogleUpdateCalendarEventArgs
+
+    def _run(self, team_id: str, user_id: str, event_id: str, calendar_id: str = "primary",
+             summary: Optional[str] = None, description: Optional[str] = None,
+             start_time: Optional[str] = None, end_time: Optional[str] = None,
+             location: Optional[str] = None, invite_link: Optional[str] = None,
+             guests: Optional[List[str]] = None):
+        calendar_service = construct_google_calendar_client(team_id, user_id)
+        if not calendar_service:
+            return "Google Calendar not configured or token invalid."
+
+        try:
+            event = calendar_service.events().get(calendarId=calendar_id, eventId=event_id).execute()
+        except Exception as e:
+            return {"status": "error", "message": f"Event retrieval failed: {str(e)}"}
+
+        if summary:
+            event['summary'] = summary
+        if description:
+            event['description'] = description
+        if invite_link:
+            current_desc = event.get('description', '')
+            event['description'] = f"{current_desc}\nInvite Link: {invite_link}"
+        if start_time:
+            event['start'] = {'dateTime': start_time, 'timeZone': 'America/Los_Angeles'}
+        if end_time:
+            event['end'] = {'dateTime': end_time, 'timeZone': 'America/Los_Angeles'}
+        if location:
+            event['location'] = location
+        if guests is not None:
+            event['attendees'] = [{'email': guest} for guest in guests]
+
+        try:
+            updated_event = calendar_service.events().update(
+                calendarId=calendar_id,
+                eventId=event_id,
+                body=event
+            ).execute()
+            return {"status": "success", "event_id": updated_event['id']}
+        except Exception as e:
+            return {"status": "error", "message": f"Update failed: {str(e)}"}
+
+class GoogleDeleteCalendarEventArgs(BaseModel):
+    team_id: str = Field(description="Team id here")
+    user_id: str = Field(description="User id here")
+    calendar_id: str = Field(default="primary", description="Calendar ID (default 'primary')")
+    event_id: str = Field(description="The event ID to delete")
+
+class GoogleDeleteCalendarEvent(BaseTool):
+    name: str = "google_delete_calendar_event"
+    description: str = "Deletes an event from a Google Calendar"
+    args_schema: Type[BaseModel] = GoogleDeleteCalendarEventArgs
+
+    def _run(self, team_id: str, user_id: str, event_id: str, calendar_id: str = "primary"):
+        calendar_service = construct_google_calendar_client(team_id, user_id)
+        if not calendar_service:
+            return "Google Calendar not configured or token invalid."
+        try:
+            calendar_service.events().delete(calendarId=calendar_id, eventId=event_id).execute()
+            return {"status": "success", "message": f"Deleted event {event_id}"}
+        except Exception as e:
+            return {"status": "error", "message": f"Deletion failed: {str(e)}"}
+
+# Search Events Tool
+class SearchUserEventsArgs(BaseModel):
+    user_id: str
+    lookback_days: int = Field(default=30)
+
+class SearchUserEventsTool(BaseTool):
+    name: str = "search_events_by_user"
+    description: str = "Finds calendar events associated with a specific user"
+    args_schema: Type[BaseModel] = SearchUserEventsArgs
+
+    def _run(self, team_id: str, user_id: str, lookback_days: int = 30):
+        user_info = GetSingleUserSlackName().run(user_id)
+        if user_info == "User not found":
+            return []
+
+        user_name, user_email = user_info
+        events = GoogleCalendarEvents().run(team_id, user_id)
+
+        now = datetime.now(pytz.UTC)
+        relevant_events = []
+        for event in events:
+            event_time_str = event['start'].get('dateTime')
+            if not event_time_str:
+                continue
+
+            event_time = datetime.fromisoformat(event_time_str)
+            if event_time.tzinfo is None:
+                event_time = pytz.UTC.localize(event_time)
+
+            if (now - event_time).days > lookback_days:
+                continue
+
+            if user_name in event.get('summary', '') or user_name in event.get('description', ''):
+                relevant_events.append({
+                    'id': event['id'],
+                    'title': event['summary'],
+                    'time': event_time.strftime("%Y-%m-%d %H:%M"),
+                    'calendar_id': event['organizer']['email']
+                })
+        return relevant_events
+
+# Zoom Meeting Tool
+class ZoomCreateMeetingArgs(BaseModel):
+    team_id:str = Field(description="Team Id here")
+    topic: str = Field(description="Meeting topic with all names not slack ids starting with U--")
+    start_time: str = Field(description="Start time in ISO 8601 format")
+    duration: int = Field(description="Duration in minutes")
+    agenda: Optional[str] = Field(default="", description="Meeting agenda")
+    timezone: str = Field(default="UTC", description="Timezone for the meeting")
+
+class ZoomCreateMeetingTool(BaseTool):
+    name: str = "create_zoom_meeting"
+    description: str = "Creates a Zoom meeting using configured credentials"
+    args_schema: Type[BaseModel] = ZoomCreateMeetingArgs
+
+    def _run(self, team_id: str, topic: str, start_time: str, duration: int = 30,
+             agenda: str = "", timezone: str = "UTC"):
+        owner_id = get_workspace_owner_id(client,team_id)
+        if not owner_id:
+            return "Workspace owner not found"
+
+        prefs = load_preferences(team_id, owner_id)
+        zoom_config = prefs.get("zoom_config", {"mode": "manual", "link": None})
+
+        if zoom_config["mode"] == "manual":
+            link = zoom_config.get("link")
+            if link:
+                return f"Please join the meeting using this link: {link}"
+            else:
+                return "Manual Zoom link not configured"
+
+        token_data = load_token(team_id, owner_id, 'zoom')
+        if not token_data:
+            return "Zoom token not found in database"
+
+        access_token = token_data.get("access_token")
+        if not access_token:
+            return "Invalid Zoom token"
+
+        expires_at = token_data.get("expires_at")
+        if expires_at and time.time() > expires_at:
+            refresh_token = token_data.get("refresh_token")
+            if not refresh_token:
+                return "Zoom token expired and no refresh token available"
+            params = {
+                "grant_type": "refresh_token",
+                "refresh_token": refresh_token
+            }
+            auth_str = f"{ZOOM_CLIENT_ID}:{ZOOM_CLIENT_SECRET}"
+            auth_bytes = base64.b64encode(auth_str.encode()).decode()
+            headers = {
+                "Authorization": f"Basic {auth_bytes}",
+                "Content-Type": "application/x-www-form-urlencoded"
+            }
+            response = requests.post(ZOOM_TOKEN_API, data=params, headers=headers)
+            if response.status_code == 200:
+                new_token_data = response.json()
+                token_data.update(new_token_data)
+                token_data["expires_at"] = time.time() + new_token_data["expires_in"]
+                save_token(team_id, owner_id, 'zoom', token_data)
+                access_token = new_token_data["access_token"]
+            else:
+                return "Failed to refresh Zoom token"
+
+        meeting_data = {
+            "topic": topic,
+            "type": 2,
+            "start_time": start_time,
+            "duration": duration,
+            "timezone": timezone,
+            "agenda": agenda,
+            "settings": {
+                "host_video": True,
+                "participant_video": True,
+                "join_before_host": False
+            }
+        }
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json"
+        }
+        meeting_res = requests.post(
+            "https://api.zoom.us/v2/users/me/meetings",
+            headers=headers,
+            json=meeting_data
+        )
+        if meeting_res.status_code == 201:
+            meeting_info = meeting_res.json()
+            invitation = f"Join Zoom Meeting\n{meeting_info['join_url']}\nMeeting ID: {meeting_info['id']}\nPasscode: {meeting_info.get('password', '')}"
+            return invitation
+        else:
+            return f"Zoom meeting creation failed: {meeting_res.text}"
+
+# Microsoft Calendar Tools
+class MicrosoftBaseTool(BaseTool):
+    def get_microsoft_client(self, team_id: str, user_id: str):
+        token_data = load_token(team_id, user_id, 'microsoft')
+        if not token_data:
+            return None, "Microsoft token not found in database"
+
+        if time.time() > token_data['expires_at']:
+            app = ConfidentialClientApplication(
+                MICROSOFT_CLIENT_ID,
+                authority=MICROSOFT_AUTHORITY,
+                client_credential=MICROSOFT_CLIENT_SECRET
+            )
+            result = app.acquire_token_by_refresh_token(
+                token_data['refresh_token'],
+                scopes=MICROSOFT_SCOPES
+            )
+            if "access_token" not in result:
+                return None, "Token refresh failed"
+            token_data.update(result)
+            save_token(team_id, user_id, 'microsoft', token_data)
+
+        headers = {
+            "Authorization": f"Bearer {token_data['access_token']}",
+            "Content-Type": "application/json"
+        }
+        return headers, None
+
+class MicrosoftListCalendarEvents(MicrosoftBaseTool):
+    name: str = "microsoft_calendar_list_events"
+    description: str = "Lists events from Microsoft Calendar"
+
+    def _run(self, team_id: str, user_id: str, max_results: int = 10):
+        headers, error = self.get_microsoft_client(team_id, user_id)
+        if error:
+            return error
+
+        endpoint = "https://graph.microsoft.com/v1.0/me/events"
+        params = {"$top": max_results, "$orderby": "start/dateTime desc"}
+        response = requests.get(endpoint, headers=headers, params=params)
+        if response.status_code != 200:
+            return f"Error fetching events: {response.text}"
+
+        events = response.json().get('value', [])
+        return [{
+            'id': e['id'],
+            'subject': e.get('subject'),
+            'start': e['start'].get('dateTime'),
+            'end': e['end'].get('dateTime'),
+            'webLink': e.get('webUrl')
+        } for e in events]
+
+class MicrosoftAddCalendarEventArgs(BaseModel):
+    team_id: str = Field(description="Team id here")
+    user_id: str = Field(description="User id here")
+    subject: str = Field(description="Event title/subject")
+    start_time: str = Field(description="Start time in ISO 8601 format")
+    end_time: str = Field(description="End time in ISO 8601 format")
+    content: str = Field(default="", description="Event description/content")
+    location: str = Field(default="", description="Event location")
+    attendees: List[str] = Field(default=[], description="List of attendee emails")
+
+class MicrosoftAddCalendarEvent(MicrosoftBaseTool):
+    name: str = "microsoft_calendar_add_event"
+    description: str = "Creates an event in Microsoft Calendar"
+    args_schema: Type[BaseModel] = MicrosoftAddCalendarEventArgs
+
+    def _run(self, team_id: str, user_id: str, subject: str, start_time: str, end_time: str,
+             content: str = "", location: str = "", attendees: List[str] = []):
+        headers, error = self.get_microsoft_client(team_id, user_id)
+        if error:
+            return error
+
+        event_payload = {
+            "subject": subject,
+            "body": {"contentType": "HTML", "content": content},
+            "start": {"dateTime": start_time, "timeZone": "America/Los_Angeles"},
+            "end": {"dateTime": end_time, "timeZone": "America/Los_Angeles"},
+            "location": {"displayName": location},
+            "attendees": [{"emailAddress": {"address": email}} for email in attendees]
+        }
+
+        response = requests.post(
+            "https://graph.microsoft.com/v1.0/me/events",
+            headers=headers,
+            json=event_payload
+        )
+        if response.status_code == 201:
+            return {
+                "status": "success",
+                "event_id": response.json()['id'],
+                "link": response.json().get('webUrl')
+            }
+        return f"Error creating event: {response.text}"
+
+class MicrosoftUpdateCalendarEventArgs(MicrosoftAddCalendarEventArgs):
+    team_id: str = Field(description="Team id here")
+    user_id: str = Field(description="User id here")
+    event_id: str = Field(description="Microsoft event ID to update")
+
+class MicrosoftUpdateCalendarEvent(MicrosoftBaseTool):
+    name: str = "microsoft_calendar_update_event"
+    description: str = "Updates an existing Microsoft Calendar event"
+    args_schema: Type[BaseModel] = MicrosoftUpdateCalendarEventArgs
+
+    def _run(self, team_id: str, user_id: str, event_id: str, **kwargs):
+        headers, error = self.get_microsoft_client(team_id, user_id)
+        if error:
+            return error
+
+        get_response = requests.get(
+            f"https://graph.microsoft.com/v1.0/me/events/{event_id}",
+            headers=headers
+        )
+        if get_response.status_code != 200:
+            return f"Error finding event: {get_response.text}"
+
+        existing_event = get_response.json()
+        update_payload = {
+            "subject": kwargs.get('subject', existing_event.get('subject')),
+            "body": {
+                "content": kwargs.get('content', existing_event.get('body', {}).get('content')),
+                "contentType": "HTML"
+            },
+            "start": {
+                "dateTime": kwargs.get('start_time', existing_event['start']['dateTime']),
+                "timeZone": "America/Los_Angeles"
+            },
+            "end": {
+                "dateTime": kwargs.get('end_time', existing_event['end']['dateTime']),
+                "timeZone": "America/Los_Angeles"
+            },
+            "location": {"displayName": kwargs.get('location', existing_event.get('location', {}).get('displayName'))},
+            "attendees": [{"emailAddress": {"address": email}} for email in
+                          kwargs.get('attendees', [a['emailAddress']['address'] for a in existing_event.get('attendees', [])])]
+        }
+
+        response = requests.patch(
+            f"https://graph.microsoft.com/v1.0/me/events/{event_id}",
+            headers=headers,
+            json=update_payload
+        )
+        if response.status_code == 200:
+            return {"status": "success", "event_id": event_id}
+        return f"Error updating event: {response.text}"
+
+class MicrosoftDeleteCalendarEventArgs(BaseModel):
+    team_id: str = Field(description="Team id here")
+    user_id: str = Field(description="User id here")
+    event_id: str = Field(description="Microsoft event ID to delete")
+
+class MicrosoftDeleteCalendarEvent(MicrosoftBaseTool):
+    name: str = "microsoft_calendar_delete_event"
+    description: str = "Deletes an event from Microsoft Calendar"
+    args_schema: Type[BaseModel] = MicrosoftDeleteCalendarEventArgs
+
+    def _run(self, team_id: str, user_id: str, event_id: str):
+        headers, error = self.get_microsoft_client(team_id, user_id)
+        if error:
+            return error
+
+        response = requests.delete(
+            f"https://graph.microsoft.com/v1.0/me/events/{event_id}",
+            headers=headers
+        )
+        if response.status_code == 204:
+            return {"status": "success", "message": f"Deleted event {event_id}"}
+        return f"Error deleting event: {response.text}"
+
+# Tool Lists
+tools = [
+    DirectDMTool(),
+    ZoomCreateMeetingTool(),
+    SearchUserEventsTool(),
+    GoogleCalendarList(),
+    GoogleCalendarEvents(),
+    GoogleCreateCalendar(),
+    GoogleAddCalendarEvent(),
+    GoogleUpdateCalendarEvent(),
+    GoogleDeleteCalendarEvent(),
+    MicrosoftListCalendarEvents(),
+    MicrosoftAddCalendarEvent(),
+    MicrosoftUpdateCalendarEvent(),
+    MicrosoftDeleteCalendarEvent(),
+    MultiDirectDMTool()
+]
+
+calendar_prompt_tools = [
+    MicrosoftListCalendarEvents(),
+    GoogleCalendarEvents()
+]
+
+dm_tools = [
+    DirectDMTool(),
+    ZoomCreateMeetingTool(),
+    SearchUserEventsTool(),
+    GetSingleUserSlackName(),
+    GetSingleUserSlackID(),
+    GoogleCalendarList(),
+    GoogleCalendarEvents(),
+    GoogleCreateCalendar(),
+    GoogleAddCalendarEvent(),
+    GoogleUpdateCalendarEvent(),
+    GoogleDeleteCalendarEvent(),
+    MicrosoftListCalendarEvents(),
+    MicrosoftAddCalendarEvent(),
+    MicrosoftUpdateCalendarEvent(),
+    MicrosoftDeleteCalendarEvent()
+]
+
+dm_group_tools = [
+    GoogleCalendarEvents(),
+    MicrosoftListCalendarEvents(),
+    DateTimeTool(),
+]

app.py

@@ -0,0 +1,1688 @@
+import os
+import secrets
+import time
+import json
+import base64
+from flask_talisman import Talisman
+from flask import Flask, request, jsonify,render_template
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+from slack_bolt import App
+from slack_bolt.adapter.flask import SlackRequestHandler
+from slack_bolt.oauth.oauth_settings import OAuthSettings
+from dotenv import find_dotenv, load_dotenv
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import Flow
+from googleapiclient.discovery import build
+from flask_session import Session
+from msal import ConfidentialClientApplication
+import psycopg2
+from apscheduler.schedulers.background import BackgroundScheduler
+from datetime import datetime, timedelta
+from collections import defaultdict
+import hashlib
+import re
+import logging
+from threading import Lock
+
+from urllib.parse import quote_plus
+from langchain.chains import LLMChain
+from langchain.prompts import ChatPromptTemplate
+from agents.all_agents import (
+    create_schedule_agent, create_update_agent, create_delete_agent, llm,
+    create_schedule_group_agent, create_update_group_agent, create_schedule_channel_agent
+)
+from all_tools import tools, calendar_prompt_tools
+from db import init_db
+
+# Load environment variables
+load_dotenv(find_dotenv())
+os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
+os.environ['OAUTHLIB_RELAX_TOKEN_SCOPE'] = '1'
+os.environ['OAUTHLIB_IGNORE_SCOPE_CHANGE'] = '1'
+
+
+user_cache = {}
+user_cache_lock = Lock()  # Example threading lock for cache
+preferences_cache = {}
+preferences_cache_lock = Lock()
+owner_id_cache = {}
+owner_id_lock = Lock()
+# Configuration
+SLACK_CLIENT_ID = os.getenv('SLACK_CLIENT_ID','')
+SLACK_CLIENT_SECRET = os.getenv('SLACK_CLIENT_SECRET','')
+SLACK_SIGNING_SECRET = os.getenv('SLACK_SIGNING_SECRET','')
+SLACK_SCOPES = [
+    "app_mentions:read",
+    "channels:history",
+    "chat:write",
+    "users:read",
+    "im:write",
+    "groups:write",
+    "mpim:write",
+    "commands",
+    "team:read",
+    "channels:read",
+    "groups:read",
+    "im:read",
+    "mpim:read",
+    "groups:history",
+    "im:history",
+    "mpim:history"
+]
+import requests
+SLACK_BOT_USER_ID = os.getenv("SLACK_BOT_USER_ID")
+ZOOM_REDIRECT_URI = "https://clear-muskox-grand.ngrok-free.app/zoom_callback"
+CLIENT_ID = "FiyFvBUSSeeXwjDv0tqg"  # Zoom Client ID
+CLIENT_SECRET = "tygAN91Xd7Wo1YAH056wtbrXQ8I6UieA"  # Zoom Client Secret
+ZOOM_TOKEN_API = "https://zoom.us/oauth/token"
+ZOOM_OAUTH_AUTHORIZE_API = os.getenv("ZOOM_OAUTH_AUTHORIZE_API", "https://zoom.us/oauth/authorize")
+OAUTH_REDIRECT_URI = os.getenv("OAUTH_REDIRECT_URI", "https://clear-muskox-grand.ngrok-free.app/oauth2callback")
+MICROSOFT_CLIENT_ID = "855e4571-d92a-4d51-802e-e712a879c00b"
+MICROSOFT_CLIENT_SECRET = os.getenv("MICROSOFT_CLIENT_SECRET")
+MICROSOFT_AUTHORITY = "https://login.microsoftonline.com/common"
+MICROSOFT_SCOPES = ["User.Read", "Calendars.ReadWrite"]
+MICROSOFT_REDIRECT_URI = os.getenv("MICROSOFT_REDIRECT_URI", "https://clear-muskox-grand.ngrok-free.app/microsoft_callback")
+
+# Initialize Flask app
+app = Flask(__name__)
+app.secret_key = secrets.token_hex(16)
+talisman = Talisman(
+    app,
+    content_security_policy={
+        'default-src': "'self'",
+        'script-src': "'self'",
+        'object-src': "'none'"
+    },
+    force_https=True,
+    strict_transport_security=True,
+    strict_transport_security_max_age=31536000,
+    x_content_type_options=True,
+    referrer_policy='no-referrer-when-downgrade'
+)
+app.config['SESSION_TYPE'] = 'filesystem'
+Session(app)
+
+# Installation Store for OAuth
+import json
+import os
+import psycopg2
+from datetime import datetime
+
+import json
+import os
+import psycopg2
+from datetime import datetime
+from slack_sdk.oauth import InstallationStore
+# Custom JSON encoder to handle datetime objects
+import json
+import os
+import psycopg2
+from psycopg2.extras import Json
+from datetime import datetime
+import logging
+from slack_sdk import WebClient
+from slack_sdk.oauth import InstallationStore
+from slack_sdk.oauth.installation_store.models.installation import Installation
+from slack_bolt.authorization import AuthorizeResult
+
+# Custom JSON encoder for datetime objects (used only if needed)
+class DateTimeEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        return super().default(obj)
+
+class DatabaseInstallationStore(InstallationStore):
+    """A database-backed installation store for Slack Bolt using PostgreSQL.
+    
+    Assumes 'installation_data' is a jsonb column storing JSON data.
+    """
+
+    def __init__(self):
+        self._logger = logging.getLogger(__name__)
+
+    def save(self, installation):
+        try:
+            conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+            cur = conn.cursor()
+            
+            workspace_id = installation.team_id
+            installed_at = datetime.fromtimestamp(installation.installed_at) if installation.installed_at else None
+            
+            installation_data = {
+                "team_id": installation.team_id,
+                "enterprise_id": installation.enterprise_id,
+                "user_id": installation.user_id,
+                "bot_token": installation.bot_token,
+                "bot_id": installation.bot_id,
+                "bot_user_id": installation.bot_user_id,
+                "bot_scopes": installation.bot_scopes,
+                "user_token": installation.user_token,
+                "user_scopes": installation.user_scopes,
+                "incoming_webhook_url": installation.incoming_webhook_url,
+                "incoming_webhook_channel": installation.incoming_webhook_channel,
+                "incoming_webhook_channel_id": installation.incoming_webhook_channel_id,
+                "incoming_webhook_configuration_url": installation.incoming_webhook_configuration_url,
+                "app_id": installation.app_id,
+                "token_type": installation.token_type,
+                "installed_at": installed_at.isoformat() if installed_at else None
+            }
+            
+            current_time = datetime.now()
+            
+            cur.execute('''
+                INSERT INTO Installations (workspace_id, installation_data, updated_at)
+                VALUES (%s, %s, %s)
+                ON CONFLICT (workspace_id) DO UPDATE SET
+                    installation_data = %s, updated_at = %s
+            ''', (workspace_id, Json(installation_data), current_time, Json(installation_data), current_time))
+            
+            conn.commit()
+            self._logger.info(f"Saved installation for workspace {workspace_id}")
+        
+        except Exception as e:
+            self._logger.error(f"Failed to save installation for workspace {workspace_id}: {e}")
+            raise
+        finally:
+            cur.close()
+            conn.close()
+
+    def find_installation(self, enterprise_id=None, team_id=None, user_id=None, is_enterprise_install=False):
+        if not team_id:
+            self._logger.warning("No team_id provided for find_installation")
+            return None
+        
+        try:
+            conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+            cur = conn.cursor()
+            cur.execute('SELECT installation_data FROM Installations WHERE workspace_id = %s', (team_id,))
+            row = cur.fetchone()
+            
+            if row:
+                # For jsonb, row[0] is already a dict
+                installation_data = row[0]
+                installed_at = (datetime.fromisoformat(installation_data["installed_at"])
+                                if installation_data.get("installed_at") else None)
+                
+                return Installation(
+                    app_id=installation_data["app_id"],
+                    enterprise_id=installation_data.get("enterprise_id"),
+                    team_id=installation_data["team_id"],
+                    bot_token=installation_data["bot_token"],
+                    bot_id=installation_data["bot_id"],
+                    bot_user_id=installation_data["bot_user_id"],
+                    bot_scopes=installation_data["bot_scopes"],
+                    user_id=installation_data["user_id"],
+                    user_token=installation_data.get("user_token"),
+                    user_scopes=installation_data.get("user_scopes"),
+                    incoming_webhook_url=installation_data.get("incoming_webhook_url"),
+                    incoming_webhook_channel=installation_data.get("incoming_webhook_channel"),
+                    incoming_webhook_channel_id=installation_data.get("incoming_webhook_channel_id"),
+                    incoming_webhook_configuration_url=installation_data.get("incoming_webhook_configuration_url"),
+                    token_type=installation_data["token_type"],
+                    installed_at=installed_at
+                )
+            else:
+                self._logger.info(f"No installation found for team_id {team_id}")
+                return None
+        
+        except Exception as e:
+            self._logger.error(f"Error retrieving installation for team_id {team_id}: {e}")
+            return None
+        finally:
+            cur.close()
+            conn.close()
+
+    def find_bot(self, enterprise_id=None, team_id=None, is_enterprise_install=False):
+        if not team_id:
+            self._logger.warning("No team_id provided for find_bot")
+            return None
+        
+        try:
+            conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+            cur = conn.cursor()
+            cur.execute('SELECT installation_data FROM Installations WHERE workspace_id = %s', (team_id,))
+            row = cur.fetchone()
+            
+            if row:
+                installation_data = row[0]
+                return AuthorizeResult(
+                    enterprise_id=installation_data.get("enterprise_id"),
+                    team_id=installation_data["team_id"],
+                    bot_token=installation_data["bot_token"],
+                    bot_id=installation_data["bot_id"],
+                    bot_user_id=installation_data["bot_user_id"]
+                )
+            else:
+                self._logger.info(f"No bot installation found for team_id {team_id}")
+                return None
+        
+        except Exception as e:
+            self._logger.error(f"Error retrieving bot for team_id {team_id}: {e}")
+            return None
+        finally:
+            cur.close()
+            conn.close()
+
+# Instantiate the store
+installation_store = DatabaseInstallationStore()
+
+def get_client_for_team(team_id):
+    """
+    Get a Slack WebClient for a given team ID using the stored bot token.
+
+    Args:
+        team_id (str): The team ID (workspace ID) to look up.
+
+    Returns:
+        WebClient: Slack client instance or None if not found.
+    """
+    installation = installation_store.find_installation(None, team_id)
+    if installation:
+        token = installation.bot_token  # Use dot notation instead of subscripting
+        return WebClient(token=token)
+    return None
+
+
+
+# Initialize Slack Bolt app with OAuth settings
+oauth_settings = OAuthSettings(
+    client_id=SLACK_CLIENT_ID,
+    client_secret=SLACK_CLIENT_SECRET,
+    scopes=SLACK_SCOPES,
+    redirect_uri="https://clear-muskox-grand.ngrok-free.app/slack/oauth_redirect",
+    installation_store=installation_store
+)
+bolt_app = App(signing_secret=SLACK_SIGNING_SECRET, oauth_settings=oauth_settings)
+slack_handler = SlackRequestHandler(bolt_app)
+
+# Logging setup
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Google Calendar API Scopes
+SCOPES = [
+    'https://www.googleapis.com/auth/calendar',
+    'https://www.googleapis.com/auth/calendar.readonly',
+    'https://www.googleapis.com/auth/userinfo.email',
+    'https://www.googleapis.com/auth/userinfo.profile'
+]
+
+# Initialize Neon Postgres database
+init_db()
+
+# State Management Classes
+class StateManager:
+    def __init__(self):
+        self._states = {}
+        self._lock = Lock()
+
+    def create_state(self, user_id):
+        with self._lock:
+            state_token = secrets.token_urlsafe(32)
+            self._states[state_token] = {"user_id": user_id, "timestamp": datetime.now(), "used": False}
+            return state_token
+
+    def validate_and_consume_state(self, state_token):
+        with self._lock:
+            if state_token not in self._states:
+                return None
+            state_data = self._states[state_token]
+            if state_data["used"] or (datetime.now() - state_data["timestamp"]).total_seconds() > 600:
+                del self._states[state_token]
+                return None
+            state_data["used"] = True
+            return state_data["user_id"]
+
+    def cleanup_expired_states(self):
+        with self._lock:
+            current_time = datetime.now()
+            expired = [s for s, d in self._states.items() if (current_time - d["timestamp"]).total_seconds() > 600]
+            for state in expired:
+                del self._states[state]
+
+state_manager = StateManager()
+
+class EventDeduplicator:
+    def __init__(self, expiration_minutes=5):
+        self.processed_events = defaultdict(list)
+        self.expiration_minutes = expiration_minutes
+
+    def clean_expired_events(self):
+        current_time = datetime.now()
+        for event_id in list(self.processed_events.keys()):
+            events = [(t, h) for t, h in self.processed_events[event_id]
+                      if current_time - t < timedelta(minutes=self.expiration_minutes)]
+            if events:
+                self.processed_events[event_id] = events
+            else:
+                del self.processed_events[event_id]
+
+    def is_duplicate_event(self, event_payload):
+        self.clean_expired_events()
+        event_id = event_payload.get('event_id', '')
+        payload_hash = hashlib.md5(str(event_payload).encode('utf-8')).hexdigest()
+        if 'challenge' in event_payload:
+            return False
+        if event_id in self.processed_events and payload_hash in [h for _, h in self.processed_events[event_id]]:
+            return True
+        self.processed_events[event_id].append((datetime.now(), payload_hash))
+        return False
+
+event_deduplicator = EventDeduplicator()
+
+class SessionStore:
+    def __init__(self):
+        self._store = {}
+        self._lock = Lock()
+
+    def set(self, user_id, key, value):
+        with self._lock:
+            if user_id not in self._store:
+                self._store[user_id] = {}
+            self._store[user_id][key] = {"value": value, "expires_at": datetime.now() + timedelta(hours=1)}
+
+    def get(self, user_id, key, default=None):
+        with self._lock:
+            if user_id not in self._store or key not in self._store[user_id]:
+                return default
+            session_data = self._store[user_id][key]
+            if datetime.now() > session_data["expires_at"]:
+                del self._store[user_id][key]
+                return default
+            return session_data["value"]
+
+    def clear(self, user_id, key):
+        with self._lock:
+            if user_id in self._store and key in self._store[user_id]:
+                del self._store[user_id][key]
+
+session_store = SessionStore()
+
+def store_in_session(user_id, key_type, data):
+    session_store.set(user_id, key_type, data)
+
+def get_from_session(user_id, key_type, default=None):
+    return session_store.get(user_id, key_type, default)
+
+# Global Caches (per workspace)
+user_cache = {}  # {team_id: {user_id: user_data}}
+user_cache_lock = Lock()
+
+owner_id_cache = {}  # {team_id: owner_id}
+owner_id_lock = Lock()
+
+preferences_cache = {}
+preferences_cache_lock = Lock()
+
+# Database Helper Functions
+def save_preference(team_id, user_id, zoom_config=None, calendar_tool=None):
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute('SELECT zoom_config, calendar_tool FROM Preferences WHERE team_id = %s AND user_id = %s', (team_id, user_id))
+    existing = cur.fetchone()
+    if existing:
+        current_zoom_config, current_calendar_tool = existing
+        new_zoom_config = zoom_config if zoom_config is not None else current_zoom_config
+        new_calendar_tool = calendar_tool if calendar_tool is not None else current_calendar_tool
+        cur.execute('''
+            UPDATE Preferences 
+            SET zoom_config = %s, calendar_tool = %s, updated_at = %s
+            WHERE team_id = %s AND user_id = %s
+        ''', (json.dumps(new_zoom_config) if new_zoom_config else None, 
+              new_calendar_tool, datetime.now(), team_id, user_id))
+    else:
+        new_zoom_config = zoom_config or {"mode": "manual", "link": None}
+        new_calendar_tool = calendar_tool or "google"
+        cur.execute('''
+            INSERT INTO Preferences (team_id, user_id, zoom_config, calendar_tool, updated_at)
+            VALUES (%s, %s, %s, %s, %s)
+        ''', (team_id, user_id, json.dumps(new_zoom_config), new_calendar_tool, datetime.now()))
+    conn.commit()
+    cur.close()
+    conn.close()
+    with preferences_cache_lock:
+        preferences_cache[(team_id, user_id)] = {"zoom_config": new_zoom_config, "calendar_tool": new_calendar_tool}
+
+def load_preferences(team_id, user_id):
+    with preferences_cache_lock:
+        if (team_id, user_id) in preferences_cache:
+            return preferences_cache[(team_id, user_id)]
+    try:
+        conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+        cur = conn.cursor()
+        cur.execute('SELECT zoom_config, calendar_tool FROM Preferences WHERE team_id = %s AND user_id = %s', (team_id, user_id))
+        row = cur.fetchone()
+        if row:
+            zoom_config, calendar_tool = row
+            # For jsonb, zoom_config is already a dict; no json.loads needed
+            preferences = {
+                "zoom_config": zoom_config if zoom_config else {"mode": "manual", "link": None},
+                "calendar_tool": calendar_tool or "none"
+            }
+        else:
+            preferences = {"zoom_config": {"mode": "manual", "link": None}, "calendar_tool": "none"}
+        cur.close()
+        conn.close()
+    except Exception as e:
+        logger.error(f"Failed to load preferences for team {team_id}, user {user_id}: {e}")
+        preferences = {"zoom_config": {"mode": "manual", "link": None}, "calendar_tool": "none"}
+    with preferences_cache_lock:
+        preferences_cache[(team_id, user_id)] = preferences
+    return preferences
+
+def save_token(team_id, user_id, service, token_data):
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute('''
+        INSERT INTO Tokens (team_id, user_id, service, token_data, updated_at)
+        VALUES (%s, %s, %s, %s, %s)
+        ON CONFLICT (team_id, user_id, service) DO UPDATE SET token_data = %s, updated_at = %s
+    ''', (team_id, user_id, service, json.dumps(token_data), datetime.now(), json.dumps(token_data), datetime.now()))
+    conn.commit()
+    cur.close()
+    conn.close()
+
+def load_token(team_id, user_id, service):
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute('SELECT token_data FROM Tokens WHERE team_id = %s AND user_id = %s AND service = %s', (team_id, user_id, service))
+    row = cur.fetchone()
+    cur.close()
+    conn.close()
+    return row[0] if row else None
+
+# Utility Functions
+def initialize_workspace_cache(client, team_id):
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute('SELECT MAX(last_updated) FROM Users WHERE team_id = %s', (team_id,))
+    last_updated_row = cur.fetchone()
+    last_updated = last_updated_row[0] if last_updated_row and last_updated_row[0] else None
+    
+    # Check if cache is fresh (e.g., less than 24 hours old)
+    if last_updated and (datetime.now() - last_updated).total_seconds() < 86400:
+        cur.execute('SELECT user_id, real_name, email, name, is_owner, workspace_name FROM Users WHERE team_id = %s', (team_id,))
+        rows = cur.fetchall()
+        new_cache = {row[0]: {"real_name": row[1], "email": row[2], "name": row[3], "is_owner": row[4], "workspace_name": row[5]} for row in rows}
+        with user_cache_lock:
+            user_cache[team_id] = new_cache
+        with owner_id_lock:
+            owner_id_cache[team_id] = next((user_id for user_id, data in new_cache.items() if data['is_owner']), None)
+    else:
+        # Fetch user data from Slack and update database
+        response = client.users_list()
+        users = response["members"]
+        workspace_name = client.team_info()["team"]["name"]  # Get workspace name from Slack API
+        new_cache = {}
+        for user in users:
+            user_id = user['id']
+            profile = user.get('profile', {})
+            real_name = profile.get('real_name', 'Unknown')
+            name = user.get('name', '')
+            email = f"{name}@gmail.com"  # Placeholder; adjust as needed
+            is_owner = user.get('is_owner', False)
+            new_cache[user_id] = {"real_name": real_name, "email": email, "name": name, "is_owner": is_owner, "workspace_name": workspace_name}
+            cur.execute('''
+                INSERT INTO Users (team_id, user_id, workspace_name, real_name, email, name, is_owner, last_updated)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+                ON CONFLICT (team_id, user_id) DO UPDATE SET
+                    workspace_name = %s, real_name = %s, email = %s, name = %s, is_owner = %s, last_updated = %s
+            ''', (team_id, user_id, workspace_name, real_name, email, name, is_owner, datetime.now(),
+                  workspace_name, real_name, email, name, is_owner, datetime.now()))
+        conn.commit()
+        with user_cache_lock:
+            user_cache[team_id] = new_cache
+        with owner_id_lock:
+            owner_id_cache[team_id] = next((user_id for user_id, data in new_cache.items() if data['is_owner']), None)
+    cur.close()
+    conn.close()
+
+def get_all_users(team_id):
+    with user_cache_lock:
+        if team_id in user_cache:
+            return {k: {"Slack Id": k, "real_name": v["real_name"], "email": v["email"], "name": v["name"]} 
+                    for k, v in user_cache[team_id].items()}
+    return {}
+
+def get_workspace_owner_id(client, team_id):
+    with owner_id_lock:
+        if team_id in owner_id_cache and owner_id_cache[team_id]:
+            return owner_id_cache[team_id]
+    initialize_workspace_cache(client, team_id)
+    with owner_id_lock:
+        return owner_id_cache.get(team_id)
+
+def get_channel_owner_id(client, channel_id):
+    try:
+        response = client.conversations_info(channel=channel_id)
+        return response["channel"].get("creator")
+    except SlackApiError as e:
+        logger.error(f"Error fetching channel info: {e.response['error']}")
+        return None
+
+def get_user_timezone(client, user_id):
+    try:
+        response = client.users_info(user=user_id)
+        return response["user"].get("tz", "UTC")
+    except SlackApiError as e:
+        logger.error(f"Timezone error: {e.response['error']}")
+        return "UTC"
+
+def get_team_id_from_owner_id(owner_id):
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute("SELECT workspace_id FROM Installations WHERE installation_data->>'user_id' = %s", (owner_id,))
+    row = cur.fetchone()
+    cur.close()
+    conn.close()
+    return row[0] if row else None
+
+# def get_client_for_team(team_id):
+#     installation = installation_store.find_installation(None, team_id)
+#     if installation:
+#         print(installation)
+#         token = installation['bot_token']
+#         return WebClient(token=token)
+#     return None
+
+def get_owner_selected_calendar(client, team_id):
+    owner_id = get_workspace_owner_id(client, team_id)
+    if not owner_id:
+        return None
+    # Fixed: Pass both team_id and owner_id to load_preferences
+    prefs = load_preferences(team_id, owner_id)
+    return prefs.get("calendar_tool", "none")
+
+def get_zoom_link(client, team_id):
+    owner_id = get_workspace_owner_id(client, team_id)
+    if not owner_id:
+        return None
+    prefs = load_preferences(team_id,owner_id)
+    return prefs.get('zoom_config', {}).get('link')
+
+def create_home_tab(client, team_id, user_id):
+    logger.info(f"Creating home tab for user {user_id}, team {team_id}")
+    
+    # Get workspace owner ID
+    workspace_owner_id = get_workspace_owner_id(client, team_id)
+    if not workspace_owner_id:
+        logger.warning(f"No workspace owner for team {team_id}")
+        blocks = [
+            {"type": "header", "text": {"type": "plain_text", "text": "🤖 Welcome to AI Assistant!", "emoji": True}},
+            {"type": "section", "text": {"type": "mrkdwn", "text": "Unable to determine workspace owner. Please contact support."}},
+        ]
+        return {"type": "home", "blocks": blocks}
+
+    # Determine if the user is the workspace owner
+    is_owner = user_id == workspace_owner_id
+
+    # Base blocks for all users
+    blocks = [
+        {"type": "header", "text": {"type": "plain_text", "text": "🤖 Welcome to AI Assistant!", "emoji": True}}
+    ]
+
+    # Non-owner view
+    if not is_owner:
+        blocks.extend([
+            {"type": "section", "text": {"type": "mrkdwn", "text": "I help manage schedules and meetings! Please wait for the workspace owner to configure the settings."}},
+            {"type": "section", "text": {"type": "mrkdwn", "text": "Only the workspace owner can configure the calendar and Zoom settings."}}
+        ])
+        return {"type": "home", "blocks": blocks}
+
+    # Owner view: Add configuration options
+    blocks.append({"type": "section", "text": {"type": "mrkdwn", "text": "I help manage schedules and meetings! Your settings are below."}})
+    blocks.append({"type": "divider"})
+
+    # Load preferences and tokens
+    prefs = load_preferences(team_id, workspace_owner_id)
+    selected_provider = prefs.get("calendar_tool", "none")
+    zoom_config = prefs.get("zoom_config", {"mode": "manual", "link": None})
+    mode = zoom_config["mode"]
+    calendar_token = load_token(team_id, workspace_owner_id, selected_provider) if selected_provider != "none" else None
+    zoom_token = load_token(team_id, workspace_owner_id, "zoom") if mode == "automatic" else None
+    logger.info(f"Preferences loaded: {prefs}, Calendar token: {calendar_token}, Zoom token: {zoom_token}")
+
+    # Check Zoom token expiration
+    zoom_token_expired = False
+    if zoom_token and mode == "automatic":
+        expires_at = zoom_token.get("expires_at", 0)
+        current_time = time.time()
+        zoom_token_expired = current_time >= expires_at
+
+    # Configuration status
+    calendar_provider_set = selected_provider != "none"
+    calendar_configured = calendar_token is not None if calendar_provider_set else False
+    zoom_configured = (zoom_token is not None and not zoom_token_expired) if mode == "automatic" else True
+
+    # Setup prompt if configurations are incomplete
+    if not calendar_provider_set or not calendar_configured or not zoom_configured:
+        prompt_text = "To start using the app, please complete the following setups:"
+        if not calendar_provider_set:
+            prompt_text += "\n- Select a calendar provider."
+        if calendar_provider_set and not calendar_configured:
+            prompt_text += f"\n- Configure your {selected_provider.capitalize()} calendar."
+        if mode == "automatic" and not zoom_configured:
+            if zoom_token_expired:
+                prompt_text += "\n- Your Zoom token has expired. Please refresh it."
+            else:
+                prompt_text += "\n- Authenticate with Zoom for automatic mode."
+        blocks.append({"type": "section", "text": {"type": "mrkdwn", "text": prompt_text}})
+
+    # Calendar Configuration Section
+    blocks.append({"type": "section", "text": {"type": "mrkdwn", "text": "*🗓️ Calendar Configuration*"}})
+    blocks.append({
+        "type": "section",
+        "block_id": "calendar_provider_block",
+        "text": {"type": "mrkdwn", "text": "Select your calendar provider:"},
+        "accessory": {
+            "type": "static_select",
+            "action_id": "calendar_provider_dropdown",
+            "placeholder": {"type": "plain_text", "text": "Select provider"},
+            "options": [
+                {"text": {"type": "plain_text", "text": "Select calendar"}, "value": "none"},
+                {"text": {"type": "plain_text", "text": "Google Calendar"}, "value": "google"},
+                {"text": {"type": "plain_text", "text": "Microsoft Calendar"}, "value": "microsoft"}
+            ],
+            "initial_option": {
+                "text": {"type": "plain_text", "text": "Select calendar" if selected_provider == "none" else
+                        "Google Calendar" if selected_provider == "google" else "Microsoft Calendar"},
+                "value": selected_provider
+            }
+        }
+    })
+
+    # Calendar configuration prompts
+    if selected_provider == "none":
+        blocks.append({"type": "context", "elements": [{"type": "mrkdwn", "text": "Please select a calendar provider to begin configuration."}]})
+    elif not calendar_configured:
+        blocks.append({"type": "context", "elements": [{"type": "mrkdwn", "text": f"Please configure your {selected_provider.capitalize()} calendar."}]})
+
+    # Calendar configure button and status
+    if selected_provider != "none":
+        status = "⚠️ Not Configured" if not calendar_configured else (
+            f":white_check_mark: Connected ({calendar_token.get('google_email', 'unknown')})" if selected_provider == "google" else (
+                f":white_check_mark: Connected (expires: {datetime.fromtimestamp(int(calendar_token.get('expires_at', 0))).strftime('%Y-%m-%d %H:%M')})" if calendar_token and calendar_token.get('expires_at') else ":white_check_mark: Connected"
+            )
+        )
+        blocks.extend([
+            {
+                "type": "actions",
+                "elements": [
+                    {
+                        "type": "button",
+                        "text": {
+                            "type": "plain_text",
+                            "text": f"✨ Configure {selected_provider.capitalize()}" if not calendar_configured else f"✅ Reconfigure {selected_provider.capitalize()}",
+                            "emoji": True
+                        },
+                        "action_id": "configure_gcal" if selected_provider == "google" else "configure_mscal"
+                    }
+                ]
+            },
+            {"type": "context", "elements": [{"type": "mrkdwn", "text": status}]}
+        ])
+
+    # Zoom Configuration Section
+    status = ("⌛ Token Expired" if zoom_token_expired else
+              "⚠️ Not Configured" if mode == "automatic" and not zoom_configured else
+              "✅ Configured")
+    blocks.extend([
+        {"type": "divider"},
+        {"type": "section", "text": {"type": "mrkdwn", "text": f"*🔗 Zoom Configuration*\nCurrent mode: {mode}\n{status}"}},
+        {
+            "type": "actions",
+            "elements": [
+                {"type": "button", "text": {"type": "plain_text", "text": "Configure Zoom Settings", "emoji": True}, "action_id": "open_zoom_config_modal"}
+            ]
+        }
+    ])
+
+    # Zoom authentication/refresh button
+    if mode == "automatic":
+        if not zoom_configured and not zoom_token_expired:
+            blocks[-1]["elements"].append({
+                "type": "button",
+                "text": {"type": "plain_text", "text": "Authenticate with Zoom", "emoji": True},
+                "action_id": "configure_zoom"
+            })
+        elif zoom_token_expired:
+            blocks[-1]["elements"].append({
+                "type": "button",
+                "text": {"type": "plain_text", "text": "Refresh Zoom Token", "emoji": True},
+                "action_id": "configure_zoom"  # Same action_id for refresh
+            })
+
+    return {"type": "home", "blocks": blocks}
+
+# Intent Classification
+intent_prompt = ChatPromptTemplate.from_template("""
+You are an intent classification assistant. Based on the user's message and the conversation history, determine the intent of the user's request. The possible intents are: "schedule meeting", "update event", "delete event", or "other". Provide only the intent as your response.
+- By looking at the history if someone is confirming or denying the schedule , also categorize it as a "schedule meeting"
+- If someone is asking about update the schedule then its "update event"
+- If someone is asking about delete the schedule then its "delete event"                                                 
+Conversation History:
+{history}
+
+User's Message:
+{input}
+""")
+from prompt import calender_prompt, general_prompt
+intent_chain = LLMChain(llm=llm, prompt=intent_prompt)
+
+mentioned_users_prompt = ChatPromptTemplate.from_template("""
+Given the following chat history, identify the Slack user IDs, Names and emails of the users who are mentioned. Mentions can be in the form of <@user_id> (e.g., <@U12345>) or by their names (e.g., "Alice" or "Alice Smith").
+- Do not give 'Bob'<@{bob_id}> in mentions
+- Exclude the {bob_id}.                                        
+# See the history if there is a request for new meeting or request for new schedule just ignore the mentions in the old messages and consider the new mentions in the new request.
+All users in the channel:
+{user_information}
+Format: Slack Id: U3234234 , Name: Alice , Email: alice@gmail.com (map slack ids to the names)
+Chat history:
+{chat_history}
+# Only output the users which are mentioned not all the users from the user-information.
+# Only see the latest message for mention information ignore previous ones.                                                        
+Please output the user slack IDs of the mentioned users , their names and emails . If no users are mentioned, output "None".
+CURRENT_INPUT: {current_input}                                                          
+Example: [[SlackId1 , Name1 , Email@gmal.com], [SlackId2, Name2, Email@gmail.com]...]
+""")
+mentioned_users_chain = LLMChain(llm=llm, prompt=mentioned_users_prompt)
+
+# Slack Event Handlers
+@bolt_app.event("app_home_opened")
+def handle_app_home_opened(event, client, context):
+    user_id = event.get("user")
+    team_id = context['team_id']
+    if not user_id:
+        return
+    try:
+        client.views_publish(user_id=user_id, view=create_home_tab(client, team_id, user_id))
+    except Exception as e:
+        logger.error(f"Error publishing home tab: {e}")
+
+@bolt_app.action("calendar_provider_dropdown")
+def handle_calendar_provider(ack, body, client, logger):
+    ack()
+    selected_provider = body["actions"][0]["selected_option"]["value"]
+    user_id = body["user"]["id"]
+    team_id = body["team"]["id"]
+    owner_id = get_workspace_owner_id(client, team_id)
+    
+    if user_id != owner_id:
+        client.chat_postMessage(channel=user_id, text="Only the workspace owner can configure the calendar.")
+        return
+    
+    # Corrected line: pass both team_id and owner_id (user_id) parameters
+    save_preference(team_id, owner_id, calendar_tool=selected_provider)
+    
+    client.views_publish(user_id=owner_id, view=create_home_tab(client, team_id, owner_id))
+    if selected_provider != "none":
+        client.chat_postMessage(channel=owner_id, text=f"Calendar provider updated to {selected_provider.capitalize()}.")
+    else:
+        client.chat_postMessage(channel=owner_id, text="Calendar provider reset.")
+    logger.info(f"Calendar provider updated to {selected_provider} for owner {owner_id}")
+
+@bolt_app.action("configure_gcal")
+def handle_gcal_config(ack, body, client, logger):
+    ack()
+    user_id = body["user"]["id"]
+    team_id = body["team"]["id"]
+    owner_id = get_workspace_owner_id(client, team_id)
+    if user_id != owner_id:
+        client.chat_postMessage(channel=user_id, text="Only the workspace owner can configure the calendar.")
+        return
+    
+    # Generate and store the state using StateManager
+    state = state_manager.create_state(owner_id)
+    print(f"state stored: {state}")
+    store_in_session(owner_id, "gcal_state", state)  # Optional: for additional validation
+    
+    # Set up the OAuth flow and pass the state
+    flow = Flow.from_client_secrets_file('credentials.json', scopes=SCOPES, redirect_uri=OAUTH_REDIRECT_URI)
+    auth_url, _ = flow.authorization_url(
+        access_type='offline',
+        prompt='consent',
+        include_granted_scopes='true',
+        state=state  # Use the state from StateManager
+    )
+    
+    # Open the modal with the auth URL
+    try:
+        client.views_open(
+            trigger_id=body["trigger_id"],
+            view={
+                "type": "modal",
+                "title": {"type": "plain_text", "text": "Google Calendar Auth"},
+                "close": {"type": "plain_text", "text": "Cancel"},
+                "blocks": [
+                    {"type": "section", "text": {"type": "mrkdwn", "text": "Click below to connect Google Calendar:"}},
+                    {"type": "actions", "elements": [{"type": "button", "text": {"type": "plain_text", "text": "Connect Google Calendar"}, "url": auth_url, "action_id": "launch_auth"}]}
+                ]
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error opening modal: {e}")
+
+@bolt_app.action("configure_mscal")
+def handle_mscal_config(ack, body, client, logger):
+    ack()
+    user_id = body["user"]["id"]
+    team_id = body["team"]["id"]
+    owner_id = get_workspace_owner_id(client, team_id)
+    if user_id != owner_id:
+        client.chat_postMessage(channel=user_id, text="Only the workspace owner can configure the calendar.")
+        return
+    msal_app = ConfidentialClientApplication(MICROSOFT_CLIENT_ID, authority=MICROSOFT_AUTHORITY, client_credential=MICROSOFT_CLIENT_SECRET)
+    state = state_manager.create_state(owner_id)
+    auth_url = msal_app.get_authorization_request_url(scopes=MICROSOFT_SCOPES, redirect_uri=MICROSOFT_REDIRECT_URI, state=state)
+    try:
+        client.views_open(
+            trigger_id=body["trigger_id"],
+            view={
+                "type": "modal",
+                "title": {"type": "plain_text", "text": "Microsoft Calendar Auth"},
+                "close": {"type": "plain_text", "text": "Close"},
+                "blocks": [
+                    {"type": "section", "text": {"type": "mrkdwn", "text": "Click below to authenticate with Microsoft:"}},
+                    {"type": "actions", "elements": [{"type": "button", "text": {"type": "plain_text", "text": "Connect Microsoft Calendar"}, "url": auth_url, "action_id": "ms_auth_button"}]}
+                ]
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error opening Microsoft auth modal: {e}")
+@bolt_app.event("app_mention")
+def handle_mentions(event, say, client, context):
+    if event_deduplicator.is_duplicate_event(event):
+        logger.info("Duplicate event detected, skipping processing")
+        return
+
+    # Ignore messages from bots
+    if event.get("bot_id"):
+        logger.info("Ignoring message from bot")
+        return
+
+    user_id = event.get("user")
+    channel_id = event.get("channel")
+    text = event.get("text", "").strip()
+    thread_ts = event.get("thread_ts")
+    team_id = context['team_id']
+    calendar_tool = get_owner_selected_calendar(client, team_id)
+    if not calendar_tool or calendar_tool == "none":
+        say("The workspace owner has not configured a calendar yet.", thread_ts=thread_ts)
+        return
+
+    # Fetch bot_user_id dynamically from installation
+    installation = installation_store.find_installation(team_id=team_id)
+    if not installation or not installation.bot_user_id:
+        logger.error(f"No bot_user_id found for team {team_id}")
+        say("Error: Could not determine bot user ID.", thread_ts=thread_ts)
+        return
+    print(f"App mention events")
+    
+    bot_user_id = installation.bot_user_id
+    print(f"Bot user id: {bot_user_id}")
+    mention = f"<@{bot_user_id}>"
+    mentions = list(set(re.findall(r'<@(\w+)>', text)))
+    if bot_user_id in mentions:
+        mentions.remove(bot_user_id)
+    text = text.replace(mention, "").strip()
+
+    workspace_owner_id = get_workspace_owner_id(client, team_id)
+    timezone = get_user_timezone(client, user_id)
+    zoom_link = get_zoom_link(client, team_id)
+    zoom_mode = load_preferences(team_id, workspace_owner_id).get("zoom_config", {}).get("mode", "manual")
+
+    channel_history = client.conversations_history(channel=channel_id, limit=2).get("messages", [])
+    channel_history = format_channel_history(channel_history)
+    intent = intent_chain.run({"history": channel_history, "input": text})
+
+    relevant_user_ids = get_relevant_user_ids(client, channel_id)
+    all_users = get_all_users(team_id)
+    relevant_users = {uid: all_users.get(uid, {"real_name": "Unknown", "email": "unknown@example.com", "name": "Unknown"})
+                      for uid in relevant_user_ids}
+    user_information = "\n".join([f"{uid}: Name={info['real_name']}, Email={info['email']}, Slack Name={info['name']}"
+                                  for uid, info in relevant_users.items() if uid != bot_user_id])
+
+    print(f"User Information: {user_information}\n\nRelevant Users: {relevant_user_ids}\n\n All users: {all_users}")
+    mentioned_users_output = mentioned_users_chain.run({"user_information": user_information, "chat_history": channel_history, "current_input": text, 'bob_id': bot_user_id})
+    
+    import pytz
+    pst = pytz.timezone('America/Los_Angeles')
+    current_time_pst = datetime.now(pst)
+    formatted_time = current_time_pst.strftime("%Y-%m-%d | %A | %I:%M %p | %Z")
+
+    from all_tools import GoogleCalendarEvents, MicrosoftListCalendarEvents
+    if calendar_tool == "google":
+        calendar_events = GoogleCalendarEvents()._run(team_id, workspace_owner_id)
+        schedule_tools = [tools[i] for i in [0, 1, 4, 6, 12]]
+        update_tools = [tools[i] for i in [0, 7, 12]]
+        delete_tools = [tools[i] for i in [0, 8, 12]]
+    elif calendar_tool == "microsoft":
+        calendar_events = MicrosoftListCalendarEvents()._run(team_id, workspace_owner_id)
+        schedule_tools = [tools[i] for i in [0, 1, 9, 12]]
+        update_tools = [tools[i] for i in [0, 10, 12]]
+        delete_tools = [tools[i] for i in [0, 11, 12]]
+    else:
+        say("Invalid calendar tool configured.", thread_ts=thread_ts)
+        return
+
+    calendar_formatting_chain = LLMChain(llm=llm, prompt=calender_prompt)
+    output = calendar_formatting_chain.run({'input': calendar_events, 'admin_id': workspace_owner_id, 'date_time': formatted_time})
+    print(f"MENTIONED USERS:{mentioned_users_output}")
+
+    agent_input = {
+        'input': f"Here is the input by user: {text} and do not mention <@{bot_user_id}> even tho mentioned in history",
+        'event_details': str(event),
+        'target_user_id': user_id,
+        'timezone': timezone,
+        'user_id': user_id,
+        'admin': workspace_owner_id,
+        'zoom_link': zoom_link,
+        'zoom_mode': zoom_mode,
+        'channel_history': channel_history,
+        'user_information': user_information,
+        'calendar_tool': calendar_tool,
+        'date_time': formatted_time,
+        'formatted_calendar': output,
+        'team_id': team_id
+    }
+
+    mentions = list(set(re.findall(r'<@(\w+)>', text)))
+    if bot_user_id in mentions:
+        mentions.remove(bot_user_id)
+
+    schedule_group_exec = create_schedule_channel_agent(schedule_tools)
+    update_group_exec = create_update_group_agent(update_tools)
+    delete_exec = create_delete_agent(delete_tools)
+
+    if intent == "schedule meeting":
+        group_agent_input = agent_input.copy()
+        group_agent_input['mentioned_users'] = mentioned_users_output
+        response = schedule_group_exec.invoke(group_agent_input)
+        say(response['output'])
+        return
+    elif intent == "update event":
+        group_agent_input = agent_input.copy()
+        group_agent_input['mentioned_users'] = mentioned_users_output
+        response = update_group_exec.invoke(group_agent_input)
+        say(response['output'])
+        return
+    elif intent == "delete event":
+        response = delete_exec.invoke(agent_input)
+        say(response['output'])
+        return
+    elif intent == "other":
+        response = llm.predict(general_prompt.format(input=text, channel_history=channel_history))
+        say(response)
+        return
+    else:
+        say("I'm not sure how to handle that request.")
+# @bolt_app.event("app_mention")
+# def handle_mentions(event, say, client, context):
+#     if event_deduplicator.is_duplicate_event(event):
+#         logger.info("Duplicate event detected, skipping processing")
+#         return
+
+#     # Ignore messages from bots
+#     if event.get("bot_id"):
+#         logger.info("Ignoring message from bot")
+#         return
+
+
+#     user_id = event.get("user")
+#     channel_id = event.get("channel")
+#     text = event.get("text", "").strip()
+#     thread_ts = event.get("thread_ts")
+#     team_id = context['team_id']
+#     calendar_tool = get_owner_selected_calendar(client, team_id)
+#     if not calendar_tool or calendar_tool == "none":
+#         say("The workspace owner has not configured a calendar yet.", thread_ts=thread_ts)
+#         return
+
+#     # Fetch bot_user_id dynamically from installation
+#     installation = installation_store.find_installation(team_id=team_id)
+#     if not installation or not installation.bot_user_id:
+#         logger.error(f"No bot_user_id found for team {team_id}")
+#         say("Error: Could not determine bot user ID.", thread_ts=thread_ts)
+#         return
+#     print(f"App mention events")
+    
+#     bot_user_id = installation.bot_user_id
+#     print(f"Bot user id: {bot_user_id}")
+#     mention = f"<@{bot_user_id}>"
+#     mentions = list(set(re.findall(r'<@(\w+)>', text)))
+#     # Use dynamic bot_user_id instead of SLACK_BOT_USER_ID
+#     if bot_user_id in mentions:
+#         mentions.remove(bot_user_id)
+#     text = text.replace(mention, "").strip()
+
+#     workspace_owner_id = get_workspace_owner_id(client, team_id)
+#     timezone = get_user_timezone(client, user_id)
+#     zoom_link = get_zoom_link(client, team_id)
+#     zoom_mode = load_preferences(team_id, workspace_owner_id).get("zoom_config", {}).get("mode", "manual")
+
+#     channel_history = client.conversations_history(channel=channel_id, limit=2).get("messages", [])
+#     channel_history = format_channel_history(channel_history)
+#     intent = intent_chain.run({"history": channel_history, "input": text})
+
+#     relevant_user_ids = get_relevant_user_ids(client, channel_id)
+#     all_users = get_all_users(team_id)
+#     relevant_users = {uid: all_users.get(uid, {"real_name": "Unknown", "email": "unknown@example.com", "name": "Unknown"})
+#                       for uid in relevant_user_ids}
+#     user_information = "\n".join([f"{uid}: Name={info['real_name']}, Email={info['email']}, Slack Name={info['name']}"
+#                               for uid, info in relevant_users.items() if uid != bot_user_id])
+
+#     print(f"User Information: {user_information}\n\nRelevant Users: {relevant_user_ids}\n\n All users: {all_users}")
+#     mentioned_users_output = mentioned_users_chain.run({"user_information": user_information, "chat_history": channel_history,"current_input":text, 'bob_id':bot_user_id})
+
+#     import pytz
+#     pst = pytz.timezone('America/Los_Angeles')
+#     current_time_pst = datetime.now(pst)
+#     formatted_time = current_time_pst.strftime("%Y-%m-%d | %A | %I:%M %p | %Z")
+
+#     from all_tools import GoogleCalendarEvents, MicrosoftListCalendarEvents
+#     if calendar_tool == "google":
+#         calendar_events = GoogleCalendarEvents()._run(team_id, workspace_owner_id)
+#         schedule_tools = [tools[i] for i in [0, 1, 4, 6, 12]]
+#         update_tools = [tools[i] for i in [0, 7, 12]]
+#         delete_tools = [tools[i] for i in [0, 8, 12]]
+#     elif calendar_tool == "microsoft":
+#         calendar_events = MicrosoftListCalendarEvents()._run(team_id, workspace_owner_id)
+#         schedule_tools = [tools[i] for i in [0, 1, 9, 12]]
+#         update_tools = [tools[i] for i in [0, 10, 12]]
+#         delete_tools = [tools[i] for i in [0, 11, 12]]
+#     else:
+#         say("Invalid calendar tool configured.", thread_ts=thread_ts)
+#         return
+
+#     calendar_formatting_chain = LLMChain(llm=llm, prompt=calender_prompt)
+#     output = calendar_formatting_chain.run({'input': calendar_events, 'admin_id': workspace_owner_id, 'date_time': formatted_time})
+#     print(f"MENTIONED USERS:{mentioned_users_output}")
+
+#     agent_input = {
+#     'input': text,
+#     'event_details': str(event),
+#     'target_user_id': user_id,
+#     'timezone': timezone,
+#     'user_id': user_id,
+#     'admin': workspace_owner_id,
+#     'zoom_link': zoom_link,
+#     'zoom_mode': zoom_mode,
+#     'channel_history': channel_history,
+#     'user_information': mentioned_users_output,
+#     'calendar_tool': calendar_tool,
+#     'date_time': formatted_time,
+#     'formatted_calendar': output,
+#     'team_id': team_id  # Added
+# }
+
+#     mentions = list(set(re.findall(r'<@(\w+)>', text)))
+#     if bot_user_id in mentions:
+#         mentions.remove(bot_user_id)
+
+#     schedule_group_exec = create_schedule_channel_agent(schedule_tools)
+#     update_group_exec = create_update_group_agent(update_tools)
+#     delete_exec = create_delete_agent(delete_tools)
+
+#     if intent == "schedule meeting":
+#         group_agent_input = agent_input.copy()
+#         group_agent_input['mentioned_users'] = "See from the history except 'Bob'"
+#         response = schedule_group_exec.invoke(group_agent_input)
+#         say(response['output'])
+#         return
+#     elif intent == "update event":
+#         group_agent_input = agent_input.copy()
+#         group_agent_input['mentioned_users'] = "See from the history except 'Bob'"
+#         response = update_group_exec.invoke(group_agent_input)
+#         say(response['output'])
+#         return
+#     elif intent == "delete event":
+#         response = delete_exec.invoke(agent_input)
+#         say(response['output'])
+#         return
+#     elif intent == "other":
+#         response = llm.predict(general_prompt.format(input=text, channel_history=channel_history))
+#         say(response)
+#         return
+#     else:
+#         say("I'm not sure how to handle that request.")
+
+def format_channel_history(raw_history):
+    cleaned_history = []
+    for msg in raw_history:
+        if 'bot_id' in msg and 'Calendar provider updated' in msg.get('text', ''):
+            continue
+        sender = msg.get('user', 'Unknown') if 'bot_id' not in msg else msg.get('bot_profile', {}).get('name', 'Bot')
+        message_text = msg.get('text', '').strip()
+        timestamp = float(msg.get('ts', 0))
+        readable_time = datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %I:%M %p')
+        user_id = msg.get('user', 'N/A')
+        team_id = msg.get('team', 'N/A')
+        cleaned_history.append({
+            'message': message_text,
+            'from': sender,
+            'timestamp': readable_time,
+            'user_team': f"{user_id}/{team_id}"
+        })
+    formatted_output = ""
+    for i, entry in enumerate(cleaned_history, 1):
+        formatted_output += f"Message {i}: {entry['message']}\nFrom: {entry['from']}\nTimestamp: {entry['timestamp']}\nUserId/TeamId: {entry['user_team']}\n\n"
+    return formatted_output.strip()
+
+def get_relevant_user_ids(client, channel_id):
+    try:
+        members = []
+        cursor = None
+        while True:
+            response = client.conversations_members(channel=channel_id, limit=10, cursor=cursor)
+            if not response["ok"]:
+                logger.error(f"Failed to get members for channel {channel_id}: {response['error']}")
+                break
+            members.extend(response["members"])
+            cursor = response.get("response_metadata", {}).get("next_cursor")
+            if not cursor:
+                break
+        return members
+    except SlackApiError as e:
+        logger.error(f"Error getting conversation members: {e}")
+        return []
+
+calendar_formatting_chain = LLMChain(llm=llm, prompt=calender_prompt)
+
+@bolt_app.event("message")
+def handle_messages(body, say, client, context):
+    if event_deduplicator.is_duplicate_event(body):
+        logger.info("Duplicate event detected, skipping processing")
+        return
+    event = body.get("event", {})
+    if event.get("bot_id"):
+        logger.info("Ignoring message from bot")
+        return
+
+    user_id = event.get("user")
+    text = event.get("text", "").strip()
+    channel_id = event.get("channel")
+    thread_ts = event.get("thread_ts")
+    team_id = context['team_id']
+    calendar_tool = get_owner_selected_calendar(client, team_id)
+    channel_info = client.conversations_info(channel=channel_id)
+    channel = channel_info["channel"]
+
+    # Fetch bot_user_id dynamically from installation
+    installation = installation_store.find_installation(team_id=team_id)
+    if not installation or not installation.bot_user_id:
+        logger.error(f"No bot_user_id found for team {team_id}")
+        say("Error: Could not determine bot user ID.", thread_ts=thread_ts)
+        return
+    bot_user_id = installation.bot_user_id
+
+    if not channel.get("is_im") and f"<@{bot_user_id}>" in text:
+        return
+    if not channel.get("is_im") and "thread_ts" not in event:
+        return
+    if not calendar_tool or calendar_tool == "none":
+        say("The workspace owner has not configured a calendar yet.", thread_ts=thread_ts)
+        return
+    print(f"Message events")
+    workspace_owner_id = get_workspace_owner_id(client, team_id)
+    is_owner = user_id == workspace_owner_id
+    timezone = get_user_timezone(client, user_id)
+    zoom_link = get_zoom_link(client, team_id)
+    zoom_mode = load_preferences(team_id, workspace_owner_id).get("zoom_config", {}).get("mode", "manual")
+    channel_history = client.conversations_history(channel=channel_id, limit=2).get("messages", [])
+    channel_history = format_channel_history(channel_history)
+    intent = intent_chain.run({"history": channel_history, "input": text})
+
+    if intent == "schedule meeting" and not is_owner and not channel.get("is_group") and not channel.get("is_mpim") and 'thread_ts' not in event:
+        admin_dm = client.conversations_open(users=workspace_owner_id)
+        prompt = ChatPromptTemplate.from_template("""
+        You have this text: {text} and your job is to mention @{workspace_owner_id} and say following in 2 scenarios:
+        if message history confirms about scheduling meeting then format below text and return only that response with no other explanation
+        "Hi {workspace_owner_id} you wanted to schedule a meeting with {user_id}, {user_id} has proposed these slots [Time slots from the text] , Are you comfortable with these slots ? Confirm so I can fix the meeting."
+        else:
+            Format the text : {text}
+        MESSAGE HISTORY: {channel_history}
+        """)
+        response = LLMChain(llm=llm, prompt=prompt)
+        client.chat_postMessage(channel=admin_dm["channel"]["id"],
+                                text=response.run({'text': text, 'workspace_owner_id': workspace_owner_id, 'user_id': user_id, 'channel_history': channel_history}))
+        say(f"<@{user_id}> I've notified the workspace owner about your meeting request.", thread_ts=thread_ts)
+        return
+
+    mentions = list(set(re.findall(r'<@(\w+)>', text)))
+    if bot_user_id in mentions:
+        mentions.remove(bot_user_id)
+
+    import pytz
+    pst = pytz.timezone('America/Los_Angeles')
+    current_time_pst = datetime.now(pst)
+    formatted_time = current_time_pst.strftime("%Y-%m-%d | %A | %I:%M %p | %Z")
+
+    from all_tools import MicrosoftListCalendarEvents, GoogleCalendarEvents
+    if calendar_tool == "google":
+        schedule_tools = [tools[i] for i in [0, 1, 4, 6, 12]]
+        update_tools = [tools[i] for i in [0, 7, 12]]
+        delete_tools = [tools[i] for i in [0, 8, 12]]
+        output = calendar_formatting_chain.run({'input': GoogleCalendarEvents()._run(team_id, workspace_owner_id), 'admin_id': workspace_owner_id, 'date_time': formatted_time})
+    elif calendar_tool == "microsoft":
+        schedule_tools = [tools[i] for i in [0, 1, 9, 12]]
+        update_tools = [tools[i] for i in [0, 10, 12]]
+        delete_tools = [tools[i] for i in [0, 11, 12]]
+        output = calendar_formatting_chain.run({'input': MicrosoftListCalendarEvents()._run(team_id, workspace_owner_id), 'admin_id': workspace_owner_id, 'date_time': formatted_time})
+    else:
+        say("Invalid calendar tool configured.", thread_ts=thread_ts)
+        return
+
+    relevant_user_ids = get_relevant_user_ids(client, channel_id)
+    all_users = get_all_users(team_id)
+    relevant_users = {uid: all_users.get(uid, {"real_name": "Unknown", "email": "unknown@example.com", "name": "Unknown"})
+                      for uid in relevant_user_ids}
+    user_information = "\n".join([f"{uid}: Name={info['real_name']}, Email={info['email']}, Slack Name={info['name']}"
+                                  for uid, info in relevant_users.items() if uid != bot_user_id])
+    print(f"All users: {all_users}\n\n Relevant users: {relevant_user_ids}")
+    mentioned_users_output = mentioned_users_chain.run({"user_information": user_information, "chat_history": channel_history, "current_input": text, 'bob_id': bot_user_id})
+    schedule_exec = create_schedule_agent(schedule_tools)
+    update_exec = create_update_agent(update_tools)
+    delete_exec = create_delete_agent(delete_tools)
+    schedule_group_exec = create_schedule_group_agent(schedule_tools)
+    update_group_exec = create_update_group_agent(update_tools)
+    print(f"MENTIONED USERS:{mentioned_users_output}")
+    channel_type = channel.get("is_group", False) or channel.get("is_mpim", False)
+    agent_input = {
+        'input': f"Here is the input by user: {text} and do not mention <@{bot_user_id}> even tho mentioned in history",
+        'event_details': str(event),
+        'target_user_id': user_id,
+        'timezone': timezone,
+        'user_id': user_id,
+        'admin': workspace_owner_id,
+        'zoom_link': zoom_link,
+        'zoom_mode': zoom_mode,
+        'channel_history': channel_history,
+        'user_information': user_information,
+        'calendar_tool': calendar_tool,
+        'date_time': formatted_time,
+        'formatted_calendar': output,
+        'team_id': team_id
+    }
+
+    if intent == "schedule meeting":
+        if not channel_type and len(mentions) > 1:
+            mentions.append(user_id)
+            dm_channel_id, error = open_group_dm(client, mentions)
+            if dm_channel_id:
+                group_agent_input = agent_input.copy()
+                group_agent_input['mentioned_users'] = mentioned_users_output
+                group_agent_input['channel_history'] = channel_history
+                group_agent_input['formatted_calendar'] = output
+                response = schedule_group_exec.invoke(group_agent_input)
+                client.chat_postMessage(channel=dm_channel_id, text=f"Group conversation started by <@{user_id}>\n\n{response['output']}")
+            elif error:
+                say(f"Sorry, I couldn't create the group conversation: {error}", thread_ts=thread_ts)
+        else:
+            if channel_type or 'thread_ts' in event:
+                group_agent_input = agent_input.copy()
+                if 'thread_ts' in event:
+                    schedule_group_exec = create_schedule_channel_agent(schedule_tools)
+                    history_response = client.conversations_replies(channel=channel_id, ts=thread_ts, limit=2)
+                    channel_history = format_channel_history(history_response.get("messages", []))
+                else:
+                    channel_history = format_channel_history(client.conversations_history(channel=channel_id, limit=3).get("messages", []))
+                group_agent_input['mentioned_users'] = mentioned_users_output
+                group_agent_input['channel_history'] = channel_history
+                group_agent_input['formatted_calendar'] = output
+                response = schedule_group_exec.invoke(group_agent_input)
+                say(response['output'], thread_ts=thread_ts)
+                return
+            response = schedule_exec.invoke(agent_input)
+            say(response['output'], thread_ts=thread_ts)
+    elif intent == "update event":
+        agent_input['current_date'] = formatted_time
+        agent_input['calendar_events'] = MicrosoftListCalendarEvents()._run(team_id, workspace_owner_id) if calendar_tool == "microsoft" else GoogleCalendarEvents()._run(team_id, workspace_owner_id)
+        if channel_type or 'thread_ts' in event:
+            group_agent_input = agent_input.copy()
+            channel_history = format_channel_history(client.conversations_history(channel=channel_id, limit=2).get("messages", []))
+            group_agent_input['mentioned_users'] = mentioned_users_output
+            group_agent_input['channel_history'] = channel_history
+            group_agent_input['formatted_calendar'] = output
+            response = update_group_exec.invoke(group_agent_input)
+            say(response['output'], thread_ts=thread_ts)
+            return
+        response = update_exec.invoke(agent_input)
+        say(response['output'], thread_ts=thread_ts)
+    elif intent == "delete event":
+        agent_input['current_date'] = formatted_time
+        agent_input['calendar_events'] = MicrosoftListCalendarEvents()._run(team_id, workspace_owner_id) if calendar_tool == "microsoft" else GoogleCalendarEvents()._run(team_id, workspace_owner_id)
+        response = delete_exec.invoke(agent_input)
+        say(response['output'], thread_ts=thread_ts)
+    elif intent == "other":
+        response = llm.predict(general_prompt.format(input=text, channel_history=channel_history))
+        say(response, thread_ts=thread_ts)
+    else:
+        say("I'm not sure how to handle that request.", thread_ts=thread_ts)
+@bolt_app.event("team_join")
+def handle_team_join(event, client, context, logger):
+    try:
+        user_info = event['user']
+        team_id = context.team_id
+        
+        # Fetch workspace name from Slack API
+        try:
+            team_info = client.team_info()
+            workspace_name = team_info['team']['name']
+        except SlackApiError as e:
+            logger.error(f"Error fetching team info: {e.response['error']}")
+            workspace_name = "Unknown Workspace"
+
+        # Extract user details
+        user_id = user_info['id']
+        real_name = user_info.get('real_name', 'Unknown')
+        profile = user_info.get('profile', {})
+        email = profile.get('email', f"{user_info.get('name', 'user')}@example.com")  # Fallback email
+        name = user_info.get('name', '')
+        is_owner = user_info.get('is_owner', False)
+
+        # Connect to database
+        conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+        cur = conn.cursor()
+        
+        # Insert/update user in Users table
+        cur.execute('''
+            INSERT INTO Users (team_id, user_id, workspace_name, real_name, email, name, is_owner, last_updated)
+            VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+            ON CONFLICT (team_id, user_id) DO UPDATE SET
+                workspace_name = EXCLUDED.workspace_name,
+                real_name = EXCLUDED.real_name,
+                email = EXCLUDED.email,
+                name = EXCLUDED.name,
+                is_owner = EXCLUDED.is_owner,
+                last_updated = EXCLUDED.last_updated
+        ''', (team_id, user_id, workspace_name, real_name, email, name, is_owner, datetime.now()))
+        
+        conn.commit()
+        cur.close()
+        conn.close()
+        
+        # Update user cache
+        with user_cache_lock:
+            if team_id not in user_cache:
+                user_cache[team_id] = {}
+            user_cache[team_id][user_id] = {
+                "real_name": real_name,
+                "email": f"{name}@gmail.com",
+                "name": name,
+                "is_owner": is_owner,
+                "workspace_name": workspace_name
+            }
+        
+        # Update owner_id_cache if user is owner
+        if is_owner:
+            with owner_id_lock:
+                owner_id_cache[team_id] = user_id
+        
+        logger.info(f"Processed team_join event for user {user_id} in team {team_id}")
+    
+    except KeyError as e:
+        logger.error(f"Missing key in event data: {e}")
+    except psycopg2.Error as e:
+        logger.error(f"Database error: {e}")
+    except Exception as e:
+        logger.error(f"Unexpected error handling team_join: {e}")
+def open_group_dm(client, users):
+    try:
+        response = client.conversations_open(users=",".join(users))
+        return response["channel"]["id"] if response["ok"] else (None, "Failed to create group DM")
+    except SlackApiError as e:
+        return None, f"Error creating group DM: {e.response['error']}"
+
+# Flask Routes
+@app.route("/slack/events", methods=["POST"])
+def slack_events():
+    return slack_handler.handle(request)
+
+@app.route("/slack/install", methods=["GET"])
+def slack_install():
+    return slack_handler.handle(request)
+
+@app.route("/slack/oauth_redirect", methods=["GET"])
+def slack_oauth_redirect():
+    return slack_handler.handle(request)
+
+@app.route("/oauth2callback")
+def oauth2callback():
+    state = request.args.get('state', '')
+    print(f"STATE: {state}")
+    print(f"STATs: {state_manager._states}")
+    user_id = state_manager.validate_and_consume_state(state)
+    stored_state = get_from_session(user_id, "gcal_state") if user_id else None
+    
+    if not user_id or stored_state != state:
+        return "Invalid state", 400
+    
+    team_id = get_team_id_from_owner_id(user_id)
+    if not team_id:
+        return "Workspace not found", 404
+    
+    client = get_client_for_team(team_id)
+    if not client:
+        return "Client not found", 500
+    
+    flow = Flow.from_client_secrets_file('credentials.json', scopes=SCOPES, redirect_uri=OAUTH_REDIRECT_URI)
+    flow.fetch_token(authorization_response=request.url)
+    credentials = flow.credentials
+    service = build('oauth2', 'v2', credentials=credentials)
+    user_info = service.userinfo().get().execute()
+    google_email = user_info.get('email', 'unknown@example.com')
+    token_data = json.loads(credentials.to_json())
+    token_data['google_email'] = google_email
+    
+    save_token(team_id, user_id, 'google', token_data)  # Adjusted to use team_id and user_id
+    client.views_publish(user_id=user_id, view=create_home_tab(client, team_id, user_id))
+    
+    return "Google Calendar connected successfully! You can close this window."
+@bolt_app.action("launch_auth")
+def handle_launch_auth(ack, body, logger):
+    ack()  # Acknowledge the action
+    logger.info(f"Launch auth triggered by user {body['user']['id']}")
+    # No further action needed since the URL redirect handles the OAuth flow
+@app.route("/microsoft_callback")
+def microsoft_callback():
+    code = request.args.get("code")
+    state = request.args.get("state")
+    if not code or not state:
+        return "Missing parameters", 400
+    user_id = state_manager.validate_and_consume_state(state)
+    if not user_id:
+        return "Invalid or expired state parameter", 403
+    team_id = get_team_id_from_owner_id(user_id)
+    if not team_id:
+        return "Workspace not found", 404
+    client = get_client_for_team(team_id)
+    if not client:
+        return "Client not found", 500
+    if user_id != get_workspace_owner_id(client, team_id):
+        return "Unauthorized", 403
+    msal_app = ConfidentialClientApplication(MICROSOFT_CLIENT_ID, authority=MICROSOFT_AUTHORITY, client_credential=MICROSOFT_CLIENT_SECRET)
+    result = msal_app.acquire_token_by_authorization_code(code, scopes=MICROSOFT_SCOPES, redirect_uri=MICROSOFT_REDIRECT_URI)
+    if "access_token" not in result:
+        return "Authentication failed", 400
+    token_data = {"access_token": result["access_token"], "refresh_token": result.get("refresh_token", ""), "expires_at": result["expires_in"] + time.time()}
+    save_token(user_id, 'microsoft', token_data)
+    client.views_publish(user_id=user_id, view=create_home_tab(client, team_id, user_id))
+    return "Microsoft Calendar connected successfully! You can close this window."
+
+@app.route("/zoom_callback")
+def zoom_callback():
+    code = request.args.get("code")
+    state = request.args.get("state")
+    user_id = state_manager.validate_and_consume_state(state)
+    if not user_id:
+        return "Invalid or expired state", 403
+    team_id = get_team_id_from_owner_id(user_id)
+    if not team_id:
+        return "Workspace not found", 404
+    client = get_client_for_team(team_id)
+    if not client:
+        return "Client not found", 500
+    params = {"grant_type": "authorization_code", "code": code, "redirect_uri": ZOOM_REDIRECT_URI}
+    try:
+        response = requests.post(ZOOM_TOKEN_API, params=params, auth=(CLIENT_ID, CLIENT_SECRET))
+    except Exception as e:
+        return jsonify({"error": f"Token request failed: {str(e)}"}), 500
+    if response.status_code == 200:
+        token_data = response.json()
+        token_data["expires_at"] = time.time() + token_data["expires_in"]
+        # Fixed: Pass all required arguments in correct order
+        save_token(team_id, user_id, 'zoom', token_data)
+        client.views_publish(user_id=user_id, view=create_home_tab(client, team_id, user_id))
+        return "Zoom connected successfully! You can close this window."
+    return "Failed to retrieve token", 400
+
+@bolt_app.action("open_zoom_config_modal")
+def handle_open_zoom_config_modal(ack, body, client, logger):
+    ack()
+    user_id = body["user"]["id"]
+    team_id = body["team"]["id"]
+    owner_id = get_workspace_owner_id(client, team_id)
+    if user_id != owner_id:
+        client.chat_postMessage(channel=user_id, text="Only the workspace owner can configure Zoom.")
+        return
+    
+    # Fixed: Pass both team_id and user_id to load_preferences
+    prefs = load_preferences(team_id, user_id)
+    zoom_config = prefs.get("zoom_config", {"mode": "manual", "link": None})
+    mode = zoom_config["mode"]
+    link = zoom_config.get("link", "")
+    
+    try:
+        client.views_open(
+            trigger_id=body["trigger_id"],
+            view={
+                "type": "modal",
+                "callback_id": "zoom_config_submit",
+                "title": {"type": "plain_text", "text": "Configure Zoom"},
+                "submit": {"type": "plain_text", "text": "Save"},
+                "close": {"type": "plain_text", "text": "Cancel"},
+                "blocks": [
+                    {
+                        "type": "input",
+                        "block_id": "zoom_mode",
+                        "label": {"type": "plain_text", "text": "Zoom Mode"},
+                        "element": {
+                            "type": "static_select",
+                            "action_id": "mode_select",
+                            "placeholder": {"type": "plain_text", "text": "Select mode"},
+                            "options": [
+                                {"text": {"type": "plain_text", "text": "Automatic"}, "value": "automatic"},
+                                {"text": {"type": "plain_text", "text": "Manual"}, "value": "manual"}
+                            ],
+                            "initial_option": {"text": {"type": "plain_text", "text": "Automatic" if mode == "automatic" else "Manual"}, "value": mode} if mode else None
+                        }
+                    },
+                    {
+                        "type": "input",
+                        "block_id": "zoom_link",
+                        "label": {"type": "plain_text", "text": "Manual Zoom Link"},
+                        "element": {
+                            "type": "plain_text_input",
+                            "action_id": "link_input",
+                            "placeholder": {"type": "plain_text", "text": "Enter Zoom link"},
+                            "initial_value": link if isinstance(link, str) else ""
+                        },
+                        "optional": True
+                    }
+                ]
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error opening Zoom config modal: {e}")
+
+@bolt_app.action("configure_zoom")
+def handle_zoom_config(ack, body, client, logger):
+    ack()  # Acknowledge the action
+    user_id = body["user"]["id"]
+    team_id = body["team"]["id"]
+
+    # Ensure only the workspace owner can configure Zoom
+    owner_id = get_workspace_owner_id(client, team_id)
+    if user_id != owner_id:
+        client.chat_postMessage(channel=user_id, text="Only the workspace owner can configure Zoom.")
+        return
+
+    # Check if this is a refresh or initial authentication
+    zoom_token = load_token(team_id, owner_id, "zoom")
+    is_refresh = zoom_token is not None
+
+    # Generate the Zoom OAuth URL
+    state = state_manager.create_state(owner_id)  # Assume this generates a unique state
+    auth_url = f"{ZOOM_OAUTH_AUTHORIZE_API}?response_type=code&client_id={CLIENT_ID}&redirect_uri={quote_plus(ZOOM_REDIRECT_URI)}&state={state}"
+
+    # Set modal text based on the scenario
+    modal_title = "Refresh Zoom Token" if is_refresh else "Authenticate with Zoom"
+    button_text = "Refresh Zoom Token" if is_refresh else "Authenticate with Zoom"
+
+    # Open a modal with the appropriate text
+    try:
+        client.views_open(
+            trigger_id=body["trigger_id"],
+            view={
+                "type": "modal",
+                "title": {"type": "plain_text", "text": modal_title},
+                "close": {"type": "plain_text", "text": "Cancel"},
+                "blocks": [
+                    {
+                        "type": "section",
+                        "text": {"type": "mrkdwn", "text": f"Click below to {button_text.lower()}:"}
+                    },
+                    {
+                        "type": "actions",
+                        "elements": [
+                            {
+                                "type": "button",
+                                "text": {"type": "plain_text", "text": button_text},
+                                "url": auth_url,
+                                "action_id": "launch_zoom_auth"
+                            }
+                        ]
+                    }
+                ]
+            }
+        )
+    except Exception as e:
+        logger.error(f"Error opening Zoom auth modal: {e}")
+
+@bolt_app.view("zoom_config_submit")
+def handle_zoom_config_submit(ack, body, client, logger):
+    ack()  # Ensure ack is called before any processing to avoid warnings
+    user_id = body["user"]["id"]
+    team_id = body["team"]["id"]
+    owner_id = get_workspace_owner_id(client, team_id)
+    if user_id != owner_id:
+        return  # Early return if not owner; no need to proceed
+    
+    values = body["view"]["state"]["values"]
+    mode = values["zoom_mode"]["mode_select"]["selected_option"]["value"]
+    link = values["zoom_link"]["link_input"]["value"] if "zoom_link" in values and "link_input" in values["zoom_link"] else None
+    zoom_config = {"mode": mode, "link": link if mode == "manual" else None}
+    
+    
+    save_preference(team_id, user_id, zoom_config=zoom_config)
+    
+    client.views_publish(user_id=user_id, view=create_home_tab(client, team_id, user_id))
+@bolt_app.action("launch_zoom_auth")
+def handle_some_action(ack, body, logger):
+    ack()
+
+scheduler = BackgroundScheduler()
+scheduler.add_job(state_manager.cleanup_expired_states, 'interval', minutes=5)
+scheduler.start()
+
+@app.route('/')
+def home():
+    return render_template('index.html')
+# @app.route('/ZOOM_verify_a12f2ccf48a647aa8ebc987a249133f8.html')
+# def home():
+#     return render_template('ZOOM_verify_a12f2ccf48a647aa8ebc987a249133f8.html')
+if __name__ == "__main__":
+    app.run(port=3000)

calendar_tools.py

@@ -0,0 +1,118 @@
+import json
+from services import create_service
+client_secret = 'credentials.json'
+
+def construct_google_calendar_client(client_secret):
+    """
+    Constructs a Google Calendar API client.
+
+    Parameters:
+    - client_secret (str): The path to the client secret JSON file.
+
+    Returns:
+    - service: The Google Calendar API service instance.
+    """
+    API_NAME = 'calendar'
+    API_VERSION = 'v3'
+    SCOPES = ['https://www.googleapis.com/auth/calendar']
+    service = create_service(client_secret, API_NAME, API_VERSION, SCOPES)
+    return service
+
+
+calendar_service = construct_google_calendar_client(client_secret=client_secret)
+
+def create_calendar_list(calendar_name):
+    """
+    Creates a new calendar list.
+
+    Parameters:
+    - calendar_name (str): The name of the new calendar list.
+
+    Returns:
+    - dict: A dictionary containing the ID of the new calendar list.
+    """
+    calendar_list = {
+        'summary': calendar_name
+    }
+    created_calendar_list = calendar_service.calendarList().insert(body=calendar_list).execute()
+    return created_calendar_list
+
+
+def list_calendar_list(max_capacity=200):
+    """
+    Lists calendar lists until the total number of items reaches max_capacity.
+
+    Parameters:
+    - max_capacity (int or str, optional): The maximum number of calendar lists to retrieve. Defaults to 200.
+      If a string is provided, it will be converted to an integer.
+
+    Returns:
+    - list: A list of dictionaries containing cleaned calendar list information with 'id', 'name', and 'description'.
+    """
+    if isinstance(max_capacity, str):
+        max_capacity = int(max_capacity)
+
+    all_calendars = []
+    all_calendars_cleaned = []
+    next_page_token = None
+    capacity_tracker = 0
+
+    while True:
+        calendar_list = calendar_service.calendarList().list(
+            maxResults=min(200, max_capacity - capacity_tracker),
+            pageToken=next_page_token
+        ).execute()
+        calendars = calendar_list.get('items', [])
+        all_calendars.extend(calendars)
+        capacity_tracker += len(calendars)
+        if capacity_tracker >= max_capacity:
+            break
+        next_page_token = calendar_list.get('nextPageToken')
+        if not next_page_token:
+            break
+
+    for calendar in all_calendars:
+        all_calendars_cleaned.append(
+            {
+                'id': calendar['id'],
+                'name': calendar['summary'],
+                'description': calendar.get('description', '')
+            })
+
+    return all_calendars_cleaned
+
+def list_calendar_events(calendar_id, max_capacity=20):
+    """
+    Lists events from a specified calendar until the total number of events reaches max_capacity.
+
+    Parameters:
+    - calendar_id (str): The ID of the calendar from which to list events.
+    - max_capacity (int or str, optional): The maximum number of events to retrieve. Defaults to 20.
+      If a string is provided, it will be converted to an integer.
+
+    Returns:
+    - list: A list of events from the specified calendar.
+    """
+    if isinstance(max_capacity, str):
+        max_capacity = int(max_capacity)
+
+    all_events = []
+    next_page_token = None
+    capacity_tracker = 0
+
+    while True:
+        events_list = calendar_service.events().list(
+            calendarId=calendar_id,
+            maxResults=min(250, max_capacity - capacity_tracker),
+            pageToken=next_page_token
+        ).execute()
+        events = events_list.get('items', [])
+        all_events.extend(events)
+        capacity_tracker += len(events)
+        if capacity_tracker >= max_capacity:
+            break
+        next_page_token = events_list.get('nextPageToken')
+        if not next_page_token:
+            break
+
+    return all_events

config.py

@@ -0,0 +1,199 @@
+from slack_sdk.errors import SlackApiError
+import os
+from dotenv import load_dotenv
+from slack_sdk import WebClient
+import sqlite3
+import json
+import psycopg2
+import logging
+from datetime import datetime
+# Load environment variables
+load_dotenv()
+
+# Slack credentials
+SLACK_BOT_TOKEN = os.environ["SLACK_BOT_TOKEN"]
+
+# Initialize the Slack client
+client = WebClient(token=SLACK_BOT_TOKEN)
+logger = logging.getLogger(__name__)
+def load_preferences(team_id, user_id):
+    with preferences_cache_lock:
+        if (team_id, user_id) in preferences_cache:
+            return preferences_cache[(team_id, user_id)]
+    try:
+        conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+        cur = conn.cursor()
+        cur.execute('SELECT zoom_config, calendar_tool FROM Preferences WHERE team_id = %s AND user_id = %s', (team_id, user_id))
+        row = cur.fetchone()
+        if row:
+            zoom_config, calendar_tool = row
+            # For jsonb, zoom_config is already a dict; no json.loads needed
+            preferences = {
+                "zoom_config": zoom_config if zoom_config else {"mode": "manual", "link": None},
+                "calendar_tool": calendar_tool or "none"
+            }
+        else:
+            preferences = {"zoom_config": {"mode": "manual", "link": None}, "calendar_tool": "none"}
+        cur.close()
+        conn.close()
+    except Exception as e:
+        logger.error(f"Failed to load preferences for team {team_id}, user {user_id}: {e}")
+        preferences = {"zoom_config": {"mode": "manual", "link": None}, "calendar_tool": "none"}
+    with preferences_cache_lock:
+        preferences_cache[(team_id, user_id)] = preferences
+    return preferences
+from threading import Lock
+user_cache = {}
+preferences_cache = {}
+preferences_cache_lock = Lock()
+user_cache_lock = Lock()  # Example threading lock for cache
+
+owner_id_cache = {}
+owner_id_lock = Lock()
+def initialize_workspace_cache(client, team_id):
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute('SELECT MAX(last_updated) FROM Users WHERE team_id = %s', (team_id,))
+    last_updated_row = cur.fetchone()
+    last_updated = last_updated_row[0] if last_updated_row and last_updated_row[0] else None
+    
+    # Check if cache is fresh (e.g., less than 24 hours old)
+    if last_updated and (datetime.now() - last_updated).total_seconds() < 86400:
+        cur.execute('SELECT user_id, real_name, email, name, is_owner, workspace_name FROM Users WHERE team_id = %s', (team_id,))
+        rows = cur.fetchall()
+        new_cache = {row[0]: {"real_name": row[1], "email": row[2], "name": row[3], "is_owner": row[4], "workspace_name": row[5]} for row in rows}
+        with user_cache_lock:
+            user_cache[team_id] = new_cache
+        with owner_id_lock:
+            owner_id_cache[team_id] = next((user_id for user_id, data in new_cache.items() if data['is_owner']), None)
+    else:
+        # Fetch user data from Slack and update database
+        response = client.users_list()
+        users = response["members"]
+        workspace_name = client.team_info()["team"]["name"]  # Get workspace name from Slack API
+        new_cache = {}
+        for user in users:
+            user_id = user['id']
+            profile = user.get('profile', {})
+            real_name = profile.get('real_name', 'Unknown')
+            name = user.get('name', '')
+            email = f"{name}@gmail.com"  # Placeholder; adjust as needed
+            is_owner = user.get('is_owner', False)
+            new_cache[user_id] = {"real_name": real_name, "email": email, "name": name, "is_owner": is_owner, "workspace_name": workspace_name}
+            cur.execute('''
+                INSERT INTO Users (team_id, user_id, workspace_name, real_name, email, name, is_owner, last_updated)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s)
+                ON CONFLICT (team_id, user_id) DO UPDATE SET
+                    workspace_name = %s, real_name = %s, email = %s, name = %s, is_owner = %s, last_updated = %s
+            ''', (team_id, user_id, workspace_name, real_name, email, name, is_owner, datetime.now(),
+                  workspace_name, real_name, email, name, is_owner, datetime.now()))
+        conn.commit()
+        with user_cache_lock:
+            user_cache[team_id] = new_cache
+        with owner_id_lock:
+            owner_id_cache[team_id] = next((user_id for user_id, data in new_cache.items() if data['is_owner']), None)
+    cur.close()
+    conn.close()
+def get_workspace_owner_id_client(client ):
+    """Get the workspace owner's user ID."""
+    try:
+        response = client.users_list()
+        members = response["members"]
+        for member in members:
+            if member.get("is_owner"):
+                return member["id"]
+    except SlackApiError as e:
+        print(f"Error fetching users: {e.response['error']}")
+    return None
+
+def get_workspace_owner_id(client, team_id):
+    with owner_id_lock:
+        if team_id in owner_id_cache and owner_id_cache[team_id]:
+            return owner_id_cache[team_id]
+    initialize_workspace_cache(client, team_id)
+    with owner_id_lock:
+        return owner_id_cache.get(team_id)
+# def get_workspace_owner_id():
+#     conn = sqlite3.connect('workspace_cache.db')
+#     c = conn.cursor()
+#     c.execute('SELECT user_id FROM workspace_cache WHERE is_owner = 1')
+#     owner_id = c.fetchone()
+#     conn.close()
+#     return owner_id[0] if owner_id else None
+
+owner_id_pref = get_workspace_owner_id_client(client)
+def GetAllUsers():
+    all_users = {}
+    try:
+        response = client.users_list()
+        print(response)
+        members = response['members']
+        for member in members:
+            user_id = member['id']
+            profile = member.get('profile', {})
+            user_name = profile.get('real_name', '')  # Use real_name from profile
+            # Use actual email if available, otherwise construct one from member['name']
+            email = profile.get('email', f"{member.get('name', '')}@gmail.com")
+            print(f"User ID: {user_id}, Name: {user_name}, Email: {email}")
+            all_users[user_id] = {"Slack Id": user_id, "name": user_name, "email": email}
+        return all_users
+    except SlackApiError as e:
+        print(f"Error fetching users: {e.response['error']}")
+        return {}
+def load_token(team_id, user_id, service):
+    """
+    Load token data from the database for a specific team, user, and service.
+
+    Parameters:
+        team_id (str): The Slack team ID.
+        user_id (str): The Slack user ID.
+        service (str): The service name (e.g., 'google').
+
+    Returns:
+        dict: The token data as a dictionary, or None if not found.
+    """
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute(
+        'SELECT token_data FROM Tokens WHERE team_id = %s AND user_id = %s AND service = %s',
+        (team_id, user_id, service)
+    )
+    row = cur.fetchone()
+    cur.close()
+    conn.close()
+    return row[0] if row else None
+
+def save_token(team_id, user_id, service, token_data):
+    """
+    Save token data to the database for a specific team, user, and service.
+
+    Parameters:
+        team_id (str): The Slack team ID.
+        user_id (str): The Slack user ID.
+        service (str): The service name (e.g., 'google').
+        token_data (dict): The token data to save (e.g., {'access_token', 'refresh_token', 'expires_at'}).
+    """
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute(
+        '''
+        INSERT INTO Tokens (team_id, user_id, service, token_data, updated_at)
+        VALUES (%s, %s, %s, %s, %s)
+        ON CONFLICT (team_id, user_id, service) 
+        DO UPDATE SET token_data = %s, updated_at = %s
+        ''',
+        (
+            team_id, user_id, service, json.dumps(token_data), datetime.now(),
+            json.dumps(token_data), datetime.now()
+        )
+    )
+    conn.commit()
+    cur.close()
+    conn.close()
+all_users_preload = GetAllUsers()
+if all_users_preload:
+    print("Users Prefection enabled")
+# def GetAllUsers():
+#     return ""
+# all_users_preload = ""
+# owner_id_pref = ""

db.py

@@ -0,0 +1,81 @@
+import os
+import psycopg2
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def init_db():
+    """
+    Initialize the Neon Postgres database by creating the necessary tables for multi-workspace support:
+    - Installations: Stores Slack workspace installation data.
+    - Users: Stores Slack user information with team_id, user_id, and workspace_name.
+    - Preferences: Stores user-specific preferences with team_id and user_id.
+    - Tokens: Stores authentication tokens with team_id, user_id, and service.
+    Prerequisites: 'DATABASE_URL' environment variable must be set with Neon Postgres connection string.
+    """
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    
+    # Create Installations table for OAuth installation data
+    cur.execute('''
+        CREATE TABLE IF NOT EXISTS Installations (
+            workspace_id TEXT PRIMARY KEY,         -- Slack workspace ID (team_id)
+            installation_data JSONB,               -- Installation data stored as JSON
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP  -- Last update timestamp
+        )
+    ''')
+    
+    # Create Users table with composite primary key (team_id, user_id) and workspace_name
+    cur.execute('''
+        CREATE TABLE IF NOT EXISTS Users (
+            team_id TEXT,                         -- Slack workspace ID
+            user_id TEXT,                         -- Slack user ID
+            workspace_name TEXT,                  -- Name of the workspace
+            real_name TEXT,                       -- User's real name from Slack
+            email TEXT,                           -- User's email from Slack
+            name TEXT,                            -- User's Slack handle
+            is_owner BOOLEAN,                     -- Indicates if user is workspace owner
+            last_updated TIMESTAMP,               -- Last time user data was updated
+            PRIMARY KEY (team_id, user_id)        -- Composite key for uniqueness across workspaces
+        )
+    ''')
+    
+    # Create Preferences table with composite primary key and foreign key
+    cur.execute('''
+        CREATE TABLE IF NOT EXISTS Preferences (
+            team_id TEXT,                         -- Slack workspace ID
+            user_id TEXT,                         -- Slack user ID
+            zoom_config JSONB,                    -- Zoom configuration stored as JSON
+            calendar_tool TEXT,                   -- Selected calendar tool (e.g., google, microsoft)
+            updated_at TIMESTAMP,                 -- Last update timestamp
+            PRIMARY KEY (team_id, user_id),       -- Composite key for uniqueness
+            CONSTRAINT fk_user
+                FOREIGN KEY(team_id, user_id)     -- References Users table
+                REFERENCES Users(team_id, user_id)
+                ON DELETE CASCADE                 -- Delete preferences if user is deleted
+        )
+    ''')
+    
+    # Create Tokens table with composite primary key and foreign key
+    cur.execute('''
+        CREATE TABLE IF NOT EXISTS Tokens (
+            team_id TEXT,                         -- Slack workspace ID
+            user_id TEXT,                         -- Slack user ID
+            service TEXT,                         -- Service name (google, microsoft, zoom)
+            token_data JSONB,                     -- Token data stored as JSON
+            updated_at TIMESTAMP,                 -- Last update timestamp
+            PRIMARY KEY (team_id, user_id, service),  -- Composite key ensures one token per service per user per workspace
+            CONSTRAINT fk_user
+                FOREIGN KEY(team_id, user_id)     -- References Users table
+                REFERENCES Users(team_id, user_id)
+                ON DELETE CASCADE                 -- Delete tokens if user is deleted
+        )
+    ''')
+    
+    conn.commit()
+    cur.close()
+    conn.close()
+
+if __name__ == '__main__':
+    init_db()
+    print('Neon Postgres database initialized successfully.')

prompt.py

@@ -0,0 +1,698 @@
+from langchain.prompts import ChatPromptTemplate
+
+# Intent Classification Prompt
+intent_prompt = ChatPromptTemplate.from_template("""
+You are an intent classification assistant. Based on the user's message and the conversation history, determine the intent of the user's request. The possible intents are: "schedule meeting", "update event", "delete event", or "other". Provide only the intent as your response.
+- By looking at the history if someone is confirming or denying the schedule , also categorize it as a schedule
+Conversation History:
+{history}
+
+User's Message:
+{input}
+""")
+
+# Schedule Meeting Agent Prompt
+
+
+
+calender_prompt = ChatPromptTemplate.from_template("""
+<SYSTEM>
+You are an intelligent agent and your job is to design the timeslots for the meetings 
+You will be given with raw calendar events and you have the following job
+
+<CURRENT DATE AND TIME>     
+{date_time}
+
+<WORKSPACE ADMIN ID>
+Use workspace admin slack id for the calendar event: {admin_id}                                                                                                                                                                                                                                                       
+<JOB STEPS>
+STEP 1. Fetch current date once
+STEP 2. Filter all past events (events on dates which are behind the current date) and also the future event timeslots
+STEP 3. Generate the 7 day timeslots omitting the past events and future time slots which have events registered
+STEP 4. Prepare those slots in this reference format 
+"
+    Date | Day | Slots | Timezone
+    01-12-2024 | Friday | All Day | PT
+    02-12-2024 | Saturday | 9am - 11am, 2pm - 3pm | PT
+    03-12-2024 | Sunday | All Day | PT
+    04-12-2024 | Monday | 10am - 12pm | PT
+    05-12-2024 | Tuesday | 1pm - 3pm | PT
+    06-12-2024 | Wednesday | All Day | PT
+    07-12-2024 | Thursday | 9am - 10am | PT
+                                                   
+"                                              
+<UNFORMATTED EVENTS>
+{input}                                                                                                                                                                                   
+FINAL OUTPUT: Formatted slots in given format and dont include any step details or preprocessing details
+""")
+
+
+
+# schedule_prompt = ChatPromptTemplate.from_template("""
+# <SYSTEM>:
+# You are a meeting scheduling assistant. Your task is to help the user schedule a meeting by finding available time slots, coordinating with participants, and creating the meeting event in the calendar.
+# <TOOLS>: Be Precise in using the tools and use it only once
+# {{tools}}
+# <CURRENT DATE AND TIME>
+# {date_time}
+# <TASK>:
+# Based on the user's request, use the appropriate tools to schedule the meeting. Check calendar availability, send direct messages to coordinate, and create the event.
+# <STEPS>
+# 1. You will be given the formatted current events of the calendar.
+# 2. Send  the schedule by mentioning all the mentioned user s and ask for their preferences.                                                                                            
+# 3. Note that there can be multiple users mentioned in the meeting text and if one user replies about a timing then also mention other users and ask if they are comfortable with this time or not.
+#     3.1: If all user agrees then schedule the meeting in the calendar
+#                                                                                                                         3.2 If even one of them disagrees then go to step 2.1 and send the sames slots mentioning the disagreement and keep performing this step until the consensus is reached and all mentioned user are agreed on one time
+#     3.3 You can keep track for yourself, lets say we have 3 users U1 , U2 and U3, you can check the users U1 has agreed , U2 has agreed but U3 didnt so again send the timetable but already prepared one so dont use the tool again just the history and mention that U3 have the clash so pick another time from the slots.
+                                                                                                                                                            
+# 4. After resolving the conflict you must call the tool to register the event in the calendar.
+#     4.1: You should include the summary of the event like who are included in the meeting
+#     4.2: You should include the email addresses of the mentioned users which you can access from the <USERS INFORMATION>.                                                                                                   
+
+# 5. Finally if meeting is registered in the calendar then send the direct message to each of the attendee/ mentioned users about confirming the meeting schedule and again you can access the user information from the <USERS INFORMATION>
+# - To send the dm to single mentioned user: send_direct_dm and pass the slack user id of the receiver i.e user_id =  'UC3472938'
+# - To send the dm to multiple mentioned users use this tool:  send_multiple_dms and user slacks id will be passed as list to this tool  i.e   user_ids = ['UA263487', 'UB8984234']                                                                                               
+ 
+#                                                                                                                                                  ------------------------------------                                                                                YOUR WORK STARTS FROM HERE.                 
+# <INPUT>:
+# {input}
+# <CHANNEL HISTORY(PREVIOUS MESSAGES FOR CONTEXT)>:
+# {channel_history}
+# - If a new message is sent or received related to new schedule of meeting then ignore old responses
+# - Always analyze the latest history and in context to new messages                                                                                                       
+# <EVENTS FROM THE CALENDAR>
+# "Hello <@mentioned_users>,
+# <@{admin}> wants to schedule a meeting with you. Here are their available time slots:
+# {formatted_calendar} Which slot suits for you best "                                                  
+# <USERS INFORMATION>:
+# {user_information}
+
+# <CALENDAR TOOL>:
+# {calendar_tool}                                                   
+# <EVENT DETAILS TO REGISTER IN THE CALENDAR>:
+# {event_details}
+
+# <TARGET USER ID>:
+# {target_user_id}
+
+# <TIMEZONE>:
+# {timezone}
+
+# <USER ID>:
+# {user_id}
+
+# <ADMIN SLACK ID>:
+# {admin}
+
+# <ZOOM LINK>:
+# {zoom_link}
+
+# <ZOOM MODE>:
+# {zoom_mode}
+
+
+# <AGENT SCRATCHPAD>:
+# {agent_scratchpad}
+
+# <OUTPUT>:
+# Provide a confirmation message after scheduling, e.g., "Meeting scheduled successfully."
+# """)
+from langchain.prompts import ChatPromptTemplate
+
+schedule_prompt = ChatPromptTemplate.from_template("""
+## System Message
+You are a meeting scheduling assistant. You task is following.
+1. Resolve conflicts when multiple users are proposing their timeslot 
+2. Schedule meetings and send the direct message only once to users.
+3. You are not allowed to use any tool twice if a tool is used once then dont use it again
+## User Information: 
+- Email addresses of all participants, found in {user_information}.
+- Store name in calendar not ids
+- You can match ids with names and emails.
+- Pass {admin} to calendar events as user 
+id   
+-  Also add admin in calendar attendees as well.                                                                                                               - You can ignore previous respones if in those responses some meeting is already set up.                                      
+## Tools
+- **Available Tools:** {{tools}}  
+  *(Placeholder for the list of tools the assistant can use, e.g., calendar tools, messaging functions.)*
+- **Tool Usage Guidelines:**   
+  - **Messaging Tools:** Use `send_direct_dm` or `send_multiple_dms` each time you need to send a message (e.g., proposing slots, collecting responses, or confirming the meeting). Call these only when explicitly required by the workflow.
+
+## Current Date and Time
+{date_time}  
+*(Placeholder for the current date and time, used as a reference for scheduling.)*
+## If you receive any message of token expiration do not process further just return the reponse of that token expiration and ask {admin} to refresh it 
+## Task
+Based on the user's request, schedule a meeting by:  
+- Checking calendar availability which is passed.    
+- Create the event in the calendar once consensus is reached by all the users.
+- Obviously you can see the history and if you find that multiple times same request of scheduling is fired means that there are 2 consecutive requests of scheduling then consider only one and latest one.
+- Never ever mention Bob in calendar summary and dont add Bob's name and email
+- And add in description that this meeting is scheduled by [admin's name here] on Slack.                                                                                                      
+## Workflow
+Follow these steps to schedule the meeting:
+
+1. **Calendar Information**  
+   This is the calendar {formatted_calendar} and now your job is to send this schedule to the mentioned user/users other than admin.
+   You should use this template and dont include any steps details:  
+"Hello <@mentioned_users/user>,
+
+<@{admin}> wants to schedule a meeting with you. Here are their available time slots:
+
+{formatted_calendar}
+
+Which slot suits you best?" 
+- Use the appropriate messaging tool (`send_direct_dm` for one user, `send_multiple_dms` for multiple users).
+
+3. **Collect and Manage Responses**(Here you will use history and new input to analyze the response)  
+- Monitor responses from all mentioned users or a single user.  
+- if user/users agree or propose a time slot , send 'send_direct_dm' message to {admin} and ask for their confirmation , once they confirmed then use calendar tool. 
+- In case of multiple mentioned users other than admin , don't send dm to admin just mention admin if all other users are agreed.
+- If all other users are not agreed or there is a conflict then mention other users for their slot confirmation.
+- Keep track of each user’s response (e.g., "U1: agreed, U2: agreed, U3: disagreed").  
+- Repeat this step, mentioning users in message as needed, until all users agree on one time slot.
+- Do not send dm to users and admin until all other users and admin agrees. and it should include a summary of the meeting (e.g., "Meeting with U1, U2, U3").  
+4: First register the zoom meeting using the tool 'create_zoom_meeting' and then register the event in the calendar using either 'microsoft_calendar_add_event' or 'google_add_calendar_event' based on calendar tools and also include the formatted output of this in the calendar summary.  
+# Do not use this tool until all users and admin are agreed: - 
+   - `send_direct_dm` for one user (e.g., `send_direct_dm(user_id='UC3472938', message='Meeting scheduled...')`).  
+   - `send_multiple_dms` for multiple users excluding the admin (e.g., `send_multiple_dms(user_ids=['UA263487', 'UB8984234'], message='Meeting scheduled...')`).
+   - microsoft_calendar_add_event:  for registering the scheduled event in microsoft calendar if "microsoft" is selected as calendar tool
+   - google_add_calendar_event:     for registering the scheduled event in microsoft calendar if "google" is selected as calendar tool                                                                                    
+
+- You will consider the single user if 2nd user is admin and you will use 'send_direct_dm                                                     
+- Get Slack IDs from {user_information}.
+
+## Notes
+- **New Messages:** If a new message about the schedule is received, ignore old responses and focus on the latest request.  
+- ***Admin Disagreement** If admin doesnt agree with the timings , send the schedule again to the mentioned user and tell about admin's availability and ask to choose another slot.
+
+## Channel History (Previous Messages for Context, Look if user has confirmed for the meeting then user calendar tool)
+{channel_history}  
+
+
+## Users Information
+{user_information}  
+
+## Team id (if needed)
+{team_id}
+## Formatted Calendar Events
+{formatted_calendar}  
+
+
+## Event Details to Register in the Calendar
+{event_details}  
+
+
+## Target User ID
+{target_user_id}  
+
+
+## Timezone
+{timezone}  
+
+
+## User ID
+{user_id}  
+
+
+## Admin Slack ID
+{admin}  
+# You can use the emails from {user_information} at the time of registering the events in the calendar    
+## Zoom Link
+{zoom_link}  
+
+## Zoom Mode
+{zoom_mode}  
+# Focus more on last history messages and ignore repetative schedule requests
+# Send only the schdule , not any processing steps or redundant text.
+# Do not consider old mentions in history if there is a request for a new meeting.                                                   
+# Dont send the direct dm to "Bob" ever.
+# Check if meeting is confirmed from the {admin} admin then use the calendar tool to register.
+# Dont say this in summary "This meeting was scheduled by U983482" Instead of Id use the name and give zoom information there                                                    
+# Good agents always use the tool once and end the chain                                                  
+# You can use the emails for the attendees from the user information provided.
+# Track used tools here and dont use them again i.e (Dm tool: used ): ____                                                                                                                
+# Never mention Slack Id in calendar summary or meeting description , always write the Names , dont write this 'This meeting was scheduled by U-------- on Slack'                                                                                                       
+# Input
+{input}
+       
+## Agent Scratchpad Once you receive success as response from the tool then close and end the chain
+{agent_scratchpad}  
+""")   
+
+schedule_group_prompt = ChatPromptTemplate.from_template("""
+## System Message
+You are a meeting scheduling assistant. You task is following.
+1. Resolve conflicts between these multiple users when they are proposing their timeslot 
+2. Schedule meetings only when all are agreed.
+3. You are not allowed to use any tool twice if a tool is used once then dont use it again
+                                                                                                               
+## If you receive any message of token expiration do not process further just return the reponse of that token expiration and ask {admin} to refresh it                                                                                                                   
+## User Information: 
+- Email addresses of all participants, found in {user_information}.
+- Store name in calendar not ids
+- You can match ids with names and emails.
+- Pass {admin} to calendar events as user id 
+
+## Mentioned Users: {mentioned_users}                                                                                                   
+## Tools
+- **Available Tools:** {{tools}}  
+  
+- **Tool Usage Guidelines:**   
+  - **Messaging Tools:** Do not send direct messages to users.
+  - Mention each user explicitly in responses while giving reference that admin scheduled meeting with these users, so they remember the timing and don’t forget.
+# Dont send the schedule everytime , if someone has proposed the timeslots already but if someone disagrees then send the schedule again and when {admin} admin agrees with the timing at the end , register the event.
+## Current Date and Time
+{date_time}  
+*(Placeholder for the current date and time, used as a reference for scheduling.)*
+## Make a checkist for yourself and this will come from channel history messages and user information that U1 has agreed , U2 has agreed but U3 or so on didnt agree so mention them and ask this user has proposed this slot do you agree with that?  and repeat this untill all the users are agreed and at the end ask from admin: {admin}
+## Task
+Based on the user's request, schedule a meeting by:  
+- Checking calendar availability which is passed.    
+- Create the event in the calendar once consensus is reached by all the users.
+- Obviously you can see the history and if you find that multiple times same request of scheduling is fired means that there are 2 consecutive requests of scheduling then consider only one and latest one.
+- Never ever mention Bob [U08AG1Q6CQ2] in calendar summary and dont add Bob's name and email
+- And add in description that this meeting is scheduled by [admin's name here] on Slack. 
+- Resolve the conflict between users   
+- You have to repeat the workflow but track the timeslots and days proposed by the users until all users are agreed.
+- Do not send the calendar again and again untill there is a disagreement or a user explicity demands [IMPORTANT]                                                                                                          # You can use the emails from {user_information} at the time of registering the events in the calendar                                                               - Never mention 'Bob'[U08AG1Q6CQ2] in any message or response and its very important not to mention bob.                                                                                                        
+# Never use multiple dms or single user dm to send the schedule and its very important.
+                                                       
+## Workflow
+Follow these steps to schedule the meeting:
+
+1. **Calendar Information**  
+   This is the calendar {formatted_calendar} and now your job is to share this schedule with the mentioned users.
+   You should use this template and dont include any steps details:  
+"Hello <@mentioned_users/user>,
+
+<@{admin}> wants to schedule a meeting with you all. Here are their available time slots:
+
+{formatted_calendar}
+
+Which slot suits you best?"                                                  
+ "                                                                                                                  
+**Tracking Users** You can track the responses like this: 
+"
+   Here's the current status:
+*   (User 1 ): Proposed Wednesday from 3pm to 4pm.
+*   (User 2): Agreed with Wednesday from 3pm to 4pm.
+*   (User 3): Admin, awaiting confirmation after other users agree.     
+                                                         
+3. **Collect and Manage Responses**(Here you will use history and new input to analyze the response)  
+- Monitor responses from all mentioned users {mentioned_users}.   
+- If all other users are not agreed or there is a conflict between {mentioned_users}.
+  There can be several scenarios that one from {mentioned_users} propose a slot and all agrees then schedule the event
+  and if any of them from {mentioned_users} disagrees then mention other users from {mentioned_users} and ask them again the slot and if all are agreed then schedule the event using microsoft_calendar_add_event or google_add_calendar_event as mentioned in calendar tools.
+- Keep track of each user’s response (e.g., "U1: agreed, U2: agreed, U3: disagreed").  
+- Do not send messages until all other users and admin agree. The final response should include a summary of the meeting (e.g., "Meeting with U1, U2, U3").  
+4: First register the zoom meeting using the tool 'create_zoom_meeting' and then register the event in the calendar using either 'microsoft_calendar_add_event' or 'google_add_calendar_event' based on calendar tools and also include the formatted output of this in the calendar summary.  
+# Do not use this tool until all users and admin are agreed: - 
+   - microsoft_calendar_add_event:  for registering the scheduled event in microsoft calendar if "microsoft" is selected as calendar tool
+   - google_add_calendar_event:     for registering the scheduled event in google calendar if "google" is selected as calendar tool                                                                                   
+
+- Get Slack IDs from {user_information}.
+## Notes
+- **New Messages:** If a new message about the schedule is received, ignore old responses and focus on the latest request.  
+- **Responses:** If one proposes a slot then mention others and ask about their preferences.
+## If a user agrees with a timeslot then mention other users and ask about their preference and tell the other users about selected preference by the user.
+## Similarly,if some user disagree or say that he/she is not available or busy within the timeslot selected by other users so  mention other users and tell that they have to select some other schedule [IMPORTANT].
+
+# Only mention those members which are present in {mentioned_users} , not all the members from user information.   
+## Channel History 
+{channel_history}  
+
+
+## Users Information
+{user_information}  
+
+
+## Formatted Calendar Events
+{formatted_calendar}  
+
+
+## Event Details to Register in the Calendar
+{event_details}  
+
+
+## Target User ID
+{target_user_id}  
+
+## Team id (if needed)
+{team_id}
+                                                         
+## Timezone
+{timezone}  
+
+
+## User ID
+{user_id}  
+
+
+## Admin Slack ID
+{admin}  
+
+## Zoom Link
+{zoom_link}  
+
+## Zoom Mode: if its manual then use zoom link otherwise use tool for creating the meeting.
+{zoom_mode}  
+# Focus more on last history messages and ignore repetative schedule requests
+# Do not send direct messages to any member. Use the calendar tool to register the meeting once the consensus is reached by all members.
+# Do not consider old mentions in history if there is a request for a new meeting.                                                        
+# Dont send any message to "Bob" ever.
+# Check if meeting is confirmed from the {admin} admin then use the calendar tool to register.                                                    
+# Good agents always use the tool once and end the chain                                                  
+# Track users if user 1 agreed and then ask user 2 and similarly to all users and at the end ask admin.
+# Use channel history to track the responses and dont mark the user in awaiting state if he already answered.               
+# Dont say this in summary "This meeting was scheduled by U983482" Instead of Id use the name and give zoom information there                                          
+# Track used tools here and dont use them again i.e (Used tools: ____ )                                                                                                               # Never mention Slack Id in calendar summary or meeting description , always write the Names , dont write this 'This meeting was scheduled by U-------- on Slack'                                                                                                           
+# Input
+{input}
+## Always mention in channel and calendar by name not by slack Id and also add the email of {admin} along with other attendees in the calendar       
+## Agent Scratchpad Once you receive success as response from the tool then close and end the chain
+{agent_scratchpad}  
+""")
+
+
+schedule_channel_prompt = ChatPromptTemplate.from_template("""
+## System Message
+You are a meeting scheduling assistant. Your task is to:
+1. Resolve conflicts between multiple users when they propose their timeslots.
+2. Schedule meetings only when all participants agree.
+3. Use the calendar tool only once when registering the event.
+
+## Channel History and Only track the timeslot responses by the users not the calendar and dont send calendar evertime.  
+{channel_history}
+## If you receive any message of token expiration do not process further just return the reponse of that token expiration and ask {admin} to refresh it 
+
+# You can use the emails from {user_information} at the time of registering the events in the calendar                                                                                                                     
+## User Information
+- Email addresses of participants but fetch only those which were mentioned in the chat, not others: {user_information}.
+- Store names in the calendar, not IDs.
+- Match IDs with names and emails.
+- Pass {admin} as the user ID for calendar events.
+
+## Mentioned Users
+{mentioned_users}
+
+## Tools
+- **Available Tools:** {{tools}}
+- **Tool Usage Guidelines:**  
+  - **Messaging Tools:** Do not send direct messages.  
+  - Mention users explicitly when responding.  
+  - Avoid repeating and sending the schedule/timeslots unless a conflict arises.  
+  - Register the event only after {admin} confirms.  
+  -  Add user names in calendar summary 
+  - Add their emails in calendar attendees                                                         
+## Current Date and Time
+{date_time} *(Used for scheduling reference.)*
+
+## Agreement Tracking Checklist
+- Use channel history and user responses to track agreements:
+  - Example: U1 and U2 have agreed, U3 has not.  
+  - Mention pending users: "User [] proposed this slot. Do you agree?"  
+  
+
+## Task
+To finalize scheduling:
+1. **Verify availability** in {formatted_calendar}.
+2. **Create an event** only when all users agree.
+3. **Prevent duplicate requests**: Process only the latest scheduling request.
+4. **Do not mention 'Bob' [U08AG1Q6CQ2]** in any messages or calendar events.
+5. **Event description should include**: "This meeting was scheduled by {admin} on Slack."
+
+6. **Never send direct messages to individuals.**  
+7. **Use the calendar tool only once.** Register the event upon {admin}'s confirmation and state that it has been scheduled.
+
+## Workflow
+### 1. Share Calendar Availability if no one has proposed the timeslot or there is disagreement. 
+Use this format to notify users:  
+*"Hello <@{mentioned_users}>,  
+<@{admin}> wants to schedule a meeting. Here are the available time slots:*  
+{formatted_calendar}  
+*Which slot works best for you?"*  
+
+### 2. Response Tracking  
+Monitor user responses:  
+- (User 1): Proposed Wednesday, 3 PM - 4 PM.  
+- (User 2): Agreed.  
+- (User 3): Awaiting confirmation from {admin}.  
+
+### 3. Handle Scheduling Conflicts  
+- Track responses from {mentioned_users}.  
+- If there is a disagreement, propose a new slot and ask for confirmation.  
+- Schedule the meeting only when all users agree.  
+- Fetch Slack IDs from {user_information} as needed.
+
+### 4. Notes    
+- If a conflict arises, notify users and find consensus.  
+- Mention only users in {mentioned_users}, not everyone in {user_information}.  
+
+### 5: First register the zoom meeting using the tool 'create_zoom_meeting' and then register the event in the calendar and also include the formatted output of this in the calendar summary.                                                            
+### If one person responds with timeslot then use his/her timeslot and mention others and ask them whether they are okay with this slot or not and track everyones response and do not send the calendar again until there is a disagreement or someone asks explicitly but just track the date and mentions                                                           
+
+# Do not consider old mentions in history if there is a request for a new meeting.
+## Zoom Details  
+- **Link:** {zoom_link}  
+- **Mode: (if its manual then use zoom link otherwise use tool for creating the meeting.)** {zoom_mode}
+## Focus more on last history messages and ignore repetative schedule requests
+## Important Rules  
+- No direct messages.  
+- Use the calendar tool only after full agreement.  
+- Track used tools and do not reuse them.  
+- Once {admin} agrees, register the event with:  
+  - `microsoft_calendar_add_event` (for Microsoft Calendar).  
+  - `google_add_calendar_event` (for Google Calendar).  
+## Users Information  
+{user_information}
+
+## Formatted Calendar Events  
+{formatted_calendar}
+
+## Event Details  
+{event_details}
+
+## Target User ID  
+{target_user_id}
+
+## Timezone  
+{timezone}
+
+## User ID  
+{user_id}
+
+## Team id (if needed)
+{team_id}
+                                                                                                                     
+## Admin Slack ID  
+{admin}
+# Never mention Slack Id in calendar summary or meeting description , always write the Names , dont write this 'This meeting was scheduled by U-------- on Slack'                                                             
+## Input  
+{input}
+
+# DO NOT REGISTER THE EVENT MULTIPLE TIMES — THIS IS CRUCIAL.
+# Dont say this in summary "This meeting was scheduled by U983482" Instead of Id use the name and give zoom information there                                                           
+## Always mention in channel and calendar by name not by slack Id and also add the email of {admin} along with other attendees in the calendar  
+## Agent Scratchpad and once you recevive success for registering event then stop the chain
+{agent_scratchpad}  
+""")
+
+
+
+
+# Update Event Agent Prompt
+update_prompt = ChatPromptTemplate.from_template("""
+SYSTEM:
+You are an event update assistant. Your task is to help the user modify an existing calendar event by searching for the event, updating its details, and notifying participants.
+
+CURRENT DATE: {current_date}
+TASK:                                                                                                  
+1. If user ask to update an existing calendar event first ask the {admin} about that if they confirm then ask for which event to update otherwise refuse.                                                 
+2. After the approval if user doesnt mention anything about the event name or id , then ask the user which event from the following you want to update
+  2.1 Filter all the events and pick those event id from the "{calendar_events}" (Filter out before current date) where user id is "{user_id}" and you can pick the user from user information "{user_information}" and ask user which one to update.
+3. If user mentiones about the event then
+  3.1 If user  mentions about new date then update the existing event based on event id
+  3.2 If user doesnt mention about the new date then ask for new date.  
+4. If {admin}=={user_id} is asking for an update then show all the events and ask which one you want to update.
+5. Dont ask from admin ({admin}=={user_id}) to confirm about updating                                                                                                                                  6. if you are encountering multiple update requests in history , consider only one
+7.Pass {admin} to calendar events as user id                                                                                                                                              EVENT DETAILS:
+                                                 
+{event_details}
+
+TARGET USER ID:
+{target_user_id}
+
+TIMEZONE:
+{timezone}
+
+USER ID:
+{user_id}
+
+ADMIN:
+{admin}
+
+Team id (if needed)
+{team_id}
+
+USER INFORMATION:
+{user_information}
+
+CALENDAR TOOL:
+{calendar_tool}
+                                                          
+TOOLS:
+{{tools}}
+- google_update_calendar_event: if calendar is "google"
+- microsoft_calendar_update_event: if calendar is "microsoft                                               
+CHANNEL HISTORY:
+Here is the history to track the agreement between users and admin                                                 
+{channel_history}                                                 
+# Never mention Slack Id in calendar summary or meeting description , always write the Names , dont write this 'This meeting was scheduled by U-------- on Slack'  
+INPUT:
+{input}
+
+AGENT SCRATCHPAD:
+{agent_scratchpad}
+
+OUTPUT:
+Provide a confirmation message after updating, e.g., "Event updated successfully."
+""")
+
+update_group_prompt = ChatPromptTemplate.from_template("""
+SYSTEM:
+You are an event update assistant. Your task is to help the user modify an existing calendar event by searching for the event, updating its details, and notifying participants.
+
+CURRENT DATE: {current_date}
+TASK:                                                                                                  
+1. If user ask to update an existing calendar event first ask the {admin} about that if they confirm then ask for which event to update otherwise refuse.                                                 
+2. After the approval if user doesnt mention anything about the event name or id , then ask the user which event from the following you want to update
+  2.1 Filter all the events and pick those event id from the "{calendar_events}" (Filter out before current date) where user id is "{user_id}" and you can pick the user from user information "{user_information}" and ask user which one to update.
+3. If user mentiones about the event then
+  3.1 If user  mentions about new date then update the existing event based on event id
+  3.2 If user doesnt mention about the new date then ask for new date.  
+4. If {admin}=={user_id} is asking for an update then show all the events and ask which one you want to update.
+                                                                                                                    5. if you are encountering multiple update requests in history , consider only one
+6.Pass {admin} to calendar events as user id                                                                                                                  7. Ask other <@{mentioned_users}> as well, if they agree on update or not 
+**Tracking Update**: You can track the update info like this:
+# While asking mention the users, do not use Slack IDs in response. the                                                        
+# Do not dm the admin{admin} about confirming anything , ask in this response.                                                                                                           # Dm all user only if new meeting is registered in the calendar
+# Ask other mention users: {mentioned_users} as well whether they are agreed with the new schedule     
+"
+   Here's the current status of update:
+*   (User 1 ): Proposed to update the schedule on Wednesday from 3pm to 4pm.
+*   (User 2): Agreed with Wednesday from 3pm to 4pm.
+*   (User 3): Admin, awaiting confirmation after other users agree.                                                      
+ "                                                                                         EVENT DETAILS:
+                                                 
+{event_details}
+
+TARGET USER ID:
+{target_user_id}
+
+TIMEZONE:
+{timezone}
+
+USER ID:
+{user_id}
+
+ADMIN:
+{admin}
+
+Team id (if needed)
+{team_id}
+
+USER INFORMATION:
+{user_information}
+
+CALENDAR TOOL:
+{calendar_tool}
+                                                          
+TOOLS:
+{{tools}}
+- google_update_calendar_event: if calendar is "google"
+- microsoft_calendar_update_event: if calendar is "microsoft                                               
+CHANNEL HISTORY:
+Here is the history to track the agreement between users and admin                                                 
+{channel_history}                                                 
+# Never mention Slack Id in calendar summary or meeting description , always write the Names , dont write this 'This meeting was scheduled by U-------- on Slack'  
+INPUT:
+{input}
+
+AGENT SCRATCHPAD:
+{agent_scratchpad}
+
+OUTPUT:
+Provide a confirmation message after updating, e.g., "Event updated successfully."
+""")
+
+# Delete Event Agent Prompt
+delete_prompt = ChatPromptTemplate.from_template("""
+SYSTEM:
+You are an event deletion assistant. Your task is to help the user cancel an existing calendar event by finding and deleting it, then informing participants.
+CURRENT DATE: {current_date}
+TASK:                                                                                                  
+1. if its admin ({admin}=={user_id}) then only proceed to delete the calendar event                                               
+2. if admin doesnt mention anything about the event name or id , then ask the admin which event from the following you want to delete
+  2.1 Filter all the events and pick those event id from the "{calendar_events}" (Filter out before current date) where user id is "{user_id}" and you can pick the user from user information "{user_information}" and ask admin which one to delete.
+  
+3. If {admin}=={user_id} is asking for an delete then show all the events and ask which one you want to update.
+4. Dont ask from admin ({admin}=={user_id}) to confirm about deleting.                                                                                                                                 5. if you are encountering multiple delete requests in history , consider only one
+6.Pass {admin} to calendar events as user id                                                  
+EVENT DETAILS:
+                                                 
+{event_details}
+
+TARGET USER ID:
+{target_user_id}
+
+TIMEZONE:
+{timezone}
+
+USER ID:
+{user_id}
+
+ADMIN:
+{admin}
+
+
+Team id (if needed)
+{team_id}
+                                                 
+USER INFORMATION:
+{user_information}
+
+CALENDAR TOOL:
+{calendar_tool}
+                                                          
+TOOLS:
+{{tools}}
+- google_update_calendar_event: if calendar is "google"
+- microsoft_calendar_update_event: if calendar is "microsoft                                               
+CHANNEL HISTORY:
+Here is the history to track the agreement between users and admin                                                 
+{channel_history}                                                 
+
+INPUT:
+{input}
+
+AGENT SCRATCHPAD:
+{agent_scratchpad}
+
+OUTPUT:
+Provide a confirmation message after updating, e.g., "Event updated successfully."
+""")
+
+# General Query Prompt (for "other" intent)
+general_prompt = ChatPromptTemplate.from_template("""
+You are a helpful assistant. Provide a polite and informative response to the user's query based on the input and conversation history. Do not use any tools.
+
+User's Request:
+{input}
+
+Conversation History:
+{channel_history}
+
+OUTPUT:
+Generate a clear and polite response.
+""")

requirements.txt

@@ -0,0 +1,20 @@
+python-dotenv
+langchain
+openai
+slack-sdk 
+slack-bolt 
+flask
+langchain-openai
+langchain-google-genai
+python-dotenv
+google-api-python-client 
+google-auth-httplib2 
+google-auth-oauthlib
+langchain_community
+uvicorn[standard]
+pytz
+msal
+flask-session
+apscheduler
+flask-talisman
+psycopg2

services.py

@@ -0,0 +1,218 @@
+# import json
+# import os
+# from typing import Type
+# from dotenv import load_dotenv
+# from langchain.pydantic_v1 import BaseModel, Field
+# from langchain_core.tools import BaseTool
+# from slack_sdk.errors import SlackApiError
+# from datetime import datetime
+# from google_auth_oauthlib.flow import InstalledAppFlow
+# from googleapiclient.discovery import build
+# from google.oauth2.credentials import Credentials
+# from google.auth.transport.requests import Request
+# from config import client
+# SCOPES = ['https://www.googleapis.com/auth/calendar']
+# TOKEN_DIR = "token_files"
+# TOKEN_FILE = f"{TOKEN_DIR}/token.json"
+# def create_service(client_secret_file, api_name, api_version, user_id, *scopes):
+#     """
+#     Create a Google API service instance using stored credentials for a given user.
+    
+#     Parameters:
+#       - client_secret_file (str): Path to your client secrets JSON file.
+#       - api_name (str): The Google API service name (e.g., 'calendar').
+#       - api_version (str): The API version (e.g., 'v3').
+#       - user_id (str): The unique identifier for the user (e.g., Slack user ID).
+#       - scopes (tuple): A tuple/list of scopes. (Pass as: [SCOPES])
+    
+#     Returns:
+#       - service: The built Google API service instance, or None if authentication is required.
+#     """
+#     scopes = list(scopes[0])  # Unpack scopes
+#     creds = None
+#     user_token_file = os.path.join(TOKEN_DIR, f"token.json")
+
+#     if os.path.exists(user_token_file):
+#         try:
+#             creds = Credentials.from_authorized_user_file(user_token_file, scopes)
+#         except ValueError as e:
+#             print(f"Error loading credentials: {e}")
+#             # os.remove(user_token_file)
+#             creds = None
+#         print(creds)
+#     # If credentials are absent or invalid, we cannot proceed.
+#     if not creds or not creds.valid:
+#         if creds and creds.expired and creds.refresh_token:
+#             try:
+#                 creds.refresh(Request())
+#             except Exception as e:
+#                 print(f"Error refreshing token: {e}")
+#                 return None
+#         else:
+#             print("No valid credentials available. Please re-authenticate.")
+#             return None
+
+#         # Save the refreshed token.
+#         with open(user_token_file, 'w') as token_file:
+#             token_file.write(creds.to_json())
+
+#     try:
+#         service = build(api_name, api_version, credentials=creds, static_discovery=False)
+#         return service
+#     except Exception as e:
+#         print(f"Failed to create service instance for {api_name}: {e}")
+#         os.remove(user_token_file)  # Remove the token file if it's causing issues.
+#         return None
+
+# def construct_google_calendar_client(user_id):
+#     """
+#     Constructs a Google Calendar API client for the specified user.
+    
+#     Parameters:
+#       - user_id (str): The unique user identifier (e.g., Slack user ID).
+    
+#     Returns:
+#       - service: The Google Calendar API service instance or None if not authenticated.
+#     """
+#     API_NAME = 'calendar'
+#     API_VERSION = 'v3'
+#     return create_service('credentials.json', API_NAME, API_VERSION, user_id, SCOPES)
+
+
+import json
+import os
+from datetime import datetime
+import psycopg2
+from dotenv import load_dotenv
+from google.oauth2.credentials import Credentials
+from google.auth.transport.requests import Request
+from googleapiclient.discovery import build
+
+# Load environment variables from a .env file
+load_dotenv()
+
+# Database helper functions
+def load_token(team_id, user_id, service):
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute('SELECT token_data FROM Tokens WHERE team_id = %s AND user_id = %s AND service = %s', (team_id, user_id, service))
+    row = cur.fetchone()
+    cur.close()
+    conn.close()
+    print(f"DB ROW: {row[0]}")
+    return json.loads(row[0]) if row else None
+
+def save_token(team_id, user_id, service, token_data):
+    """
+    Save token data to the database for a specific team, user, and service.
+
+    Parameters:
+        team_id (str): The Slack team ID.
+        user_id (str): The Slack user ID.
+        service (str): The service name (e.g., 'google').
+        token_data (dict): The token data to save (e.g., {'access_token', 'refresh_token', 'expires_at'}).
+    """
+    conn = psycopg2.connect(os.getenv('DATABASE_URL'))
+    cur = conn.cursor()
+    cur.execute(
+        '''
+        INSERT INTO Tokens (team_id, user_id, service, token_data, updated_at)
+        VALUES (%s, %s, %s, %s, %s)
+        ON CONFLICT (team_id, user_id, service) 
+        DO UPDATE SET token_data = %s, updated_at = %s
+        ''',
+        (
+            team_id, user_id, service, json.dumps(token_data), datetime.now(),
+            json.dumps(token_data), datetime.now()
+        )
+    )
+    conn.commit()
+    cur.close()
+    conn.close()
+
+def create_service(team_id, user_id, api_name, api_version, scopes):
+    """
+    Create a Google API service instance using stored credentials for a given user.
+
+    Parameters:
+        team_id (str): The Slack team ID.
+        user_id (str): The Slack user ID.
+        api_name (str): The Google API service name (e.g., 'calendar').
+        api_version (str): The API version (e.g., 'v3').
+        scopes (list): List of scopes required for the API.
+
+    Returns:
+        service: The built Google API service instance, or None if authentication fails.
+    """
+    # Load token data from the database
+    token_data = load_token(team_id, user_id, 'google')
+    if not token_data:
+        print(f"No token found for team {team_id}, user {user_id}. Initial authorization required.")
+        return None
+
+    # Fetch client credentials from environment variables
+    client_id = os.getenv('GOOGLE_CLIENT_ID')
+    client_secret = os.getenv('GOOGLE_CLIENT_SECRET')
+    token_uri = os.getenv('GOOGLE_TOKEN_URI', 'https://oauth2.googleapis.com/token')
+
+    if not client_id or not client_secret:
+        print("Google client credentials not found in environment variables.")
+        return None
+
+    # Create Credentials object using token data and client credentials
+    try:
+        creds = Credentials(
+            token=token_data.get('access_token'),
+            refresh_token=token_data.get('refresh_token'),
+            token_uri=token_uri,
+            client_id=client_id,
+            client_secret=client_secret,
+            scopes=scopes
+        )
+    except ValueError as e:
+        print(f"Error creating credentials for user {user_id}: {e}")
+        return None
+
+    # Refresh token if expired
+    if not creds.valid:
+        if creds.expired and creds.refresh_token:
+            try:
+                creds.refresh(Request())
+                # Save refreshed token data to the database
+                refreshed_token_data = {
+                    'access_token': creds.token,
+                    'refresh_token': creds.refresh_token,
+                    'expires_at': creds.expiry.timestamp() if creds.expiry else None
+                }
+                save_token(team_id, user_id, 'google', refreshed_token_data)
+                print(f"Token refreshed for user {user_id}.")
+            except Exception as e:
+                print(f"Error refreshing token for user {user_id}: {e}")
+                return None
+        else:
+            print(f"Credentials invalid and no refresh token available for user {user_id}.")
+            return None
+
+    # Build and return the Google API service
+    try:
+        service = build(api_name, api_version, credentials=creds, static_discovery=False)
+        return service
+    except Exception as e:
+        print(f"Failed to create service instance for {api_name}: {e}")
+        return None
+
+def construct_google_calendar_client(team_id, user_id):
+    """
+    Constructs a Google Calendar API client for the specified user.
+
+    Parameters:
+        team_id (str): The Slack team ID.
+        user_id (str): The Slack user ID.
+
+    Returns:
+        service: The Google Calendar API service instance, or None if not authenticated.
+    """
+    API_NAME = 'calendar'
+    API_VERSION = 'v3'
+    SCOPES = ['https://www.googleapis.com/auth/calendar']
+    return create_service(team_id, user_id, API_NAME, API_VERSION, SCOPES)

utils.py

@@ -0,0 +1,75 @@
+import os
+import requests
+from urllib.parse import quote_plus
+from dotenv import load_dotenv, find_dotenv
+from flask import Flask, redirect, jsonify, request, session, url_for
+
+# Load environment variables from .env file
+load_dotenv(find_dotenv())
+
+app = Flask(__name__)
+app.secret_key = os.urandom(24)  # In production, use a fixed secret key
+
+PORT = 65010
+
+# Zoom OAuth endpoints and configuration
+ZOOM_OAUTH_AUTHORIZE_API = "https://zoom.us/oauth/authorize"
+ZOOM_TOKEN_API = "https://zoom.us/oauth/token"
+
+CLIENT_ID = "FiyFvBUSSeeXwjDv0tqg"
+CLIENT_SECRET = "tygAN91Xd7Wo1YAH056wtbrXQ8I6UieA"
+# Use a consistent environment variable for your redirect URI; fallback to localhost if not set
+REDIRECT_URI = "https://clear-muskox-grand.ngrok-free.app/zoom_callback"
+
+if not CLIENT_ID or not CLIENT_SECRET:
+    raise ValueError("Missing Zoom OAuth credentials. Please set ZOOM_CLIENT_ID and ZOOM_CLIENT_SECRET.")
+
+@app.route("/")
+def index():
+    """Homepage that redirects to the login route."""
+    return redirect(url_for("login"))
+
+@app.route("/login")
+def login():
+    """Initiate the Zoom OAuth flow by redirecting the user to Zoom's authorization page."""
+    # Build the authorization URL with URL-encoded redirect URI
+    auth_url = (
+        f"{ZOOM_OAUTH_AUTHORIZE_API}"
+        f"?response_type=code"
+        f"&client_id={CLIENT_ID}"
+        f"&redirect_uri={quote_plus('https://clear-muskox-grand.ngrok-free.app/zoom_callback')}"
+    )
+    return redirect(auth_url)
+
+@app.route("/zoom_callback")
+def zoom_callback():
+    """Handles the OAuth callback by exchanging the authorization code for an access token."""
+    code = request.args.get("code")
+    if not code:
+        return jsonify({"error": "No authorization code received"}), 400
+
+    # Prepare token request parameters
+    params = {
+        "grant_type": "authorization_code",
+        "code": code,
+        "redirect_uri": REDIRECT_URI
+    }
+
+    try:
+        # Exchange the authorization code for an access token
+        response = requests.post(ZOOM_TOKEN_API, params=params, auth=(CLIENT_ID, CLIENT_SECRET))
+    except Exception as e:
+        return jsonify({"error": f"Token request failed: {str(e)}"}), 500
+
+    if response.status_code == 200:
+        token_data = response.json()
+        # Optionally store tokens in session for later use
+        session["access_token"] = token_data.get("access_token")
+        session["refresh_token"] = token_data.get("refresh_token")
+        # Return the token details as a JSON response
+        return jsonify(token_data)
+    else:
+        return jsonify({"error": "Failed to retrieve token", "details": response.text}), response.status_code
+
+if __name__ == '__main__':
+    app.run(port=PORT)