letta-nightly 0.11.7.dev20251006104136__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

letta/services/lettuce/lettuce_client_base.py

@@ -0,0 +1,86 @@
+from letta.constants import DEFAULT_MAX_STEPS
+from letta.schemas.agent import AgentState
+from letta.schemas.letta_message import MessageType
+from letta.schemas.message import MessageCreate
+from letta.schemas.user import User
+
+
+class LettuceClient:
+    """Base class for LettuceClient."""
+
+    def __init__(self):
+        """Initialize the LettuceClient."""
+        self.client: None = None
+
+    @classmethod
+    async def create(cls) -> "LettuceClient":
+        """
+        Asynchronously creates the client.
+
+        Returns:
+            LettuceClient: The created LettuceClient instance.
+        """
+        instance = cls()
+        return instance
+
+    def get_client(self) -> None:
+        """
+        Get the inner client.
+
+        Returns:
+            None: The inner client.
+        """
+        return self.client
+
+    async def get_status(self, run_id: str) -> str | None:
+        """
+        Get the status of a run.
+
+        Args:
+            run_id (str): The ID of the run.
+
+        Returns:
+            str | None: The status of the run or None if not available.
+        """
+        return None
+
+    async def cancel(self, run_id: str) -> str | None:
+        """
+        Cancel a run.
+
+        Args:
+            run_id (str): The ID of the run to cancel.
+
+        Returns:
+            str | None: The ID of the canceled run or None if not available.
+        """
+        return None
+
+    async def step(
+        self,
+        agent_state: AgentState,
+        actor: User,
+        input_messages: list[MessageCreate],
+        max_steps: int = DEFAULT_MAX_STEPS,
+        run_id: str | None = None,
+        use_assistant_message: bool = True,
+        include_return_message_types: list[MessageType] | None = None,
+        request_start_timestamp_ns: int | None = None,
+    ) -> str | None:
+        """
+        Execute the agent loop on Lettuce service.
+
+        Args:
+            agent_state (AgentState): The state of the agent.
+            actor (User): The actor.
+            input_messages (list[MessageCreate]): The input messages.
+            max_steps (int, optional): The maximum number of steps. Defaults to DEFAULT_MAX_STEPS.
+            run_id (str | None, optional): The ID of the run. Defaults to None.
+            use_assistant_message (bool, optional): Whether to use the assistant message. Defaults to True.
+            include_return_message_types (list[MessageType] | None, optional): The message types to include in the return. Defaults to None.
+            request_start_timestamp_ns (int | None, optional): The start timestamp of the request. Defaults to None.
+
+        Returns:
+            str | None: The ID of the run or None if client is not available.
+        """
+        return None

letta/services/mcp_manager.py

@@ -18,6 +18,7 @@ from letta.functions.mcp_client.types import (
     StdioServerConfig,
     StreamableHTTPServerConfig,
 )
+from letta.functions.schema_generator import normalize_mcp_schema
 from letta.functions.schema_validator import validate_complete_json_schema
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
@@ -72,7 +73,9 @@ class MCPManager:
             tools = await mcp_client.list_tools()
             # Add health information to each tool
             for tool in tools:
+                # Try to normalize the schema and re-validate\
                 if tool.inputSchema:
+                    tool.inputSchema = normalize_mcp_schema(tool.inputSchema)
                     health_status, reasons = validate_complete_json_schema(tool.inputSchema)
                     tool.health = MCPToolHealth(status=health_status.value, reasons=reasons)
 
@@ -140,12 +143,41 @@ class MCPManager:
         for mcp_tool in mcp_tools:
             # TODO: @jnjpng move health check to tool class
             if mcp_tool.name == mcp_tool_name:
-                # Check tool health - reject only INVALID tools
-                if mcp_tool.health:
-                    if mcp_tool.health.status == "INVALID":
-                        raise ValueError(
-                            f"Tool {mcp_tool_name} cannot be attached, JSON schema is invalid.Reasons: {', '.join(mcp_tool.health.reasons)}"
-                        )
+                # Check tool health - but try normalization first for INVALID schemas
+                if mcp_tool.health and mcp_tool.health.status == "INVALID":
+                    logger.info(f"Attempting to normalize INVALID schema for tool {mcp_tool_name}")
+                    logger.info(f"Original health reasons: {mcp_tool.health.reasons}")
+
+                    # Try to normalize the schema and re-validate
+                    try:
+                        # Normalize the schema to fix common issues
+                        logger.debug(f"Normalizing schema for {mcp_tool_name}")
+                        normalized_schema = normalize_mcp_schema(mcp_tool.inputSchema)
+
+                        # Re-validate after normalization
+                        logger.debug(f"Re-validating schema for {mcp_tool_name}")
+                        health_status, health_reasons = validate_complete_json_schema(normalized_schema)
+                        logger.info(f"After normalization: status={health_status.value}, reasons={health_reasons}")
+
+                        # Update the tool's schema and health (use inputSchema, not input_schema)
+                        mcp_tool.inputSchema = normalized_schema
+                        mcp_tool.health.status = health_status.value
+                        mcp_tool.health.reasons = health_reasons
+
+                        # Log the normalization result
+                        if health_status.value != "INVALID":
+                            logger.info(f"✓ MCP tool {mcp_tool_name} schema normalized successfully: {health_status.value}")
+                        else:
+                            logger.warning(f"MCP tool {mcp_tool_name} still INVALID after normalization. Reasons: {health_reasons}")
+                    except Exception as e:
+                        logger.error(f"Failed to normalize schema for tool {mcp_tool_name}: {e}", exc_info=True)
+
+                # After normalization attempt, check if still INVALID
+                if mcp_tool.health and mcp_tool.health.status == "INVALID":
+                    raise ValueError(
+                        f"Tool {mcp_tool_name} cannot be attached, JSON schema is invalid even after normalization. "
+                        f"Reasons: {', '.join(mcp_tool.health.reasons)}"
+                    )
 
                 tool_create = ToolCreate.from_mcp(mcp_server_name=mcp_server_name, mcp_tool=mcp_tool)
                 return await self.tool_manager.create_mcp_tool_async(