gabay 0.1.1__tar.gz

gabay-0.1.1/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: gabay
+Version: 0.1.1
+Summary: A self-hosted, Telegram-first AI assistant for productivity.
+Author-email: Gabay Team <hello@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/gabay
+Project-URL: Documentation, https://github.com/yourusername/gabay#readme
+Project-URL: Repository, https://github.com/yourusername/gabay.git
+Project-URL: Issues, https://github.com/yourusername/gabay/issues
+Keywords: telegram,assistant,ai,productivity,self-hosted
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: uvicorn>=0.23.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: python-multipart>=0.0.6
+Requires-Dist: python-telegram-bot>=20.0
+Requires-Dist: telethon>=1.30.0
+Requires-Dist: celery>=5.3.0
+Requires-Dist: redis>=5.0.0
+Requires-Dist: groq>=0.5.0
+Requires-Dist: google-api-python-client>=2.0.0
+Requires-Dist: google-auth-httplib2>=0.1.0
+Requires-Dist: google-auth-oauthlib>=1.0.0
+Requires-Dist: notion-client>=2.2.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: click>=8.0.0
+
+# Gabay AI Assistant
+
+Gabay is a self-hosted, Docker-based AI assistant designed as a Telegram-first productivity tool. It acts as a unified gateway allowing users to manage Gmail, Google Drive, Notion, and Meta (Facebook/Instagram) properties autonomously.
+
+## Features
+
+- **Daily Briefing (`/brief`)**: Scans unread emails and Facebook/Instagram notifications to provide a prioritized, LLM-summarized update.
+- **Content Reading (`/read`)**: Fetches unread emails and recent Notion pages (try "read my emails" or "what's new in Notion?").
+- **Universal Search (`/search`)**: Deep-search across Google Drive and Notion directly from Telegram.
+- **Seamless Saving**: Reply to any file or PDF with `/save` to upload it to Drive or save to Notion.
+- **Agentic Intent**: Leverages Groq (Llama 3) to understand natural language requests.
+
+## Quick Install
+
+Gabay is now available as a Python package. You can install it directly via pip:
+
+```bash
+pip install gabay
+```
+
+Then run the setup wizard:
+```bash
+gabay config
+```
+
+## Setup Instructions (Docker)
+Gabay uses both a **Bot** (commands) and a **Userbot** (acting as you).
+1.  **Bot**: Create a bot via [@BotFather](https://t.me/botfather) to get your `TELEGRAM_BOT_TOKEN`.
+2.  **API Credentials**: Go to [my.telegram.org](https://my.telegram.org/auth), log in, and create an "App" to get your `TELEGRAM_API_ID` and `TELEGRAM_API_HASH`.
+3.  **Phone Number**: Your `TELEGRAM_PHONE` is required to authenticate the Userbot session.
+
+### 2. Google Cloud Setup (Gmail/Drive)
+1.  Go to the [Google Cloud Console](https://console.cloud.google.com/).
+2.  **Enable APIs**: Enable both the **Gmail API** and **Google Drive API**.
+3.  **OAuth Consent Screen**: 
+    - Set up an "External" consent screen.
+    - Under **Test Users**, add your own email address.
+4.  **Create Credentials**: 
+    - Create an **OAuth client ID** (Web application).
+    - Add `http://localhost:8000/auth/google/callback` to **Authorized redirect URIs**.
+5.  Get your **Client ID** and **Client Secret**.
+
+### 3. Notion Setup
+1.  Create an **Internal Integration**: Go to [Notion My Integrations](https://www.notion.com/my-integrations).
+2.  Get your `NOTION_API_KEY`.
+3.  **Share Database**: Open your Notion database, click "..." -> **Connect to**, and find your integration.
+4.  Copy the **Database ID** from the URL (the string after the `/` and before the `?`).
+
+### 4. Environment Variables
+Create a `.env` file in the root directory:
+```env
+# Telegram
+TELEGRAM_BOT_TOKEN="your_token"
+TELEGRAM_API_ID=12345
+TELEGRAM_API_HASH="your_hash"
+TELEGRAM_PHONE="+123456789"
+
+# LLM
+GROQ_API_KEY="your_groq_key"
+
+# Google OAuth
+GOOGLE_CLIENT_ID="your_google_id"
+GOOGLE_CLIENT_SECRET="your_google_secret"
+
+# Notion
+NOTION_API_KEY="your_notion_key"
+NOTION_DATABASE_ID="your_database_id"
+```
+
+### 5. Running and Connecting
+1.  **Start**: `docker-compose up -d --build`
+2.  **Dashboard**: Send `/auth` to your bot on Telegram.
+3.  **Login**: Open the link and click **Connect Account** for each service.
+
+## Use Cases
+- "Give me a briefing on my emails today."
+- "Read my latest Notion notes."
+- "Search for 'Project Alpha' on Drive."
+- "Send an email to john@example.com saying I'll be late."

gabay-0.1.1/README.md

@@ -0,0 +1,79 @@
+# Gabay AI Assistant
+
+Gabay is a self-hosted, Docker-based AI assistant designed as a Telegram-first productivity tool. It acts as a unified gateway allowing users to manage Gmail, Google Drive, Notion, and Meta (Facebook/Instagram) properties autonomously.
+
+## Features
+
+- **Daily Briefing (`/brief`)**: Scans unread emails and Facebook/Instagram notifications to provide a prioritized, LLM-summarized update.
+- **Content Reading (`/read`)**: Fetches unread emails and recent Notion pages (try "read my emails" or "what's new in Notion?").
+- **Universal Search (`/search`)**: Deep-search across Google Drive and Notion directly from Telegram.
+- **Seamless Saving**: Reply to any file or PDF with `/save` to upload it to Drive or save to Notion.
+- **Agentic Intent**: Leverages Groq (Llama 3) to understand natural language requests.
+
+## Quick Install
+
+Gabay is now available as a Python package. You can install it directly via pip:
+
+```bash
+pip install gabay
+```
+
+Then run the setup wizard:
+```bash
+gabay config
+```
+
+## Setup Instructions (Docker)
+Gabay uses both a **Bot** (commands) and a **Userbot** (acting as you).
+1.  **Bot**: Create a bot via [@BotFather](https://t.me/botfather) to get your `TELEGRAM_BOT_TOKEN`.
+2.  **API Credentials**: Go to [my.telegram.org](https://my.telegram.org/auth), log in, and create an "App" to get your `TELEGRAM_API_ID` and `TELEGRAM_API_HASH`.
+3.  **Phone Number**: Your `TELEGRAM_PHONE` is required to authenticate the Userbot session.
+
+### 2. Google Cloud Setup (Gmail/Drive)
+1.  Go to the [Google Cloud Console](https://console.cloud.google.com/).
+2.  **Enable APIs**: Enable both the **Gmail API** and **Google Drive API**.
+3.  **OAuth Consent Screen**: 
+    - Set up an "External" consent screen.
+    - Under **Test Users**, add your own email address.
+4.  **Create Credentials**: 
+    - Create an **OAuth client ID** (Web application).
+    - Add `http://localhost:8000/auth/google/callback` to **Authorized redirect URIs**.
+5.  Get your **Client ID** and **Client Secret**.
+
+### 3. Notion Setup
+1.  Create an **Internal Integration**: Go to [Notion My Integrations](https://www.notion.com/my-integrations).
+2.  Get your `NOTION_API_KEY`.
+3.  **Share Database**: Open your Notion database, click "..." -> **Connect to**, and find your integration.
+4.  Copy the **Database ID** from the URL (the string after the `/` and before the `?`).
+
+### 4. Environment Variables
+Create a `.env` file in the root directory:
+```env
+# Telegram
+TELEGRAM_BOT_TOKEN="your_token"
+TELEGRAM_API_ID=12345
+TELEGRAM_API_HASH="your_hash"
+TELEGRAM_PHONE="+123456789"
+
+# LLM
+GROQ_API_KEY="your_groq_key"
+
+# Google OAuth
+GOOGLE_CLIENT_ID="your_google_id"
+GOOGLE_CLIENT_SECRET="your_google_secret"
+
+# Notion
+NOTION_API_KEY="your_notion_key"
+NOTION_DATABASE_ID="your_database_id"
+```
+
+### 5. Running and Connecting
+1.  **Start**: `docker-compose up -d --build`
+2.  **Dashboard**: Send `/auth` to your bot on Telegram.
+3.  **Login**: Open the link and click **Connect Account** for each service.
+
+## Use Cases
+- "Give me a briefing on my emails today."
+- "Read my latest Notion notes."
+- "Search for 'Project Alpha' on Drive."
+- "Send an email to john@example.com saying I'll be late."

gabay-0.1.1/gabay/__init__.py

@@ -0,0 +1 @@
+# Gabay root package

gabay-0.1.1/gabay/cli.py

@@ -0,0 +1,128 @@
+import click
+import uvicorn
+import asyncio
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+# Add the current directory to sys.path only if running from source
+if (Path.cwd() / "gabay").exists() and (Path.cwd() / "gabay" / "__init__.py").exists():
+    sys.path.insert(0, str(Path.cwd()))
+
+@click.group()
+def cli():
+    """Gabay - Your self-hosted Telegram-first AI assistant."""
+    pass
+
+@cli.command()
+@click.option('--port', default=8000, help='Port to run the API on.')
+@click.option('--host', default='0.0.0.0', help='Host to bind the API to.')
+def api(port, host):
+    """Start the Gabay FastAPI Core Server (OAuth Web UI)."""
+    click.echo(f"Starting Gabay API on {host}:{port}...")
+    uvicorn.run("gabay.core.main:app", host=host, port=port, reload=False)
+
+@cli.command()
+def bot():
+    """Start the Gabay Telegram Bot."""
+    click.echo("Starting Gabay Telegram Bot...")
+    from gabay.core.telegram_bot import get_telegram_app, start_telegram_polling
+    app = get_telegram_app()
+    if app:
+        asyncio.run(start_telegram_polling(app))
+        # start_telegram_polling runs the updater, which blocks until stopped
+        # If it doesn't block (like Application.run_polling() does), we need to keep it alive
+        # Actually in our code, we did updater.start_polling() which is async. We should probably use run_polling
+        # Let's just call app.run_polling() directly
+        app.run_polling()
+
+@cli.command()
+def worker():
+    """Start the Gabay Celery Worker."""
+    click.echo("Starting Gabay Celery Worker...")
+    # Using subprocess to run celery
+    subprocess.run(["celery", "-A", "gabay.worker.celery_app", "worker", "--loglevel=INFO", "-E"])
+
+@cli.command()
+def beat():
+    """Start the Gabay Celery Beat Scheduler."""
+    click.echo("Starting Gabay Celery Beat Scheduler...")
+    subprocess.run(["celery", "-A", "gabay.worker.celery_app", "beat", "--loglevel=INFO"])
+
+@cli.command()
+def all():
+    """Run API, Bot, and Worker concurrently."""
+    click.echo("Starting all Gabay services...")
+    
+    # We use subprocess to launch the other commands
+    processes = []
+    
+    # API
+    processes.append(subprocess.Popen([sys.executable, "-m", "uvicorn", "gabay.core.main:app", "--host", "0.0.0.0", "--port", "8000"]))
+    
+    # Worker
+    processes.append(subprocess.Popen(["celery", "-A", "gabay.worker.celery_app", "worker", "--loglevel=INFO", "-E"]))
+    
+    # Beat
+    processes.append(subprocess.Popen(["celery", "-A", "gabay.worker.celery_app", "beat", "--loglevel=INFO"]))
+    
+    # Bot
+    # We can just run it in the main process, or as another subprocess
+    processes.append(subprocess.Popen([sys.executable, "-c", "from gabay.core.telegram_bot import get_telegram_app; app=get_telegram_app(); app and app.run_polling()"]))
+    
+    try:
+        for p in processes:
+            p.wait()
+    except KeyboardInterrupt:
+        click.echo("Stopping all services...")
+        for p in processes:
+            p.terminate()
+
+@cli.command()
+def config():
+    """Interactive setup for environment variables (.env)."""
+    click.echo("Gabay Configuration Setup")
+    click.echo("This will create or update your local .env file.")
+    
+    from gabay.core.config import save_to_env
+    
+    telegram_bot_token = click.prompt("Telegram Bot Token (from @BotFather)", default="", hide_input=True)
+    if telegram_bot_token:
+        save_to_env("TELEGRAM_BOT_TOKEN", telegram_bot_token)
+        
+    groq_api_key = click.prompt("Groq API Key (for LLM)", default="", hide_input=True)
+    if groq_api_key:
+        save_to_env("GROQ_API_KEY", groq_api_key)
+        
+    google_client_id = click.prompt("Google OAuth Client ID", default="")
+    if google_client_id:
+        save_to_env("GOOGLE_CLIENT_ID", google_client_id)
+        
+    google_client_secret = click.prompt("Google OAuth Client Secret", default="", hide_input=True)
+    if google_client_secret:
+        save_to_env("GOOGLE_CLIENT_SECRET", google_client_secret)
+        
+    click.echo("\n--- Mailbox Credentials (SMTP) ---")
+    smtp_host = click.prompt("SMTP Host (e.g., smtp.gmail.com)", default="smtp.gmail.com")
+    save_to_env("SMTP_HOST", smtp_host)
+    
+    smtp_port = click.prompt("SMTP Port", default=587, type=int)
+    save_to_env("SMTP_PORT", str(smtp_port))
+    
+    smtp_user = click.prompt("SMTP User (your email)", default="")
+    if smtp_user:
+        save_to_env("SMTP_USER", smtp_user)
+        
+    smtp_pass = click.prompt("SMTP Password (App Password)", default="", hide_input=True)
+    if smtp_pass:
+        save_to_env("SMTP_PASSWORD", smtp_pass)
+
+    click.echo("\n--- Region ---")
+    tz = click.prompt("Timezone", default="Asia/Manila")
+    save_to_env("TZ", tz)
+        
+    click.echo("✅ .env file updated successfully!")
+
+if __name__ == '__main__':
+    cli()

gabay-0.1.1/gabay/core/config.py

@@ -0,0 +1,71 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+import os
+import pathlib
+
+class Settings(BaseSettings):
+    telegram_bot_token: str = "TBD"
+    telegram_api_id: int = 0
+    telegram_api_hash: str = ""
+    telegram_phone: str = ""
+    redis_url: str = "redis://localhost:6379/0"
+    log_level: str = "INFO"
+    data_dir: str = "/app/data" # in docker
+    
+    # LLM config
+    groq_api_key: str = ""
+    
+    # Google OAuth
+    google_client_id: str = ""
+    google_client_secret: str = ""
+    
+    # Notion API
+    notion_api_key: str = ""
+    
+    # OAuth Web UI config
+    base_url: str = "http://localhost:8000"
+    
+    # SMTP Email config
+    smtp_host: str = ""
+    smtp_port: int = 587
+    smtp_user: str = ""
+    smtp_password: str = ""
+    
+    # Notion config
+    notion_database_id: str = ""
+
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", arbitrary_types_allowed=True)
+
+# For local development without Docker, use local data folder
+if not os.path.exists("/app/data"):
+    # Running locally
+    import pathlib
+    base_dir = pathlib.Path(__file__).parent.parent
+    local_data_dir = base_dir / "data"
+    local_data_dir.mkdir(exist_ok=True)
+    os.environ["DATA_DIR"] = str(local_data_dir)
+
+settings = Settings()
+
+def save_to_env(key: str, value: str):
+    """Utility to interactively save a new key to the .env file."""
+    env_path = pathlib.Path(".env")
+    if not env_path.exists():
+        env_path.touch()
+        
+    # Read existing lines to avoid duplicates
+    with open(env_path, "r") as f:
+        lines = f.readlines()
+        
+    with open(env_path, "w") as f:
+        key_found = False
+        for line in lines:
+            if line.startswith(f"{key}="):
+                f.write(f"{key}={value}\n")
+                key_found = True
+            else:
+                f.write(line)
+        if not key_found:
+            f.write(f"{key}={value}\n")
+            
+    # Update current runtime settings implicitly (or caller updates it)
+    os.environ[key] = value

gabay-0.1.1/gabay/core/connectors/calendar_api.py

@@ -0,0 +1,79 @@
+import logging
+from datetime import datetime, timezone, timedelta
+from gabay.core.connectors.google_api import get_google_service
+
+logger = logging.getLogger(__name__)
+
+def get_events(user_id: str, time_min: str = None, time_max: str = None) -> list[str]:
+    """Retrieve events from the user's primary Google Calendar within a timeframe."""
+    service = get_google_service(user_id, "calendar", "v3")
+    if not service:
+        return ["Google Calendar is not connected. Please authenticate in the Admin Dashboard."]
+
+    try:
+        now = datetime.now(timezone.utc)
+        
+        if not time_min:
+            start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+            time_min = start.isoformat()
+            
+        if not time_max:
+            end = now.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
+            time_max = end.isoformat()
+
+        events_result = service.events().list(
+            calendarId='primary',
+            timeMin=time_min,
+            timeMax=time_max,
+            maxResults=50,
+            singleEvents=True,
+            orderBy='startTime'
+        ).execute()
+        
+        events = events_result.get('items', [])
+        
+        if not events:
+            return ["You have no events scheduled for this timeframe."]
+            
+        parsed_events = []
+        for event in events:
+            start_time = event['start'].get('dateTime', event['start'].get('date'))
+            # Format time
+            if 'T' in start_time:
+                try:
+                    dt = datetime.fromisoformat(start_time)
+                    start_time = dt.strftime("%b %d, %I:%M %p")
+                except:
+                    pass
+            summary = event.get('summary', 'Untitled Event')
+            parsed_events.append(f"• {start_time}: {summary}")
+            
+        return parsed_events
+    except Exception as e:
+        logger.error(f"Error fetching calendar events: {e}")
+        return [f"Failed to fetch calendar events. Error: {str(e)}"]
+
+def create_event(user_id: str, summary: str, start_time: str, end_time: str) -> str:
+    """Create a new event on the user's primary calendar."""
+    service = get_google_service(user_id, "calendar", "v3")
+    if not service:
+        return "Google Calendar is not connected."
+        
+    try:
+        event = {
+          'summary': summary,
+          'start': {
+            'dateTime': start_time,
+            'timeZone': 'UTC',
+          },
+          'end': {
+            'dateTime': end_time,
+            'timeZone': 'UTC',
+          }
+        }
+
+        event = service.events().insert(calendarId='primary', body=event).execute()
+        return f"Event created: {event.get('htmlLink')}"
+    except Exception as e:
+        logger.error(f"Error creating calendar event: {e}")
+        return f"Failed to create event. Error: {str(e)}"

gabay-0.1.1/gabay/core/connectors/google_api.py

@@ -0,0 +1,180 @@
+import logging
+from googleapiclient.discovery import build
+from google.oauth2.credentials import Credentials
+from google.auth.transport.requests import Request as GoogleRequest
+import json
+from gabay.core.connectors.token_manager import token_manager
+from gabay.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+def get_google_service(user_id: str, service_name: str, version: str):
+    token_data = token_manager.get_token("google", str(user_id))
+    if not token_data:
+        logger.warning(f"No Google token found for user {user_id}")
+        return None
+        
+    logger.debug(f"Getting Google service for user {user_id}. Provider keys: {list(token_data.keys())}")
+    
+    # Inject client credentials if missing from stored token
+    if 'client_id' not in token_data or not token_data['client_id']:
+        token_data['client_id'] = settings.google_client_id
+    if 'client_secret' not in token_data or not token_data['client_secret']:
+        token_data['client_secret'] = settings.google_client_secret
+        
+    creds = Credentials.from_authorized_user_info(token_data)
+    
+    # Check if we need to refresh the token
+    if creds and creds.expired and creds.refresh_token:
+        try:
+            logger.info(f"Refreshing Google token for user {user_id}...")
+            creds.refresh(GoogleRequest())
+            # Save refreshed token back to storage
+            new_token_data = json.loads(creds.to_json())
+            token_manager.save_token("google", user_id, new_token_data)
+        except Exception as e:
+            logger.error(f"Failed to refresh Google token for {user_id}: {e}")
+            # If refresh fails, we might want to notify the user to re-pair
+            return None
+            
+    return build(service_name, version, credentials=creds)
+
+def get_unread_emails(user_id: str) -> list[str]:
+    service = get_google_service(user_id, "gmail", "v1")
+    if not service:
+        return []
+    
+    try:
+        results = service.users().messages().list(userId='me', q='is:unread', maxResults=5).execute()
+        messages = results.get('messages', [])
+        
+        email_summaries = []
+        for msg in messages:
+            m = service.users().messages().get(userId='me', id=msg['id']).execute()
+            # Extract basic info
+            headers = m['payload']['headers']
+            subject = next((h['value'] for h in headers if h['name'] == 'Subject'), "No Subject")
+            sender = next((h['value'] for h in headers if h['name'] == 'From'), "Unknown")
+            email_summaries.append(f"From {sender}: {subject}")
+        return email_summaries
+    except Exception as e:
+        logger.error(f"Gmail error: {e}")
+        return []
+
+def upload_file_to_drive(user_id: str, file_path: str, mime_type: str) -> str:
+    # Minimal implementation for now
+    return "https://drive.google.com/upload/mock"
+
+def search_drive(user_id: str, query: str) -> list[dict]:
+    service = get_google_service(user_id, "drive", "v3")
+    if not service:
+        return []
+    
+    try:
+        q = f"name contains '{query}' or fullText contains '{query}'"
+        results = service.files().list(
+            q=q,
+            spaces='drive',
+            fields='files(id, name, mimeType, webViewLink)',
+            pageSize=5
+        ).execute()
+        
+        files = results.get('files', [])
+        return [{"id": f['id'], "title": f['name'], "mimeType": f.get('mimeType', ''), "link": f.get('webViewLink', '')} for f in files]
+    except Exception as e:
+        logger.error(f"Drive search error: {e}")
+        return []
+
+def send_email(user_id: str, recipient: str, subject: str, body: str) -> str:
+    # Actually most users prefer SMTP for simple sending if they have credentials,
+    # but since this is google_api.py, we could use Gmail API.
+    # For now, let's keep the placeholder or use the logic from worker tasks if it's there.
+    return f"Successfully queued email to {recipient} via Google API."
+
+def share_file(user_id: str, file_id: str) -> str:
+    """Updates file permissions to 'anyone with link can read' and returns the webViewLink."""
+    service = get_google_service(user_id, "drive", "v3")
+    if not service:
+        return {"error": "Not connected to Google Drive."}
+    
+    try:
+        # Create a permission allowing anyone with the link to read
+        body = {
+            'type': 'anyone',
+            'role': 'reader'
+        }
+        service.permissions().create(
+            fileId=file_id,
+            body=body
+        ).execute()
+
+        # Get the webViewLink
+        file_info = service.files().get(fileId=file_id, fields='webViewLink, name').execute()
+        return {"link": file_info['webViewLink'], "name": file_info['name']}
+    except Exception as e:
+        logger.error(f"Error sharing file {file_id}: {e}")
+        return {"error": f"Error sharing file: {e}"}
+
+def download_drive_file(user_id: str, file_id: str, mime_type: str) -> str:
+    """
+    Downloads or exports a file from Google Drive as plain text.
+    Google Docs ('application/vnd.google-apps.document') must be exported.
+    Standard text files ('text/plain') are downloaded directly.
+    """
+    service = get_google_service(user_id, "drive", "v3")
+    if not service:
+        return "Not connected to Google Drive."
+
+    try:
+        if 'application/vnd.google-apps.document' in mime_type:
+            # Export Google Doc to text
+            request = service.files().export_media(fileId=file_id, mimeType='text/plain')
+        elif 'text/' in mime_type or 'application/json' in mime_type or 'application/csv' in mime_type:
+            # Download regular text file
+            request = service.files().get_media(fileId=file_id)
+        elif 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' in mime_type:
+            # Download binary .docx
+            request = service.files().get_media(fileId=file_id)
+        else:
+            return f"Unsupported file type for summarization: {mime_type}"
+
+        from io import BytesIO
+        from googleapiclient.http import MediaIoBaseDownload
+        
+        fh = BytesIO()
+        downloader = MediaIoBaseDownload(fh, request)
+        done = False
+        while done is False:
+            status, done = downloader.next_chunk()
+            
+        file_bytes = fh.getvalue()
+        
+        # Word docx parsing
+        if 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' in mime_type:
+            import zipfile
+            import xml.etree.ElementTree as ET
+            try:
+                with zipfile.ZipFile(BytesIO(file_bytes)) as d:
+                    xml_content = d.read('word/document.xml')
+                    tree = ET.XML(xml_content)
+                    WORD_NAMESPACE = '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}'
+                    PARA = WORD_NAMESPACE + 'p'
+                    TEXT = WORD_NAMESPACE + 't'
+                    
+                    paragraphs = []
+                    for paragraph in tree.iter(PARA):
+                        texts = [node.text for node in paragraph.iter(TEXT) if node.text]
+                        if texts:
+                            paragraphs.append(''.join(texts))
+                    return '\n\n'.join(paragraphs)
+            except Exception as e:
+                logger.error(f"Failed to parse docx: {e}")
+                return f"Error extracting text from DOCX: {e}"
+
+        # Return the decoded text
+        return file_bytes.decode('utf-8')
+        
+    except Exception as e:
+        logger.error(f"Error downloading file {file_id}: {e}")
+        return f"Error downloading file: {e}"
+