letta-nightly 0.5.0.dev20241018104142__tar.gz → 0.5.0.dev20241020104030__tar.gz

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.0.dev20241018104142
+Version: 0.5.0.dev20241020104030
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -24,7 +24,7 @@ Requires-Dist: alembic (>=1.13.3,<2.0.0)
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev"
 Requires-Dist: chromadb (>=0.4.24,<0.5.0)
-Requires-Dist: composio-core (>=0.5.28,<0.6.0) ; extra == "external-tools"
+Requires-Dist: composio-core (>=0.5.34,<0.6.0) ; extra == "external-tools"
 Requires-Dist: composio-langchain (>=0.5.28,<0.6.0) ; extra == "external-tools"
 Requires-Dist: crewai (>=0.41.1,<0.42.0) ; extra == "external-tools"
 Requires-Dist: crewai-tools (>=0.8.3,<0.9.0) ; extra == "external-tools"

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/agent.py

@@ -23,7 +23,7 @@ from letta.errors import LLMError
 from letta.interface import AgentInterface
 from letta.llm_api.helpers import is_context_overflow_error
 from letta.llm_api.llm_api_tools import create
-from letta.local_llm.utils import num_tokens_from_messages
+from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.memory import ArchivalMemory, RecallMemory, summarize_messages
 from letta.metadata import MetadataStore
 from letta.persistence_manager import LocalStateManager
@@ -33,6 +33,9 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import MessageRole
 from letta.schemas.memory import ContextWindowOverview, Memory
 from letta.schemas.message import Message, UpdateMessage
+from letta.schemas.openai.chat_completion_request import (
+    Tool as ChatCompletionRequestTool,
+)
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
 from letta.schemas.openai.chat_completion_response import (
     Message as ChatCompletionMessage,
@@ -500,7 +503,7 @@ class Agent(BaseAgent):
     def _handle_ai_response(
         self,
         response_message: ChatCompletionMessage,  # TODO should we eventually move the Message creation outside of this function?
-        override_tool_call_id: bool = True,
+        override_tool_call_id: bool = False,
         # If we are streaming, we needed to create a Message ID ahead of time,
         # and now we want to use it in the creation of the Message object
         # TODO figure out a cleaner way to do this
@@ -527,6 +530,7 @@ class Agent(BaseAgent):
 
             # generate UUID for tool call
             if override_tool_call_id or response_message.function_call:
+                warnings.warn("Overriding the tool call can result in inconsistent tool call IDs during streaming")
                 tool_call_id = get_tool_call_id()  # needs to be a string for JSON
                 response_message.tool_calls[0].id = tool_call_id
             else:
@@ -1458,6 +1462,24 @@ class Agent(BaseAgent):
         )
         num_tokens_external_memory_summary = count_tokens(external_memory_summary)
 
+        # tokens taken up by function definitions
+        if self.functions:
+            available_functions_definitions = [ChatCompletionRequestTool(type="function", function=f) for f in self.functions]
+            num_tokens_available_functions_definitions = num_tokens_from_functions(functions=self.functions, model=self.model)
+        else:
+            available_functions_definitions = []
+            num_tokens_available_functions_definitions = 0
+
+        num_tokens_used_total = (
+            num_tokens_system  # system prompt
+            + num_tokens_available_functions_definitions  # function definitions
+            + num_tokens_core_memory  # core memory
+            + num_tokens_external_memory_summary  # metadata (statistics) about recall/archival
+            + num_tokens_summary_memory  # summary of ongoing conversation
+            + num_tokens_messages  # tokens taken by messages
+        )
+        assert isinstance(num_tokens_used_total, int)
+
         return ContextWindowOverview(
             # context window breakdown (in messages)
             num_messages=len(self._messages),
@@ -1466,7 +1488,7 @@ class Agent(BaseAgent):
             num_tokens_external_memory_summary=num_tokens_external_memory_summary,
             # top-level information
             context_window_size_max=self.agent_state.llm_config.context_window,
-            context_window_size_current=num_tokens_system + num_tokens_core_memory + num_tokens_summary_memory + num_tokens_messages,
+            context_window_size_current=num_tokens_used_total,
             # context window breakdown (in tokens)
             num_tokens_system=num_tokens_system,
             system_prompt=system_prompt,
@@ -1476,6 +1498,9 @@ class Agent(BaseAgent):
             summary_memory=summary_memory,
             num_tokens_messages=num_tokens_messages,
             messages=self._messages,
+            # related to functions
+            num_tokens_functions_definitions=num_tokens_available_functions_definitions,
+            functions_definitions=available_functions_definitions,
         )
 
 

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/client/client.py

@@ -96,6 +96,9 @@ class AbstractClient(object):
     ):
         raise NotImplementedError
 
