letta-nightly 0.5.1.dev20241106104104__py3-none-any.whl → 0.5.2.dev20241107104040__py3-none-any.whl

letta/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.1"
+__version__ = "0.5.2"
 
 # import clients
 from letta.client.client import LocalClient, RESTClient, create_client

letta/agent.py

@@ -3,7 +3,6 @@ import inspect
 import traceback
 import warnings
 from abc import ABC, abstractmethod
-from lib2to3.fixer_util import is_list
 from typing import List, Literal, Optional, Tuple, Union
 
 from tqdm import tqdm
@@ -249,12 +248,21 @@ class Agent(BaseAgent):
         # 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.")
+            for rule in agent_state.tool_rules:
+                if not isinstance(rule, TerminalToolRule):
+                    warnings.warn("Tool rules only work reliably for the latest OpenAI models that support structured outputs.")
+                    break
         # add default rule for having send_message be a terminal tool
-
-        if not is_list(agent_state.tool_rules):
+        if agent_state.tool_rules is None:
             agent_state.tool_rules = []
-        agent_state.tool_rules.append(TerminalToolRule(tool_name="send_message"))
+        # Define the rule to add
+        send_message_terminal_rule = TerminalToolRule(tool_name="send_message")
+        # Check if an equivalent rule is already present
+        if not any(
+            isinstance(rule, TerminalToolRule) and rule.tool_name == send_message_terminal_rule.tool_name for rule in agent_state.tool_rules
+        ):
+            agent_state.tool_rules.append(send_message_terminal_rule)
+
         self.tool_rules_solver = ToolRulesSolver(tool_rules=agent_state.tool_rules)
 
         # gpt-4, gpt-3.5-turbo, ...
@@ -396,7 +404,6 @@ class Agent(BaseAgent):
                     exec(tool.module, env)
                 else:
                     exec(tool.source_code, env)
-
                 self.functions_python[tool.json_schema["name"]] = env[tool.json_schema["name"]]
                 self.functions.append(tool.json_schema)
             except Exception as e:
@@ -788,7 +795,6 @@ class Agent(BaseAgent):
 
         # 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

letta/agent_store/db.py

@@ -578,4 +578,6 @@ class SQLLiteStorageConnector(SQLStorageConnector):
 def attach_base():
     # This should be invoked in server.py to make sure Base gets initialized properly
     # DO NOT REMOVE
-    print("Initializing database...")
+    from letta.utils import printd
+
+    printd("Initializing database...")

letta/cli/cli.py

@@ -10,7 +10,7 @@ import letta.utils as utils
 from letta import create_client
 from letta.agent import Agent, save_agent
 from letta.config import LettaConfig
-from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR
+from letta.constants import CLI_WARNING_PREFIX, LETTA_DIR, MIN_CONTEXT_WINDOW
 from letta.local_llm.constants import ASSISTANT_MESSAGE_CLI_SYMBOL
 from letta.log import get_logger
 from letta.metadata import MetadataStore
