letta-nightly 0.5.1.dev20241030104135__py3-none-any.whl → 0.5.1.dev20241101104122__py3-none-any.whl

letta/agent.py

@@ -20,6 +20,7 @@ from letta.constants import (
     REQ_HEARTBEAT_MESSAGE,
 )
 from letta.errors import LLMError
+from letta.helpers import ToolRulesSolver
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import is_context_overflow_error
 from letta.llm_api.llm_api_tools import create
@@ -43,6 +44,7 @@ from letta.schemas.openai.chat_completion_response import (
 from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.passage import Passage
 from letta.schemas.tool import Tool
+from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
 from letta.system import (
     get_heartbeat,
@@ -242,6 +244,14 @@ class Agent(BaseAgent):
         # link tools
         self.link_tools(tools)
 
+        # initialize a tool rules solver
+        if agent_state.tool_rules:
+            # if there are tool rules, print out a warning
+            warnings.warn("Tool rules only work reliably for the latest OpenAI models that support structured outputs.")
+        # add default rule for having send_message be a terminal tool
+        agent_state.tool_rules.append(TerminalToolRule(tool_name="send_message"))
+        self.tool_rules_solver = ToolRulesSolver(tool_rules=agent_state.tool_rules)
+
         # gpt-4, gpt-3.5-turbo, ...
         self.model = self.agent_state.llm_config.model
 
@@ -465,15 +475,26 @@ class Agent(BaseAgent):
         function_call: str = "auto",
         first_message: bool = False,  # hint
         stream: bool = False,  # TODO move to config?
+        fail_on_empty_response: bool = False,
+        empty_response_retry_limit: int = 3,
     ) -> ChatCompletionResponse:
         """Get response from LLM API"""
+        # Get the allowed tools based on the ToolRulesSolver state
+        allowed_tool_names = self.tool_rules_solver.get_allowed_tool_names()
+
+        if not allowed_tool_names:
+            # if it's empty, any available tools are fair game
+            allowed_functions = self.functions
+        else:
+            allowed_functions = [func for func in self.functions if func["name"] in allowed_tool_names]
+
         try:
             response = create(
                 # agent_state=self.agent_state,
                 llm_config=self.agent_state.llm_config,
                 messages=message_sequence,
                 user_id=self.agent_state.user_id,
-                functions=self.functions,
+                functions=allowed_functions,
                 functions_python=self.functions_python,
                 function_call=function_call,
                 # hint
@@ -484,7 +505,15 @@ class Agent(BaseAgent):
             )
 
             if len(response.choices) == 0 or response.choices[0] is None:
-                raise Exception(f"API call didn't return a message: {response}")
+                empty_api_err_message = f"API call didn't return a message: {response}"
+                if fail_on_empty_response or empty_response_retry_limit == 0:
+                    raise Exception(empty_api_err_message)
+                else:
+                    # Decrement retry limit and try again
+                    warnings.warn(empty_api_err_message)
+                    return self._get_ai_reply(
+                        message_sequence, function_call, first_message, stream, fail_on_empty_response, empty_response_retry_limit - 1
+                    )
 
             # special case for 'length'
             if response.choices[0].finish_reason == "length":
@@ -515,6 +544,7 @@ class Agent(BaseAgent):
             assert response_message_id.startswith("message-"), response_message_id
 
         messages = []  # append these to the history when done
+        function_name = None
 
         # Step 2: check if LLM wanted to call a function
         if response_message.function_call or (response_message.tool_calls is not None and len(response_message.tool_calls) > 0):
@@ -724,6 +754,15 @@ class Agent(BaseAgent):
         # TODO: @charles please check this
         self.rebuild_memory()
 
+        # Update ToolRulesSolver state with last called function
+        self.tool_rules_solver.update_tool_usage(function_name)
+
+        # Update heartbeat request according to provided tool rules
+        if self.tool_rules_solver.has_children_tools(function_name):
+            heartbeat_request = True
+        elif self.tool_rules_solver.is_terminal_tool(function_name):
+            heartbeat_request = False
+
         return messages, heartbeat_request, function_failed
 
     def step(

letta/client/client.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, Generator, List, Optional, Union
 import requests
 
 import letta.utils
-from letta.constants import BASE_TOOLS, DEFAULT_HUMAN, DEFAULT_PERSONA
+from letta.constants import ADMIN_PREFIX, BASE_TOOLS, DEFAULT_HUMAN, DEFAULT_PERSONA
 from letta.data_sources.connectors import DataConnector
 from letta.functions.functions import parse_source_code
 from letta.memory import get_memory_functions
@@ -39,9 +39,11 @@ from letta.schemas.memory import (
 )
 from letta.schemas.message import Message, MessageCreate, UpdateMessage
 from letta.schemas.openai.chat_completions import ToolCall
+from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source, SourceCreate, SourceUpdate
 from letta.schemas.tool import Tool, ToolCreate, ToolUpdate
+from letta.schemas.tool_rule import BaseToolRule
 from letta.server.rest_api.interface import QueuingInterface
 from letta.server.server import SyncServer
 from letta.utils import get_human_text, get_persona_text
@@ -139,6 +141,8 @@ class AbstractClient(object):
         agent_id: Optional[str] = None,
         name: Optional[str] = None,
         stream: Optional[bool] = False,
+        stream_steps: bool = False,
+        stream_tokens: bool = False,
         include_full_message: Optional[bool] = False,
     ) -> LettaResponse:
         raise NotImplementedError
@@ -195,7 +199,6 @@ class AbstractClient(object):
         self,
         func,
         name: Optional[str] = None,
-        update: Optional[bool] = True,
         tags: Optional[List[str]] = None,
     ) -> Tool:
         raise NotImplementedError
