letta-nightly 0.6.12.dev20250122104013__py3-none-any.whl → 0.6.14.dev20250123041709__py3-none-any.whl

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

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, Response
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.orm.errors import NoResultFound
 from letta.schemas.block import Block, BlockUpdate, CreateBlock
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 router = APIRouter(prefix="/blocks", tags=["blocks"])
 
 
-@router.get("/", response_model=List[Block], operation_id="list_memory_blocks")
+@router.get("/", response_model=List[Block], operation_id="list_blocks")
 def list_blocks(
     # query parameters
     label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
@@ -26,7 +26,7 @@ def list_blocks(
     return server.block_manager.get_blocks(actor=actor, label=label, is_template=templates_only, template_name=name)
 
 
-@router.post("/", response_model=Block, operation_id="create_memory_block")
+@router.post("/", response_model=Block, operation_id="create_block")
 def create_block(
     create_block: CreateBlock = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -37,8 +37,8 @@ def create_block(
     return server.block_manager.create_or_update_block(actor=actor, block=block)
 
 
-@router.patch("/{block_id}", response_model=Block, operation_id="update_memory_block")
-def update_block(
+@router.patch("/{block_id}", response_model=Block, operation_id="modify_block")
+def modify_block(
     block_id: str,
     block_update: BlockUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -48,7 +48,7 @@ def update_block(
     return server.block_manager.update_block(block_id=block_id, block_update=block_update, actor=actor)
 
 
-@router.delete("/{block_id}", response_model=Block, operation_id="delete_memory_block")
+@router.delete("/{block_id}", response_model=Block, operation_id="delete_block")
 def delete_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
@@ -58,8 +58,8 @@ def delete_block(
     return server.block_manager.delete_block(block_id=block_id, actor=actor)
 
 
-@router.get("/{block_id}", response_model=Block, operation_id="get_memory_block")
-def get_block(
+@router.get("/{block_id}", response_model=Block, operation_id="retrieve_block")
+def retrieve_block(
     block_id: str,
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
@@ -73,41 +73,3 @@ def get_block(
         return block
     except NoResultFound:
         raise HTTPException(status_code=404, detail="Block not found")
-
-
-@router.patch("/{block_id}/attach", response_model=None, status_code=204, operation_id="link_agent_memory_block")
-def link_agent_memory_block(
-    block_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
-):
-    """
-    Link a memory block to an agent.
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-
-    try:
-        server.agent_manager.attach_block(agent_id=agent_id, block_id=block_id, actor=actor)
-        return Response(status_code=204)
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
-
-
-@router.patch("/{block_id}/detach", response_model=None, status_code=204, operation_id="unlink_agent_memory_block")
-def unlink_agent_memory_block(
-    block_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
-):
-    """
-    Unlink a memory block from an agent
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-
-    try:
-        server.agent_manager.detach_block(agent_id=agent_id, block_id=block_id, actor=actor)
-        return Response(status_code=204)
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))

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

@@ -26,9 +26,9 @@ def list_jobs(
     jobs = server.job_manager.list_jobs(actor=actor)
 
     if source_id:
-        # can't be in the ORM since we have source_id stored in the metadata_
+        # can't be in the ORM since we have source_id stored in the metadata
         # TODO: Probably change this
-        jobs = [job for job in jobs if job.metadata_.get("source_id") == source_id]
+        jobs = [job for job in jobs if job.metadata.get("source_id") == source_id]
     return jobs
 
 
@@ -45,8 +45,8 @@ def list_active_jobs(
     return server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running])
 
 
-@router.get("/{job_id}", response_model=Job, operation_id="get_job")
-def get_job(
+@router.get("/{job_id}", response_model=Job, operation_id="retrieve_job")
+def retrieve_job(
     job_id: str,
     user_id: Optional[str] = Header(None, alias="user_id"),
     server: "SyncServer" = Depends(get_letta_server),

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

@@ -45,8 +45,8 @@ def create_provider(
     return provider
 
 
-@router.put("/", 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
@@ -48,23 +48,6 @@ def get_tool(
     return tool
 
 
-@router.get("/name/{tool_name}", response_model=str, operation_id="get_tool_id_by_name")
-def get_tool_id(
-    tool_name: 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
-):
-    """
-    Get a tool ID by name
-    """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-    tool = server.tool_manager.get_tool_by_name(tool_name=tool_name, actor=actor)
-    if tool:
-        return tool.id
-    else:
-        raise HTTPException(status_code=404, detail=f"Tool with name {tool_name} and organization id {actor.organization_id} not found.")
-
-
 @router.get("/", response_model=List[Tool], operation_id="list_tools")
 def list_tools(
     cursor: Optional[str] = None,
@@ -139,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),
@@ -237,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

@@ -773,9 +773,9 @@ class SyncServer(Server):
         interface: Union[AgentInterface, None] = None,
     ) -> AgentState:
         if request.llm_config is None:
-            if request.llm is None:
-                raise ValueError("Must specify either llm or llm_config in request")
-            request.llm_config = self.get_llm_config_from_handle(handle=request.llm, context_window_limit=request.context_window_limit)
+            if request.model is None:
+                raise ValueError("Must specify either model or llm_config in request")
+            request.llm_config = self.get_llm_config_from_handle(handle=request.model, context_window_limit=request.context_window_limit)
 
         if request.embedding_config is None:
             if request.embedding is None:
@@ -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()