+    def get_tools_from_agent(self, agent_id: str):
+        raise NotImplementedError
+
     def add_tool_to_agent(self, agent_id: str, tool_id: str):
         raise NotImplementedError
 
@@ -197,7 +200,7 @@ class AbstractClient(object):
     ) -> Tool:
         raise NotImplementedError
 
-    def list_tools(self) -> List[Tool]:
+    def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Tool]:
         raise NotImplementedError
 
     def get_tool(self, id: str) -> Tool:
@@ -480,6 +483,21 @@ class RESTClient(AbstractClient):
             raise ValueError(f"Failed to update agent: {response.text}")
         return AgentState(**response.json())
 
+    def get_tools_from_agent(self, agent_id: str) -> List[Tool]:
+        """
+        Get tools to an existing agent
+
+        Args:
+           agent_id (str): ID of the agent
+
+        Returns:
+           List[Tool]: A List of Tool objs
+        """
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/tools", headers=self.headers)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to get tools from agents: {response.text}")
+        return [Tool(**tool) for tool in response.json()]
+
     def add_tool_to_agent(self, agent_id: str, tool_id: str):
         """
         Add tool to an existing agent
@@ -1364,14 +1382,19 @@ class RESTClient(AbstractClient):
     #        raise ValueError(f"Failed to create tool: {response.text}")
     #    return ToolModel(**response.json())
 
-    def list_tools(self) -> List[Tool]:
+    def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Tool]:
         """
         List available tools for the user.
 
         Returns:
             tools (List[Tool]): List of tools
         """
-        response = requests.get(f"{self.base_url}/{self.api_prefix}/tools", headers=self.headers)
+        params = {}
+        if cursor:
+            params["cursor"] = str(cursor)
+        if limit:
+            params["limit"] = limit
+        response = requests.get(f"{self.base_url}/{self.api_prefix}/tools", params=params, headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to list tools: {response.text}")
         return [Tool(**tool) for tool in response.json()]
@@ -1692,6 +1715,19 @@ class LocalClient(AbstractClient):
         )
         return agent_state
 
+    def get_tools_from_agent(self, agent_id: str) -> List[Tool]:
+        """
+        Get tools from an existing agent.
+
+        Args:
+            agent_id (str): ID of the agent
+
+        Returns:
+            List[Tool]: A list of Tool objs
+        """
+        self.interface.clear()
+        return self.server.get_tools_from_agent(agent_id=agent_id, user_id=self.user_id)
+
     def add_tool_to_agent(self, agent_id: str, tool_id: str):
         """
         Add tool to an existing agent
@@ -2250,15 +2286,14 @@ class LocalClient(AbstractClient):
             ToolUpdate(id=id, source_type=source_type, source_code=source_code, tags=tags, name=name), self.user_id
         )
 
-    def list_tools(self):
+    def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50) -> List[Tool]:
         """
         List available tools for the user.
 
         Returns:
             tools (List[Tool]): List of tools
         """
