letta-nightly 0.6.5.dev20241218213641__py3-none-any.whl → 0.6.5.dev20241220104040__py3-none-any.whl

letta/server/rest_api/interface.py

@@ -12,11 +12,11 @@ from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import (
     AssistantMessage,
-    FunctionCall,
-    FunctionCallDelta,
-    FunctionCallMessage,
-    FunctionReturn,
-    InternalMonologue,
+    ToolCall,
+    ToolCallDelta,
+    ToolCallMessage,
+    ToolReturnMessage,
+    ReasoningMessage,
     LegacyFunctionCallMessage,
     LegacyLettaMessage,
     LettaMessage,
@@ -411,7 +411,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
     def _process_chunk_to_letta_style(
         self, chunk: ChatCompletionChunkResponse, message_id: str, message_date: datetime
-    ) -> Optional[Union[InternalMonologue, FunctionCallMessage, AssistantMessage]]:
+    ) -> Optional[Union[ReasoningMessage, ToolCallMessage, AssistantMessage]]:
         """
         Example data from non-streaming response looks like:
 
@@ -426,10 +426,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         # inner thoughts
         if message_delta.content is not None:
-            processed_chunk = InternalMonologue(
+            processed_chunk = ReasoningMessage(
                 id=message_id,
                 date=message_date,
-                internal_monologue=message_delta.content,
+                reasoning=message_delta.content,
             )
 
         # tool calls
@@ -442,7 +442,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 if self.inner_thoughts_in_kwargs:
                     raise NotImplementedError("inner_thoughts_in_kwargs with use_assistant_message not yet supported")
 
-                # If we just received a chunk with the message in it, we either enter "send_message" mode, or we do standard FunctionCallMessage passthrough mode
+                # If we just received a chunk with the message in it, we either enter "send_message" mode, or we do standard ToolCallMessage passthrough mode
 
                 # Track the function name while streaming
                 # If we were previously on a 'send_message', we need to 'toggle' into 'content' mode
@@ -474,7 +474,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             assistant_message=cleaned_func_args,
                         )
 
-                # otherwise we just do a regular passthrough of a FunctionCallDelta via a FunctionCallMessage
+                # otherwise we just do a regular passthrough of a ToolCallDelta via a ToolCallMessage
                 else:
                     tool_call_delta = {}
                     if tool_call.id:
@@ -485,13 +485,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         if tool_call.function.name:
                             tool_call_delta["name"] = tool_call.function.name
 
-                    processed_chunk = FunctionCallMessage(
+                    processed_chunk = ToolCallMessage(
                         id=message_id,
                         date=message_date,
-                        function_call=FunctionCallDelta(
+                        tool_call=ToolCallDelta(
                             name=tool_call_delta.get("name"),
                             arguments=tool_call_delta.get("arguments"),
-                            function_call_id=tool_call_delta.get("id"),
+                            tool_call_id=tool_call_delta.get("id"),
                         ),
                     )
 
@@ -518,10 +518,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
                     # If we have inner thoughts, we should output them as a chunk
                     if updates_inner_thoughts:
-                        processed_chunk = InternalMonologue(
+                        processed_chunk = ReasoningMessage(
                             id=message_id,
                             date=message_date,
-                            internal_monologue=updates_inner_thoughts,
+                            reasoning=updates_inner_thoughts,
                         )
                         # Additionally inner thoughts may stream back with a chunk of main JSON
                         # In that case, since we can only return a chunk at a time, we should buffer it
@@ -531,7 +531,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             else:
                                 self.function_args_buffer += updates_main_json
 
-                    # If we have main_json, we should output a FunctionCallMessage
+                    # If we have main_json, we should output a ToolCallMessage
                     elif updates_main_json:
 
                         # If there's something in the function_name buffer, we should release it first
@@ -539,13 +539,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         #       however the frontend may expect name first, then args, so to be
                         #       safe we'll output name first in a separate chunk
                         if self.function_name_buffer:
-                            processed_chunk = FunctionCallMessage(
+                            processed_chunk = ToolCallMessage(
                                 id=message_id,
                                 date=message_date,
-                                function_call=FunctionCallDelta(
+                                tool_call=ToolCallDelta(
                                     name=self.function_name_buffer,
                                     arguments=None,
-                                    function_call_id=self.function_id_buffer,
+                                    tool_call_id=self.function_id_buffer,
                                 ),
                             )
                             # Clear the buffer
@@ -561,20 +561,20 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                 self.function_args_buffer += updates_main_json
 
                         # If there was nothing in the name buffer, we can proceed to
-                        # output the arguments chunk as a FunctionCallMessage
+                        # output the arguments chunk as a ToolCallMessage
                         else:
                             # There may be a buffer from a previous chunk, for example
                             # if the previous chunk had arguments but we needed to flush name
                             if self.function_args_buffer:
                                 # In this case, we should release the buffer + new data at once
                                 combined_chunk = self.function_args_buffer + updates_main_json
-                                processed_chunk = FunctionCallMessage(
+                                processed_chunk = ToolCallMessage(
                                     id=message_id,
                                     date=message_date,
-                                    function_call=FunctionCallDelta(
+                                    tool_call=ToolCallDelta(
                                         name=None,
                                         arguments=combined_chunk,
-                                        function_call_id=self.function_id_buffer,
+                                        tool_call_id=self.function_id_buffer,
                                     ),
                                 )
                                 # clear buffer
@@ -582,13 +582,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                 self.function_id_buffer = None
                             else:
                                 # If there's no buffer to clear, just output a new chunk with new data
-                                processed_chunk = FunctionCallMessage(
+                                processed_chunk = ToolCallMessage(
                                     id=message_id,
                                     date=message_date,
-                                    function_call=FunctionCallDelta(
+                                    tool_call=ToolCallDelta(
                                         name=None,
                                         arguments=updates_main_json,
-                                        function_call_id=self.function_id_buffer,
+                                        tool_call_id=self.function_id_buffer,
                                     ),
                                 )
                                 self.function_id_buffer = None
@@ -608,10 +608,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         #     # if tool_call.function.name:
                         #     # tool_call_delta["name"] = tool_call.function.name
 
-                        # processed_chunk = FunctionCallMessage(
+                        # processed_chunk = ToolCallMessage(
                         #     id=message_id,
                         #     date=message_date,
-                        #     function_call=FunctionCallDelta(name=tool_call_delta.get("name"), arguments=tool_call_delta.get("arguments")),
+                        #     tool_call=ToolCallDelta(name=tool_call_delta.get("name"), arguments=tool_call_delta.get("arguments")),
                         # )
 
                     else:
@@ -642,10 +642,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 #     if tool_call.function.name:
                 #         tool_call_delta["name"] = tool_call.function.name
 
-                # processed_chunk = FunctionCallMessage(
+                # processed_chunk = ToolCallMessage(
                 #     id=message_id,
                 #     date=message_date,
-                #     function_call=FunctionCallDelta(name=tool_call_delta.get("name"), arguments=tool_call_delta.get("arguments")),
+                #     tool_call=ToolCallDelta(name=tool_call_delta.get("name"), arguments=tool_call_delta.get("arguments")),
                 # )
 
             # elif False and self.inner_thoughts_in_kwargs and tool_call.function:
@@ -680,15 +680,15 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             # Once we get a complete key, check if the key matches
 
             # If it does match, start processing the value (stringified-JSON string
-            # And with each new chunk, output it as a chunk of type InternalMonologue
+            # And with each new chunk, output it as a chunk of type ReasoningMessage
 
-            # If the key doesn't match, then flush the buffer as a single FunctionCallMessage chunk
+            # If the key doesn't match, then flush the buffer as a single ToolCallMessage chunk
 
             # If we're reading a value
 
-            # If we're reading the inner thoughts value, we output chunks of type InternalMonologue
+            # If we're reading the inner thoughts value, we output chunks of type ReasoningMessage
 
-            # Otherwise, do simple chunks of FunctionCallMessage
+            # Otherwise, do simple chunks of ToolCallMessage
 
             else:
 
@@ -701,13 +701,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     if tool_call.function.name:
                         tool_call_delta["name"] = tool_call.function.name
 
-                processed_chunk = FunctionCallMessage(
+                processed_chunk = ToolCallMessage(
                     id=message_id,
                     date=message_date,
-                    function_call=FunctionCallDelta(
+                    tool_call=ToolCallDelta(
                         name=tool_call_delta.get("name"),
                         arguments=tool_call_delta.get("arguments"),
-                        function_call_id=tool_call_delta.get("id"),
+                        tool_call_id=tool_call_delta.get("id"),
                     ),
                 )
 
@@ -823,10 +823,10 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             #     "id": str(msg_obj.id) if msg_obj is not None else None,
             # }
             assert msg_obj is not None, "Internal monologue requires msg_obj references for metadata"
-            processed_chunk = InternalMonologue(
+            processed_chunk = ReasoningMessage(
                 id=msg_obj.id,
                 date=msg_obj.created_at,
-                internal_monologue=msg,
+                reasoning=msg,
             )
 
             self._push_to_buffer(processed_chunk)
@@ -911,13 +911,13 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             assistant_message=func_args[self.assistant_message_tool_kwarg],
                         )
                     else:
-                        processed_chunk = FunctionCallMessage(
+                        processed_chunk = ToolCallMessage(
                             id=msg_obj.id,
                             date=msg_obj.created_at,
-                            function_call=FunctionCall(
+                            tool_call=ToolCall(
                                 name=function_call.function.name,
                                 arguments=function_call.function.arguments,
-                                function_call_id=function_call.id,
+                                tool_call_id=function_call.id,
                             ),
                         )
 
@@ -942,24 +942,24 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             msg = msg.replace("Success: ", "")
             # new_message = {"function_return": msg, "status": "success"}
             assert msg_obj.tool_call_id is not None
-            new_message = FunctionReturn(
+            new_message = ToolReturnMessage(
                 id=msg_obj.id,
                 date=msg_obj.created_at,
-                function_return=msg,
+                tool_return=msg,
                 status="success",
-                function_call_id=msg_obj.tool_call_id,
+                tool_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(
+            new_message = ToolReturnMessage(
                 id=msg_obj.id,
                 date=msg_obj.created_at,
-                function_return=msg,
+                tool_return=msg,
                 status="error",
-                function_call_id=msg_obj.tool_call_id,
+                tool_call_id=msg_obj.tool_call_id,
             )
 
         else:

letta/server/rest_api/routers/openai/chat_completions/chat_completions.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Optional
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_message import FunctionCall, LettaMessage
+from letta.schemas.letta_message import ToolCall, LettaMessage
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
 from letta.schemas.openai.chat_completion_response import (
     ChatCompletionResponse,
@@ -94,7 +94,7 @@ async def create_chat_completion(
         created_at = None
         for letta_msg in response_messages.messages:
             assert isinstance(letta_msg, LettaMessage)
-            if isinstance(letta_msg, FunctionCall):
+            if isinstance(letta_msg, ToolCall):
                 if letta_msg.name and letta_msg.name == "send_message":
                     try:
                         letta_function_call_args = json.loads(letta_msg.arguments)

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

@@ -17,6 +17,7 @@ from fastapi.responses import JSONResponse, StreamingResponse
 from pydantic import Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
+from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
 from letta.schemas.block import (  # , BlockLabelUpdate, BlockLimitUpdate
@@ -54,6 +55,8 @@ from letta.server.server import SyncServer
 
 router = APIRouter(prefix="/agents", tags=["agents"])
 
+logger = get_logger(__name__)
+
 
 # TODO: This should be paginated
 @router.get("/", response_model=List[AgentState], operation_id="list_agents")

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

@@ -7,7 +7,7 @@ from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
 from letta.errors import LettaToolCreateError
 from letta.orm.errors import UniqueConstraintViolationError
-from letta.schemas.letta_message import FunctionReturn
+from letta.schemas.letta_message import ToolReturnMessage
 from letta.schemas.tool import Tool, ToolCreate, ToolRunFromSource, ToolUpdate
 from letta.schemas.user import User
 from letta.server.rest_api.utils import get_letta_server
@@ -152,33 +152,18 @@ def update_tool(
 
 
 @router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")
-def add_base_tools(
+def upsert_base_tools(
     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 base tools
+    Upsert base tools
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.tool_manager.add_base_tools(actor=actor)
+    return server.tool_manager.upsert_base_tools(actor=actor)
 
 
-# NOTE: can re-enable if needed
-# @router.post("/{tool_id}/run", response_model=FunctionReturn, operation_id="run_tool")
-# def run_tool(
-#     server: SyncServer = Depends(get_letta_server),
-#     request: ToolRun = Body(...),
-#     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-# ):
-#     """
-#     Run an existing tool on provided arguments
-#     """
-#     actor = server.user_manager.get_user_or_default(user_id=user_id)
-
-#     return server.run_tool(tool_id=request.tool_id, tool_args=request.tool_args, user_id=actor.id)
-
-
-@router.post("/run", response_model=FunctionReturn, operation_id="run_tool_from_source")
+@router.post("/run", response_model=ToolReturnMessage, operation_id="run_tool_from_source")
 def run_tool_from_source(
     server: SyncServer = Depends(get_letta_server),
     request: ToolRunFromSource = Body(...),

letta/server/rest_api/utils.py

@@ -8,6 +8,7 @@ from typing import AsyncGenerator, Optional, Union
 from fastapi import Header
 from pydantic import BaseModel
 
+from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.schemas.usage import LettaUsageStatistics
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.server import SyncServer
@@ -61,34 +62,21 @@ async def sse_async_generator(
                 if not isinstance(usage, LettaUsageStatistics):
                     raise ValueError(f"Expected LettaUsageStatistics, got {type(usage)}")
                 yield sse_formatter({"usage": usage.model_dump()})
-            except Exception as e:
-                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
+            except ContextWindowExceededError as e:
+                log_error_to_sentry(e)
+                yield sse_formatter({"error": f"Stream failed: {e}", "code": str(e.code.value) if e.code else None})
 
-                    sentry_sdk.capture_exception(e)
+            except RateLimitExceededError as e:
+                log_error_to_sentry(e)
+                yield sse_formatter({"error": f"Stream failed: {e}", "code": str(e.code.value) if e.code else None})
 
+            except Exception as e:
+                log_error_to_sentry(e)
                 yield sse_formatter({"error": f"Stream failed (internal error occured)"})
 
     except Exception as e:
-        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)
-
+        log_error_to_sentry(e)
         yield sse_formatter({"error": "Stream failed (decoder encountered an error)"})
 
     finally:
@@ -113,3 +101,16 @@ def get_user_id(user_id: Optional[str] = Header(None, alias="user_id")) -> Optio
 
 def get_current_interface() -> StreamingServerInterface:
     return StreamingServerInterface
+
+def log_error_to_sentry(e):
+    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)