@@ -204,6 +207,7 @@ class AbstractClient(object):
         self,
         id: str,
         name: Optional[str] = None,
+        description: Optional[str] = None,
         func: Optional[Callable] = None,
         tags: Optional[List[str]] = None,
     ) -> Tool:
@@ -282,6 +286,15 @@ class AbstractClient(object):
     def list_embedding_configs(self) -> List[EmbeddingConfig]:
         raise NotImplementedError
 
+    def create_org(self, name: Optional[str] = None) -> Organization:
+        raise NotImplementedError
+
+    def list_orgs(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Organization]:
+        raise NotImplementedError
+
+    def delete_org(self, org_id: str) -> Organization:
+        raise NotImplementedError
+
 
 class RESTClient(AbstractClient):
     """
@@ -394,7 +407,7 @@ class RESTClient(AbstractClient):
         # add memory tools
         memory_functions = get_memory_functions(memory)
         for func_name, func in memory_functions.items():
-            tool = self.create_tool(func, name=func_name, tags=["memory", "letta-base"], update=True)
+            tool = self.create_tool(func, name=func_name, tags=["memory", "letta-base"])
             tool_names.append(tool.name)
 
         # check if default configs are provided
@@ -778,7 +791,7 @@ class RESTClient(AbstractClient):
         name: Optional[str] = None,
         stream_steps: bool = False,
         stream_tokens: bool = False,
-        include_full_message: Optional[bool] = False,
+        include_full_message: bool = False,
     ) -> Union[LettaResponse, Generator[LettaStreamingResponse, None, None]]:
         """
         Send a message to an agent
@@ -799,7 +812,12 @@ class RESTClient(AbstractClient):
         # TODO: figure out how to handle stream_steps and stream_tokens
 
         # When streaming steps is True, stream_tokens must be False
-        request = LettaRequest(messages=messages, stream_steps=stream_steps, stream_tokens=stream_tokens, return_message_object=True)
+        request = LettaRequest(
+            messages=messages,
+            stream_steps=stream_steps,
+            stream_tokens=stream_tokens,
+            return_message_object=include_full_message,
+        )
         if stream_tokens or stream_steps:
             from letta.client.streaming import _sse_post
 
@@ -814,12 +832,12 @@ class RESTClient(AbstractClient):
             response = LettaResponse(**response.json())
 
             # simplify messages
-            if not include_full_message:
-                messages = []
-                for m in response.messages:
-                    assert isinstance(m, Message)
-                    messages += m.to_letta_message()
-                response.messages = messages
+            # if not include_full_message:
+            #     messages = []
+            #     for m in response.messages:
+            #         assert isinstance(m, Message)
+            #         messages += m.to_letta_message()
+            #     response.messages = messages
 
             return response
 
@@ -1257,7 +1275,6 @@ class RESTClient(AbstractClient):
         self,
         func: Callable,
         name: Optional[str] = None,
-        update: Optional[bool] = True,  # TODO: actually use this
         tags: Optional[List[str]] = None,
     ) -> Tool:
         """
@@ -1267,7 +1284,6 @@ class RESTClient(AbstractClient):
             func (callable): The function to create a tool for.
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
-            update (bool, optional): Update the tool if it already exists. Defaults to True.
 
         Returns:
             tool (Tool): The created tool.
@@ -1292,6 +1308,7 @@ class RESTClient(AbstractClient):
         self,
         id: str,
         name: Optional[str] = None,
+        description: Optional[str] = None,
         func: Optional[Callable] = None,
         tags: Optional[List[str]] = None,
     ) -> Tool:
@@ -1314,7 +1331,7 @@ class RESTClient(AbstractClient):
 
         source_type = "python"
 
-        request = ToolUpdate(source_type=source_type, source_code=source_code, tags=tags, name=name)
+        request = ToolUpdate(description=description, source_type=source_type, source_code=source_code, tags=tags, name=name)
         response = requests.patch(f"{self.base_url}/{self.api_prefix}/tools/{id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update tool: {response.text}")
@@ -1464,6 +1481,54 @@ class RESTClient(AbstractClient):
             raise ValueError(f"Failed to list embedding configs: {response.text}")
         return [EmbeddingConfig(**config) for config in response.json()]
 
+    def list_orgs(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Organization]:
+        """
+        Retrieves a list of all organizations in the database, with optional pagination.
+
+        @param cursor: the pagination cursor, if any
+        @param limit: the maximum number of organizations to retrieve
+        @return: a list of Organization objects
+        """
+        params = {"cursor": cursor, "limit": limit}
+        response = requests.get(f"{self.base_url}/{ADMIN_PREFIX}/orgs", headers=self.headers, params=params)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to retrieve organizations: {response.text}")
+        return [Organization(**org_data) for org_data in response.json()]
+
+    def create_org(self, name: Optional[str] = None) -> Organization:
+        """
+        Creates an organization with the given name. If not provided, we generate a random one.
+
+        @param name: the name of the organization
+        @return: the created Organization
+        """
+        payload = {"name": name}
+        response = requests.post(f"{self.base_url}/{ADMIN_PREFIX}/orgs", headers=self.headers, json=payload)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to create org: {response.text}")
+        return Organization(**response.json())
+
+    def delete_org(self, org_id: str) -> Organization:
+        """
+        Deletes an organization by its ID.
+
+        @param org_id: the ID of the organization to delete
+        @return: the deleted Organization object
+        """
+        # Define query parameters with org_id
+        params = {"org_id": org_id}
+
+        # Make the DELETE request with query parameters
+        response = requests.delete(f"{self.base_url}/{ADMIN_PREFIX}/orgs", headers=self.headers, params=params)
+
+        if response.status_code == 404:
+            raise ValueError(f"Organization with ID '{org_id}' does not exist")
+        elif response.status_code != 200:
+            raise ValueError(f"Failed to delete organization: {response.text}")
+
+        # Parse and return the deleted organization
+        return Organization(**response.json())
+
 
 class LocalClient(AbstractClient):
     """
@@ -1568,6 +1633,7 @@ class LocalClient(AbstractClient):
         system: Optional[str] = None,
         # tools
         tools: Optional[List[str]] = None,
+        tool_rules: Optional[List[BaseToolRule]] = None,
         include_base_tools: Optional[bool] = True,
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
@@ -1582,6 +1648,7 @@ class LocalClient(AbstractClient):
             memory (Memory): Memory configuration
             system (str): System configuration
             tools (List[str]): List of tools
+            tool_rules (Optional[List[BaseToolRule]]): List of tool rules
             include_base_tools (bool): Include base tools
             metadata (Dict): Metadata
             description (str): Description
@@ -1603,7 +1670,7 @@ class LocalClient(AbstractClient):
         # add memory tools
         memory_functions = get_memory_functions(memory)
         for func_name, func in memory_functions.items():
-            tool = self.create_tool(func, name=func_name, tags=["memory", "letta-base"], update=True)
+            tool = self.create_tool(func, name=func_name, tags=["memory", "letta-base"])
             tool_names.append(tool.name)
 
         self.interface.clear()
@@ -1620,6 +1687,7 @@ class LocalClient(AbstractClient):
                 metadata_=metadata,
                 memory=memory,
                 tools=tool_names,
+                tool_rules=tool_rules,
                 system=system,
                 agent_type=agent_type,
                 llm_config=llm_config if llm_config else self._default_llm_config,
@@ -2175,7 +2243,6 @@ class LocalClient(AbstractClient):
     def load_langchain_tool(self, langchain_tool: "LangChainBaseTool", additional_imports_module_attr_map: dict[str, str] = None) -> Tool:
         tool_create = ToolCreate.from_langchain(
             langchain_tool=langchain_tool,
-            organization_id=self.org_id,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
         )
         return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
@@ -2184,12 +2251,11 @@ class LocalClient(AbstractClient):
         tool_create = ToolCreate.from_crewai(
             crewai_tool=crewai_tool,
             additional_imports_module_attr_map=additional_imports_module_attr_map,
-            organization_id=self.org_id,
         )
         return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
 
     def load_composio_tool(self, action: "ActionType") -> Tool:
-        tool_create = ToolCreate.from_composio(action=action, organization_id=self.org_id)
+        tool_create = ToolCreate.from_composio(action=action)
         return self.server.tool_manager.create_or_update_tool(tool_create, actor=self.user)
 
     # TODO: Use the above function `add_tool` here as there is duplicate logic
@@ -2197,9 +2263,8 @@ class LocalClient(AbstractClient):
         self,
         func,
         name: Optional[str] = None,
-        update: Optional[bool] = True,  # TODO: actually use this
         tags: Optional[List[str]] = None,
-        terminal: Optional[bool] = False,
+        description: Optional[str] = None,
     ) -> Tool:
         """
         Create a tool. This stores the source code of function on the server, so that the server can execute the function and generate an OpenAI JSON schemas for it when using with an agent.
@@ -2208,8 +2273,7 @@ class LocalClient(AbstractClient):
             func (callable): The function to create a tool for.
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
-            update (bool, optional): Update the tool if it already exists. Defaults to True.
-            terminal (bool, optional): Whether the tool is a terminal tool (no more agent steps). Defaults to False.
+            description (str, optional): The description.
 
         Returns:
             tool (Tool): The created tool.
@@ -2229,7 +2293,7 @@ class LocalClient(AbstractClient):
                 source_code=source_code,
                 name=name,
                 tags=tags,
-                terminal=terminal,
+                description=description,
             ),
             actor=self.user,
         )
@@ -2238,6 +2302,7 @@ class LocalClient(AbstractClient):
         self,
         id: str,
         name: Optional[str] = None,
+        description: Optional[str] = None,
         func: Optional[callable] = None,
         tags: Optional[List[str]] = None,
     ) -> Tool:
@@ -2258,6 +2323,7 @@ class LocalClient(AbstractClient):
             "source_code": parse_source_code(func) if func else None,
             "tags": tags,
             "name": name,
+            "description": description,
         }
 
         # Filter out any None values from the dictionary
@@ -2648,3 +2714,12 @@ class LocalClient(AbstractClient):
             configs (List[EmbeddingConfig]): List of embedding configurations
         """
         return self.server.list_embedding_models()
+
+    def create_org(self, name: Optional[str] = None) -> Organization:
+        return self.server.organization_manager.create_organization(name=name)
+
+    def list_orgs(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Organization]:
+        return self.server.organization_manager.list_organizations(cursor=cursor, limit=limit)
+
+    def delete_org(self, org_id: str) -> Organization:
+        return self.server.organization_manager.delete_organization_by_id(org_id=org_id)

letta/client/streaming.py

@@ -13,6 +13,7 @@ from letta.schemas.letta_message import (
     InternalMonologue,
 )
 from letta.schemas.letta_response import LettaStreamingResponse
+from letta.schemas.usage import LettaUsageStatistics
 
 
 def _sse_post(url: str, data: dict, headers: dict) -> Generator[LettaStreamingResponse, None, None]:
@@ -58,6 +59,8 @@ def _sse_post(url: str, data: dict, headers: dict) -> Generator[LettaStreamingRe
                             yield FunctionCallMessage(**chunk_data)
                         elif "function_return" in chunk_data:
                             yield FunctionReturn(**chunk_data)
+                        elif "usage" in chunk_data:
+                            yield LettaUsageStatistics(**chunk_data["usage"])
                         else:
                             raise ValueError(f"Unknown message type in chunk_data: {chunk_data}")
 

letta/constants.py

@@ -3,6 +3,9 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 
+ADMIN_PREFIX = "/v1/admin"
+API_PREFIX = "/v1"
+OPENAI_API_PREFIX = "/openai"
 
 # String in the error message for when the context window is too large
 # Example full message:

letta/functions/functions.py

@@ -7,10 +7,9 @@ from typing import Optional
 
 from letta.constants import CLI_WARNING_PREFIX
 from letta.functions.schema_generator import generate_schema
-from letta.schemas.tool import ToolCreate
 
 
-def derive_openai_json_schema(tool_create: ToolCreate) -> dict:
+def derive_openai_json_schema(source_code: str, name: Optional[str]) -> dict:
     # auto-generate openai schema
     try:
         # Define a custom environment with necessary imports
@@ -19,14 +18,14 @@ def derive_openai_json_schema(tool_create: ToolCreate) -> dict:
         }
 
         env.update(globals())
-        exec(tool_create.source_code, env)
+        exec(source_code, env)
 
         # get available functions
         functions = [f for f in env if callable(env[f])]
 
         # TODO: not sure if this always works
         func = env[functions[-1]]
-        json_schema = generate_schema(func, terminal=tool_create.terminal, name=tool_create.name)
+        json_schema = generate_schema(func, name=name)
         return json_schema
     except Exception as e:
         raise RuntimeError(f"Failed to execute source code: {e}")
@@ -51,7 +50,7 @@ def load_function_set(module: ModuleType) -> dict:
             if attr_name in function_dict:
                 raise ValueError(f"Found a duplicate of function name '{attr_name}'")
 
-            generated_schema = generate_schema(attr, terminal=False)
+            generated_schema = generate_schema(attr)
             function_dict[attr_name] = {
                 "module": inspect.getsource(module),
                 "python_function": attr,

letta/functions/schema_generator.py

@@ -3,6 +3,7 @@ from typing import Any, Dict, Optional, Type, Union, get_args, get_origin
 
 from docstring_parser import parse
 from pydantic import BaseModel
+from pydantic.v1 import BaseModel as V1BaseModel
 
 
 def is_optional(annotation):
@@ -74,7 +75,7 @@ def pydantic_model_to_open_ai(model):
     }
 
 
-def generate_schema(function, terminal: Optional[bool], name: Optional[str] = None, description: Optional[str] = None) -> dict:
+def generate_schema(function, name: Optional[str] = None, description: Optional[str] = None) -> dict:
     # Get the signature of the function
     sig = inspect.signature(function)
 
