letta-nightly 0.5.5.dev20241122170833__py3-none-any.whl → 0.6.0.dev20241204051808__py3-none-any.whl

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

@@ -1,23 +1,28 @@
 import asyncio
+import warnings
 from datetime import datetime
-from typing import Dict, List, Optional, Union
+from typing import List, Optional, Union
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
 from fastapi.responses import JSONResponse, StreamingResponse
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgentState
+from letta.schemas.block import (  # , BlockLabelUpdate, BlockLimitUpdate
+    Block,
+    BlockUpdate,
+    CreateBlock,
+)
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import (
     LegacyLettaMessage,
     LettaMessage,
     LettaMessageUnion,
 )
-from letta.schemas.letta_request import LettaRequest
+from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import (
     ArchivalMemorySummary,
-    BasicBlockMemory,
     ContextWindowOverview,
     CreateArchivalMemory,
     Memory,
@@ -30,7 +35,6 @@ from letta.schemas.tool import Tool
 from letta.server.rest_api.interface import StreamingServerInterface
 from letta.server.rest_api.utils import get_letta_server, sse_async_generator
 from letta.server.server import SyncServer
-from letta.utils import deduplicate
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -82,13 +86,6 @@ def create_agent(
     Create a new agent with the specified configuration.
     """
     actor = server.get_user_or_default(user_id=user_id)
-    agent.user_id = actor.id
-    # TODO: sarah make general
-    # TODO: eventually remove this
-    assert agent.memory is not None  # TODO: dont force this, can be None (use default human/person)
-    blocks = agent.memory.get_blocks()
-    agent.memory = BasicBlockMemory(blocks=blocks)
-
     return server.create_agent(agent, actor=actor)
 
 
@@ -195,6 +192,7 @@ def get_agent_in_context_messages(
     return server.get_in_context_messages(agent_id=agent_id)
 
 
+# TODO: remove? can also get with agent blocks
 @router.get("/{agent_id}/memory", response_model=Memory, operation_id="get_agent_memory")
 def get_agent_memory(
     agent_id: str,
@@ -208,21 +206,96 @@ def get_agent_memory(
     return server.get_agent_memory(agent_id=agent_id)
 
 
-@router.patch("/{agent_id}/memory", response_model=Memory, operation_id="update_agent_memory")
-def update_agent_memory(
+@router.get("/{agent_id}/memory/block/{block_label}", response_model=Block, operation_id="get_agent_memory_block")
+def get_agent_memory_block(
+    agent_id: str,
+    block_label: 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
+):
+    """
+    Retrieve a memory block from an agent.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    block_id = server.blocks_agents_manager.get_block_id_for_label(agent_id=agent_id, block_label=block_label)
+    return server.block_manager.get_block_by_id(block_id, actor=actor)
+
+
+@router.get("/{agent_id}/memory/block", response_model=List[Block], operation_id="get_agent_memory_blocks")
+def get_agent_memory_blocks(
+    agent_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
+):
+    """
+    Retrieve the memory blocks of a specific agent.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+    block_ids = server.blocks_agents_manager.list_block_ids_for_agent(agent_id=agent_id)
+    return [server.block_manager.get_block_by_id(block_id, actor=actor) for block_id in block_ids]
+
+
+@router.post("/{agent_id}/memory/block", response_model=Memory, operation_id="add_agent_memory_block")
+def add_agent_memory_block(
     agent_id: str,
-    request: Dict = Body(...),
+    create_block: CreateBlock = Body(...),
     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
 ):
     """
-    Update the core memory of a specific agent.
-    This endpoint accepts new memory contents (human and persona) and updates the core memory of the agent identified by the user ID and agent ID.
+    Creates a memory block and links it to the agent.
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    memory = server.update_agent_core_memory(user_id=actor.id, agent_id=agent_id, new_memory_contents=request)
-    return memory
+    # Copied from POST /blocks
+    block_req = Block(**create_block.model_dump())
+    block = server.block_manager.create_or_update_block(actor=actor, block=block_req)
+
+    # Link the block to the agent
+    updated_memory = server.link_block_to_agent_memory(user_id=actor.id, agent_id=agent_id, block_id=block.id)
+
+    return updated_memory
+
+
+@router.delete("/{agent_id}/memory/block/{block_label}", response_model=Memory, operation_id="remove_agent_memory_block_by_label")
+def remove_agent_memory_block(
+    agent_id: str,
+    # TODO should this be block_id, or the label?
+    # I think label is OK since it's user-friendly + guaranteed to be unique within a Memory object
+    block_label: 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
+):
+    """
+    Removes a memory block from an agent by unlnking it. If the block is not linked to any other agent, it is deleted.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    # Unlink the block from the agent
+    updated_memory = server.unlink_block_from_agent_memory(user_id=actor.id, agent_id=agent_id, block_label=block_label)
+
+    return updated_memory
+
+
+@router.patch("/{agent_id}/memory/block/{block_label}", response_model=Block, operation_id="update_agent_memory_block_by_label")
+def update_agent_memory_block(
+    agent_id: str,
+    block_label: str,
+    update_block: BlockUpdate = Body(...),
+    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
+):
+    """
+    Removes a memory block from an agent by unlnking it. If the block is not linked to any other agent, it is deleted.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+
+    # get the block_id from the label
+    block_id = server.blocks_agents_manager.get_block_id_for_label(agent_id=agent_id, block_label=block_label)
+
+    # update the block
+    return server.block_manager.update_block(block_id=block_id, block_update=update_block, actor=actor)
 
 
 @router.get("/{agent_id}/memory/recall", response_model=RecallMemorySummary, operation_id="get_agent_recall_memory_summary")
@@ -318,17 +391,13 @@ def get_agent_messages(
     limit: int = Query(10, description="Maximum number of messages to retrieve."),
     msg_object: bool = Query(False, description="If true, returns Message objects. If false, return LettaMessage objects."),
     # Flags to support the use of AssistantMessage message types
-    use_assistant_message: bool = Query(
-        False,
-        description="[Only applicable if msg_object is False] If true, returns AssistantMessage objects when the agent calls a designated message tool. If false, return FunctionCallMessage objects for all tool calls.",
-    ),
-    assistant_message_function_name: str = Query(
+    assistant_message_tool_name: str = Query(
         DEFAULT_MESSAGE_TOOL,
-        description="[Only applicable if use_assistant_message is True] The name of the designated message tool.",
+        description="The name of the designated message tool.",
     ),
-    assistant_message_function_kwarg: str = Query(
+    assistant_message_tool_kwarg: str = Query(
         DEFAULT_MESSAGE_TOOL_KWARG,
-        description="[Only applicable if use_assistant_message is True] The name of the message argument in the designated message tool.",
+        description="The name of the message argument in the designated message tool.",
     ),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
@@ -344,9 +413,8 @@ def get_agent_messages(
         limit=limit,
         reverse=True,
         return_message_object=msg_object,
-        use_assistant_message=use_assistant_message,
-        assistant_message_function_name=assistant_message_function_name,
-        assistant_message_function_kwarg=assistant_message_function_kwarg,
+        assistant_message_tool_name=assistant_message_tool_name,
+        assistant_message_tool_kwarg=assistant_message_tool_kwarg,
     )
 
 
@@ -366,43 +434,69 @@ def update_message(
 
 @router.post(
     "/{agent_id}/messages",
+    response_model=LettaResponse,
+    operation_id="create_agent_message",
+)
+async def send_message(
+    agent_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    request: LettaRequest = Body(...),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    """
+    Process a user message and return the agent's response.
+    This endpoint accepts a message from a user and processes it through the agent.
+    """
+    actor = server.get_user_or_default(user_id=user_id)
+    result = await send_message_to_agent(
+        server=server,
+        agent_id=agent_id,
+        user_id=actor.id,
+        messages=request.messages,
+        stream_steps=False,
+        stream_tokens=False,
+        # Support for AssistantMessage
+        assistant_message_tool_name=request.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+    )
+    return result
+
+
+@router.post(
+    "/{agent_id}/messages/stream",
     response_model=None,
     operation_id="create_agent_message",
     responses={
         200: {
             "description": "Successful response",
             "content": {
-                "application/json": {"$ref": "#/components/schemas/LettaResponse"},  # Use model_json_schema() instead of model directly
                 "text/event-stream": {"description": "Server-Sent Events stream"},
             },
         }
     },
 )
-async def send_message(
+async def send_message_streaming(
     agent_id: str,
     server: SyncServer = Depends(get_letta_server),
-    request: LettaRequest = Body(...),
+    request: LettaStreamingRequest = Body(...),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
     Process a user message and return the agent's response.
     This endpoint accepts a message from a user and processes it through the agent.
-    It can optionally stream the response if 'stream_steps' or 'stream_tokens' is set to True.
+    It will stream the steps of the response always, and stream the tokens if 'stream_tokens' is set to True.
     """
     actor = server.get_user_or_default(user_id=user_id)
-
     result = await send_message_to_agent(
         server=server,
         agent_id=agent_id,
         user_id=actor.id,
         messages=request.messages,
-        stream_steps=request.stream_steps,
+        stream_steps=True,
         stream_tokens=request.stream_tokens,
-        return_message_object=request.return_message_object,
         # Support for AssistantMessage
-        use_assistant_message=request.use_assistant_message,
-        assistant_message_function_name=request.assistant_message_function_name,
-        assistant_message_function_kwarg=request.assistant_message_function_kwarg,
+        assistant_message_tool_name=request.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
     )
     return result
 
@@ -417,13 +511,11 @@ async def send_message_to_agent(
     stream_steps: bool,
     stream_tokens: bool,
     # related to whether or not we return `LettaMessage`s or `Message`s
-    return_message_object: bool,  # Should be True for Python Client, False for REST API
     chat_completion_mode: bool = False,
     timestamp: Optional[datetime] = None,
     # Support for AssistantMessage
-    use_assistant_message: bool = False,
-    assistant_message_function_name: str = DEFAULT_MESSAGE_TOOL,
-    assistant_message_function_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
+    assistant_message_tool_name: str = DEFAULT_MESSAGE_TOOL,
+    assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
 ) -> Union[StreamingResponse, LettaResponse]:
     """Split off into a separate function so that it can be imported in the /chat/completion proxy."""
 
@@ -440,13 +532,16 @@ async def send_message_to_agent(
 
         # Get the generator object off of the agent's streaming interface
         # This will be attached to the POST SSE request used under-the-hood
-        letta_agent = server._get_or_load_agent(agent_id=agent_id)
+        # letta_agent = server.load_agent(agent_id=agent_id)
+        letta_agent = server.load_agent(agent_id=agent_id)
 
         # Disable token streaming if not OpenAI
         # TODO: cleanup this logic
         llm_config = letta_agent.agent_state.llm_config
-        if llm_config.model_endpoint_type != "openai" or "inference.memgpt.ai" in llm_config.model_endpoint:
-            print("Warning: token streaming is only supported for OpenAI models. Setting to False.")
+        if stream_tokens and (llm_config.model_endpoint_type != "openai" or "inference.memgpt.ai" in llm_config.model_endpoint):
+            warnings.warn(
+                "Token streaming is only supported for models with type 'openai' or `inference.memgpt.ai` in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
+            )
             stream_tokens = False
 
         # Create a new interface per request
@@ -464,9 +559,8 @@ async def send_message_to_agent(
         # streaming_interface.function_call_legacy_mode = stream
 
         # Allow AssistantMessage is desired by client
-        streaming_interface.use_assistant_message = use_assistant_message
-        streaming_interface.assistant_message_function_name = assistant_message_function_name
-        streaming_interface.assistant_message_function_kwarg = assistant_message_function_kwarg
+        streaming_interface.assistant_message_tool_name = assistant_message_tool_name
+        streaming_interface.assistant_message_tool_kwarg = assistant_message_tool_kwarg
 
         # Related to JSON buffer reader
         streaming_interface.inner_thoughts_in_kwargs = (
@@ -481,14 +575,11 @@ async def send_message_to_agent(
                 user_id=user_id,
                 agent_id=agent_id,
                 messages=messages,
+                interface=streaming_interface,
             )
         )
 
         if stream_steps:
-            if return_message_object:
-                # TODO implement returning `Message`s in a stream, not just `LettaMessage` format
-                raise NotImplementedError
-
             # return a stream
             return StreamingResponse(
                 sse_async_generator(
@@ -518,14 +609,7 @@ async def send_message_to_agent(
             # If we want to convert these to Message, we can use the attached IDs
             # NOTE: we will need to de-duplicate the Messsage IDs though (since Assistant->Inner+Func_Call)
             # TODO: eventually update the interface to use `Message` and `MessageChunk` (new) inside the deque instead
-            if return_message_object:
-                message_ids = [m.id for m in filtered_stream]
-                message_ids = deduplicate(message_ids)
-                message_objs = [server.get_agent_message(agent_id=agent_id, message_id=m_id) for m_id in message_ids]
-                message_objs = [m for m in message_objs if m is not None]
-                return LettaResponse(messages=message_objs, usage=usage)
-            else:
-                return LettaResponse(messages=filtered_stream, usage=usage)
+            return LettaResponse(messages=filtered_stream, usage=usage)
 
     except HTTPException:
         raise

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

@@ -3,7 +3,8 @@ from typing import TYPE_CHECKING, List, Optional
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.orm.errors import NoResultFound
-from letta.schemas.block import Block, BlockCreate, BlockUpdate
+from letta.schemas.block import Block, BlockUpdate, CreateBlock
+from letta.schemas.memory import Memory
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 
@@ -28,7 +29,7 @@ def list_blocks(
 
 @router.post("/", response_model=Block, operation_id="create_memory_block")
 def create_block(
-    create_block: BlockCreate = Body(...),
+    create_block: CreateBlock = Body(...),
     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
 ):
@@ -40,12 +41,12 @@ def create_block(
 @router.patch("/{block_id}", response_model=Block, operation_id="update_memory_block")
 def update_block(
     block_id: str,
-    updated_block: BlockUpdate = Body(...),
+    update_block: BlockUpdate = Body(...),
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     actor = server.get_user_or_default(user_id=user_id)
-    return server.block_manager.update_block(block_id=block_id, block_update=updated_block, actor=actor)
+    return server.block_manager.update_block(block_id=block_id, block_update=update_block, actor=actor)
 
 
 @router.delete("/{block_id}", response_model=Block, operation_id="delete_memory_block")
@@ -64,8 +65,52 @@ def get_block(
     server: SyncServer = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
+    print("call get block", block_id)
     actor = server.get_user_or_default(user_id=user_id)
     try:
-        return server.block_manager.get_block_by_id(block_id=block_id, actor=actor)
+        block = server.block_manager.get_block_by_id(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")
+
+
+@router.patch("/{block_id}/attach", response_model=Block, operation_id="update_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.get_user_or_default(user_id=user_id)
+
+    block = server.block_manager.get_block_by_id(block_id=block_id, actor=actor)
+    if block is None:
+        raise HTTPException(status_code=404, detail="Block not found")
+
+    server.blocks_agents_manager.add_block_to_agent(agent_id=agent_id, block_id=block_id, block_label=block.label)
+    return block
+
+
+@router.patch("/{block_id}/detach", response_model=Memory, operation_id="update_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.get_user_or_default(user_id=user_id)
+
+    block = server.block_manager.get_block_by_id(block_id=block_id, actor=actor)
+    if block is None:
+        raise HTTPException(status_code=404, detail="Block not found")
+    # Link the block to the agent
+    server.blocks_agents_manager.remove_block_with_id_from_agent(agent_id=agent_id, block_id=block_id)
+    return block

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

@@ -0,0 +1,127 @@
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, Query
+
+from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
+from letta.schemas.sandbox_config import SandboxConfigCreate, SandboxConfigUpdate
+from letta.schemas.sandbox_config import SandboxEnvironmentVariable as PydanticEnvVar
+from letta.schemas.sandbox_config import (
+    SandboxEnvironmentVariableCreate,
+    SandboxEnvironmentVariableUpdate,
+    SandboxType,
+)
+from letta.server.rest_api.utils import get_letta_server, get_user_id
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/sandbox-config", tags=["sandbox-config"])
+
+
+### Sandbox Config Routes
+
+
+@router.post("/", response_model=PydanticSandboxConfig)
+def create_sandbox_config(
+    config_create: SandboxConfigCreate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+
+    return server.sandbox_config_manager.create_or_update_sandbox_config(config_create, actor)
+
+
+@router.post("/e2b/default", response_model=PydanticSandboxConfig)
+def create_default_e2b_sandbox_config(
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.E2B, actor=actor)
+
+
+@router.post("/local/default", response_model=PydanticSandboxConfig)
+def create_default_local_sandbox_config(
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.get_or_create_default_sandbox_config(sandbox_type=SandboxType.LOCAL, actor=actor)
+
+
+@router.patch("/{sandbox_config_id}", response_model=PydanticSandboxConfig)
+def update_sandbox_config(
+    sandbox_config_id: str,
+    config_update: SandboxConfigUpdate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.update_sandbox_config(sandbox_config_id, config_update, actor)
+
+
+@router.delete("/{sandbox_config_id}", status_code=204)
+def delete_sandbox_config(
+    sandbox_config_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    server.sandbox_config_manager.delete_sandbox_config(sandbox_config_id, actor)
+
+
+@router.get("/", response_model=List[PydanticSandboxConfig])
+def list_sandbox_configs(
+    limit: int = Query(1000, description="Number of results to return"),
+    cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.list_sandbox_configs(actor, limit=limit, cursor=cursor)
+
+
+### Sandbox Environment Variable Routes
+
+
+@router.post("/{sandbox_config_id}/environment-variable", response_model=PydanticEnvVar)
+def create_sandbox_env_var(
+    sandbox_config_id: str,
+    env_var_create: SandboxEnvironmentVariableCreate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.create_sandbox_env_var(env_var_create, sandbox_config_id, actor)
+
+
+@router.patch("/environment-variable/{env_var_id}", response_model=PydanticEnvVar)
+def update_sandbox_env_var(
+    env_var_id: str,
+    env_var_update: SandboxEnvironmentVariableUpdate,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.update_sandbox_env_var(env_var_id, env_var_update, actor)
+
+
+@router.delete("/environment-variable/{env_var_id}", status_code=204)
+def delete_sandbox_env_var(
+    env_var_id: str,
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    server.sandbox_config_manager.delete_sandbox_env_var(env_var_id, actor)
+
+
+@router.get("/{sandbox_config_id}/environment-variable", response_model=List[PydanticEnvVar])
+def list_sandbox_env_vars(
+    sandbox_config_id: str,
+    limit: int = Query(1000, description="Number of results to return"),
+    cursor: Optional[str] = Query(None, description="Pagination cursor to fetch the next set of results"),
+    server: SyncServer = Depends(get_letta_server),
+    user_id: str = Depends(get_user_id),
+):
+    actor = server.get_user_or_default(user_id=user_id)
+    return server.sandbox_config_manager.list_sandbox_env_vars(sandbox_config_id, actor, limit=limit, cursor=cursor)

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

@@ -37,7 +37,10 @@ def get_source(
     """
     actor = server.get_user_or_default(user_id=user_id)
 
-    return server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    source = server.source_manager.get_source_by_id(source_id=source_id, actor=actor)
+    if not source:
+        raise HTTPException(status_code=404, detail=f"Source with id={source_id} not found.")
+    return source
 
 
 @router.get("/name/{source_name}", response_model=str, operation_id="get_source_id_by_name")
@@ -52,6 +55,8 @@ def get_source_id_by_name(
     actor = server.get_user_or_default(user_id=user_id)
 
     source = server.source_manager.get_source_by_name(source_name=source_name, actor=actor)
+    if not source:
+        raise HTTPException(status_code=404, detail=f"Source with name={source_name} not found.")
     return source.id
 
 
@@ -94,6 +99,8 @@ def update_source(
     Update the name or documentation of an existing data source.
     """
     actor = server.get_user_or_default(user_id=user_id)
+    if not server.source_manager.get_source_by_id(source_id=source_id, actor=actor):
+        raise HTTPException(status_code=404, detail=f"Source with id={source_id} does not exist.")
     return server.source_manager.update_source(source_id=source_id, source_update=source, actor=actor)