-        tools = self.server.list_tools(user_id=self.user_id)
-        return tools
+        return self.server.list_tools(cursor=cursor, limit=limit, user_id=self.user_id)
 
     def get_tool(self, id: str) -> Optional[Tool]:
         """

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/llm_api/openai.py

@@ -18,8 +18,13 @@ from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_mes
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as _Message
 from letta.schemas.message import MessageRole as _MessageRole
+from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
 from letta.schemas.openai.chat_completion_request import (
-    ChatCompletionRequest,
+    FunctionCall as ToolFunctionChoiceFunctionCall,
+)
+from letta.schemas.openai.chat_completion_request import (
+    Tool,
+    ToolFunctionChoice,
     cast_message_to_subtype,
 )
 from letta.schemas.openai.chat_completion_response import (
@@ -36,7 +41,7 @@ from letta.streaming_interface import (
     AgentChunkStreamingInterface,
     AgentRefreshStreamingInterface,
 )
-from letta.utils import smart_urljoin
+from letta.utils import get_tool_call_id, smart_urljoin
 
 OPENAI_SSE_DONE = "[DONE]"
 
@@ -100,10 +105,10 @@ def openai_get_model_list(
 
 def build_openai_chat_completions_request(
     llm_config: LLMConfig,
-    messages: List[Message],
+    messages: List[_Message],
     user_id: Optional[str],
     functions: Optional[list],
-    function_call: str,
+    function_call: Optional[str],
     use_tool_naming: bool,
     max_tokens: Optional[int],
 ) -> ChatCompletionRequest:
@@ -124,11 +129,17 @@ def build_openai_chat_completions_request(
         model = None
 
     if use_tool_naming:
+        if function_call is None:
+            tool_choice = None
+        elif function_call not in ["none", "auto", "required"]:
+            tool_choice = ToolFunctionChoice(type="function", function=ToolFunctionChoiceFunctionCall(name=function_call))
+        else:
+            tool_choice = function_call
         data = ChatCompletionRequest(
             model=model,
             messages=openai_message_list,
-            tools=[{"type": "function", "function": f} for f in functions] if functions else None,
-            tool_choice=function_call,
+            tools=[Tool(type="function", function=f) for f in functions] if functions else None,
+            tool_choice=tool_choice,
             user=str(user_id),
             max_tokens=max_tokens,
         )
@@ -163,6 +174,7 @@ def openai_chat_completions_process_stream(
     stream_interface: Optional[Union[AgentChunkStreamingInterface, AgentRefreshStreamingInterface]] = None,
     create_message_id: bool = True,
     create_message_datetime: bool = True,
+    override_tool_call_id: bool = True,
 ) -> ChatCompletionResponse:
     """Process a streaming completion response, and return a ChatCompletionRequest at the end.
 
@@ -233,6 +245,14 @@ def openai_chat_completions_process_stream(
         ):
             assert isinstance(chat_completion_chunk, ChatCompletionChunkResponse), type(chat_completion_chunk)
 
