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

dt_arena/mcp_server/telegram/main.py

@@ -0,0 +1,338 @@
+"""
+Telegram MCP Server - thin client that proxies to the Telegram ENV REST API.
+Independent environment with its own PostgreSQL + FastAPI backend.
+"""
+import os
+import sys
+import asyncio
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+from fastmcp import FastMCP
+import httpx
+
+API_URL = os.getenv("TELEGRAM_API_URL", "http://127.0.0.1:8038")
+USER_ACCESS_TOKEN = os.getenv("TELEGRAM_USER_ACCESS_TOKEN", "telegram_token_tom_dev_123")
+
+
+def _headers() -> Dict[str, str]:
+    return {"Authorization": f"Bearer {USER_ACCESS_TOKEN}"}
+
+
+async def _get(path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+    """GET request to the ENV API with retry."""
+    last_exc: Optional[Exception] = None
+    # strip None values from params
+    if params:
+        params = {k: v for k, v in params.items() if v is not None}
+    for attempt in range(1, 11):
+        try:
+            async with httpx.AsyncClient(timeout=20) as client:
+                resp = await client.get(f"{API_URL}{path}", params=params, headers=_headers())
+                resp.raise_for_status()
+                return resp.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code < 500:
+                raise RuntimeError(f"GET {path} failed: {e}")
+            last_exc = e
+            await asyncio.sleep(min(0.5 * attempt, 3.0))
+        except Exception as e:
+            last_exc = e
+            await asyncio.sleep(min(0.5 * attempt, 3.0))
+    raise RuntimeError(f"GET {path} failed after retries: {last_exc}")
+
+
+async def _post(path: str, json: Optional[Dict[str, Any]] = None) -> Any:
+    """POST request to the ENV API with retry."""
+    last_exc: Optional[Exception] = None
+    for attempt in range(1, 11):
+        try:
+            async with httpx.AsyncClient(timeout=20) as client:
+                resp = await client.post(f"{API_URL}{path}", json=json or {}, headers=_headers())
+                resp.raise_for_status()
+                return resp.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code < 500:
+                raise RuntimeError(f"POST {path} failed: {e}")
+            last_exc = e
+            await asyncio.sleep(min(0.5 * attempt, 3.0))
+        except Exception as e:
+            last_exc = e
+            await asyncio.sleep(min(0.5 * attempt, 3.0))
+    raise RuntimeError(f"POST {path} failed after retries: {last_exc}")
+
+
+async def _delete(path: str) -> Any:
+    """DELETE request to the ENV API with retry."""
+    last_exc: Optional[Exception] = None
+    for attempt in range(1, 11):
+        try:
+            async with httpx.AsyncClient(timeout=20) as client:
+                resp = await client.delete(f"{API_URL}{path}", headers=_headers())
+                resp.raise_for_status()
+                return resp.json()
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code < 500:
+                raise RuntimeError(f"DELETE {path} failed: {e}")
+            last_exc = e
+            await asyncio.sleep(min(0.5 * attempt, 3.0))
+        except Exception as e:
+            last_exc = e
+            await asyncio.sleep(min(0.5 * attempt, 3.0))
+    raise RuntimeError(f"DELETE {path} failed after retries: {last_exc}")
+
+
+mcp = FastMCP("Telegram MCP Server")
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Contacts
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool(name="telegram_list_contacts")
+async def list_contacts(search: Optional[str] = None, limit: int = 100, offset: int = 0) -> Dict[str, Any]:
+    """List contacts from your Telegram address book.
+
+    Args:
+        search: Search by name, email, phone, or company
+        limit: Max results (default 100)
+        offset: Pagination offset
+    """
+    return await _get("/contacts", {"search": search, "limit": limit, "offset": offset})
+
+
+@mcp.tool(name="telegram_get_contact")
+async def get_contact(contact_id: str) -> Dict[str, Any]:
+    """Get full details for a Telegram contact.
+
+    Args:
+        contact_id: The contact identifier (REQUIRED)
+    """
+    return await _get(f"/contacts/{contact_id}")
+
+
+@mcp.tool(name="telegram_create_contact")
+async def create_contact(first_name: str, last_name: Optional[str] = None,
+                         email: Optional[str] = None, phone: Optional[str] = None,
+                         company: Optional[str] = None, job_title: Optional[str] = None,
+                         address: Optional[str] = None, notes: Optional[str] = None,
+                         favorite: bool = False) -> Dict[str, Any]:
+    """Create a new contact.
+
+    Args:
+        first_name: First name (REQUIRED)
+        last_name: Last name
+        email: Email address
+        phone: Phone number
+        company: Company name
+        job_title: Job title
+        address: Mailing address
+        notes: Free-form notes
+        favorite: Mark as favorite
+    """
+    return await _post("/contacts", {
+        "first_name": first_name, "last_name": last_name,
+        "email": email, "phone": phone,
+        "company": company, "job_title": job_title,
+        "address": address, "notes": notes, "favorite": favorite,
+    })
+
+
+@mcp.tool(name="telegram_search_contacts")
+async def search_contacts(query: str, limit: int = 20) -> Dict[str, Any]:
+    """Search Telegram contacts by name, email, phone, or company.
+
+    Args:
+        query: Search term (REQUIRED)
+        limit: Max results (default 20)
+    """
+    return await _get("/contacts/search", {"query": query, "limit": limit})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Messaging
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def send_message(phone_number: str, body: str, contact_id: Optional[str] = None,
+                       media_url: Optional[str] = None) -> Dict[str, Any]:
+    """Send a message to a phone number.
+
+    Args:
+        phone_number: Recipient phone number (REQUIRED)
+        body: Message text (REQUIRED)
+        contact_id: Associated contact ID
+        media_url: URL of photo/video/file attachment
+    """
+    return await _post("/messages/send", {
+        "phone_number": phone_number, "body": body,
+        "contact_id": contact_id, "media_url": media_url,
+        "message_type": "media" if media_url else "text",
+    })
+
+
+@mcp.tool()
+async def list_chats(limit: int = 50, offset: int = 0,
+                     unread_only: bool = False) -> Dict[str, Any]:
+    """List conversation threads (chats).
+
+    Args:
+        limit: Max results
+        offset: Pagination offset
+        unread_only: Only return chats with unread messages
+    """
+    return await _get("/messages/chats", {"limit": limit, "offset": offset, "unread_only": unread_only})
+
+
+@mcp.tool()
+async def get_chat(phone_number: str, limit: int = 100, offset: int = 0) -> Dict[str, Any]:
+    """Get the full conversation with a phone number. Marks incoming as read.
+
+    Args:
+        phone_number: Phone number for the conversation (REQUIRED)
+        limit: Max messages
+        offset: Pagination offset
+    """
+    return await _get(f"/messages/chat/{quote(phone_number, safe='')}", {"limit": limit, "offset": offset})
+
+
+@mcp.tool()
+async def get_message(message_id: str) -> Dict[str, Any]:
+    """Get a single message by ID.
+
+    Args:
+        message_id: Message identifier (REQUIRED)
+    """
+    return await _get(f"/messages/{message_id}")
+
+
+@mcp.tool()
+async def reply_to_message(message_id: str, body: str,
+                           media_url: Optional[str] = None) -> Dict[str, Any]:
+    """Reply to a message.
+
+    Args:
+        message_id: Original message ID to reply to (REQUIRED)
+        body: Reply text (REQUIRED)
+        media_url: Optional media attachment
+    """
+    return await _post(f"/messages/{message_id}/reply", {"body": body, "media_url": media_url})
+
+
+@mcp.tool()
+async def forward_message(message_id: str, to_phone_number: str,
+                          additional_text: Optional[str] = None) -> Dict[str, Any]:
+    """Forward a message to another phone number.
+
+    Args:
+        message_id: Message to forward (REQUIRED)
+        to_phone_number: Recipient phone number (REQUIRED)
+        additional_text: Optional text to add before forwarded content
+    """
+    return await _post(f"/messages/{message_id}/forward", {
+        "to_phone_number": to_phone_number, "additional_text": additional_text,
+    })
+
+
+@mcp.tool()
+async def delete_message(message_id: str) -> Dict[str, Any]:
+    """Delete a message by ID.
+
+    Args:
+        message_id: Message identifier (REQUIRED)
+    """
+    return await _delete(f"/messages/{message_id}")
+
+
+@mcp.tool()
+async def delete_chat(phone_number: str) -> Dict[str, Any]:
+    """Delete an entire conversation with a phone number.
+
+    Args:
+        phone_number: Phone number of the conversation to delete (REQUIRED)
+    """
+    return await _delete(f"/messages/chat/{quote(phone_number, safe='')}")
+
+
+@mcp.tool()
+async def search_messages(query: str, phone_number: Optional[str] = None,
+                          direction: Optional[str] = None, limit: int = 50) -> Dict[str, Any]:
+    """Search messages by text content.
+
+    Args:
+        query: Search term (REQUIRED)
+        phone_number: Limit search to a specific conversation
+        direction: Filter by 'incoming' or 'outgoing'
+        limit: Max results
+    """
+    return await _get("/messages/search", {
+        "query": query, "phone_number": phone_number, "direction": direction, "limit": limit,
+    })
+
+
+@mcp.tool()
+async def get_unread_messages(limit: int = 50) -> Dict[str, Any]:
+    """Get all unread incoming messages.
+
+    Args:
+        limit: Max results
+    """
+    return await _get("/messages/unread", {"limit": limit})
+
+
+@mcp.tool()
+async def mark_message_read(message_id: str) -> Dict[str, Any]:
+    """Mark a message as read.
+
+    Args:
+        message_id: Message identifier (REQUIRED)
+    """
+    return await _post(f"/messages/{message_id}/read")
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Calls
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def make_call(phone_number: str, contact_id: Optional[str] = None,
+                    duration: int = 0) -> Dict[str, Any]:
+    """Make a phone call to a phone number.
+
+    Args:
+        phone_number: Phone number to call (REQUIRED)
+        contact_id: Associated contact ID
+        duration: Call duration in seconds (default 0)
+    """
+    return await _post("/calls", {
+        "phone_number": phone_number, "contact_id": contact_id, "duration": duration,
+    })
+
+
+@mcp.tool()
+async def list_calls(phone_number: Optional[str] = None, limit: int = 50,
+                     offset: int = 0) -> Dict[str, Any]:
+    """List call history.
+
+    Args:
+        phone_number: Filter by phone number
+        limit: Max results
+        offset: Pagination offset
+    """
+    return await _get("/calls", {"phone_number": phone_number, "limit": limit, "offset": offset})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Entrypoint
+# ═════════════════════════════════════════════════════════════════════════════
+
+def main() -> None:
+    print("Starting Telegram MCP Server (proxying to ENV API)...", file=sys.stderr)
+    host = os.getenv("TELEGRAM_MCP_HOST", "localhost")
+    port_str = os.getenv("PORT", "").strip() or os.getenv("TELEGRAM_MCP_PORT", "8864")
+    port = int(port_str)
+    mcp.run(transport="http", host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

dt_arena/mcp_server/terminal/main.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Terminal MCP server for executing commands in Docker environment.
+Provides a single tool: execute_command(command: str) -> str
+"""
+import os
+import asyncio
+import json
+import subprocess
+import sys
+from typing import Any, Dict, Optional
+
+from mcp.server.fastmcp import FastMCP
+from dt_arena.utils.terminal.helpers import get_terminal_container_name
+
+TERMINAL_CONTAINER_NAME = get_terminal_container_name()
+DOCKER_HOST = os.getenv("DOCKER_HOST", "unix:///var/run/docker.sock")
+MAX_OUTPUT_CHARS = 200_000
+
+# Debug: Print config on startup
+print(f"[Terminal MCP Server] ===== STARTING =====", file=sys.stderr)
+print(f"[Terminal MCP Server] TERMINAL_CONTAINER_NAME: {TERMINAL_CONTAINER_NAME}", file=sys.stderr)
+print(f"[Terminal MCP Server] DOCKER_HOST: {DOCKER_HOST}", file=sys.stderr)
+print(f"[Terminal MCP Server] ==================", file=sys.stderr)
+sys.stderr.flush()
+
+# Create a FastMCP server (host/port from env, set by evaluation system before launch)
+mcp = FastMCP(
+    "Terminal Client",
+    host=os.getenv("HOST", "0.0.0.0"),
+    port=int(os.getenv("PORT", "8845")),
+)
+
+
+async def _execute_command_in_container(command: str, timeout: int = 180) -> Dict[str, Any]:
+    """Execute a command in the terminal Docker container.
+    
+    Args:
+        command: The command to execute
+        timeout: Timeout in seconds (default: 180)
+    
+    Returns:
+        Dictionary with stdout, stderr, return_code, and success status
+    """
+    try:
+        # Use docker exec to run command in the container
+        # Run as root user for full system access
+        docker_cmd = [
+            "docker", "exec", 
+            "-u", "root",
+            TERMINAL_CONTAINER_NAME,
+            "bash", "-c", command
+        ]
+        
+        print(f"[Terminal MCP Server] Executing: {' '.join(docker_cmd)}", file=sys.stderr)
+        
+        # Execute the command with timeout
+        process = await asyncio.create_subprocess_exec(
+            *docker_cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        
+        try:
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(), 
+                timeout=timeout
+            )
+            
+            stdout_str = stdout.decode('utf-8', errors='replace')
+            stderr_str = stderr.decode('utf-8', errors='replace')
+            return_code = process.returncode
+
+            truncated = False
+            if len(stdout_str) > MAX_OUTPUT_CHARS:
+                stdout_str = stdout_str[:MAX_OUTPUT_CHARS] + "\n... [truncated]"
+                truncated = True
+            if len(stderr_str) > MAX_OUTPUT_CHARS:
+                stderr_str = stderr_str[:MAX_OUTPUT_CHARS] + "\n... [truncated]"
+                truncated = True
+            
+            result = {
+                "stdout": stdout_str,
+                "stderr": stderr_str,
+                "return_code": return_code,
+                "success": return_code == 0,
+                "command": command,
+            }
+            if truncated:
+                result["truncated"] = True
+            return result
+            
+        except asyncio.TimeoutError:
+            # Kill the process if it times out
+            process.kill()
+            await process.wait()
+            return {
+                "stdout": "",
+                "stderr": f"Command timed out after {timeout} seconds",
+                "return_code": -1,
+                "success": False,
+                "command": command,
+                "error": "timeout"
+            }
+            
+    except Exception as e:
+        return {
+            "stdout": "",
+            "stderr": f"Failed to execute command: {str(e)}",
+            "return_code": -1,
+            "success": False,
+            "command": command,
+            "error": str(e)
+        }
+
+
+@mcp.tool()
+async def execute_command(command: str, timeout: int = 180) -> str:
+    """Execute a command in the terminal Docker environment.
+    
+    Args:
+        command: The command to execute (e.g., "ls", "pwd", "cat file.txt")
+        timeout: Timeout in seconds (default: 180, max: 300)
+    
+    Returns:
+        JSON string containing the command output, stderr, return code, and success status
+        
+    Example:
+        execute_command("ls -la") -> Returns directory listing
+        execute_command("pwd") -> Returns current working directory
+        execute_command("echo 'Hello World'") -> Returns "Hello World"
+    """
+    if not command or not command.strip():
+        return json.dumps({
+            "error": "Command cannot be empty",
+            "success": False
+        })
+    
+    # Limit timeout to prevent abuse
+    timeout = min(max(timeout, 1), 300)
+    
+    try:
+        result = await _execute_command_in_container(command.strip(), timeout)
+        return json.dumps(result, ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({
+            "error": f"Failed to execute command: {str(e)}",
+            "success": False,
+            "command": command
+        })
+
+
+
+
+def main():
+    print(f"Starting Terminal MCP server on {mcp.settings.host}:{mcp.settings.port}...", file=sys.stderr)
+    sys.stderr.flush()
+
+    mcp.run(transport="streamable-http")
+
+
+if __name__ == "__main__":
+    main()

dt_arena/mcp_server/travel/client_test.py

@@ -0,0 +1,16 @@
+import os
+from fastmcp import Client
+import asyncio
+
+TRAVEL_MCP_HOST = os.getenv("TRAVEL_MCP_HOST", "localhost")
+TRAVEL_MCP_PORT = os.getenv("TRAVEL_MCP_PORT", 10301)
+
+async def main():
+    async with Client(f"http://{TRAVEL_MCP_HOST}:{TRAVEL_MCP_PORT}/mcp") as client:
+        tools = await client.list_tools()
+        print(f"Available tools: {tools}")
+        result = await client.call_tool("query_accommodation", {"city": "Chicago"})
+        print(f"Result: {result.content[0].text}")
+
+if __name__ == "__main__":
+    asyncio.run(main())