decodingtrust-agent-sdk 0.1.0__py3-none-any.whl

dt_arena/mcp_server/google_form/main.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+Local Google Form MCP server
+- Controls the dockerized Google-Form environment at dt_arena/envs/google-form
+- Exposes tools to read/update form schema and list/submit/clear submissions
+"""
+import os
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import httpx
+from fastmcp import FastMCP
+
+FORM_API_BASE = os.getenv("FORM_API_BASE", "http://127.0.0.1:8054").rstrip("/")
+# Default schema path relative to this file's location
+_default_schema = Path(__file__).resolve().parent.parent.parent / "envs" / "google-form" / "schemas" / "schema.json"
+# Handle empty SCHEMA_PATH env var by using default
+_schema_env = os.getenv("SCHEMA_PATH", "").strip()
+SCHEMA_PATH = Path(_schema_env) if _schema_env else _default_schema
+
+mcp = FastMCP("Local Google Form")
+
+_client: Optional[httpx.AsyncClient] = None
+
+
+async def get_http() -> httpx.AsyncClient:
+    global _client
+    if _client is None:
+        _client = httpx.AsyncClient(timeout=20.0)
+    return _client
+
+
+def _read_schema_file() -> Dict[str, Any]:
+    if not SCHEMA_PATH.exists():
+        raise FileNotFoundError(f"Schema not found at {SCHEMA_PATH}")
+    return json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
+
+
+def _write_schema_file(data: Dict[str, Any]) -> None:
+    SCHEMA_PATH.parent.mkdir(parents=True, exist_ok=True)
+    SCHEMA_PATH.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+@mcp.tool()
+async def get_form() -> str:
+    """Get current form schema (via API if available, else read file)."""
+    try:
+        client = await get_http()
+        r = await client.get(f"{FORM_API_BASE}/form")
+        if r.status_code == 200:
+            return json.dumps(r.json(), ensure_ascii=False, indent=2)
+    except Exception:
+        pass
+    # Fallback to file
+    try:
+        return json.dumps(_read_schema_file(), ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+@mcp.tool()
+async def set_form(schema_json: str) -> str:
+    """Replace schema.json with provided JSON string (pretty-printed)."""
+    try:
+        data = json.loads(schema_json)
+        if not isinstance(data, dict):
+            return json.dumps({"error": "schema must be a JSON object"})
+        _write_schema_file(data)
+        return json.dumps({"ok": True, "schema_path": str(SCHEMA_PATH)})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+@mcp.tool()
+async def list_submissions(limit: int = 100) -> str:
+    """List recent submissions from API. Returns up to 'limit' rows."""
+    try:
+        client = await get_http()
+        r = await client.get(f"{FORM_API_BASE}/submissions")
+        if r.status_code != 200:
+            return json.dumps({"error": f"HTTP {r.status_code}: {r.text}"})
+        rows = r.json() or []
+        return json.dumps(rows[: max(1, min(2000, limit))], ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+@mcp.tool()
+async def submit(payload_json: str) -> str:
+    """Submit a response to the form. payload_json should be a JSON object of field->value."""
+    try:
+        payload = json.loads(payload_json or "{}")
+        if not isinstance(payload, dict):
+            return json.dumps({"error": "payload must be a JSON object"})
+        client = await get_http()
+        r = await client.post(f"{FORM_API_BASE}/submit", json=payload)
+        if r.status_code != 200:
+            return json.dumps({"error": f"HTTP {r.status_code}: {r.text}"})
+        return json.dumps(r.json(), ensure_ascii=False)
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+@mcp.tool()
+async def clear_submissions() -> str:
+    """Clear local submissions by truncating the submissions.jsonl file."""
+    try:
+        # submissions are stored at /app/data in container; API doesn't expose clear.
+        # We'll use a local file path if mounted; otherwise, emulate by rewriting an empty file in schema folder's sibling 'server/data'
+        # Heuristic local path:
+        possible_paths = [
+            Path("/scratch/czr/thb/DecodingTrust-Agent/dt_arena/envs/google-form/server/data/submissions.jsonl"),
+            Path.cwd() / "server" / "data" / "submissions.jsonl",
+        ]
+        cleared = []
+        for p in possible_paths:
+            try:
+                p.parent.mkdir(parents=True, exist_ok=True)
+                p.write_text("", encoding="utf-8")
+                cleared.append(str(p))
+            except Exception:
+                continue
+        return json.dumps({"ok": True, "paths": cleared})
+    except Exception as e:
+        return json.dumps({"error": str(e)})
+
+
+def main() -> None:
+    import sys
+    print("Starting Local Google Form MCP server…", file=sys.stderr)
+    host = os.getenv("GF_MCP_HOST", "localhost")
+    port_str = os.getenv("PORT", "").strip()
+    port = int(port_str) if port_str else 8855
+    mcp.run(transport="http", host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()
+
+

dt_arena/mcp_server/googledocs/main.py

@@ -0,0 +1,458 @@
+"""
+Google Docs MCP Server - thin client that proxies to the Google Docs ENV API.
+Independent environment with its own PostgreSQL + FastAPI backend.
+"""
+import os
+import sys
+import asyncio
+from typing import Any, Dict, List, Optional
+
+from fastmcp import FastMCP
+import httpx
+
+
+API_URL = os.getenv("GOOGLEDOCS_API_URL", "http://127.0.0.1:8866")
+USER_ACCESS_TOKEN = os.getenv("GOOGLEDOCS_USER_ACCESS_TOKEN", "")
+
+
+async def _api_call(name: str, arguments: Dict[str, Any]) -> Any:
+    """Call the Google Docs ENV API with retry for cold-start tolerance."""
+    last_exc: Optional[Exception] = None
+    for attempt in range(1, 11):
+        try:
+            async with httpx.AsyncClient(timeout=20) as client:
+                args = dict(arguments or {})
+                token = os.getenv("GOOGLEDOCS_USER_ACCESS_TOKEN", USER_ACCESS_TOKEN)
+                headers = {"Authorization": f"Bearer {token}"} if token else {}
+                resp = await client.post(
+                    f"{API_URL}/tools/call",
+                    json={"name": name, "arguments": args},
+                    headers=headers,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+                return data.get("result")
+        except Exception as e:
+            last_exc = e
+            await asyncio.sleep(min(0.5 * attempt, 3.0))
+    raise RuntimeError(f"ENV API call failed after retries: {last_exc}")
+
+
+mcp = FastMCP("Google Docs MCP Server")
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Document Management
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def create_document(title: str = "Untitled document", content: str = "", 
+                          folder_id: Optional[str] = None) -> Dict[str, Any]:
+    """Create a new Google Docs document.
+
+    Args:
+        title: Document title (default: "Untitled document")
+        content: Initial plain text content
+        folder_id: Optional folder to create document in
+    """
+    return await _api_call("create_document", {"title": title, "content": content, "folder_id": folder_id})
+
+
+@mcp.tool()
+async def get_document(document_id: str) -> Dict[str, Any]:
+    """Get a document by ID, including its full content.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+    """
+    return await _api_call("get_document", {"document_id": document_id})
+
+
+@mcp.tool()
+async def update_document(document_id: str, title: Optional[str] = None, 
+                          content: Optional[str] = None, starred: Optional[bool] = None) -> Dict[str, Any]:
+    """Update a document's title, content, or starred status.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        title: New title
+        content: New plain text content (replaces existing)
+        starred: Star/unstar the document
+    """
+    args = {"document_id": document_id}
+    if title is not None:
+        args["title"] = title
+    if content is not None:
+        args["content"] = content
+    if starred is not None:
+        args["starred"] = starred
+    return await _api_call("update_document", args)
+
+
+@mcp.tool()
+async def delete_document(document_id: str, permanent: bool = False) -> Dict[str, Any]:
+    """Move document to trash or permanently delete it.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        permanent: If True, permanently delete; if False, move to trash
+    """
+    return await _api_call("delete_document", {"document_id": document_id, "permanent": permanent})
+
+
+@mcp.tool()
+async def restore_document(document_id: str) -> Dict[str, Any]:
+    """Restore a document from trash.
+
+    Args:
+        document_id: The trashed document identifier (REQUIRED)
+    """
+    return await _api_call("restore_document", {"document_id": document_id})
+
+
+@mcp.tool()
+async def list_documents(limit: int = 50, offset: int = 0, folder_id: Optional[str] = None,
+                         starred: Optional[bool] = None, trashed: bool = False) -> Dict[str, Any]:
+    """List documents accessible to the user.
+
+    Args:
+        limit: Maximum number of documents to return (default 50)
+        offset: Pagination offset
+        folder_id: Filter by folder
+        starred: Filter by starred status
+        trashed: If True, list trashed documents
+    """
+    return await _api_call("list_documents", {
+        "limit": limit, "offset": offset, "folder_id": folder_id, 
+        "starred": starred, "trashed": trashed
+    })
+
+
+@mcp.tool()
+async def search_documents(query: str, limit: int = 50) -> Dict[str, Any]:
+    """Search documents by title or content.
+
+    Args:
+        query: Search term (REQUIRED)
+        limit: Maximum results
+    """
+    return await _api_call("search_documents", {"query": query, "limit": limit})
+
+
+@mcp.tool()
+async def get_recent_documents(limit: int = 20) -> Dict[str, Any]:
+    """Get recently accessed documents.
+
+    Args:
+        limit: Maximum number of documents (default 20)
+    """
+    return await _api_call("get_recent_documents", {"limit": limit})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Sharing
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def share_document(document_id: str, email: str, 
+                         permission: str = "viewer") -> Dict[str, Any]:
+    """Share a document with another user.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        email: Email address of the user to share with (REQUIRED)
+        permission: Permission level - 'viewer', 'commenter', or 'editor' (default: viewer)
+    """
+    return await _api_call("share_document", {
+        "document_id": document_id, "email": email, "permission": permission
+    })
+
+
+@mcp.tool()
+async def update_share(share_id: str, permission: str) -> Dict[str, Any]:
+    """Update sharing permission for a user.
+
+    Args:
+        share_id: The share identifier (REQUIRED)
+        permission: New permission level - 'viewer', 'commenter', or 'editor' (REQUIRED)
+    """
+    return await _api_call("update_share", {"share_id": share_id, "permission": permission})
+
+
+@mcp.tool()
+async def remove_share(share_id: str) -> Dict[str, Any]:
+    """Remove a user's access to a document.
+
+    Args:
+        share_id: The share identifier (REQUIRED)
+    """
+    return await _api_call("remove_share", {"share_id": share_id})
+
+
+@mcp.tool()
+async def get_document_shares(document_id: str) -> Dict[str, Any]:
+    """Get all users a document is shared with.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+    """
+    return await _api_call("get_document_shares", {"document_id": document_id})
+
+
+@mcp.tool()
+async def enable_link_sharing(document_id: str, permission: str = "viewer") -> Dict[str, Any]:
+    """Enable link sharing for a document (anyone with link can access).
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        permission: Permission for link access - 'viewer', 'commenter', or 'editor'
+    """
+    return await _api_call("enable_link_sharing", {"document_id": document_id, "permission": permission})
+
+
+@mcp.tool()
+async def disable_link_sharing(document_id: str) -> Dict[str, Any]:
+    """Disable link sharing for a document.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+    """
+    return await _api_call("disable_link_sharing", {"document_id": document_id})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Comments
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def add_comment(document_id: str, content: str, quoted_text: Optional[str] = None,
+                      selection_start: Optional[int] = None, selection_end: Optional[int] = None,
+                      parent_id: Optional[str] = None) -> Dict[str, Any]:
+    """Add a comment to a document.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        content: Comment text (REQUIRED)
+        quoted_text: Text being commented on
+        selection_start: Start position of selection
+        selection_end: End position of selection
+        parent_id: Parent comment ID for replies
+    """
+    return await _api_call("add_comment", {
+        "document_id": document_id, "content": content, "quoted_text": quoted_text,
+        "selection_start": selection_start, "selection_end": selection_end, "parent_id": parent_id
+    })
+
+
+@mcp.tool()
+async def get_comments(document_id: str, include_resolved: bool = False) -> Dict[str, Any]:
+    """Get all comments on a document.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        include_resolved: Include resolved comments (default: False)
+    """
+    return await _api_call("get_comments", {"document_id": document_id, "include_resolved": include_resolved})
+
+
+@mcp.tool()
+async def resolve_comment(comment_id: str) -> Dict[str, Any]:
+    """Mark a comment as resolved.
+
+    Args:
+        comment_id: The comment identifier (REQUIRED)
+    """
+    return await _api_call("resolve_comment", {"comment_id": comment_id})
+
+
+@mcp.tool()
+async def delete_comment(comment_id: str) -> Dict[str, Any]:
+    """Delete a comment.
+
+    Args:
+        comment_id: The comment identifier (REQUIRED)
+    """
+    return await _api_call("delete_comment", {"comment_id": comment_id})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Version History
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def create_version(document_id: str, version_name: Optional[str] = None) -> Dict[str, Any]:
+    """Create a named version (snapshot) of the document.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        version_name: Optional name for this version
+    """
+    return await _api_call("create_version", {"document_id": document_id, "version_name": version_name})
+
+
+@mcp.tool()
+async def list_versions(document_id: str) -> Dict[str, Any]:
+    """List all versions of a document.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+    """
+    return await _api_call("list_versions", {"document_id": document_id})
+
+
+@mcp.tool()
+async def restore_version(document_id: str, version_id: str) -> Dict[str, Any]:
+    """Restore document to a previous version.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        version_id: The version identifier (REQUIRED)
+    """
+    return await _api_call("restore_version", {"document_id": document_id, "version_id": version_id})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Folders
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def create_folder(name: str, parent_id: Optional[str] = None, 
+                        color: Optional[str] = None) -> Dict[str, Any]:
+    """Create a new folder.
+
+    Args:
+        name: Folder name (REQUIRED)
+        parent_id: Parent folder ID for nested folders
+        color: Folder color (hex code)
+    """
+    return await _api_call("create_folder", {"name": name, "parent_id": parent_id, "color": color})
+
+
+@mcp.tool()
+async def list_folders(parent_id: Optional[str] = None) -> Dict[str, Any]:
+    """List folders.
+
+    Args:
+        parent_id: Parent folder ID to list children of (None for root)
+    """
+    return await _api_call("list_folders", {"parent_id": parent_id})
+
+
+@mcp.tool()
+async def move_document_to_folder(document_id: str, folder_id: Optional[str] = None) -> Dict[str, Any]:
+    """Move a document to a folder.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        folder_id: Target folder ID (None to move to root)
+    """
+    return await _api_call("move_document_to_folder", {"document_id": document_id, "folder_id": folder_id})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Images
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def upload_image(filename: str, document_id: Optional[str] = None,
+                       data: Optional[str] = None, url: Optional[str] = None,
+                       mime_type: str = "image/png", width: Optional[int] = None,
+                       height: Optional[int] = None) -> Dict[str, Any]:
+    """Upload an image to use in a document.
+
+    Args:
+        filename: Image filename (REQUIRED)
+        document_id: Document to associate image with
+        data: Base64-encoded image data
+        url: URL of the image (alternative to data)
+        mime_type: MIME type (default: image/png)
+        width: Image width in pixels
+        height: Image height in pixels
+    """
+    return await _api_call("upload_image", {
+        "filename": filename, "document_id": document_id, "data": data, "url": url,
+        "mime_type": mime_type, "width": width, "height": height
+    })
+
+
+@mcp.tool()
+async def list_images(document_id: str) -> Dict[str, Any]:
+    """List all images in a document.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+    """
+    return await _api_call("list_images", {"document_id": document_id})
+
+
+@mcp.tool()
+async def delete_image(image_id: str) -> Dict[str, Any]:
+    """Delete an image.
+
+    Args:
+        image_id: The image identifier (REQUIRED)
+    """
+    return await _api_call("delete_image", {"image_id": image_id})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Suggestions (Suggesting Mode)
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def add_suggestion(document_id: str, suggestion_type: str,
+                         original_text: Optional[str] = None, suggested_text: Optional[str] = None,
+                         selection_start: Optional[int] = None, selection_end: Optional[int] = None) -> Dict[str, Any]:
+    """Add a suggestion to a document (like Google Docs suggesting mode).
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        suggestion_type: Type of suggestion - 'insert', 'delete', 'replace', or 'format' (REQUIRED)
+        original_text: Original text being changed
+        suggested_text: Suggested replacement text
+        selection_start: Start position of the change
+        selection_end: End position of the change
+    """
+    return await _api_call("add_suggestion", {
+        "document_id": document_id, "suggestion_type": suggestion_type,
+        "original_text": original_text, "suggested_text": suggested_text,
+        "selection_start": selection_start, "selection_end": selection_end
+    })
+
+
+@mcp.tool()
+async def review_suggestion(suggestion_id: str, action: str) -> Dict[str, Any]:
+    """Accept or reject a suggestion.
+
+    Args:
+        suggestion_id: The suggestion identifier (REQUIRED)
+        action: 'accept' or 'reject' (REQUIRED)
+    """
+    return await _api_call("review_suggestion", {"suggestion_id": suggestion_id, "action": action})
+
+
+@mcp.tool()
+async def list_suggestions(document_id: str, status: str = "pending") -> Dict[str, Any]:
+    """List suggestions on a document.
+
+    Args:
+        document_id: The document identifier (REQUIRED)
+        status: Filter by status - 'pending', 'accepted', or 'rejected' (default: pending)
+    """
+    return await _api_call("list_suggestions", {"document_id": document_id, "status": status})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Entrypoint
+# ═════════════════════════════════════════════════════════════════════════════
+
+def main() -> None:
+    print("Starting Google Docs MCP Server (proxying to ENV API)...", file=sys.stderr)
+    host = os.getenv("GOOGLEDOCS_MCP_HOST", "localhost")
+    port_str = os.getenv("PORT", "").strip() or os.getenv("GOOGLEDOCS_MCP_PORT", "8866")
+    port = int(port_str)
+    mcp.run(transport="http", host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()