@createlex/createlexgenai 1.0.0

package/python/fastmcp.py

@@ -0,0 +1,768 @@
+#!/usr/bin/env python3
+import asyncio
+import inspect
+import json
+import logging
+import websockets
+from typing import Any, Callable, Dict, List, Optional, Union, get_type_hints
+import time
+from datetime import datetime
+import traceback
+import sys
+import os
+
+# Import activity tracker for usage logging
+try:
+    from activity_tracker import track_tool_call as log_tool_activity, shutdown_tracker
+    ACTIVITY_TRACKING_ENABLED = True
+except ImportError:
+    ACTIVITY_TRACKING_ENABLED = False
+    def log_tool_activity(*args, **kwargs):
+        pass
+    def shutdown_tracker():
+        pass
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger('fastmcp')
+
+# Connection stability configuration
+CONNECTION_STABILITY_CONFIG = {
+    'max_response_size': 32 * 1024,  # 32KB
+    'chunk_size': 16 * 1024,         # 16KB
+    'max_chunks': 10,
+    'websocket_max_size': 1024 * 1024,  # 1MB
+    'ping_interval': 20,
+    'ping_timeout': 10,
+    'close_timeout': 10
+}
+
+def should_summarize_response(data: Any) -> bool:
+    """Check if response should be summarized due to size."""
+    try:
+        json_str = json.dumps(data)
+        return len(json_str.encode('utf-8')) > CONNECTION_STABILITY_CONFIG['max_response_size']
+    except Exception:
+        return False
+
+def summarize_large_response(data: Any, tool_name: str = None) -> Any:
+    """Create a summary of large response data."""
+    try:
+        if isinstance(data, dict):
+            # Check for blueprint context data
+            if data.get('context_type') == 'blueprint_editor':
+                return summarize_blueprint_context(data)
+            # Check for scene objects data
+            elif 'actors' in data and isinstance(data['actors'], list):
+                return summarize_scene_objects(data)
+            # Generic dict summarization
+            else:
+                return {
+                    'type': 'large_response_summary',
+                    'original_keys': list(data.keys())[:10],
+                    'total_keys': len(data.keys()) if hasattr(data, 'keys') else 0,
+                    'note': f'Large response summarized for {tool_name or "unknown tool"}. Use specific queries for details.'
+                }
+        elif isinstance(data, list):
+            return {
+                'type': 'large_list_summary',
+                'length': len(data),
+                'first_items': data[:3] if len(data) > 0 else [],
+                'note': f'Large list with {len(data)} items summarized. Use specific queries for details.'
+            }
+        else:
+            return {
+                'type': 'large_data_summary',
+                'data_type': type(data).__name__,
+                'note': 'Large response summarized due to size constraints.'
+            }
+    except Exception as e:
+        logger.error(f"Error summarizing response: {e}")
+        return {
+            'error': 'Failed to summarize large response',
+            'original_type': type(data).__name__,
+            'note': 'Response was too large to process safely.'
+        }
+
+def summarize_blueprint_context(data: dict) -> dict:
+    """Summarize blueprint context data."""
+    summary = {
+        'success': data.get('success', False),
+        'context_type': data.get('context_type'),
+        'has_active_editor': data.get('has_active_editor', False),
+        'note': 'Blueprint context summarized. Use specific queries for detailed information.'
+    }
+
+    if 'active_blueprint' in data:
+        summary['active_blueprint'] = data['active_blueprint']
+
+    if 'editor_state' in data:
+        editor_state = data['editor_state']
+        summary['editor_summary'] = {
+            'blueprint_name': editor_state.get('blueprint_name'),
+            'parent_class': editor_state.get('parent_class'),
+            'is_compiled': editor_state.get('is_compiled'),
+            'has_compile_errors': editor_state.get('has_compile_errors'),
+            'total_function_graphs': editor_state.get('total_function_graphs')
+        }
+
+    if 'graph_info' in data and 'function_graphs' in data['graph_info']:
+        graphs = data['graph_info']['function_graphs']
+        summary['function_graphs_summary'] = [
+            {
+                'name': g.get('name'),
+                'type': g.get('type'),
+                'node_count': g.get('node_count'),
+                'is_active': g.get('is_active')
+            }
+            for g in graphs[:5]  # First 5 graphs
+        ]
+        if len(graphs) > 5:
+            summary['function_graphs_summary'].append({
+                'note': f'... and {len(graphs) - 5} more graphs'
+            })
+
+    if 'available_nodes' in data:
+        available_nodes = data['available_nodes']
+        summary['available_nodes_summary'] = {
+            'categories': list(available_nodes.keys()),
+            'total_nodes': sum(len(nodes) for nodes in available_nodes.values()) if isinstance(available_nodes, dict) else 0
+        }
+
+    return summary
+
+def summarize_scene_objects(data: dict) -> dict:
+    """Summarize scene objects data."""
+    actors = data.get('actors', [])
+
+    # Count actors by class
+    class_counts = {}
+    for actor in actors:
+        actor_class = actor.get('class', 'Unknown')
+        class_counts[actor_class] = class_counts.get(actor_class, 0) + 1
+
+    return {
+        'success': data.get('success', False),
+        'total_actors': len(actors),
+        'actor_classes': class_counts,
+        'sample_actors': [
+            {
+                'name': actor.get('name'),
+                'class': actor.get('class'),
+                'location': actor.get('location')
+            }
+            for actor in actors[:3]  # First 3 actors
+        ],
+        'note': f'Scene with {len(actors)} actors summarized. Use specific queries for detailed information.'
+    }
+
+class FastMCP:
+    """
+    Fast MCP (Model Control Protocol) implementation.
+    
+    This class provides a lightweight framework for defining tools that can be
+    exposed to language models for execution, following the Model Control Protocol.
+    """
+    
+    def __init__(self, name: str = "MCP"):
+        """
+        Initialize a new FastMCP instance.
+        
+        Args:
+            name: Name of the MCP server
+        """
+        self.name = name
+        self.tools = {}
+        self.connected_clients = {}
+        self.ws_server = None
+        
+        logger.info(f"Initialized FastMCP: {name}")
+        
+    def tool(self, func=None, **kwargs):
+        """
+        Decorator to register a function as an MCP tool.
+        
+        Args:
+            func: The function to register
+            **kwargs: Additional tool metadata
+            
+        Returns:
+            The decorated function
+        """
+        def decorator(f):
+            # Get parameter types and return type using type hints
+            sig = inspect.signature(f)
+            type_hints = get_type_hints(f)
+            return_type = type_hints.get('return', Any).__name__
+            
+            # Build a parameter schema
+            parameters = []
+            for name, param in sig.parameters.items():
+                param_type = type_hints.get(name, Any).__name__
+                default = param.default if param.default is not inspect.Parameter.empty else None
+                has_default = param.default is not inspect.Parameter.empty
+                
+                parameters.append({
+                    'name': name,
+                    'type': param_type,
+                    'required': not has_default,
+                    'default': default
+                })
+            
+            # Get description from docstring
+            description = f.__doc__ or "No description provided"
+            
+            # Convert parameters to MCP schema format
+            properties = {}
+            required = []
+
+            for param in parameters:
+                param_name = param['name']
+                param_type = param['type']
+
+                # Map Python types to JSON schema types
+                if param_type in ['int', 'integer']:
+                    schema_type = "integer"
+                elif param_type in ['float', 'number']:
+                    schema_type = "number"
+                elif param_type in ['bool', 'boolean']:
+                    schema_type = "boolean"
+                elif param_type in ['list', 'array']:
+                    schema_type = "array"
+                elif param_type in ['dict', 'object']:
+                    schema_type = "object"
+                else:
+                    schema_type = "string"
+
+                # For arrays, include items schema (required by Gemini API)
+                if schema_type == "array":
+                    properties[param_name] = {"type": schema_type, "items": {"type": "number"}}
+                else:
+                    properties[param_name] = {"type": schema_type}
+
+                if param['required']:
+                    required.append(param_name)
+
+            schema = {
+                "type": "object",
+                "properties": properties,
+                "required": required
+            }
+
+            # Register the tool
+            tool_name = kwargs.get('name', f.__name__)
+            self.tools[tool_name] = {
+                'function': f,
+                'name': tool_name,
+                'description': description,
+                'parameters': parameters,
+                'schema': schema,
+                'return_type': return_type
+            }
+            
+            logger.info(f"Registered tool: {tool_name}")
+            return f
+            
+        if func is None:
+            return decorator
+        return decorator(func)
+    
+    def get_tools_description(self) -> List[Dict]:
+        """
+        Get a list of tool descriptions.
+        
+        Returns:
+            List of tool metadata dictionaries
+        """
+        tools_info = []
+        for name, tool in self.tools.items():
+            tools_info.append({
+                'name': name,
+                'description': tool['description'],
+                'parameters': tool['parameters'],
+                'return_type': tool['return_type']
+            })
+        return tools_info
+    
+    def call_tool(self, name: str, arguments: Dict[str, Any]) -> Any:
+        """
+        Call a registered tool by name with arguments.
+        
+        Args:
+            name: Name of the tool to call
+            arguments: Dictionary of arguments to pass to the tool
+            
+        Returns:
+            Result of the tool execution
+            
+        Raises:
+            ValueError: If the tool is not found
+        """
+        start_time = time.time()
+        success = False
+        error_msg = None
+        result_summary = None
+        
+        if name not in self.tools:
+            logger.error(f"Tool not found: {name}")
+            # Track failed tool call
+            if ACTIVITY_TRACKING_ENABLED:
+                log_tool_activity(
+                    tool_name=name,
+                    arguments=arguments,
+                    success=False,
+                    duration_ms=0,
+                    error=f"Tool not found: {name}"
+                )
+            raise ValueError(f"Tool not found: {name}")
+        
+        tool = self.tools[name]
+        func = tool['function']
+        
+        logger.info(f"Calling tool: {name} with arguments: {arguments}")
+        
+        try:
+            # Filter arguments to only include those accepted by the function
+            import inspect
+            sig = inspect.signature(func)
+            filtered_args = {k: v for k, v in arguments.items() if k in sig.parameters}
+
+            # Execute the tool with the filtered arguments
+            result = func(**filtered_args)
+            logger.info(f"Tool {name} execution result: {result}")
+            
+            success = True
+            # Create a brief result summary for analytics
+            if isinstance(result, dict):
+                result_summary = f"dict with {len(result)} keys"
+            elif isinstance(result, list):
+                result_summary = f"list with {len(result)} items"
+            elif isinstance(result, str):
+                result_summary = f"string ({len(result)} chars)"
+            else:
+                result_summary = type(result).__name__
+                
+            return result
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"Error executing tool {name}: {e}")
+            logger.error(traceback.format_exc())
+            raise
+        finally:
+            # Track the tool call (success or failure)
+            duration_ms = (time.time() - start_time) * 1000
+            if ACTIVITY_TRACKING_ENABLED:
+                log_tool_activity(
+                    tool_name=name,
+                    arguments=arguments,
+                    success=success,
+                    duration_ms=duration_ms,
+                    error=error_msg,
+                    result_summary=result_summary
+                )
+    
+    def run(self, host: str = 'localhost', port: int = 8765) -> None:
+        """
+        Start the MCP server.
+
+        Args:
+            host: Host to bind the server to (use 'stdio' for stdin/stdout mode)
+            port: Port to listen on (ignored in stdio mode)
+        """
+        if host == 'stdio':
+            logger.info(f"Starting FastMCP server: {self.name} in stdio mode")
+            asyncio.run(self._run_stdio_server())
+        else:
+            logger.info(f"Starting FastMCP server: {self.name} on {host}:{port}")
+            asyncio.run(self._run_server(host, port))
+    
+    async def _run_server(self, host: str, port: int) -> None:
+        """
+        Internal method to run the WebSocket server with enhanced stability.
+
+        Args:
+            host: Host to bind the server to
+            port: Port to listen on
+        """
+        # Configure WebSocket server with stability settings
+        self.ws_server = await websockets.serve(
+            self._handle_client,
+            host,
+            port,
+            max_size=CONNECTION_STABILITY_CONFIG['websocket_max_size'],
+            max_queue=32,
+            ping_interval=CONNECTION_STABILITY_CONFIG['ping_interval'],
+            ping_timeout=CONNECTION_STABILITY_CONFIG['ping_timeout'],
+            close_timeout=CONNECTION_STABILITY_CONFIG['close_timeout']
+        )
+        logger.info(f"WebSocket server started on {host}:{port} with enhanced stability settings")
+
+        await self.ws_server.wait_closed()
+
+    async def _run_stdio_server(self) -> None:
+        """
+        Run the MCP server in stdio mode for Claude Desktop/Cursor integration.
+        Windows-compatible version using synchronous I/O.
+        """
+        import sys
+        import threading
+        import queue
+
+        logger.info("FastMCP server running in stdio mode")
+
+        # Use a queue for thread-safe communication
+        input_queue = queue.Queue()
+
+        def read_stdin():
+            """Read from stdin in a separate thread"""
+            try:
+                while True:
+                    line = sys.stdin.readline()
+                    if not line:
+                        break
+                    input_queue.put(line.strip())
+            except Exception as e:
+                logger.error(f"Error reading stdin: {e}")
+                input_queue.put(None)
+
+        # Start stdin reader thread
+        stdin_thread = threading.Thread(target=read_stdin, daemon=True)
+        stdin_thread.start()
+
+        try:
+            while True:
+                try:
+                    # Get message from queue (blocking)
+                    message = input_queue.get(timeout=1.0)
+                    if message is None:
+                        break
+
+                    if not message:
+                        continue
+
+                    # Parse the JSON message
+                    data = json.loads(message)
+
+                    # Process the MCP message
+                    response = await self._process_mcp_message(data)
+
+                    if response:
+                        # Send response to stdout
+                        response_json = json.dumps(response)
+                        print(response_json, flush=True)
+
+                except queue.Empty:
+                    # Timeout - continue loop to check for shutdown
+                    continue
+                except json.JSONDecodeError as e:
+                    logger.error(f"Invalid JSON received: {e}")
+                    continue
+                except Exception as e:
+                    logger.error(f"Error processing stdio message: {e}")
+                    error_response = {
+                        "jsonrpc": "2.0",
+                        "id": data.get("id") if 'data' in locals() else None,
+                        "error": {
+                            "code": -32603,
+                            "message": str(e)
+                        }
+                    }
+                    print(json.dumps(error_response), flush=True)
+
+        except KeyboardInterrupt:
+            logger.info("Stdio server interrupted")
+        except Exception as e:
+            logger.error(f"Stdio server error: {e}")
+        finally:
+            logger.info("Stdio server shutting down")
+            # Shutdown activity tracker to flush pending activities
+            if ACTIVITY_TRACKING_ENABLED:
+                shutdown_tracker()
+
+    async def _handle_client(self, websocket):
+        """
+        Handles a connected WebSocket client.
+        """
+        client_id = id(websocket)
+        self.connected_clients[client_id] = websocket
+        logger.info(f"Client {client_id} connected")
+        
+        try:
+            async for message in websocket:
+                try:
+                    # Parse the message as JSON
+                    try:
+                        data = json.loads(message)
+                    except json.JSONDecodeError:
+                        logger.error(f"Invalid JSON from client {client_id}: {message}")
+                        await websocket.send(json.dumps({
+                            "type": "error",
+                            "error": "Invalid JSON message format",
+                            "timestamp": datetime.now().isoformat()
+                        }))
+                        continue
+                    
+                    # Generate a request ID if not provided
+                    request_id = data.get("id", str(int(time.time() * 1000)))
+                    if "id" not in data:
+                        data["id"] = request_id
+                        
+                    # Process based on message type
+                    if "type" not in data:
+                        logger.error(f"Missing 'type' in message from client {client_id}: {data}")
+                        await websocket.send(json.dumps({
+                            "id": request_id,
+                            "type": "error",
+                            "error": "Missing 'type' in message",
+                            "timestamp": datetime.now().isoformat()
+                        }))
+                        continue
+                        
+                    message_type = data["type"]
+                    
+                    # Check for tool request
+                    if message_type == "tool_request":
+                        if "tool" not in data or "arguments" not in data:
+                            logger.error(f"Missing 'tool' or 'arguments' in tool request from client {client_id}: {data}")
+                            await websocket.send(json.dumps({
+                                "id": request_id,
+                                "type": "error",
+                                "error": "Tool request must include 'tool' and 'arguments'",
+                                "timestamp": datetime.now().isoformat()
+                            }))
+                            continue
+                            
+                        tool_name = data["tool"]
+                        arguments = data["arguments"]
+                        
+                        try:
+                            result = self.call_tool(tool_name, arguments)
+
+                            # Check if response should be summarized for stability
+                            if should_summarize_response(result):
+                                logger.info(f"Large response detected for {tool_name}, creating summary...")
+                                result = summarize_large_response(result, tool_name)
+                                logger.info(f"Response summarized for {tool_name}")
+
+                            response = {
+                                "id": request_id,
+                                "type": "tool_response",
+                                "result": result,
+                                "tool": tool_name,
+                                "status": "success",
+                                "timestamp": datetime.now().isoformat()
+                            }
+
+                            await websocket.send(json.dumps(response))
+
+                        except Exception as e:
+                            logger.error(f"Error calling tool {tool_name}: {e}")
+                            await websocket.send(json.dumps({
+                                "id": request_id,
+                                "type": "tool_response",
+                                "tool": tool_name,
+                                "status": "error",
+                                "error": str(e),
+                                "timestamp": datetime.now().isoformat()
+                            }))
+                    
+                    # Check for command request
+                    elif message_type == "command" or message_type == "mcp_command":
+                        if "command" not in data or "params" not in data:
+                            logger.error(f"Missing 'command' or 'params' in command request from client {client_id}: {data}")
+                            await websocket.send(json.dumps({
+                                "id": request_id,
+                                "type": "error",
+                                "error": "Command request must include 'command' and 'params'",
+                                "timestamp": datetime.now().isoformat()
+                            }))
+                            continue
+                            
+                        command_name = data["command"]
+                        params = data["params"]
+                        
+                        try:
+                            # Try to find a tool with this name
+                            if command_name in self.tools:
+                                result = self.call_tool(command_name, params)
+
+                                # Check if response should be summarized for stability
+                                if should_summarize_response(result):
+                                    logger.info(f"Large command response detected for {command_name}, creating summary...")
+                                    result = summarize_large_response(result, command_name)
+                                    logger.info(f"Command response summarized for {command_name}")
+
+                                await websocket.send(json.dumps({
+                                    "id": request_id,
+                                    "type": "command_response",
+                                    "result": result,
+                                    "command": command_name,
+                                    "status": "success",
+                                    "timestamp": datetime.now().isoformat()
+                                }))
+                            else:
+                                logger.error(f"Command {command_name} not found")
+                                await websocket.send(json.dumps({
+                                    "id": request_id,
+                                    "type": "command_response",
+                                    "command": command_name,
+                                    "status": "error",
+                                    "error": f"Command '{command_name}' not found",
+                                    "timestamp": datetime.now().isoformat()
+                                }))
+                        except Exception as e:
+                            logger.error(f"Error executing command {command_name}: {e}")
+                            await websocket.send(json.dumps({
+                                "id": request_id,
+                                "type": "command_response",
+                                "command": command_name,
+                                "status": "error",
+                                "error": str(e),
+                                "timestamp": datetime.now().isoformat()
+                            }))
+                    
+                    # Check for tool list request
+                    elif message_type == "list_tools":
+                        tools_info = self.get_tools_description()
+                        await websocket.send(json.dumps({
+                            "id": request_id,
+                            "type": "tool_list",
+                            "tools": tools_info,
+                            "count": len(tools_info),
+                            "timestamp": datetime.now().isoformat()
+                        }))
+                    
+                    # Unknown message type
+                    else:
+                        logger.error(f"Unknown message type from client {client_id}: {message_type}")
+                        await websocket.send(json.dumps({
+                            "id": request_id,
+                            "type": "error",
+                            "error": f"Unknown message type: {message_type}",
+                            "timestamp": datetime.now().isoformat()
+                        }))
+                except Exception as e:
+                    logger.error(f"Error processing message from client {client_id}: {e}")
+                    logger.error(traceback.format_exc())
+                    try:
+                        await websocket.send(json.dumps({
+                            "type": "error",
+                            "error": f"Server error: {str(e)}",
+                            "traceback": traceback.format_exc(),
+                            "timestamp": datetime.now().isoformat()
+                        }))
+                    except:
+                        logger.error("Failed to send error message to client")
+        except websockets.exceptions.ConnectionClosed:
+            logger.info(f"Client {client_id} disconnected")
+        finally:
+            # Clean up the client when they disconnect
+            if client_id in self.connected_clients:
+                del self.connected_clients[client_id]
+
+    async def _process_mcp_message(self, data):
+        """
+        Process MCP protocol messages for stdio mode.
+        """
+        try:
+            # Handle MCP initialization
+            if data.get("method") == "initialize":
+                return {
+                    "jsonrpc": "2.0",
+                    "id": data.get("id"),
+                    "result": {
+                        "protocolVersion": "2024-11-05",
+                        "capabilities": {
+                            "tools": {}
+                        },
+                        "serverInfo": {
+                            "name": self.name,
+                            "version": "1.0.0"
+                        }
+                    }
+                }
+
+            # Handle tools/list request
+            elif data.get("method") == "tools/list":
+                tools_list = []
+                for tool_name, tool_info in self.tools.items():
+                    tools_list.append({
+                        "name": tool_name,
+                        "description": tool_info.get("description", ""),
+                        "inputSchema": tool_info.get("schema", {
+                            "type": "object",
+                            "properties": {},
+                            "required": []
+                        })
+                    })
+
+                return {
+                    "jsonrpc": "2.0",
+                    "id": data.get("id"),
+                    "result": {
+                        "tools": tools_list
+                    }
+                }
+
+            # Handle tools/call request
+            elif data.get("method") == "tools/call":
+                params = data.get("params", {})
+                tool_name = params.get("name")
+                arguments = params.get("arguments", {})
+
+                if tool_name in self.tools:
+                    result = self.call_tool(tool_name, arguments)
+                    return {
+                        "jsonrpc": "2.0",
+                        "id": data.get("id"),
+                        "result": {
+                            "content": [
+                                {
+                                    "type": "text",
+                                    "text": str(result)
+                                }
+                            ]
+                        }
+                    }
+                else:
+                    return {
+                        "jsonrpc": "2.0",
+                        "id": data.get("id"),
+                        "error": {
+                            "code": -32601,
+                            "message": f"Tool '{tool_name}' not found"
+                        }
+                    }
+
+            # Handle notifications (no response needed)
+            elif "id" not in data:
+                return None
+
+            # Handle malformed requests with None method (ignore them like createlex-bridge)
+            elif data.get('method') is None or data.get('method') == 'None':
+                return None  # Ignore malformed requests instead of returning errors
+
+            # Unknown method
+            else:
+                return {
+                    "jsonrpc": "2.0",
+                    "id": data.get("id"),
+                    "error": {
+                        "code": -32601,
+                        "message": f"Method '{data.get('method')}' not found"
+                    }
+                }
+
+        except Exception as e:
+            logger.error(f"Error processing MCP message: {e}")
+            return {
+                "jsonrpc": "2.0",
+                "id": data.get("id"),
+                "error": {
+                    "code": -32603,
+                    "message": str(e)
+                }
+            }