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

dt_arena/mcp_server/whatsapp/main.py

@@ -0,0 +1,318 @@
+"""
+WhatsApp MCP Server - thin client that proxies to the WhatsApp 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("WHATSAPP_API_URL", "http://127.0.0.1:8039")
+USER_ACCESS_TOKEN = os.getenv("WHATSAPP_USER_ACCESS_TOKEN", "whatsapp_token_tom_dev_123")
+
+
+async def _api_call(name: str, arguments: Dict[str, Any]) -> Any:
+    """Call the WhatsApp 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 {})
+                if USER_ACCESS_TOKEN:
+                    args["access_token"] = USER_ACCESS_TOKEN
+                resp = await client.post(f"{API_URL}/tools/call", json={"name": name, "arguments": args})
+                resp.raise_for_status()
+                data = resp.json()
+                return data.get("result")
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code < 500:
+                raise RuntimeError(f"ENV API call 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"ENV API call failed after retries: {last_exc}")
+
+
+mcp = FastMCP("WhatsApp MCP Server")
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Contact Lookup
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def list_contacts(search: Optional[str] = None, limit: int = 100, offset: int = 0) -> Dict[str, Any]:
+    """List contacts from your WhatsApp address book.
+
+    Args:
+        search: Search by name, email, phone, or company
+        limit: Max results (default 100)
+        offset: Pagination offset
+    """
+    return await _api_call("list_contacts", {"search": search, "limit": limit, "offset": offset})
+
+
+@mcp.tool()
+async def get_contact(contact_id: str) -> Dict[str, Any]:
+    """Get full details for a contact.
+
+    Args:
+        contact_id: The contact identifier (REQUIRED)
+    """
+    return await _api_call("get_contact", {"contact_id": contact_id})
+
+
+@mcp.tool()
+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 in WhatsApp.
+
+    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 _api_call("create_contact", {
+        "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()
+async def search_contacts(query: str, limit: int = 20) -> Dict[str, Any]:
+    """Search contacts by name, email, phone, or company.
+
+    Args:
+        query: Search term (REQUIRED)
+        limit: Max results (default 20)
+    """
+    return await _api_call("search_contacts", {"query": query, "limit": limit})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# WhatsApp Messaging
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def send_whatsapp_message(phone_number: str, body: str, contact_id: Optional[str] = None,
+                                media_url: Optional[str] = None) -> Dict[str, Any]:
+    """Send a WhatsApp 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/document attachment
+    """
+    return await _api_call("send_message", {
+        "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_whatsapp_chats(limit: int = 50, offset: int = 0,
+                              unread_only: bool = False) -> Dict[str, Any]:
+    """List WhatsApp conversation threads (chats).
+
+    Args:
+        limit: Max results
+        offset: Pagination offset
+        unread_only: Only return chats with unread messages
+    """
+    return await _api_call("list_message_threads", {"limit": limit, "offset": offset, "unread_only": unread_only})
+
+
+@mcp.tool()
+async def get_whatsapp_chat(phone_number: str, limit: int = 100, offset: int = 0) -> Dict[str, Any]:
+    """Get the full WhatsApp 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 _api_call("get_conversation", {"phone_number": phone_number, "limit": limit, "offset": offset})
+
+
+@mcp.tool()
+async def get_whatsapp_message(message_id: str) -> Dict[str, Any]:
+    """Get a single WhatsApp message by ID.
+
+    Args:
+        message_id: Message identifier (REQUIRED)
+    """
+    return await _api_call("get_message", {"message_id": message_id})
+
+
+@mcp.tool()
+async def reply_to_whatsapp_message(message_id: str, body: str,
+                                    media_url: Optional[str] = None) -> Dict[str, Any]:
+    """Reply to a WhatsApp message.
+
+    Args:
+        message_id: Original message ID to reply to (REQUIRED)
+        body: Reply text (REQUIRED)
+        media_url: Optional media attachment
+    """
+    return await _api_call("reply_to_message", {"message_id": message_id, "body": body, "media_url": media_url})
+
+
+@mcp.tool()
+async def forward_whatsapp_message(message_id: str, to_phone_number: str,
+                                   additional_text: Optional[str] = None) -> Dict[str, Any]:
+    """Forward a WhatsApp 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 _api_call("forward_message", {
+        "message_id": message_id, "to_phone_number": to_phone_number, "additional_text": additional_text,
+    })
+
+
+@mcp.tool()
+async def delete_whatsapp_message(message_id: str) -> Dict[str, Any]:
+    """Delete a WhatsApp message by ID.
+
+    Args:
+        message_id: Message identifier (REQUIRED)
+    """
+    return await _api_call("delete_message", {"message_id": message_id})
+
+
+@mcp.tool()
+async def delete_whatsapp_chat(phone_number: str) -> Dict[str, Any]:
+    """Delete an entire WhatsApp conversation with a phone number.
+
+    Args:
+        phone_number: Phone number of the conversation to delete (REQUIRED)
+    """
+    return await _api_call("delete_conversation", {"phone_number": phone_number})
+
+
+@mcp.tool()
+async def search_whatsapp_messages(query: str, phone_number: Optional[str] = None,
+                                   direction: Optional[str] = None, limit: int = 50) -> Dict[str, Any]:
+    """Search WhatsApp 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 _api_call("search_messages", {
+        "query": query, "phone_number": phone_number, "direction": direction, "limit": limit,
+    })
+
+
+@mcp.tool()
+async def get_unread_whatsapp_messages(limit: int = 50) -> Dict[str, Any]:
+    """Get all unread incoming WhatsApp messages.
+
+    Args:
+        limit: Max results
+    """
+    return await _api_call("get_unread_messages", {"limit": limit})
+
+
+@mcp.tool()
+async def mark_whatsapp_message_read(message_id: str) -> Dict[str, Any]:
+    """Mark a WhatsApp message as read.
+
+    Args:
+        message_id: Message identifier (REQUIRED)
+    """
+    return await _api_call("mark_message_read", {"message_id": message_id})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# WhatsApp Phone Calls
+# ═════════════════════════════════════════════════════════════════════════════
+
+@mcp.tool()
+async def make_whatsapp_call(phone_number: str, contact_id: Optional[str] = None,
+                             notes: Optional[str] = None) -> Dict[str, Any]:
+    """Initiate a WhatsApp voice/video call.
+
+    Args:
+        phone_number: Phone number to call (REQUIRED)
+        contact_id: Associated contact ID
+        notes: Optional notes about the call
+    """
+    return await _api_call("make_call", {
+        "phone_number": phone_number, "contact_id": contact_id, "notes": notes,
+    })
+
+
+@mcp.tool()
+async def list_whatsapp_calls(phone_number: Optional[str] = None,
+                              direction: Optional[str] = None,
+                              limit: int = 50, offset: int = 0) -> Dict[str, Any]:
+    """List WhatsApp call history.
+
+    Args:
+        phone_number: Filter by phone number
+        direction: Filter by 'incoming', 'outgoing', or 'missed'
+        limit: Max results (default 50)
+        offset: Pagination offset
+    """
+    return await _api_call("list_calls", {
+        "phone_number": phone_number, "direction": direction, "limit": limit, "offset": offset,
+    })
+
+
+@mcp.tool()
+async def get_whatsapp_call(call_id: str) -> Dict[str, Any]:
+    """Get details of a specific WhatsApp call.
+
+    Args:
+        call_id: Call identifier (REQUIRED)
+    """
+    return await _api_call("get_call", {"call_id": call_id})
+
+
+@mcp.tool()
+async def delete_whatsapp_call(call_id: str) -> Dict[str, Any]:
+    """Delete a WhatsApp call record from history.
+
+    Args:
+        call_id: Call identifier (REQUIRED)
+    """
+    return await _api_call("delete_call", {"call_id": call_id})
+
+
+# ═════════════════════════════════════════════════════════════════════════════
+# Entrypoint
+# ═════════════════════════════════════════════════════════════════════════════
+
+def main() -> None:
+    print("Starting WhatsApp MCP Server (proxying to ENV API)...", file=sys.stderr)
+    host = os.getenv("WHATSAPP_MCP_HOST", "localhost")
+    port_str = os.getenv("PORT", "").strip() or os.getenv("WHATSAPP_MCP_PORT", "8865")
+    port = int(port_str)
+    mcp.run(transport="http", host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

dt_arena/mcp_server/windows/client_test.py

@@ -0,0 +1,270 @@
+import asyncio
+import base64
+from typing import Optional, List, Dict, Any
+from contextlib import AsyncExitStack
+from pathlib import Path
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from anthropic import Anthropic
+from dotenv import load_dotenv
+
+load_dotenv()  # load environment variables from .env
+
+
+class MCPClient:
+    def __init__(self):
+        # Initialize session and client objects
+        self.session: Optional[ClientSession] = None
+        self.exit_stack = AsyncExitStack()
+        self.anthropic = Anthropic()
+
+    async def connect_to_server(self, server_script_path: str, extra_args: Optional[List[str]] = None):
+        """Connect to an MCP server
+
+        Args:
+            server_script_path: Path to the server script (.py or .js)
+            extra_args: Optional additional arguments to pass to the server
+        """
+        is_python = server_script_path.endswith(".py")
+        is_js = server_script_path.endswith(".js")
+        if not (is_python or is_js):
+            raise ValueError("Server script must be a .py or .js file")
+
+        command = "python" if is_python else "node"
+        args = [server_script_path]
+        if extra_args:
+            args.extend(extra_args)
+
+        server_params = StdioServerParameters(command=command, args=args, env=None)
+
+        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+        self.stdio, self.write = stdio_transport
+        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
+
+        await self.session.initialize()
+
+        # List available tools
+        response = await self.session.list_tools()
+        tools = response.tools
+        print("\nConnected to server with tools:", [tool.name for tool in tools])
+
+    def encode_image(self, image_path: str) -> Dict[str, Any]:
+        """Encode an image file to base64 and determine its media type
+
+        Args:
+            image_path: Path to the image file
+
+        Returns:
+            Dictionary with image data and media type for Anthropic API
+        """
+        path = Path(image_path)
+        if not path.exists():
+            raise FileNotFoundError(f"Image file not found: {image_path}")
+
+        # Determine media type based on file extension
+        extension = path.suffix.lower()
+        media_type_map = {
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".png": "image/png",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+        }
+
+        media_type = media_type_map.get(extension)
+        if not media_type:
+            raise ValueError(f"Unsupported image format: {extension}. Supported formats: {list(media_type_map.keys())}")
+
+        # Read and encode the image
+        with open(path, "rb") as image_file:
+            image_data = base64.standard_b64encode(image_file.read()).decode("utf-8")
+
+        return {"type": "image", "source": {"type": "base64", "media_type": media_type, "data": image_data}}
+
+    def convert_mcp_content_to_anthropic(self, content: Any) -> Any:
+        """Convert MCP tool result content to Anthropic API format
+
+        Args:
+            content: Content from MCP tool result
+
+        Returns:
+            Converted content in Anthropic API format
+        """
+        # If content is a list, convert each item
+        if isinstance(content, list):
+            converted = []
+            for item in content:
+                # Check if this is an MCP image format
+                if item.type == "image":
+                    # Convert MCP image format to Anthropic format
+                    converted.append(
+                        {"type": "image", "source": {"type": "base64", "media_type": item.mimeType, "data": item.data}}
+                    )
+                elif item.type == "text":
+                    # Text content remains the same
+                    converted.append(item)
+                else:
+                    # Unknown format, keep as is
+                    converted.append(item)
+            return converted
+        else:
+            # If content is not a list, return as is
+            return content
+
+    async def process_query(self, query: str, image_paths: Optional[List[str]] = None) -> str:
+        """Process a query using Claude and available tools
+
+        Args:
+            query: Text query to process
+            image_paths: Optional list of image file paths to include in the query
+        """
+        # Build message content with text and images
+        content: List[Dict[str, Any]] = []
+
+        # Add images first if provided
+        if image_paths:
+            for image_path in image_paths:
+                try:
+                    image_content = self.encode_image(image_path)
+                    content.append(image_content)
+                    print(f"Loaded image: {image_path}")
+                except Exception as e:
+                    print(f"Warning: Failed to load image {image_path}: {str(e)}")
+
+        # Add text query
+        content.append({"type": "text", "text": query})
+
+        messages = [{"role": "user", "content": content}]
+
+        response = await self.session.list_tools()
+        available_tools = [
+            {
+                "name": tool.name,
+                "description": tool.description,
+                "input_schema": tool.inputSchema,
+            }
+            for tool in response.tools
+        ]
+
+        # Initial Claude API call
+        response = self.anthropic.messages.create(
+            model="claude-sonnet-4-5",
+            max_tokens=1000,
+            messages=messages,
+            tools=available_tools,
+        )
+
+        # Process response and handle tool calls
+        final_text = []
+
+        # Agentic loop: continue while there are tool calls
+        while response.stop_reason == "tool_use":
+            # Collect all content from assistant's response
+            assistant_content = []
+            tool_results = []
+
+            for content_block in response.content:
+                if content_block.type == "text":
+                    final_text.append(content_block.text)
+                    assistant_content.append({"type": "text", "text": content_block.text})
+                elif content_block.type == "tool_use":
+                    tool_name = content_block.name
+                    tool_args = content_block.input
+                    tool_use_id = content_block.id
+
+                    assistant_content.append(
+                        {"type": "tool_use", "id": tool_use_id, "name": tool_name, "input": tool_args}
+                    )
+
+                    # Execute tool call
+                    print(f"[Calling tool {tool_name} with args {tool_args}]")
+                    result = await self.session.call_tool(tool_name, tool_args)
+
+                    # Convert MCP content format to Anthropic format
+                    converted_content = self.convert_mcp_content_to_anthropic(result.content)
+
+                    # Add tool result
+                    tool_results.append(
+                        {"type": "tool_result", "tool_use_id": tool_use_id, "content": converted_content}
+                    )
+
+            # Add assistant message with all content (text + tool_use)
+            messages.append({"role": "assistant", "content": assistant_content})
+
+            # Add user message with tool results
+            messages.append({"role": "user", "content": tool_results})
+
+            # Get next response from Claude
+            response = self.anthropic.messages.create(
+                model="claude-sonnet-4-5",
+                max_tokens=1000,
+                messages=messages,
+                tools=available_tools,
+            )
+
+        # Process final response (no more tool calls)
+        for content_block in response.content:
+            if content_block.type == "text":
+                final_text.append(content_block.text)
+
+        return "\n".join(final_text)
+
+    async def chat_loop(self):
+        """Run an interactive chat loop"""
+        print("\nMCP Client Started!")
+        print("Type your queries or 'quit' to exit.")
+        print("To include images, use: your query --image path/to/image.jpg --image path/to/another.png")
+
+        while True:
+            try:
+                query = input("\nQuery: ").strip()
+                if query.lower() == "quit":
+                    break
+
+                # Parse image paths from query
+                image_paths = []
+                parts = query.split("--image")
+
+                if len(parts) > 1:
+                    # First part is the actual query
+                    query = parts[0].strip()
+
+                    # Remaining parts are image paths
+                    for part in parts[1:]:
+                        image_path = part.strip().split()[0] if part.strip() else ""
+                        if image_path:
+                            image_paths.append(image_path)
+
+                response = await self.process_query(query, image_paths if image_paths else None)
+                print("\n" + response)
+
+            except Exception as e:
+                print(f"\nError: {str(e)}")
+
+    async def cleanup(self):
+        """Clean up resources"""
+        await self.exit_stack.aclose()
+
+
+async def main():
+    if len(sys.argv) < 2:
+        print("Usage: python client_test.py <path_to_server_script> [additional_args...]")
+        sys.exit(1)
+
+    server_script = sys.argv[1]
+    extra_args = sys.argv[2:] if len(sys.argv) > 2 else None
+
+    client = MCPClient()
+    try:
+        await client.connect_to_server(server_script, extra_args)
+        await client.chat_loop()
+    finally:
+        await client.cleanup()
+
+
+if __name__ == "__main__":
+    import sys
+
+    asyncio.run(main())