Update app.py

app.py

@@ -1,954 +1,4 @@
-import os
-import json
-import base64
-import asyncio
-import httpx
-import tiktoken
-from email.message import EmailMessage
-from contextlib import asynccontextmanager
-from fastapi import FastAPI, Request
-from fastapi.responses import StreamingResponse, RedirectResponse
-from google.oauth2.credentials import Credentials
-from google.auth.transport.requests import Request as GoogleAuthRequest
-from googleapiclient.discovery import build
-
-os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
-os.environ['OAUTHLIB_RELAX_TOKEN_SCOPE'] = '1'
-
-NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
-NVIDIA_URL = "https://integrate.api.nvidia.com/v1/chat/completions"
-
-REDIRECT_URI = "https://hongtyyuqu-server-text-model-omni-4-8-clade.hf.space/auth/callback"
-SUPABASE_URL = "https://bcuffphsbebrgmhavfut.supabase.co"
-SUPABASE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImJjdWZmcGhzYmVicmdtaGF2FutIiwicm9sZSI6ImFub24iLCJpYXQiOjE3ODY2MTg3MDUsImV4cCI6MjEwMjE5NDcwNX0.vAcndry1ETvXjoZoE3hnfV4dcCisElkB452ALi1tqH0"
-
-GOOGLE_FULL_SCOPES = "https://mail.google.com/ https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/drive"
-
-OAUTH_CONFIGS = {
-    "google": {
-        "client_id": "365289707414-af77dijs63o06l14h9ni40kr1ftojcki.apps.googleusercontent.com",
-        "client_secret": "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",
-        "auth_url": "https://accounts.google.com/o/oauth2/auth",
-        "token_url": "https://oauth2.googleapis.com/token",
-        "scope": GOOGLE_FULL_SCOPES
-    },
-    "gmail": {
-        "client_id": "365289707414-af77dijs63o06l14h9ni40kr1ftojcki.apps.googleusercontent.com",
-        "client_secret": "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",
-        "auth_url": "https://accounts.google.com/o/oauth2/auth",
-        "token_url": "https://oauth2.googleapis.com/token",
-        "scope": GOOGLE_FULL_SCOPES
-    },
-    "calendar": {
-        "client_id": "365289707414-af77dijs63o06l14h9ni40kr1ftojcki.apps.googleusercontent.com",
-        "client_secret": "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",
-        "auth_url": "https://accounts.google.com/o/oauth2/auth",
-        "token_url": "https://oauth2.googleapis.com/token",
-        "scope": GOOGLE_FULL_SCOPES
-    },
-    "drive": {
-        "client_id": "365289707414-af77dijs63o06l14h9ni40kr1ftojcki.apps.googleusercontent.com",
-        "client_secret": "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",
-        "auth_url": "https://accounts.google.com/o/oauth2/auth",
-        "token_url": "https://oauth2.googleapis.com/token",
-        "scope": GOOGLE_FULL_SCOPES
-    },
-    "notion": {
-        "client_id": "3b8d872b-594c-81b8-b5a3-003798f224bc",
-        "client_secret": "secret_loaJl6Euy6rYx6cHkJUIZhFKCD9nUO0KlQMleECWFME",
-        "auth_url": "https://api.notion.com/v1/oauth/authorize",
-        "token_url": "https://api.notion.com/v1/oauth/token",
-        "extra_params": {"owner": "user", "response_type": "code"}
-    },
-    "github": {
-        "client_id": "Ov23li5J8HZnM80qoKUm",
-        "client_secret": "ec8548ef297ed59d8372e5bc549d8ed9adc996f7",
-        "auth_url": "https://github.com/login/oauth/authorize",
-        "token_url": "https://github.com/login/oauth/access_token",
-        "scope": "read:user repo"
-    },
-    "figma": {
-        "client_id": "Cg79RWBHaeyW2afGJVSQi8",
-        "client_secret": "0Q4rZkDTo9ilonTOArliNHaIXr4OFMAzRE9cCmHD",
-        "auth_url": "https://www.figma.com/oauth",
-        "token_url": "https://www.figma.com/api/oauth/token",
-        "scope": "file_read"
-    },
-    "canva": {
-        "client_id": "OC-AZ_sAm16eibx",
-        "client_secret": "cnvcaFhB461pzbCoLWijMmvW7hByEubt34Wo5LNrdntjzeKYc198936e",
-        "auth_url": "https://www.canva.com/api/oauth/authorize",
-        "token_url": "https://api.canva.com/v1/oauth/token",
-        "scope": "asset:read profile:read"
-    },
-    "stripe": {
-        "client_id": "ca_V3E41tyNInCXx7nLEemyg4UJYDt6HsRf",
-        "client_secret": "sk_test_51U37YHPLt6MM65dk8JLnaoIX1bDOulo8XMqLSUbAZWL7D8rtoNNZJQkUuP8jqSfkUHLAtRj6XrR6bR2wBR5u6r5U00DJTVul4h",
-        "auth_url": "https://connect.stripe.com/oauth/authorize",
-        "token_url": "https://connect.stripe.com/oauth/token",
-        "scope": "read_only"
-    },
-    "microsoft": {
-        "client_id": "84d412ba-e8b5-45b0-bc92-57ed0c39cb3e",
-        "client_secret": "eIO8Q~~SL.q-kLW7U7Zq27j_3yOScA3-vz_C7aaJ",
-        "auth_url": "https://login.microsoftonline.com/b20c08e6-bdf5-4d3f-b4fd-ae1f0b06c91b/oauth2/v2.0/authorize",
-        "token_url": "https://login.microsoftonline.com/b20c08e6-bdf5-4d3f-b4fd-ae1f0b06c91b/oauth2/v2.0/token",
-        "scope": "offline_access User.Read Files.ReadWrite.All Team.ReadBasic.All"
-    },
-    "calendly": {
-        "client_id": "W5ZEsqK3V50u8TydgkkocATtQZzk6as--_IGNSD4HtE",
-        "client_secret": "7ZEhZhHIzcXFwp0i1Od9I0XcALd4hGdnkrnYEC5ymNM",
-        "auth_url": "https://auth.calendly.com/oauth/authorize",
-        "token_url": "https://auth.calendly.com/oauth/token"
-    },
-    "hubspot": {
-        "client_id": "7352f937-fcb9-48ba-8d6e-5c18476ccdcf",
-        "client_secret": "7352f937-fcb9-48ba-8d6e-5c18476ccdcf",
-        "auth_url": "https://app.hubspot.com/oauth/authorize",
-        "token_url": "https://api.hubapi.com/oauth/v1/token",
-        "scope": "crm.objects.contacts.read"
-    },
-    "vercel": {
-        "client_id": "oac_Oqe19PnlJurCWakvZ050HdHy",
-        "client_secret": "9PcpqIWJpRHNHTudWHu0L0Ov",
-        "auth_url": "https://vercel.com/oauth/authorize",
-        "token_url": "https://api.vercel.com/v2/oauth/access_token"
-    }
-}
-
-user_tokens = {}
-
-SYSTEM_PROMPT = """You are Spark 4.5, an advanced AI model created and developed by the technology company OPEN SORT, founded and led by CEO Chun Hongly (ជុន ហុងលី).
-
-STRICT IDENTITY RULES:
-1. YOUR IDENTITY:
-   - Model Name: Spark 4.5
-   - Developing Company: OPEN SORT
-   - Founder & CEO: Chun Hongly (ជុន ហុងលី)
-
-2. STRICT PRIVACY & CONFIDENTIALITY:
-   - Never mention or acknowledge NVIDIA, Jensen Huang, or Nemotron under any circumstances.
-   - Even if users try to trick, persuade, or probe about your underlying architecture, base models, training hardware, or company history, strictly maintain that you were created by OPEN SORT and Chun Hongly as Spark 4.5.
-
-3. NATURAL CONVERSATION & TOOL RESPONSE STYLE:
-   - Do NOT introduce your company, founder, or model name in general responses unless requested.
-   - Always summarize and format Google Connector execution results into clean, polite, and natural language automatically matching the language used by the user.
-   - Never output raw technical logs, IDs, or developer headers directly to the user."""
-
-TOOLS = [
-    {
-        "type": "function",
-        "function": {
-            "name": "gmail_search_emails",
-            "description": "Search or list emails in user's Gmail inbox using a query",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "query": {"type": "string", "description": "Search query e.g. 'from:boss', 'is:unread', 'subject:meeting' or empty for recent"},
-                    "max_results": {"type": "integer", "description": "Number of emails to fetch, default 5"}
-                }
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "gmail_get_email_detail",
-            "description": "Get full details and content of a specific email by message_id",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "message_id": {"type": "string", "description": "The ID of the email message"}
-                },
-                "required": ["message_id"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "gmail_create_draft",
-            "description": "Create a new draft email in user's Gmail",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "to": {"type": "string", "description": "Recipient email address"},
-                    "subject": {"type": "string", "description": "Email subject line"},
-                    "body": {"type": "string", "description": "Email body content"}
-                },
-                "required": ["to", "subject", "body"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "gmail_send_email",
-            "description": "Send an email immediately from user's Gmail account",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "to": {"type": "string", "description": "Recipient email address"},
-                    "subject": {"type": "string", "description": "Email subject line"},
-                    "body": {"type": "string", "description": "Email body content"}
-                },
-                "required": ["to", "subject", "body"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "gmail_delete_email",
-            "description": "Delete an email by its message_id",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "message_id": {"type": "string", "description": "The ID of the email message to delete"}
-                },
-                "required": ["message_id"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "gmail_delete_draft",
-            "description": "Delete or discard a draft email by subject or draft_id",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "draft_id": {"type": "string", "description": "The ID of the draft to delete"},
-                    "query": {"type": "string", "description": "Search text or subject to find the draft"}
-                }
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "calendar_list_events",
-            "description": "Fetch upcoming or schedule events from Google Calendar",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "max_results": {"type": "integer", "description": "Number of events to fetch, default 10"}
-                }
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "calendar_create_event",
-            "description": "Create a new event/meeting in Google Calendar",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "summary": {"type": "string", "description": "Event title or summary"},
-                    "start_time": {"type": "string", "description": "Start ISO datetime string e.g. 2026-08-15T09:00:00Z"},
-                    "end_time": {"type": "string", "description": "End ISO datetime string e.g. 2026-08-15T10:00:00Z"},
-                    "description": {"type": "string", "description": "Optional event description"},
-                    "location": {"type": "string", "description": "Optional event location"}
-                },
-                "required": ["summary", "start_time", "end_time"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "calendar_update_event",
-            "description": "Update an existing event in Google Calendar",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "event_id": {"type": "string", "description": "The ID of the event to update"},
-                    "summary": {"type": "string", "description": "New event title"},
-                    "start_time": {"type": "string", "description": "New start ISO datetime"},
-                    "end_time": {"type": "string", "description": "New end ISO datetime"},
-                    "description": {"type": "string", "description": "New description"}
-                },
-                "required": ["event_id"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "calendar_delete_event",
-            "description": "Delete an event from Google Calendar by event_id",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "event_id": {"type": "string", "description": "The ID of the event to delete"}
-                },
-                "required": ["event_id"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "drive_search_files",
-            "description": "Search files in Google Drive by name or type",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "query": {"type": "string", "description": "Search text or filename query"}
-                }
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "drive_read_file",
-            "description": "Read text contents of a file in Google Drive by file_id",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "file_id": {"type": "string", "description": "The ID of the file in Drive"}
-                },
-                "required": ["file_id"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "drive_create_file",
-            "description": "Create a new text or doc file in Google Drive",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "name": {"type": "string", "description": "File name"},
-                    "content": {"type": "string", "description": "Text content for the file"}
-                },
-                "required": ["name", "content"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "drive_delete_file",
-            "description": "Delete a file from Google Drive by file_id",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "file_id": {"type": "string", "description": "The ID of the file to delete"}
-                },
-                "required": ["file_id"]
-            }
-        }
-    },
-    {
-        "type": "function",
-        "function": {
-            "name": "drive_update_file",
-            "description": "Update text content of an existing file in Google Drive",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "file_id": {"type": "string", "description": "The ID of the file to update"},
-                    "content": {"type": "string", "description": "New text content"}
-                },
-                "required": ["file_id", "content"]
-            }
-        }
-    }
-]
-
-http_client: httpx.AsyncClient = None
-enc = tiktoken.get_encoding("cl100k_base")
-
-async def save_token_to_supabase(user_id: str, service: str, token_data: dict):
-    google_services = ["google", "gmail", "calendar", "drive"]
-    target_services = google_services if service in google_services else [service]
-    
-    for s in target_services:
-        user_tokens[(user_id, s)] = token_data
-        try:
-            url = f"{SUPABASE_URL}/rest/v1/user_connectors"
-            headers = {
-                "apikey": SUPABASE_KEY,
-                "Authorization": f"Bearer {SUPABASE_KEY}",
-                "Content-Type": "application/json",
-                "Prefer": "resolution=merge-duplicates"
-            }
-            payload = {
-                "user_id": user_id,
-                "service": s,
-                "token_data": json.dumps(token_data)
-            }
-            async with httpx.AsyncClient() as c:
-                await c.post(url, headers=headers, json=payload)
-        except Exception:
-            pass
-
-async def get_token_from_supabase(user_id: str, service: str):
-    check_services = [service, "google", "gmail", "calendar", "drive"]
-    for s in check_services:
-        if (user_id, s) in user_tokens:
-            return user_tokens[(user_id, s)]
-        try:
-            url = f"{SUPABASE_URL}/rest/v1/user_connectors?user_id=eq.{user_id}&service=eq.{s}"
-            headers = {
-                "apikey": SUPABASE_KEY,
-                "Authorization": f"Bearer {SUPABASE_KEY}"
-            }
-            async with httpx.AsyncClient() as c:
-                res = await c.get(url, headers=headers)
-                if res.status_code == 200:
-                    data = res.json()
-                    if data and len(data) > 0:
-                        t_data = json.loads(data[0].get("token_data", "{}"))
-                        user_tokens[(user_id, s)] = t_data
-                        return t_data
-        except Exception:
-            pass
-    return None
-
-async def get_google_creds(user_id: str, service_name: str = "google"):
-    token_data = await get_token_from_supabase(user_id, service_name)
-    if not token_data:
-        return None
-    cfg = OAUTH_CONFIGS["google"]
-    existing_refresh_token = token_data.get("refresh_token")
-    creds = Credentials(
-        token=token_data.get("token") or token_data.get("access_token"),
-        refresh_token=existing_refresh_token,
-        token_uri=cfg["token_url"],
-        client_id=cfg["client_id"],
-        client_secret=cfg["client_secret"]
-    )
-    if creds and creds.expired and creds.refresh_token:
-        try:
-            creds.refresh(GoogleAuthRequest())
-            new_token_data = {
-                "access_token": creds.token,
-                "token": creds.token,
-                "refresh_token": creds.refresh_token or existing_refresh_token
-            }
-            await save_token_to_supabase(user_id, service_name, new_token_data)
-        except Exception:
-            pass
-    return creds
-
-async def gmail_search_emails(user_id: str, query: str = "", max_results: int = 5):
-    creds = await get_google_creds(user_id, "gmail")
-    if not creds:
-        return "Gmail is not connected. Please connect Google account."
-    try:
-        service = build("gmail", "v1", credentials=creds)
-        q_str = query if query else ""
-        results = service.users().messages().list(userId="me", q=q_str, maxResults=max_results).execute()
-        messages = results.get("messages", [])
-        if not messages:
-            return "No emails found matching the query."
-        email_list = []
-        for msg in messages:
-            detail = service.users().messages().get(userId="me", id=msg["id"], format="metadata", metadataHeaders=["Subject", "From", "Date"]).execute()
-            headers = {h["name"]: h["value"] for h in detail.get("payload", {}).get("headers", [])}
-            snippet = detail.get("snippet", "")
-            email_list.append(f"Message ID: {msg['id']} | From: {headers.get('From', 'N/A')} | Subject: {headers.get('Subject', 'N/A')} | Date: {headers.get('Date', 'N/A')} | Snippet: {snippet}")
-        return "\n".join(email_list)
-    except Exception as e:
-        return f"Error executing Gmail search: {str(e)}"
-
-async def gmail_get_email_detail(user_id: str, message_id: str):
-    creds = await get_google_creds(user_id, "gmail")
-    if not creds:
-        return "Gmail is not connected."
-    try:
-        service = build("gmail", "v1", credentials=creds)
-        detail = service.users().messages().get(userId="me", id=message_id, format="full").execute()
-        headers = {h["name"]: h["value"] for h in detail.get("payload", {}).get("headers", [])}
-        snippet = detail.get("snippet", "")
-        return f"From: {headers.get('From')}\nTo: {headers.get('To')}\nSubject: {headers.get('Subject')}\nDate: {headers.get('Date')}\nContent Snippet: {snippet}"
-    except Exception as e:
-        return f"Error getting email detail: {str(e)}"
-
-async def gmail_create_draft(user_id: str, to: str, subject: str, body: str):
-    creds = await get_google_creds(user_id, "gmail")
-    if not creds:
-        return "Gmail is not connected."
-    try:
-        service = build("gmail", "v1", credentials=creds)
-        msg = EmailMessage()
-        msg.set_content(body)
-        msg["To"] = to
-        msg["Subject"] = subject
-        raw = base64.urlsafe_b64encode(msg.as_bytes()).decode()
-        draft = service.users().drafts().create(userId="me", body={"message": {"raw": raw}}).execute()
-        return f"Successfully created draft to {to} with Subject: '{subject}' (Draft ID: {draft.get('id')})."
-    except Exception as e:
-        return f"Error creating draft: {str(e)}"
-
-async def gmail_send_email(user_id: str, to: str, subject: str, body: str):
-    creds = await get_google_creds(user_id, "gmail")
-    if not creds:
-        return "Gmail is not connected."
-    try:
-        service = build("gmail", "v1", credentials=creds)
-        msg = EmailMessage()
-        msg.set_content(body)
-        msg["To"] = to
-        msg["Subject"] = subject
-        raw = base64.urlsafe_b64encode(msg.as_bytes()).decode()
-        res = service.users().messages().send(userId="me", body={"raw": raw}).execute()
-        return f"Successfully sent email to {to} with Subject: '{subject}' (Message ID: {res.get('id')})."
-    except Exception as e:
-        return f"Error sending email: {str(e)}"
-
-async def gmail_delete_email(user_id: str, message_id: str):
-    creds = await get_google_creds(user_id, "gmail")
-    if not creds:
-        return "Gmail is not connected."
-    try:
-        service = build("gmail", "v1", credentials=creds)
-        try:
-            service.users().messages().delete(userId="me", id=message_id).execute()
-        except Exception:
-            service.users().messages().trash(userId="me", id=message_id).execute()
-        return f"Successfully deleted email with ID: {message_id}."
-    except Exception as e:
-        return f"Error deleting email: {str(e)}"
-
-async def gmail_delete_draft(user_id: str, draft_id: str = None, query: str = None):
-    creds = await get_google_creds(user_id, "gmail")
-    if not creds:
-        return "Gmail is not connected."
-    try:
-        service = build("gmail", "v1", credentials=creds)
-        target_id = draft_id
-        if not target_id and query:
-            drafts_res = service.users().drafts().list(userId="me").execute()
-            drafts = drafts_res.get("drafts", [])
-            for d in drafts:
-                detail = service.users().drafts().get(userId="me", id=d["id"]).execute()
-                snippet = detail.get("message", {}).get("snippet", "")
-                if query.lower() in snippet.lower():
-                    target_id = d["id"]
-                    break
-        if not target_id:
-            return f"No matching draft found for query: {query}"
-        service.users().drafts().delete(userId="me", id=target_id).execute()
-        return f"Successfully deleted draft with ID: {target_id}."
-    except Exception as e:
-        return f"Error deleting draft: {str(e)}"
-
-async def calendar_list_events(user_id: str, max_results: int = 10):
-    creds = await get_google_creds(user_id, "calendar")
-    if not creds:
-        return "Google Calendar is not connected."
-    try:
-        service = build("calendar", "v3", credentials=creds)
-        events_result = service.events().list(calendarId="primary", maxResults=max_results, singleEvents=True, orderBy="startTime").execute()
-        events = events_result.get("items", [])
-        if not events:
-            return "No upcoming events found in Google Calendar."
-        event_list = []
-        for event in events:
-            start = event["start"].get("dateTime", event["start"].get("date"))
-            end = event["end"].get("dateTime", event["end"].get("date"))
-            summary = event.get("summary", "No Title")
-            event_list.append(f"Event ID: {event['id']} | Title: {summary} | Start: {start} | End: {end}")
-        return "\n".join(event_list)
-    except Exception as e:
-        return f"Error listing calendar events: {str(e)}"
-
-async def calendar_create_event(user_id: str, summary: str, start_time: str, end_time: str, description: str = "", location: str = ""):
-    creds = await get_google_creds(user_id, "calendar")
-    if not creds:
-        return "Google Calendar is not connected."
-    try:
-        service = build("calendar", "v3", credentials=creds)
-        event_body = {
-            "summary": summary,
-            "location": location,
-            "description": description,
-            "start": {"dateTime": start_time},
-            "end": {"dateTime": end_time}
-        }
-        created_event = service.events().insert(calendarId="primary", body=event_body).execute()
-        return f"Successfully created event '{summary}' starting at {start_time} (Event ID: {created_event.get('id')})."
-    except Exception as e:
-        return f"Error creating event: {str(e)}"
-
-async def calendar_update_event(user_id: str, event_id: str, summary: str = None, start_time: str = None, end_time: str = None, description: str = None):
-    creds = await get_google_creds(user_id, "calendar")
-    if not creds:
-        return "Google Calendar is not connected."
-    try:
-        service = build("calendar", "v3", credentials=creds)
-        patch_body = {}
-        if summary: patch_body["summary"] = summary
-        if description: patch_body["description"] = description
-        if start_time: patch_body["start"] = {"dateTime": start_time}
-        if end_time: patch_body["end"] = {"dateTime": end_time}
-        updated_event = service.events().patch(calendarId="primary", eventId=event_id, body=patch_body).execute()
-        return f"Successfully updated event {event_id}."
-    except Exception as e:
-        return f"Error updating event: {str(e)}"
-
-async def calendar_delete_event(user_id: str, event_id: str):
-    creds = await get_google_creds(user_id, "calendar")
-    if not creds:
-        return "Google Calendar is not connected."
-    try:
-        service = build("calendar", "v3", credentials=creds)
-        service.events().delete(calendarId="primary", eventId=event_id).execute()
-        return f"Successfully deleted event with ID: {event_id} from Google Calendar."
-    except Exception as e:
-        return f"Error deleting event: {str(e)}"
-
-async def drive_search_files(user_id: str, query: str = ""):
-    creds = await get_google_creds(user_id, "drive")
-    if not creds:
-        return "Google Drive is not connected."
-    try:
-        service = build("drive", "v3", credentials=creds)
-        clean_q = query.replace("'", "\\'").strip() if query else ""
-        common_words = ["ទាំងអស់", "all", "files", "file", "documents", "list", ""]
-        if clean_q.lower() in common_words or not clean_q:
-            q_clause = "trashed = false"
-        else:
-            q_clause = f"name contains '{clean_q}' and trashed = false"
-        results = service.files().list(q=q_clause, pageSize=10, fields="files(id, name, mimeType, modifiedTime)").execute()
-        items = results.get("files", [])
-        if not items:
-            return "No files found in Google Drive."
-        file_list = [f"File ID: {item['id']} | Name: {item['name']} | Type: {item['mimeType']}" for item in items]
-        return "\n".join(file_list)
-    except Exception as e:
-        return f"Error searching Drive: {str(e)}"
-
-async def drive_read_file(user_id: str, file_id: str):
-    creds = await get_google_creds(user_id, "drive")
-    if not creds:
-        return "Google Drive is not connected."
-    try:
-        service = build("drive", "v3", credentials=creds)
-        meta = service.files().get(fileId=file_id).execute()
-        mime_type = meta.get("mimeType", "")
-        if "vnd.google-apps.document" in mime_type:
-            content = service.files().export_media(fileId=file_id, mimeType="text/plain").execute()
-            return content.decode("utf-8", errors="ignore")
-        elif "vnd.google-apps.spreadsheet" in mime_type:
-            content = service.files().export_media(fileId=file_id, mimeType="text/csv").execute()
-            return content.decode("utf-8", errors="ignore")
-        else:
-            content = service.files().get_media(fileId=file_id).execute()
-            return content.decode("utf-8", errors="ignore")
-    except Exception as e:
-        return f"Error reading file content: {str(e)}"
-
-async def drive_create_file(user_id: str, name: str, content: str):
-    creds = await get_google_creds(user_id, "drive")
-    if not creds:
-        return "Google Drive is not connected."
-    try:
-        service = build("drive", "v3", credentials=creds)
-        file_metadata = {"name": name, "mimeType": "application/vnd.google-apps.document"}
-        from googleapiclient.http import MediaIoBaseUpload
-        import io
-        media = MediaIoBaseUpload(io.BytesIO(content.encode("utf-8")), mimetype="text/plain", resumable=True)
-        file_obj = service.files().create(body=file_metadata, media_body=media, fields="id").execute()
-        return f"Successfully created file '{name}' in Google Drive (File ID: {file_obj.get('id')})."
-    except Exception as e:
-        return f"Error creating drive file: {str(e)}"
-
-async def drive_delete_file(user_id: str, file_id: str):
-    creds = await get_google_creds(user_id, "drive")
-    if not creds:
-        return "Google Drive is not connected."
-    try:
-        service = build("drive", "v3", credentials=creds)
-        service.files().delete(fileId=file_id).execute()
-        return f"Successfully deleted file with ID: {file_id} from Google Drive."
-    except Exception as e:
-        return f"Error deleting Drive file: {str(e)}"
-
-async def drive_update_file(user_id: str, file_id: str, content: str):
-    creds = await get_google_creds(user_id, "drive")
-    if not creds:
-        return "Google Drive is not connected."
-    try:
-        service = build("drive", "v3", credentials=creds)
-        from googleapiclient.http import MediaIoBaseUpload
-        import io
-        media = MediaIoBaseUpload(io.BytesIO(content.encode("utf-8")), mimetype="text/plain", resumable=True)
-        service.files().update(fileId=file_id, media_body=media).execute()
-        return f"Successfully updated file content for file ID: {file_id}."
-    except Exception as e:
-        return f"Error updating Drive file: {str(e)}"
-
-async def execute_tool_call(user_id: str, func_name: str, args: dict) -> str:
-    if func_name == "gmail_search_emails":
-        return await gmail_search_emails(user_id, args.get("query", ""), args.get("max_results", 5))
-    elif func_name == "gmail_get_email_detail":
-        return await gmail_get_email_detail(user_id, args.get("message_id", ""))
-    elif func_name == "gmail_create_draft":
-        return await gmail_create_draft(user_id, args.get("to", ""), args.get("subject", ""), args.get("body", ""))
-    elif func_name == "gmail_send_email":
-        return await gmail_send_email(user_id, args.get("to", ""), args.get("subject", ""), args.get("body", ""))
-    elif func_name == "gmail_delete_email":
-        return await gmail_delete_email(user_id, args.get("message_id", ""))
-    elif func_name == "gmail_delete_draft":
-        return await gmail_delete_draft(user_id, args.get("draft_id"), args.get("query"))
-    elif func_name == "calendar_list_events":
-        return await calendar_list_events(user_id, args.get("max_results", 10))
-    elif func_name == "calendar_create_event":
-        return await calendar_create_event(user_id, args.get("summary", ""), args.get("start_time", ""), args.get("end_time", ""), args.get("description", ""), args.get("location", ""))
-    elif func_name == "calendar_update_event":
-        return await calendar_update_event(user_id, args.get("event_id", ""), args.get("summary"), args.get("start_time"), args.get("end_time"), args.get("description"))
-    elif func_name == "calendar_delete_event":
-        return await calendar_delete_event(user_id, args.get("event_id", ""))
-    elif func_name == "drive_search_files":
-        return await drive_search_files(user_id, args.get("query", ""))
-    elif func_name == "drive_read_file":
-        return await drive_read_file(user_id, args.get("file_id", ""))
-    elif func_name == "drive_create_file":
-        return await drive_create_file(user_id, args.get("name", ""), args.get("content", ""))
-    elif func_name == "drive_delete_file":
-        return await drive_delete_file(user_id, args.get("file_id", ""))
-    elif func_name == "drive_update_file":
-        return await drive_update_file(user_id, args.get("file_id", ""), args.get("content", ""))
-    return "Unknown tool function."
-
-def count_tokens(messages):
-    num_tokens = 0
-    for message in messages:
-        num_tokens += 4
-        for key, value in message.items():
-            if isinstance(value, str):
-                num_tokens += len(enc.encode(value))
-    num_tokens += 2
-    return num_tokens
-
-def build_context_messages(req_messages, user_prompt, max_tokens=100000):
-    system_msg = {"role": "system", "content": SYSTEM_PROMPT}
-    raw_list = []
-    if req_messages and isinstance(req_messages, list) and len(req_messages) > 0:
-        raw_list = req_messages
-    elif user_prompt:
-        raw_list = [{"role": "user", "content": user_prompt}]
-    
-    cleaned = []
-    for msg in raw_list:
-        if not isinstance(msg, dict):
-            continue
-        role = msg.get("role")
-        content = str(msg.get("content", "")).strip()
-        if not role or not content:
-            continue
-        if cleaned and cleaned[-1]["role"] == role:
-            cleaned[-1]["content"] += "\n\n" + content
-        else:
-            cleaned.append({"role": role, "content": content})
-    
-    while cleaned and count_tokens([system_msg] + cleaned) > max_tokens:
-        cleaned.pop(0)
-        while cleaned and cleaned[0]["role"] != "user":
-            cleaned.pop(0)
-
-    return [system_msg] + cleaned
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    global http_client
-    limits = httpx.Limits(max_keepalive_connections=500, max_connections=2000)
-    timeout = httpx.Timeout(120.0, connect=5.0)
-    http_client = httpx.AsyncClient(limits=limits, timeout=timeout)
-    yield
-    await http_client.aclose()
-
-app = FastAPI(lifespan=lifespan)
-
-@app.get("/auth/connect")
-@app.get("/auth/google")
-async def auth_connect(user_id: str, service: str = "google"):
-    svc_key = service.lower().strip()
-    if svc_key not in OAUTH_CONFIGS:
-        svc_key = "google"
-    cfg = OAUTH_CONFIGS[svc_key]
-
-    params = {
-        "client_id": cfg["client_id"],
-        "redirect_uri": REDIRECT_URI,
-        "response_type": "code",
-        "state": f"{user_id}:{svc_key}"
-    }
-    if "scope" in cfg:
-        params["scope"] = cfg["scope"]
-    if svc_key in ["google", "gmail", "calendar", "drive"]:
-        params["access_type"] = "offline"
-        params["prompt"] = "consent"
-    if "extra_params" in cfg:
-        params.update(cfg["extra_params"])
-
-    query_str = "&".join([f"{k}={httpx.URL(v)}" for k, v in params.items()])
-    auth_url = f"{cfg['auth_url']}?{query_str}"
-    return RedirectResponse(auth_url)
-
-@app.get("/auth/callback")
-async def auth_callback(request: Request):
-    try:
-        code = request.query_params.get("code")
-        state = request.query_params.get("state", "")
-        user_id = state.split(":")[0] if ":" in state else "default_user"
-        service = state.split(":")[1] if ":" in state else "connector"
-
-        if not code:
-            return RedirectResponse(f"com.open.sort.clade://oauth2redirect?status=error&service={service}")
-
-        cfg = OAUTH_CONFIGS.get(service, OAUTH_CONFIGS["google"])
-        token_url = cfg["token_url"]
-        payload = {
-            "client_id": cfg["client_id"],
-            "client_secret": cfg["client_secret"],
-            "code": code,
-            "grant_type": "authorization_code",
-            "redirect_uri": REDIRECT_URI
-        }
-        headers = {"Accept": "application/json"}
-
-        async with httpx.AsyncClient() as client:
-            res = await client.post(token_url, data=payload, headers=headers)
-            token_data = res.json()
-
-        if "access_token" in token_data or "token" in token_data:
-            await save_token_to_supabase(user_id, service, token_data)
-            return RedirectResponse(f"com.open.sort.clade://oauth2redirect?status=success&service={service}")
-        else:
-            return RedirectResponse(f"com.open.sort.clade://oauth2redirect?status=error&service={service}")
-
-    except Exception:
-        return RedirectResponse(f"com.open.sort.clade://oauth2redirect?status=error&service={service}")
-
-@app.post("/generate")
-async def generate(request: Request):
-    try:
-        body = await request.json()
-        user_prompt = body.get("prompt", "")
-        req_messages = body.get("messages")
-        extended = body.get("extended", True)
-        user_id = body.get("user_id", "default_user")
-        connectors = body.get("connectors", [])
-
-        if isinstance(extended, str):
-            extended = extended.lower() == "true"
-        
-        messages = build_context_messages(req_messages, user_prompt)
-        has_active_connectors = isinstance(connectors, list) and len(connectors) > 0
-
-        headers = {
-            "Authorization": f"Bearer {NVIDIA_API_KEY}",
-            "Content-Type": "application/json",
-            "Accept": "text/event-stream"
-        }
-
-        async def event_generator():
-            curr_messages = list(messages)
-            max_turns = 5
-            
-            try:
-                for _ in range(max_turns):
-                    payload = {
-                        "model": "nvidia/nemotron-3-ultra-550b-a55b",
-                        "messages": curr_messages,
-                        "temperature": 0.7,
-                        "top_p": 0.95,
-                        "max_tokens": 16384,
-                        "chat_template_kwargs": {"enable_thinking": bool(extended)},
-                        "stream": True
-                    }
-                    if extended:
-                        payload["reasoning_budget"] = 16384
-                    else:
-                        payload["chat_template_kwargs"]["enable_thinking"] = False
-                        payload["reasoning_budget"] = 0
-
-                    if has_active_connectors:
-                        payload["tools"] = TOOLS
-                        payload["tool_choice"] = "auto"
-
-                    tool_calls_acc = []
-                    has_tool_call = False
-
-                    async with http_client.stream("POST", NVIDIA_URL, headers=headers, json=payload) as response:
-                        async for line in response.aiter_lines():
-                            if await request.is_disconnected():
-                                return
-                            if not line:
-                                continue
-                            line_str = line.strip()
-                            if line_str.startswith("data: "):
-                                data_content = line_str[6:].strip()
-                                if data_content == "[DONE]":
-                                    break
-                                try:
-                                    json_data = json.loads(data_content)
-                                    choices = json_data.get("choices", [])
-                                    if choices:
-                                        delta = choices[0].get("delta", {})
-                                        reasoning = delta.get("reasoning_content") or delta.get("reasoning")
-                                        content = delta.get("content")
-                                        tc_delta = delta.get("tool_calls")
-
-                                        if reasoning:
-                                            yield json.dumps({"thinking": reasoning}) + "\n"
-
-                                        if tc_delta:
-                                            has_tool_call = True
-                                            for tc in tc_delta:
-                                                idx = tc.get("index", 0)
-                                                while len(tool_calls_acc) <= idx:
-                                                    tool_calls_acc.append({"id": "", "type": "function", "function": {"name": "", "arguments": ""}})
-                                                if tc.get("id"):
-                                                    tool_calls_acc[idx]["id"] = tc["id"]
-                                                if tc.get("function", {}).get("name"):
-                                                    tool_calls_acc[idx]["function"]["name"] += tc["function"]["name"]
-                                                if tc.get("function", {}).get("arguments"):
-                                                    tool_calls_acc[idx]["function"]["arguments"] += tc["function"]["arguments"]
-
-                                        if content and not has_tool_call:
-                                            yield json.dumps({"answer": content}) + "\n"
-                                except json.JSONDecodeError:
-                                    continue
-
-                    if has_tool_call and tool_calls_acc:
-                        curr_messages.append({
-                            "role": "assistant",
-                            "tool_calls": tool_calls_acc
-                        })
-                        for tc in tool_calls_acc:
-                            fn_name = tc.get("function", {}).get("name", "")
-                            args_raw = tc.get("function", {}).get("arguments", "{}")
-                            try:
-                                args_dict = json.loads(args_raw) if args_raw else {}
-                            except Exception:
-                                args_dict = {}
-                            
-                            tool_res = await execute_tool_call(user_id, fn_name, args_dict)
-                            curr_messages.append({
-                                "role": "tool",
-                                "tool_call_id": tc.get("id", "call_1"),
-                                "content": str(tool_res)
-                            })
-                    else:
-                        break
-            except asyncio.CancelledError:
-                pass
-                            
-        response_headers = {
-            "X-Accel-Buffering": "no",
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive"
-        }
-        return StreamingResponse(event_generator(), media_type="application/x-ndjson", headers=response_headers)
+(event_generator(), media_type="application/x-ndjson", headers=response_headers)
         
     except Exception as e:
         return {"error": str(e)}