Merge pull request #94 from srijanAtGithub/dev

release v3.0.0 — MCP servers, model upgrades, cost improvements, better tool retrieval and Navigator enhancements

Author: srijanAtGithub

.gitignore

@@ -7,6 +7,7 @@ build/
 dist/
 wheels/
 *.egg-info
+.cache
 
 # Virtual environments
 .venv

Agent/agent.py

@@ -1,12 +1,31 @@
+import os
+import json
+from pathlib import Path
+
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from Auth.swiggy_auth import get_swiggy_token
-from Auth.gmail_auth import get_gmail_token
-from Auth.telegram_auth import get_telegram_config
-from Auth.tavily_auth import get_tavily_config
-from Auth.github_auth import get_github_config
+from Auth.google_auth import get_google_config, auto_auth
 
 from configuration import TELEGRAM_BLACKLIST
 
+import structlog
+log = structlog.get_logger()
+
+SICILY_HOME = Path.home() / ".sicily"
+CONNECTED_PATH = SICILY_HOME / "connected.json"
+
+
+def requires_keys(*keys: str):
+    """
+    Decorator to attach required environment variables to a connector loader.
+    Allows the UI to check for missing keys before attempting to load it.
+    """
+    def decorator(func):
+        func.required_keys = list(keys)
+        return func
+    return decorator
+
+
 async def load_swiggy_tools(tool_manager):
     token = await get_swiggy_token()
 
@@ -33,23 +52,36 @@ async def load_swiggy_tools(tool_manager):
     await tool_manager.register(im_tools, "swiggy-instamart")
 
 
-async def load_gmail_tools(tool_manager):
-    token = await get_gmail_token()
+# async def load_calendar_tools(tool_manager):
+#     """
+#     Local Google Calendar MCP using @cocal/google-calendar-mcp.
+#     Works with normal personal OAuth credentials (no Developer Preview needed).
+#     """
 
-    gmail_client = MultiServerMCPClient({
-        "gmail": {
-            "transport": "streamable_http",
-            "url": "https://gmailmcp.googleapis.com/mcp/v1",
-            "headers": {"Authorization": f"Bearer {token}"},
-        }
-    })
+#     credentials_path = str(SICILY_HOME / "google_credentials.json")
 
-    tools = await gmail_client.get_tools()
-    await tool_manager.register(tools, "gmail")
+#     calendar_client = MultiServerMCPClient({
+#         "calendar": {
+#             "transport": "stdio",
+#             "command": "npx",
+#             "args": ["-y", "@cocal/google-calendar-mcp"],
+#             "env": {
+#                 "GOOGLE_OAUTH_CREDENTIALS": credentials_path,
+#             },
+#         }
+#     })
 
+#     tools = await calendar_client.get_tools()
+#     await tool_manager.register(tools, "calendar")
 
+
+@requires_keys("TELEGRAM_API_ID", "TELEGRAM_API_HASH", "TELEGRAM_SESSION_STRING")
 async def load_telegram_tools(tool_manager):
