letta-nightly 0.6.1.dev20241208192034__tar.gz → 0.6.2.dev20241210030252__tar.gz

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.1.dev20241208192034
+Version: 0.6.2.dev20241210030252
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/__init__.py

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

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/agent.py

@@ -801,7 +801,13 @@ class Agent(BaseAgent):
                     # but by default, we add a truncation safeguard to prevent bad functions from
                     # overflow the agent context window
                     truncate = True
-                function_response_string = validate_function_response(function_response, truncate=truncate)
+
+                # get the function response limit
+                tool_obj = [tool for tool in self.agent_state.tools if tool.name == function_name][0]
+                return_char_limit = tool_obj.return_char_limit
+                function_response_string = validate_function_response(
+                    function_response, return_char_limit=return_char_limit, truncate=truncate
+                )
                 function_args.pop("self", None)
                 function_response = package_function_response(True, function_response_string)
                 function_failed = False

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/cli/cli.py

@@ -51,6 +51,7 @@ def server(
     port: Annotated[Optional[int], typer.Option(help="Port to run the server on")] = None,
     host: Annotated[Optional[str], typer.Option(help="Host to run the server on (default to localhost)")] = None,
     debug: Annotated[bool, typer.Option(help="Turn debugging output on")] = False,
+    ade: Annotated[bool, typer.Option(help="Allows remote access")] = False,  # NOTE: deprecated
     secure: Annotated[bool, typer.Option(help="Adds simple security access")] = False,
 ):
     """Launch a Letta server process"""

letta_nightly-0.6.2.dev20241210030252/letta/cli/cli_load.py

@@ -0,0 +1,68 @@
+"""
+This file contains functions for loading data into Letta's archival storage.
+
+Data can be loaded with the following command, once a load function is defined:
+```
+letta load <data-connector-type> --name <dataset-name> [ADDITIONAL ARGS]
+```
+
+"""
+
+import uuid
+from typing import Annotated, List, Optional
+
+import questionary
+import typer
+
+from letta import create_client
+from letta.data_sources.connectors import DirectoryConnector
+
+app = typer.Typer()
+
+
+default_extensions = ".txt,.md,.pdf"
+
+
+@app.command("directory")
+def load_directory(
+    name: Annotated[str, typer.Option(help="Name of dataset to load.")],
+    input_dir: Annotated[Optional[str], typer.Option(help="Path to directory containing dataset.")] = None,
+    input_files: Annotated[List[str], typer.Option(help="List of paths to files containing dataset.")] = [],
+    recursive: Annotated[bool, typer.Option(help="Recursively search for files in directory.")] = False,
+    extensions: Annotated[str, typer.Option(help="Comma separated list of file extensions to load")] = default_extensions,
+    user_id: Annotated[Optional[uuid.UUID], typer.Option(help="User ID to associate with dataset.")] = None,  # TODO: remove
+    description: Annotated[Optional[str], typer.Option(help="Description of the source.")] = None,
+):
+    client = create_client()
+
+    # create connector
+    connector = DirectoryConnector(input_files=input_files, input_directory=input_dir, recursive=recursive, extensions=extensions)
+
+    # choose form list of embedding configs
+    embedding_configs = client.list_embedding_configs()
+    embedding_options = [embedding_config.embedding_model for embedding_config in embedding_configs]
+
+    embedding_choices = [
+        questionary.Choice(title=embedding_config.pretty_print(), value=embedding_config) for embedding_config in embedding_configs
+    ]
+
+    # select model
+    if len(embedding_options) == 0:
+        raise ValueError("No embedding models found. Please enable a provider.")
+    elif len(embedding_options) == 1:
+        embedding_model_name = embedding_options[0]
+    else:
+        embedding_model_name = questionary.select("Select embedding model:", choices=embedding_choices).ask().embedding_model
+    embedding_config = [
+        embedding_config for embedding_config in embedding_configs if embedding_config.embedding_model == embedding_model_name
+    ][0]
+
+    # create source
+    source = client.create_source(name=name, embedding_config=embedding_config)
+
+    # load data
+    try:
+        client.load_data(connector, source_name=name)
+    except Exception as e:
+        typer.secho(f"Failed to load data from provided information.\n{e}", fg=typer.colors.RED)
+        client.delete_source(source.id)

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/client/client.py

