letta-nightly 0.13.0.dev20251031104146__py3-none-any.whl → 0.13.1.dev20251031234110__py3-none-any.whl

letta/schemas/providers/openrouter.py

@@ -21,7 +21,6 @@ class OpenRouterProvider(OpenAIProvider):
     provider_category: ProviderCategory = Field(ProviderCategory.base, description="The category of the provider (base or byok)")
     api_key: str = Field(..., description="API key for the OpenRouter API.")
     base_url: str = Field("https://openrouter.ai/api/v1", description="Base URL for the OpenRouter API.")
-    handle_base: str | None = Field(None, description="Custom handle base name for model handles (e.g., 'custom' instead of 'openrouter').")
 
     def _list_llm_models(self, data: list[dict]) -> list[LLMConfig]:
         """
@@ -34,7 +33,7 @@ class OpenRouterProvider(OpenAIProvider):
                 continue
             model_name, context_window_size = check
 
-            handle = self.get_handle(model_name, base_name=self.handle_base) if self.handle_base else self.get_handle(model_name)
+            handle = self.get_handle(model_name)
 
             config = LLMConfig(
                 model=model_name,

letta/schemas/run_metrics.py

@@ -2,11 +2,12 @@ from typing import List, Optional
 
 from pydantic import Field
 
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase
 
 
 class RunMetricsBase(LettaBase):
-    __id_prefix__ = "run"
+    __id_prefix__ = PrimitiveType.RUN.value
 
 
 class RunMetrics(RunMetricsBase):

letta/schemas/sandbox_config.py

@@ -102,7 +102,9 @@ class SandboxConfig(SandboxConfigBase):
     config: Dict = Field(default_factory=lambda: {}, description="The JSON sandbox settings data.")
 
     def get_e2b_config(self) -> E2BSandboxConfig:
-        return E2BSandboxConfig(**self.config)
+        config_dict = self.config.copy()
+        config_dict["template"] = tool_settings.e2b_sandbox_template_id
+        return E2BSandboxConfig(**config_dict)
 
     def get_local_config(self) -> LocalSandboxConfig:
         return LocalSandboxConfig(**self.config)

letta/schemas/step_metrics.py

@@ -2,11 +2,12 @@ from typing import Optional
 
 from pydantic import Field
 
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase
 
 
 class StepMetricsBase(LettaBase):
-    __id_prefix__ = "step"
+    __id_prefix__ = PrimitiveType.STEP.value
 
 
 class StepMetrics(StepMetricsBase):

letta/schemas/tool_rule.py

@@ -4,14 +4,14 @@ from typing import Annotated, Any, Dict, List, Literal, Optional, Set, Union
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
-from letta.schemas.enums import ToolRuleType
+from letta.schemas.enums import PrimitiveType, ToolRuleType
 from letta.schemas.letta_base import LettaBase
 
 logger = logging.getLogger(__name__)
 
 
 class BaseToolRule(LettaBase):
-    __id_prefix__ = "tool_rule"
+    __id_prefix__ = PrimitiveType.TOOL_RULE.value
     tool_name: str = Field(..., description="The name of the tool. Must exist in the database for the user's organization.")
     type: ToolRuleType = Field(..., description="The type of the message.")
     prompt_template: Optional[str] = Field(

letta/schemas/user.py

@@ -4,11 +4,12 @@ from typing import Optional
 from pydantic import Field
 
 from letta.constants import DEFAULT_ORG_ID
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase
 
 
 class UserBase(LettaBase):
-    __id_prefix__ = "user"
+    __id_prefix__ = PrimitiveType.USER.value
 
 
 class User(UserBase):

letta/server/rest_api/app.py

@@ -26,6 +26,7 @@ from letta.errors import (
     AgentFileImportError,
     AgentNotFoundForExportError,
     BedrockPermissionError,
+    HandleNotFoundError,
     LettaAgentNotFoundError,
     LettaExpiredError,
     LettaInvalidArgumentError,
@@ -39,6 +40,7 @@ from letta.errors import (
     LettaUserNotFoundError,
     LLMAuthenticationError,
     LLMError,
+    LLMProviderOverloaded,
     LLMRateLimitError,
     LLMTimeoutError,
     PendingApprovalError,
@@ -270,7 +272,7 @@ def create_application() -> "FastAPI":
         return JSONResponse(
             status_code=500,
             content={
-                "detail": "An internal server error occurred",
+                "detail": "An unknown error occurred",
                 # Only include error details in debug/development mode
                 # "debug_info": str(exc) if settings.debug else None
             },
@@ -369,6 +371,7 @@ def create_application() -> "FastAPI":
     app.add_exception_handler(LettaAgentNotFoundError, _error_handler_404_agent)
     app.add_exception_handler(LettaUserNotFoundError, _error_handler_404_user)
     app.add_exception_handler(AgentNotFoundForExportError, _error_handler_404)
+    app.add_exception_handler(HandleNotFoundError, _error_handler_404)
 
     # 410 Expired errors
     app.add_exception_handler(LettaExpiredError, _error_handler_410)
@@ -396,6 +399,7 @@ def create_application() -> "FastAPI":
     # 503 Service Unavailable errors
     app.add_exception_handler(OperationalError, _error_handler_503)
     app.add_exception_handler(LettaServiceUnavailableError, _error_handler_503)
+    app.add_exception_handler(LLMProviderOverloaded, _error_handler_503)
 
     @app.exception_handler(IncompatibleAgentType)
     async def handle_incompatible_agent_type(request: Request, exc: IncompatibleAgentType):

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

@@ -7,6 +7,8 @@ from letta.server.rest_api.routers.v1.folders import router as folders_router
 from letta.server.rest_api.routers.v1.groups import router as groups_router
 from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.identities import router as identities_router
+from letta.server.rest_api.routers.v1.internal_agents import router as internal_agents_router
+from letta.server.rest_api.routers.v1.internal_blocks import router as internal_blocks_router
 from letta.server.rest_api.routers.v1.internal_runs import router as internal_runs_router
 from letta.server.rest_api.routers.v1.internal_templates import router as internal_templates_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
@@ -32,6 +34,8 @@ ROUTERS = [
     chat_completions_router,
     groups_router,
     identities_router,
+    internal_agents_router,
+    internal_blocks_router,
     internal_runs_router,
     internal_templates_router,
     llm_router,

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

@@ -25,21 +25,23 @@ from letta.errors import (
     AgentNotFoundForExportError,
     PendingApprovalError,
 )
-from letta.helpers.datetime_helpers import get_utc_timestamp_ns
+from letta.groups.sleeptime_multi_agent_v4 import SleeptimeMultiAgentV4
+from letta.helpers.datetime_helpers import get_utc_time, get_utc_timestamp_ns
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.otel.context import get_ctx_attributes
 from letta.otel.metric_registry import MetricRegistry
 from letta.schemas.agent import AgentRelationships, AgentState, CreateAgent, UpdateAgent
 from letta.schemas.agent_file import AgentFileSchema
-from letta.schemas.block import BaseBlock, Block, BlockUpdate
-from letta.schemas.enums import AgentType, RunStatus
+from letta.schemas.block import BaseBlock, Block, BlockResponse, BlockUpdate
+from letta.schemas.enums import AgentType, MessageRole, RunStatus
 from letta.schemas.file import AgentFileAttachment, FileMetadataBase, PaginatedAgentFiles
 from letta.schemas.group import Group
 from letta.schemas.job import LettaRequestConfig
 from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion, MessageType
+from letta.schemas.letta_message_content import TextContent
 from letta.schemas.letta_request import LettaAsyncRequest, LettaRequest, LettaStreamingRequest
-from letta.schemas.letta_response import LettaResponse
+from letta.schemas.letta_response import LettaResponse, LettaStreamingResponse
 from letta.schemas.letta_stop_reason import StopReasonType
 from letta.schemas.memory import (
     ArchivalMemorySearchResponse,
@@ -48,7 +50,7 @@ from letta.schemas.memory import (
     CreateArchivalMemory,
     Memory,
 )
-from letta.schemas.message import BaseMessage, MessageCreate, MessageCreateType, MessageSearchRequest, MessageSearchResult
+from letta.schemas.message import Message, MessageCreate, MessageCreateType, MessageSearchRequest, MessageSearchResult
 from letta.schemas.passage import Passage
 from letta.schemas.run import Run as PydanticRun, RunUpdate
 from letta.schemas.source import BaseSource, Source
@@ -915,7 +917,7 @@ async def retrieve_agent_memory(
     return await server.get_agent_memory_async(agent_id=agent_id, actor=actor)
 
 
-@router.get("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="retrieve_core_memory_block")
+@router.get("/{agent_id}/core-memory/blocks/{block_label}", response_model=BlockResponse, operation_id="retrieve_core_memory_block")
 async def retrieve_block_for_agent(
     block_label: str,
     agent_id: AgentId,
@@ -930,7 +932,7 @@ async def retrieve_block_for_agent(
     return await server.agent_manager.get_block_with_label_async(agent_id=agent_id, block_label=block_label, actor=actor)
 
 
-@router.get("/{agent_id}/core-memory/blocks", response_model=list[Block], operation_id="list_core_memory_blocks")
+@router.get("/{agent_id}/core-memory/blocks", response_model=list[BlockResponse], operation_id="list_core_memory_blocks")
 async def list_blocks_for_agent(
     agent_id: AgentId,
     server: "SyncServer" = Depends(get_letta_server),
@@ -962,7 +964,7 @@ async def list_blocks_for_agent(
     )
 
 
-@router.patch("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="modify_core_memory_block")
+@router.patch("/{agent_id}/core-memory/blocks/{block_label}", response_model=BlockResponse, operation_id="modify_core_memory_block")
 async def modify_block_for_agent(
     block_label: str,
     agent_id: AgentId,
@@ -1394,7 +1396,7 @@ async def send_message(
 # noinspection PyInconsistentReturns
 @router.post(
     "/{agent_id}/messages/stream",
-    response_model=None,
+    response_model=LettaStreamingResponse,
     operation_id="create_agent_message_stream",
     responses={
         200: {
@@ -1902,3 +1904,63 @@ async def summarize_messages(
             status_code=status.HTTP_403_FORBIDDEN,
             detail="Summarization is not currently supported for this agent configuration. Please contact Letta support.",
         )
+
+
+class CaptureMessagesRequest(BaseModel):
+    provider: str
+    model: str
+    request_messages: list[dict[str, Any]]
+    response_dict: dict[str, Any]
+
+
+@router.post("/{agent_id}/messages/capture", response_model=str, operation_id="capture_messages", include_in_schema=False)
+async def capture_messages(
+    agent_id: AgentId,
+    request: CaptureMessagesRequest = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Capture a list of messages for an agent.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    agent = await server.agent_manager.get_agent_by_id_async(agent_id, actor, include_relationships=["multi_agent_group"])
+
+    messages_to_persist = []
+
+    # Input user messages
+    for message in request.request_messages:
+        if message["role"] == "user":
+            messages_to_persist.append(
+                Message(
+                    role=MessageRole.user,
+                    content=[(TextContent(text=message["content"]))],
+                    agent_id=agent_id,
+                    tool_calls=None,
+                    tool_call_id=None,
+                    created_at=get_utc_time(),
+                )
+            )
+
+    # Assistant response
+    messages_to_persist.append(
+        Message(
+            role=MessageRole.assistant,
+            content=[(TextContent(text=request.response_dict["content"]))],
+            agent_id=agent_id,
+            model=request.model,
+            tool_calls=None,
+            tool_call_id=None,
+            created_at=get_utc_time(),
+        )
+    )
+
+    response_messages = await server.message_manager.create_many_messages_async(messages_to_persist, actor=actor)
+
+    sleeptime_group = agent.multi_agent_group if agent.multi_agent_group and agent.multi_agent_group.manager_type == "sleeptime" else None
+    if sleeptime_group:
+        sleeptime_agent_loop = SleeptimeMultiAgentV4(agent_state=agent, actor=actor, group=sleeptime_group)
+        sleeptime_agent_loop.response_messages = response_messages
+        run_ids = await sleeptime_agent_loop.run_sleeptime_agents()
+
+    return JSONResponse({"success": True, "messages_created": len(response_messages), "run_ids": run_ids})

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

@@ -4,7 +4,7 @@ from fastapi import APIRouter, Body, Depends, HTTPException, Query
 
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentRelationships, AgentState
-from letta.schemas.block import BaseBlock, Block, BlockUpdate, CreateBlock
+from letta.schemas.block import BaseBlock, Block, BlockResponse, BlockUpdate, CreateBlock
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
 from letta.server.server import SyncServer
 from letta.utils import is_1_0_sdk_version
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 router = APIRouter(prefix="/blocks", tags=["blocks"])
 
 
-@router.get("/", response_model=List[Block], operation_id="list_blocks")
+@router.get("/", response_model=List[BlockResponse], operation_id="list_blocks")
 async def list_blocks(
     # query parameters
     label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
@@ -117,7 +117,7 @@ async def count_blocks(
     return await server.block_manager.size_async(actor=actor)
 
 
-@router.post("/", response_model=Block, operation_id="create_block")
+@router.post("/", response_model=BlockResponse, operation_id="create_block")
 async def create_block(
     create_block: CreateBlock = Body(...),
     server: SyncServer = Depends(get_letta_server),
@@ -128,7 +128,7 @@ async def create_block(
     return await server.block_manager.create_or_update_block_async(actor=actor, block=block)
 
 
-@router.patch("/{block_id}", response_model=Block, operation_id="modify_block")
+@router.patch("/{block_id}", response_model=BlockResponse, operation_id="modify_block")
 async def modify_block(
     block_id: BlockId,
     block_update: BlockUpdate = Body(...),
@@ -149,7 +149,7 @@ async def delete_block(
     await server.block_manager.delete_block_async(block_id=block_id, actor=actor)
 
 
-@router.get("/{block_id}", response_model=Block, operation_id="retrieve_block")
+@router.get("/{block_id}", response_model=BlockResponse, operation_id="retrieve_block")
 async def retrieve_block(
     block_id: BlockId,
     server: SyncServer = Depends(get_letta_server),
@@ -214,7 +214,7 @@ async def list_agents_for_block(
     return agents
 
 
-@router.patch("/{block_id}/identities/attach/{identity_id}", response_model=Block, operation_id="attach_identity_to_block")
+@router.patch("/{block_id}/identities/attach/{identity_id}", response_model=BlockResponse, operation_id="attach_identity_to_block")
 async def attach_identity_to_block(
     identity_id: str,
     block_id: BlockId,
@@ -233,7 +233,7 @@ async def attach_identity_to_block(
     return await server.block_manager.get_block_by_id_async(block_id=block_id, actor=actor)
 
 
-@router.patch("/{block_id}/identities/detach/{identity_id}", response_model=Block, operation_id="detach_identity_from_block")
+@router.patch("/{block_id}/identities/detach/{identity_id}", response_model=BlockResponse, operation_id="detach_identity_from_block")
 async def detach_identity_from_block(
     identity_id: str,
     block_id: BlockId,

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

@@ -284,3 +284,43 @@ async def reset_group_messages(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     await server.group_manager.reset_messages_async(group_id=group_id, actor=actor)
+
+
+@router.patch("/{group_id}/blocks/attach/{block_id}", response_model=None, operation_id="attach_block_to_group")
+async def attach_block_to_group(
+    block_id: str,
+    group_id: GroupId,
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Attach a block to a group.
+    This will add the block to the group and all agents within the group.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    await server.group_manager.attach_block_async(
+        group_id=group_id,
+        block_id=block_id,
+        actor=actor,
+    )
+    return None
+
+
+@router.patch("/{group_id}/blocks/detach/{block_id}", response_model=None, operation_id="detach_block_from_group")
+async def detach_block_from_group(
+    block_id: str,
+    group_id: GroupId,
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Detach a block from a group.
+    This will remove the block from the group and all agents within the group.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    await server.group_manager.detach_block_async(
+        group_id=group_id,
+        block_id=block_id,
+        actor=actor,
+    )
+    return None

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

@@ -4,7 +4,7 @@ from fastapi import APIRouter, Body, Depends, Header, Query
 
 from letta.orm.errors import NoResultFound, UniqueConstraintViolationError
 from letta.schemas.agent import AgentRelationships, AgentState
-from letta.schemas.block import Block
+from letta.schemas.block import Block, BlockResponse
 from letta.schemas.identity import (
     Identity,
     IdentityCreate,
@@ -188,7 +188,7 @@ async def list_agents_for_identity(
     )
 
 
-@router.get("/{identity_id}/blocks", response_model=List[Block], operation_id="list_blocks_for_identity")
+@router.get("/{identity_id}/blocks", response_model=List[BlockResponse], operation_id="list_blocks_for_identity")
 async def list_blocks_for_identity(
     identity_id: IdentityId,
     before: Optional[str] = Query(

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

@@ -0,0 +1,31 @@
+from fastapi import APIRouter, Body, Depends
+
+from letta.schemas.block import Block, BlockUpdate
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
+from letta.server.server import SyncServer
+from letta.validators import AgentId
+
+router = APIRouter(prefix="/_internal_agents", tags=["_internal_agents"])
+
+
+@router.patch("/{agent_id}/core-memory/blocks/{block_label}", response_model=Block, operation_id="modify_internal_core_memory_block")
+async def modify_block_for_agent(
+    block_label: str,
+    agent_id: AgentId,
+    block_update: BlockUpdate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Updates a core memory block of an agent.
+    """
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+
+    block = await server.agent_manager.modify_block_by_label_async(
+        agent_id=agent_id, block_label=block_label, block_update=block_update, actor=actor
+    )
+
+    # This should also trigger a system prompt change in the agent
+    await server.agent_manager.rebuild_system_prompt_async(agent_id=agent_id, actor=actor, force=True, update_timestamp=False)
+
+    return block

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

