letta-nightly 0.5.1.dev20241030104135__py3-none-any.whl → 0.5.1.dev20241101104122__py3-none-any.whl

letta/metadata.py

@@ -30,6 +30,12 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.openai.chat_completions import ToolCall, ToolCallFunction
 from letta.schemas.source import Source
+from letta.schemas.tool_rule import (
+    BaseToolRule,
+    InitToolRule,
+    TerminalToolRule,
+    ToolRule,
+)
 from letta.schemas.user import User
 from letta.settings import settings
 from letta.utils import enforce_types, get_utc_time, printd
@@ -196,6 +202,41 @@ def generate_api_key(prefix="sk-", length=51) -> str:
     return new_key
 
 
+class ToolRulesColumn(TypeDecorator):
+    """Custom type for storing a list of ToolRules as JSON"""
+
+    impl = JSON
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        return dialect.type_descriptor(JSON())
+
+    def process_bind_param(self, value: List[BaseToolRule], dialect):
+        """Convert a list of ToolRules to JSON-serializable format."""
+        if value:
+            return [rule.model_dump() for rule in value]
+        return value
+
+    def process_result_value(self, value, dialect) -> List[BaseToolRule]:
+        """Convert JSON back to a list of ToolRules."""
+        if value:
+            return [self.deserialize_tool_rule(rule_data) for rule_data in value]
+        return value
+
+    @staticmethod
+    def deserialize_tool_rule(data: dict) -> BaseToolRule:
+        """Deserialize a dictionary to the appropriate ToolRule subclass based on the 'type'."""
+        rule_type = data.get("type")  # Remove 'type' field if it exists since it is a class var
+        if rule_type == "InitToolRule":
+            return InitToolRule(**data)
+        elif rule_type == "TerminalToolRule":
+            return TerminalToolRule(**data)
+        elif rule_type == "ToolRule":
+            return ToolRule(**data)
+        else:
+            raise ValueError(f"Unknown tool rule type: {rule_type}")
+
+
 class AgentModel(Base):
     """Defines data model for storing Passages (consisting of text, embedding)"""
 
@@ -212,7 +253,6 @@ class AgentModel(Base):
     message_ids = Column(JSON)
     memory = Column(JSON)
     system = Column(String)
-    tools = Column(JSON)
 
     # configs
     agent_type = Column(String)
@@ -224,6 +264,7 @@ class AgentModel(Base):
 
     # tools
     tools = Column(JSON)
+    tool_rules = Column(ToolRulesColumn)
 
     Index(__tablename__ + "_idx_user", user_id),
 
@@ -241,6 +282,7 @@ class AgentModel(Base):
             memory=Memory.load(self.memory),  # load dictionary
             system=self.system,
             tools=self.tools,
+            tool_rules=self.tool_rules,
             agent_type=self.agent_type,
             llm_config=self.llm_config,
             embedding_config=self.embedding_config,

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/tool.py

@@ -38,8 +38,5 @@ class Tool(SqlalchemyBase, OrganizationMixin):
         String, nullable=True, doc="the module path from which this tool was derived in the codebase."
     )
 
-    # TODO: add terminal here eventually
-    # This was an intentional decision by Sarah
-
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="tools", lazy="selectin")

letta/schemas/agent.py

@@ -11,6 +11,7 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.tool_rule import BaseToolRule
 
 
 class BaseAgent(LettaBase, validate_assignment=True):
@@ -61,6 +62,9 @@ class AgentState(BaseAgent, validate_assignment=True):
     # tools
     tools: List[str] = Field(..., description="The tools used by the agent.")
 
+    # 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.")
 
@@ -104,6 +108,7 @@ class CreateAgent(BaseAgent):
     message_ids: Optional[List[uuid.UUID]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
     memory: Optional[Memory] = Field(None, description="The in-context memory of the agent.")
     tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tool_rules: Optional[List[BaseToolRule]] = Field(None, description="The tool rules governing the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
     agent_type: Optional[AgentType] = Field(None, description="The type of agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
@@ -156,8 +161,3 @@ class AgentStepResponse(BaseModel):
         ..., description="Whether the agent step ended because the in-context memory is near its limit."
     )
     usage: UsageStatistics = Field(..., description="Usage statistics of the LLM call during the agent's step.")
-
-
-class RemoveToolsFromAgent(BaseModel):
-    agent_id: str = Field(..., description="The id of the agent.")
-    tool_ids: Optional[List[str]] = Field(None, description="The tools to be removed from 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):
@@ -36,4 +36,4 @@ class LettaResponse(BaseModel):
 
 
 # The streaming response is either [DONE], [DONE_STEP], [DONE], an error, or a LettaMessage
-LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus]
+LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaUsageStatistics]

letta/schemas/tool.py

@@ -10,7 +10,6 @@ from letta.functions.helpers import (
 from letta.functions.schema_generator import generate_schema_from_args_schema
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
-from letta.services.organization_manager import OrganizationManager
 
 
 class BaseTool(LettaBase):
@@ -69,10 +68,9 @@ class ToolCreate(LettaBase):
     json_schema: Optional[Dict] = Field(
         None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
     )
-    terminal: Optional[bool] = Field(None, description="Whether the tool is a terminal tool (allow requesting heartbeats).")
 
     @classmethod
-    def from_composio(cls, action: "ActionType", organization_id: str = OrganizationManager.DEFAULT_ORG_ID) -> "ToolCreate":
+    def from_composio(cls, action: "ActionType") -> "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
@@ -114,7 +112,6 @@ class ToolCreate(LettaBase):
         cls,
         langchain_tool: "LangChainBaseTool",
         additional_imports_module_attr_map: dict[str, str] = None,
-        organization_id: str = OrganizationManager.DEFAULT_ORG_ID,
     ) -> "ToolCreate":
         """
         Class method to create an instance of Tool from a Langchain tool (must be from langchain_community.tools).
@@ -147,7 +144,6 @@ class ToolCreate(LettaBase):
         cls,
         crewai_tool: "CrewAIBaseTool",
         additional_imports_module_attr_map: dict[str, str] = None,
-        organization_id: str = OrganizationManager.DEFAULT_ORG_ID,
     ) -> "ToolCreate":
         """
         Class method to create an instance of Tool from a crewAI BaseTool object.
@@ -212,5 +208,7 @@ class ToolUpdate(LettaBase):
     tags: Optional[List[str]] = Field(None, description="Metadata tags.")
     module: Optional[str] = Field(None, description="The source code of the function.")
     source_code: Optional[str] = Field(None, description="The source code of the function.")
-    json_schema: Optional[Dict] = Field(None, description="The JSON schema of the function.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
+    json_schema: Optional[Dict] = Field(
+        None, description="The JSON schema of the function (auto-generated from source_code if not provided)"
+    )

letta/schemas/tool_rule.py

@@ -0,0 +1,25 @@
+from typing import List
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+
+
+class BaseToolRule(LettaBase):
+    __id_prefix__ = "tool_rule"
+    tool_name: str = Field(..., description="The name of the tool. Must exist in the database for the user's organization.")
+
+
+class ToolRule(BaseToolRule):
+    type: str = Field("ToolRule")
+    children: List[str] = Field(..., description="The children tools that can be invoked.")
+
+
+class InitToolRule(BaseToolRule):
+    type: str = Field("InitToolRule")
+    """Represents the initial tool rule configuration."""
+
+
+class TerminalToolRule(BaseToolRule):
+    type: str = Field("TerminalToolRule")
+    """Represents a terminal tool rule configuration where if this tool gets called, it must end the agent loop."""

letta/server/rest_api/app.py

@@ -8,6 +8,7 @@ import uvicorn
 from fastapi import FastAPI
 from starlette.middleware.cors import CORSMiddleware
 
+from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
 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
@@ -53,10 +54,11 @@ 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
 
-ADMIN_PREFIX = "/v1/admin"
-API_PREFIX = "/v1"
-OPENAI_API_PREFIX = "/openai"
+log = logging.getLogger("uvicorn")
 
 
 def create_application() -> "FastAPI":

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": {"schema": LettaResponse.model_json_schema()},  # 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/organizations.py

@@ -22,7 +22,7 @@ def get_all_orgs(
     Get a list of all orgs in the database
     """
     try:
-        next_cursor, orgs = server.organization_manager.list_organizations(cursor=cursor, limit=limit)
+        orgs = server.organization_manager.list_organizations(cursor=cursor, limit=limit)
     except HTTPException:
         raise
     except Exception as e:
@@ -38,7 +38,7 @@ def create_org(
     """
     Create a new org in the database
     """
-    org = server.organization_manager.create_organization(request)
+    org = server.organization_manager.create_organization(name=request.name)
     return org
 
 

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():
@@ -820,7 +820,7 @@ class SyncServer(Server):
                     continue
                 source_code = parse_source_code(func)
                 # memory functions are not terminal
-                json_schema = generate_schema(func, terminal=False, name=func_name)
+                json_schema = generate_schema(func, name=func_name)
                 source_type = "python"
                 tags = ["memory", "memgpt-base"]
                 tool = self.tool_manager.create_or_update_tool(
@@ -842,6 +842,7 @@ class SyncServer(Server):
                 name=request.name,
                 user_id=user_id,
                 tools=request.tools if request.tools else [],
+                tool_rules=request.tool_rules if request.tool_rules else [],
                 agent_type=request.agent_type or AgentType.memgpt_agent,
                 llm_config=llm_config,
                 embedding_config=embedding_config,
@@ -1793,43 +1794,6 @@ class SyncServer(Server):
         letta_agent = self._get_or_load_agent(agent_id=agent_id)
         return letta_agent.update_message(request=request)
 
-        # TODO decide whether this should be done in the server.py or agent.py
-        # Reason to put it in agent.py:
-        # - we use the agent object's persistence_manager to update the message
-        # - it makes it easy to do things like `retry`, `rethink`, etc.
-        # Reason to put it in server.py:
-        # - fundamentally, we should be able to edit a message (without agent id)
-        #   in the server by directly accessing the DB / message store
-        """
-        message = letta_agent.persistence_manager.recall_memory.storage.get(id=request.id)
-        if message is None:
-            raise ValueError(f"Message with id {request.id} not found")
-
-        # 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
-        letta_agent.persistence_manager.recall_memory.storage.update(record=message)
-
-        # Return the updated message
-        updated_message = letta_agent.persistence_manager.recall_memory.storage.get(id=message.id)
-        if updated_message is None:
-            raise ValueError(f"Error persisting message - message with id {request.id} not found")
-        return updated_message
-        """
-
     def rewrite_agent_message(self, agent_id: str, new_text: str) -> Message:
 
         # Get the current message

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