letta-nightly 0.5.4.dev20241127104220__py3-none-any.whl → 0.5.4.dev20241128000451__py3-none-any.whl

letta/config.py

@@ -16,7 +16,7 @@ from letta.constants import (
     LETTA_DIR,
 )
 from letta.log import get_logger
-from letta.schemas.agent import AgentState
+from letta.schemas.agent import PersistedAgentState
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.llm_config import LLMConfig
 
@@ -434,7 +434,7 @@ class AgentConfig:
             json.dump(vars(self), f, indent=4)
 
     def to_agent_state(self):
-        return AgentState(
+        return PersistedAgentState(
             name=self.name,
             preset=self.preset,
             persona=self.persona,

letta/constants.py

@@ -38,6 +38,8 @@ DEFAULT_PRESET = "memgpt_chat"
 
 # Base tools that cannot be edited, as they access agent state directly
 BASE_TOOLS = ["send_message", "conversation_search", "conversation_search_date", "archival_memory_insert", "archival_memory_search"]
+# Base memory tools CAN be edited, and are added by default by the server
+BASE_MEMORY_TOOLS = ["core_memory_append", "core_memory_replace"]
 
 # The name of the tool used to send message to the user
 # May not be relevant in cases where the agent has multiple ways to message to user (send_imessage, send_discord_mesasge, ...)
@@ -127,6 +129,9 @@ MESSAGE_SUMMARY_REQUEST_ACK = "Understood, I will respond with a summary of the
 # These serve as in-context examples of how to use functions / what user messages look like
 MESSAGE_SUMMARY_TRUNC_KEEP_N_LAST = 3
 
+# Maximum length of an error message
+MAX_ERROR_MESSAGE_CHAR_LIMIT = 500
+
 # Default memory limits
 CORE_MEMORY_PERSONA_CHAR_LIMIT: int = 5000
 CORE_MEMORY_HUMAN_CHAR_LIMIT: int = 5000

letta/functions/function_sets/base.py

@@ -11,7 +11,7 @@ from letta.constants import MAX_PAUSE_HEARTBEATS
 # If the function fails, throw an exception
 
 
-def send_message(self: Agent, message: str) -> Optional[str]:
+def send_message(self: "Agent", message: str) -> Optional[str]:
     """
     Sends a message to the human user.
 
@@ -172,3 +172,40 @@ def archival_memory_search(self: Agent, query: str, page: Optional[int] = 0) ->
         results_formatted = [f"timestamp: {d['timestamp']}, memory: {d['content']}" for d in results]
         results_str = f"{results_pref} {json_dumps(results_formatted)}"
     return results_str
+
+
+def core_memory_append(agent_state: "AgentState", label: str, content: str) -> Optional[str]:  # type: ignore
+    """
+    Append to the contents of core memory.
+
+    Args:
+        label (str): Section of the memory to be edited (persona or human).
+        content (str): Content to write to the memory. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    current_value = str(agent_state.memory.get_block(label).value)
+    new_value = current_value + "\n" + str(content)
+    agent_state.memory.update_block_value(label=label, value=new_value)
+    return None
+
+
+def core_memory_replace(agent_state: "AgentState", label: str, old_content: str, new_content: str) -> Optional[str]:  # type: ignore
+    """
+    Replace the contents of core memory. To delete memories, use an empty string for new_content.
+
+    Args:
+        label (str): Section of the memory to be edited (persona or human).
+        old_content (str): String to replace. Must be an exact match.
+        new_content (str): Content to write to the memory. All unicode (including emojis) are supported.
+
+    Returns:
+        Optional[str]: None is always returned as this function does not produce a response.
+    """
+    current_value = str(agent_state.memory.get_block(label).value)
+    if old_content not in current_value:
+        raise ValueError(f"Old content '{old_content}' not found in memory block '{label}'")
+    new_value = current_value.replace(str(old_content), str(new_content))
+    agent_state.memory.update_block_value(label=label, value=new_value)
+    return None

letta/helpers/tool_rule_solver.py

@@ -2,11 +2,12 @@ from typing import Dict, List, Optional, Set
 
 from pydantic import BaseModel, Field
 
+from letta.schemas.enums import ToolRuleType
 from letta.schemas.tool_rule import (
     BaseToolRule,
+    ChildToolRule,
     InitToolRule,
     TerminalToolRule,
-    ToolRule,
 )
 
 
@@ -21,7 +22,7 @@ class ToolRulesSolver(BaseModel):
     init_tool_rules: List[InitToolRule] = Field(
         default_factory=list, description="Initial tool rules to be used at the start of tool execution."
     )
-    tool_rules: List[ToolRule] = Field(
+    tool_rules: List[ChildToolRule] = Field(
         default_factory=list, description="Standard tool rules for controlling execution sequence and allowed transitions."
     )
     terminal_tool_rules: List[TerminalToolRule] = Field(
@@ -33,11 +34,11 @@ class ToolRulesSolver(BaseModel):
         super().__init__(**kwargs)
         # Separate the provided tool rules into init, standard, and terminal categories
         for rule in tool_rules:
-            if isinstance(rule, InitToolRule):
+            if rule.type == ToolRuleType.run_first:
                 self.init_tool_rules.append(rule)
-            elif isinstance(rule, ToolRule):
+            elif rule.type == ToolRuleType.constrain_child_tools:
                 self.tool_rules.append(rule)
-            elif isinstance(rule, TerminalToolRule):
+            elif rule.type == ToolRuleType.exit_loop:
                 self.terminal_tool_rules.append(rule)
 
         # Validate the tool rules to ensure they form a DAG

letta/main.py

@@ -189,7 +189,7 @@ def run_agent_loop(
 
                 elif user_input.lower() == "/memory":
                     print(f"\nDumping memory contents:\n")
-                    print(f"{letta_agent.memory.compile()}")
+                    print(f"{letta_agent.agent_state.memory.compile()}")
                     print(f"{letta_agent.persistence_manager.archival_memory.compile()}")
                     print(f"{letta_agent.persistence_manager.recall_memory.compile()}")
                     continue

letta/metadata.py

@@ -3,27 +3,21 @@
 import os
 import secrets
 import warnings
-from typing import List, Optional
+from typing import List, Optional, Union
 
 from sqlalchemy import JSON, Column, DateTime, Index, String, TypeDecorator
 from sqlalchemy.sql import func
 
 from letta.config import LettaConfig
 from letta.orm.base import Base
-from letta.schemas.agent import AgentState
+from letta.schemas.agent import PersistedAgentState
 from letta.schemas.api_key import APIKey
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import JobStatus
+from letta.schemas.enums import JobStatus, ToolRuleType
 from letta.schemas.job import Job
 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.tool_rule import (
-    BaseToolRule,
-    InitToolRule,
-    TerminalToolRule,
-    ToolRule,
-)
+from letta.schemas.tool_rule import ChildToolRule, InitToolRule, TerminalToolRule
 from letta.schemas.user import User
 from letta.services.per_agent_lock_manager import PerAgentLockManager
 from letta.settings import settings
@@ -165,28 +159,35 @@ class ToolRulesColumn(TypeDecorator):
     def load_dialect_impl(self, dialect):
         return dialect.type_descriptor(JSON())
 
-    def process_bind_param(self, value: List[BaseToolRule], dialect):
+    def process_bind_param(self, value, dialect):
         """Convert a list of ToolRules to JSON-serializable format."""
         if value:
-            return [rule.model_dump() for rule in value]
+            data = [rule.model_dump() for rule in value]
+            for d in data:
+                d["type"] = d["type"].value
+
+            for d in data:
+                assert not (d["type"] == "ToolRule" and "children" not in d), "ToolRule does not have children field"
+            return data
         return value
 
-    def process_result_value(self, value, dialect) -> List[BaseToolRule]:
+    def process_result_value(self, value, dialect) -> List[Union[ChildToolRule, InitToolRule, TerminalToolRule]]:
         """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:
+    def deserialize_tool_rule(data: dict) -> Union[ChildToolRule, InitToolRule, TerminalToolRule]:
         """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":
+        rule_type = ToolRuleType(data.get("type"))  # Remove 'type' field if it exists since it is a class var
+        if rule_type == ToolRuleType.run_first:
             return InitToolRule(**data)
-        elif rule_type == "TerminalToolRule":
+        elif rule_type == ToolRuleType.exit_loop:
             return TerminalToolRule(**data)
-        elif rule_type == "ToolRule":
-            return ToolRule(**data)
+        elif rule_type == ToolRuleType.constrain_child_tools:
+            rule = ChildToolRule(**data)
+            return rule
         else:
             raise ValueError(f"Unknown tool rule type: {rule_type}")
 
@@ -205,7 +206,6 @@ class AgentModel(Base):
 
     # state (context compilation)
     message_ids = Column(JSON)
-    memory = Column(JSON)
     system = Column(String)
 
     # configs
@@ -217,7 +217,7 @@ class AgentModel(Base):
     metadata_ = Column(JSON)
 
     # tools
-    tools = Column(JSON)
+    tool_names = Column(JSON)
     tool_rules = Column(ToolRulesColumn)
 
     Index(__tablename__ + "_idx_user", user_id),
@@ -225,24 +225,22 @@ class AgentModel(Base):
     def __repr__(self) -> str:
         return f"<Agent(id='{self.id}', name='{self.name}')>"
 
-    def to_record(self) -> AgentState:
-        agent_state = AgentState(
+    def to_record(self) -> PersistedAgentState:
+        agent_state = PersistedAgentState(
             id=self.id,
             user_id=self.user_id,
             name=self.name,
             created_at=self.created_at,
             description=self.description,
             message_ids=self.message_ids,
-            memory=Memory.load(self.memory),  # load dictionary
             system=self.system,
-            tools=self.tools,
+            tool_names=self.tool_names,
             tool_rules=self.tool_rules,
             agent_type=self.agent_type,
             llm_config=self.llm_config,
             embedding_config=self.embedding_config,
             metadata_=self.metadata_,
         )
-        assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
         return agent_state
 
 
@@ -347,18 +345,18 @@ class MetadataStore:
             return tokens
 
     @enforce_types
-    def create_agent(self, agent: AgentState):
+    def create_agent(self, agent: PersistedAgentState):
         # insert into agent table
         # make sure agent.name does not already exist for user user_id
         with self.session_maker() as session:
             if session.query(AgentModel).filter(AgentModel.name == agent.name).filter(AgentModel.user_id == agent.user_id).count() > 0:
                 raise ValueError(f"Agent with name {agent.name} already exists")
             fields = vars(agent)
-            fields["memory"] = agent.memory.to_dict()
-            if "_internal_memory" in fields:
-                del fields["_internal_memory"]
-            else:
-                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            # fields["memory"] = agent.memory.to_dict()
+            # if "_internal_memory" in fields:
+            #    del fields["_internal_memory"]
+            # else:
+            #    warnings.warn(f"Agent {agent.id} has no _internal_memory field")
             if "tags" in fields:
                 del fields["tags"]
             else:
@@ -367,15 +365,15 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    def update_agent(self, agent: AgentState):
+    def update_agent(self, agent: PersistedAgentState):
         with self.session_maker() as session:
             fields = vars(agent)
-            if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
-                fields["memory"] = agent.memory.to_dict()
-            if "_internal_memory" in fields:
-                del fields["_internal_memory"]
-            else:
-                warnings.warn(f"Agent {agent.id} has no _internal_memory field")
+            # if isinstance(agent.memory, Memory):  # TODO: this is nasty but this whole class will soon be removed so whatever
+            #    fields["memory"] = agent.memory.to_dict()
+            # if "_internal_memory" in fields:
+            #    del fields["_internal_memory"]
+            # else:
+            #    warnings.warn(f"Agent {agent.id} has no _internal_memory field")
             if "tags" in fields:
                 del fields["tags"]
             else:
@@ -400,7 +398,7 @@ class MetadataStore:
             session.commit()
 
     @enforce_types
-    def list_agents(self, user_id: str) -> List[AgentState]:
+    def list_agents(self, user_id: str) -> List[PersistedAgentState]:
         with self.session_maker() as session:
             results = session.query(AgentModel).filter(AgentModel.user_id == user_id).all()
             return [r.to_record() for r in results]
@@ -408,7 +406,7 @@ class MetadataStore:
     @enforce_types
     def get_agent(
         self, agent_id: Optional[str] = None, agent_name: Optional[str] = None, user_id: Optional[str] = None
-    ) -> Optional[AgentState]:
+    ) -> Optional[PersistedAgentState]:
         with self.session_maker() as session:
             if agent_id:
                 results = session.query(AgentModel).filter(AgentModel.id == agent_id).all()

letta/o1_agent.py

@@ -6,7 +6,6 @@ from letta.metadata import MetadataStore
 from letta.schemas.agent import AgentState
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import UsageStatistics
-from letta.schemas.tool import Tool
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 
@@ -45,13 +44,11 @@ class O1Agent(Agent):
         interface: AgentInterface,
         agent_state: AgentState,
         user: User,
-        tools: List[Tool] = [],
         max_thinking_steps: int = 10,
         first_message_verify_mono: bool = False,
     ):
-        super().__init__(interface, agent_state, tools, user)
+        super().__init__(interface, agent_state, user)
         self.max_thinking_steps = max_thinking_steps
-        self.tools = tools
         self.first_message_verify_mono = first_message_verify_mono
 
     def step(

letta/persistence_manager.py

@@ -121,6 +121,7 @@ class LocalStateManager(PersistenceManager):
         # self.messages = [self.messages[0]] + added_messages + self.messages[1:]
 
         # add to recall memory
+        self.recall_memory.insert_many([m for m in added_messages])
 
     def append_to_messages(self, added_messages: List[Message]):
         # first tag with timestamps

letta/schemas/agent.py

@@ -2,15 +2,18 @@ from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field, field_validator, model_validator
+from pydantic import BaseModel, Field, field_validator
 
+from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.letta_base import LettaBase
 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
+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):
@@ -32,23 +35,8 @@ class AgentType(str, Enum):
     o1_agent = "o1_agent"
 
 
-class AgentState(BaseAgent, 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.
-
-    Parameters:
-        id (str): The unique identifier of the agent.
-        name (str): The name of the agent (must be unique to the user).
-        created_at (datetime): The datetime the agent was created.
-        message_ids (List[str]): The ids of the messages in the agent's in-context memory.
-        memory (Memory): The in-context memory of the agent.
-        tools (List[str]): The tools used by the agent. This includes any memory editing functions specified in `memory`.
-        system (str): The system prompt used by the agent.
-        llm_config (LLMConfig): The LLM configuration used by the agent.
-        embedding_config (EmbeddingConfig): The embedding configuration used by the 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)
@@ -56,16 +44,12 @@ class AgentState(BaseAgent, validate_assignment=True):
     # in-context memory
     message_ids: Optional[List[str]] = Field(default=None, description="The ids of the messages in the agent's in-context memory.")
 
-    memory: Memory = Field(default_factory=Memory, description="The in-context memory of the agent.")
-
     # tools
-    tools: List[str] = Field(..., description="The tools used by the agent.")
+    # TODO: move to ORM mapping
+    tool_names: 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.")
-
-    # tags
-    tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
+    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.")
@@ -77,40 +61,62 @@ class AgentState(BaseAgent, validate_assignment=True):
     llm_config: LLMConfig = Field(..., description="The LLM configuration used by the agent.")
     embedding_config: EmbeddingConfig = Field(..., description="The embedding configuration used by the agent.")
 
-    def __init__(self, **data):
-        super().__init__(**data)
-        self._internal_memory = self.memory
+    class Config:
+        arbitrary_types_allowed = True
+        validate_assignment = True
 
-    @model_validator(mode="after")
-    def verify_memory_type(self):
-        try:
-            assert isinstance(self.memory, Memory)
-        except Exception as e:
-            raise e
-        return self
 
-    @property
-    def memory(self) -> Memory:
-        return self._internal_memory
+class AgentState(PersistedAgentState):
+    """
+    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.
+
+    Parameters:
+        id (str): The unique identifier of the agent.
+        name (str): The name of the agent (must be unique to the user).
+        created_at (datetime): The datetime the agent was created.
+        message_ids (List[str]): The ids of the messages in the agent's in-context memory.
+        memory (Memory): The in-context memory of the agent.
+        tools (List[str]): The tools used by the agent. This includes any memory editing functions specified in `memory`.
+        system (str): The system prompt used by the agent.
+        llm_config (LLMConfig): The LLM configuration used by the agent.
+        embedding_config (EmbeddingConfig): The embedding configuration used by the agent.
 
-    @memory.setter
-    def memory(self, value):
-        if not isinstance(value, Memory):
-            raise TypeError(f"Expected Memory, got {type(value).__name__}")
-        self._internal_memory = value
+    """
 
-    class Config:
-        arbitrary_types_allowed = True
-        validate_assignment = True
+    # NOTE: this is what is returned to the client and also what is used to initialize `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
+    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(BaseAgent):  #
     # 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.")
-    memory: Optional[Memory] = Field(None, description="The in-context memory 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: 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.")
+    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: Optional[AgentType] = Field(None, description="The type of agent.")
@@ -151,7 +157,7 @@ class CreateAgent(BaseAgent):
 class UpdateAgentState(BaseAgent):
     id: str = Field(..., description="The id of the agent.")
     name: Optional[str] = Field(None, description="The name of the agent.")
-    tools: Optional[List[str]] = Field(None, description="The tools used by the agent.")
+    tool_names: Optional[List[str]] = Field(None, description="The tools 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.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
@@ -159,7 +165,6 @@ class UpdateAgentState(BaseAgent):
 
     # 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.")
-    memory: Optional[Memory] = Field(None, description="The in-context memory of the agent.")
 
 
 class AgentStepResponse(BaseModel):

letta/schemas/block.py

@@ -28,6 +28,12 @@ class BaseBlock(LettaBase, validate_assignment=True):
     description: Optional[str] = Field(None, description="Description of the block.")
     metadata_: Optional[dict] = Field({}, description="Metadata of the block.")
 
+    # def __len__(self):
+    #     return len(self.value)
+
+    class Config:
+        extra = "ignore"  # Ignores extra fields
+
     @model_validator(mode="after")
     def verify_char_limit(self) -> Self:
         if self.value and len(self.value) > self.limit:
@@ -36,9 +42,6 @@ class BaseBlock(LettaBase, validate_assignment=True):
 
         return self
 
-    # def __len__(self):
-    #     return len(self.value)
-
     def __setattr__(self, name, value):
         """Run validation if self.value is updated"""
         super().__setattr__(name, value)
@@ -46,9 +49,6 @@ class BaseBlock(LettaBase, validate_assignment=True):
             # run validation
             self.__class__.model_validate(self.model_dump(exclude_unset=True))
 
-    class Config:
-        extra = "ignore"  # Ignores extra fields
-
 
 class Block(BaseBlock):
     """
@@ -88,11 +88,11 @@ class Persona(Block):
     label: str = "persona"
 
 
-class BlockCreate(BaseBlock):
-    """Create a block"""
-
-    is_template: bool = True
-    label: str = Field(..., description="Label of the block.")
+# class CreateBlock(BaseBlock):
+#    """Create a block"""
+#
+#    is_template: bool = True
+#    label: str = Field(..., description="Label of the block.")
 
 
 class BlockLabelUpdate(BaseModel):
@@ -102,16 +102,16 @@ class BlockLabelUpdate(BaseModel):
     new_label: str = Field(..., description="New label of the block.")
 
 
-class CreatePersona(BlockCreate):
-    """Create a persona block"""
-
-    label: str = "persona"
-
-
-class CreateHuman(BlockCreate):
-    """Create a human block"""
-
-    label: str = "human"
+# class CreatePersona(CreateBlock):
+#    """Create a persona block"""
+#
+#    label: str = "persona"
+#
+#
+# class CreateHuman(CreateBlock):
+#    """Create a human block"""
+#
+#    label: str = "human"
 
 
 class BlockUpdate(BaseBlock):
@@ -131,13 +131,57 @@ class BlockLimitUpdate(BaseModel):
     limit: int = Field(..., description="New limit of the block.")
 
 
-class UpdatePersona(BlockUpdate):
-    """Update a persona block"""
+# class UpdatePersona(BlockUpdate):
+#    """Update a persona block"""
+#
+#    label: str = "persona"
+#
+#
+# class UpdateHuman(BlockUpdate):
+#    """Update a human block"""
+#
+#    label: str = "human"
+
+
+class CreateBlock(BaseBlock):
+    """Create a block"""
+
+    label: str = Field(..., description="Label of the block.")
+    limit: int = Field(2000, description="Character limit of the block.")
+    value: str = Field(..., description="Value of the block.")
+
+    # block templates
+    is_template: bool = False
+    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.", alias="name")
+
+
+class CreateHuman(CreateBlock):
+    """Create a human block"""
+
+    label: str = "human"
+
+
+class CreatePersona(CreateBlock):
+    """Create a persona block"""
 
     label: str = "persona"
 
 
-class UpdateHuman(BlockUpdate):
-    """Update a human block"""
+class CreateBlockTemplate(CreateBlock):
+    """Create a block template"""
+
+    is_template: bool = True
+
+
+class CreateHumanBlockTemplate(CreateHuman):
+    """Create a human block template"""
 
+    is_template: bool = True
     label: str = "human"
+
+
+class CreatePersonaBlockTemplate(CreatePersona):
+    """Create a persona block template"""
+
+    is_template: bool = True
+    label: str = "persona"