letta-nightly 0.6.9.dev20250116104035__py3-none-any.whl → 0.6.9.dev20250116195713__py3-none-any.whl

letta/schemas/tool.py

@@ -2,13 +2,17 @@ from typing import Any, Dict, List, Optional
 
 from pydantic import Field, model_validator
 
-from letta.constants import COMPOSIO_TOOL_TAG_NAME, FUNCTION_RETURN_CHAR_LIMIT, LETTA_CORE_TOOL_MODULE_NAME
+from letta.constants import (
+    COMPOSIO_TOOL_TAG_NAME,
+    FUNCTION_RETURN_CHAR_LIMIT,
+    LETTA_CORE_TOOL_MODULE_NAME,
+    LETTA_MULTI_AGENT_TOOL_MODULE_NAME,
+)
 from letta.functions.functions import derive_openai_json_schema, get_json_schema_from_module
 from letta.functions.helpers import generate_composio_tool_wrapper, generate_langchain_tool_wrapper
 from letta.functions.schema_generator import generate_schema_from_args_schema_v2
 from letta.orm.enums import ToolType
 from letta.schemas.letta_base import LettaBase
-from letta.schemas.openai.chat_completions import ToolCall
 
 
 class BaseTool(LettaBase):
@@ -32,7 +36,6 @@ class Tool(BaseTool):
     tool_type: ToolType = Field(ToolType.CUSTOM, description="The type of the tool.")
     description: Optional[str] = Field(None, description="The description of the tool.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
-    module: Optional[str] = Field(None, description="The module of the function.")
     organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the tool.")
     name: Optional[str] = Field(None, description="The name of the function.")
     tags: List[str] = Field([], description="Metadata tags.")
@@ -66,6 +69,9 @@ class Tool(BaseTool):
         elif self.tool_type in {ToolType.LETTA_CORE, ToolType.LETTA_MEMORY_CORE}:
             # If it's letta core tool, we generate the json_schema on the fly here
             self.json_schema = get_json_schema_from_module(module_name=LETTA_CORE_TOOL_MODULE_NAME, function_name=self.name)
+        elif self.tool_type in {ToolType.LETTA_MULTI_AGENT_CORE}:
+            # If it's letta multi-agent tool, we also generate the json_schema on the fly here
+            self.json_schema = get_json_schema_from_module(module_name=LETTA_MULTI_AGENT_TOOL_MODULE_NAME, function_name=self.name)
 
         # Derive name from the JSON schema if not provided
         if not self.name:
@@ -81,24 +87,11 @@ class Tool(BaseTool):
 
         return self
 
-    def to_dict(self):
-        """
-        Convert tool into OpenAI representation.
-        """
-        return vars(
-            ToolCall(
-                tool_id=self.id,
-                tool_call_type="function",
-                function=self.module,
-            )
-        )
-
 
 class ToolCreate(LettaBase):
     name: Optional[str] = Field(None, description="The name of the function (auto-generated from source_code if not provided).")
     description: Optional[str] = Field(None, description="The description of the tool.")
     tags: List[str] = Field([], description="Metadata tags.")
-    module: Optional[str] = Field(None, description="The source code of the function.")
     source_code: str = Field(..., description="The source code of the function.")
     source_type: str = Field("python", description="The source type of the function.")
     json_schema: Optional[Dict] = Field(
@@ -212,7 +205,6 @@ class ToolUpdate(LettaBase):
     description: Optional[str] = Field(None, description="The description of the tool.")
     name: Optional[str] = Field(None, description="The name of the function.")
     tags: Optional[List[str]] = Field(None, description="Metadata tags.")
-    module: Optional[str] = Field(None, description="The source code of the function.")
     source_code: Optional[str] = Field(None, description="The source code of the function.")
     source_type: Optional[str] = Field(None, description="The type of the source code.")
     json_schema: Optional[Dict] = Field(

letta/server/rest_api/interface.py

@@ -281,6 +281,9 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         # turn function argument to send_message into a normal text stream
         self.streaming_chat_completion_json_reader = FunctionArgumentsStreamHandler(json_key=assistant_message_tool_kwarg)
 
+        # Store metadata passed from server
+        self.metadata = {}
+
         self._chunks = deque()
         self._event = asyncio.Event()  # Use an event to notify when chunks are available
         self._active = True  # This should be set to False to stop the generator

letta/server/rest_api/routers/openai/chat_completions/chat_completions.py

@@ -3,13 +3,11 @@ from typing import TYPE_CHECKING, Optional
 
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 
-from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message import LettaMessage, ToolCall
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse, Choice, Message, UsageStatistics
 
 # TODO this belongs in a controller!
-from letta.server.rest_api.routers.v1.agents import send_message_to_agent
 from letta.server.rest_api.utils import get_letta_server
 
 if TYPE_CHECKING:
@@ -52,12 +50,10 @@ async def create_chat_completion(
         # TODO(charles) support multimodal parts
         assert isinstance(input_message.content, str)
 
-        return await send_message_to_agent(
-            server=server,
+        return await server.send_message_to_agent(
             agent_id=agent_id,
-            user_id=actor.id,
-            role=MessageRole(input_message.role),
-            message=input_message.content,
+            actor=actor,
+            message=input_message.content,  # TODO: This is broken
             # Turn streaming ON
             stream_steps=True,
             stream_tokens=True,
@@ -71,12 +67,10 @@ async def create_chat_completion(
         # TODO(charles) support multimodal parts
         assert isinstance(input_message.content, str)
 
-        response_messages = await send_message_to_agent(
-            server=server,
+        response_messages = await server.send_message_to_agent(
             agent_id=agent_id,
-            user_id=actor.id,
-            role=MessageRole(input_message.role),
-            message=input_message.content,
+            actor=actor,
+            message=input_message.content,  # TODO: This is broken
             # Turn streaming OFF
             stream_steps=False,
             stream_tokens=False,

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

@@ -4,8 +4,10 @@ from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
 from letta.server.rest_api.routers.v1.providers import router as providers_router
+from letta.server.rest_api.routers.v1.runs import router as runs_router
 from letta.server.rest_api.routers.v1.sandbox_configs import router as sandbox_configs_router
 from letta.server.rest_api.routers.v1.sources import router as sources_router
+from letta.server.rest_api.routers.v1.tags import router as tags_router
 from letta.server.rest_api.routers.v1.tools import router as tools_router
 
 ROUTERS = [
@@ -18,4 +20,6 @@ ROUTERS = [
     health_router,
     sandbox_configs_router,
     providers_router,
+    runs_router,
+    tags_router,
 ]

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

@@ -1,10 +1,8 @@
-import asyncio
-import warnings
 from datetime import datetime
 from typing import List, Optional, Union
 
 from fastapi import APIRouter, BackgroundTasks, Body, Depends, Header, HTTPException, Query, status
-from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.responses import JSONResponse
 from pydantic import Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
@@ -12,19 +10,18 @@ from letta.log import get_logger
 from letta.orm.errors import NoResultFound
 from letta.schemas.agent import AgentState, CreateAgent, UpdateAgent
 from letta.schemas.block import Block, BlockUpdate, CreateBlock  # , BlockLabelUpdate, BlockLimitUpdate
-from letta.schemas.enums import MessageStreamStatus
-from letta.schemas.job import Job, JobStatus, JobUpdate
-from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, LettaMessageUnion
+from letta.schemas.job import JobStatus, JobUpdate
+from letta.schemas.letta_message import LettaMessageUnion
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import ArchivalMemorySummary, ContextWindowOverview, CreateArchivalMemory, Memory, RecallMemorySummary
-from letta.schemas.message import Message, MessageCreate, MessageUpdate
+from letta.schemas.message import Message, MessageUpdate
 from letta.schemas.passage import Passage
+from letta.schemas.run import Run
 from letta.schemas.source import Source
 from letta.schemas.tool import Tool
 from letta.schemas.user import User
-from letta.server.rest_api.interface import StreamingServerInterface
-from letta.server.rest_api.utils import get_letta_server, sse_async_generator
+from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
@@ -46,9 +43,9 @@ def list_agents(
     ),
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),
-    cursor: Optional[int] = Query(None, description="Cursor for pagination"),
+    cursor: Optional[str] = Query(None, description="Cursor for pagination"),
     limit: Optional[int] = Query(None, description="Limit for pagination"),
-    # Extract user_id from header, default to None if not present
+    query_text: Optional[str] = Query(None, description="Search agents by name"),
 ):
     """
     List all agents associated with a given user.
@@ -63,6 +60,7 @@ def list_agents(
             "tags": tags,
             "match_all_tags": match_all_tags,
             "name": name,
+            "query_text": query_text,
         }.items()
         if value is not None
     }
@@ -155,6 +153,18 @@ def remove_tool_from_agent(
     return server.agent_manager.detach_tool(agent_id=agent_id, tool_id=tool_id, actor=actor)
 
 
+@router.patch("/{agent_id}/reset-messages", response_model=AgentState, operation_id="reset_messages")
+def reset_messages(
+    agent_id: str,
+    add_default_initial_messages: bool = Query(default=False, description="If true, adds the default initial messages after resetting."),
+    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
+):
+    """Resets the messages for an agent"""
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    return server.agent_manager.reset_messages(agent_id=agent_id, actor=actor, add_default_initial_messages=add_default_initial_messages)
+
+
 @router.get("/{agent_id}", response_model=AgentState, operation_id="get_agent")
 def get_agent_state(
     agent_id: str,
@@ -485,17 +495,16 @@ async def send_message(
     This endpoint accepts a message from a user and processes it through the agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    result = await send_message_to_agent(
-        server=server,
+    result = await server.send_message_to_agent(
         agent_id=agent_id,
         actor=actor,
         messages=request.messages,
         stream_steps=False,
         stream_tokens=False,
         # Support for AssistantMessage
-        use_assistant_message=request.use_assistant_message,
-        assistant_message_tool_name=request.assistant_message_tool_name,
-        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+        use_assistant_message=request.config.use_assistant_message,
+        assistant_message_tool_name=request.config.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.config.assistant_message_tool_kwarg,
     )
     return result
 
@@ -526,16 +535,16 @@ async def send_message_streaming(
     """
 
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    result = await send_message_to_agent(
-        server=server,
+    result = await server.send_message_to_agent(
         agent_id=agent_id,
         actor=actor,
         messages=request.messages,
         stream_steps=True,
         stream_tokens=request.stream_tokens,
         # Support for AssistantMessage
-        assistant_message_tool_name=request.assistant_message_tool_name,
-        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+        use_assistant_message=request.config.use_assistant_message,
+        assistant_message_tool_name=request.config.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.config.assistant_message_tool_kwarg,
     )
     return result
 
@@ -546,21 +555,23 @@ async def process_message_background(
     actor: User,
     agent_id: str,
     messages: list,
+    use_assistant_message: bool,
     assistant_message_tool_name: str,
     assistant_message_tool_kwarg: str,
 ) -> None:
     """Background task to process the message and update job status."""
     try:
         # TODO(matt) we should probably make this stream_steps and log each step as it progresses, so the job update GET can see the total steps so far + partial usage?
-        result = await send_message_to_agent(
-            server=server,
+        result = await server.send_message_to_agent(
             agent_id=agent_id,
             actor=actor,
             messages=messages,
             stream_steps=False,  # NOTE(matt)
             stream_tokens=False,
+            use_assistant_message=use_assistant_message,
             assistant_message_tool_name=assistant_message_tool_name,
             assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+            metadata={"job_id": job_id},  # Pass job_id through metadata
         )
 
         # Update job status to completed
@@ -571,6 +582,9 @@ async def process_message_background(
         )
         server.job_manager.update_job_by_id(job_id=job_id, job_update=job_update, actor=actor)
 
+        # Add job usage statistics
+        server.job_manager.add_job_usage(job_id=job_id, usage=result.usage, actor=actor)
+
     except Exception as e:
         # Update job status to failed
         job_update = JobUpdate(
@@ -584,7 +598,7 @@ async def process_message_background(
 
 @router.post(
     "/{agent_id}/messages/async",
-    response_model=Job,
+    response_model=Run,
     operation_id="create_agent_message_async",
 )
 async def send_message_async(
@@ -595,152 +609,34 @@ async def send_message_async(
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     """
-    Asynchronously process a user message and return a job ID.
-    The actual processing happens in the background, and the status can be checked using the job ID.
+    Asynchronously process a user message and return a run object.
+    The actual processing happens in the background, and the status can be checked using the run ID.
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
 
     # Create a new job
-    job = Job(
+    run = Run(
         user_id=actor.id,
         status=JobStatus.created,
         metadata_={
             "job_type": "send_message_async",
             "agent_id": agent_id,
         },
+        request_config=request.config,
     )
-    job = server.job_manager.create_job(pydantic_job=job, actor=actor)
+    run = server.job_manager.create_job(pydantic_job=run, actor=actor)
 
     # Add the background task
     background_tasks.add_task(
         process_message_background,
-        job_id=job.id,
+        job_id=run.id,
         server=server,
         actor=actor,
         agent_id=agent_id,
         messages=request.messages,
-        assistant_message_tool_name=request.assistant_message_tool_name,
-        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+        use_assistant_message=request.config.use_assistant_message,
+        assistant_message_tool_name=request.config.assistant_message_tool_name,
+        assistant_message_tool_kwarg=request.config.assistant_message_tool_kwarg,
     )
 
-    return job
-
-
-# TODO: move this into server.py?
-async def send_message_to_agent(
-    server: SyncServer,
-    agent_id: str,
-    actor: User,
-    # role: MessageRole,
-    messages: Union[List[Message], List[MessageCreate]],
-    stream_steps: bool,
-    stream_tokens: bool,
-    # related to whether or not we return `LettaMessage`s or `Message`s
-    chat_completion_mode: bool = False,
-    timestamp: Optional[datetime] = None,
-    # Support for AssistantMessage
-    use_assistant_message: bool = True,
-    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."""
-
-    # TODO: @charles is this the correct way to handle?
-    include_final_message = True
-
-    if not stream_steps and stream_tokens:
-        raise HTTPException(status_code=400, detail="stream_steps must be 'true' if stream_tokens is 'true'")
-
-    # For streaming response
-    try:
-
-        # TODO: move this logic into server.py
-
-        # 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.load_agent(agent_id=agent_id, actor=actor)
-
-        # Disable token streaming if not OpenAI
-        # TODO: cleanup this logic
-        llm_config = letta_agent.agent_state.llm_config
-        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
-        letta_agent.interface = StreamingServerInterface(use_assistant_message)
-        streaming_interface = letta_agent.interface
-        if not isinstance(streaming_interface, StreamingServerInterface):
-            raise ValueError(f"Agent has wrong type of interface: {type(streaming_interface)}")
-
-        # Enable token-streaming within the request if desired
-        streaming_interface.streaming_mode = stream_tokens
-        # "chatcompletion mode" does some remapping and ignores inner thoughts
-        streaming_interface.streaming_chat_completion_mode = chat_completion_mode
-
-        # streaming_interface.allow_assistant_message = stream
-        # streaming_interface.function_call_legacy_mode = stream
-
-        # Allow AssistantMessage is desired by client
-        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 = (
-            llm_config.put_inner_thoughts_in_kwargs if llm_config.put_inner_thoughts_in_kwargs is not None else False
-        )
-
-        # Offload the synchronous message_func to a separate thread
-        streaming_interface.stream_start()
-        task = asyncio.create_task(
-            asyncio.to_thread(
-                server.send_messages,
-                actor=actor,
-                agent_id=agent_id,
-                messages=messages,
-                interface=streaming_interface,
-            )
-        )
-
-        if stream_steps:
-            # return a stream
-            return StreamingResponse(
-                sse_async_generator(
-                    streaming_interface.get_generator(),
-                    usage_task=task,
-                    finish_message=include_final_message,
-                ),
-                media_type="text/event-stream",
-            )
-
-        else:
-            # buffer the stream, then return the list
-            generated_stream = []
-            async for message in streaming_interface.get_generator():
-                assert (
-                    isinstance(message, LettaMessage) or isinstance(message, LegacyLettaMessage) or isinstance(message, MessageStreamStatus)
-                ), type(message)
-                generated_stream.append(message)
-                if message == MessageStreamStatus.done:
-                    break
-
-            # Get rid of the stream status messages
-            filtered_stream = [d for d in generated_stream if not isinstance(d, MessageStreamStatus)]
-            usage = await task
-
-            # By default the stream will be messages of type LettaMessage or LettaLegacyMessage
-            # 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
-            return LettaResponse(messages=filtered_stream, usage=usage)
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(e)
-        import traceback
-
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"{e}")
+    return run

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

@@ -0,0 +1,137 @@
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, Header, HTTPException, Query
+
+from letta.orm.enums import JobType
+from letta.orm.errors import NoResultFound
+from letta.schemas.enums import JobStatus, MessageRole
+from letta.schemas.letta_message import LettaMessageUnion
+from letta.schemas.openai.chat_completion_response import UsageStatistics
+from letta.schemas.run import Run
+from letta.server.rest_api.utils import get_letta_server
+from letta.server.server import SyncServer
+
+router = APIRouter(prefix="/runs", tags=["runs"])
+
+
+@router.get("/", response_model=List[Run], operation_id="list_runs")
+def list_runs(
+    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
+):
+    """
+    List all runs.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    return [Run.from_job(job) for job in server.job_manager.list_jobs(actor=actor, job_type=JobType.RUN)]
+
+
+@router.get("/active", response_model=List[Run], operation_id="list_active_runs")
+def list_active_runs(
+    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
+):
+    """
+    List all active runs.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    active_runs = server.job_manager.list_jobs(actor=actor, statuses=[JobStatus.created, JobStatus.running], job_type=JobType.RUN)
+
+    return [Run.from_job(job) for job in active_runs]
+
+
+@router.get("/{run_id}", response_model=Run, operation_id="get_run")
+def get_run(
+    run_id: str,
+    user_id: Optional[str] = Header(None, alias="user_id"),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get the status of a run.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    try:
+        job = server.job_manager.get_job_by_id(job_id=run_id, actor=actor)
+        return Run.from_job(job)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Run not found")
+
+
+@router.get("/{run_id}/messages", response_model=List[LettaMessageUnion], operation_id="get_run_messages")
+async def get_run_messages(
+    run_id: str,
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+    cursor: Optional[str] = Query(None, description="Cursor for pagination"),
+    limit: Optional[int] = Query(100, description="Maximum number of messages to return"),
+    ascending: bool = Query(True, description="Sort order by creation time"),
+    role: Optional[MessageRole] = Query(None, description="Filter by role"),
+):
+    """
+    Get messages associated with a run with filtering options.
+
+    Args:
+        run_id: ID of the run
+        cursor: Cursor for pagination
+        limit: Maximum number of messages to return
+        ascending: Sort order by creation time
+        role: Filter by role (user/assistant/system/tool)
+        return_message_object: Whether to return Message objects or LettaMessage objects
+        user_id: ID of the user making the request
+
+    Returns:
+        A list of messages associated with the run. Default is List[LettaMessage].
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    try:
+        messages = server.job_manager.get_run_messages_cursor(
+            run_id=run_id,
+            actor=actor,
+            limit=limit,
+            cursor=cursor,
+            ascending=ascending,
+            role=role,
+        )
+        return messages
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@router.get("/{run_id}/usage", response_model=UsageStatistics, operation_id="get_run_usage")
+def get_run_usage(
+    run_id: str,
+    user_id: Optional[str] = Header(None, alias="user_id"),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Get usage statistics for a run.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    try:
+        usage = server.job_manager.get_job_usage(job_id=run_id, actor=actor)
+        return usage
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail=f"Run '{run_id}' not found")
+
+
+@router.delete("/{run_id}", response_model=Run, operation_id="delete_run")
+def delete_run(
+    run_id: str,
+    user_id: Optional[str] = Header(None, alias="user_id"),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    """
+    Delete a run by its run_id.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    try:
+        job = server.job_manager.delete_job_by_id(job_id=run_id, actor=actor)
+        return Run.from_job(job)
+    except NoResultFound:
+        raise HTTPException(status_code=404, detail="Run not found")

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

@@ -0,0 +1,27 @@
+from typing import TYPE_CHECKING, List, Optional
+
+from fastapi import APIRouter, Depends, Header, Query
+
+from letta.server.rest_api.utils import get_letta_server
+
+if TYPE_CHECKING:
+    from letta.server.server import SyncServer
+
+
+router = APIRouter(prefix="/tags", tags=["tag", "admin"])
+
+
+@router.get("/", tags=["admin"], response_model=List[str], operation_id="list_tags")
+def get_tags(
+    cursor: Optional[str] = Query(None),
+    limit: Optional[int] = Query(50),
+    server: "SyncServer" = Depends(get_letta_server),
+    query_text: Optional[str] = Query(None),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    """
+    Get a list of all tags in the database
+    """
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    tags = server.agent_manager.list_tags(actor=actor, cursor=cursor, limit=limit, query_text=query_text)
+    return tags

letta/server/rest_api/utils.py

@@ -3,7 +3,7 @@ import json
 import os
 import warnings
 from enum import Enum
-from typing import AsyncGenerator, Optional, Union
+from typing import TYPE_CHECKING, AsyncGenerator, Optional, Union
 
 from fastapi import Header
 from pydantic import BaseModel
@@ -11,7 +11,9 @@ from pydantic import BaseModel
 from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.schemas.usage import LettaUsageStatistics
 from letta.server.rest_api.interface import StreamingServerInterface
-from letta.server.server import SyncServer
+
+if TYPE_CHECKING:
+    from letta.server.server import SyncServer
 
 # from letta.orm.user import User
 # from letta.orm.utilities import get_db_session
@@ -86,7 +88,7 @@ async def sse_async_generator(
 
 
 # TODO: why does this double up the interface?
-def get_letta_server() -> SyncServer:
+def get_letta_server() -> "SyncServer":
     # Check if a global server is already instantiated
     from letta.server.rest_api.app import server