@@ -244,6 +244,19 @@ def run(
             llm_model_name = questionary.select("Select LLM model:", choices=llm_choices).ask().model
         llm_config = [llm_config for llm_config in llm_configs if llm_config.model == llm_model_name][0]
 
+        # option to override context window
+        if llm_config.context_window is not None:
+            context_window_validator = lambda x: x.isdigit() and int(x) > MIN_CONTEXT_WINDOW and int(x) <= llm_config.context_window
+            context_window_input = questionary.text(
+                "Select LLM context window limit (hit enter for default):",
+                default=str(llm_config.context_window),
+                validate=context_window_validator,
+            ).ask()
+            if context_window_input is not None:
+                llm_config.context_window = int(context_window_input)
+            else:
+                sys.exit(1)
+
         # choose form list of embedding configs
         embedding_configs = client.list_embedding_configs()
         embedding_options = [embedding_config.embedding_model for embedding_config in embedding_configs]

letta/client/client.py

@@ -77,6 +77,7 @@ class AbstractClient(object):
         memory: Memory = ChatMemory(human=get_human_text(DEFAULT_HUMAN), persona=get_persona_text(DEFAULT_PERSONA)),
         system: Optional[str] = None,
         tools: Optional[List[str]] = None,
+        tool_rules: Optional[List[BaseToolRule]] = None,
         include_base_tools: Optional[bool] = True,
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
@@ -333,8 +334,12 @@ class RESTClient(AbstractClient):
         self._default_llm_config = default_llm_config
         self._default_embedding_config = default_embedding_config
 
-    def list_agents(self) -> List[AgentState]:
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents", headers=self.headers)
+    def list_agents(self, tags: Optional[List[str]] = None) -> List[AgentState]:
+        params = {}
+        if tags:
+            params["tags"] = tags
+
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents", headers=self.headers, params=params)
         return [AgentState(**agent) for agent in response.json()]
 
     def agent_exists(self, agent_id: str) -> bool:
@@ -372,6 +377,7 @@ class RESTClient(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},
@@ -425,6 +431,7 @@ class RESTClient(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,
@@ -477,6 +484,7 @@ class RESTClient(AbstractClient):
         description: Optional[str] = None,
         system: Optional[str] = None,
         tools: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
         metadata: Optional[Dict] = None,
         llm_config: Optional[LLMConfig] = None,
         embedding_config: Optional[EmbeddingConfig] = None,
@@ -506,6 +514,7 @@ class RESTClient(AbstractClient):
             name=name,
             system=system,
             tools=tools,
+            tags=tags,
             description=description,
             metadata_=metadata,
             llm_config=llm_config,
@@ -1614,13 +1623,10 @@ class LocalClient(AbstractClient):
         self.organization = self.server.get_organization_or_default(self.org_id)
 
     # agents
-    def list_agents(self) -> List[AgentState]:
+    def list_agents(self, tags: Optional[List[str]] = None) -> List[AgentState]:
         self.interface.clear()
 
-        # TODO: fix the server function
-        # return self.server.list_agents(user_id=self.user_id)
-
-        return self.server.ms.list_agents(user_id=self.user_id)
+        return self.server.list_agents(user_id=self.user_id, tags=tags)
 
     def agent_exists(self, agent_id: Optional[str] = None, agent_name: Optional[str] = None) -> bool:
         """
@@ -1754,6 +1760,7 @@ class LocalClient(AbstractClient):
         description: Optional[str] = None,
         system: Optional[str] = None,
         tools: Optional[List[str]] = None,
+        tags: Optional[List[str]] = None,
         metadata: Optional[Dict] = None,
         llm_config: Optional[LLMConfig] = None,
         embedding_config: Optional[EmbeddingConfig] = None,
@@ -1785,6 +1792,7 @@ class LocalClient(AbstractClient):
                 name=name,
                 system=system,
                 tools=tools,
+                tags=tags,
                 description=description,
                 metadata_=metadata,
                 llm_config=llm_config,
@@ -1869,7 +1877,7 @@ class LocalClient(AbstractClient):
             agent_state (AgentState): State of the agent
         """
         self.interface.clear()
-        return self.server.get_agent(agent_name=agent_name, user_id=self.user_id, agent_id=None)
+        return self.server.get_agent_state(agent_name=agent_name, user_id=self.user_id, agent_id=None)
 
     def get_agent(self, agent_id: str) -> AgentState:
         """

letta/constants.py

@@ -18,6 +18,9 @@ IN_CONTEXT_MEMORY_KEYWORD = "CORE_MEMORY"
 # OpenAI error message: Invalid 'messages[1].tool_calls[0].id': string too long. Expected a string with maximum length 29, but got a string with length 36 instead.
 TOOL_CALL_ID_MAX_LEN = 29
 
+# minimum context window size
+MIN_CONTEXT_WINDOW = 4000
+
 # embeddings
 MAX_EMBEDDING_DIM = 4096  # maximum supported embeding size - do NOT change or else DBs will need to be reset
 

letta/functions/functions.py

@@ -9,7 +9,7 @@ from letta.constants import CLI_WARNING_PREFIX
 from letta.functions.schema_generator import generate_schema
 
 
-def derive_openai_json_schema(source_code: str, name: Optional[str]) -> dict:
+def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> dict:
     # auto-generate openai schema
     try:
         # Define a custom environment with necessary imports

letta/helpers/tool_rule_solver.py

@@ -1,4 +1,3 @@
-import warnings
 from typing import Dict, List, Optional, Set
 
 from pydantic import BaseModel, Field
@@ -67,7 +66,7 @@ class ToolRulesSolver(BaseModel):
             if error_on_empty:
                 raise RuntimeError(message)
             else:
-                warnings.warn(message)
+                # warnings.warn(message)
                 return []
 
     def is_terminal_tool(self, tool_name: str) -> bool:

letta/log.py

@@ -56,7 +56,7 @@ DEVELOPMENT_LOGGING = {
             "propagate": False,
         },
         "uvicorn": {
-            "level": "INFO",
+            "level": "CRITICAL",
             "handlers": ["console"],
             "propagate": False,
         },

letta/main.py

@@ -26,6 +26,9 @@ from letta.streaming_interface import AgentRefreshStreamingInterface
 
 # interface = interface()
 
+# disable composio print on exit
+os.environ["COMPOSIO_DISABLE_VERSION_CHECK"] = "true"
+
 app = typer.Typer(pretty_exceptions_enable=False)
 app.command(name="run")(run)
 app.command(name="version")(version)

letta/metadata.py

@@ -493,6 +493,7 @@ class MetadataStore:
             fields = vars(agent)
             fields["memory"] = agent.memory.to_dict()
             del fields["_internal_memory"]
+            del fields["tags"]
             session.add(AgentModel(**fields))
             session.commit()
 
@@ -531,6 +532,7 @@ class MetadataStore:
             if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
                 fields["memory"] = agent.memory.to_dict()
             del fields["_internal_memory"]
+            del fields["tags"]
             session.query(AgentModel).filter(AgentModel.id == agent.id).update(fields)
             session.commit()
 

letta/orm/agents_tags.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+
+from sqlalchemy import ForeignKey, String, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.mixins import OrganizationMixin
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.agents_tags import AgentsTags as PydanticAgentsTags
+
+if TYPE_CHECKING:
+    from letta.orm.organization import Organization
+
+
+class AgentsTags(SqlalchemyBase, OrganizationMixin):
+    """Associates tags with agents, allowing agents to have multiple tags and supporting tag-based filtering."""
+
+    __tablename__ = "agents_tags"
+    __pydantic_model__ = PydanticAgentsTags
+    __table_args__ = (UniqueConstraint("agent_id", "tag", name="unique_agent_tag"),)
+
+    # The agent associated with this tag
+    agent_id = mapped_column(String, ForeignKey("agents.id"), primary_key=True)
+
+    # The name of the tag
+    tag: Mapped[str] = mapped_column(String, nullable=False, doc="The name of the tag associated with the agent.")
+
+    # relationships
+    organization: Mapped["Organization"] = relationship("Organization", back_populates="agents_tags")

letta/orm/organization.py

@@ -23,6 +23,7 @@ class Organization(SqlalchemyBase):
 
     users: Mapped[List["User"]] = relationship("User", back_populates="organization", cascade="all, delete-orphan")
     tools: Mapped[List["Tool"]] = relationship("Tool", back_populates="organization", cascade="all, delete-orphan")
+    agents_tags: Mapped[List["AgentsTags"]] = relationship("AgentsTags", back_populates="organization", cascade="all, delete-orphan")
 
     # TODO: Map these relationships later when we actually make these models
     # below is just a suggestion

letta/orm/sqlalchemy_base.py

@@ -112,6 +112,22 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         self.is_deleted = True
         return self.update(db_session)
 
+    def hard_delete(self, db_session: "Session", actor: Optional["User"] = None) -> None:
+        """Permanently removes the record from the database."""
+        if actor:
+            logger.info(f"User {actor.id} requested hard deletion of {self.__class__.__name__} with ID {self.id}")
+
+        with db_session as session:
+            try:
+                session.delete(self)
+                session.commit()
+            except Exception as e:
+                session.rollback()
+                logger.exception(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}")
+                raise ValueError(f"Failed to hard delete {self.__class__.__name__} with ID {self.id}: {e}")
+            else:
+                logger.info(f"{self.__class__.__name__} with ID {self.id} successfully hard deleted")
+
     def update(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
         if actor:
             self._set_created_and_updated_by_fields(actor.id)

letta/schemas/agent.py

@@ -64,6 +64,9 @@ class AgentState(BaseAgent, validate_assignment=True):
     # tool rules
     tool_rules: Optional[List[BaseToolRule]] = Field(default=None, description="The list of tool rules.")
 
+    # tags
+    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
+
     # system prompt
     system: str = Field(..., description="The system prompt used by the agent.")
 
@@ -108,6 +111,7 @@ class CreateAgent(BaseAgent):
     memory: Optional[Memory] = Field(None, description="The in-context memory of the agent.")
     tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
     tool_rules: Optional[List[BaseToolRule]] = Field(None, description="The tool rules governing the agent.")
+    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     agent_type: Optional[AgentType] = Field(None, description="The type of agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
@@ -148,6 +152,7 @@ class UpdateAgentState(BaseAgent):
     id: str = Field(..., description="The id of the agent.")
     name: Optional[str] = Field(None, description="The name of the agent.")
     tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")

letta/schemas/agents_tags.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class AgentsTagsBase(LettaBase):
+    __id_prefix__ = "agents_tags"
+
+
+class AgentsTags(AgentsTagsBase):
+    """
+    Schema representing the relationship between tags and agents.
+
+    Parameters:
+        agent_id (str): The ID of the associated agent.
+        tag_id (str): The ID of the associated tag.
+        tag_name (str): The name of the tag.
+        created_at (datetime): The date this relationship was created.
+    """
+
+    id: str = AgentsTagsBase.generate_id_field()
+    agent_id: str = Field(..., description="The ID of the associated agent.")
+    tag: str = Field(..., description="The name of the tag.")
+    created_at: Optional[datetime] = Field(None, description="The creation date of the association.")
+    updated_at: Optional[datetime] = Field(None, description="The update date of the tag.")
+    is_deleted: bool = Field(False, description="Whether this tag is deleted or not.")
+
+
+class AgentsTagsCreate(AgentsTagsBase):
+    tag: str = Field(..., description="The tag name.")

letta/schemas/block.py

@@ -18,7 +18,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
     limit: int = Field(2000, description="Character limit of the block.")
 
     # template data (optional)
-    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.")
+    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
     template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
 
     # context window label
@@ -58,11 +58,11 @@ class Block(BaseBlock):
     A Block represents a reserved section of the LLM's context window which is editable. `Block` objects contained in the `Memory` object, which is able to edit the Block values.
 
     Parameters:
-        name (str): The name of the block.
+        label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
         value (str): The value of the block. This is the string that is represented in the context window.
         limit (int): The character limit of the block.
+        template_name (str): The name of the block template (if it is a template).
         template (bool): Whether the block is a template (e.g. saved human/persona options). Non-template blocks are not stored in the database and are ephemeral, while templated blocks are stored in the database.
-        label (str): The label of the block (e.g. 'human', 'persona'). This defines a category for the block.
         description (str): Description of the block.
         metadata_ (Dict): Metadata of the block.
         user_id (str): The unique identifier of the user associated with the block.

letta/schemas/letta_response.py

@@ -1,3 +1,6 @@
+import html
+import json
+import re
 from typing import List, Union
 
 from pydantic import BaseModel, Field
@@ -34,6 +37,113 @@ class LettaResponse(BaseModel):
             indent=4,
         )
 
+    def _repr_html_(self):
+        def get_formatted_content(msg):
+            if msg.message_type == "internal_monologue":
+                return f'<div class="content"><span class="internal-monologue">{html.escape(msg.internal_monologue)}</span></div>'
+            elif msg.message_type == "function_call":
+                args = format_json(msg.function_call.arguments)
+                return f'<div class="content"><span class="function-name">{html.escape(msg.function_call.name)}</span>({args})</div>'
+            elif msg.message_type == "function_return":
+
+                return_value = format_json(msg.function_return)
+                # return f'<div class="status-line">Status: {html.escape(msg.status)}</div><div class="content">{return_value}</div>'
+                return f'<div class="content">{return_value}</div>'
+            elif msg.message_type == "user_message":
+                if is_json(msg.message):
+                    return f'<div class="content">{format_json(msg.message)}</div>'
+                else:
+                    return f'<div class="content">{html.escape(msg.message)}</div>'
+            elif msg.message_type in ["assistant_message", "system_message"]:
+                return f'<div class="content">{html.escape(msg.message)}</div>'
+            else:
+                return f'<div class="content">{html.escape(str(msg))}</div>'
+
+        def is_json(string):
+            try:
+                json.loads(string)
+                return True
+            except ValueError:
+                return False
+
+        def format_json(json_str):
+            try:
+                parsed = json.loads(json_str)
+                formatted = json.dumps(parsed, indent=2, ensure_ascii=False)
+                formatted = formatted.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+                formatted = formatted.replace("\n", "<br>").replace("  ", "&nbsp;&nbsp;")
+                formatted = re.sub(r'(".*?"):', r'<span class="json-key">\1</span>:', formatted)
+                formatted = re.sub(r': (".*?")', r': <span class="json-string">\1</span>', formatted)
+                formatted = re.sub(r": (\d+)", r': <span class="json-number">\1</span>', formatted)
+                formatted = re.sub(r": (true|false)", r': <span class="json-boolean">\1</span>', formatted)
+                return formatted
+            except json.JSONDecodeError:
+                return html.escape(json_str)
+
+        html_output = """
+        <style>
+            .message-container, .usage-container {
+                font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+                max-width: 800px;
+                margin: 20px auto;
+                background-color: #1e1e1e;
+                border-radius: 8px;
+                overflow: hidden;
+                color: #d4d4d4;
+            }
+            .message, .usage-stats {
+                padding: 10px 15px;
+                border-bottom: 1px solid #3a3a3a;
+            }
+            .message:last-child, .usage-stats:last-child {
+                border-bottom: none;
+            }
+            .title {
+                font-weight: bold;
+                margin-bottom: 5px;
+                color: #ffffff;
+                text-transform: uppercase;
+                font-size: 0.9em;
+            }
+            .content {
+                background-color: #2d2d2d;
+                border-radius: 4px;
+                padding: 5px 10px;
+                font-family: 'Consolas', 'Courier New', monospace;
+                white-space: pre-wrap;
+            }
+            .json-key, .function-name, .json-boolean { color: #9cdcfe; }
+            .json-string { color: #ce9178; }
+            .json-number { color: #b5cea8; }
+            .internal-monologue { font-style: italic; }
+        </style>
+        <div class="message-container">
+        """
+
+        for msg in self.messages:
+            content = get_formatted_content(msg)
+            title = msg.message_type.replace("_", " ").upper()
+            html_output += f"""
+            <div class="message">
+                <div class="title">{title}</div>
+                {content}
+            </div>
+            """
+        html_output += "</div>"
+
+        # Formatting the usage statistics
+        usage_html = json.dumps(self.usage.model_dump(), indent=2)
+        html_output += f"""
+        <div class="usage-container">
+            <div class="usage-stats">
+                <div class="title">USAGE STATISTICS</div>
+                <div class="content">{format_json(usage_html)}</div>
+            </div>
+        </div>
+        """
+
+        return html_output
+
 
 # The streaming response is either [DONE], [DONE_STEP], [DONE], an error, or a LettaMessage
 LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaUsageStatistics]

letta/schemas/llm_config.py

@@ -13,7 +13,7 @@ class LLMConfig(BaseModel):
         model_endpoint (str): The endpoint for the model.
         model_wrapper (str): The wrapper for the model. This is used to wrap additional text around the input/output of the model. This is useful for text-to-text completions, such as the Completions API in OpenAI.
         context_window (int): The context window size for the model.
-        put_inner_thoughts_in_kwargs (bool): Puts 'inner_thoughts' as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.
+        put_inner_thoughts_in_kwargs (bool): Puts `inner_thoughts` as a kwarg in the function call if this is set to True. This helps with function calling performance and also the generation of inner thoughts.
     """
 
     # TODO: 🤮 don't default to a vendor! bug city!
@@ -67,6 +67,12 @@ class LLMConfig(BaseModel):
 
     @classmethod
     def default_config(cls, model_name: str):
+        """
+        Convinience function to generate a default `LLMConfig` from a model name. Only some models are supported in this function.
+
+        Args:
+            model_name (str): The name of the model (gpt-4, gpt-4o-mini, letta).
+        """
         if model_name == "gpt-4":
             return cls(
                 model="gpt-4",

letta/schemas/tool.py

@@ -1,6 +1,5 @@
 from typing import Dict, List, Optional
 
-from composio import LogLevel
 from pydantic import Field
 
 from letta.functions.helpers import (
@@ -68,7 +67,7 @@ class ToolCreate(LettaBase):
     tags: List[str] = Field([], description="Metadata tags.")
     module: Optional[str] = Field(None, description="The source code of the function.")
     source_code: str = Field(..., description="The source code of the function.")
-    source_type: str = Field(..., description="The source type of the function.")
+    source_type: str = Field("python", description="The source type of the function.")
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
@@ -86,6 +85,7 @@ class ToolCreate(LettaBase):
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the Composio tool.
         """
+        from composio import LogLevel
         from composio_langchain import ComposioToolSet
 
         composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
@@ -216,3 +216,7 @@ class ToolUpdate(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
+
+    class Config:
+        extra = "ignore"  # Allows extra fields without validation errors
+        # TODO: Remove this, and clean usage of ToolUpdate everywhere else

letta/schemas/tool_rule.py

@@ -11,15 +11,25 @@ class BaseToolRule(LettaBase):
 
 
 class ToolRule(BaseToolRule):
+    """
+    A ToolRule represents a tool that can be invoked by the agent.
+    """
+
     type: str = Field("ToolRule")
     children: List[str] = Field(..., description="The children tools that can be invoked.")
 
 
 class InitToolRule(BaseToolRule):
+    """
+    Represents the initial tool rule configuration.
+    """
+
     type: str = Field("InitToolRule")
-    """Represents the initial tool rule configuration."""
 
 
 class TerminalToolRule(BaseToolRule):
+    """
+    Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop.
+    """
+
     type: str = Field("TerminalToolRule")
-    """Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop."""

letta/server/rest_api/app.py

@@ -8,6 +8,7 @@ import uvicorn
 from fastapi import FastAPI
 from starlette.middleware.cors import CORSMiddleware
 
+from letta.__init__ import __version__
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 from letta.schemas.letta_response import LettaResponse
 from letta.server.constants import REST_DEFAULT_PORT
@@ -66,6 +67,7 @@ def create_application() -> "FastAPI":
     """the application start routine"""
     # global server
     # server = SyncServer(default_interface_factory=lambda: interface())
+    print(f"\n[[ Letta server // v{__version__} ]]")
 
     app = FastAPI(
         swagger_ui_parameters={"docExpansion": "none"},
@@ -78,6 +80,7 @@ def create_application() -> "FastAPI":
 
     if "--ade" in sys.argv:
         settings.cors_origins.append("https://app.letta.com")
+        print(f"▶ View using ADE at: https://app.letta.com/local-project/agents")
 
     app.add_middleware(
         CORSMiddleware,
@@ -179,7 +182,7 @@ def start_server(
         # Add the handler to the logger
         server_logger.addHandler(stream_handler)
 
-    print(f"Running: uvicorn server:app --host {host or 'localhost'} --port {port or REST_DEFAULT_PORT}")
+    print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
     uvicorn.run(
         app,
         host=host or "localhost",