@@ -0,0 +1,177 @@
+from typing import TYPE_CHECKING, List, Literal, Optional
+
+from fastapi import APIRouter, Body, Depends, Query
+
+from letta.schemas.agent import AgentState
+from letta.schemas.block import Block, CreateBlock
+from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
+from letta.server.server import SyncServer
+from letta.utils import is_1_0_sdk_version
+from letta.validators import BlockId
+
+if TYPE_CHECKING:
+    pass
+
+router = APIRouter(prefix="/_internal_blocks", tags=["_internal_blocks"])
+
+
+@router.get("/", response_model=List[Block], operation_id="list_internal_blocks")
+async def list_blocks(
+    # query parameters
+    label: Optional[str] = Query(None, description="Labels to include (e.g. human, persona)"),
+    templates_only: bool = Query(False, description="Whether to include only templates"),
+    name: Optional[str] = Query(None, description="Name of the block"),
+    identity_id: Optional[str] = Query(None, description="Search agents by identifier id"),
+    identifier_keys: Optional[List[str]] = Query(None, description="Search agents by identifier keys"),
+    project_id: Optional[str] = Query(None, description="Search blocks by project id"),
+    limit: Optional[int] = Query(50, description="Number of blocks to return"),
+    before: Optional[str] = Query(
+        None,
+        description="Block ID cursor for pagination. Returns blocks that come before this block ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Block ID cursor for pagination. Returns blocks that come after this block ID in the specified sort order",
+    ),
+    order: Literal["asc", "desc"] = Query(
+        "asc", description="Sort order for blocks by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    label_search: Optional[str] = Query(
+        None,
+        description=("Search blocks by label. If provided, returns blocks that match this label. This is a full-text search on labels."),
+    ),
+    description_search: Optional[str] = Query(
+        None,
+        description=(
+            "Search blocks by description. If provided, returns blocks that match this description. "
+            "This is a full-text search on block descriptions."
+        ),
+    ),
+    value_search: Optional[str] = Query(
+        None,
+        description=("Search blocks by value. If provided, returns blocks that match this value."),
+    ),
+    connected_to_agents_count_gt: Optional[int] = Query(
+        None,
+        description=(
+            "Filter blocks by the number of connected agents. "
+            "If provided, returns blocks that have more than this number of connected agents."
+        ),
+    ),
+    connected_to_agents_count_lt: Optional[int] = Query(
+        None,
+        description=(
+            "Filter blocks by the number of connected agents. "
+            "If provided, returns blocks that have less than this number of connected agents."
+        ),
+    ),
+    connected_to_agents_count_eq: Optional[List[int]] = Query(
+        None,
+        description=(
+            "Filter blocks by the exact number of connected agents. "
+            "If provided, returns blocks that have exactly this number of connected agents."
+        ),
+    ),
+    show_hidden_blocks: bool | None = Query(
+        False,
+        include_in_schema=False,
+        description="If set to True, include blocks marked as hidden in the results.",
+    ),
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    return await server.block_manager.get_blocks_async(
+        actor=actor,
+        label=label,
+        is_template=templates_only,
+        value_search=value_search,
+        label_search=label_search,
+        description_search=description_search,
+        template_name=name,
+        identity_id=identity_id,
+        identifier_keys=identifier_keys,
+        project_id=project_id,
+        before=before,
+        connected_to_agents_count_gt=connected_to_agents_count_gt,
+        connected_to_agents_count_lt=connected_to_agents_count_lt,
+        connected_to_agents_count_eq=connected_to_agents_count_eq,
+        limit=limit,
+        after=after,
+        ascending=(order == "asc"),
+        show_hidden_blocks=show_hidden_blocks,
+    )
+
+
+@router.post("/", response_model=Block, operation_id="create_internal_block")
+async def create_block(
+    create_block: CreateBlock = Body(...),
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    block = Block(**create_block.model_dump())
+    return await server.block_manager.create_or_update_block_async(actor=actor, block=block)
+
+
+@router.delete("/{block_id}", operation_id="delete_internal_block")
+async def delete_block(
+    block_id: BlockId,
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    await server.block_manager.delete_block_async(block_id=block_id, actor=actor)
+
+
+@router.get("/{block_id}/agents", response_model=List[AgentState], operation_id="list_agents_for_internal_block")
+async def list_agents_for_block(
+    block_id: BlockId,
+    before: Optional[str] = Query(
+        None,
+        description="Agent ID cursor for pagination. Returns agents that come before this agent ID in the specified sort order",
+    ),
+    after: Optional[str] = Query(
+        None,
+        description="Agent ID cursor for pagination. Returns agents that come after this agent ID in the specified sort order",
+    ),
+    limit: Optional[int] = Query(50, description="Maximum number of agents to return"),
+    order: Literal["asc", "desc"] = Query(
+        "desc", description="Sort order for agents by creation time. 'asc' for oldest first, 'desc' for newest first"
+    ),
+    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    include_relationships: list[str] | None = Query(
+        None,
+        description=(
+            "Specify which relational fields (e.g., 'tools', 'sources', 'memory') to include in the response. "
+            "If not provided, all relationships are loaded by default. "
+            "Using this can optimize performance by reducing unnecessary joins."
+            "This is a legacy parameter, and no longer supported after 1.0.0 SDK versions."
+        ),
+    ),
+    include: List[str] = Query(
+        [],
+        description=("Specify which relational fields to include in the response. No relationships are included by default."),
+    ),
+    server: SyncServer = Depends(get_letta_server),
+    headers: HeaderParams = Depends(get_headers),
+):
+    """
+    Retrieves all agents associated with the specified 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)
+    if include_relationships is None and is_1_0_sdk_version(headers):
+        include_relationships = []  # don't default include all if using new SDK version
+    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,
+        include=include,
+        actor=actor,
+    )
+    return agents