letta-nightly 0.6.13.dev20250122185528__py3-none-any.whl → 0.6.14.dev20250123104106__py3-none-any.whl

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

@@ -45,8 +45,8 @@ def create_provider(
     return provider
 
 
-@router.patch("/", tags=["providers"], response_model=Provider, operation_id="update_provider")
-def update_provider(
+@router.patch("/", tags=["providers"], response_model=Provider, operation_id="modify_provider")
+def modify_provider(
     request: ProviderUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
 ):

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

@@ -43,8 +43,8 @@ def list_active_runs(
     return [Run.from_job(job) for job in active_runs]
 
 
-@router.get("/{run_id}", response_model=Run, operation_id="get_run")
-def get_run(
+@router.get("/{run_id}", response_model=Run, operation_id="retrieve_run")
+def retrieve_run(
     run_id: str,
     user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),
@@ -69,9 +69,9 @@ RunMessagesResponse = Annotated[
 @router.get(
     "/{run_id}/messages",
     response_model=RunMessagesResponse,
-    operation_id="get_run_messages",
+    operation_id="list_run_messages",
 )
-async def get_run_messages(
+async def list_run_messages(
     run_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
@@ -111,8 +111,8 @@ async def get_run_messages(
         raise HTTPException(status_code=404, detail=str(e))
 
 
-@router.get("/{run_id}/usage", response_model=UsageStatistics, operation_id="get_run_usage")
-def get_run_usage(
+@router.get("/{run_id}/usage", response_model=UsageStatistics, operation_id="retrieve_run_usage")
+def retrieve_run_usage(
     run_id: str,
     user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),

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

@@ -19,8 +19,8 @@ from letta.utils import sanitize_filename
 router = APIRouter(prefix="/sources", tags=["sources"])
 
 
-@router.get("/{source_id}", response_model=Source, operation_id="get_source")
-def get_source(
+@router.get("/{source_id}", response_model=Source, operation_id="retrieve_source")
+def retrieve_source(
     source_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -81,8 +81,8 @@ def create_source(
     return server.source_manager.create_source(source=source, actor=actor)
 
 
-@router.patch("/{source_id}", response_model=Source, operation_id="update_source")
-def update_source(
+@router.patch("/{source_id}", response_model=Source, operation_id="modify_source")
+def modify_source(
     source_id: str,
     source: SourceUpdate,
     server: "SyncServer" = Depends(get_letta_server),
@@ -111,36 +111,6 @@ def delete_source(
     server.delete_source(source_id=source_id, actor=actor)
 
 
-@router.post("/{source_id}/attach", response_model=Source, operation_id="attach_agent_to_source")
-def attach_source_to_agent(
-    source_id: str,
-    agent_id: str = Query(..., description="The unique identifier of the agent to attach the source to."),
-    server: "SyncServer" = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-):
-    """
-    Attach a data source to an existing agent.
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-    server.agent_manager.attach_source(source_id=source_id, agent_id=agent_id, actor=actor)
-    return server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
-
-
-@router.post("/{source_id}/detach", response_model=Source, operation_id="detach_agent_from_source")
-def detach_source_from_agent(
-    source_id: str,
-    agent_id: str = Query(..., description="The unique identifier of the agent to detach the source from."),
-    server: "SyncServer" = Depends(get_letta_server),
-    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-) -> None:
-    """
-    Detach a data source from an existing agent.
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-    server.agent_manager.detach_source(agent_id=agent_id, source_id=source_id, actor=actor)
-    return server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
-
-
 @router.post("/{source_id}/upload", response_model=Job, operation_id="upload_file_to_source")
 def upload_file_to_source(
     file: UploadFile,
@@ -161,7 +131,7 @@ def upload_file_to_source(
     # create job
     job = Job(
         user_id=actor.id,
-        metadata_={"type": "embedding", "filename": file.filename, "source_id": source_id},
+        metadata={"type": "embedding", "filename": file.filename, "source_id": source_id},
         completed_at=None,
     )
     job_id = job.id
@@ -178,7 +148,7 @@ def upload_file_to_source(
 
 
 @router.get("/{source_id}/passages", response_model=List[Passage], operation_id="list_source_passages")
-def list_passages(
+def list_source_passages(
     source_id: str,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -191,8 +161,8 @@ def list_passages(
     return passages
 
 
-@router.get("/{source_id}/files", response_model=List[FileMetadata], operation_id="list_files_from_source")
-def list_files_from_source(
+@router.get("/{source_id}/files", response_model=List[FileMetadata], operation_id="list_source_files")
+def list_source_files(
     source_id: str,
     limit: int = Query(1000, description="Number of files to return"),
     cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),

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

@@ -12,7 +12,7 @@ router = APIRouter(prefix="/tags", tags=["tag", "admin"])
 
 
 @router.get("/", tags=["admin"], response_model=List[str], operation_id="list_tags")
-def get_tags(
+def list_tags(
     cursor: Optional[str] = Query(None),
     limit: Optional[int] = Query(50),
     server: "SyncServer" = Depends(get_letta_server),

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

@@ -31,8 +31,8 @@ def delete_tool(
     server.tool_manager.delete_tool_by_id(tool_id=tool_id, actor=actor)
 
 
-@router.get("/{tool_id}", response_model=Tool, operation_id="get_tool")
-def get_tool(
+@router.get("/{tool_id}", response_model=Tool, operation_id="retrieve_tool")
+def retrieve_tool(
     tool_id: str,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -122,8 +122,8 @@ def upsert_tool(
         raise HTTPException(status_code=500, detail=f"An unexpected error occurred: {str(e)}")
 
 
-@router.patch("/{tool_id}", response_model=Tool, operation_id="update_tool")
-def update_tool(
+@router.patch("/{tool_id}", response_model=Tool, operation_id="modify_tool")
+def modify_tool(
     tool_id: str,
     request: ToolUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -220,11 +220,10 @@ def add_composio_tool(
     Add a new Composio tool by action name (Composio refers to each tool as an `Action`)
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    composio_api_key = get_composio_key(server, actor=actor)
 
     try:
-        tool_create = ToolCreate.from_composio(action_name=composio_action_name, api_key=composio_api_key)
-        return server.tool_manager.create_or_update_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=actor)
+        tool_create = ToolCreate.from_composio(action_name=composio_action_name)
+        return server.tool_manager.create_or_update_composio_tool(pydantic_tool=Tool(**tool_create.model_dump()), actor=actor)
     except EnumStringNotFound as e:
         raise HTTPException(
             status_code=400,  # Bad Request

letta/server/server.py

@@ -956,8 +956,8 @@ class SyncServer(Server):
 
         # update job status
         job.status = JobStatus.completed
-        job.metadata_["num_passages"] = num_passages
-        job.metadata_["num_documents"] = num_documents
+        job.metadata["num_passages"] = num_passages
+        job.metadata["num_documents"] = num_documents
         self.job_manager.update_job_by_id(job_id=job_id, job_update=JobUpdate(**job.model_dump()), actor=actor)
 
         # update all agents who have this source attached
@@ -1019,7 +1019,7 @@ class SyncServer(Server):
             attached_agents = [{"id": agent.id, "name": agent.name} for agent in agents]
 
             # Overwrite metadata field, should be empty anyways
-            source.metadata_ = dict(
+            source.metadata = dict(
                 num_documents=num_documents,
                 num_passages=num_passages,
                 attached_agents=attached_agents,

letta/services/agent_manager.py

@@ -25,6 +25,7 @@ from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.message import MessageCreate
 from letta.schemas.passage import Passage as PydanticPassage
 from letta.schemas.source import Source as PydanticSource
+from letta.schemas.tool import Tool as PydanticTool
 from letta.schemas.tool_rule import ToolRule as PydanticToolRule
 from letta.schemas.user import User as PydanticUser
 from letta.services.block_manager import BlockManager
@@ -81,7 +82,7 @@ class AgentManager:
         block_ids = list(agent_create.block_ids or [])  # Create a local copy to avoid modifying the original
         if agent_create.memory_blocks:
             for create_block in agent_create.memory_blocks:
-                block = self.block_manager.create_or_update_block(PydanticBlock(**create_block.model_dump()), actor=actor)
+                block = self.block_manager.create_or_update_block(PydanticBlock(**create_block.model_dump(to_orm=True)), actor=actor)
                 block_ids.append(block.id)
 
         # TODO: Remove this block once we deprecate the legacy `tools` field
@@ -116,7 +117,7 @@ class AgentManager:
             source_ids=agent_create.source_ids or [],
             tags=agent_create.tags or [],
             description=agent_create.description,
-            metadata_=agent_create.metadata_,
+            metadata=agent_create.metadata,
             tool_rules=agent_create.tool_rules,
             actor=actor,
         )
@@ -176,7 +177,7 @@ class AgentManager:
         source_ids: List[str],
         tags: List[str],
         description: Optional[str] = None,
-        metadata_: Optional[Dict] = None,
+        metadata: Optional[Dict] = None,
         tool_rules: Optional[List[PydanticToolRule]] = None,
     ) -> PydanticAgentState:
         """Create a new agent."""
@@ -190,7 +191,7 @@ class AgentManager:
                 "embedding_config": embedding_config,
                 "organization_id": actor.organization_id,
                 "description": description,
-                "metadata_": metadata_,
+                "metadata_": metadata,
                 "tool_rules": tool_rules,
             }
 
@@ -241,11 +242,14 @@ class AgentManager:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
             # Update scalar fields directly
-            scalar_fields = {"name", "system", "llm_config", "embedding_config", "message_ids", "tool_rules", "description", "metadata_"}
+            scalar_fields = {"name", "system", "llm_config", "embedding_config", "message_ids", "tool_rules", "description", "metadata"}
             for field in scalar_fields:
                 value = getattr(agent_update, field, None)
                 if value is not None:
-                    setattr(agent, field, value)
+                    if field == "metadata":
+                        setattr(agent, "metadata_", value)
+                    else:
+                        setattr(agent, field, value)
 
             # Update relationships using _process_relationship and _process_tags
             if agent_update.tool_ids is not None:
@@ -464,6 +468,12 @@ class AgentManager:
         new_messages = [message_ids[0]] + message_ids[num:]  # 0 is system message
         return self.set_in_context_messages(agent_id=agent_id, message_ids=new_messages, actor=actor)
 
+    @enforce_types
+    def trim_all_in_context_messages_except_system(self, agent_id: str, actor: PydanticUser) -> PydanticAgentState:
+        message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
+        new_messages = [message_ids[0]]  # 0 is system message
+        return self.set_in_context_messages(agent_id=agent_id, message_ids=new_messages, actor=actor)
+
     @enforce_types
     def prepend_to_in_context_messages(self, messages: List[PydanticMessage], agent_id: str, actor: PydanticUser) -> PydanticAgentState:
         message_ids = self.get_agent_by_id(agent_id=agent_id, actor=actor).message_ids
@@ -531,7 +541,7 @@ class AgentManager:
     # Source Management
     # ======================================================================================================================
     @enforce_types
-    def attach_source(self, agent_id: str, source_id: str, actor: PydanticUser) -> None:
+    def attach_source(self, agent_id: str, source_id: str, actor: PydanticUser) -> PydanticAgentState:
         """
         Attaches a source to an agent.
 
@@ -561,6 +571,7 @@ class AgentManager:
 
             # Commit the changes
             agent.update(session, actor=actor)
+            return agent.to_pydantic()
 
     @enforce_types
     def list_attached_sources(self, agent_id: str, actor: PydanticUser) -> List[PydanticSource]:
@@ -582,7 +593,7 @@ class AgentManager:
             return [source.to_pydantic() for source in agent.sources]
 
     @enforce_types
-    def detach_source(self, agent_id: str, source_id: str, actor: PydanticUser) -> None:
+    def detach_source(self, agent_id: str, source_id: str, actor: PydanticUser) -> PydanticAgentState:
         """
         Detaches a source from an agent.
 
@@ -596,10 +607,17 @@ class AgentManager:
             agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
 
             # Remove the source from the relationship
-            agent.sources = [s for s in agent.sources if s.id != source_id]
+            remaining_sources = [s for s in agent.sources if s.id != source_id]
+
+            if len(remaining_sources) == len(agent.sources):  # Source ID was not in the relationship
+                logger.warning(f"Attempted to remove unattached source id={source_id} from agent id={agent_id} by actor={actor}")
+
+            # Update the sources relationship
+            agent.sources = remaining_sources
 
             # Commit the changes
             agent.update(session, actor=actor)
+            return agent.to_pydantic()
 
     # ======================================================================================================================
     # Block management
@@ -1005,6 +1023,22 @@ class AgentManager:
             agent.update(session, actor=actor)
             return agent.to_pydantic()
 
+    @enforce_types
+    def list_attached_tools(self, agent_id: str, actor: PydanticUser) -> List[PydanticTool]:
+        """
+        List all tools attached to an agent.
+
+        Args:
+            agent_id: ID of the agent to list tools for.
+            actor: User performing the action.
+
+        Returns:
+            List[PydanticTool]: List of tools attached to the agent.
+        """
+        with self.session_maker() as session:
+            agent = AgentModel.read(db_session=session, identifier=agent_id, actor=actor)
+            return [tool.to_pydantic() for tool in agent.tools]
+
     # ======================================================================================================================
     # Tag Management
     # ======================================================================================================================

letta/services/block_manager.py

@@ -24,11 +24,11 @@ class BlockManager:
         """Create a new block based on the Block schema."""
         db_block = self.get_block_by_id(block.id, actor)
         if db_block:
-            update_data = BlockUpdate(**block.model_dump(exclude_none=True))
+            update_data = BlockUpdate(**block.model_dump(to_orm=True, exclude_none=True))
             self.update_block(block.id, update_data, actor)
         else:
             with self.session_maker() as session:
-                data = block.model_dump(exclude_none=True)
+                data = block.model_dump(to_orm=True, exclude_none=True)
                 block = BlockModel(**data, organization_id=actor.organization_id)
                 block.create(session, actor=actor)
             return block.to_pydantic()
@@ -40,7 +40,7 @@ class BlockManager:
 
         with self.session_maker() as session:
             block = BlockModel.read(db_session=session, identifier=block_id, actor=actor)
-            update_data = block_update.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = block_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
 
             for key, value in update_data.items():
                 setattr(block, key, value)

letta/services/job_manager.py

@@ -39,7 +39,7 @@ class JobManager:
         with self.session_maker() as session:
             # Associate the job with the user
             pydantic_job.user_id = actor.id
-            job_data = pydantic_job.model_dump()
+            job_data = pydantic_job.model_dump(to_orm=True)
             job = JobModel(**job_data)
             job.create(session, actor=actor)  # Save job in the database
         return job.to_pydantic()
@@ -52,7 +52,7 @@ class JobManager:
             job = self._verify_job_access(session=session, job_id=job_id, actor=actor, access=["write"])
 
             # Update job attributes with only the fields that were explicitly set
-            update_data = job_update.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = job_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
 
             # Automatically update the completion timestamp if status is set to 'completed'
             if update_data.get("status") == JobStatus.completed and not job.completed_at:
@@ -62,7 +62,9 @@ class JobManager:
                 setattr(job, key, value)
 
             # Save the updated job to the database
-            return job.update(db_session=session)  # TODO: Add this later , actor=actor)
+            job.update(db_session=session)  # TODO: Add this later , actor=actor)
+
+            return job.to_pydantic()
 
     @enforce_types
     def get_job_by_id(self, job_id: str, actor: PydanticUser) -> PydanticJob:

letta/services/organization_manager.py

@@ -44,7 +44,7 @@ class OrganizationManager:
     @enforce_types
     def _create_organization(self, pydantic_org: PydanticOrganization) -> PydanticOrganization:
         with self.session_maker() as session:
-            org = OrganizationModel(**pydantic_org.model_dump())
+            org = OrganizationModel(**pydantic_org.model_dump(to_orm=True))
             org.create(session)
             return org.to_pydantic()
 

letta/services/passage_manager.py

@@ -38,14 +38,14 @@ class PassageManager:
     def create_passage(self, pydantic_passage: PydanticPassage, actor: PydanticUser) -> PydanticPassage:
         """Create a new passage in the appropriate table based on whether it has agent_id or source_id."""
         # Common fields for both passage types
-        data = pydantic_passage.model_dump()
+        data = pydantic_passage.model_dump(to_orm=True)
         common_fields = {
             "id": data.get("id"),
             "text": data["text"],
             "embedding": data["embedding"],
             "embedding_config": data["embedding_config"],
             "organization_id": data["organization_id"],
-            "metadata_": data.get("metadata_", {}),
+            "metadata_": data.get("metadata", {}),
             "is_deleted": data.get("is_deleted", False),
             "created_at": data.get("created_at", datetime.utcnow()),
         }
@@ -145,7 +145,7 @@ class PassageManager:
                     raise ValueError(f"Passage with id {passage_id} does not exist.")
 
             # Update the database record with values from the provided record
-            update_data = passage.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = passage.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
             for key, value in update_data.items():
                 setattr(curr_passage, key, value)
 

letta/services/provider_manager.py

@@ -24,7 +24,7 @@ class ProviderManager:
             # Lazily create the provider id prior to persistence
             provider.resolve_identifier()
 
-            new_provider = ProviderModel(**provider.model_dump(exclude_unset=True))
+            new_provider = ProviderModel(**provider.model_dump(to_orm=True, exclude_unset=True))
             new_provider.create(session)
             return new_provider.to_pydantic()
 
@@ -36,7 +36,7 @@ class ProviderManager:
             existing_provider = ProviderModel.read(db_session=session, identifier=provider_update.id)
 
             # Update only the fields that are provided in ProviderUpdate
-            update_data = provider_update.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = provider_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
             for key, value in update_data.items():
                 setattr(existing_provider, key, value)
 

letta/services/sandbox_config_manager.py

@@ -172,7 +172,7 @@ class SandboxConfigManager:
             return db_env_var
         else:
             with self.session_maker() as session:
-                env_var = SandboxEnvVarModel(**env_var.model_dump(exclude_none=True))
+                env_var = SandboxEnvVarModel(**env_var.model_dump(to_orm=True, exclude_none=True))
                 env_var.create(session, actor=actor)
             return env_var.to_pydantic()
 
@@ -183,7 +183,7 @@ class SandboxConfigManager:
         """Update an existing sandbox environment variable."""
         with self.session_maker() as session:
             env_var = SandboxEnvVarModel.read(db_session=session, identifier=env_var_id, actor=actor)
-            update_data = env_var_update.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = env_var_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
             update_data = {key: value for key, value in update_data.items() if getattr(env_var, key) != value}
 
             if update_data:

letta/services/source_manager.py

@@ -30,7 +30,7 @@ class SourceManager:
             with self.session_maker() as session:
                 # Provide default embedding config if not given
                 source.organization_id = actor.organization_id
-                source = SourceModel(**source.model_dump(exclude_none=True))
+                source = SourceModel(**source.model_dump(to_orm=True, exclude_none=True))
                 source.create(session, actor=actor)
             return source.to_pydantic()
 
@@ -41,7 +41,7 @@ class SourceManager:
             source = SourceModel.read(db_session=session, identifier=source_id, actor=actor)
 
             # get update dictionary
-            update_data = source_update.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = source_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
             # Remove redundant update fields
             update_data = {key: value for key, value in update_data.items() if getattr(source, key) != value}
 
@@ -132,7 +132,7 @@ class SourceManager:
         else:
             with self.session_maker() as session:
                 file_metadata.organization_id = actor.organization_id
-                file_metadata = FileMetadataModel(**file_metadata.model_dump(exclude_none=True))
+                file_metadata = FileMetadataModel(**file_metadata.model_dump(to_orm=True, exclude_none=True))
                 file_metadata.create(session, actor=actor)
             return file_metadata.to_pydantic()
 

letta/services/tool_execution_sandbox.py

@@ -364,7 +364,9 @@ class ToolExecutionSandbox:
             sbx = Sandbox(sandbox_config.get_e2b_config().template, metadata={self.METADATA_CONFIG_STATE_KEY: state_hash})
         else:
             # no template
-            sbx = Sandbox(metadata={self.METADATA_CONFIG_STATE_KEY: state_hash}, **e2b_config.model_dump(exclude={"pip_requirements"}))
+            sbx = Sandbox(
+                metadata={self.METADATA_CONFIG_STATE_KEY: state_hash}, **e2b_config.model_dump(to_orm=True, exclude={"pip_requirements"})
+            )
 
         # install pip requirements
         if e2b_config.pip_requirements:

letta/services/tool_manager.py

@@ -39,7 +39,7 @@ class ToolManager:
         tool = self.get_tool_by_name(tool_name=pydantic_tool.name, actor=actor)
         if tool:
             # Put to dict and remove fields that should not be reset
-            update_data = pydantic_tool.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = pydantic_tool.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
 
             # If there's anything to update
             if update_data:
@@ -53,6 +53,11 @@ class ToolManager:
 
         return tool
 
+    @enforce_types
+    def create_or_update_composio_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
+        pydantic_tool.tool_type = ToolType.EXTERNAL_COMPOSIO
+        return self.create_or_update_tool(pydantic_tool, actor)
+
     @enforce_types
     def create_tool(self, pydantic_tool: PydanticTool, actor: PydanticUser) -> PydanticTool:
         """Create a new tool based on the ToolCreate schema."""
@@ -62,7 +67,7 @@ class ToolManager:
             # Auto-generate description if not provided
             if pydantic_tool.description is None:
                 pydantic_tool.description = pydantic_tool.json_schema.get("description", None)
-            tool_data = pydantic_tool.model_dump()
+            tool_data = pydantic_tool.model_dump(to_orm=True)
 
             tool = ToolModel(**tool_data)
             tool.create(session, actor=actor)  # Re-raise other database-related errors
@@ -107,7 +112,7 @@ class ToolManager:
             tool = ToolModel.read(db_session=session, identifier=tool_id, actor=actor)
 
             # Update tool attributes with only the fields that were explicitly set
-            update_data = tool_update.model_dump(exclude_none=True)
+            update_data = tool_update.model_dump(to_orm=True, exclude_none=True)
             for key, value in update_data.items():
                 setattr(tool, key, value)
 

letta/services/user_manager.py

@@ -45,7 +45,7 @@ class UserManager:
     def create_user(self, pydantic_user: PydanticUser) -> PydanticUser:
         """Create a new user if it doesn't already exist."""
         with self.session_maker() as session:
-            new_user = UserModel(**pydantic_user.model_dump())
+            new_user = UserModel(**pydantic_user.model_dump(to_orm=True))
             new_user.create(session)
             return new_user.to_pydantic()
 
@@ -57,7 +57,7 @@ class UserManager:
             existing_user = UserModel.read(db_session=session, identifier=user_update.id)
 
             # Update only the fields that are provided in UserUpdate
-            update_data = user_update.model_dump(exclude_unset=True, exclude_none=True)
+            update_data = user_update.model_dump(to_orm=True, exclude_unset=True, exclude_none=True)
             for key, value in update_data.items():
                 setattr(existing_user, key, value)
 

letta/settings.py

@@ -18,6 +18,34 @@ class ToolSettings(BaseSettings):
     local_sandbox_dir: Optional[str] = None
 
 
+class SummarizerSettings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="letta_summarizer_", extra="ignore")
+
+    # Controls if we should evict all messages
+    # TODO: Can refactor this into an enum if we have a bunch of different kinds of summarizers
+    evict_all_messages: bool = False
+
+    # The maximum number of retries for the summarizer
+    # If we reach this cutoff, it probably means that the summarizer is not compressing down the in-context messages any further
+    # And we throw a fatal error
+    max_summarizer_retries: int = 3
+
+    # When to warn the model that a summarize command will happen soon
+    # The amount of tokens before a system warning about upcoming truncation is sent to Letta
+    memory_warning_threshold: float = 0.75
+
+    # Whether to send the system memory warning message
+    send_memory_warning_message: bool = False
+
+    # The desired memory pressure to summarize down to
+    desired_memory_token_pressure: float = 0.3
+
+    # The number of messages at the end to keep
+    # Even when summarizing, we may want to keep a handful of recent messages
+    # These serve as in-context examples of how to use functions / what user messages look like
+    keep_last_n_messages: int = 0
+
+
 class ModelSettings(BaseSettings):
 
     model_config = SettingsConfigDict(env_file=".env", extra="ignore")
@@ -147,3 +175,4 @@ settings = Settings(_env_parse_none_str="None")
 test_settings = TestSettings()
 model_settings = ModelSettings()
 tool_settings = ToolSettings()
+summarizer_settings = SummarizerSettings()

letta/system.py

@@ -161,10 +161,10 @@ def package_system_message(system_message, message_type="system_alert", time=Non
     return json.dumps(packaged_message)
 
 
-def package_summarize_message(summary, summary_length, hidden_message_count, total_message_count, timestamp=None):
+def package_summarize_message(summary, summary_message_count, hidden_message_count, total_message_count, timestamp=None):
     context_message = (
         f"Note: prior messages ({hidden_message_count} of {total_message_count} total messages) have been hidden from view due to conversation memory constraints.\n"
-        + f"The following is a summary of the previous {summary_length} messages:\n {summary}"
+        + f"The following is a summary of the previous {summary_message_count} messages:\n {summary}"
     )
 
     formatted_time = get_local_time() if timestamp is None else timestamp

{letta_nightly-0.6.13.dev20250122185528.dist-info → letta_nightly-0.6.14.dev20250123104106.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.13.dev20250122185528
+Version: 0.6.14.dev20250123104106
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team