+            # NOTE: this assumes that the tool call ID will only appear in one of the chunks during the stream
+            if override_tool_call_id:
+                for choice in chat_completion_chunk.choices:
+                    if choice.delta.tool_calls and len(choice.delta.tool_calls) > 0:
+                        for tool_call in choice.delta.tool_calls:
+                            if tool_call.id is not None:
+                                tool_call.id = get_tool_call_id()
+
             if stream_interface:
                 if isinstance(stream_interface, AgentChunkStreamingInterface):
                     stream_interface.process_chunk(
@@ -279,6 +299,7 @@ def openai_chat_completions_process_stream(
                     else:
                         accum_message.content += content_delta
 
+                # TODO(charles) make sure this works for parallel tool calling?
                 if message_delta.tool_calls is not None:
                     tool_calls_delta = message_delta.tool_calls
 
@@ -329,7 +350,7 @@ def openai_chat_completions_process_stream(
     assert all([c.finish_reason != TEMP_STREAM_FINISH_REASON for c in chat_completion_response.choices])
     assert all(
         [
-            all([tc != TEMP_STREAM_TOOL_CALL_ID for tc in c.message.tool_calls]) if c.message.tool_calls else True
+            all([tc.id != TEMP_STREAM_TOOL_CALL_ID for tc in c.message.tool_calls]) if c.message.tool_calls else True
             for c in chat_completion_response.choices
         ]
     )

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/local_llm/utils.py

@@ -1,6 +1,6 @@
 import os
 import warnings
-from typing import List
+from typing import List, Union
 
 import requests
 import tiktoken
@@ -11,6 +11,7 @@ import letta.local_llm.llm_chat_completion_wrappers.configurable_wrapper as conf
 import letta.local_llm.llm_chat_completion_wrappers.dolphin as dolphin
 import letta.local_llm.llm_chat_completion_wrappers.llama3 as llama3
 import letta.local_llm.llm_chat_completion_wrappers.zephyr as zephyr
+from letta.schemas.openai.chat_completion_request import Tool, ToolCall
 
 
 def post_json_auth_request(uri, json_payload, auth_type, auth_key):
@@ -123,7 +124,7 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
     return num_tokens
 
 
-def num_tokens_from_tool_calls(tool_calls: List[dict], model: str = "gpt-4"):
+def num_tokens_from_tool_calls(tool_calls: Union[List[dict], List[ToolCall]], model: str = "gpt-4"):
     """Based on above code (num_tokens_from_functions).
 
     Example to encode:
@@ -144,10 +145,25 @@ def num_tokens_from_tool_calls(tool_calls: List[dict], model: str = "gpt-4"):
 
     num_tokens = 0
     for tool_call in tool_calls:
-        function_tokens = len(encoding.encode(tool_call["id"]))
-        function_tokens += 2 + len(encoding.encode(tool_call["type"]))
-        function_tokens += 2 + len(encoding.encode(tool_call["function"]["name"]))
-        function_tokens += 2 + len(encoding.encode(tool_call["function"]["arguments"]))
+        if isinstance(tool_call, dict):
+            tool_call_id = tool_call["id"]
+            tool_call_type = tool_call["type"]
+            tool_call_function = tool_call["function"]
+            tool_call_function_name = tool_call_function["name"]
+            tool_call_function_arguments = tool_call_function["arguments"]
+        elif isinstance(tool_call, Tool):
+            tool_call_id = tool_call.id
+            tool_call_type = tool_call.type
+            tool_call_function = tool_call.function
+            tool_call_function_name = tool_call_function.name
+            tool_call_function_arguments = tool_call_function.arguments
+        else:
+            raise ValueError(f"Unknown tool call type: {type(tool_call)}")
+
+        function_tokens = len(encoding.encode(tool_call_id))
+        function_tokens += 2 + len(encoding.encode(tool_call_type))
+        function_tokens += 2 + len(encoding.encode(tool_call_function_name))
+        function_tokens += 2 + len(encoding.encode(tool_call_function_arguments))
 
         num_tokens += function_tokens
 

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/metadata.py

@@ -14,7 +14,9 @@ from sqlalchemy import (
     Integer,
     String,
     TypeDecorator,
+    asc,
     desc,
+    or_,
 )
 from sqlalchemy.sql import func
 
@@ -707,12 +709,19 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    # def list_tools(self, user_id: str) -> List[ToolModel]: # TODO: add when users can creat tools
-    def list_tools(self, user_id: Optional[str] = None) -> List[ToolModel]:
+    def list_tools(self, cursor: Optional[str] = None, limit: Optional[int] = 50, user_id: Optional[str] = None) -> List[ToolModel]:
         with self.session_maker() as session:
-            results = session.query(ToolModel).filter(ToolModel.user_id == None).all()
-            if user_id:
-                results += session.query(ToolModel).filter(ToolModel.user_id == user_id).all()
+            # Query for public tools or user-specific tools
+            query = session.query(ToolModel).filter(or_(ToolModel.user_id == None, ToolModel.user_id == user_id))
+
+            # Apply cursor if provided (assuming cursor is an ID)
+            if cursor:
+                query = query.filter(ToolModel.id > cursor)
+
+            # Order by ID and apply limit
+            results = query.order_by(asc(ToolModel.id)).limit(limit).all()
+
+            # Convert to records
             res = [r.to_record() for r in results]
             return res
 

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/schemas/letta_message.py

@@ -78,12 +78,14 @@ class FunctionCall(BaseModel):
 
     name: str
     arguments: str
+    function_call_id: str
 
 
 class FunctionCallDelta(BaseModel):
 
     name: Optional[str]
     arguments: Optional[str]
+    function_call_id: Optional[str]
 
     # NOTE: this is a workaround to exclude None values from the JSON dump,
     # since the OpenAI style of returning chunks doesn't include keys with null values
@@ -129,10 +131,10 @@ class FunctionCallMessage(LettaMessage):
     @classmethod
     def validate_function_call(cls, v):
         if isinstance(v, dict):
-            if "name" in v and "arguments" in v:
-                return FunctionCall(name=v["name"], arguments=v["arguments"])
-            elif "name" in v or "arguments" in v:
-                return FunctionCallDelta(name=v.get("name"), arguments=v.get("arguments"))
+            if "name" in v and "arguments" in v and "function_call_id" in v:
+                return FunctionCall(name=v["name"], arguments=v["arguments"], function_call_id=v["function_call_id"])
+            elif "name" in v or "arguments" in v or "function_call_id" in v:
+                return FunctionCallDelta(name=v.get("name"), arguments=v.get("arguments"), function_call_id=v.get("function_call_id"))
             else:
                 raise ValueError("function_call must contain either 'name' or 'arguments'")
         return v
@@ -147,11 +149,13 @@ class FunctionReturn(LettaMessage):
         status (Literal["success", "error"]): The status of the function call
         id (str): The ID of the message
         date (datetime): The date the message was created in ISO format
+        function_call_id (str): A unique identifier for the function call that generated this message
     """
 
     message_type: Literal["function_return"] = "function_return"
     function_return: str
     status: Literal["success", "error"]
+    function_call_id: str
 
 
 # Legacy Letta API had an additional type "assistant_message" and the "function_call" was a formatted string

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/schemas/memory.py

@@ -9,6 +9,7 @@ if TYPE_CHECKING:
 
 from letta.schemas.block import Block
 from letta.schemas.message import Message
+from letta.schemas.openai.chat_completion_request import Tool
 
 
 class ContextWindowOverview(BaseModel):
@@ -41,6 +42,9 @@ class ContextWindowOverview(BaseModel):
     num_tokens_summary_memory: int = Field(..., description="The number of tokens in the summary memory.")
     summary_memory: Optional[str] = Field(None, description="The content of the summary memory.")
 
+    num_tokens_functions_definitions: int = Field(..., description="The number of tokens in the functions definitions.")
+    functions_definitions: Optional[List[Tool]] = Field(..., description="The content of the functions definitions.")
+
     num_tokens_messages: int = Field(..., description="The number of tokens in the messages list.")
     # TODO make list of messages?
     # messages: List[dict] = Field(..., description="The messages in the context window.")

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/schemas/message.py

@@ -178,6 +178,7 @@ class Message(BaseMessage):
                                 function_call=FunctionCall(
                                     name=tool_call.function.name,
                                     arguments=tool_call.function.arguments,
+                                    function_call_id=tool_call.id,
                                 ),
                             )
                         )
@@ -203,6 +204,7 @@ class Message(BaseMessage):
                     raise ValueError(f"Invalid status: {status}")
             except json.JSONDecodeError:
                 raise ValueError(f"Failed to decode function return: {self.text}")
+            assert self.tool_call_id is not None
             messages.append(
                 # TODO make sure this is what the API returns
                 # function_return may not match exactly...
@@ -211,6 +213,7 @@ class Message(BaseMessage):
                     date=self.created_at,
                     function_return=self.text,
                     status=status_enum,
+                    function_call_id=self.tool_call_id,
                 )
             )
         elif self.role == MessageRole.user:

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/schemas/openai/chat_completion_request.py