letta/server/server.py

@@ -47,7 +47,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 # openai schemas
 from letta.schemas.enums import JobStatus
 from letta.schemas.job import Job, JobUpdate
-from letta.schemas.letta_message import FunctionReturn, LettaMessage
+from letta.schemas.letta_message import ToolReturnMessage, LettaMessage
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import (
     ArchivalMemorySummary,
@@ -301,7 +301,7 @@ class SyncServer(Server):
             self.default_org = self.organization_manager.create_default_organization()
             self.default_user = self.user_manager.create_default_user()
             self.block_manager.add_default_blocks(actor=self.default_user)
-            self.tool_manager.add_base_tools(actor=self.default_user)
+            self.tool_manager.upsert_base_tools(actor=self.default_user)
 
             # If there is a default org/user
             # This logic may have to change in the future
@@ -981,15 +981,12 @@ class SyncServer(Server):
         assistant_message_tool_kwarg: str = constants.DEFAULT_MESSAGE_TOOL_KWARG,
     ) -> Union[List[Message], List[LettaMessage]]:
         # 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
+        actor = self.user_manager.get_user_or_default(user_id=user_id)
         start_date = self.message_manager.get_message_by_id(after, actor=actor).created_at if after else None
         end_date = self.message_manager.get_message_by_id(before, actor=actor).created_at if before else None
