workspace-mcp 1.0.0__tar.gz → 1.0.2__tar.gz

workspace_mcp-1.0.2/PKG-INFO

@@ -0,0 +1,422 @@
+Metadata-Version: 2.4
+Name: workspace-mcp
+Version: 1.0.2
+Summary: Comprehensive, highly performant Google Workspace Streamable HTTP & SSE MCP Server for Calendar, Gmail, Docs, Sheets, Slides & Drive
+Author-email: Taylor Wilsdon <taylor@taylorwilsdon.com>
+License: MIT
+Project-URL: Homepage, https://workspacemcp.com
+Project-URL: Repository, https://github.com/taylorwilsdon/google_workspace_mcp
+Project-URL: Documentation, https://github.com/taylorwilsdon/google_workspace_mcp#readme
+Project-URL: Issues, https://github.com/taylorwilsdon/google_workspace_mcp/issues
+Project-URL: Changelog, https://github.com/taylorwilsdon/google_workspace_mcp/releases
+Keywords: mcp,google,workspace,llm,ai,claude,model,context,protocol,server
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: fastmcp>=2.3.3
+Requires-Dist: google-api-python-client>=2.168.0
+Requires-Dist: google-auth-httplib2>=0.2.0
+Requires-Dist: google-auth-oauthlib>=1.2.2
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: tomlkit
+Dynamic: license-file
+
+<div align="center">
+
+# Google Workspace MCP Server <img src="https://github.com/user-attachments/assets/b89524e4-6e6e-49e6-ba77-00d6df0c6e5c" width="80" align="right" />
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.11+](https://img.shields.io/badge/Python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
+[![PyPI](https://img.shields.io/pypi/v/workspace-mcp.svg)](https://pypi.org/project/workspace-mcp/)
+[![UV](https://img.shields.io/badge/Package%20Installer-UV-blueviolet)](https://github.com/astral-sh/uv)
+[![Website](https://img.shields.io/badge/Website-workspacemcp.com-green.svg)](https://workspacemcp.com)
+[![Verified on MseeP](https://mseep.ai/badge.svg)](https://mseep.ai/app/eebbc4a6-0f8c-41b2-ace8-038e5516dba0)
+
+**This is the single most feature-complete Google Workspace MCP server**
+
+*Full natural language control over Google Calendar, Drive, Gmail, Docs, Sheets, Slides, Forms, and Chat through all MCP clients, AI assistants and developer tools*
+
+</div>
+
+<div align="center">
+<a href="https://glama.ai/mcp/servers/@taylorwilsdon/google_workspace_mcp">
+  <img width="195" src="https://glama.ai/mcp/servers/@taylorwilsdon/google_workspace_mcp/badge" alt="Google Workspace Server MCP server" align="center"/>
+</a>
+<a href="https://www.pulsemcp.com/servers/taylorwilsdon-google-workspace">
+<img width="456" src="https://github.com/user-attachments/assets/0794ef1a-dc1c-447d-9661-9c704d7acc9d" align="center"/>
+</a>
+</div>
+
+---
+
+
+**See it in action:**
+<div align="center">
+  <video width="832" src="https://github.com/user-attachments/assets/a342ebb4-1319-4060-a974-39d202329710"></video>
+</div>
+
+---
+
+
+## 🌐 Overview
+
+A production-ready MCP server that integrates all major Google Workspace services with AI assistants. Built with FastMCP for optimal performance, featuring advanced authentication handling, service caching, and streamlined development patterns.
+
+## ✨ Features
+
+- **🔐 Advanced OAuth 2.0**: Secure authentication with automatic token refresh, transport-aware callback handling, session management, and centralized scope management
+- **📅 Google Calendar**: Full calendar management with event CRUD operations
+- **📁 Google Drive**: File operations with native Microsoft Office format support (.docx, .xlsx)
+- **📧 Gmail**: Complete email management with search, send, and draft capabilities
+- **📄 Google Docs**: Document operations including content extraction and creation
+- **📊 Google Sheets**: Comprehensive spreadsheet management with flexible cell operations
+- **🖼️ Google Slides**: Presentation management with slide creation, updates, and content manipulation
+- **📝 Google Forms**: Form creation, retrieval, publish settings, and response management
+- **💬 Google Chat**: Space management and messaging capabilities
+- **🔄 Multiple Transports**: HTTP with SSE fallback, OpenAPI compatibility via `mcpo`
+- **⚡ High Performance**: Service caching, thread-safe sessions, FastMCP integration
+- **🧩 Developer Friendly**: Minimal boilerplate, automatic service injection, centralized configuration
+
+---
+
+## 🚀 Quick Start
+
+### Simplest Start (uvx - Recommended)
+
+Run instantly without installation:
+
+```bash
+# Start the server with all Google Workspace tools
+uvx workspace-mcp
+
+# Start with specific tools only
+uvx workspace-mcp --tools gmail drive calendar
+
+# Start in HTTP mode for debugging
+uvx workspace-mcp --transport streamable-http
+```
+
+*Requires Python 3.11+ and [uvx](https://github.com/astral-sh/uv). The package is available on [PyPI](https://pypi.org/project/workspace-mcp).*
+
+### Development Installation
+
+For development or customization:
+
+```bash
+git clone https://github.com/taylorwilsdon/google_workspace_mcp.git
+cd google_workspace_mcp
+uv run main.py
+```
+
+### Prerequisites
+
+- **Python 3.11+**
+- **[uvx](https://github.com/astral-sh/uv)** (for instant installation) or [uv](https://github.com/astral-sh/uv) (for development)
+- **Google Cloud Project** with OAuth 2.0 credentials
+
+### Configuration
+
+1. **Google Cloud Setup**:
+   - Create OAuth 2.0 credentials (web application) in [Google Cloud Console](https://console.cloud.google.com/)
+   - Enable APIs: Calendar, Drive, Gmail, Docs, Sheets, Slides, Forms, Chat
+   - Download credentials as `client_secret.json` in project root
+     - To use a different location for `client_secret.json`, you can set the `GOOGLE_CLIENT_SECRETS` environment variable with that path
+   - Add redirect URI: `http://localhost:8000/oauth2callback`
+
+2. **Environment**:
+   ```bash
+   export OAUTHLIB_INSECURE_TRANSPORT=1  # Development only
+   ```
+
+3. **Server Configuration**:
+   The server's base URL and port can be customized using environment variables:
+   - `WORKSPACE_MCP_BASE_URI`: Sets the base URI for the server (default: http://localhost). This affects the server_url used for Gemini native function calling and the OAUTH_REDIRECT_URI.
+   - `WORKSPACE_MCP_PORT`: Sets the port the server listens on (default: 8000). This affects the server_url, port, and OAUTH_REDIRECT_URI.
+
+### Start the Server
+
+```bash
+# Default (stdio mode for MCP clients)
+uv run main.py
+
+# HTTP mode (for web interfaces and debugging)
+uv run main.py --transport streamable-http
+
+# Single-user mode (simplified authentication)
+uv run main.py --single-user
+
+# Selective tool registration (only register specific tools)
+uv run main.py --tools gmail drive calendar
+uv run main.py --tools sheets docs
+uv run main.py --single-user --tools gmail  # Can combine with other flags
+
+# Docker
+docker build -t workspace-mcp .
+docker run -p 8000:8000 -v $(pwd):/app workspace-mcp --transport streamable-http
+```
+
+**Available Tools for `--tools` flag**: `gmail`, `drive`, `calendar`, `docs`, `sheets`, `forms`, `chat`
+
+### Connect to Claude Desktop
+
+The server supports two transport modes:
+
+#### Stdio Mode (Default - Recommended for Claude Desktop)
+**Option 1: Auto-install (Recommended)**
+```bash
+python install_claude.py
+```
+
+**Option 2: Manual Configuration**
+1. Open Claude Desktop Settings → Developer → Edit Config
+2. This creates/opens the config file at:
+   - **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+   - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+3. Add the server configuration:
+
+```json
+{
+  "mcpServers": {
+    "google_workspace": {
+      "command": "uvx",
+      "args": ["workspace-mcp"]
+    }
+  }
+}
+```
+
+**Alternative (Development Installation)**:
+```json
+{
+  "mcpServers": {
+    "google_workspace": {
+      "command": "uv",
+      "args": ["run", "main.py"],
+      "cwd": "/path/to/google_workspace_mcp"
+    }
+  }
+}
+```
+
+#### HTTP Mode (For debugging or web interfaces)
+If you need to use HTTP mode with Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "google_workspace": {
+      "command": "npx",
+      "args": ["mcp-remote", "http://localhost:8000/mcp"]
+    }
+  }
+}
+```
+
+*Note: Make sure to start the server with `--transport streamable-http` when using HTTP mode.*
+
+### First-Time Authentication
+
+The server features **transport-aware OAuth callback handling**:
+
+- **Stdio Mode**: Automatically starts a minimal HTTP server on port 8000 for OAuth callbacks
+- **HTTP Mode**: Uses the existing FastAPI server for OAuth callbacks
+- **Same OAuth Flow**: Both modes use `http://localhost:8000/oauth2callback` for consistency
+
+When calling a tool:
+1. Server returns authorization URL
+2. Open URL in browser and authorize
+3. Server handles OAuth callback automatically (on port 8000 in both modes)
+4. Retry the original request
+
+---
+
+## 🧰 Available Tools
+
+> **Note**: All tools support automatic authentication via `@require_google_service()` decorators with 30-minute service caching.
+
+### 📅 Google Calendar ([`calendar_tools.py`](gcalendar/calendar_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `list_calendars` | List accessible calendars |
+| `get_events` | Retrieve events with time range filtering |
+| `create_event` | Create events (all-day or timed) |
+| `modify_event` | Update existing events |
+| `delete_event` | Remove events |
+
+### 📁 Google Drive ([`drive_tools.py`](gdrive/drive_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `search_drive_files` | Search files with query syntax |
+| `get_drive_file_content` | Read file content (supports Office formats) |
+| `list_drive_items` | List folder contents |
+| `create_drive_file` | Create new files |
+
+### 📧 Gmail ([`gmail_tools.py`](gmail/gmail_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `search_gmail_messages` | Search with Gmail operators |
+| `get_gmail_message_content` | Retrieve message content |
+| `send_gmail_message` | Send emails |
+| `draft_gmail_message` | Create drafts |
+
+### 📝 Google Docs ([`docs_tools.py`](gdocs/docs_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `search_docs` | Find documents by name |
+| `get_doc_content` | Extract document text |
+| `list_docs_in_folder` | List docs in folder |
+| `create_doc` | Create new documents |
+
+### 📊 Google Sheets ([`sheets_tools.py`](gsheets/sheets_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `list_spreadsheets` | List accessible spreadsheets |
+| `get_spreadsheet_info` | Get spreadsheet metadata |
+| `read_sheet_values` | Read cell ranges |
+| `modify_sheet_values` | Write/update/clear cells |
+| `create_spreadsheet` | Create new spreadsheets |
+| `create_sheet` | Add sheets to existing files |
+
+### 📝 Google Forms ([`forms_tools.py`](gforms/forms_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `create_form` | Create new forms with title and description |
+| `get_form` | Retrieve form details, questions, and URLs |
+| `set_publish_settings` | Configure form template and authentication settings |
+| `get_form_response` | Get individual form response details |
+| `list_form_responses` | List all responses to a form with pagination |
+
+### 💬 Google Chat ([`chat_tools.py`](gchat/chat_tools.py))
+
+| Tool | Description |
+|------|-------------|
+| `list_spaces` | List chat spaces/rooms |
+| `get_messages` | Retrieve space messages |
+| `send_message` | Send messages to spaces |
+| `search_messages` | Search across chat history |
+
+---
+
+## 🛠️ Development
+
+### Project Structure
+
+```
+google_workspace_mcp/
+├── auth/              # Authentication system with decorators
+├── core/              # MCP server and utilities
+├── g{service}/        # Service-specific tools
+├── main.py            # Server entry point
+├── client_secret.json # OAuth credentials (not committed)
+└── pyproject.toml     # Dependencies
+```
+
+### Adding New Tools
+
+```python
+from auth.service_decorator import require_google_service
+
+@require_google_service("drive", "drive_read")  # Service + scope group
+async def your_new_tool(service, param1: str, param2: int = 10):
+    """Tool description"""
+    # service is automatically injected and cached
+    result = service.files().list().execute()
+    return result  # Return native Python objects
+```
+
+### Architecture Highlights
+
+- **Service Caching**: 30-minute TTL reduces authentication overhead
+- **Scope Management**: Centralized in `SCOPE_GROUPS` for easy maintenance
+- **Error Handling**: Native exceptions instead of manual error construction
+- **Multi-Service Support**: `@require_multiple_services()` for complex tools
+
+---
+
+## 🔒 Security
+
+- **Credentials**: Never commit `client_secret.json` or `.credentials/` directory
+- **OAuth Callback**: Uses `http://localhost:8000/oauth2callback` for development (requires `OAUTHLIB_INSECURE_TRANSPORT=1`)
+- **Transport-Aware Callbacks**: Stdio mode starts a minimal HTTP server only for OAuth, ensuring callbacks work in all modes
+- **Production**: Use HTTPS for callback URIs and configure accordingly
+- **Network Exposure**: Consider authentication when using `mcpo` over networks
+- **Scope Minimization**: Tools request only necessary permissions
+
+---
+
+## 🌐 Integration with Open WebUI
+
+To use this server as a tool provider within Open WebUI:
+
+### 1. Create MCPO Configuration
+
+Create a file named `config.json` with the following structure to have `mcpo` make the streamable HTTP endpoint available as an OpenAPI spec tool:
+
+```json
+{
+  "mcpServers": {
+    "google_workspace": {
+      "type": "streamablehttp",
+      "url": "http://localhost:8000/mcp"
+    }
+  }
+}
+```
+
+### 2. Start the MCPO Server
+
+```bash
+mcpo --port 8001 --config config.json --api-key "your-optional-secret-key"
+```
+
+This command starts the `mcpo` proxy, serving your active (assuming port 8000) Google Workspace MCP on port 8001.
+
+### 3. Configure Open WebUI
+
+1. Navigate to your Open WebUI settings
+2. Go to **"Connections"** → **"Tools"**
+3. Click **"Add Tool"**
+4. Enter the **Server URL**: `http://localhost:8001/google_workspace` (matching the mcpo base URL and server name from config.json)
+5. If you used an `--api-key` with mcpo, enter it as the **API Key**
+6. Save the configuration
+
+The Google Workspace tools should now be available when interacting with models in Open WebUI.
+
+---
+
+## 📄 License
+
+MIT License - see `LICENSE` file for details.
+
+---
+
+<div align="center">
+<img width="810" alt="Gmail Integration" src="https://github.com/user-attachments/assets/656cea40-1f66-40c1-b94c-5a2c900c969d" />
+<img width="810" alt="Calendar Management" src="https://github.com/user-attachments/assets/d3c2a834-fcca-4dc5-8990-6d6dc1d96048" />
+<img width="842" alt="Batch Emails" src="https://github.com/user-attachments/assets/0876c789-7bcc-4414-a144-6c3f0aaffc06" />
+</div>

{workspace_mcp-1.0.0 → workspace_mcp-1.0.2}/README.md

@@ -4,12 +4,14 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/Python-3.11%2B-blue.svg)](https://www.python.org/downloads/)
+[![PyPI](https://img.shields.io/pypi/v/workspace-mcp.svg)](https://pypi.org/project/workspace-mcp/)
 [![UV](https://img.shields.io/badge/Package%20Installer-UV-blueviolet)](https://github.com/astral-sh/uv)
 [![Website](https://img.shields.io/badge/Website-workspacemcp.com-green.svg)](https://workspacemcp.com)
+[![Verified on MseeP](https://mseep.ai/badge.svg)](https://mseep.ai/app/eebbc4a6-0f8c-41b2-ace8-038e5516dba0)
 
-**The world's most feature-complete Google Workspace MCP server**
+**This is the single most feature-complete Google Workspace MCP server**
 
-*Connect MCP Clients, AI assistants and developer tools to Google Calendar, Drive, Gmail, Docs, Sheets, Slides, Forms, and Chat*
+*Full natural language control over Google Calendar, Drive, Gmail, Docs, Sheets, Slides, Forms, and Chat through all MCP clients, AI assistants and developer tools*
 
 </div>
 
@@ -56,13 +58,26 @@ A production-ready MCP server that integrates all major Google Workspace service
 
 ## 🚀 Quick Start
 
-### Prerequisites
+### Simplest Start (uvx - Recommended)
 
-- **Python 3.11+**
-- **[uv](https://github.com/astral-sh/uv)** (recommended) or pip
-- **Google Cloud Project** with OAuth 2.0 credentials
+Run instantly without installation:
+
+```bash
+# Start the server with all Google Workspace tools
+uvx workspace-mcp
+
+# Start with specific tools only
+uvx workspace-mcp --tools gmail drive calendar
 
-### Installation
+# Start in HTTP mode for debugging
+uvx workspace-mcp --transport streamable-http
+```
+
+*Requires Python 3.11+ and [uvx](https://github.com/astral-sh/uv). The package is available on [PyPI](https://pypi.org/project/workspace-mcp).*
+
+### Development Installation
+
+For development or customization:
 
 ```bash
 git clone https://github.com/taylorwilsdon/google_workspace_mcp.git
@@ -70,12 +85,19 @@ cd google_workspace_mcp
 uv run main.py
 ```
 
+### Prerequisites
+
+- **Python 3.11+**
+- **[uvx](https://github.com/astral-sh/uv)** (for instant installation) or [uv](https://github.com/astral-sh/uv) (for development)
+- **Google Cloud Project** with OAuth 2.0 credentials
+
 ### Configuration
 
 1. **Google Cloud Setup**:
    - Create OAuth 2.0 credentials (web application) in [Google Cloud Console](https://console.cloud.google.com/)
    - Enable APIs: Calendar, Drive, Gmail, Docs, Sheets, Slides, Forms, Chat
    - Download credentials as `client_secret.json` in project root
+     - To use a different location for `client_secret.json`, you can set the `GOOGLE_CLIENT_SECRETS` environment variable with that path
    - Add redirect URI: `http://localhost:8000/oauth2callback`
 
 2. **Environment**:
@@ -106,8 +128,8 @@ uv run main.py --tools sheets docs
 uv run main.py --single-user --tools gmail  # Can combine with other flags
 
 # Docker
-docker build -t google-workspace-mcp .
-docker run -p 8000:8000 -v $(pwd):/app google-workspace-mcp --transport streamable-http
+docker build -t workspace-mcp .
+docker run -p 8000:8000 -v $(pwd):/app workspace-mcp --transport streamable-http
 ```
 
 **Available Tools for `--tools` flag**: `gmail`, `drive`, `calendar`, `docs`, `sheets`, `forms`, `chat`
@@ -129,6 +151,18 @@ python install_claude.py
    - **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
 3. Add the server configuration:
 
+```json
+{
+  "mcpServers": {
+    "google_workspace": {
+      "command": "uvx",
+      "args": ["workspace-mcp"]
+    }
+  }
+}
+```
+
+**Alternative (Development Installation)**:
 ```json
 {
   "mcpServers": {

{workspace_mcp-1.0.0 → workspace_mcp-1.0.2}/auth/service_decorator.py

@@ -193,29 +193,37 @@ def require_google_service(
             # Original authentication logic is handled automatically
     """
     def decorator(func: Callable) -> Callable:
+        # Inspect the original function signature
+        original_sig = inspect.signature(func)
+        params = list(original_sig.parameters.values())
+
+        # The decorated function must have 'service' as its first parameter.
+        if not params or params[0].name != 'service':
+            raise TypeError(
+                f"Function '{func.__name__}' decorated with @require_google_service "
+                "must have 'service' as its first parameter."
+            )
+
+        # Create a new signature for the wrapper that excludes the 'service' parameter.
+        # This is the signature that FastMCP will see.
+        wrapper_sig = original_sig.replace(parameters=params[1:])
+
         @wraps(func)
         async def wrapper(*args, **kwargs):
-            # Extract user_google_email from function parameters
-            sig = inspect.signature(func)
-            param_names = list(sig.parameters.keys())
+            # Note: `args` and `kwargs` are now the arguments for the *wrapper*,
+            # which does not include 'service'.
 
-            # Find user_google_email parameter
-            user_google_email = None
-            if 'user_google_email' in kwargs:
-                user_google_email = kwargs['user_google_email']
-            else:
-                # Look for user_google_email in positional args
-                try:
-                    user_email_index = param_names.index('user_google_email')
-                    if user_email_index < len(args):
-                        user_google_email = args[user_email_index]
-                except ValueError:
-                    pass
+            # Extract user_google_email from the arguments passed to the wrapper
+            bound_args = wrapper_sig.bind(*args, **kwargs)
+            bound_args.apply_defaults()
+            user_google_email = bound_args.arguments.get('user_google_email')
 
             if not user_google_email:
-                raise Exception("user_google_email parameter is required but not found")
+                # This should ideally not be reached if 'user_google_email' is a required parameter
+                # in the function signature, but it's a good safeguard.
+                raise Exception("'user_google_email' parameter is required but was not found.")
 
-            # Get service configuration
+            # Get service configuration from the decorator's arguments
             if service_type not in SERVICE_CONFIGS:
                 raise Exception(f"Unknown service type: {service_type}")
 
@@ -226,7 +234,7 @@ def require_google_service(
             # Resolve scopes
             resolved_scopes = _resolve_scopes(scopes)
 
-            # Check cache first if enabled
+            # --- Service Caching and Authentication Logic (largely unchanged) ---
             service = None
             actual_user_email = user_google_email
 
@@ -236,7 +244,6 @@ def require_google_service(
                 if cached_result:
                     service, actual_user_email = cached_result
 
-            # If not cached, authenticate
             if service is None:
                 try:
                     tool_name = func.__name__
@@ -247,30 +254,22 @@ def require_google_service(
                         user_google_email=user_google_email,
                         required_scopes=resolved_scopes,
                     )
-
-                    # Cache the service if caching is enabled
                     if cache_enabled:
                         cache_key = _get_cache_key(user_google_email, service_name, service_version, resolved_scopes)
                         _cache_service(cache_key, service, actual_user_email)
-
                 except GoogleAuthenticationError as e:
                     raise Exception(str(e))
 
-            # Inject service as first parameter
-            if 'service' in param_names:
-                kwargs['service'] = service
-            else:
-                # Insert service as first positional argument
-                args = (service,) + args
-
-            # Call the original function with refresh error handling
+            # --- Call the original function with the service object injected ---
             try:
-                return await func(*args, **kwargs)
+                # Prepend the fetched service object to the original arguments
+                return await func(service, *args, **kwargs)
             except RefreshError as e:
-                # Handle token refresh errors gracefully
                 error_message = _handle_token_refresh_error(e, actual_user_email, service_name)
                 raise Exception(error_message)
 
+        # Set the wrapper's signature to the one without 'service'
+        wrapper.__signature__ = wrapper_sig
         return wrapper
     return decorator
 

{workspace_mcp-1.0.0 → workspace_mcp-1.0.2}/core/server.py

@@ -1,6 +1,6 @@
 import logging
 import os
-from typing import Dict, Any, Optional
+from typing import Optional
 from importlib import metadata
 
 from fastapi import Header
@@ -86,18 +86,17 @@ async def health_check(request: Request):
     """Health check endpoint for container orchestration."""
     from fastapi.responses import JSONResponse
     try:
-        version = metadata.version("google-workspace-mcp")
+        version = metadata.version("workspace-mcp")
     except metadata.PackageNotFoundError:
         version = "dev"
     return JSONResponse({
         "status": "healthy",
-        "service": "google-workspace-mcp",
+        "service": "workspace-mcp",
         "version": version,
         "transport": _current_transport_mode
     })
 
 
-# Register OAuth callback as a custom route
 @server.custom_route("/oauth2callback", methods=["GET"])
 async def oauth2_callback(request: Request) -> HTMLResponse:
     """
@@ -105,8 +104,6 @@ async def oauth2_callback(request: Request) -> HTMLResponse:
     This endpoint exchanges the authorization code for credentials and saves them.
     It then displays a success or error page to the user.
     """
-    # State is used by google-auth-library for CSRF protection and should be present.
-    # We don't need to track it ourselves in this simplified flow.
     state = request.query_params.get("state")
     code = request.query_params.get("code")
     error = request.query_params.get("error")
@@ -122,7 +119,6 @@ async def oauth2_callback(request: Request) -> HTMLResponse:
         return create_error_response(error_message)
 
     try:
-        # Use the centralized CONFIG_CLIENT_SECRETS_PATH
         client_secrets_path = CONFIG_CLIENT_SECRETS_PATH
         if not os.path.exists(client_secrets_path):
             logger.error(f"OAuth client secrets file not found at {client_secrets_path}")
@@ -207,13 +203,10 @@ async def start_google_auth(
     if not ensure_oauth_callback_available(_current_transport_mode, WORKSPACE_MCP_PORT, WORKSPACE_MCP_BASE_URI):
         raise Exception("Failed to start OAuth callback server. Please try again.")
 
-    # Use the centralized start_auth_flow from auth.google_auth
     auth_result = await start_auth_flow(
         mcp_session_id=mcp_session_id,
         user_google_email=user_google_email,
         service_name=service_name,
         redirect_uri=redirect_uri
     )
-
-    # auth_result is now a plain string, not a CallToolResult
     return auth_result