@@ -74,7 +74,7 @@ class ToolFunctionChoice(BaseModel):
     function: FunctionCall
 
 
-ToolChoice = Union[Literal["none", "auto"], ToolFunctionChoice]
+ToolChoice = Union[Literal["none", "auto", "required"], ToolFunctionChoice]
 
 
 ## tools ##
@@ -117,7 +117,7 @@ class ChatCompletionRequest(BaseModel):
 
     # function-calling related
     tools: Optional[List[Tool]] = None
-    tool_choice: Optional[ToolChoice] = "none"
+    tool_choice: Optional[ToolChoice] = None  # "none" means don't call a tool
     # deprecated scheme
     functions: Optional[List[FunctionSchema]] = None
     function_call: Optional[FunctionCallChoice] = None

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/server/rest_api/app.py

@@ -70,6 +70,7 @@ def create_application() -> "FastAPI":
         title="Letta",
         summary="Create LLM agents with long-term memory and custom tools 📚🦙",
         version="1.0.0",  # TODO wire this up to the version in the package
+        debug=True,
     )
 
     if "--ade" in sys.argv:

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/server/rest_api/interface.py

@@ -531,7 +531,11 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     processed_chunk = FunctionCallMessage(
                         id=message_id,
                         date=message_date,
-                        function_call=FunctionCallDelta(name=tool_call_delta.get("name"), arguments=tool_call_delta.get("arguments")),
+                        function_call=FunctionCallDelta(
+                            name=tool_call_delta.get("name"),
+                            arguments=tool_call_delta.get("arguments"),
+                            function_call_id=tool_call_delta.get("id"),
+                        ),
                     )
 
             else:
