letta-nightly 0.11.7.dev20251007104119__py3-none-any.whl → 0.11.7.dev20251008104128__py3-none-any.whl

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

@@ -154,13 +154,10 @@ async def retrieve_block(
     headers: HeaderParams = Depends(get_headers),
 ):
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-    try:
-        block = await server.block_manager.get_block_by_id_async(block_id=block_id, actor=actor)
-        if block is None:
-            raise HTTPException(status_code=404, detail="Block not found")
-        return block
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail="Block not found")
+    block = await server.block_manager.get_block_by_id_async(block_id=block_id, actor=actor)
+    if block is None:
+        raise NoResultFound(f"Block with id '{block_id}' not found")
+    return block
 
 
 @router.get("/{block_id}/agents", response_model=List[AgentState], operation_id="list_agents_for_block")
@@ -195,16 +192,13 @@ async def list_agents_for_block(
     Raises a 404 if the block does not exist.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-    try:
-        agents = await server.block_manager.get_agents_for_block_async(
-            block_id=block_id,
-            before=before,
-            after=after,
-            limit=limit,
-            ascending=(order == "asc"),
-            include_relationships=include_relationships,
-            actor=actor,
-        )
-        return agents
-    except NoResultFound:
-        raise HTTPException(status_code=404, detail=f"Block with id={block_id} not found")
+    agents = await server.block_manager.get_agents_for_block_async(
+        block_id=block_id,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=(order == "asc"),
+        include_relationships=include_relationships,
+        actor=actor,
+    )
+    return agents

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

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Literal, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
+from fastapi import APIRouter, Body, Depends, Header, Query
 
 from letta.orm.errors import NoResultFound, UniqueConstraintViolationError
 from letta.schemas.agent import AgentState
@@ -39,26 +39,19 @@ async def list_identities(
     """
     Get a list of all identities in the database
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-
-        identities = await server.identity_manager.list_identities_async(
-            name=name,
-            project_id=project_id,
-            identifier_key=identifier_key,
-            identity_type=identity_type,
-            before=before,
-            after=after,
-            limit=limit,
-            ascending=(order == "asc"),
-            actor=actor,
-        )
-    except HTTPException:
-        raise
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+
+    identities = await server.identity_manager.list_identities_async(
+        name=name,
+        project_id=project_id,
+        identifier_key=identifier_key,
+        identity_type=identity_type,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=(order == "asc"),
+        actor=actor,
+    )
     return identities
 
 
@@ -70,15 +63,11 @@ async def count_identities(
     """
     Get count of all identities for a user
     """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
         return await server.identity_manager.size_async(actor=actor)
     except NoResultFound:
         return 0
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
 
 
 @router.get("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="retrieve_identity")
@@ -87,11 +76,8 @@ async def retrieve_identity(
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.identity_manager.get_identity_async(identity_id=identity_id, actor=actor)
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.identity_manager.get_identity_async(identity_id=identity_id, actor=actor)
 
 
 @router.post("/", tags=["identities"], response_model=Identity, operation_id="create_identity")
@@ -103,21 +89,8 @@ async def create_identity(
         None, alias="X-Project", description="The project slug to associate with the identity (cloud only)."
     ),  # Only handled by next js middleware
 ):
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.identity_manager.create_identity_async(identity=identity, actor=actor)
-    except HTTPException:
-        raise
-    except UniqueConstraintViolationError:
-        if identity.project_id:
-            raise HTTPException(
-                status_code=409,
-                detail=f"An identity with identifier key {identity.identifier_key} already exists for project {identity.project_id}",
-            )
-        else:
-            raise HTTPException(status_code=409, detail=f"An identity with identifier key {identity.identifier_key} already exists")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.identity_manager.create_identity_async(identity=identity, actor=actor)
 
 
 @router.put("/", tags=["identities"], response_model=Identity, operation_id="upsert_identity")
@@ -129,15 +102,8 @@ async def upsert_identity(
         None, alias="X-Project", description="The project slug to associate with the identity (cloud only)."
     ),  # Only handled by next js middleware
 ):
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.identity_manager.upsert_identity_async(identity=identity, actor=actor)
-    except HTTPException:
-        raise
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.identity_manager.upsert_identity_async(identity=identity, actor=actor)
 
 
 @router.patch("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="update_identity")
@@ -147,15 +113,8 @@ async def modify_identity(
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.identity_manager.update_identity_async(identity_id=identity_id, identity=identity, actor=actor)
-    except HTTPException:
-        raise
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.identity_manager.update_identity_async(identity_id=identity_id, identity=identity, actor=actor)
 
 
 @router.put("/{identity_id}/properties", tags=["identities"], operation_id="upsert_identity_properties")
@@ -165,15 +124,8 @@ async def upsert_identity_properties(
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.identity_manager.upsert_identity_properties_async(identity_id=identity_id, properties=properties, actor=actor)
-    except HTTPException:
-        raise
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.identity_manager.upsert_identity_properties_async(identity_id=identity_id, properties=properties, actor=actor)
 
 
 @router.delete("/{identity_id}", tags=["identities"], operation_id="delete_identity")
@@ -185,15 +137,8 @@ async def delete_identity(
     """
     Delete an identity by its identifier key
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        await server.identity_manager.delete_identity_async(identity_id=identity_id, actor=actor)
-    except HTTPException:
-        raise
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    await server.identity_manager.delete_identity_async(identity_id=identity_id, actor=actor)
 
 
 @router.get("/{identity_id}/agents", response_model=List[AgentState], operation_id="list_agents_for_identity")
@@ -218,20 +163,15 @@ async def list_agents_for_identity(
     """
     Get all agents associated with the specified identity.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.identity_manager.list_agents_for_identity_async(
-            identity_id=identity_id,
-            before=before,
-            after=after,
-            limit=limit,
-            ascending=(order == "asc"),
-            actor=actor,
-        )
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=f"Identity with id={identity_id} not found")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.identity_manager.list_agents_for_identity_async(
+        identity_id=identity_id,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=(order == "asc"),
+        actor=actor,
+    )
 
 
 @router.get("/{identity_id}/blocks", response_model=List[Block], operation_id="list_blocks_for_identity")
@@ -256,17 +196,12 @@ async def list_blocks_for_identity(
     """
     Get all blocks associated with the specified identity.
     """
-    try:
-        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-        return await server.identity_manager.list_blocks_for_identity_async(
-            identity_id=identity_id,
-            before=before,
-            after=after,
-            limit=limit,
-            ascending=(order == "asc"),
-            actor=actor,
-        )
-    except NoResultFound as e:
-        raise HTTPException(status_code=404, detail=f"Identity with id={identity_id} not found")
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"{e}")
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.identity_manager.list_blocks_for_identity_async(
+        identity_id=identity_id,
+        before=before,
+        after=after,
+        limit=limit,
+        ascending=(order == "asc"),
+        actor=actor,
+    )

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

@@ -61,6 +61,27 @@ async def create_block(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+@router.post("/blocks/batch", response_model=List[Block], operation_id="create_internal_template_blocks_batch")
+async def create_blocks_batch(
+    blocks: List[InternalTemplateBlockCreate] = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Create multiple blocks with template-related fields.
+    """
+    try:
+        actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+        created_blocks = []
+        for block in blocks:
+            block_obj = Block(**block.model_dump())
+            created_block = await server.block_manager.create_or_update_block_async(block_obj, actor=actor)
+            created_blocks.append(created_block)
+        return created_blocks
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 class DeploymentEntity(BaseModel):
     """A deployment entity."""
 

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

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List, Literal, Optional
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 
@@ -16,11 +16,23 @@ router = APIRouter(prefix="/jobs", tags=["jobs"])
 async def list_jobs(
     server: "SyncServer" = Depends(get_letta_server),
     source_id: Optional[str] = Query(None, description="Only list jobs associated with the source."),
-    before: Optional[str] = Query(None, description="Cursor for pagination"),
-    after: Optional[str] = Query(None, description="Cursor for pagination"),
-    limit: Optional[int] = Query(50, description="Limit for pagination"),
+    before: Optional[str] = Query(
+        None, description="Job ID cursor for pagination. Returns jobs that come before this job ID in the specified sort order"
+    ),
+    after: Optional[str] = Query(
+        None, description="Job ID cursor for pagination. Returns jobs that come after this job ID in the specified sort order"
+    ),
+    limit: Optional[int] = Query(100, description="Maximum number of jobs to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for jobs by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
     active: bool = Query(False, description="Filter for active jobs."),
-    ascending: bool = Query(True, description="Whether to sort jobs oldest to newest (True, default) or newest to oldest (False)"),
+    ascending: bool = Query(
+        True,
+        description="Whether to sort jobs oldest to newest (True, default) or newest to oldest (False). Deprecated in favor of order field.",
+        deprecated=True,
+    ),
     headers: HeaderParams = Depends(get_headers),
 ):
     """
@@ -32,6 +44,11 @@ async def list_jobs(
     if active:
         statuses = [JobStatus.created, JobStatus.running]
 
+    if ascending is not True:
+        sort_ascending = ascending
+    else:
+        sort_ascending = order == "asc"
+
     # TODO: add filtering by status
     return await server.job_manager.list_jobs_async(
         actor=actor,
@@ -40,7 +57,7 @@ async def list_jobs(
         before=before,
         after=after,
         limit=limit,
-        ascending=ascending,
+        ascending=sort_ascending,
     )
 
 

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

@@ -122,7 +122,7 @@ async def list_batches(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
 
-    jobs = server.job_manager.list_jobs(
+    jobs = await server.job_manager.list_jobs_async(
         actor=actor,
         statuses=[JobStatus.created, JobStatus.running],
         job_type=JobType.BATCH,