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

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

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

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import List, Literal, Optional
 
 from fastapi import APIRouter, Depends, Query
@@ -55,13 +56,25 @@ async def list_runs(
     order: Literal["asc", "desc"] = Query(
         "desc", description="Sort order for runs by creation time. 'asc' for oldest first, 'desc' for newest first"
     ),
-    order_by: Literal["created_at"] = Query("created_at", description="Field to sort by"),
+    order_by: Literal["created_at", "duration"] = Query("created_at", description="Field to sort by"),
     active: bool = Query(False, description="Filter for active runs."),
     ascending: bool = Query(
         False,
         description="Whether to sort agents oldest to newest (True) or newest to oldest (False, default). Deprecated in favor of order field.",
         deprecated=True,
     ),
+    project_id: Optional[str] = Query(None, description="Filter runs by project ID."),
+    duration_percentile: Optional[int] = Query(
+        None, description="Filter runs by duration percentile (1-100). Returns runs slower than this percentile."
+    ),
+    duration_value: Optional[int] = Query(
+        None, description="Duration value in nanoseconds for filtering. Must be used with duration_operator."
+    ),
+    duration_operator: Optional[Literal["gt", "lt", "eq"]] = Query(
+        None, description="Comparison operator for duration filter: 'gt' (greater than), 'lt' (less than), 'eq' (equals)."
+    ),
+    start_date: Optional[datetime] = Query(None, description="Filter runs created on or after this date (ISO 8601 format)."),
+    end_date: Optional[datetime] = Query(None, description="Filter runs created on or before this date (ISO 8601 format)."),
     headers: HeaderParams = Depends(get_headers),
 ):
     """
@@ -89,6 +102,11 @@ async def list_runs(
     # Convert string statuses to RunStatus enum
     parsed_statuses = convert_statuses_to_enum(statuses)
 
+    # Create duration filter dict if both parameters provided
+    duration_filter = None
+    if duration_value is not None and duration_operator is not None:
+        duration_filter = {"value": duration_value, "operator": duration_operator}
+
     runs = await runs_manager.list_runs(
         actor=actor,
         agent_ids=agent_ids,
@@ -103,5 +121,11 @@ async def list_runs(
         step_count=step_count,
         step_count_operator=step_count_operator,
         tools_used=tools_used,
+        project_id=project_id,
+        order_by=order_by,
+        duration_percentile=duration_percentile,
+        duration_filter=duration_filter,
+        start_date=start_date,
+        end_date=end_date,
     )
     return runs

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

@@ -23,7 +23,6 @@ from letta.server.rest_api.streaming_response import (
     cancellation_aware_stream_wrapper,
 )
 from letta.server.server import SyncServer
-from letta.services.lettuce import LettuceClient
 from letta.services.run_manager import RunManager
 from letta.settings import settings
 
@@ -150,26 +149,7 @@ async def retrieve_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-
-    run = await runs_manager.get_run_by_id(run_id=run_id, actor=actor)
-
-    use_lettuce = run.metadata and run.metadata.get("lettuce")
-    if use_lettuce and run.status not in [RunStatus.completed, RunStatus.failed, RunStatus.cancelled]:
-        lettuce_client = await LettuceClient.create()
-        status = await lettuce_client.get_status(run_id=run_id)
-
-        # Map the status to our enum
-        run_status = run.status
-        if status == "RUNNING":
-            run_status = RunStatus.running
-        elif status == "COMPLETED":
-            run_status = RunStatus.completed
-        elif status == "FAILED":
-            run_status = RunStatus.failed
-        elif status == "CANCELLED":
-            run_status = RunStatus.cancelled
-        run.status = run_status
-    return run
+    return await runs_manager.get_run_with_status(run_id=run_id, actor=actor)
 
 
 RunMessagesResponse = Annotated[
@@ -276,7 +256,7 @@ async def delete_run(
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
     runs_manager = RunManager()
-    return await runs_manager.delete_run_by_id(run_id=run_id, actor=actor)
+    return await runs_manager.delete_run(run_id=run_id, actor=actor)
 
 
 @router.post(

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

@@ -7,6 +7,7 @@ from httpx import ConnectError, HTTPStatusError
 from pydantic import BaseModel, Field
 from starlette.responses import StreamingResponse
 
+from letta.constants import DEFAULT_GENERATE_TOOL_MODEL_HANDLE
 from letta.errors import (
     LettaInvalidArgumentError,
     LettaInvalidMCPSchemaError,
@@ -817,7 +818,7 @@ async def generate_tool_from_prompt(
     Generate a tool from the given user prompt.
     """
     actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
-    llm_config = await server.get_cached_llm_config_async(actor=actor, handle=request.handle or "anthropic/claude-3-5-sonnet-20240620")
+    llm_config = await server.get_cached_llm_config_async(actor=actor, handle=request.handle or DEFAULT_GENERATE_TOOL_MODEL_HANDLE)
     formatted_prompt = (
         f"Generate a python function named {request.tool_name} using the instructions below "
         + (f"based on this starter code: \n\n```\n{request.starter_code}\n```\n\n" if request.starter_code else "\n")
@@ -867,12 +868,22 @@ async def generate_tool_from_prompt(
     response = llm_client.convert_response_to_chat_completion(response_data, input_messages, llm_config)
     output = json.loads(response.choices[0].message.tool_calls[0].function.arguments)
     pip_requirements = [PipRequirement(name=k, version=v or None) for k, v in json.loads(output["pip_requirements_json"]).items()]
+
+    # Derive JSON schema from the generated source code
+    try:
+        json_schema = derive_openai_json_schema(source_code=output["raw_source_code"])
+    except Exception as e:
+        raise LettaInvalidArgumentError(
+            message=f"Failed to generate JSON schema for tool '{request.tool_name}': {e}", argument_name="tool_name"
+        )
+
     return GenerateToolOutput(
         tool=Tool(
             name=request.tool_name,
             source_type="python",
             source_code=output["raw_source_code"],
             pip_requirements=pip_requirements,
+            json_schema=json_schema,
         ),
         sample_args=json.loads(output["sample_args_json"]),
         response=response.choices[0].message.content,

letta/server/server.py

@@ -304,9 +304,8 @@ class SyncServer(object):
         if model_settings.openrouter_api_key:
             self._enabled_providers.append(
                 OpenRouterProvider(
-                    name="openrouter",
+                    name=model_settings.openrouter_handle_base if model_settings.openrouter_handle_base else "openrouter",
                     api_key=model_settings.openrouter_api_key,
-                    handle_base=model_settings.openrouter_handle_base,
                 )
             )
 
@@ -415,21 +414,38 @@ class SyncServer(object):
         actor: User,
     ) -> AgentState:
         if request.llm_config is None:
+            additional_config_params = {}
             if request.model is None:
                 if settings.default_llm_handle is None:
                     raise LettaInvalidArgumentError("Must specify either model or llm_config in request", argument_name="model")
                 else:
-                    request.model = settings.default_llm_handle
+                    handle = settings.default_llm_handle
+            else:
+                if isinstance(request.model, str):
+                    handle = request.model
+                elif isinstance(request.model, list):
+                    raise LettaInvalidArgumentError("Multiple models are not supported yet")
+                else:
+                    # EXTREMELEY HACKY, TEMPORARY WORKAROUND
+                    handle = f"{request.model.provider}/{request.model.model}"
+                    # TODO: figure out how to override various params
+                    additional_config_params = request.model._to_legacy_config_params()
+
             config_params = {
-                "handle": request.model,
+                "handle": handle,
                 "context_window_limit": request.context_window_limit,
                 "max_tokens": request.max_tokens,
                 "max_reasoning_tokens": request.max_reasoning_tokens,
                 "enable_reasoner": request.enable_reasoner,
             }
+            config_params.update(additional_config_params)
             log_event(name="start get_cached_llm_config", attributes=config_params)
             request.llm_config = await self.get_cached_llm_config_async(actor=actor, **config_params)
             log_event(name="end get_cached_llm_config", attributes=config_params)
+            if request.model and isinstance(request.model, str):
+                assert request.llm_config.handle == request.model, (
+                    f"LLM config handle {request.llm_config.handle} does not match request handle {request.model}"
+                )
 
         if request.reasoning is None:
             request.reasoning = request.llm_config.enable_reasoner or request.llm_config.put_inner_thoughts_in_kwargs

letta/services/agent_manager.py

@@ -411,9 +411,6 @@ class AgentManager:
         if agent_create.include_multi_agent_tools:
             tool_names |= calculate_multi_agent_tools()
 
-        # take out the deprecated tool names
-        tool_names.difference_update(set(DEPRECATED_LETTA_TOOLS))
-
         supplied_ids = set(agent_create.tool_ids or [])
 
         source_ids = agent_create.source_ids or []
@@ -1568,7 +1565,7 @@ class AgentManager:
             actor: User performing the action
 
         Raises:
-            ValueError: If either agent or source doesn't exist
+            NoResultFound: If either agent or source doesn't exist or actor lacks permission to access them
             IntegrityError: If the source is already attached to the agent
         """
 
@@ -1576,6 +1573,9 @@ class AgentManager:
             # Verify both agent and source exist and user has permission to access them
             agent = await AgentModel.read_async(db_session=session, identifier=agent_id, actor=actor)
 
+            # Verify the actor has permission to access the source
+            await SourceModel.read_async(db_session=session, identifier=source_id, actor=actor)
+
             # The _process_relationship helper already handles duplicate checking via unique constraint
             await _process_relationship_async(
                 session=session,

letta/services/archive_manager.py

@@ -14,6 +14,7 @@ from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import PrimitiveType, VectorDBProvider
 from letta.schemas.user import User as PydanticUser
 from letta.server.db import db_registry
+from letta.services.helpers.agent_manager_helper import validate_agent_exists_async
 from letta.settings import DatabaseChoice, settings
 from letta.utils import enforce_types
 from letta.validators import raise_on_invalid_id
@@ -130,6 +131,9 @@ class ArchiveManager:
             ]
 
         async with db_registry.async_session() as session:
+            if agent_id:
+                await validate_agent_exists_async(session, agent_id, actor)
+
             archives = await ArchiveModel.list_async(
                 db_session=session,
                 before=before,
@@ -157,6 +161,12 @@ class ArchiveManager:
     ) -> None:
         """Attach an agent to an archive."""
         async with db_registry.async_session() as session:
+            # Verify agent exists and user has access to it
+            await validate_agent_exists_async(session, agent_id, actor)
+
+            # Verify archive exists and user has access to it
+            await ArchiveModel.read_async(db_session=session, identifier=archive_id, actor=actor)
+
             # Check if relationship already exists
             existing = await session.execute(
                 select(ArchivesAgents).where(
@@ -194,6 +204,12 @@ class ArchiveManager:
     ) -> None:
         """Detach an agent from an archive."""
         async with db_registry.async_session() as session:
+            # Verify agent exists and user has access to it
+            await validate_agent_exists_async(session, agent_id, actor)
+
+            # Verify archive exists and user has access to it
+            await ArchiveModel.read_async(db_session=session, identifier=archive_id, actor=actor)
+
             # Delete the relationship directly
             result = await session.execute(
                 delete(ArchivesAgents).where(

letta/services/group_manager.py

@@ -5,8 +5,10 @@ from sqlalchemy import and_, asc, delete, desc, or_, select
 from sqlalchemy.orm import Session
 
 from letta.orm.agent import Agent as AgentModel
+from letta.orm.block import Block
 from letta.orm.errors import NoResultFound
 from letta.orm.group import Group as GroupModel
+from letta.orm.groups_blocks import GroupsBlocks
 from letta.orm.message import Message as MessageModel
 from letta.otel.tracing import trace_method
 from letta.schemas.enums import PrimitiveType
@@ -410,6 +412,48 @@ class GroupManager:
                 for block in blocks:
                     session.add(BlocksAgents(agent_id=manager_agent.id, block_id=block.id, block_label=block.label))
 
+    @enforce_types
+    @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
+    async def attach_block_async(self, group_id: str, block_id: str, actor: PydanticUser) -> None:
+        """Attach a block to a group."""
+        async with db_registry.async_session() as session:
+            # Verify group exists and user has access
+            await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
+
+            # Verify block exists AND user has access to it
+            await Block.read_async(db_session=session, identifier=block_id, actor=actor)
+
+            # Check if block is already attached to the group
+            check_query = select(GroupsBlocks).where(and_(GroupsBlocks.group_id == group_id, GroupsBlocks.block_id == block_id))
+            result = await session.execute(check_query)
+            if result.scalar_one_or_none():
+                # Block already attached, no-op
+                return
+
+            # Add block to group
+            session.add(GroupsBlocks(group_id=group_id, block_id=block_id))
+            await session.commit()
+
+    @enforce_types
+    @trace_method
+    @raise_on_invalid_id(param_name="group_id", expected_prefix=PrimitiveType.GROUP)
+    @raise_on_invalid_id(param_name="block_id", expected_prefix=PrimitiveType.BLOCK)
+    async def detach_block_async(self, group_id: str, block_id: str, actor: PydanticUser) -> None:
+        """Detach a block from a group."""
+        async with db_registry.async_session() as session:
+            # Verify group exists and user has access
+            await GroupModel.read_async(db_session=session, identifier=group_id, actor=actor)
+
+            # Verify block exists AND user has access to it
+            await Block.read_async(db_session=session, identifier=block_id, actor=actor)
+
+            # Remove block from group
+            delete_group_block = delete(GroupsBlocks).where(and_(GroupsBlocks.group_id == group_id, GroupsBlocks.block_id == block_id))
+            await session.execute(delete_group_block)
+            await session.commit()
+
     @staticmethod
     def ensure_buffer_length_range_valid(
         max_value: Optional[int],

letta/services/helpers/run_manager_helper.py

@@ -37,7 +37,7 @@ async def _apply_pagination_async(
                     RunModel.id,
                     after_sort_value,
                     after_id,
-                    forward=ascending,
+                    forward=not ascending,
                     nulls_last=sort_nulls_last,
                 )
             )
@@ -55,7 +55,7 @@ async def _apply_pagination_async(
                     RunModel.id,
                     before_sort_value,
                     before_id,
-                    forward=not ascending,
+                    forward=ascending,
                     nulls_last=sort_nulls_last,
                 )
             )