@@ -128,7 +129,7 @@ def generate_schema(function, terminal: Optional[bool], name: Optional[str] = No
 
     # append the heartbeat
     # TODO: don't hard-code
-    if function.__name__ not in ["send_message", "pause_heartbeats"] and not terminal:
+    if function.__name__ not in ["send_message", "pause_heartbeats"]:
         schema["parameters"]["properties"]["request_heartbeat"] = {
             "type": "boolean",
             "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
@@ -139,7 +140,7 @@ def generate_schema(function, terminal: Optional[bool], name: Optional[str] = No
 
 
 def generate_schema_from_args_schema(
-    args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
+    args_schema: Type[V1BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
 ) -> Dict[str, Any]:
     properties = {}
     required = []

letta/helpers/__init__.py

@@ -0,0 +1 @@
+from letta.helpers.tool_rule_solver import ToolRulesSolver

letta/helpers/tool_rule_solver.py

@@ -0,0 +1,115 @@
+import warnings
+from typing import Dict, List, Optional, Set
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.tool_rule import (
+    BaseToolRule,
+    InitToolRule,
+    TerminalToolRule,
+    ToolRule,
+)
+
+
+class ToolRuleValidationError(Exception):
+    """Custom exception for tool rule validation errors in ToolRulesSolver."""
+
+    def __init__(self, message: str):
+        super().__init__(f"ToolRuleValidationError: {message}")
+
+
+class ToolRulesSolver(BaseModel):
+    init_tool_rules: List[InitToolRule] = Field(
+        default_factory=list, description="Initial tool rules to be used at the start of tool execution."
+    )
+    tool_rules: List[ToolRule] = Field(
+        default_factory=list, description="Standard tool rules for controlling execution sequence and allowed transitions."
+    )
+    terminal_tool_rules: List[TerminalToolRule] = Field(
+        default_factory=list, description="Terminal tool rules that end the agent loop if called."
+    )
+    last_tool_name: Optional[str] = Field(None, description="The most recent tool used, updated with each tool call.")
+
+    def __init__(self, tool_rules: List[BaseToolRule], **kwargs):
+        super().__init__(**kwargs)
+        # Separate the provided tool rules into init, standard, and terminal categories
+        for rule in tool_rules:
+            if isinstance(rule, InitToolRule):
+                self.init_tool_rules.append(rule)
+            elif isinstance(rule, ToolRule):
+                self.tool_rules.append(rule)
+            elif isinstance(rule, TerminalToolRule):
+                self.terminal_tool_rules.append(rule)
+
+        # Validate the tool rules to ensure they form a DAG
+        if not self.validate_tool_rules():
+            raise ToolRuleValidationError("Tool rules contain cycles, which are not allowed in a valid configuration.")
+
+    def update_tool_usage(self, tool_name: str):
+        """Update the internal state to track the last tool called."""
+        self.last_tool_name = tool_name
+
+    def get_allowed_tool_names(self, error_on_empty: bool = False) -> List[str]:
+        """Get a list of tool names allowed based on the last tool called."""
+        if self.last_tool_name is None:
+            # Use initial tool rules if no tool has been called yet
+            return [rule.tool_name for rule in self.init_tool_rules]
+        else:
+            # Find a matching ToolRule for the last tool used
+            current_rule = next((rule for rule in self.tool_rules if rule.tool_name == self.last_tool_name), None)
+
+            # Return children which must exist on ToolRule
+            if current_rule:
+                return current_rule.children
+
+            # Default to empty if no rule matches
+            message = "User provided tool rules and execution state resolved to no more possible tool calls."
+            if error_on_empty:
+                raise RuntimeError(message)
+            else:
+                warnings.warn(message)
+                return []
+
+    def is_terminal_tool(self, tool_name: str) -> bool:
+        """Check if the tool is defined as a terminal tool in the terminal tool rules."""
+        return any(rule.tool_name == tool_name for rule in self.terminal_tool_rules)
+
+    def has_children_tools(self, tool_name):
+        """Check if the tool has children tools"""
+        return any(rule.tool_name == tool_name for rule in self.tool_rules)
+
+    def validate_tool_rules(self) -> bool:
+        """
+        Validate that the tool rules define a directed acyclic graph (DAG).
+        Returns True if valid (no cycles), otherwise False.
+        """
+        # Build adjacency list for the tool graph
+        adjacency_list: Dict[str, List[str]] = {rule.tool_name: rule.children for rule in self.tool_rules}
+
+        # Track visited nodes
+        visited: Set[str] = set()
+        path_stack: Set[str] = set()
+
+        # Define DFS helper function
+        def dfs(tool_name: str) -> bool:
+            if tool_name in path_stack:
+                return False  # Cycle detected
+            if tool_name in visited:
+                return True  # Already validated
+
+            # Mark the node as visited in the current path
+            path_stack.add(tool_name)
+            for child in adjacency_list.get(tool_name, []):
+                if not dfs(child):
+                    return False  # Cycle detected in DFS
+            path_stack.remove(tool_name)  # Remove from current path
+            visited.add(tool_name)
+            return True
+
+        # Run DFS from each tool in `tool_rules`
+        for rule in self.tool_rules:
+            if rule.tool_name not in visited:
+                if not dfs(rule.tool_name):
+                    return False  # Cycle found, invalid tool rules
+
+        return True  # No cycles, valid DAG

letta/llm_api/helpers.py

@@ -16,9 +16,11 @@ def convert_to_structured_output(openai_function: dict) -> dict:
 
     See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas
     """
+    description = openai_function["description"] if "description" in openai_function else ""
+
     structured_output = {
         "name": openai_function["name"],
-        "description": openai_function["description"],
+        "description": description,
         "strict": True,
         "parameters": {"type": "object", "properties": {}, "additionalProperties": False, "required": []},
     }

letta/llm_api/llm_api_tools.py

@@ -106,7 +106,7 @@ def create(
     messages: List[Message],
     user_id: Optional[str] = None,  # option UUID to associate request with
     functions: Optional[list] = None,
-    functions_python: Optional[list] = None,
+    functions_python: Optional[dict] = None,
     function_call: str = "auto",
     # hint
     first_message: bool = False,
@@ -140,7 +140,6 @@ def create(
             raise ValueError(f"OpenAI key is missing from letta config file")
 
         data = build_openai_chat_completions_request(llm_config, messages, user_id, functions, function_call, use_tool_naming, max_tokens)
-
         if stream:  # Client requested token streaming
             data.stream = True
             assert isinstance(stream_interface, AgentChunkStreamingInterface) or isinstance(

letta/llm_api/openai.py

@@ -530,7 +530,12 @@ def openai_chat_completions_request(
         data.pop("tools")
         data.pop("tool_choice", None)  # extra safe,  should exist always (default="auto")
 
+    if "tools" in data:
+        for tool in data["tools"]:
+            tool["function"] = convert_to_structured_output(tool["function"])
+
     response_json = make_post_request(url, headers, data)
+
     return ChatCompletionResponse(**response_json)