letta-nightly 0.6.4.dev20241216104246__py3-none-any.whl → 0.6.5.dev20241218055539__py3-none-any.whl

letta/schemas/embedding_config.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Literal, Optional
 
 from pydantic import BaseModel, Field
 
@@ -20,7 +20,25 @@ class EmbeddingConfig(BaseModel):
 
     """
 
-    embedding_endpoint_type: str = Field(..., description="The endpoint type for the model.")
+    embedding_endpoint_type: Literal[
+        "openai",
+        "anthropic",
+        "cohere",
+        "google_ai",
+        "azure",
+        "groq",
+        "ollama",
+        "webui",
+        "webui-legacy",
+        "lmstudio",
+        "lmstudio-legacy",
+        "llamacpp",
+        "koboldcpp",
+        "vllm",
+        "hugging-face",
+        "mistral",
+        "together",  # completions endpoint
+    ] = Field(..., description="The endpoint type for the model.")
     embedding_endpoint: Optional[str] = Field(None, description="The endpoint for the model (`None` if local).")
     embedding_model: str = Field(..., description="The model for the embedding.")
     embedding_dim: int = Field(..., description="The dimension of the embedding.")

letta/schemas/passage.py

@@ -10,7 +10,7 @@ from letta.utils import get_utc_time
 
 
 class PassageBase(OrmMetadataBase):
-    __id_prefix__ = "passage_legacy"
+    __id_prefix__ = "passage"
 
     is_deleted: bool = Field(False, description="Whether this passage is deleted or not.")
 

letta/schemas/sandbox_config.py

@@ -1,7 +1,7 @@
 import hashlib
 import json
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from pydantic import BaseModel, Field, model_validator
 
@@ -21,6 +21,7 @@ class SandboxRunResult(BaseModel):
     agent_state: Optional[AgentState] = Field(None, description="The agent state")
     stdout: Optional[List[str]] = Field(None, description="Captured stdout (e.g. prints, logs) from the function invocation")
     stderr: Optional[List[str]] = Field(None, description="Captured stderr from the function invocation")
+    status: Literal["success", "error"] = Field(..., description="The status of the tool execution and return object")
     sandbox_config_fingerprint: str = Field(None, description="The fingerprint of the config for the sandbox")
 
 

letta/server/rest_api/app.py

@@ -14,6 +14,13 @@ 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.log import get_logger
+from letta.orm.errors import (
+    DatabaseTimeoutError,
+    ForeignKeyConstraintViolationError,
+    NoResultFound,
+    UniqueConstraintViolationError,
+)
 from letta.schemas.letta_response import LettaResponse
 from letta.server.constants import REST_DEFAULT_PORT
 
@@ -45,6 +52,7 @@ from letta.settings import settings
 # NOTE(charles): @ethan I had to add this to get the global as the bottom to work
 interface: StreamingServerInterface = StreamingServerInterface
 server = SyncServer(default_interface_factory=lambda: interface())
+logger = get_logger(__name__)
 
 # TODO: remove
 password = None
@@ -170,6 +178,41 @@ def create_application() -> "FastAPI":
             },
         )
 
+    @app.exception_handler(NoResultFound)
+    async def no_result_found_handler(request: Request, exc: NoResultFound):
+        logger.error(f"NoResultFound: {exc}")
+
+        return JSONResponse(
+            status_code=404,
+            content={"detail": str(exc)},
+        )
+
+    @app.exception_handler(ForeignKeyConstraintViolationError)
+    async def foreign_key_constraint_handler(request: Request, exc: ForeignKeyConstraintViolationError):
+        logger.error(f"ForeignKeyConstraintViolationError: {exc}")
+
+        return JSONResponse(
+            status_code=409,
+            content={"detail": str(exc)},
+        )
+
+    @app.exception_handler(UniqueConstraintViolationError)
+    async def unique_key_constraint_handler(request: Request, exc: UniqueConstraintViolationError):
+        logger.error(f"UniqueConstraintViolationError: {exc}")
+
+        return JSONResponse(
+            status_code=409,
+            content={"detail": str(exc)},
+        )
+
+    @app.exception_handler(DatabaseTimeoutError)
+    async def database_timeout_error_handler(request: Request, exc: DatabaseTimeoutError):
+        logger.error(f"Timeout occurred: {exc}. Original exception: {exc.original_exception}")
+        return JSONResponse(
+            status_code=503,
+            content={"detail": "The database is temporarily unavailable. Please try again later."},
+        )
+
     @app.exception_handler(ValueError)
     async def value_error_handler(request: Request, exc: ValueError):
         return JSONResponse(status_code=400, content={"detail": str(exc)})
@@ -222,11 +265,6 @@ def create_application() -> "FastAPI":
 
     @app.on_event("startup")
     def on_startup():
-        # load the default tools
-        # from letta.orm.tool import Tool
-
-        # Tool.load_default_tools(get_db_session())
-
         generate_openapi_schema(app)
 
     @app.on_event("shutdown")

letta/server/rest_api/routers/v1/tools.py

@@ -195,7 +195,7 @@ def run_tool_from_source(
             tool_source_type=request.source_type,
             tool_args=request.args,
             tool_name=request.name,
-            user_id=actor.id,
+            actor=actor,
         )
     except LettaToolCreateError as e:
         # HTTP 400 == Bad Request

letta/server/rest_api/utils.py

@@ -1,5 +1,6 @@
 import asyncio
 import json
+import os
 import warnings
 from enum import Enum
 from typing import AsyncGenerator, Optional, Union
@@ -64,13 +65,31 @@ async def sse_async_generator(
                 import traceback
 
                 traceback.print_exc()
-                warnings.warn(f"Error getting usage data: {e}")
-                yield sse_formatter({"error": "Failed to get usage data"})
+                warnings.warn(f"SSE stream generator failed: {e}")
+
+                # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
+                # Print the stack trace
+                if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+                    import sentry_sdk
+
+                    sentry_sdk.capture_exception(e)
+
+                yield sse_formatter({"error": f"Stream failed (internal error occured)"})
 
     except Exception as e:
-        print("stream decoder hit error:", e)
-        print(traceback.print_stack())
-        yield sse_formatter({"error": "stream decoder encountered an error"})
+        import traceback
+
+        traceback.print_exc()
+        warnings.warn(f"SSE stream generator failed: {e}")
+
+        # Log the error, since the exception handler upstack (in FastAPI) won't catch it, because this may be a 200 response
+        # Print the stack trace
+        if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
+            import sentry_sdk
+
+            sentry_sdk.capture_exception(e)
+
+        yield sse_formatter({"error": "Stream failed (decoder encountered an error)"})
 
     finally:
         if finish_message:

letta/server/server.py

@@ -4,7 +4,6 @@ import os
 import traceback
 import warnings
 from abc import abstractmethod
-from asyncio import Lock
 from datetime import datetime
 from typing import Callable, List, Optional, Tuple, Union
 
@@ -19,7 +18,6 @@ from letta.agent import Agent, save_agent
 from letta.chat_only_agent import ChatOnlyAgent
 from letta.credentials import LettaCredentials
 from letta.data_sources.connectors import DataConnector, load_data
-from letta.errors import LettaAgentNotFoundError
 
 # TODO use custom interface
 from letta.interface import AgentInterface  # abstract
@@ -76,7 +74,7 @@ from letta.services.source_manager import SourceManager
 from letta.services.tool_execution_sandbox import ToolExecutionSandbox
 from letta.services.tool_manager import ToolManager
 from letta.services.user_manager import UserManager
-from letta.utils import get_utc_time, json_dumps, json_loads
+from letta.utils import get_friendly_error_msg, get_utc_time, json_dumps, json_loads
 
 logger = get_logger(__name__)
 
@@ -192,7 +190,14 @@ if settings.letta_pg_uri_no_default:
     config.archival_storage_uri = settings.letta_pg_uri_no_default
 
     # create engine
-    engine = create_engine(settings.letta_pg_uri)
+    engine = create_engine(
+        settings.letta_pg_uri,
+        pool_size=settings.pg_pool_size,
+        max_overflow=settings.pg_max_overflow,
+        pool_timeout=settings.pg_pool_timeout,
+        pool_recycle=settings.pg_pool_recycle,
+        echo=settings.pg_echo,
+    )
 else:
     # TODO: don't rely on config storage
     engine = create_engine("sqlite:///" + os.path.join(config.recall_storage_path, "sqlite.db"))
@@ -266,9 +271,6 @@ class SyncServer(Server):
 
         self.credentials = LettaCredentials.load()
 
-        # Locks
-        self.send_message_lock = Lock()
-
         # Initialize the metadata store
         config = LettaConfig.load()
         if settings.letta_pg_uri_no_default:
@@ -399,9 +401,6 @@ class SyncServer(Server):
         with agent_lock:
             agent_state = self.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
 
-            if agent_state is None:
-                raise LettaAgentNotFoundError(f"Agent (agent_id={agent_id}) does not exist")
-
             interface = interface or self.default_interface_factory()
             if agent_state.agent_type == AgentType.memgpt_agent:
                 agent = Agent(agent_state=agent_state, interface=interface, user=actor)
@@ -777,6 +776,18 @@ class SyncServer(Server):
         # interface
         interface: Union[AgentInterface, None] = None,
     ) -> AgentState:
+        if request.llm_config is None:
+            if request.llm is None:
+                raise ValueError("Must specify either llm or llm_config in request")
+            request.llm_config = self.get_llm_config_from_handle(handle=request.llm, context_window_limit=request.context_window_limit)
+
+        if request.embedding_config is None:
+            if request.embedding is None:
+                raise ValueError("Must specify either embedding or embedding_config in request")
+            request.embedding_config = self.get_embedding_config_from_handle(
+                handle=request.embedding, embedding_chunk_size=request.embedding_chunk_size or constants.DEFAULT_EMBEDDING_CHUNK_SIZE
+            )
+
         """Create a new agent using a config"""
         # Invoke manager
         agent_state = self.agent_manager.create_agent(
@@ -824,13 +835,13 @@ class SyncServer(Server):
         actor: User,
     ) -> AgentState:
         """Update the agents core memory block, return the new state"""
+        # Update agent state in the db first
+        agent_state = self.agent_manager.update_agent(agent_id=agent_id, agent_update=request, actor=actor)
+
         # Get the agent object (loaded in memory)
         letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
 
-        # Update tags
-        if request.tags is not None:  # Allow for empty list
-            letta_agent.agent_state.tags = request.tags
-
+        # TODO: Everything below needs to get removed, no updating anything in memory
         # update the system prompt
         if request.system:
             letta_agent.update_system_prompt(request.system)
@@ -842,45 +853,9 @@ class SyncServer(Server):
             # then (2) setting the attributes ._messages and .state.message_ids
             letta_agent.set_message_buffer(message_ids=request.message_ids)
 
-        # tools
-        if request.tool_ids:
-            # Replace tools and also re-link
-
-            # (1) get tools + make sure they exist
-            # Current and target tools as sets of tool names
-            current_tools = letta_agent.agent_state.tools
-            current_tool_ids = set([t.id for t in current_tools])
-            target_tool_ids = set(request.tool_ids)
-
-            # Calculate tools to add and remove
-            tool_ids_to_add = target_tool_ids - current_tool_ids
-            tools_ids_to_remove = current_tool_ids - target_tool_ids
-
-            # update agent tool list
-            for tool_id in tools_ids_to_remove:
-                self.remove_tool_from_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
-            for tool_id in tool_ids_to_add:
-                self.add_tool_to_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
-
-            # reload agent
-            letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
-        # configs
-        if request.llm_config:
-            letta_agent.agent_state.llm_config = request.llm_config
-        if request.embedding_config:
-            letta_agent.agent_state.embedding_config = request.embedding_config
-
-        # other minor updates
-        if request.name:
-            letta_agent.agent_state.name = request.name
-        if request.metadata_:
-            letta_agent.agent_state.metadata_ = request.metadata_
-
-        # save the agent
-        save_agent(letta_agent)
-        # TODO: probably reload the agent somehow?
-        return letta_agent.agent_state
+        letta_agent.update_state()
+
+        return agent_state
 
     def get_tools_from_agent(self, agent_id: str, user_id: Optional[str]) -> List[Tool]:
         """Get tools from an existing agent"""
@@ -901,32 +876,9 @@ class SyncServer(Server):
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
-        # Get all the tool objects from the request
-        tool_objs = []
-        tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool_id, actor=actor)
-        assert tool_obj, f"Tool with id={tool_id} does not exist"
-        tool_objs.append(tool_obj)
-
-        for tool in letta_agent.agent_state.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=actor)
-            assert tool_obj, f"Tool with id={tool.id} does not exist"
+        agent_state = self.agent_manager.attach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
-            # If it's not the already added tool
-            if tool_obj.id != tool_id:
-                tool_objs.append(tool_obj)
-
-        # replace the list of tool names ("ids") inside the agent state
-        letta_agent.agent_state.tools = tool_objs
-
-        # then attempt to link the tools modules
-        letta_agent.link_tools(tool_objs)
-
-        # save the agent
-        save_agent(letta_agent)
-        return letta_agent.agent_state
+        return agent_state
 
     def remove_tool_from_agent(
         self,
@@ -937,29 +889,9 @@ class SyncServer(Server):
         """Remove tools from an existing agent"""
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
+        agent_state = self.agent_manager.detach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
-        # Get all the tool_objs
-        tool_objs = []
-        for tool in letta_agent.agent_state.tools:
-            tool_obj = self.tool_manager.get_tool_by_id(tool_id=tool.id, actor=actor)
-            assert tool_obj, f"Tool with id={tool.id} does not exist"
-
-            # If it's not the tool we want to remove
-            if tool_obj.id != tool_id:
-                tool_objs.append(tool_obj)
-
-        # replace the list of tool names ("ids") inside the agent state
-        letta_agent.agent_state.tools = tool_objs
-
-        # then attempt to link the tools modules
-        letta_agent.link_tools(tool_objs)
-
-        # save the agent
-        save_agent(letta_agent)
-        return letta_agent.agent_state
+        return agent_state
 
     # convert name->id
 
@@ -970,7 +902,7 @@ class SyncServer(Server):
 
     def get_archival_memory_summary(self, agent_id: str, actor: User) -> ArchivalMemorySummary:
         agent = self.load_agent(agent_id=agent_id, actor=actor)
-        return ArchivalMemorySummary(size=agent.passage_manager.size(actor=self.default_user))
+        return ArchivalMemorySummary(size=self.agent_manager.passage_size(actor=actor, agent_id=agent_id))
 
     def get_recall_memory_summary(self, agent_id: str, actor: User) -> RecallMemorySummary:
         agent = self.load_agent(agent_id=agent_id, actor=actor)
@@ -987,18 +919,9 @@ class SyncServer(Server):
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
-        # iterate over records
-        records = letta_agent.passage_manager.list_passages(
-            actor=actor,
-            agent_id=agent_id,
-            cursor=cursor,
-            limit=limit,
-        )
+        passages = self.agent_manager.list_passages(agent_id=agent_id, actor=actor)
 
-        return records
+        return passages
 
     def get_agent_archival_cursor(
         self,
@@ -1012,15 +935,13 @@ class SyncServer(Server):
         # TODO: Thread actor directly through this function, since the top level caller most likely already retrieved the user
         actor = self.user_manager.get_user_or_default(user_id=user_id)
 
-        # Get the agent object (loaded in memory)
-        letta_agent = self.load_agent(agent_id=agent_id, actor=actor)
-
         # iterate over records
-        records = letta_agent.passage_manager.list_passages(
-            actor=self.default_user,
+        records = self.agent_manager.list_passages(
+            actor=actor,
             agent_id=agent_id,
             cursor=cursor,
             limit=limit,
+            ascending=not reverse,
         )
         return records
 
@@ -1105,7 +1026,7 @@ class SyncServer(Server):
                     config_copy[k] = server_utils.shorten_key_middle(v, chars_each_side=5)
             return config_copy
 
-        # TODO: do we need a seperate server config?
+        # TODO: do we need a separate server config?
         base_config = vars(self.config)
         clean_base_config = clean_keys(base_config)
 
@@ -1136,7 +1057,8 @@ class SyncServer(Server):
         self.source_manager.delete_source(source_id=source_id, actor=actor)
 
         # delete data from passage store
-        self.passage_manager.delete_passages(actor=actor, limit=None, source_id=source_id)
+        passages_to_be_deleted = self.agent_manager.list_passages(actor=actor, source_id=source_id, limit=None)
+        self.passage_manager.delete_passages(actor=actor, passages=passages_to_be_deleted)
 
         # TODO: delete data from agent passage stores (?)
 
@@ -1167,9 +1089,11 @@ class SyncServer(Server):
         for agent_state in agent_states:
             agent_id = agent_state.id
             agent = self.load_agent(agent_id=agent_id, actor=actor)
-            curr_passage_size = self.passage_manager.size(actor=actor, agent_id=agent_id, source_id=source_id)
+
+            # Attach source to agent
+            curr_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
             agent.attach_source(user=actor, source_id=source_id, source_manager=self.source_manager, agent_manager=self.agent_manager)
-            new_passage_size = self.passage_manager.size(actor=actor, agent_id=agent_id, source_id=source_id)
+            new_passage_size = self.agent_manager.passage_size(actor=actor, agent_id=agent_id)
             assert new_passage_size >= curr_passage_size  # in case empty files are added
 
         return job
@@ -1233,14 +1157,9 @@ class SyncServer(Server):
             source = self.source_manager.get_source_by_id(source_id=source_id, actor=actor)
         elif source_name:
             source = self.source_manager.get_source_by_name(source_name=source_name, actor=actor)
+            source_id = source.id
         else:
             raise ValueError(f"Need to provide at least source_id or source_name to find the source.")
-        source_id = source.id
-
-        # TODO: This should be done with the ORM?
-        # delete all Passage objects with source_id==source_id from agent's archival memory
-        agent = self.load_agent(agent_id=agent_id, actor=actor)
-        agent.passage_manager.delete_passages(actor=actor, limit=100, source_id=source_id)
 
         # delete agent-source mapping
         self.agent_manager.detach_source(agent_id=agent_id, source_id=source_id, actor=actor)
@@ -1262,7 +1181,7 @@ class SyncServer(Server):
         for source in sources:
 
             # count number of passages
-            num_passages = self.passage_manager.size(actor=actor, source_id=source.id)
+            num_passages = self.agent_manager.passage_size(actor=actor, source_id=source.id)
 
             # TODO: add when files table implemented
             ## count number of files
@@ -1363,6 +1282,55 @@ class SyncServer(Server):
                 warnings.warn(f"An error occurred while listing embedding models for provider {provider}: {e}")
         return embedding_models
 
+    def get_llm_config_from_handle(self, handle: str, context_window_limit: Optional[int] = None) -> LLMConfig:
+        provider_name, model_name = handle.split("/", 1)
+        provider = self.get_provider_from_name(provider_name)
+
+        llm_configs = [config for config in provider.list_llm_models() if config.model == model_name]
+        if not llm_configs:
+            raise ValueError(f"LLM model {model_name} is not supported by {provider_name}")
+        elif len(llm_configs) > 1:
+            raise ValueError(f"Multiple LLM models with name {model_name} supported by {provider_name}")
+        else:
+            llm_config = llm_configs[0]
+
+        if context_window_limit:
+            if context_window_limit > llm_config.context_window:
+                raise ValueError(f"Context window limit ({context_window_limit}) is greater than maximum of ({llm_config.context_window})")
+            llm_config.context_window = context_window_limit
+
+        return llm_config
+
+    def get_embedding_config_from_handle(
+        self, handle: str, embedding_chunk_size: int = constants.DEFAULT_EMBEDDING_CHUNK_SIZE
+    ) -> EmbeddingConfig:
+        provider_name, model_name = handle.split("/", 1)
+        provider = self.get_provider_from_name(provider_name)
+
+        embedding_configs = [config for config in provider.list_embedding_models() if config.embedding_model == model_name]
+        if not embedding_configs:
+            raise ValueError(f"Embedding model {model_name} is not supported by {provider_name}")
+        elif len(embedding_configs) > 1:
+            raise ValueError(f"Multiple embedding models with name {model_name} supported by {provider_name}")
+        else:
+            embedding_config = embedding_configs[0]
+
+        if embedding_chunk_size:
+            embedding_config.embedding_chunk_size = embedding_chunk_size
+
+        return embedding_config
+
+    def get_provider_from_name(self, provider_name: str) -> Provider:
+        providers = [provider for provider in self._enabled_providers if provider.name == provider_name]
+        if not providers:
+            raise ValueError(f"Provider {provider_name} is not supported")
+        elif len(providers) > 1:
+            raise ValueError(f"Multiple providers with name {provider_name} supported")
+        else:
+            provider = providers[0]
+
+        return provider
+
     def add_llm_model(self, request: LLMConfig) -> LLMConfig:
         """Add a new LLM model"""
 
@@ -1383,7 +1351,7 @@ class SyncServer(Server):
 
     def run_tool_from_source(
         self,
-        user_id: str,
+        actor: User,
         tool_args: str,
         tool_source: str,
         tool_source_type: Optional[str] = None,
@@ -1411,56 +1379,29 @@ class SyncServer(Server):
 
         # Next, attempt to run the tool with the sandbox
         try:
-            sandbox_run_result = ToolExecutionSandbox(tool.name, tool_args_dict, user_id, tool_object=tool).run(agent_state=agent_state)
-            function_response = str(sandbox_run_result.func_return)
-            stdout = [s for s in sandbox_run_result.stdout if s.strip()]
-            stderr = [s for s in sandbox_run_result.stderr if s.strip()]
-
-            # expected error
-            if stderr:
-                error_msg = self.get_error_msg_for_func_return(tool.name, stderr[-1])
-                return FunctionReturn(
-                    id="null",
-                    function_call_id="null",
-                    date=get_utc_time(),
-                    status="error",
-                    function_return=error_msg,
-                    stdout=stdout,
-                    stderr=stderr,
-                )
-
+            sandbox_run_result = ToolExecutionSandbox(tool.name, tool_args_dict, actor, tool_object=tool).run(agent_state=agent_state)
             return FunctionReturn(
                 id="null",
                 function_call_id="null",
                 date=get_utc_time(),
-                status="success",
-                function_return=function_response,
-                stdout=stdout,
-                stderr=stderr,
+                status=sandbox_run_result.status,
+                function_return=str(sandbox_run_result.func_return),
+                stdout=sandbox_run_result.stdout,
+                stderr=sandbox_run_result.stderr,
             )
 
-        # unexpected error TODO(@cthomas): consolidate error handling
         except Exception as e:
-            error_msg = self.get_error_msg_for_func_return(tool.name, e)
+            func_return = get_friendly_error_msg(function_name=tool.name, exception_name=type(e).__name__, exception_message=str(e))
             return FunctionReturn(
                 id="null",
                 function_call_id="null",
                 date=get_utc_time(),
                 status="error",
-                function_return=error_msg,
-                stdout=[""],
+                function_return=func_return,
+                stdout=[],
                 stderr=[traceback.format_exc()],
             )
 
-    def get_error_msg_for_func_return(self, tool_name, exception_message):
-        # same as agent.py
-        from letta.constants import MAX_ERROR_MESSAGE_CHAR_LIMIT
-
-        error_msg = f"Error executing tool {tool_name}: {exception_message}"
-        if len(error_msg) > MAX_ERROR_MESSAGE_CHAR_LIMIT:
-            error_msg = error_msg[:MAX_ERROR_MESSAGE_CHAR_LIMIT]
-        return error_msg
-
     # Composio wrappers
     def get_composio_client(self, api_key: Optional[str] = None):
         if api_key:

letta/server/ws_api/server.py

@@ -33,7 +33,7 @@ class WebSocketServer:
         self.initialize_server()
         # Can play with ping_interval and ping_timeout
         # See: https://websockets.readthedocs.io/en/stable/topics/timeouts.html
-        # and https://github.com/cpacker/Letta/issues/471
+        # and https://github.com/letta-ai/letta/issues/471
         async with websockets.serve(self.handle_client, self.host, self.port):
             await asyncio.Future()  # Run forever