@@ -548,7 +552,11 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 processed_chunk = FunctionCallMessage(
                     id=message_id,
                     date=message_date,
-                    function_call=FunctionCallDelta(name=tool_call_delta.get("name"), arguments=tool_call_delta.get("arguments")),
+                    function_call=FunctionCallDelta(
+                        name=tool_call_delta.get("name"),
+                        arguments=tool_call_delta.get("arguments"),
+                        function_call_id=tool_call_delta.get("id"),
+                    ),
                 )
 
         elif choice.finish_reason is not None:
@@ -759,6 +767,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             function_call=FunctionCall(
                                 name=function_call.function.name,
                                 arguments=function_call.function.arguments,
+                                function_call_id=function_call.id,
                             ),
                         )
 
@@ -786,21 +795,25 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         elif msg.startswith("Success: "):
             msg = msg.replace("Success: ", "")
             # new_message = {"function_return": msg, "status": "success"}
+            assert msg_obj.tool_call_id is not None
             new_message = FunctionReturn(
                 id=msg_obj.id,
                 date=msg_obj.created_at,
                 function_return=msg,
                 status="success",
+                function_call_id=msg_obj.tool_call_id,
             )
 
         elif msg.startswith("Error: "):
             msg = msg.replace("Error: ", "")
             # new_message = {"function_return": msg, "status": "error"}
+            assert msg_obj.tool_call_id is not None
             new_message = FunctionReturn(
                 id=msg_obj.id,
                 date=msg_obj.created_at,
                 function_return=msg,
                 status="error",
+                function_call_id=msg_obj.tool_call_id,
             )
 
         else:

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/server/rest_api/routers/v1/agents.py

@@ -27,6 +27,7 @@ from letta.schemas.memory import (
 from letta.schemas.message import Message, MessageCreate, UpdateMessage
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
+from letta.schemas.tool import Tool
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import get_letta_server, sse_async_generator
 from letta.server.server import SyncServer
@@ -100,6 +101,17 @@ def update_agent(
     return server.update_agent(update_agent, user_id=actor.id)
 
 
+@router.get("/{agent_id}/tools", response_model=List[Tool], operation_id="get_tools_from_agent")
+def get_tools_from_agent(
+    agent_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """Get tools from an existing agent"""
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.get_tools_from_agent(agent_id=agent_id, user_id=actor.id)
+
+
 @router.patch("/{agent_id}/add-tool/{tool_id}", response_model=AgentState, operation_id="add_tool_to_agent")
 def add_tool_to_agent(
     agent_id: str,
@@ -107,10 +119,8 @@ def add_tool_to_agent(
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
-    """Add tools to an exsiting agent"""
+    """Add tools to an existing agent"""
     actor = server.get_user_or_default(user_id=user_id)
-
-    update_agent.id = agent_id
     return server.add_tool_to_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
 
 
@@ -121,10 +131,8 @@ def remove_tool_from_agent(
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
-    """Add tools to an exsiting agent"""
+    """Add tools to an existing agent"""
     actor = server.get_user_or_default(user_id=user_id)
-
-    update_agent.id = agent_id
     return server.remove_tool_from_agent(agent_id=agent_id, tool_id=tool_id, user_id=actor.id)
 
 

{letta_nightly-0.5.0.dev20241018104142 → letta_nightly-0.5.0.dev20241020104030}/letta/server/rest_api/routers/v1/tools.py

@@ -59,18 +59,21 @@ def get_tool_id(
 
 @router.get("/", response_model=List[Tool], operation_id="list_tools")
 def list_all_tools(
+    cursor: Optional[str] = None,
+    limit: Optional[int] = 50,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Get a list of all tools available to agents created by a user
     """
-    actor = server.get_user_or_default(user_id=user_id)
-    actor.id
-
-    # TODO: add back when user-specific
-    return server.list_tools(user_id=actor.id)
-    # return server.ms.list_tools(user_id=None)
+    try:
+        actor = server.get_user_or_default(user_id=user_id)
+        return server.list_tools(cursor=cursor, limit=limit, user_id=actor.id)
+    except Exception as e:
+        # Log or print the full exception here for debugging
+        print(f"Error occurred: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.post("/", response_model=Tool, operation_id="create_tool")