-    env = await get_telegram_config()
+    env = os.environ.copy()
+    
+    env["TELEGRAM_API_ID"] = os.environ["TELEGRAM_API_ID"]
+    env["TELEGRAM_API_HASH"] = os.environ["TELEGRAM_API_HASH"]
+    env["TELEGRAM_SESSION_STRING"] = os.environ["TELEGRAM_SESSION_STRING"]
 
     telegram_client = MultiServerMCPClient({
         "telegram": {
@@ -70,9 +102,10 @@ async def load_telegram_tools(tool_manager):
     await tool_manager.register(filtered_tools, "telegram")
 
 
+@requires_keys("TAVILY_API_KEY")
 async def load_tavily_tools(tool_manager):
-    env = await get_tavily_config()
-    api_key = env["TAVILY_API_KEY"]
+
+    api_key = os.environ["TAVILY_API_KEY"]
 
     tavily_client = MultiServerMCPClient({
         "tavily": {
@@ -84,9 +117,10 @@ async def load_tavily_tools(tool_manager):
     await tool_manager.register(tools, "tavily")
 
 
+@requires_keys("GITHUB_TOKEN")
 async def load_github_tools(tool_manager):
-    env = await get_github_config()
-    token = env["GITHUB_TOKEN"]
+
+    token = os.environ["GITHUB_TOKEN"]
 
     github_client = MultiServerMCPClient({
         "github": {
@@ -99,13 +133,165 @@ async def load_github_tools(tool_manager):
     await tool_manager.register(tools, "github")
 
 
+@requires_keys("NOTION_TOKEN")
+async def load_notion_tools(tool_manager):
+    env = os.environ.copy()
+    
+    # We already know this exists because the decorator checked!
+    token = os.environ["NOTION_TOKEN"]
+    
+    # Map it to whatever the MCP server expects (passing it as both just to be safe)
+    env["NOTION_TOKEN"] = token
+    env["NOTION_API_KEY"] = token 
+
+    notion_client = MultiServerMCPClient({
+        "notion": {
+            "transport": "stdio",
+            "command": "npx",
+            "args": ["-y", "notion-mcp-server"],
+            "env": env,
+        }
+    })
+
+    tools = await notion_client.get_tools()
+    await tool_manager.register(tools, "notion")
+
+
+@requires_keys("SPOTIFY_CLIENT_ID", "SPOTIFY_CLIENT_SECRET", "SPOTIFY_REDIRECT_URI")
+async def load_spotify_tools(tool_manager):
+    env = os.environ.copy()
+    
+    # Grab them directly; the decorator guarantees they are present
+    env["SPOTIFY_CLIENT_ID"] = os.environ["SPOTIFY_CLIENT_ID"]
+    env["SPOTIFY_CLIENT_SECRET"] = os.environ["SPOTIFY_CLIENT_SECRET"]
+    env["SPOTIFY_REDIRECT_URI"] = os.environ.get("SPOTIFY_REDIRECT_URI", "http://127.0.0.1:8080/callback")
+
+    spotify_client = MultiServerMCPClient({
+        "spotify": {
+            "transport": "stdio",
+            "command": "uvx",
+            "args": [
+                "--python", "3.12",
+                "--from", "git+https://github.com/varunneal/spotify-mcp",
+                "spotify-mcp",
+            ],
+            "env": env,
+        }
+    })
+
+    tools = await spotify_client.get_tools()
+    await tool_manager.register(tools, "spotify")
+
+
+async def load_google_workspace_tools(tool_manager):
+    """
+    Google Workspace MCP (aaronsb) - Gmail, Calendar, Drive, Docs, Sheets, Tasks, Meet
+    Uses high-level tools (manage_email, manage_calendar, etc.)
+    Auth is handled by the package itself via manage_accounts tool.
+
+    On first load, if no account is authenticated, automatically trigger the manage_accounts authenticate flow.
+    """
+
+    client_id, client_secret = await get_google_config()
+
+    workspace_client = MultiServerMCPClient({
+        "google-workspace": {
+            "transport": "stdio",
+            "command": "npx",
+            "args": ["-y", "@aaronsb/google-workspace-mcp"],
+            "env": {
+                "GOOGLE_CLIENT_ID": client_id,
+                "GOOGLE_CLIENT_SECRET": client_secret,
+            },
+        }
+    })
+
+    tools = await workspace_client.get_tools()
+    await tool_manager.register(tools, "google-workspace")
+
+    # Auto-auth if no account is configured
+    await auto_auth(tools)
+
+
+async def load_excalidraw_tools(tool_manager):
+    """
+    Official Excalidraw MCP (remote) via mcp-remote bridge.
+    Works with zero API keys for basic diagram creation.
+    First connect may open a browser if OAuth is required.
+    """
+    excalidraw_client = MultiServerMCPClient({
+        "excalidraw": {
+            "transport": "stdio",
+            "command": "npx",
+            "args": [
+                "-y",
+                "mcp-remote@latest",
+                "https://mcp.excalidraw.com",
+            ],
+        }
+    })
+
+    tools = await excalidraw_client.get_tools()
+    await tool_manager.register(tools, "excalidraw")
+
+
+async def load_canva_tools(tool_manager):
+    """
+    Official Canva remote MCP server.
+    Uses mcp-remote so the OAuth browser flow works reliably.
+    First connect will open a browser for you to authorize Canva.
+    """
+    canva_client = MultiServerMCPClient({
+        "canva": {
+            "transport": "stdio",
+            "command": "npx",
+            "args": [
+                "-y",
+                "mcp-remote@latest",
+                "https://mcp.canva.com/mcp",
+            ],
+        }
+    })
+
+    tools = await canva_client.get_tools()
+    await tool_manager.register(tools, "canva")
+
+
+async def load_linear_tools(tool_manager):
+    """
+    Official Linear remote MCP server.
+    Uses mcp-remote so the OAuth browser flow works reliably.
+    First connect will open a browser for you to authorize Linear.
+    """
+    linear_client = MultiServerMCPClient({
+        "linear": {
+            "transport": "stdio",
+            "command": "npx",
+            "args": [
+                "-y",
+                "mcp-remote@latest",
+                "https://mcp.linear.app/mcp",
+            ],
+        }
+    })
+
+    tools = await linear_client.get_tools()
+    await tool_manager.register(tools, "linear")
+
+
 # Registry of all available connectors — add new ones here
 CONNECTORS = {
-    "swiggy":      load_swiggy_tools,
-    "gmail":       load_gmail_tools,
-    "telegram":    load_telegram_tools,
-    "tavily":      load_tavily_tools,
-    "github":      load_github_tools,
+    "swiggy":           load_swiggy_tools,
+    # "calendar":         load_calendar_tools,
+    "telegram":         load_telegram_tools,
+    "tavily":           load_tavily_tools,
+    "github":           load_github_tools,
+    "notion":           load_notion_tools,
+    "spotify":          load_spotify_tools,
+    "google_workspace": load_google_workspace_tools,
+    "excalidraw":       load_excalidraw_tools,
+    "canva":            load_canva_tools,
+    "linear":           load_linear_tools,
 }
 
 # Some connectors register more than one MCP server under the hood
@@ -127,4 +313,80 @@ def get_connector_servers(name: str) -> list[str]:
 
 def is_connector_loaded(name: str, loaded_servers) -> bool:
     """True if any server belonging to this connector is currently loaded."""
-    return any(server in loaded_servers for server in get_connector_servers(name))
+    return any(server in loaded_servers for server in get_connector_servers(name))
+
+
+# ── Persistence: which connectors the user has turned on ────────────
+#
+# This does NOT persist the actual MCP tool objects/sessions (those are
+# short-lived, carry live tokens/clients and must be re-fetched fresh
+# every process start regardless). It only persists the *set of
+# connector names* the user has previously connected, so we know what
+# to reconnect to automatically on the next boot — instead of coming
+# up with zero tools and silently waiting for the user to notice and
+# re-run every /connect_* command by hand.
+
+def _read_connected() -> set[str]:
+    if not CONNECTED_PATH.exists():
+        return set()
+    try:
+        data = json.loads(CONNECTED_PATH.read_text())
+        return set(data.get("connectors", []))
+    except Exception:
+        log.warning("connected_json_unreadable, treating as empty")
+        return set()
+
+
+def _write_connected(names: set[str]) -> None:
+    CONNECTED_PATH.parent.mkdir(parents=True, exist_ok=True)
+    CONNECTED_PATH.write_text(json.dumps({"connectors": sorted(names)}, indent=2))
+
+
+def mark_connector_connected(name: str) -> None:
+    """Call this right after a connector's load_* function succeeds."""
+    names = _read_connected()
+    if name not in names:
+        names.add(name)
+        _write_connected(names)
+        log.info("connector_marked_persisted", connector=name)
+
+
+def mark_connector_disconnected(name: str) -> None:
+    """Call this from /disconnect_* so we don't try to reconnect it on next boot."""
+    names = _read_connected()
+    if name in names:
+        names.discard(name)
+        _write_connected(names)
+        log.info("connector_unmarked_persisted", connector=name)
+
+
+async def restore_connected_connectors(tool_manager) -> None:
+    """
+    Call this once at startup (after tool_manager exists, before/alongside
+    initialize_agent). Reconnects every connector the user had previously
+    turned on, using the SAME load_* functions /connect_* commands use —
+    so auth/token fetching happens fresh, only the "which ones" list is
+    persisted.
+
+    Best-effort per connector: one connector failing to reconnect (e.g.
+    expired token, MCP server down) must not block the others or crash
+    startup — that would turn "some data reset" into "nothing works".
+    """
+    names = _read_connected()
+    if not names:
+        log.info("no_persisted_connectors_to_restore")
+        return
+
+    for name in sorted(names):
+        loader = CONNECTORS.get(name)
+        if loader is None:
+            log.warning("persisted_connector_unknown_skipping", connector=name)
+            continue
+        try:
+            await loader(tool_manager)
+            log.info("connector_restored", connector=name)
+        except Exception as e:
+            log.warning("connector_restore_failed", connector=name, error=str(e))
+            # Leave it marked as "connected" in connected.json — it was a
+            # transient failure (bad token, MCP server down), not the user
+            # disconnecting it. We'll just retry on the next restart.