-        records = letta_agent.message_manager.list_messages_for_agent(
+
+        records = self.message_manager.list_messages_for_agent(
             agent_id=agent_id,
             actor=actor,
             start_date=start_date,
@@ -998,10 +995,7 @@ class SyncServer(Server):
             ascending=not reverse,
         )
 
-        assert all(isinstance(m, Message) for m in records)
-
         if not return_message_object:
-            # If we're GETing messages in reverse, we need to reverse the inner list (generated by to_letta_message)
             records = [
                 msg
                 for m in records
@@ -1356,7 +1350,7 @@ class SyncServer(Server):
         tool_source: str,
         tool_source_type: Optional[str] = None,
         tool_name: Optional[str] = None,
-    ) -> FunctionReturn:
+    ) -> ToolReturnMessage:
         """Run a tool from source code"""
 
         try:
@@ -1380,24 +1374,24 @@ class SyncServer(Server):
         # Next, attempt to run the tool with the sandbox
         try:
             sandbox_run_result = ToolExecutionSandbox(tool.name, tool_args_dict, actor, tool_object=tool).run(agent_state=agent_state)
-            return FunctionReturn(
+            return ToolReturnMessage(
                 id="null",
-                function_call_id="null",
+                tool_call_id="null",
                 date=get_utc_time(),
                 status=sandbox_run_result.status,
-                function_return=str(sandbox_run_result.func_return),
+                tool_return=str(sandbox_run_result.func_return),
                 stdout=sandbox_run_result.stdout,
                 stderr=sandbox_run_result.stderr,
             )
 
         except Exception as e:
             func_return = get_friendly_error_msg(function_name=tool.name, exception_name=type(e).__name__, exception_message=str(e))
-            return FunctionReturn(
+            return ToolReturnMessage(
                 id="null",
-                function_call_id="null",
+                tool_call_id="null",
                 date=get_utc_time(),
                 status="error",
-                function_return=func_return,
+                tool_return=func_return,
                 stdout=[],
                 stderr=[traceback.format_exc()],
             )