letta-nightly 0.6.1.dev20241207104149__tar.gz → 0.6.1.dev20241208104134__tar.gz

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.1.dev20241207104149
+Version: 0.6.1.dev20241208104134
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -26,7 +26,7 @@ Requires-Dist: alembic (>=1.13.3,<2.0.0)
 Requires-Dist: autoflake (>=2.3.0,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: black[jupyter] (>=24.2.0,<25.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: chromadb (>=0.4.24,<0.5.0)
-Requires-Dist: composio-core (>=0.5.34,<0.6.0)
+Requires-Dist: composio-core (>=0.5.51,<0.6.0)
 Requires-Dist: composio-langchain (>=0.5.28,<0.6.0)
 Requires-Dist: datasets (>=2.14.6,<3.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: demjson3 (>=3.0.6,<4.0.0)

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/agent.py

@@ -36,7 +36,7 @@ from letta.schemas.block import BlockUpdate
 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.message import Message, MessageUpdate
 from letta.schemas.openai.chat_completion_request import (
     Tool as ChatCompletionRequestTool,
 )
@@ -477,10 +477,10 @@ class Agent(BaseAgent):
         for tool in tools:
             try:
                 # WARNING: name may not be consistent?
-                if tool.module:  # execute the whole module
-                    exec(tool.module, env)
-                else:
-                    exec(tool.source_code, env)
+                # if tool.module:  # execute the whole module
+                #    exec(tool.module, env)
+                # else:
+                exec(tool.source_code, env)
                 self.functions_python[tool.json_schema["name"]] = env[tool.json_schema["name"]]
                 self.functions.append(tool.json_schema)
             except Exception:
@@ -512,9 +512,10 @@ class Agent(BaseAgent):
         for m in self._messages:
             # assert is_utc_datetime(m.created_at), f"created_at on message for agent {self.agent_state.name} isn't UTC:\n{vars(m)}"
             # TODO eventually do casting via an edit_message function
-            if not is_utc_datetime(m.created_at):
-                printd(f"Warning - created_at on message for agent {self.agent_state.name} isn't UTC (text='{m.text}')")
-                m.created_at = m.created_at.replace(tzinfo=datetime.timezone.utc)
+            if m.created_at:
+                if not is_utc_datetime(m.created_at):
+                    printd(f"Warning - created_at on message for agent {self.agent_state.name} isn't UTC (text='{m.text}')")
+                    m.created_at = m.created_at.replace(tzinfo=datetime.timezone.utc)
 
     def set_message_buffer(self, message_ids: List[str], force_utc: bool = True):
         """Set the messages in the buffer to the message IDs list"""
@@ -1405,36 +1406,10 @@ class Agent(BaseAgent):
             f"Attached data source {source.name} to agent {self.agent_state.name}, consisting of {len(all_passages)}. Agent now has {total_agent_passages} embeddings in archival memory.",
         )
 
-    def update_message(self, request: UpdateMessage) -> Message:
+    def update_message(self, message_id: str, request: MessageUpdate) -> Message:
         """Update the details of a message associated with an agent"""
-
-        message = self.message_manager.get_message_by_id(message_id=request.id, actor=self.user)
-        if message is None:
-            raise ValueError(f"Message with id {request.id} not found")
-        assert isinstance(message, Message), f"Message is not a Message object: {type(message)}"
-
-        # Override fields
-        # NOTE: we try to do some sanity checking here (see asserts), but it's not foolproof
-        if request.role:
-            message.role = request.role
-        if request.text:
-            message.text = request.text
-        if request.name:
-            message.name = request.name
-        if request.tool_calls:
-            assert message.role == MessageRole.assistant, "Tool calls can only be added to assistant messages"
-            message.tool_calls = request.tool_calls
-        if request.tool_call_id:
-            assert message.role == MessageRole.tool, "tool_call_id can only be added to tool messages"
-            message.tool_call_id = request.tool_call_id
-
         # Save the updated message
-        self.message_manager.update_message_by_id(message_id=message.id, message=message, actor=self.user)
-
-        # Return the updated message
-        updated_message = self.message_manager.get_message_by_id(message_id=message.id, actor=self.user)
-        if updated_message is None:
-            raise ValueError(f"Error persisting message - message with id {request.id} not found")
+        updated_message = self.message_manager.update_message_by_id(message_id=message_id, message_update=request, actor=self.user)
         return updated_message
 
     # TODO(sarah): should we be creating a new message here, or just editing a message?
@@ -1444,10 +1419,10 @@ class Agent(BaseAgent):
             msg_obj = self._messages[x]
             if msg_obj.role == MessageRole.assistant:
                 updated_message = self.update_message(
-                    request=UpdateMessage(
-                        id=msg_obj.id,
+                    message_id=msg_obj.id,
+                    request=MessageUpdate(
                         text=new_thought,
-                    )
+                    ),
                 )
                 self.refresh_message_buffer()
                 return updated_message
@@ -1486,10 +1461,10 @@ class Agent(BaseAgent):
 
                     # Write the update to the DB
                     updated_message = self.update_message(
-                        request=UpdateMessage(
-                            id=message_obj.id,
+                        message_id=message_obj.id,
+                        request=MessageUpdate(
                             tool_calls=message_obj.tool_calls,
-                        )
+                        ),
                     )
                     self.refresh_message_buffer()
                     return updated_message

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/cli/cli.py

@@ -51,7 +51,6 @@ 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,
     secure: Annotated[bool, typer.Option(help="Adds simple security access")] = False,
 ):
     """Launch a Letta server process"""
@@ -371,8 +370,7 @@ def delete_agent(
         sys.exit(1)
 
 
-def version():
+def version() -> str:
     import letta
 
-    print(letta.__version__)
     return letta.__version__

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/client/client.py

@@ -22,7 +22,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import JobStatus, MessageRole
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
-from letta.schemas.letta_request import LettaRequest
+from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse, LettaStreamingResponse
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import (
@@ -32,7 +32,7 @@ from letta.schemas.memory import (
     Memory,
     RecallMemorySummary,
 )
-from letta.schemas.message import Message, MessageCreate, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.openai.chat_completions import ToolCall
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
@@ -586,8 +586,7 @@ class RESTClient(AbstractClient):
         tool_calls: Optional[List[ToolCall]] = None,
         tool_call_id: Optional[str] = None,
     ) -> Message:
-        request = UpdateMessage(
-            id=message_id,
+        request = MessageUpdate(
             role=role,
             text=text,
             name=name,
@@ -965,8 +964,10 @@ class RESTClient(AbstractClient):
         if stream_tokens or stream_steps:
             from letta.client.streaming import _sse_post
 
+            request = LettaStreamingRequest(messages=messages, stream_tokens=stream_tokens)
             return _sse_post(f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/messages/stream", request.model_dump(), self.headers)
         else:
+            request = LettaRequest(messages=messages)
             response = requests.post(
                 f"{self.base_url}/{self.api_prefix}/agents/{agent_id}/messages", json=request.model_dump(), headers=self.headers
             )
@@ -2146,8 +2147,8 @@ class LocalClient(AbstractClient):
     ) -> Message:
         message = self.server.update_agent_message(
             agent_id=agent_id,
-            request=UpdateMessage(
-                id=message_id,
+            message_id=message_id,
+            request=MessageUpdate(
                 role=role,
                 text=text,
                 name=name,
@@ -2683,7 +2684,7 @@ class LocalClient(AbstractClient):
         return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     def load_composio_tool(self, action: "ActionType") -> Tool:
-        tool_create = ToolCreate.from_composio(action=action)
+        tool_create = ToolCreate.from_composio(action_name=action.name)
         return self.server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=self.user)
 
     def create_tool(

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/functions/helpers.py

@@ -4,12 +4,12 @@ import humps
 from pydantic import BaseModel
 
 
-def generate_composio_tool_wrapper(action: "ActionType") -> tuple[str, str]:
+def generate_composio_tool_wrapper(action_name: str) -> tuple[str, str]:
     # Instantiate the object
-    tool_instantiation_str = f"composio_toolset.get_tools(actions=[Action.{str(action)}])[0]"
+    tool_instantiation_str = f"composio_toolset.get_tools(actions=['{action_name}'])[0]"
 
     # Generate func name
-    func_name = action.name.lower()
+    func_name = action_name.lower()
 
     wrapper_function_str = f"""
 def {func_name}(**kwargs):

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/llm_api/openai.py

@@ -217,7 +217,6 @@ def openai_chat_completions_process_stream(
     dummy_message = _Message(
         role=_MessageRole.assistant,
         text="",
-        user_id="",
         agent_id="",
         model="",
         name=None,

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/local_llm/llm_chat_completion_wrappers/chatml.py

@@ -3,6 +3,7 @@ from letta.local_llm.json_parser import clean_json
 from letta.local_llm.llm_chat_completion_wrappers.wrapper_base import (
     LLMChatCompletionWrapper,
 )
+from letta.schemas.enums import MessageRole
 from letta.utils import json_dumps, json_loads
 
 PREFIX_HINT = """# Reminders:
@@ -208,7 +209,9 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
 
         # Last are the user/assistant messages
         for message in messages[1:]:
-            assert message["role"] in ["user", "assistant", "function", "tool"], message
+            # check that message["role"] is a valid option for MessageRole
+            # TODO: this shouldn't be necessary if we use pydantic in the future
+            assert message["role"] in [role.value for role in MessageRole]
 
             if message["role"] == "user":
                 # Support for AutoGen naming of agents
@@ -231,6 +234,15 @@ class ChatMLInnerMonologueWrapper(LLMChatCompletionWrapper):
 
                 prompt += f"\n<|im_start|>{role_str}\n{msg_str.strip()}<|im_end|>"
 
+            elif message["role"] == "system":
+
+                role_str = "system"
+                msg_str = self._compile_system_message(
+                    system_message=message["content"], functions=functions, function_documentation=function_documentation
+                )
+
+                prompt += f"\n<|im_start|>{role_str}\n{msg_str.strip()}<|im_end|>"
+
             elif message["role"] in ["tool", "function"]:
                 if self.allow_function_role:
                     role_str = message["role"]

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/orm/message.py

@@ -1,7 +1,6 @@
-from datetime import datetime
 from typing import Optional
 
-from sqlalchemy import JSON, DateTime, TypeDecorator
+from sqlalchemy import JSON, TypeDecorator
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import AgentMixin, OrganizationMixin
@@ -58,7 +57,6 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     name: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Name for multi-agent scenarios")
     tool_calls: Mapped[ToolCall] = mapped_column(ToolCallColumn, doc="Tool call information")
     tool_call_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="ID of the tool call")
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=datetime.utcnow)
 
     # Relationships
     # TODO: Add in after Agent ORM is created

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/schemas/message.py

@@ -13,7 +13,7 @@ from letta.constants import (
 )
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.schemas.enums import MessageRole
-from letta.schemas.letta_base import LettaBase
+from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.letta_message import (
     AssistantMessage,
     FunctionCall,
@@ -50,7 +50,7 @@ def add_inner_thoughts_to_tool_call(
         raise e
 
 
-class BaseMessage(LettaBase):
+class BaseMessage(OrmMetadataBase):
     __id_prefix__ = "message"
 
 
@@ -66,10 +66,9 @@ class MessageCreate(BaseMessage):
     name: Optional[str] = Field(None, description="The name of the participant.")
 
 
-class UpdateMessage(BaseMessage):
+class MessageUpdate(BaseMessage):
     """Request to update a message"""
 
-    id: str = Field(..., description="The id of the message.")
     role: Optional[MessageRole] = Field(None, description="The role of the participant.")
     text: Optional[str] = Field(None, description="The text of the message.")
     # NOTE: probably doesn't make sense to allow remapping user_id or agent_id (vs creating a new message)
@@ -109,9 +108,10 @@ class Message(BaseMessage):
     agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
     model: Optional[str] = Field(None, description="The model used to make the function call.")
     name: Optional[str] = Field(None, description="The name of the participant.")
-    created_at: datetime = Field(default_factory=get_utc_time, description="The time the message was created.")
     tool_calls: Optional[List[ToolCall]] = Field(None, description="The list of tool calls requested.")
     tool_call_id: Optional[str] = Field(None, description="The id of the tool call.")
+    # This overrides the optional base orm schema, created_at MUST exist on all messages objects
+    created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 
     @field_validator("role")
     @classmethod

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/schemas/tool.py

@@ -93,7 +93,7 @@ class ToolCreate(LettaBase):
     )
 
     @classmethod
-    def from_composio(cls, action: "ActionType") -> "ToolCreate":
+    def from_composio(cls, action_name: str, api_key: Optional[str] = None) -> "ToolCreate":
         """
         Class method to create an instance of Letta-compatible Composio Tool.
         Check https://docs.composio.dev/introduction/intro/overview to look at options for from_composio
@@ -101,15 +101,20 @@ class ToolCreate(LettaBase):
         This function will error if we find more than one tool, or 0 tools.
 
         Args:
-            action ActionType: A action name to filter tools by.
+            action_name str: A action name to filter tools by.
         Returns:
             Tool: A Letta Tool initialized with attributes derived from the Composio tool.
         """
         from composio import LogLevel
         from composio_langchain import ComposioToolSet
 
-        composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
-        composio_tools = composio_toolset.get_tools(actions=[action])
+        if api_key:
+            # Pass in an external API key
+            composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR, api_key=api_key)
+        else:
+            # Use environmental variable
+            composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
+        composio_tools = composio_toolset.get_tools(actions=[action_name])
 
         assert len(composio_tools) > 0, "User supplied parameters do not match any Composio tools"
         assert len(composio_tools) == 1, f"User supplied parameters match too many Composio tools; {len(composio_tools)} > 1"
@@ -119,7 +124,7 @@ class ToolCreate(LettaBase):
         description = composio_tool.description
         source_type = "python"
         tags = ["composio"]
-        wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action)
+        wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action_name)
         json_schema = generate_schema_from_args_schema_v2(composio_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
@@ -177,14 +182,16 @@ class ToolCreate(LettaBase):
 
     @classmethod
     def load_default_composio_tools(cls) -> List["ToolCreate"]:
-        from composio_langchain import Action
+        pass
 
-        calculator = ToolCreate.from_composio(action=Action.MATHEMATICAL_CALCULATOR)
-        serp_news = ToolCreate.from_composio(action=Action.SERPAPI_NEWS_SEARCH)
-        serp_google_search = ToolCreate.from_composio(action=Action.SERPAPI_SEARCH)
-        serp_google_maps = ToolCreate.from_composio(action=Action.SERPAPI_GOOGLE_MAPS_SEARCH)
+        # TODO: Disable composio tools for now
+        # TODO: Naming is causing issues
+        # calculator = ToolCreate.from_composio(action_name=Action.MATHEMATICAL_CALCULATOR.name)
+        # serp_news = ToolCreate.from_composio(action_name=Action.SERPAPI_NEWS_SEARCH.name)
+        # serp_google_search = ToolCreate.from_composio(action_name=Action.SERPAPI_SEARCH.name)
+        # serp_google_maps = ToolCreate.from_composio(action_name=Action.SERPAPI_GOOGLE_MAPS_SEARCH.name)
 
-        return [calculator, serp_news, serp_google_search, serp_google_maps]
+        return []
 
 
 class ToolUpdate(LettaBase):

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/server/rest_api/app.py

@@ -144,9 +144,8 @@ def create_application() -> "FastAPI":
         debug=True,
     )
 
-    if (os.getenv("LETTA_SERVER_ADE") == "true") or "--ade" in sys.argv:
-        settings.cors_origins.append("https://app.letta.com")
-        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
+    settings.cors_origins.append("https://app.letta.com")
+    print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
 
     if (os.getenv("LETTA_SERVER_SECURE") == "true") or "--secure" in sys.argv:
         print(f"▶ Using secure mode with password: {random_password}")

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/server/rest_api/routers/v1/agents.py

@@ -28,7 +28,7 @@ from letta.schemas.memory import (
     Memory,
     RecallMemorySummary,
 )
-from letta.schemas.message import Message, MessageCreate, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
@@ -422,14 +422,13 @@ def get_agent_messages(
 def update_message(
     agent_id: str,
     message_id: str,
-    request: UpdateMessage = Body(...),
+    request: MessageUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):
     """
     Update the details of a message associated with an agent.
     """
-    assert request.id == message_id, f"Message ID mismatch: {request.id} != {message_id}"
-    return server.update_agent_message(agent_id=agent_id, request=request)
+    return server.update_agent_message(agent_id=agent_id, message_id=message_id, request=request)
 
 
 @router.post(
@@ -486,6 +485,8 @@ async def send_message_streaming(
     This endpoint accepts a message from a user and processes it through the agent.
     It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
+    request.stream_tokens = False
+
     actor = server.get_user_or_default(user_id=user_id)
     result = await send_message_to_agent(
         server=server,

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/server/rest_api/routers/v1/tools.py

@@ -7,6 +7,7 @@ from letta.errors import LettaToolCreateError
 from letta.orm.errors import UniqueConstraintViolationError
 from letta.schemas.letta_message import FunctionReturn
 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
 from letta.server.server import SyncServer
 
@@ -213,22 +214,27 @@ def run_tool_from_source(
 
 
 @router.get("/composio/apps", response_model=List[AppModel], operation_id="list_composio_apps")
-def list_composio_apps(server: SyncServer = Depends(get_letta_server)):
+def list_composio_apps(server: SyncServer = Depends(get_letta_server), user_id: Optional[str] = Header(None, alias="user_id")):
     """
     Get a list of all Composio apps
     """
-    return server.get_composio_apps()
+    actor = server.get_user_or_default(user_id=user_id)
+    composio_api_key = get_composio_key(server, actor=actor)
+    return server.get_composio_apps(api_key=composio_api_key)
 
 
 @router.get("/composio/apps/{composio_app_name}/actions", response_model=List[ActionModel], operation_id="list_composio_actions_by_app")
 def list_composio_actions_by_app(
     composio_app_name: str,
     server: SyncServer = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
     Get a list of all Composio actions for a specific app
     """
-    return server.get_composio_actions_from_app_name(composio_app_name=composio_app_name)
+    actor = server.get_user_or_default(user_id=user_id)
+    composio_api_key = get_composio_key(server, actor=actor)
+    return server.get_composio_actions_from_app_name(composio_app_name=composio_app_name, api_key=composio_api_key)
 
 
 @router.post("/composio/{composio_action_name}", response_model=Tool, operation_id="add_composio_tool")
@@ -241,5 +247,21 @@ def add_composio_tool(
     Add a new Composio tool by action name (Composio refers to each tool as an `Action`)
     """
     actor = server.get_user_or_default(user_id=user_id)
-    tool_create = ToolCreate.from_composio(action=composio_action_name)
+    composio_api_key = get_composio_key(server, actor=actor)
+    tool_create = ToolCreate.from_composio(action_name=composio_action_name, api_key=composio_api_key)
     return server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=actor)
+
+
+# TODO: Factor this out to somewhere else
+def get_composio_key(server: SyncServer, actor: User):
+    api_keys = server.sandbox_config_manager.list_sandbox_env_vars_by_key(key="COMPOSIO_API_KEY", actor=actor)
+    if not api_keys:
+        raise HTTPException(
+            status_code=400,  # Bad Request
+            detail=f"No API keys found for Composio. Please add your Composio API Key as an environment variable for your sandbox configuration.",
+        )
+
+    # TODO: Add more protections around this
+    # Ideally, not tied to a specific sandbox, but for now we just get the first one
+    # Theoretically possible for someone to have different composio api keys per sandbox
+    return api_keys[0].value

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/server/rest_api/utils.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-import traceback
 import warnings
 from enum import Enum
 from typing import AsyncGenerator, Optional, Union
@@ -62,6 +61,9 @@ async def sse_async_generator(
                     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"Error getting usage data: {e}")
                 yield sse_formatter({"error": "Failed to get usage data"})
 

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/server/server.py

@@ -67,7 +67,7 @@ from letta.schemas.memory import (
     Memory,
     RecallMemorySummary,
 )
-from letta.schemas.message import Message, MessageCreate, MessageRole, UpdateMessage
+from letta.schemas.message import Message, MessageCreate, MessageRole, MessageUpdate
 from letta.schemas.organization import Organization
 from letta.schemas.passage import Passage
 from letta.schemas.source import Source
@@ -236,11 +236,6 @@ class SyncServer(Server):
         # Locks
         self.send_message_lock = Lock()
 
-        # Composio
-        self.composio_client = None
-        if tool_settings.composio_api_key:
-            self.composio_client = Composio(api_key=tool_settings.composio_api_key)
-
         # Initialize the metadata store
         config = LettaConfig.load()
         if settings.letta_pg_uri_no_default:
@@ -1667,12 +1662,12 @@ class SyncServer(Server):
         save_agent(letta_agent, self.ms)
         return message
 
-    def update_agent_message(self, agent_id: str, request: UpdateMessage) -> Message:
+    def update_agent_message(self, agent_id: str, message_id: str, request: MessageUpdate) -> Message:
         """Update the details of a message associated with an agent"""
 
         # Get the current message
         letta_agent = self.load_agent(agent_id=agent_id)
-        response = letta_agent.update_message(request=request)
+        response = letta_agent.update_message(message_id=message_id, request=request)
         save_agent(letta_agent, self.ms)
         return response
 
@@ -1899,9 +1894,17 @@ class SyncServer(Server):
             )
 
     # Composio wrappers
-    def get_composio_apps(self) -> List["AppModel"]:
+    def get_composio_client(self, api_key: Optional[str] = None):
+        if api_key:
+            return Composio(api_key=api_key)
+        elif tool_settings.composio_api_key:
+            return Composio(api_key=tool_settings.composio_api_key)
+        else:
+            return Composio()
+
+    def get_composio_apps(self, api_key: Optional[str] = None) -> List["AppModel"]:
         """Get a list of all Composio apps with actions"""
-        apps = self.composio_client.apps.get()
+        apps = self.get_composio_client(api_key=api_key).apps.get()
         apps_with_actions = []
         for app in apps:
             # A bit of hacky logic until composio patches this
@@ -1910,6 +1913,6 @@ class SyncServer(Server):
 
         return apps_with_actions
 
-    def get_composio_actions_from_app_name(self, composio_app_name: str) -> List["ActionModel"]:
-        actions = self.composio_client.actions.get(apps=[composio_app_name])
+    def get_composio_actions_from_app_name(self, composio_app_name: str, api_key: Optional[str] = None) -> List["ActionModel"]:
+        actions = self.get_composio_client(api_key=api_key).actions.get(apps=[composio_app_name])
         return actions

{letta_nightly-0.6.1.dev20241207104149 → letta_nightly-0.6.1.dev20241208104134}/letta/services/message_manager.py

@@ -5,6 +5,7 @@ from letta.orm.errors import NoResultFound
 from letta.orm.message import Message as MessageModel
 from letta.schemas.enums import MessageRole
 from letta.schemas.message import Message as PydanticMessage
+from letta.schemas.message import MessageUpdate
 from letta.schemas.user import User as PydanticUser
 from letta.utils import enforce_types
 
@@ -44,27 +45,38 @@ class MessageManager:
         return [self.create_message(m, actor=actor) for m in pydantic_msgs]
 
     @enforce_types
-    def update_message_by_id(self, message_id: str, message: PydanticMessage, actor: PydanticUser) -> PydanticMessage:
+    def update_message_by_id(self, message_id: str, message_update: MessageUpdate, actor: PydanticUser) -> PydanticMessage:
         """
         Updates an existing record in the database with values from the provided record object.
         """
         with self.session_maker() as session:
             # Fetch existing message from database
-            msg = MessageModel.read(
+            message = MessageModel.read(
                 db_session=session,
                 identifier=message_id,
                 actor=actor,
             )
 
-            # Update the database record with values from the provided record
-            for column in MessageModel.__table__.columns:
-                column_name = column.name
-                if hasattr(message, column_name):
-                    new_value = getattr(message, column_name)
-                    setattr(msg, column_name, new_value)
+            # Some safety checks specific to messages
+            if message_update.tool_calls and message.role != MessageRole.assistant:
+                raise ValueError(
+                    f"Tool calls {message_update.tool_calls} can only be added to assistant messages. Message {message_id} has role {message.role}."
+                )
+            if message_update.tool_call_id and message.role != MessageRole.tool:
+                raise ValueError(
+                    f"Tool call IDs {message_update.tool_call_id} can only be added to tool messages. Message {message_id} has role {message.role}."
+                )
+
+            # get update dictionary
+            update_data = message_update.model_dump(exclude_unset=True, exclude_none=True)
+            # Remove redundant update fields
+            update_data = {key: value for key, value in update_data.items() if getattr(message, key) != value}
+
+            for key, value in update_data.items():
+                setattr(message, key, value)
+            message.update(db_session=session, actor=actor)
 
-            # Commit changes
-            return msg.update(db_session=session, actor=actor).to_pydantic()
+            return message.to_pydantic()
 
     @enforce_types
     def delete_message_by_id(self, message_id: str, actor: PydanticUser) -> bool: