letta-nightly 0.5.1.dev20241103104102__tar.gz → 0.5.1.dev20241105104128__tar.gz

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.5.1.dev20241103104102
+Version: 0.5.1.dev20241105104128
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
@@ -52,6 +52,8 @@ Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres"
 Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres"
 Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev"
 Requires-Dist: prettytable (>=3.9.0,<4.0.0)
+Requires-Dist: psycopg2 (>=2.9.10,<3.0.0) ; extra == "postgres"
+Requires-Dist: psycopg2-binary (>=2.9.10,<3.0.0) ; extra == "postgres"
 Requires-Dist: pyautogen (==0.2.22) ; extra == "autogen"
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.2.1,<3.0.0)

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/agent.py

@@ -235,6 +235,7 @@ class Agent(BaseAgent):
         # extras
         messages_total: Optional[int] = None,  # TODO remove?
         first_message_verify_mono: bool = True,  # TODO move to config?
+        initial_message_sequence: Optional[List[Message]] = None,
     ):
         assert isinstance(agent_state.memory, Memory), f"Memory object is not of type Memory: {type(agent_state.memory)}"
         # Hold a copy of the state that was used to init the agent
@@ -294,6 +295,7 @@ class Agent(BaseAgent):
 
         else:
             printd(f"Agent.__init__ :: creating, state={agent_state.message_ids}")
+            assert self.agent_state.id is not None and self.agent_state.user_id is not None
 
             # Generate a sequence of initial messages to put in the buffer
             init_messages = initialize_message_sequence(
@@ -306,14 +308,40 @@ class Agent(BaseAgent):
                 include_initial_boot_message=True,
             )
 
-            # Cast the messages to actual Message objects to be synced to the DB
-            init_messages_objs = []
-            for msg in init_messages:
-                init_messages_objs.append(
+            if initial_message_sequence is not None:
+                # We always need the system prompt up front
+                system_message_obj = Message.dict_to_message(
+                    agent_id=self.agent_state.id,
+                    user_id=self.agent_state.user_id,
+                    model=self.model,
+                    openai_message_dict=init_messages[0],
+                )
+                # Don't use anything else in the pregen sequence, instead use the provided sequence
+                init_messages = [system_message_obj] + initial_message_sequence
+
+            else:
+                # Basic "more human than human" initial message sequence
+                init_messages = initialize_message_sequence(
+                    model=self.model,
+                    system=self.system,
+                    memory=self.memory,
+                    archival_memory=None,
+                    recall_memory=None,
+                    memory_edit_timestamp=get_utc_time(),
+                    include_initial_boot_message=True,
+                )
+                # Cast to Message objects
+                init_messages = [
                     Message.dict_to_message(
                         agent_id=self.agent_state.id, user_id=self.agent_state.user_id, model=self.model, openai_message_dict=msg
                     )
-                )
+                    for msg in init_messages
+                ]
+
+            # Cast the messages to actual Message objects to be synced to the DB
+            init_messages_objs = []
+            for msg in init_messages:
+                init_messages_objs.append(msg)
             assert all([isinstance(msg, Message) for msg in init_messages_objs]), (init_messages_objs, init_messages)
 
             # Put the messages inside the message buffer

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/cli/cli.py

@@ -282,10 +282,10 @@ def run(
         system_prompt = system if system else None
 
         memory = ChatMemory(human=human_obj.value, persona=persona_obj.value, limit=core_memory_limit)
-        metadata = {"human": human_obj.name, "persona": persona_obj.name}
+        metadata = {"human": human_obj.template_name, "persona": persona_obj.template_name}
 
-        typer.secho(f"->  {ASSISTANT_MESSAGE_CLI_SYMBOL} Using persona profile: '{persona_obj.name}'", fg=typer.colors.WHITE)
-        typer.secho(f"->  🧑 Using human profile: '{human_obj.name}'", fg=typer.colors.WHITE)
+        typer.secho(f"->  {ASSISTANT_MESSAGE_CLI_SYMBOL} Using persona profile: '{persona_obj.template_name}'", fg=typer.colors.WHITE)
+        typer.secho(f"->  🧑 Using human profile: '{human_obj.template_name}'", fg=typer.colors.WHITE)
 
         # add tools
         agent_state = client.create_agent(

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/cli/cli_config.py

@@ -59,13 +59,13 @@ def list(arg: Annotated[ListChoice, typer.Argument]):
         """List all humans"""
         table.field_names = ["Name", "Text"]
         for human in client.list_humans():
-            table.add_row([human.name, human.value.replace("\n", "")[:100]])
+            table.add_row([human.template_name, human.value.replace("\n", "")[:100]])
         print(table)
     elif arg == ListChoice.personas:
         """List all personas"""
         table.field_names = ["Name", "Text"]
         for persona in client.list_personas():
-            table.add_row([persona.name, persona.value.replace("\n", "")[:100]])
+            table.add_row([persona.template_name, persona.value.replace("\n", "")[:100]])
         print(table)
     elif arg == ListChoice.sources:
         """List all data sources"""

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/client/client.py

@@ -376,6 +376,7 @@ class RESTClient(AbstractClient):
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
+        initial_message_sequence: Optional[List[Message]] = None,
     ) -> AgentState:
         """Create an agent
 
@@ -428,9 +429,18 @@ class RESTClient(AbstractClient):
             agent_type=agent_type,
             llm_config=llm_config if llm_config else self._default_llm_config,
             embedding_config=embedding_config if embedding_config else self._default_embedding_config,
+            initial_message_sequence=initial_message_sequence,
+        )
+
+        # Use model_dump_json() instead of model_dump()
+        # If we use model_dump(), the datetime objects will not be serialized correctly
+        # response = requests.post(f"{self.base_url}/{self.api_prefix}/agents", json=request.model_dump(), headers=self.headers)
+        response = requests.post(
+            f"{self.base_url}/{self.api_prefix}/agents",
+            data=request.model_dump_json(),  # Use model_dump_json() instead of json=model_dump()
+            headers={"Content-Type": "application/json", **self.headers},
         )
 
-        response = requests.post(f"{self.base_url}/{self.api_prefix}/agents", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Status {response.status_code} - Failed to create agent: {response.text}")
         return AgentState(**response.json())
@@ -859,8 +869,8 @@ class RESTClient(AbstractClient):
         else:
             return [Block(**block) for block in response.json()]
 
-    def create_block(self, label: str, text: str, name: Optional[str] = None, template: bool = False) -> Block:  #
-        request = CreateBlock(label=label, value=text, template=template, name=name)
+    def create_block(self, label: str, text: str, template_name: Optional[str] = None, template: bool = False) -> Block:  #
+        request = CreateBlock(label=label, value=text, template=template, template_name=template_name)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to create block: {response.text}")
@@ -872,7 +882,7 @@ class RESTClient(AbstractClient):
             return Block(**response.json())
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
-        request = UpdateBlock(id=block_id, name=name, value=text)
+        request = UpdateBlock(id=block_id, template_name=name, value=text)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{block_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update block: {response.text}")
@@ -926,7 +936,7 @@ class RESTClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.create_block(label="human", name=name, text=text, template=True)
+        return self.create_block(label="human", template_name=name, text=text, template=True)
 
     def update_human(self, human_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Human:
         """
@@ -939,7 +949,7 @@ class RESTClient(AbstractClient):
         Returns:
             human (Human): Updated human block
         """
-        request = UpdateHuman(id=human_id, name=name, value=text)
+        request = UpdateHuman(id=human_id, template_name=name, value=text)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{human_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update human: {response.text}")
@@ -966,7 +976,7 @@ class RESTClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.create_block(label="persona", name=name, text=text, template=True)
+        return self.create_block(label="persona", template_name=name, text=text, template=True)
 
     def update_persona(self, persona_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Persona:
         """
@@ -979,7 +989,7 @@ class RESTClient(AbstractClient):
         Returns:
             persona (Persona): Updated persona block
         """
-        request = UpdatePersona(id=persona_id, name=name, value=text)
+        request = UpdatePersona(id=persona_id, template_name=name, value=text)
         response = requests.post(f"{self.base_url}/{self.api_prefix}/blocks/{persona_id}", json=request.model_dump(), headers=self.headers)
         if response.status_code != 200:
             raise ValueError(f"Failed to update persona: {response.text}")
@@ -1648,6 +1658,7 @@ class LocalClient(AbstractClient):
         # metadata
         metadata: Optional[Dict] = {"human:": DEFAULT_HUMAN, "persona": DEFAULT_PERSONA},
         description: Optional[str] = None,
+        initial_message_sequence: Optional[List[Message]] = None,
     ) -> AgentState:
         """Create an agent
 
@@ -1702,6 +1713,7 @@ class LocalClient(AbstractClient):
                 agent_type=agent_type,
                 llm_config=llm_config if llm_config else self._default_llm_config,
                 embedding_config=embedding_config if embedding_config else self._default_embedding_config,
+                initial_message_sequence=initial_message_sequence,
             ),
             actor=self.user,
         )
@@ -2116,7 +2128,7 @@ class LocalClient(AbstractClient):
         Returns:
             human (Human): Human block
         """
-        return self.server.create_block(CreateHuman(name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.create_block(CreateHuman(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
 
     def create_persona(self, name: str, text: str):
         """
@@ -2129,7 +2141,7 @@ class LocalClient(AbstractClient):
         Returns:
             persona (Persona): Persona block
         """
-        return self.server.create_block(CreatePersona(name=name, value=text, user_id=self.user_id), user_id=self.user_id)
+        return self.server.create_block(CreatePersona(template_name=name, value=text, user_id=self.user_id), user_id=self.user_id)
 
     def list_humans(self):
         """
@@ -2635,7 +2647,7 @@ class LocalClient(AbstractClient):
         """
         return self.server.get_blocks(label=label, template=templates_only)
 
-    def create_block(self, label: str, text: str, name: Optional[str] = None, template: bool = False) -> Block:  #
+    def create_block(self, label: str, text: str, template_name: Optional[str] = None, template: bool = False) -> Block:  #
         """
         Create a block
 
@@ -2648,7 +2660,7 @@ class LocalClient(AbstractClient):
             block (Block): Created block
         """
         return self.server.create_block(
-            CreateBlock(label=label, name=name, value=text, user_id=self.user_id, template=template), user_id=self.user_id
+            CreateBlock(label=label, template_name=template_name, value=text, user_id=self.user_id, template=template), user_id=self.user_id
         )
 
     def update_block(self, block_id: str, name: Optional[str] = None, text: Optional[str] = None) -> Block:
@@ -2663,7 +2675,7 @@ class LocalClient(AbstractClient):
         Returns:
             block (Block): Updated block
         """
-        return self.server.update_block(UpdateBlock(id=block_id, name=name, value=text))
+        return self.server.update_block(UpdateBlock(id=block_id, template_name=name, value=text))
 
     def get_block(self, block_id: str) -> Block:
         """

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/functions/schema_generator.py

@@ -139,32 +139,73 @@ def generate_schema(function, name: Optional[str] = None, description: Optional[
     return schema
 
 
-def generate_schema_from_args_schema(
+def generate_schema_from_args_schema_v1(
     args_schema: Type[V1BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
 ) -> Dict[str, Any]:
     properties = {}
     required = []
     for field_name, field in args_schema.__fields__.items():
-        if field.type_.__name__ == "str":
+        if field.type_ == str:
             field_type = "string"
-        elif field.type_.__name__ == "int":
+        elif field.type_ == int:
             field_type = "integer"
-        elif field.type_.__name__ == "bool":
+        elif field.type_ == bool:
             field_type = "boolean"
         else:
             field_type = field.type_.__name__
-        properties[field_name] = {"type": field_type, "description": field.field_info.description}
+
+        properties[field_name] = {
+            "type": field_type,
+            "description": field.field_info.description,
+        }
         if field.required:
             required.append(field_name)
 
-    # Construct the OpenAI function call JSON object
     function_call_json = {
         "name": name,
         "description": description,
         "parameters": {"type": "object", "properties": properties, "required": required},
     }
 
-    # append heartbeat (necessary for triggering another reasoning step after this tool call)
+    if append_heartbeat:
+        function_call_json["parameters"]["properties"]["request_heartbeat"] = {
+            "type": "boolean",
+            "description": "Request an immediate heartbeat after function execution. Set to `True` if you want to send a follow-up message or run a follow-up function.",
+        }
+        function_call_json["parameters"]["required"].append("request_heartbeat")
+
+    return function_call_json
+
+
+def generate_schema_from_args_schema_v2(
+    args_schema: Type[BaseModel], name: Optional[str] = None, description: Optional[str] = None, append_heartbeat: bool = True
+) -> Dict[str, Any]:
+    properties = {}
+    required = []
+    for field_name, field in args_schema.model_fields.items():
+        field_type_annotation = field.annotation
+        if field_type_annotation == str:
+            field_type = "string"
+        elif field_type_annotation == int:
+            field_type = "integer"
+        elif field_type_annotation == bool:
+            field_type = "boolean"
+        else:
+            field_type = field_type_annotation.__name__
+
+        properties[field_name] = {
+            "type": field_type,
+            "description": field.description,
+        }
+        if field.is_required():
+            required.append(field_name)
+
+    function_call_json = {
+        "name": name,
+        "description": description,
+        "parameters": {"type": "object", "properties": properties, "required": required},
+    }
+
     if append_heartbeat:
         function_call_json["parameters"]["properties"]["request_heartbeat"] = {
             "type": "boolean",

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/metadata.py

@@ -348,7 +348,7 @@ class BlockModel(Base):
     id = Column(String, primary_key=True, nullable=False)
     value = Column(String, nullable=False)
     limit = Column(BIGINT)
-    name = Column(String)
+    template_name = Column(String, nullable=True, default=None)
     template = Column(Boolean, default=False)  # True: listed as possible human/persona
     label = Column(String, nullable=False)
     metadata_ = Column(JSON)
@@ -357,7 +357,7 @@ class BlockModel(Base):
     Index(__tablename__ + "_idx_user", user_id),
 
     def __repr__(self) -> str:
-        return f"<Block(id='{self.id}', name='{self.name}', template='{self.template}', label='{self.label}', user_id='{self.user_id}')>"
+        return f"<Block(id='{self.id}', template_name='{self.template_name}', template='{self.template_name}', label='{self.label}', user_id='{self.user_id}')>"
 
     def to_record(self) -> Block:
         if self.label == "persona":
@@ -365,7 +365,7 @@ class BlockModel(Base):
                 id=self.id,
                 value=self.value,
                 limit=self.limit,
-                name=self.name,
+                template_name=self.template_name,
                 template=self.template,
                 label=self.label,
                 metadata_=self.metadata_,
@@ -377,7 +377,7 @@ class BlockModel(Base):
                 id=self.id,
                 value=self.value,
                 limit=self.limit,
-                name=self.name,
+                template_name=self.template_name,
                 template=self.template,
                 label=self.label,
                 metadata_=self.metadata_,
@@ -389,7 +389,7 @@ class BlockModel(Base):
                 id=self.id,
                 value=self.value,
                 limit=self.limit,
-                name=self.name,
+                template_name=self.template_name,
                 template=self.template,
                 label=self.label,
                 metadata_=self.metadata_,
@@ -512,7 +512,7 @@ class MetadataStore:
             # with a given name doesn't exist.
             if (
                 session.query(BlockModel)
-                .filter(BlockModel.name == block.name)
+                .filter(BlockModel.template_name == block.template_name)
                 .filter(BlockModel.user_id == block.user_id)
                 .filter(BlockModel.template == True)
                 .filter(BlockModel.label == block.label)
@@ -520,7 +520,7 @@ class MetadataStore:
                 > 0
             ):
 
-                raise ValueError(f"Block with name {block.name} already exists")
+                raise ValueError(f"Block with name {block.template_name} already exists")
             session.add(BlockModel(**vars(block)))
             session.commit()
 
@@ -658,7 +658,7 @@ class MetadataStore:
         user_id: Optional[str],
         label: Optional[str] = None,
         template: Optional[bool] = None,
-        name: Optional[str] = None,
+        template_name: Optional[str] = None,
         id: Optional[str] = None,
     ) -> Optional[List[Block]]:
         """List available blocks"""
@@ -671,8 +671,8 @@ class MetadataStore:
             if label:
                 query = query.filter(BlockModel.label == label)
 
-            if name:
-                query = query.filter(BlockModel.name == name)
+            if template_name:
+                query = query.filter(BlockModel.template_name == template_name)
 
             if id:
                 query = query.filter(BlockModel.id == id)

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/schemas/agent.py

@@ -1,4 +1,3 @@
-import uuid
 from datetime import datetime
 from enum import Enum
 from typing import Dict, List, Optional
@@ -105,7 +104,7 @@ class AgentState(BaseAgent, validate_assignment=True):
 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[uuid.UUID]] = Field(None, description="The ids of the messages in the agent's in-context memory.")
+    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.")
     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.")
@@ -113,6 +112,11 @@ class CreateAgent(BaseAgent):
     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.")
     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
+    # If the client wants to make this empty, then the client can set the arg to an empty list
+    initial_message_sequence: Optional[List[Message]] = Field(
+        None, description="The initial set of messages to put in the agent's in-context memory."
+    )
 
     @field_validator("name")
     @classmethod

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/schemas/block.py

@@ -18,7 +18,7 @@ class BaseBlock(LettaBase, validate_assignment=True):
     limit: int = Field(2000, description="Character limit of the block.")
 
     # template data (optional)
-    name: Optional[str] = Field(None, description="Name of the block if it is a template.")
+    template_name: Optional[str] = Field(None, description="Name of the block if it is a template.")
     template: bool = Field(False, description="Whether the block is a template (e.g. saved human/persona options).")
 
     # context window label

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/schemas/letta_base.py

@@ -21,6 +21,8 @@ class LettaBase(BaseModel):
         from_attributes=True,
         # throw errors if attributes are given that don't belong
         extra="forbid",
+        # handle datetime serialization consistently across all models
+        # json_encoders={datetime: lambda dt: (dt.replace(tzinfo=timezone.utc) if dt.tzinfo is None else dt).isoformat()},
     )
 
     # def __id_prefix__(self):

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/schemas/organization.py

@@ -4,6 +4,7 @@ from typing import Optional
 from pydantic import Field
 
 from letta.schemas.letta_base import LettaBase
+from letta.utils import get_utc_time
 
 
 class OrganizationBase(LettaBase):
@@ -13,7 +14,7 @@ class OrganizationBase(LettaBase):
 class Organization(OrganizationBase):
     id: str = Field(..., description="The id of the organization.")
     name: str = Field(..., description="The name of the organization.")
-    created_at: datetime = Field(default_factory=datetime.utcnow, description="The creation date of the organization.")
+    created_at: Optional[datetime] = Field(default_factory=get_utc_time, description="The creation date of the organization.")
 
 
 class OrganizationCreate(OrganizationBase):

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/schemas/tool.py

@@ -1,5 +1,6 @@
 from typing import Dict, List, Optional
 
+from composio import LogLevel
 from pydantic import Field
 
 from letta.functions.helpers import (
@@ -7,7 +8,10 @@ from letta.functions.helpers import (
     generate_crewai_tool_wrapper,
     generate_langchain_tool_wrapper,
 )
-from letta.functions.schema_generator import generate_schema_from_args_schema
+from letta.functions.schema_generator import (
+    generate_schema_from_args_schema_v1,
+    generate_schema_from_args_schema_v2,
+)
 from letta.schemas.letta_base import LettaBase
 from letta.schemas.openai.chat_completions import ToolCall
 
@@ -84,7 +88,7 @@ class ToolCreate(LettaBase):
         """
         from composio_langchain import ComposioToolSet
 
-        composio_toolset = ComposioToolSet()
+        composio_toolset = ComposioToolSet(logging_level=LogLevel.ERROR)
         composio_tools = composio_toolset.get_tools(actions=[action])
 
         assert len(composio_tools) > 0, "User supplied parameters do not match any Composio tools"
@@ -96,7 +100,7 @@ class ToolCreate(LettaBase):
         source_type = "python"
         tags = ["composio"]
         wrapper_func_name, wrapper_function_str = generate_composio_tool_wrapper(action)
-        json_schema = generate_schema_from_args_schema(composio_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_schema_from_args_schema_v2(composio_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,
@@ -128,7 +132,7 @@ class ToolCreate(LettaBase):
         tags = ["langchain"]
         # NOTE: langchain tools may come from different packages
         wrapper_func_name, wrapper_function_str = generate_langchain_tool_wrapper(langchain_tool, additional_imports_module_attr_map)
-        json_schema = generate_schema_from_args_schema(langchain_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_schema_from_args_schema_v1(langchain_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,
@@ -158,7 +162,7 @@ class ToolCreate(LettaBase):
         source_type = "python"
         tags = ["crew-ai"]
         wrapper_func_name, wrapper_function_str = generate_crewai_tool_wrapper(crewai_tool, additional_imports_module_attr_map)
-        json_schema = generate_schema_from_args_schema(crewai_tool.args_schema, name=wrapper_func_name, description=description)
+        json_schema = generate_schema_from_args_schema_v1(crewai_tool.args_schema, name=wrapper_func_name, description=description)
 
         return cls(
             name=wrapper_func_name,

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/schemas/user.py

@@ -24,8 +24,8 @@ class User(UserBase):
     id: str = Field(..., description="The id of the user.")
     organization_id: Optional[str] = Field(OrganizationManager.DEFAULT_ORG_ID, description="The organization id of the user")
     name: str = Field(..., description="The name of the user.")
-    created_at: datetime = Field(default_factory=datetime.utcnow, description="The creation date of the user.")
-    updated_at: datetime = Field(default_factory=datetime.utcnow, description="The update date of the user.")
+    created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the user.")
+    updated_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The update date of the user.")
     is_deleted: bool = Field(False, description="Whether this user is deleted or not.")
 
 

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/server/server.py

@@ -857,7 +857,10 @@ class SyncServer(Server):
                     agent_state=agent_state,
                     tools=tool_objs,
                     # gpt-3.5-turbo tends to omit inner monologue, relax this requirement for now
-                    first_message_verify_mono=True if (llm_config.model is not None and "gpt-4" in llm_config.model) else False,
+                    first_message_verify_mono=(
+                        True if (llm_config and llm_config.model is not None and "gpt-4" in llm_config.model) else False
+                    ),
+                    initial_message_sequence=request.initial_message_sequence,
                 )
             elif request.agent_type == AgentType.o1_agent:
                 agent = O1Agent(
@@ -865,7 +868,9 @@ class SyncServer(Server):
                     agent_state=agent_state,
                     tools=tool_objs,
                     # gpt-3.5-turbo tends to omit inner monologue, relax this requirement for now
-                    first_message_verify_mono=True if (llm_config.model is not None and "gpt-4" in llm_config.model) else False,
+                    first_message_verify_mono=(
+                        True if (llm_config and llm_config.model is not None and "gpt-4" in llm_config.model) else False
+                    ),
                 )
             # rebuilding agent memory on agent create in case shared memory blocks
             # were specified in the new agent's memory config. we're doing this for two reasons:
@@ -1084,7 +1089,7 @@ class SyncServer(Server):
         id: Optional[str] = None,
     ) -> Optional[List[Block]]:
 
-        return self.ms.get_blocks(user_id=user_id, label=label, template=template, name=name, id=id)
+        return self.ms.get_blocks(user_id=user_id, label=label, template=template, template_name=name, id=id)
 
     def get_block(self, block_id: str):
 
@@ -1096,14 +1101,18 @@ class SyncServer(Server):
         return blocks[0]
 
     def create_block(self, request: CreateBlock, user_id: str, update: bool = False) -> Block:
-        existing_blocks = self.ms.get_blocks(name=request.name, user_id=user_id, template=request.template, label=request.label)
-        if existing_blocks is not None:
+        existing_blocks = self.ms.get_blocks(
+            template_name=request.template_name, user_id=user_id, template=request.template, label=request.label
+        )
+
+        # for templates, update existing block template if exists
+        if existing_blocks is not None and request.template:
             existing_block = existing_blocks[0]
             assert len(existing_blocks) == 1
             if update:
                 return self.update_block(UpdateBlock(id=existing_block.id, **vars(request)))
             else:
-                raise ValueError(f"Block with name {request.name} already exists")
+                raise ValueError(f"Block with name {request.template_name} already exists")
         block = Block(**vars(request))
         self.ms.create_block(block)
         return block
@@ -1112,7 +1121,7 @@ class SyncServer(Server):
         block = self.get_block(request.id)
         block.limit = request.limit if request.limit is not None else block.limit
         block.value = request.value if request.value is not None else block.value
-        block.name = request.name if request.name is not None else block.name
+        block.template_name = request.template_name if request.template_name is not None else block.template_name
         self.ms.update_block(block=block)
         return self.ms.get_block(block_id=request.id)
 
@@ -1773,12 +1782,12 @@ class SyncServer(Server):
         for persona_file in list_persona_files():
             text = open(persona_file, "r", encoding="utf-8").read()
             name = os.path.basename(persona_file).replace(".txt", "")
-            self.create_block(CreatePersona(user_id=user_id, name=name, value=text, template=True), user_id=user_id, update=True)
+            self.create_block(CreatePersona(user_id=user_id, template_name=name, value=text, template=True), user_id=user_id, update=True)
 
         for human_file in list_human_files():
             text = open(human_file, "r", encoding="utf-8").read()
             name = os.path.basename(human_file).replace(".txt", "")
-            self.create_block(CreateHuman(user_id=user_id, name=name, value=text, template=True), user_id=user_id, update=True)
+            self.create_block(CreateHuman(user_id=user_id, template_name=name, value=text, template=True), user_id=user_id, update=True)
 
     def get_agent_message(self, agent_id: str, message_id: str) -> Optional[Message]:
         """Get a single message from the agent's memory"""

{letta_nightly-0.5.1.dev20241103104102 → letta_nightly-0.5.1.dev20241105104128}/letta/services/tool_manager.py

@@ -12,7 +12,7 @@ from letta.orm.tool import Tool as ToolModel
 from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool import ToolCreate, ToolUpdate
 from letta.schemas.user import User as PydanticUser
-from letta.utils import enforce_types
+from letta.utils import enforce_types, printd
 
 
 class ToolManager:
@@ -54,7 +54,7 @@ class ToolManager:
             if update_data:
                 self.update_tool_by_id(tool.id, ToolUpdate(**update_data), actor)
             else:
-                warnings.warn(
+                printd(
                     f"`create_or_update_tool` was called with user_id={actor.id}, organization_id={actor.organization_id}, name={tool_create.name}, but found existing tool with nothing to update."
                 )
         except NoResultFound: