letta-nightly 0.5.1.dev20241031104107__py3-none-any.whl → 0.5.1.dev20241102104033__py3-none-any.whl

letta/client/client.py

@@ -225,6 +225,9 @@ class AbstractClient(object):
     def get_tool_id(self, name: str) -> Optional[str]:
         raise NotImplementedError
 
+    def add_base_tools(self) -> List[Tool]:
+        raise NotImplementedError
+
     def load_data(self, connector: DataConnector, source_name: str):
         raise NotImplementedError
 
@@ -791,7 +794,7 @@ class RESTClient(AbstractClient):
         name: Optional[str] = None,
         stream_steps: bool = False,
         stream_tokens: bool = False,
-        include_full_message: Optional[bool] = False,
+        include_full_message: bool = False,
     ) -> Union[LettaResponse, Generator[LettaStreamingResponse, None, None]]:
         """
         Send a message to an agent
@@ -812,7 +815,12 @@ class RESTClient(AbstractClient):
         # TODO: figure out how to handle stream_steps and stream_tokens
 
         # When streaming steps is True, stream_tokens must be False
-        request = LettaRequest(messages=messages, stream_steps=stream_steps, stream_tokens=stream_tokens, return_message_object=True)
+        request = LettaRequest(
+            messages=messages,
+            stream_steps=stream_steps,
+            stream_tokens=stream_tokens,
+            return_message_object=include_full_message,
+        )
         if stream_tokens or stream_steps:
             from letta.client.streaming import _sse_post
 
@@ -827,12 +835,12 @@ class RESTClient(AbstractClient):
             response = LettaResponse(**response.json())
 
             # simplify messages
-            if not include_full_message:
-                messages = []
-                for m in response.messages:
-                    assert isinstance(m, Message)
-                    messages += m.to_letta_message()
-                response.messages = messages
+            # if not include_full_message:
+            #     messages = []
+            #     for m in response.messages:
+            #         assert isinstance(m, Message)
+            #         messages += m.to_letta_message()
+            #     response.messages = messages
 
             return response
 
@@ -1266,6 +1274,13 @@ class RESTClient(AbstractClient):
             raise ValueError(f"Failed to get tool: {response.text}")
         return response.json()
 
+    def add_base_tools(self) -> List[Tool]:
+        response = requests.post(f"{self.base_url}/{self.api_prefix}/tools/add-base-tools/", headers=self.headers)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to add base tools: {response.text}")
+
+        return [Tool(**tool) for tool in response.json()]
+
     def create_tool(
         self,
         func: Callable,

letta/constants.py

@@ -36,7 +36,6 @@ DEFAULT_PRESET = "memgpt_chat"
 # Tools
 BASE_TOOLS = [
     "send_message",
-    # "pause_heartbeats",
     "conversation_search",
     "conversation_search_date",
     "archival_memory_insert",

letta/orm/__init__.py

@@ -0,0 +1,4 @@
+from letta.orm.base import Base
+from letta.orm.organization import Organization
+from letta.orm.tool import Tool
+from letta.orm.user import User

letta/orm/sqlalchemy_base.py

@@ -107,23 +107,32 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         """
         # Start the query
         query = select(cls)
+        # Collect query conditions for better error reporting
+        query_conditions = []
 
         # If an identifier is provided, add it to the query conditions
         if identifier is not None:
             identifier = cls.get_uid_from_identifier(identifier)
             query = query.where(cls._id == identifier)
+            query_conditions.append(f"id='{identifier}'")
 
         if kwargs:
             query = query.filter_by(**kwargs)
+            query_conditions.append(", ".join(f"{key}='{value}'" for key, value in kwargs.items()))
 
         if actor:
             query = cls.apply_access_predicate(query, actor, access)
+            query_conditions.append(f"access level in {access} for actor='{actor}'")
 
         if hasattr(cls, "is_deleted"):
             query = query.where(cls.is_deleted == False)
+            query_conditions.append("is_deleted=False")
         if found := db_session.execute(query).scalar():
             return found
-        raise NoResultFound(f"{cls.__name__} with id {identifier} not found")
+
+        # Construct a detailed error message based on query conditions
+        conditions_str = ", ".join(query_conditions) if query_conditions else "no specific conditions"
+        raise NoResultFound(f"{cls.__name__} not found with {conditions_str}")
 
     def create(self, db_session: "Session", actor: Optional["User"] = None) -> Type["SqlalchemyBase"]:
         if actor:

letta/schemas/agent.py

@@ -63,7 +63,7 @@ class AgentState(BaseAgent, validate_assignment=True):
     tools: List[str] = Field(..., description="The tools used by the agent.")
 
     # tool rules
-    tool_rules: List[BaseToolRule] = Field(..., description="The list of tool rules.")
+    tool_rules: Optional[List[BaseToolRule]] = Field(default=None, description="The list of tool rules.")
 
     # system prompt
     system: str = Field(..., description="The system prompt used by the agent.")

letta/schemas/letta_response.py

@@ -3,7 +3,7 @@ from typing import List, Union
 from pydantic import BaseModel, Field
 
 from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.letta_message import LettaMessage
+from letta.schemas.letta_message import LettaMessage, LettaMessageUnion
 from letta.schemas.message import Message
 from letta.schemas.usage import LettaUsageStatistics
 from letta.utils import json_dumps
@@ -21,7 +21,7 @@ class LettaResponse(BaseModel):
         usage (LettaUsageStatistics): The usage statistics
     """
 
-    messages: Union[List[Message], List[LettaMessage]] = Field(..., description="The messages returned by the agent.")
+    messages: Union[List[Message], List[LettaMessageUnion]] = Field(..., description="The messages returned by the agent.")
     usage: LettaUsageStatistics = Field(..., description="The usage statistics of the agent.")
 
     def __str__(self):

letta/server/rest_api/app.py

@@ -9,6 +9,7 @@ from fastapi import FastAPI
 from starlette.middleware.cors import CORSMiddleware
 
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
+from letta.schemas.letta_response import LettaResponse
 from letta.server.constants import REST_DEFAULT_PORT
 
 # NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
@@ -54,6 +55,12 @@ password = None
 #    password = secrets.token_urlsafe(16)
 #    #typer.secho(f"Generated admin server password for this session: {password}", fg=typer.colors.GREEN)
 
+import logging
+
+from fastapi import FastAPI
+
+log = logging.getLogger("uvicorn")
+
 
 def create_application() -> "FastAPI":
     """the application start routine"""
@@ -122,6 +129,9 @@ def create_application() -> "FastAPI":
         openai_docs["info"]["title"] = "OpenAI Assistants API"
         letta_docs["paths"] = {k: v for k, v in letta_docs["paths"].items() if not k.startswith("/openai")}
         letta_docs["info"]["title"] = "Letta API"
+        letta_docs["components"]["schemas"]["LettaResponse"] = {
+            "properties": LettaResponse.model_json_schema(ref_template="#/components/schemas/LettaResponse/properties/{model}")["$defs"]
+        }
 
         # Split the API docs into Letta API, and OpenAI Assistants compatible API
         for name, docs in [

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

@@ -4,7 +4,6 @@ from typing import Dict, List, Optional, Union
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
 from fastapi.responses import JSONResponse, StreamingResponse
-from starlette.responses import StreamingResponse
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgentState
@@ -359,7 +358,20 @@ def update_message(
     return server.update_agent_message(agent_id=agent_id, request=request)
 
 
-@router.post("/{agent_id}/messages", response_model=None, operation_id="create_agent_message")
+@router.post(
+    "/{agent_id}/messages",
+    response_model=None,
+    operation_id="create_agent_message",
+    responses={
+        200: {
+            "description": "Successful response",
+            "content": {
+                "application/json": {"$ref": "#/components/schemas/LettaResponse"},  # Use model_json_schema() instead of model directly
+                "text/event-stream": {"description": "Server-Sent Events stream"},
+            },
+        }
+    },
+)
 async def send_message(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -373,7 +385,7 @@ async def send_message(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return await send_message_to_agent(
+    result = await send_message_to_agent(
         server=server,
         agent_id=agent_id,
         user_id=actor.id,
@@ -386,6 +398,7 @@ async def send_message(
         assistant_message_function_name=request.assistant_message_function_name,
         assistant_message_function_kwarg=request.assistant_message_function_kwarg,
     )
+    return result
 
 
 # TODO: move this into server.py?

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

@@ -104,3 +104,15 @@ def update_tool(
     """
     actor = server.get_user_or_default(user_id=user_id)
     return server.tool_manager.update_tool_by_id(tool_id, actor.id, request)
+
+
+@router.post("/add-base-tools", response_model=List[Tool], operation_id="add_base_tools")
+def add_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
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.tool_manager.add_base_tools(actor=actor)

letta/server/server.py

@@ -35,8 +35,9 @@ from letta.interface import AgentInterface  # abstract
 from letta.interface import CLIInterface  # for printing to terminal
 from letta.log import get_logger
 from letta.memory import get_memory_functions
-from letta.metadata import Base, MetadataStore
+from letta.metadata import MetadataStore
 from letta.o1_agent import O1Agent
+from letta.orm import Base
 from letta.orm.errors import NoResultFound
 from letta.prompts import gpt_system
 from letta.providers import (
@@ -169,6 +170,8 @@ from letta.settings import model_settings, settings, tool_settings
 
 config = LettaConfig.load()
 
+attach_base()
+
 if settings.letta_pg_uri_no_default:
     config.recall_storage_type = "postgres"
     config.recall_storage_uri = settings.letta_pg_uri_no_default
@@ -181,13 +184,10 @@ else:
     # TODO: don't rely on config storage
     engine = create_engine("sqlite:///" + os.path.join(config.recall_storage_path, "sqlite.db"))
 
+    Base.metadata.create_all(bind=engine)
 
 SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
 
-attach_base()
-
-Base.metadata.create_all(bind=engine)
-
 
 # Dependency
 def get_db():
@@ -254,7 +254,7 @@ class SyncServer(Server):
             self.default_org = self.organization_manager.create_default_organization()
             self.default_user = self.user_manager.create_default_user()
             self.add_default_blocks(self.default_user.id)
-            self.tool_manager.add_default_tools(module_name="base", actor=self.default_user)
+            self.tool_manager.add_base_tools(actor=self.default_user)
 
             # If there is a default org/user
             # This logic may have to change in the future

letta/server/startup.sh

@@ -1,5 +1,8 @@
 #!/bin/sh
 echo "Starting MEMGPT server..."
+
+alembic upgrade head
+
 if [ "$MEMGPT_ENVIRONMENT" = "DEVELOPMENT" ] ; then
     echo "Starting in development mode!"
     uvicorn letta.server.rest_api.app:app --reload --reload-dir /letta --host 0.0.0.0 --port 8283