@@ -11,6 +11,7 @@ from letta.constants import (
     BASE_TOOLS,
     DEFAULT_HUMAN,
     DEFAULT_PERSONA,
+    FUNCTION_RETURN_CHAR_LIMIT,
 )
 from letta.data_sources.connectors import DataConnector
 from letta.functions.functions import parse_source_code
@@ -200,18 +201,12 @@ class AbstractClient(object):
         raise NotImplementedError
 
     def create_tool(
-        self,
-        func,
-        name: Optional[str] = None,
-        tags: Optional[List[str]] = None,
+        self, func, name: Optional[str] = None, tags: Optional[List[str]] = None, return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT
     ) -> Tool:
         raise NotImplementedError
 
     def create_or_update_tool(
-        self,
-        func,
-        name: Optional[str] = None,
-        tags: Optional[List[str]] = None,
+        self, func, name: Optional[str] = None, tags: Optional[List[str]] = None, return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT
     ) -> Tool:
         raise NotImplementedError
 
@@ -222,6 +217,7 @@ class AbstractClient(object):
         description: Optional[str] = None,
         func: Optional[Callable] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         raise NotImplementedError
 
@@ -960,7 +956,6 @@ 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)
         if stream_tokens or stream_steps:
             from letta.client.streaming import _sse_post
 
@@ -985,6 +980,39 @@ class RESTClient(AbstractClient):
 
             return response
 
+    def send_message_async(
+        self,
+        message: str,
+        role: str,
+        agent_id: Optional[str] = None,
+        name: Optional[str] = None,
+    ) -> Job:
+        """
+        Send a message to an agent (async, returns a job)
+
+        Args:
+            message (str): Message to send
+            role (str): Role of the message
+            agent_id (str): ID of the agent
+            name(str): Name of the sender
+
+        Returns:
+            job (Job): Information about the async job
+        """
+        messages = [MessageCreate(role=MessageRole(role), text=message, name=name)]
+
+        request = LettaRequest(messages=messages)
+        response = requests.post(
+            f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/messages/async",
+            json=request.model_dump(),
+            headers=self.headers,
+        )
+        if response.status_code != 200:
+            raise ValueError(f"Failed to send message: {response.text}")
+        response = Job(**response.json())
+
+        return response
+
     # humans / personas
 
     def list_blocks(self, label: Optional[str] = None, templates_only: Optional[bool] = True) -> List[Block]:
@@ -1319,6 +1347,7 @@ class RESTClient(AbstractClient):
         Returns:
             source (Source): Created source
         """
+        assert embedding_config or self._default_embedding_config, f"Must specify embedding_config for source"
         source_create = SourceCreate(name=name, embedding_config=embedding_config or self._default_embedding_config)
         payload = source_create.model_dump()
         response = requests.post(f"{self.base_url}/{self.api_prefix}/sources", json=payload, headers=self.headers)
@@ -1432,6 +1461,7 @@ class RESTClient(AbstractClient):
         func: Callable,
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> 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.
@@ -1440,6 +1470,7 @@ 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.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -1448,7 +1479,9 @@ class RESTClient(AbstractClient):
         source_type = "python"
 
         # call server function
-        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags)
+        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, return_char_limit=return_char_limit)
+        if tags:
+            request.tags = tags
         response = requests.post(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create tool: {response.text}")
@@ -1459,6 +1492,7 @@ class RESTClient(AbstractClient):
         func: Callable,
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Creates or updates 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.
@@ -1467,6 +1501,7 @@ 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.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -1475,7 +1510,9 @@ class RESTClient(AbstractClient):
         source_type = "python"
 
         # call server function
-        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, tags=tags)
+        request = ToolCreate(source_type=source_type, source_code=source_code, name=name, return_char_limit=return_char_limit)
+        if tags:
+            request.tags = tags
         response = requests.put(f"{self.base_url}/{self.api_prefix}/tools", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create tool: {response.text}")
@@ -1488,6 +1525,7 @@ class RESTClient(AbstractClient):
         description: Optional[str] = None,
         func: Optional[Callable] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Update a tool with provided parameters (name, func, tags)
@@ -1497,6 +1535,7 @@ class RESTClient(AbstractClient):
             name (str): Name of the tool
             func (callable): Function to wrap in a tool
             tags (List[str]): Tags for the tool
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): Updated tool
@@ -1508,7 +1547,14 @@ class RESTClient(AbstractClient):
 
         source_type = "python"
 
-        request = ToolUpdate(description=description, 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,
+            return_char_limit=return_char_limit,
+        )
         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}")
@@ -2693,6 +2739,7 @@ class LocalClient(AbstractClient):
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
         description: Optional[str] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> 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.
@@ -2702,6 +2749,7 @@ class LocalClient(AbstractClient):
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
             description (str, optional): The description.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -2722,6 +2770,7 @@ class LocalClient(AbstractClient):
                 name=name,
                 tags=tags,
                 description=description,
+                return_char_limit=return_char_limit,
             ),
             actor=self.user,
         )
@@ -2732,6 +2781,7 @@ class LocalClient(AbstractClient):
         name: Optional[str] = None,
         tags: Optional[List[str]] = None,
         description: Optional[str] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Creates or updates 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.
@@ -2741,6 +2791,7 @@ class LocalClient(AbstractClient):
             name: (str): Name of the tool (must be unique per-user.)
             tags (Optional[List[str]], optional): Tags for the tool. Defaults to None.
             description (str, optional): The description.
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): The created tool.
@@ -2758,6 +2809,7 @@ class LocalClient(AbstractClient):
                 name=name,
                 tags=tags,
                 description=description,
+                return_char_limit=return_char_limit,
             ),
             actor=self.user,
         )
@@ -2769,6 +2821,7 @@ class LocalClient(AbstractClient):
         description: Optional[str] = None,
         func: Optional[callable] = None,
         tags: Optional[List[str]] = None,
+        return_char_limit: int = FUNCTION_RETURN_CHAR_LIMIT,
     ) -> Tool:
         """
         Update a tool with provided parameters (name, func, tags)
