letta-nightly 0.6.4.dev20241213193437__py3-none-any.whl → 0.6.4.dev20241214104034__py3-none-any.whl

letta/schemas/agent.py

@@ -1,13 +1,11 @@
-from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator
 
-from letta.constants import BASE_MEMORY_TOOLS, BASE_TOOLS
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.letta_base import LettaBase
+from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.llm_config import LLMConfig
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message, MessageCreate
@@ -15,15 +13,7 @@ from letta.schemas.openai.chat_completion_response import UsageStatistics
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.tool_rule import ToolRule
-
-
-class BaseAgent(LettaBase, validate_assignment=True):
-    __id_prefix__ = "agent"
-    description: Optional[str] = Field(None, description="The description of the agent.")
-
-    # metadata
-    metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
-    user_id: Optional[str] = Field(None, description="The user id of the agent.")
+from letta.utils import create_random_username
 
 
 class AgentType(str, Enum):
@@ -38,37 +28,7 @@ class AgentType(str, Enum):
     chat_only_agent = "chat_only_agent"
 
 
-class PersistedAgentState(BaseAgent, validate_assignment=True):
-    # NOTE: this has been changed to represent the data stored in the ORM, NOT what is passed around internally or returned to the user
-    id: str = BaseAgent.generate_id_field()
-    name: str = Field(..., description="The name of the agent.")
-    created_at: datetime = Field(..., description="The datetime the agent was created.", default_factory=datetime.now)
-
-    # in-context memory
-    message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
-    # tools
-    # TODO: move to ORM mapping
-    tool_names: List[str] = Field(..., description="The tools used by the agent.")
-
-    # tool rules
-    tool_rules: Optional[List[ToolRule]] = Field(default=None, description="The list of tool rules.")
-
-    # system prompt
-    system: str = Field(..., description="The system prompt used by the agent.")
-
-    # agent configuration
-    agent_type: AgentType = Field(..., description="The type of agent.")
-
-    # llm information
-    llm_config: LLMConfig = Field(..., description="The LLM configuration used by the agent.")
-    embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the agent.")
-
-    class Config:
-        arbitrary_types_allowed = True
-        validate_assignment = True
-
-
-class AgentState(PersistedAgentState):
+class AgentState(OrmMetadataBase, validate_assignment=True):
     """
     Representation of an agent's state. This is the state of the agent at a given time, and is persisted in the DB backend. The state has all the information needed to recreate a persisted agent.
 
@@ -85,43 +45,58 @@ class AgentState(PersistedAgentState):
 
     """
 
+    __id_prefix__ = "agent"
+
     # NOTE: this is what is returned to the client and also what is used to initialize `Agent`
+    id: str = Field(..., description="The id of the agent. Assigned by the database.")
+    name: str = Field(..., description="The name of the agent.")
+    # tool rules
+    tool_rules: Optional[List[ToolRule]] = Field(default=None, description="The list of tool rules.")
+
+    # in-context memory
+    message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
+
+    # system prompt
+    system: str = Field(..., description="The system prompt used by the agent.")
+
+    # agent configuration
+    agent_type: AgentType = Field(..., description="The type of agent.")
+
+    # llm information
+    llm_config: LLMConfig = Field(..., description="The LLM configuration used by the agent.")
+    embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the agent.")
 
     # This is an object representing the in-process state of a running `Agent`
     # Field in this object can be theoretically edited by tools, and will be persisted by the ORM
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the agent.")
+
+    description: Optional[str] = Field(None, description="The description of the agent.")
+    metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
+
     memory: Memory = Field(..., description="The in-context memory of the agent.")
     tools: List[Tool] = Field(..., description="The tools used by the agent.")
     sources: List[Source] = Field(..., description="The sources used by the agent.")
     tags: List[str] = Field(..., description="The tags associated with the agent.")
-    # TODO: add in context message objects
-
-    def to_persisted_agent_state(self) -> PersistedAgentState:
-        # turn back into persisted agent
-        data = self.model_dump()
-        del data["memory"]
-        del data["tools"]
-        del data["sources"]
-        del data["tags"]
-        return PersistedAgentState(**data)
 
 
-class CreateAgent(BaseAgent):  #
+class CreateAgent(BaseModel, validate_assignment=True):  #
     # all optional as server can generate defaults
-    name: Optional[str] = Field(None, description="The name of the agent.")
-    message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
+    name: str = Field(default_factory=lambda: create_random_username(), description="The name of the agent.")
 
     # memory creation
     memory_blocks: List[CreateBlock] = Field(
-        # [CreateHuman(), CreatePersona()], description="The blocks to create in the agent's in-context memory."
         ...,
         description="The blocks to create in the agent's in-context memory.",
     )
-
-    tools: List[str] = Field(BASE_TOOLS + BASE_MEMORY_TOOLS, description="The tools used by the agent.")
+    # TODO: This is a legacy field and should be removed ASAP to force `tool_ids` usage
+    tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tool_ids: Optional[List[str]] = Field(None, description="The ids of the tools used by the agent.")
+    source_ids: Optional[List[str]] = Field(None, description="The ids of the sources used by the agent.")
+    block_ids: Optional[List[str]] = Field(None, description="The ids of the blocks used by the agent.")
     tool_rules: Optional[List[ToolRule]] = Field(None, description="The tool rules governing the agent.")
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
-    agent_type: AgentType = Field(AgentType.memgpt_agent, description="The type of agent.")
+    agent_type: AgentType = Field(default_factory=lambda: AgentType.memgpt_agent, description="The type of agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
     # Note: if this is None, then we'll populate with the standard "more human than human" initial message sequence
@@ -129,6 +104,9 @@ class CreateAgent(BaseAgent):  #
     initial_message_sequence: Optional[List[MessageCreate]] = Field(
         None, description="The initial set of messages to put in the agent's in-context memory."
     )
+    include_base_tools: bool = Field(True, description="The LLM configuration used by the agent.")
+    description: Optional[str] = Field(None, description="The description of the agent.")
+    metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
 
     @field_validator("name")
     @classmethod
@@ -156,17 +134,22 @@ class CreateAgent(BaseAgent):  #
         return name
 
 
-class UpdateAgentState(BaseAgent):
-    id: str = Field(..., description="The id of the agent.")
+class UpdateAgent(BaseModel):
     name: Optional[str] = Field(None, description="The name of the agent.")
-    tool_names: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tool_ids: Optional[List[str]] = Field(None, description="The ids of the tools used by the agent.")
+    source_ids: Optional[List[str]] = Field(None, description="The ids of the sources used by the agent.")
+    block_ids: Optional[List[str]] = Field(None, description="The ids of the blocks used by the agent.")
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
+    tool_rules: Optional[List[ToolRule]] = Field(None, description="The tool rules governing the agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
-
-    # TODO: determine if these should be editable via this schema?
     message_ids: Optional[List[str]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
+    description: Optional[str] = Field(None, description="The description of the agent.")
+    metadata_: Optional[Dict] = Field(None, description="The metadata of the agent.", alias="metadata_")
+
+    class Config:
+        extra = "ignore"  # Ignores extra fields
 
 
 class AgentStepResponse(BaseModel):

letta/schemas/memory.py

@@ -87,7 +87,7 @@ class Memory(BaseModel, validate_assignment=True):
             Template(prompt_template)
 
             # Validate compatibility with current memory structure
-            test_render = Template(prompt_template).render(blocks=self.blocks)
+            Template(prompt_template).render(blocks=self.blocks)
 
             # If we get here, the template is valid and compatible
             self.prompt_template = prompt_template
@@ -213,6 +213,7 @@ class ChatMemory(BasicBlockMemory):
             human (str): The starter value for the human block.
             limit (int): The character limit for each block.
         """
+        # TODO: Should these be CreateBlocks?
         super().__init__(blocks=[Block(value=persona, limit=limit, label="persona"), Block(value=human, limit=limit, label="human")])
 
 

letta/schemas/sandbox_config.py

@@ -3,10 +3,11 @@ import json
 from enum import Enum
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 from letta.schemas.agent import AgentState
 from letta.schemas.letta_base import LettaBase, OrmMetadataBase
+from letta.settings import tool_settings
 
 
 # Sandbox Config
@@ -45,6 +46,16 @@ class E2BSandboxConfig(BaseModel):
     def type(self) -> "SandboxType":
         return SandboxType.E2B
 
+    @model_validator(mode="before")
+    @classmethod
+    def set_default_template(cls, data: dict):
+        """
+        Assign a default template value if the template field is not provided.
+        """
+        if data.get("template") is None:
+            data["template"] = tool_settings.e2b_sandbox_template_id
+        return data
+
 
 class SandboxConfigBase(OrmMetadataBase):
     __id_prefix__ = "sandbox"

letta/server/rest_api/app.py

@@ -25,9 +25,6 @@ from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.routers.openai.assistants.assistants import (
     router as openai_assistants_router,
 )
-from letta.server.rest_api.routers.openai.assistants.threads import (
-    router as openai_threads_router,
-)
 from letta.server.rest_api.routers.openai.chat_completions.chat_completions import (
     router as openai_chat_completions_router,
 )
@@ -215,7 +212,6 @@ def create_application() -> "FastAPI":
 
     # openai
     app.include_router(openai_assistants_router, prefix=OPENAI_API_PREFIX)
-    app.include_router(openai_threads_router, prefix=OPENAI_API_PREFIX)
     app.include_router(openai_chat_completions_router, prefix=OPENAI_API_PREFIX)
 
     # /api/auth endpoints
@@ -236,7 +232,6 @@ def create_application() -> "FastAPI":
     @app.on_event("shutdown")
     def on_shutdown():
         global server
-        server.save_agents()
         # server = None
 
     return app

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

@@ -36,7 +36,7 @@ async def create_chat_completion(
     The bearer token will be used to identify the user.
     The 'user' field in the completion_request should be set to the agent ID.
     """
-    actor = server.get_user_or_default(user_id=user_id)
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     agent_id = completion_request.user
     if agent_id is None: