letta-nightly 0.6.9.dev20250119103943__py3-none-any.whl → 0.6.10.dev20250120193553__py3-none-any.whl

letta/llm_api/aws_bedrock.py

@@ -0,0 +1,134 @@
+import os
+from typing import Any, Dict, List
+
+from anthropic import AnthropicBedrock
+
+from letta.settings import model_settings
+
+
+def has_valid_aws_credentials() -> bool:
+    """
+    Check if AWS credentials are properly configured.
+    """
+    valid_aws_credentials = os.getenv("AWS_ACCESS_KEY_ID") and os.getenv("AWS_SECRET_ACCESS_KEY") and os.getenv("AWS_REGION")
+    return valid_aws_credentials
+
+
+def get_bedrock_client():
+    """
+    Get a Bedrock client
+    """
+    import boto3
+
+    sts_client = boto3.client(
+        "sts",
+        aws_access_key_id=model_settings.aws_access_key,
+        aws_secret_access_key=model_settings.aws_secret_access_key,
+        region_name=model_settings.aws_region,
+    )
+    credentials = sts_client.get_session_token()["Credentials"]
+
+    bedrock = AnthropicBedrock(
+        aws_access_key=credentials["AccessKeyId"],
+        aws_secret_key=credentials["SecretAccessKey"],
+        aws_session_token=credentials["SessionToken"],
+        aws_region=model_settings.aws_region,
+    )
+    return bedrock
+
+
+def bedrock_get_model_list(region_name: str) -> List[dict]:
+    """
+    Get list of available models from Bedrock.
+
+    Args:
+        region_name: AWS region name
+        model_provider: Optional provider name to filter models. If None, returns all models.
+        output_modality: Output modality to filter models. Defaults to "text".
+
+    Returns:
+        List of model summaries
+    """
+    import boto3
+
+    try:
+        bedrock = boto3.client("bedrock", region_name=region_name)
+        response = bedrock.list_inference_profiles()
+        return response["inferenceProfileSummaries"]
+    except Exception as e:
+        print(f"Error getting model list: {str(e)}")
+        raise e
+
+
+def bedrock_get_model_details(region_name: str, model_id: str) -> Dict[str, Any]:
+    """
+    Get details for a specific model from Bedrock.
+    """
+    import boto3
+    from botocore.exceptions import ClientError
+
+    try:
+        bedrock = boto3.client("bedrock", region_name=region_name)
+        response = bedrock.get_foundation_model(modelIdentifier=model_id)
+        return response["modelDetails"]
+    except ClientError as e:
+        print(f"Error getting model details: {str(e)}")
+        raise e
+
+
+def bedrock_get_model_context_window(model_id: str) -> int:
+    """
+    Get context window size for a specific model.
+    """
+    # Bedrock doesn't provide this via API, so we maintain a mapping
+    context_windows = {
+        "anthropic.claude-3-5-sonnet-20241022-v2:0": 200000,
+        "anthropic.claude-3-5-sonnet-20240620-v1:0": 200000,
+        "anthropic.claude-3-5-haiku-20241022-v1:0": 200000,
+        "anthropic.claude-3-haiku-20240307-v1:0": 200000,
+        "anthropic.claude-3-opus-20240229-v1:0": 200000,
+        "anthropic.claude-3-sonnet-20240229-v1:0": 200000,
+    }
+    return context_windows.get(model_id, 200000)  # default to 100k if unknown
+
+
+"""
+{
+    "id": "msg_123",
+    "type": "message",
+    "role": "assistant",
+    "model": "anthropic.claude-3-5-sonnet-20241022-v2:0",
+    "content": [
+        {
+            "type": "text",
+            "text": "I see the Firefox icon. Let me click on it and then navigate to a weather website."
+        },
+        {
+            "type": "tool_use",
+            "id": "toolu_123",
+            "name": "computer",
+            "input": {
+                "action": "mouse_move",
+                "coordinate": [
+                    708,
+                    736
+                ]
+            }
+        },
+        {
+            "type": "tool_use",
+            "id": "toolu_234",
+            "name": "computer",
+            "input": {
+                "action": "left_click"
+            }
+        }
+    ],
+    "stop_reason": "tool_use",
+    "stop_sequence": null,
+    "usage": {
+        "input_tokens": 3391,
+        "output_tokens": 132
+    }
+}
+"""

letta/llm_api/llm_api_tools.py

@@ -6,7 +6,8 @@ import requests
 
 from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LettaConfigurationError, RateLimitExceededError
-from letta.llm_api.anthropic import anthropic_chat_completions_request
+from letta.llm_api.anthropic import anthropic_bedrock_chat_completions_request, anthropic_chat_completions_request
+from letta.llm_api.aws_bedrock import has_valid_aws_credentials
 from letta.llm_api.azure_openai import azure_openai_chat_completions_request
 from letta.llm_api.google_ai import convert_tools_to_google_ai_format, google_ai_chat_completions_request
 from letta.llm_api.helpers import add_inner_thoughts_to_functions, unpack_all_inner_thoughts_from_kwargs
@@ -22,7 +23,6 @@ from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest, Tool, cast_message_to_subtype
 from letta.schemas.openai.chat_completion_response import ChatCompletionResponse
-from letta.services.provider_manager import ProviderManager
 from letta.settings import ModelSettings
 from letta.streaming_interface import AgentChunkStreamingInterface, AgentRefreshStreamingInterface
 
@@ -252,12 +252,7 @@ def create(
             tool_call = {"type": "function", "function": {"name": force_tool_call}}
             assert functions is not None
 
-        # load anthropic key from db in case a custom key has been stored
-        anthropic_key_override = ProviderManager().get_anthropic_key_override()
-
         return anthropic_chat_completions_request(
-            url=llm_config.model_endpoint,
-            api_key=anthropic_key_override if anthropic_key_override else model_settings.anthropic_api_key,
             data=ChatCompletionRequest(
                 model=llm_config.model,
                 messages=[cast_message_to_subtype(m.to_openai_dict()) for m in messages],
@@ -374,6 +369,34 @@ def create(
             auth_key=model_settings.together_api_key,
         )
 
+    elif llm_config.model_endpoint_type == "bedrock":
+        """Anthropic endpoint that goes via /embeddings instead of /chat/completions"""
+
+        if stream:
+            raise NotImplementedError(f"Streaming not yet implemented for Anthropic (via the /embeddings endpoint).")
+        if not use_tool_naming:
+            raise NotImplementedError("Only tool calling supported on Anthropic API requests")
+
+        if not has_valid_aws_credentials():
+            raise LettaConfigurationError(message="Invalid or missing AWS credentials. Please configure valid AWS credentials.")
+
+        tool_call = None
+        if force_tool_call is not None:
+            tool_call = {"type": "function", "function": {"name": force_tool_call}}
+            assert functions is not None
+
+        return anthropic_bedrock_chat_completions_request(
+            data=ChatCompletionRequest(
+                model=llm_config.model,
+                messages=[cast_message_to_subtype(m.to_openai_dict()) for m in messages],
+                tools=[{"type": "function", "function": f} for f in functions] if functions else None,
+                tool_choice=tool_call,
+                # user=str(user_id),
+                # NOTE: max_tokens is required for Anthropic API
+                max_tokens=1024,  # TODO make dynamic
+            ),
+        )
+
     # local model
     else:
         if stream:

letta/orm/__init__.py

@@ -13,6 +13,7 @@ from letta.orm.provider import Provider
 from letta.orm.sandbox_config import AgentEnvironmentVariable, SandboxConfig, SandboxEnvironmentVariable
 from letta.orm.source import Source
 from letta.orm.sources_agents import SourcesAgents
+from letta.orm.step import Step
 from letta.orm.tool import Tool
 from letta.orm.tools_agents import ToolsAgents
 from letta.orm.user import User

letta/orm/job.py

@@ -13,8 +13,8 @@ from letta.schemas.letta_request import LettaRequestConfig
 
 if TYPE_CHECKING:
     from letta.orm.job_messages import JobMessage
-    from letta.orm.job_usage_statistics import JobUsageStatistics
     from letta.orm.message import Message
+    from letta.orm.step import Step
     from letta.orm.user import User
 
 
@@ -41,9 +41,7 @@ class Job(SqlalchemyBase, UserMixin):
     # relationships
     user: Mapped["User"] = relationship("User", back_populates="jobs")
     job_messages: Mapped[List["JobMessage"]] = relationship("JobMessage", back_populates="job", cascade="all, delete-orphan")
-    usage_statistics: Mapped[list["JobUsageStatistics"]] = relationship(
-        "JobUsageStatistics", back_populates="job", cascade="all, delete-orphan"
-    )
+    steps: Mapped[List["Step"]] = relationship("Step", back_populates="job", cascade="save-update")
 
     @property
     def messages(self) -> List["Message"]:

letta/orm/message.py

@@ -1,6 +1,6 @@
 from typing import Optional
 
-from sqlalchemy import Index
+from sqlalchemy import ForeignKey, Index
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.custom_columns import ToolCallColumn
@@ -24,10 +24,14 @@ class Message(SqlalchemyBase, OrganizationMixin, AgentMixin):
     name: Mapped[Optional[str]] = mapped_column(nullable=True, doc="Name for multi-agent scenarios")
     tool_calls: Mapped[ToolCall] = mapped_column(ToolCallColumn, doc="Tool call information")
     tool_call_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="ID of the tool call")
+    step_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("steps.id", ondelete="SET NULL"), nullable=True, doc="ID of the step that this message belongs to"
+    )
 
     # Relationships
     agent: Mapped["Agent"] = relationship("Agent", back_populates="messages", lazy="selectin")
     organization: Mapped["Organization"] = relationship("Organization", back_populates="messages", lazy="selectin")
+    step: Mapped["Step"] = relationship("Step", back_populates="messages", lazy="selectin")
 
     # Job relationship
     job_message: Mapped[Optional["JobMessage"]] = relationship(

letta/orm/step.py

@@ -0,0 +1,54 @@
+import uuid
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from sqlalchemy import JSON, ForeignKey, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.step import Step as PydanticStep
+
+if TYPE_CHECKING:
+    from letta.orm.job import Job
+    from letta.orm.provider import Provider
+
+
+class Step(SqlalchemyBase):
+    """Tracks all metadata for agent step."""
+
+    __tablename__ = "steps"
+    __pydantic_model__ = PydanticStep
+
+    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"step-{uuid.uuid4()}")
+    origin: Mapped[Optional[str]] = mapped_column(nullable=True, doc="The surface that this agent step was initiated from.")
+    organization_id: Mapped[str] = mapped_column(
+        ForeignKey("organizations.id", ondelete="RESTRICT"),
+        nullable=True,
+        doc="The unique identifier of the organization that this step ran for",
+    )
+    provider_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("providers.id", ondelete="RESTRICT"),
+        nullable=True,
+        doc="The unique identifier of the provider that was configured for this step",
+    )
+    job_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("jobs.id", ondelete="SET NULL"), nullable=True, doc="The unique identified of the job run that triggered this step"
+    )
+    provider_name: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the provider used for this step.")
+    model: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="The name of the model used for this step.")
+    context_window_limit: Mapped[Optional[int]] = mapped_column(
+        None, nullable=True, doc="The context window limit configured for this step."
+    )
+    completion_tokens: Mapped[int] = mapped_column(default=0, doc="Number of tokens generated by the agent")
+    prompt_tokens: Mapped[int] = mapped_column(default=0, doc="Number of tokens in the prompt")
+    total_tokens: Mapped[int] = mapped_column(default=0, doc="Total number of tokens processed by the agent")
+    completion_tokens_details: Mapped[Optional[Dict]] = mapped_column(JSON, nullable=True, doc="metadata for the agent.")
+    tags: Mapped[Optional[List]] = mapped_column(JSON, doc="Metadata tags.")
+    tid: Mapped[Optional[str]] = mapped_column(None, nullable=True, doc="Transaction ID that processed the step.")
+
+    # Relationships (foreign keys)
+    organization: Mapped[Optional["Organization"]] = relationship("Organization")
+    provider: Mapped[Optional["Provider"]] = relationship("Provider")
+    job: Mapped[Optional["Job"]] = relationship("Job", back_populates="steps")
+
+    # Relationships (backrefs)
+    messages: Mapped[List["Message"]] = relationship("Message", back_populates="step", cascade="save-update", lazy="noload")

letta/schemas/embedding_config.py

@@ -23,6 +23,7 @@ class EmbeddingConfig(BaseModel):
     embedding_endpoint_type: Literal[
         "openai",
         "anthropic",
+        "bedrock",
         "cohere",
         "google_ai",
         "azure",

letta/schemas/letta_message.py

@@ -217,3 +217,27 @@ LettaMessageUnion = Annotated[
     Union[SystemMessage, UserMessage, ReasoningMessage, ToolCallMessage, ToolReturnMessage, AssistantMessage],
     Field(discriminator="message_type"),
 ]
+
+
+def create_letta_message_union_schema():
+    return {
+        "oneOf": [
+            {"$ref": "#/components/schemas/SystemMessage-Output"},
+            {"$ref": "#/components/schemas/UserMessage-Output"},
+            {"$ref": "#/components/schemas/ReasoningMessage"},
+            {"$ref": "#/components/schemas/ToolCallMessage"},
+            {"$ref": "#/components/schemas/ToolReturnMessage"},
+            {"$ref": "#/components/schemas/AssistantMessage-Output"},
+        ],
+        "discriminator": {
+            "propertyName": "message_type",
+            "mapping": {
+                "system_message": "#/components/schemas/SystemMessage-Output",
+                "user_message": "#/components/schemas/UserMessage-Output",
+                "reasoning_message": "#/components/schemas/ReasoningMessage",
+                "tool_call_message": "#/components/schemas/ToolCallMessage",
+                "tool_return_message": "#/components/schemas/ToolReturnMessage",
+                "assistant_message": "#/components/schemas/AssistantMessage-Output",
+            },
+        },
+    }

letta/schemas/letta_response.py

@@ -28,15 +28,7 @@ class LettaResponse(BaseModel):
         description="The messages returned by the agent.",
         json_schema_extra={
             "items": {
-                "oneOf": [
-                    {"$ref": "#/components/schemas/SystemMessage-Output"},
-                    {"$ref": "#/components/schemas/UserMessage-Output"},
-                    {"$ref": "#/components/schemas/ReasoningMessage"},
-                    {"$ref": "#/components/schemas/ToolCallMessage"},
-                    {"$ref": "#/components/schemas/ToolReturnMessage"},
-                    {"$ref": "#/components/schemas/AssistantMessage-Output"},
-                ],
-                "discriminator": {"propertyName": "message_type"},
+                "$ref": "#/components/schemas/LettaMessageUnion",
             }
         },
     )

letta/schemas/llm_config.py

@@ -36,6 +36,7 @@ class LLMConfig(BaseModel):
         "hugging-face",
         "mistral",
         "together",  # completions endpoint
+        "bedrock",
     ] = Field(..., description="The endpoint type for the model.")
     model_endpoint: Optional[str] = Field(None, description="The endpoint for the model.")
     model_wrapper: Optional[str] = Field(None, description="The wrapper for the model.")

letta/schemas/message.py

@@ -99,6 +99,7 @@ class Message(BaseMessage):
     name: Optional[str] = Field(None, description="The name of the participant.")
     tool_calls: Optional[List[ToolCall]] = Field(None, description="The list of tool calls requested.")
     tool_call_id: Optional[str] = Field(None, description="The id of the tool call.")
+    step_id: Optional[str] = Field(None, description="The id of the step that this message was created in.")
     # This overrides the optional base orm schema, created_at MUST exist on all messages objects
     created_at: datetime = Field(default_factory=get_utc_time, description="The timestamp when the object was created.")
 

letta/schemas/providers.py

@@ -168,7 +168,23 @@ class OpenAIProvider(Provider):
                 embedding_dim=1536,
                 embedding_chunk_size=300,
                 handle=self.get_handle("text-embedding-ada-002"),
-            )
+            ),
+            EmbeddingConfig(
+                embedding_model="text-embedding-3-small",
+                embedding_endpoint_type="openai",
+                embedding_endpoint="https://api.openai.com/v1",
+                embedding_dim=2000,
+                embedding_chunk_size=300,
+                handle=self.get_handle("text-embedding-3-small"),
+            ),
+            EmbeddingConfig(
+                embedding_model="text-embedding-3-large",
+                embedding_endpoint_type="openai",
+                embedding_endpoint="https://api.openai.com/v1",
+                embedding_dim=2000,
+                embedding_chunk_size=300,
+                handle=self.get_handle("text-embedding-3-large"),
+            ),
         ]
 
     def get_model_context_window_size(self, model_name: str):
@@ -598,8 +614,13 @@ class AzureProvider(Provider):
             context_window_size = self.get_model_context_window(model_name)
             model_endpoint = get_azure_chat_completions_endpoint(self.base_url, model_name, self.api_version)
             configs.append(
-                LLMConfig(model=model_name, model_endpoint_type="azure", model_endpoint=model_endpoint, context_window=context_window_size),
-                handle=self.get_handle(model_name),
+                LLMConfig(
+                    model=model_name,
+                    model_endpoint_type="azure",
+                    model_endpoint=model_endpoint,
+                    context_window=context_window_size,
+                    handle=self.get_handle(model_name),
+                ),
             )
         return configs
 
@@ -699,3 +720,39 @@ class VLLMCompletionsProvider(Provider):
 
 class CohereProvider(OpenAIProvider):
     pass
+
+
+class AnthropicBedrockProvider(Provider):
+    name: str = "bedrock"
+    aws_region: str = Field(..., description="AWS region for Bedrock")
+
+    def list_llm_models(self):
+        from letta.llm_api.aws_bedrock import bedrock_get_model_list
+
+        models = bedrock_get_model_list(self.aws_region)
+
+        configs = []
+        for model_summary in models:
+            model_arn = model_summary["inferenceProfileArn"]
+            configs.append(
+                LLMConfig(
+                    model=model_arn,
+                    model_endpoint_type=self.name,
+                    model_endpoint=None,
+                    context_window=self.get_model_context_window(model_arn),
+                    handle=self.get_handle(model_arn),
+                )
+            )
+        return configs
+
+    def list_embedding_models(self):
+        return []
+
+    def get_model_context_window(self, model_name: str) -> Optional[int]:
+        # Context windows for Claude models
+        from letta.llm_api.aws_bedrock import bedrock_get_model_context_window
+
+        return bedrock_get_model_context_window(model_name)
+
+    def get_handle(self, model_name: str) -> str:
+        return f"anthropic/{model_name}"

letta/schemas/step.py

@@ -0,0 +1,31 @@
+from typing import Dict, List, Optional
+
+from pydantic import Field
+
+from letta.schemas.letta_base import LettaBase
+from letta.schemas.message import Message
+
+
+class StepBase(LettaBase):
+    __id_prefix__ = "step"
+
+
+class Step(StepBase):
+    id: str = Field(..., description="The id of the step. Assigned by the database.")
+    origin: Optional[str] = Field(None, description="The surface that this agent step was initiated from.")
+    organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the step.")
+    provider_id: Optional[str] = Field(None, description="The unique identifier of the provider that was configured for this step")
+    job_id: Optional[str] = Field(
+        None, description="The unique identifier of the job that this step belongs to. Only included for async calls."
+    )
+    provider_name: Optional[str] = Field(None, description="The name of the provider used for this step.")
+    model: Optional[str] = Field(None, description="The name of the model used for this step.")
+    context_window_limit: Optional[int] = Field(None, description="The context window limit configured for this step.")
+    completion_tokens: Optional[int] = Field(None, description="The number of tokens generated by the agent during this step.")
+    prompt_tokens: Optional[int] = Field(None, description="The number of tokens in the prompt during this step.")
+    total_tokens: Optional[int] = Field(None, description="The total number of tokens processed by the agent during this step.")
+    completion_tokens_details: Optional[Dict] = Field(None, description="Metadata for the agent.")
+
+    tags: List[str] = Field([], description="Metadata tags.")
+    tid: Optional[str] = Field(None, description="The unique identifier of the transaction that processed this step.")
+    messages: List[Message] = Field([], description="The messages generated during this step.")

letta/server/rest_api/app.py

@@ -13,9 +13,10 @@ from starlette.middleware.cors import CORSMiddleware
 
 from letta.__init__ import __version__
 from letta.constants import ADMIN_PREFIX, API_PREFIX, OPENAI_API_PREFIX
-from letta.errors import LettaAgentNotFoundError, LettaUserNotFoundError
+from letta.errors import BedrockPermissionError, LettaAgentNotFoundError, LettaUserNotFoundError
 from letta.log import get_logger
 from letta.orm.errors import DatabaseTimeoutError, ForeignKeyConstraintViolationError, NoResultFound, UniqueConstraintViolationError
+from letta.schemas.letta_message import create_letta_message_union_schema
 from letta.server.constants import REST_DEFAULT_PORT
 
 # NOTE(charles): these are extra routes that are not part of v1 but we still need to mount to pass tests
@@ -67,6 +68,7 @@ def generate_openapi_schema(app: FastAPI):
     openai_docs["info"]["title"] = "OpenAI Assistants API"
     letta_docs["paths"] = {k: v for k, v in letta_docs["paths"].items() if not k.startswith("/openai")}
     letta_docs["info"]["title"] = "Letta API"
