d

src/Agentic_System/Gmail_Agent.py

@@ -16,12 +16,14 @@ try:
     from .google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         GMAIL_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 except ImportError:
     from google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         GMAIL_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 try:
@@ -150,12 +152,23 @@ class GmailAgent:
                 logger.info("[GMAIL-AGENT] STEP 2 DONE: Got %d Google tools (%.2fs)", len(tools), _time.time() - t2)
                 for i, tool in enumerate(tools):
                     logger.info("[GMAIL-AGENT]   Tool[%d]: %s", i, getattr(tool, 'name', tool))
+                tool_names = {getattr(tool, "name", str(tool)) for tool in tools}
                 if not tools:
                     logger.error("[GMAIL-AGENT] Remote MCP exposed zero Gmail tools")
                     return (
                         "Gmail tools are unavailable because the remote MCP server exposed zero tools. "
                         "This usually means MCP auth is incomplete or the server is not advertising Gmail tools."
                     )
+                if tool_names == {AUTH_BOOTSTRAP_TOOL}:
+                    logger.info("[GMAIL-AGENT] Only auth bootstrap tool exposed; initiating auth flow")
+                    auth_result = await google_mcp.call_tool(
+                        AUTH_BOOTSTRAP_TOOL,
+                        {
+                            "service_name": SERVICE_DISPLAY_MAP["gmail"],
+                            "user_google_email": USER_GOOGLE_EMAIL,
+                        },
+                    )
+                    return str(auth_result)
             except Exception as e:
                 logger.error("[GMAIL-AGENT] STEP 2 FAILED: list_tools error: %s", e, exc_info=True)
 

src/Agentic_System/Google_Calendar_Agent.py

@@ -16,12 +16,14 @@ try:
     from .google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         CALENDAR_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 except ImportError:
     from google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         CALENDAR_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 
@@ -109,12 +111,23 @@ class GoogleCalendarAgent:
             if google_mcp is None:
                 return "Google Calendar tools are currently unavailable because the MCP server is not connected."
             tools = await google_mcp.list_tools()
+            tool_names = {getattr(tool, "name", str(tool)) for tool in tools}
             if not tools:
                 logger.error("Google Calendar MCP exposed zero tools")
                 return (
                     "Google Calendar tools are unavailable because the remote MCP server exposed zero tools. "
                     "This usually means MCP auth is incomplete or the server is not advertising Calendar tools."
                 )
+            if tool_names == {AUTH_BOOTSTRAP_TOOL}:
+                logger.info("Google Calendar MCP only exposed auth bootstrap tool; initiating auth flow")
+                auth_result = await google_mcp.call_tool(
+                    AUTH_BOOTSTRAP_TOOL,
+                    {
+                        "service_name": SERVICE_DISPLAY_MAP["calendar"],
+                        "user_google_email": USER_GOOGLE_EMAIL,
+                    },
+                )
+                return str(auth_result)
             skillport_mcp = await enter_optional_mcp(stack, self._create_skillport_server, "SkillPort Calendar MCP")
             agent = self._create_agent(google_mcp, skillport_mcp)
             logger.info("Google Calendar agent ready with %d MCP server(s)", len(agent.mcp_servers))

src/Agentic_System/Google_Docs_Agent.py

@@ -16,12 +16,14 @@ try:
     from .google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         DOCS_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 except ImportError:
     from google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         DOCS_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 
@@ -107,12 +109,23 @@ class GoogleDocsAgent:
             if google_mcp is None:
                 return "Google Docs tools are currently unavailable because the MCP server is not connected."
             tools = await google_mcp.list_tools()
+            tool_names = {getattr(tool, "name", str(tool)) for tool in tools}
             if not tools:
                 logger.error("Google Docs MCP exposed zero tools")
                 return (
                     "Google Docs tools are unavailable because the remote MCP server exposed zero tools. "
                     "This usually means MCP auth is incomplete or the server is not advertising Docs tools."
                 )
+            if tool_names == {AUTH_BOOTSTRAP_TOOL}:
+                logger.info("Google Docs MCP only exposed auth bootstrap tool; initiating auth flow")
+                auth_result = await google_mcp.call_tool(
+                    AUTH_BOOTSTRAP_TOOL,
+                    {
+                        "service_name": SERVICE_DISPLAY_MAP["docs"],
+                        "user_google_email": USER_GOOGLE_EMAIL,
+                    },
+                )
+                return str(auth_result)
             skillport_mcp = await enter_optional_mcp(stack, self._create_skillport_server, "SkillPort Docs MCP")
             agent = self._create_agent(google_mcp, skillport_mcp)
             logger.info("Google Docs agent ready with %d MCP server(s)", len(agent.mcp_servers))

src/Agentic_System/Google_Drive_Agent.py

@@ -16,12 +16,14 @@ try:
     from .google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         DRIVE_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 except ImportError:
     from google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         DRIVE_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 
@@ -110,12 +112,23 @@ class GoogleDriveAgent:
             if google_mcp is None:
                 return "Google Drive tools are currently unavailable because the MCP server is not connected."
             tools = await google_mcp.list_tools()
+            tool_names = {getattr(tool, "name", str(tool)) for tool in tools}
             if not tools:
                 logger.error("Google Drive MCP exposed zero tools")
                 return (
                     "Google Drive tools are unavailable because the remote MCP server exposed zero tools. "
                     "This usually means MCP auth is incomplete or the server is not advertising Drive tools."
                 )