@@ -2778,6 +2831,7 @@ class LocalClient(AbstractClient):
             name (str): Name of the tool
             func (callable): Function to wrap in a tool
             tags (List[str]): Tags for the tool
+            return_char_limit (int): The character limit for the tool's return value. Defaults to FUNCTION_RETURN_CHAR_LIMIT.
 
         Returns:
             tool (Tool): Updated tool
@@ -2788,6 +2842,7 @@ class LocalClient(AbstractClient):
             "tags": tags,
             "name": name,
             "description": description,
+            "return_char_limit": return_char_limit,
         }
 
         # Filter out any None values from the dictionary
@@ -2836,7 +2891,7 @@ class LocalClient(AbstractClient):
             id (str): ID of the tool (`None` if not found)
         """
         tool = self.server.tool_manager.get_tool_by_name(tool_name=name, actor=self.user)
-        return tool.id
+        return tool.id if tool else None
 
     def load_data(self, connector: DataConnector, source_name: str):
         """
@@ -2896,6 +2951,7 @@ class LocalClient(AbstractClient):
         Returns:
             source (Source): Created source
         """
+        assert embedding_config or self._default_embedding_config, f"Must specify embedding_config for source"
         source = Source(
             name=name, embedding_config=embedding_config or self._default_embedding_config, organization_id=self.user.organization_id
         )

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/errors.py

@@ -22,6 +22,30 @@ class LettaToolCreateError(LettaError):
         super().__init__(self.message)
 
 
+class LettaConfigurationError(LettaError):
+    """Error raised when there are configuration-related issues."""
+
+    def __init__(self, message: str, missing_fields: Optional[List[str]] = None):
+        self.missing_fields = missing_fields or []
+        super().__init__(message)
+
+
+class LettaAgentNotFoundError(LettaError):
+    """Error raised when an agent is not found."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
+class LettaUserNotFoundError(LettaError):
+    """Error raised when a user is not found."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(self.message)
+
+
 class LLMError(LettaError):
     pass
 

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/llm_api/llm_api_tools.py

@@ -5,6 +5,7 @@ from typing import List, Optional, Union
 import requests
 
 from letta.constants import CLI_WARNING_PREFIX
+from letta.errors import LettaConfigurationError
 from letta.llm_api.anthropic import anthropic_chat_completions_request
 from letta.llm_api.azure_openai import azure_openai_chat_completions_request
 from letta.llm_api.google_ai import (
@@ -148,7 +149,7 @@ def create(
     if llm_config.model_endpoint_type == "openai":
         if model_settings.openai_api_key is None and llm_config.model_endpoint == "https://api.openai.com/v1":
             # only is a problem if we are *not* using an openai proxy
-            raise ValueError(f"OpenAI key is missing from letta config file")
+            raise LettaConfigurationError(message="OpenAI key is missing from letta config file", missing_fields=["openai_api_key"])
 
         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
@@ -187,13 +188,19 @@ def create(
             raise NotImplementedError(f"Streaming not yet implemented for {llm_config.model_endpoint_type}")
 
         if model_settings.azure_api_key is None:
-            raise ValueError(f"Azure API key is missing. Did you set AZURE_API_KEY in your env?")
+            raise LettaConfigurationError(
+                message="Azure API key is missing. Did you set AZURE_API_KEY in your env?", missing_fields=["azure_api_key"]
+            )
 
         if model_settings.azure_base_url is None:
-            raise ValueError(f"Azure base url is missing. Did you set AZURE_BASE_URL in your env?")
+            raise LettaConfigurationError(
+                message="Azure base url is missing. Did you set AZURE_BASE_URL in your env?", missing_fields=["azure_base_url"]
+            )
 
         if model_settings.azure_api_version is None:
-            raise ValueError(f"Azure API version is missing. Did you set AZURE_API_VERSION in your env?")
+            raise LettaConfigurationError(
+                message="Azure API version is missing. Did you set AZURE_API_VERSION in your env?", missing_fields=["azure_api_version"]
+            )
 
         # Set the llm config model_endpoint from model_settings
         # For Azure, this model_endpoint is required to be configured via env variable, so users don't need to provide it in the LLM config
@@ -291,7 +298,7 @@ def create(
             raise NotImplementedError(f"Streaming not yet implemented for Groq.")
 
         if model_settings.groq_api_key is None and llm_config.model_endpoint == "https://api.groq.com/openai/v1/chat/completions":
-            raise ValueError(f"Groq key is missing from letta config file")
+            raise LettaConfigurationError(message="Groq key is missing from letta config file", missing_fields=["groq_api_key"])
 
         # force to true for groq, since they don't support 'content' is non-null
         if llm_config.put_inner_thoughts_in_kwargs:
@@ -344,7 +351,7 @@ def create(
             raise NotImplementedError(f"Streaming not yet implemented for TogetherAI (via the /completions endpoint).")
 
         if model_settings.together_api_key is None and llm_config.model_endpoint == "https://api.together.ai/v1/completions":
-            raise ValueError(f"TogetherAI key is missing from letta config file")
+            raise LettaConfigurationError(message="TogetherAI key is missing from letta config file", missing_fields=["together_api_key"])
 
         return get_chat_completion(
             model=llm_config.model,

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/main.py

@@ -191,7 +191,6 @@ def run_agent_loop(
                     print(f"\nDumping memory contents:\n")
                     print(f"{letta_agent.agent_state.memory.compile()}")
                     print(f"{letta_agent.archival_memory.compile()}")
-                    print(f"{letta_agent.recall_memory.compile()}")
                     continue
 
                 elif user_input.lower() == "/model":

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/offline_memory_agent.py

@@ -150,11 +150,8 @@ class OfflineMemoryAgent(Agent):
         step_count = 0
 
         while counter < self.max_memory_rethinks:
-            # This is hacky but we need to do this for now
-            # TODO: REMOVE THIS
-            for m in next_input_message:
-                m.id = m._generate_id()
-
+            if counter > 0:
+                next_input_message = []
             kwargs["ms"] = ms
             kwargs["first_message"] = False
             step_response = self.inner_step(

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/orm/sqlalchemy_base.py

@@ -187,7 +187,7 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
                 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")
+                logger.debug(f"{self.__class__.__name__} with ID {self.id} successfully hard deleted")
 
     def update(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
         logger.debug(f"Updating {self.__class__.__name__} with ID: {self.id} with actor={actor}")

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/orm/tool.py

@@ -30,6 +30,7 @@ class Tool(SqlalchemyBase, OrganizationMixin):
     __table_args__ = (UniqueConstraint("name", "organization_id", name="uix_name_organization"),)
 
     name: Mapped[str] = mapped_column(doc="The display name of the tool.")
+    return_char_limit: Mapped[int] = mapped_column(nullable=True, doc="The maximum number of characters the tool can return.")
     description: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The description of the tool.")
     tags: Mapped[List] = mapped_column(JSON, doc="Metadata tags used to filter tools.")
     source_type: Mapped[ToolSourceType] = mapped_column(String, doc="The type of the source code.", default=ToolSourceType.json)
@@ -45,19 +46,16 @@ class Tool(SqlalchemyBase, OrganizationMixin):
 
 
 # Add event listener to update tool_name in ToolsAgents when Tool name changes
-@event.listens_for(Tool, 'before_update')
+@event.listens_for(Tool, "before_update")
 def update_tool_name_in_tools_agents(mapper, connection, target):
     """Update tool_name in ToolsAgents when Tool name changes."""
     state = target._sa_instance_state
-    history = state.get_history('name', passive=True)
+    history = state.get_history("name", passive=True)
     if not history.has_changes():
         return
-    
+
     # Get the new name and update all associated ToolsAgents records
     new_name = target.name
     from letta.orm.tools_agents import ToolsAgents
-    connection.execute(
-        ToolsAgents.__table__.update().where(
-            ToolsAgents.tool_id == target.id
-        ).values(tool_name=new_name)
-    )
+
+    connection.execute(ToolsAgents.__table__.update().where(ToolsAgents.tool_id == target.id).values(tool_name=new_name))

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/schemas/message.py

@@ -481,7 +481,20 @@ class Message(BaseMessage):
             return f"<{xml_tag}>{string}</{xml_tag}" if xml_tag else string
 
         if self.role == "system":
-            raise ValueError(f"Anthropic 'system' role not supported")
+            # NOTE: this is not for system instructions, but instead system "events"
+
+            assert all([v is not None for v in [self.text, self.role]]), vars(self)
+            # Two options here, we would use system.package_system_message,
+            # or use a more Anthropic-specific packaging ie xml tags
+            user_system_event = add_xml_tag(string=f"SYSTEM ALERT: {self.text}", xml_tag="event")
+            anthropic_message = {
+                "content": user_system_event,
+                "role": "user",
+            }
+
+            # Optional field, do not include if null
+            if self.name is not None:
+                anthropic_message["name"] = self.name
 
         elif self.role == "user":
             assert all([v is not None for v in [self.text, self.role]]), vars(self)

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/schemas/tool.py

@@ -2,6 +2,7 @@ from typing import Dict, List, Optional
 
 from pydantic import Field, model_validator
 
+from letta.constants import FUNCTION_RETURN_CHAR_LIMIT
 from letta.functions.functions import derive_openai_json_schema
 from letta.functions.helpers import (
     generate_composio_tool_wrapper,
@@ -41,6 +42,9 @@ class Tool(BaseTool):
     source_code: str = Field(..., description="The source code of the function.")
     json_schema: Optional[Dict] = Field(None, description="The JSON schema of the function.")
 
+    # tool configuration
+    return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
+
     # metadata fields
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
@@ -91,6 +95,7 @@ class ToolCreate(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
+    return_char_limit: int = Field(FUNCTION_RETURN_CHAR_LIMIT, description="The maximum number of characters in the response.")
 
     @classmethod
     def from_composio(cls, action_name: str, api_key: Optional[str] = None) -> "ToolCreate":

{letta_nightly-0.6.1.dev20241208192034 → letta_nightly-0.6.2.dev20241210030252}/letta/server/rest_api/app.py

@@ -13,6 +13,7 @@ from starlette.middleware.cors import CORSMiddleware
 
 from letta.__init__ import __version__
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
+from letta.errors import LettaAgentNotFoundError, LettaUserNotFoundError
 from letta.schemas.letta_response import LettaResponse
 from letta.server.constants import REST_DEFAULT_PORT
 
@@ -144,6 +145,35 @@ def create_application() -> "FastAPI":
         debug=True,
     )
 
+    @app.exception_handler(Exception)
+    async def generic_error_handler(request, exc):
+        # Log the actual error for debugging
+        log.error(f"Unhandled error: {exc}", exc_info=True)
+
+        # Print the stack trace
+        print(f"Stack trace: {exc.__traceback__}")
+        if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+            import sentry_sdk
+
+            sentry_sdk.capture_exception(exc)
+
+        return JSONResponse(
+            status_code=500,
+            content={
+                "detail": "An internal server error occurred",
+                # Only include error details in debug/development mode
+                # "debug_info": str(exc) if settings.debug else None
+            },
+        )
+
+    @app.exception_handler(LettaAgentNotFoundError)
+    async def agent_not_found_handler(request, exc):
+        return JSONResponse(status_code=404, content={"detail": "Agent not found"})
+
+    @app.exception_handler(LettaUserNotFoundError)
+    async def user_not_found_handler(request, exc):
+        return JSONResponse(status_code=404, content={"detail": "User not found"})
+
     settings.cors_origins.append("https://app.letta.com")
     print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")