+    letta_docs["components"]["schemas"]["LettaMessageUnion"] = create_letta_message_union_schema()
 
     # Split the API docs into Letta API, and OpenAI Assistants compatible API
     for name, docs in [
@@ -144,7 +146,7 @@ def create_application() -> "FastAPI":
         log.error(f"Unhandled error: {exc}", exc_info=True)
 
         # Print the stack trace
-        print(f"Stack trace: {exc.__traceback__}")
+        print(f"Stack trace: {exc}")
         if (os.getenv("SENTRY_DSN") is not None) and (os.getenv("SENTRY_DSN") != ""):
             import sentry_sdk
 
@@ -206,6 +208,19 @@ def create_application() -> "FastAPI":
     async def user_not_found_handler(request: Request, exc: LettaUserNotFoundError):
         return JSONResponse(status_code=404, content={"detail": "User not found"})
 
+    @app.exception_handler(BedrockPermissionError)
+    async def bedrock_permission_error_handler(request, exc: BedrockPermissionError):
+        return JSONResponse(
+            status_code=403,
+            content={
+                "error": {
+                    "type": "bedrock_permission_denied",
+                    "message": "Unable to access the required AI model. Please check your Bedrock permissions or contact support.",
+                    "details": {"model_arn": exc.model_arn, "reason": str(exc)},
+                }
+            },
+        )
+
     settings.cors_origins.append("https://app.letta.com")
 
     if (os.getenv("LETTA_SERVER_SECURE") == "true") or "--secure" in sys.argv:
@@ -275,6 +290,8 @@ def start_server(
         server_logger.addHandler(stream_handler)
 
     if (os.getenv("LOCAL_HTTPS") == "true") or "--localhttps" in sys.argv:
+        print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
+        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
         uvicorn.run(
             app,
             host=host or "localhost",
@@ -282,13 +299,11 @@ def start_server(
             ssl_keyfile="certs/localhost-key.pem",
             ssl_certfile="certs/localhost.pem",
         )
-        print(f"▶ Server running at: https://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
     else:
+        print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
+        print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")
         uvicorn.run(
             app,
             host=host or "localhost",
             port=port or REST_DEFAULT_PORT,
         )
-        print(f"▶ Server running at: http://{host or 'localhost'}:{port or REST_DEFAULT_PORT}\n")
-
-    print(f"▶ View using ADE at: https://app.letta.com/development-servers/local/dashboard")

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

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List, Optional, Union
+from typing import Annotated, List, Optional, Union
 
 from fastapi import APIRouter, BackgroundTasks, Body, Depends, Header, HTTPException, Query, status
 from fastapi.responses import JSONResponse
@@ -428,7 +428,20 @@ def delete_agent_archival_memory(
     return JSONResponse(status_code=status.HTTP_200_OK, content={"message": f"Memory id={memory_id} successfully deleted"})
 
 
-@router.get("/{agent_id}/messages", response_model=Union[List[Message], List[LettaMessageUnion]], operation_id="list_agent_messages")
+AgentMessagesResponse = Annotated[
+    Union[List[Message], List[LettaMessageUnion]],
+    Field(
+        json_schema_extra={
+            "anyOf": [
+                {"type": "array", "items": {"$ref": "#/components/schemas/letta__schemas__message__Message"}},
+                {"type": "array", "items": {"$ref": "#/components/schemas/LettaMessageUnion"}},
+            ]
+        }
+    ),
+]
+
+
+@router.get("/{agent_id}/messages", response_model=AgentMessagesResponse, operation_id="list_agent_messages")
 def get_agent_messages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),

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

@@ -18,7 +18,7 @@ def list_llm_backends(
 ):
 
     models = server.list_llm_models()
-    print(models)
+    # print(models)
     return models
 
 
@@ -28,5 +28,5 @@ def list_embedding_backends(
 ):
 
     models = server.list_embedding_models()
-    print(models)
+    # print(models)
     return models

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

@@ -1,6 +1,7 @@
-from typing import List, Optional
+from typing import Annotated, List, Optional
 
 from fastapi import APIRouter, Depends, Header, HTTPException, Query
+from pydantic import Field
 
 from letta.orm.enums import JobType
 from letta.orm.errors import NoResultFound
@@ -60,7 +61,16 @@ def get_run(
         raise HTTPException(status_code=404, detail="Run not found")
 
 
-@router.get("/{run_id}/messages", response_model=List[LettaMessageUnion], operation_id="get_run_messages")
+RunMessagesResponse = Annotated[
+    List[LettaMessageUnion], Field(json_schema_extra={"type": "array", "items": {"$ref": "#/components/schemas/LettaMessageUnion"}})
+]
+
+
+@router.get(
+    "/{run_id}/messages",
+    response_model=RunMessagesResponse,
+    operation_id="get_run_messages",
+)
 async def get_run_messages(
     run_id: str,
     server: "SyncServer" = Depends(get_letta_server),