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

letta/schemas/tool.py

@@ -3,7 +3,6 @@ from typing import Any, Dict, List, Optional
 from pydantic import ConfigDict, Field, model_validator
 
 from letta.constants import (
-    COMPOSIO_TOOL_TAG_NAME,
     FUNCTION_RETURN_CHAR_LIMIT,
     LETTA_BUILTIN_TOOL_MODULE_NAME,
     LETTA_CORE_TOOL_MODULE_NAME,
@@ -16,15 +15,9 @@ from letta.constants import (
 # MCP Tool metadata constants for schema health status
 MCP_TOOL_METADATA_SCHEMA_STATUS = f"{MCP_TOOL_TAG_NAME_PREFIX}:SCHEMA_STATUS"
 MCP_TOOL_METADATA_SCHEMA_WARNINGS = f"{MCP_TOOL_TAG_NAME_PREFIX}:SCHEMA_WARNINGS"
-from letta.functions.ast_parsers import get_function_name_and_docstring
-from letta.functions.composio_helpers import generate_composio_tool_wrapper
-from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
+from letta.functions.functions import get_json_schema_from_module
 from letta.functions.mcp_client.types import MCPTool
-from letta.functions.schema_generator import (
-    generate_schema_from_args_schema_v2,
-    generate_tool_schema_for_composio,
-    generate_tool_schema_for_mcp,
-)
+from letta.functions.schema_generator import generate_tool_schema_for_mcp
 from letta.log import get_logger
 from letta.schemas.enums import ToolSourceType, ToolType
 from letta.schemas.letta_base import LettaBase
@@ -80,46 +73,19 @@ class Tool(BaseTool):
     def refresh_source_code_and_json_schema(self):
         """
         Refresh name, description, source_code, and json_schema.
-        """
-        from letta.functions.helpers import generate_model_from_args_json_schema
-
-        if self.tool_type == ToolType.CUSTOM and not self.json_schema:
-            # attempt various fallbacks to get the JSON schema
-            if not self.source_code:
-                logger.error("Custom tool with id=%s is missing source_code field", self.id)
-                raise ValueError(f"Custom tool with id={self.id} is missing source_code field.")
-
-            if self.source_type == ToolSourceType.typescript:
-                # TypeScript tools don't support args_json_schema, only direct schema generation
-                if not self.json_schema:
-                    try:
-                        from letta.functions.typescript_parser import derive_typescript_json_schema
 
-                        self.json_schema = derive_typescript_json_schema(source_code=self.source_code)
-                    except Exception as e:
-                        logger.error("Failed to derive TypeScript json schema for tool with id=%s name=%s: %s", self.id, self.name, e)
-            elif (
-                self.source_type == ToolSourceType.python or self.source_type is None
-            ):  # default to python if not provided for backwards compatability
-                # Python tool handling
-                # Always derive json_schema for freshest possible json_schema
-                if self.args_json_schema is not None:
-                    name, description = get_function_name_and_docstring(self.source_code, self.name)
-                    args_schema = generate_model_from_args_json_schema(self.args_json_schema)
-                    self.json_schema = generate_schema_from_args_schema_v2(
-                        args_schema=args_schema,
-                        name=name,
-                        description=description,
-                        append_heartbeat=False,
-                    )
-                else:  # elif not self.json_schema: # TODO: JSON schema is not being derived correctly the first time?
-                    # If there's not a json_schema provided, then we need to re-derive
-                    try:
-                        self.json_schema = derive_openai_json_schema(source_code=self.source_code)
-                    except Exception as e:
-                        logger.error("Failed to derive json schema for tool with id=%s name=%s: %s", self.id, self.name, e)
-            else:
-                raise ValueError(f"Unknown tool source type: {self.source_type}")
+        Note: Schema generation for custom tools is now handled at creation/update time in ToolManager.
+        This method only handles built-in Letta tools.
+        """
+        if self.tool_type == ToolType.CUSTOM:
+            # Custom tools should already have their schema set during creation/update
+            # No schema generation happens here anymore
+            if not self.json_schema:
+                logger.warning(
+                    "Custom tool with id=%s name=%s is missing json_schema. Schema should be set during creation/update.",
+                    self.id,
+                    self.name,
+                )
         elif self.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE, ToolType.LETTA_SLEEPTIME_CORE}:
             # If it's letta core tool, we generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_CORE_TOOL_MODULE_NAME, function_name=self.name)
@@ -135,26 +101,6 @@ class Tool(BaseTool):
         elif self.tool_type in {ToolType.LETTA_FILES_CORE}:
             # If it's letta files tool, we generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_FILES_TOOL_MODULE_NAME, function_name=self.name)
-        elif self.tool_type in {ToolType.EXTERNAL_COMPOSIO}:
-            # Composio schemas handled separately
-            pass
-
-        # At this point, we need to validate that at least json_schema is populated
-        if not self.json_schema:
-            logger.error("Tool with id=%s name=%s tool_type=%s is missing a json_schema", self.id, self.name, self.tool_type)
-            raise ValueError(f"Tool with id={self.id} name={self.name} tool_type={self.tool_type} is missing a json_schema.")
-
-        # Derive name from the JSON schema if not provided
-        if not self.name:
-            # TODO: This in theory could error, but name should always be on json_schema
-            # TODO: Make JSON schema a typed pydantic object
-            self.name = self.json_schema.get("name")
-
-        # Derive description from the JSON schema if not provided
-        if not self.description:
-            # TODO: This in theory could error, but description should always be on json_schema
-            # TODO: Make JSON schema a typed pydantic object
-            self.description = self.json_schema.get("description")
 
         return self
 
@@ -199,45 +145,6 @@ class ToolCreate(LettaBase):
             json_schema=json_schema,
         )
 
-    @classmethod
-    def from_composio(cls, action_name: str) -> "ToolCreate":
-        """
-        Class method to create an instance of Letta-compatible Composio Tool.
-        Check https://docs.composio.dev/introduction/intro/overview to look at options for from_composio
-
-        This function will error if we find more than one tool, or 0 tools.
-
-        Args:
-            action_name str: A action name to filter tools by.
-        Returns:
-            Tool: A Letta Tool initialized with attributes derived from the Composio tool.
-        """
-        from composio import ComposioToolSet, LogLevel
-
-        composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR, lock=False)
-        composio_action_schemas = composio_toolset.get_action_schemas(actions=[action_name], check_connected_accounts=False)
-
-        assert len(composio_action_schemas) > 0, "User supplied parameters do not match any Composio tools"
-        assert len(composio_action_schemas) == 1, (
-            f"User supplied parameters match too many Composio tools; {len(composio_action_schemas)} > 1"
-        )
-
-        composio_action_schema = composio_action_schemas[0]
-
-        description = composio_action_schema.description
-        source_type = "python"
-        tags = [COMPOSIO_TOOL_TAG_NAME]
-        wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action_name)
-        json_schema = generate_tool_schema_for_composio(composio_action_schema.parameters, name=wrapper_func_name, description=description)
-
-        return cls(
-            description=description,
-            source_type=source_type,
-            tags=tags,
-            source_code=wrapper_function_str,
-            json_schema=json_schema,
-        )
-
 
 class ToolUpdate(LettaBase):
     description: Optional[str] = Field(None, description="The description of the tool.")
@@ -253,6 +160,7 @@ class ToolUpdate(LettaBase):
     npm_requirements: list[NpmRequirement] | None = Field(None, description="Optional list of npm packages required by this tool.")
     metadata_: Optional[Dict[str, Any]] = Field(None, description="A dictionary of additional metadata for the tool.")
     default_requires_approval: Optional[bool] = Field(None, description="Whether or not to require approval before executing this tool.")
+    # name: Optional[str] = Field(None, description="The name of the tool (must match the JSON schema name and source code function name).")
 
     model_config = ConfigDict(extra="ignore")  # Allows extra fields without validation errors
     # TODO: Remove this, and clean usage of ToolUpdate everywhere else

letta/schemas/tool_rule.py

@@ -2,7 +2,7 @@ import json
 import logging
 from typing import Annotated, Any, Dict, List, Literal, Optional, Set, Union
 
-from pydantic import Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 from letta.schemas.enums import ToolRuleType
 from letta.schemas.letta_base import LettaBase
@@ -36,6 +36,30 @@ class BaseToolRule(LettaBase):
         """Default implementation returns None. Subclasses provide optimized strings."""
         return None
 
+    @property
+    def requires_force_tool_call(self) -> bool:
+        """Whether this tool rule requires forcing a tool call in the LLM request when active.
+        When True, the LLM must use a tool; when False, tool use is optional.
+        Default is False for most rules."""
+        return False
+
+
+class ToolCallNode(BaseModel):
+    """Typed child override for prefilled arguments.
+
+    When used in a ChildToolRule, if this child is selected next, its `args` will be
+    applied as prefilled arguments (overriding overlapping LLM-provided values).
+    """
+
+    name: str = Field(..., description="The name of the child tool to invoke next.")
+    args: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description=(
+            "Optional prefilled arguments for this child tool. Keys must match the tool's parameter names and values "
+            "must satisfy the tool's JSON schema. Supports partial prefill; non-overlapping parameters are left to the model."
+        ),
+    )
+
 
 class ChildToolRule(BaseToolRule):
     """
@@ -43,30 +67,66 @@ class ChildToolRule(BaseToolRule):
     """
 
     type: Literal[ToolRuleType.constrain_child_tools] = ToolRuleType.constrain_child_tools
+
     children: List[str] = Field(..., description="The children tools that can be invoked.")
+    child_arg_nodes: Optional[List[ToolCallNode]] = Field(
+        default=None,
+        description=("Optional list of typed child argument overrides. Each node must reference a child in 'children'."),
+    )
     prompt_template: Optional[str] = Field(
         default=None,
         description="Optional template string (ignored).",
     )
 
+    @property
+    def requires_force_tool_call(self) -> bool:
+        """Child tool rules require forcing tool calls."""
+        return True
+
     def __hash__(self):
         """Hash including children list (sorted for consistency)."""
-        return hash((self.tool_name, self.type, tuple(sorted(self.children))))
+        # Hash on child names only for stability
+        child_names = tuple(sorted(self.children))
+        return hash((self.tool_name, self.type, child_names))
 
     def __eq__(self, other):
         """Equality including children list."""
         if not isinstance(other, ChildToolRule):
             return False
-        return self.tool_name == other.tool_name and self.type == other.type and sorted(self.children) == sorted(other.children)
+        self_names = sorted(self.children)
+        other_names = sorted(other.children)
+        return self.tool_name == other.tool_name and self.type == other.type and self_names == other_names
+
+    def get_child_names(self) -> List[str]:
+        return list(self.children)
+
+    def get_child_args_map(self) -> Dict[str, Dict[str, Any]]:
+        mapping: Dict[str, Dict[str, Any]] = {}
+        if self.child_arg_nodes:
+            for node in self.child_arg_nodes:
+                if node.args:
+                    mapping[node.name] = dict(node.args)
+        return mapping
 
     def get_valid_tools(self, tool_call_history: List[str], available_tools: Set[str], last_function_response: Optional[str]) -> Set[str]:
         last_tool = tool_call_history[-1] if tool_call_history else None
-        return set(self.children) if last_tool == self.tool_name else available_tools
+        return set(self.get_child_names()) if last_tool == self.tool_name else available_tools
 
     def render_prompt(self) -> str | None:
-        children_str = ", ".join(self.children)
+        children_str = ", ".join(self.get_child_names())
         return f"<tool_rule>\nAfter using {self.tool_name}, you must use one of these tools: {children_str}\n</tool_rule>"
 
+    @model_validator(mode="after")
+    def validate_child_arg_nodes(self):
+        if self.child_arg_nodes:
+            child_set = set(self.children)
+            for node in self.child_arg_nodes:
+                if node.name not in child_set:
+                    raise ValueError(
+                        f"ChildToolRule child_arg_nodes contains a node for '{node.name}' which is not in children {self.children}."
+                    )
+        return self
+
 
 class ParentToolRule(BaseToolRule):
     """
@@ -77,6 +137,11 @@ class ParentToolRule(BaseToolRule):
     children: List[str] = Field(..., description="The children tools that can be invoked.")
     prompt_template: Optional[str] = Field(default=None, description="Optional template string (ignored).")
 
+    @property
+    def requires_force_tool_call(self) -> bool:
+        """Parent tool rules require forcing tool calls."""
+        return True
+
     def __hash__(self):
         """Hash including children list (sorted for consistency)."""
         return hash((self.tool_name, self.type, tuple(sorted(self.children))))
@@ -107,6 +172,11 @@ class ConditionalToolRule(BaseToolRule):
     require_output_mapping: bool = Field(default=False, description="Whether to throw an error when output doesn't match any case")
     prompt_template: Optional[str] = Field(default=None, description="Optional template string (ignored).")
 
+    @property
+    def requires_force_tool_call(self) -> bool:
+        """Conditional tool rules require forcing tool calls."""
+        return True
+
     def __hash__(self):
         """Hash including all configuration fields."""
         # convert dict to sorted tuple of items for consistent hashing
@@ -187,6 +257,19 @@ class InitToolRule(BaseToolRule):
     """
 
     type: Literal[ToolRuleType.run_first] = ToolRuleType.run_first
+    args: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description=(
+            "Optional prefilled arguments for this tool. When present, these values will override any LLM-provided "
+            "arguments with the same keys during invocation. Keys must match the tool's parameter names and values "
+            "must satisfy the tool's JSON schema. Supports partial prefill; non-overlapping parameters are left to the model."
+        ),
+    )
+
+    @property
+    def requires_force_tool_call(self) -> bool:
+        """Initial tool rules require forcing tool calls."""
+        return True
 
 
 class TerminalToolRule(BaseToolRule):

letta/serialize_schemas/marshmallow_agent.py

@@ -241,4 +241,5 @@ class MarshmallowAgentSchema(BaseSchema):
             "groups",
             "batch_items",
             "organization",
+            "runs",  # Exclude the runs relationship (agents_runs association table)
         )