+            if tool_names == {AUTH_BOOTSTRAP_TOOL}:
+                logger.info("Google Drive MCP only exposed auth bootstrap tool; initiating auth flow")
+                auth_result = await google_mcp.call_tool(
+                    AUTH_BOOTSTRAP_TOOL,
+                    {
+                        "service_name": SERVICE_DISPLAY_MAP["drive"],
+                        "user_google_email": USER_GOOGLE_EMAIL,
+                    },
+                )
+                return str(auth_result)
             skillport_mcp = await enter_optional_mcp(stack, self._create_skillport_server, "SkillPort Drive MCP")
             agent = self._create_agent(google_mcp, skillport_mcp)
             logger.info("Google Drive agent ready with %d MCP server(s)", len(agent.mcp_servers))

src/Agentic_System/Google_Sheet_Agent.py

@@ -16,12 +16,14 @@ try:
     from .google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         SHEETS_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 except ImportError:
     from google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         SHEETS_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 
@@ -104,12 +106,23 @@ class GoogleSheetsAgent:
             if google_mcp is None:
                 return "Google Sheets tools are currently unavailable because the MCP server is not connected."
             tools = await google_mcp.list_tools()
+            tool_names = {getattr(tool, "name", str(tool)) for tool in tools}
             if not tools:
                 logger.error("Google Sheets MCP exposed zero tools")
                 return (
                     "Google Sheets tools are unavailable because the remote MCP server exposed zero tools. "
                     "This usually means MCP auth is incomplete or the server is not advertising Sheets tools."
                 )
+            if tool_names == {AUTH_BOOTSTRAP_TOOL}:
+                logger.info("Google Sheets MCP only exposed auth bootstrap tool; initiating auth flow")
+                auth_result = await google_mcp.call_tool(
+                    AUTH_BOOTSTRAP_TOOL,
+                    {
+                        "service_name": SERVICE_DISPLAY_MAP["sheets"],
+                        "user_google_email": USER_GOOGLE_EMAIL,
+                    },
+                )
+                return str(auth_result)
             skillport_mcp = await enter_optional_mcp(stack, self._create_skillport_server, "SkillPort Sheets MCP")
             agent = self._create_agent(google_mcp, skillport_mcp)
             logger.info("Google Sheets agent ready with %d MCP server(s)", len(agent.mcp_servers))

src/Agentic_System/Google_Slides_Agent.py

@@ -16,12 +16,14 @@ try:
     from .google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         SLIDES_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 except ImportError:
     from google_mcp_config import (
         LONGCAT_API_KEY, LONGCAT_BASE_URL, MODEL_NAME,
         SLIDES_TOOLS, create_google_mcp_server, create_skillport_mcp_server,
+        AUTH_BOOTSTRAP_TOOL, SERVICE_DISPLAY_MAP,
         USER_GOOGLE_EMAIL,
     )
 
@@ -107,12 +109,23 @@ class GoogleSlidesAgent:
             if google_mcp is None:
                 return "Google Slides tools are currently unavailable because the MCP server is not connected."
             tools = await google_mcp.list_tools()
+            tool_names = {getattr(tool, "name", str(tool)) for tool in tools}
             if not tools:
                 logger.error("Google Slides MCP exposed zero tools")
                 return (
                     "Google Slides tools are unavailable because the remote MCP server exposed zero tools. "
                     "This usually means MCP auth is incomplete or the server is not advertising Slides tools."
                 )
+            if tool_names == {AUTH_BOOTSTRAP_TOOL}:
+                logger.info("Google Slides MCP only exposed auth bootstrap tool; initiating auth flow")
+                auth_result = await google_mcp.call_tool(
+                    AUTH_BOOTSTRAP_TOOL,
+                    {
+                        "service_name": SERVICE_DISPLAY_MAP["slides"],
+                        "user_google_email": USER_GOOGLE_EMAIL,
+                    },
+                )
+                return str(auth_result)
             skillport_mcp = await enter_optional_mcp(stack, self._create_skillport_server, "SkillPort Slides MCP")
             agent = self._create_agent(google_mcp, skillport_mcp)
             logger.info("Google Slides agent ready with %d MCP server(s)", len(agent.mcp_servers))

src/Agentic_System/google_mcp_config.py

@@ -90,6 +90,17 @@ SERVICE_MAP = {
     "slides": "slides",
 }
 
+SERVICE_DISPLAY_MAP = {
+    "sheets": "Google Sheets",
+    "docs": "Google Docs",
+    "drive": "Google Drive",
+    "calendar": "Google Calendar",
+    "gmail": "Google Gmail",
+    "slides": "Google Slides",
+}
+
+AUTH_BOOTSTRAP_TOOL = "start_google_auth"
+
 
 # ─── Tool Name Constants Per Service ─────────────────────────────────────────
 # These must match the exact function names registered via @server.tool()
@@ -214,13 +225,14 @@ def create_google_mcp_server(service: str, tool_names: list[str]):
     from agents.mcp import MCPServerStreamableHttp
     from agents.mcp import create_static_tool_filter
 
-    tool_filter = create_static_tool_filter(allowed_tool_names=tool_names)
+    allowed_tool_names = list(dict.fromkeys([*tool_names, AUTH_BOOTSTRAP_TOOL]))
+    tool_filter = create_static_tool_filter(allowed_tool_names=allowed_tool_names)
 
     logger.info("=" * 60)
     logger.info("[MCP-FACTORY] Creating MCPServerStreamableHttp for service: %s", service)
     logger.info("[MCP-FACTORY]   URL         : %s", MCP_SERVER_URL)
     logger.info("[MCP-FACTORY]   Headers set : %s", bool(get_mcp_headers()))
-    logger.info("[MCP-FACTORY]   Tool filter : %s", tool_names)
+    logger.info("[MCP-FACTORY]   Tool filter : %s", allowed_tool_names)
     logger.info("=" * 60)
 
     return MCPServerStreamableHttp(