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

letta/schemas/model.py

@@ -0,0 +1,265 @@
+from typing import Annotated, Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import ProviderType
+from letta.schemas.llm_config import LLMConfig
+from letta.schemas.response_format import ResponseFormatUnion
+
+
+class ModelBase(BaseModel):
+    handle: str = Field(..., description="Unique handle for API reference (format: provider_display_name/model_display_name)")
+    name: str = Field(..., description="The actual model name used by the provider")
+    display_name: str = Field(..., description="Display name for the model shown in UI")
+    provider_type: ProviderType = Field(..., description="The type of the provider")
+    provider_name: str = Field(..., description="The name of the provider")
+    model_type: Literal["llm", "embedding"] = Field(..., description="Type of model (llm or embedding)")
+
+
+class Model(ModelBase):
+    model_type: Literal["llm"] = Field("llm", description="Type of model (llm or embedding)")
+    max_context_window: int = Field(..., description="The maximum context window for the model")
+    # supports_token_streaming: Optional[bool] = Field(None, description="Whether token streaming is supported")
+    # supports_tool_calling: Optional[bool] = Field(None, description="Whether tool calling is supported")
+
+    def _from_llm_config(self, llm_config: LLMConfig) -> "Model":
+        return self(
+            handle=llm_config.handle,
+            name=llm_config.model,
+            display_name=llm_config.display_name,
+            provider_type=llm_config.model_endpoint_type,
+            provider_name=llm_config.provider_name,
+        )
+
+
+class EmbeddingModel(ModelBase):
+    model_type: Literal["embedding"] = Field("embedding", description="Type of model (llm or embedding)")
+    embedding_dim: int = Field(..., description="The dimension of the embedding")
+
+    def _from_embedding_config(self, embedding_config: EmbeddingConfig) -> "Model":
+        return self(
+            handle=embedding_config.handle,
+            name=embedding_config.embedding_model,
+            display_name=embedding_config.embedding_model,
+            provider_type=embedding_config.embedding_endpoint_type,
+            provider_name=embedding_config.embedding_endpoint_type,
+        )
+
+
+class ModelSettings(BaseModel):
+    """Schema for defining settings for a model"""
+
+    model: str = Field(..., description="The name of the model.")
+    max_output_tokens: int = Field(4096, description="The maximum number of tokens the model can generate.")
+
+
+class OpenAIReasoning(BaseModel):
+    reasoning_effort: Literal["minimal", "low", "medium", "high"] = Field(
+        "minimal", description="The reasoning effort to use when generating text reasoning models"
+    )
+
+    # TODO: implement support for this
+    # summary: Optional[Literal["auto", "detailed"]] = Field(
+    #    None, description="The reasoning summary level to use when generating text reasoning models"
+    # )
+
+
+class OpenAIModelSettings(ModelSettings):
+    provider: Literal["openai"] = Field("openai", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    reasoning: OpenAIReasoning = Field(OpenAIReasoning(reasoning_effort="high"), description="The reasoning configuration for the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    # TODO: implement support for these
+    # reasoning_summary: Optional[Literal["none", "short", "detailed"]] = Field(
+    #    None, description="The reasoning summary level to use when generating text reasoning models"
+    # )
+    # max_tool_calls: int = Field(10, description="The maximum number of tool calls the model can make.")
+    # parallel_tool_calls: bool = Field(False, description="Whether the model supports parallel tool calls.")
+    # top_logprobs: int = Field(10, description="The number of top logprobs to return.")
+    # top_p: float = Field(1.0, description="The top-p value to use when generating text.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "reasoning_effort": self.reasoning.reasoning_effort,
+            "response_format": self.response_format,
+        }
+
+
+#    "thinking": {
+#        "type": "enabled",
+#        "budget_tokens": 10000
+#    }
+
+
+class AnthropicThinking(BaseModel):
+    type: Literal["enabled", "disabled"] = Field("enabled", description="The type of thinking to use.")
+    budget_tokens: int = Field(1024, description="The maximum number of tokens the model can use for extended thinking.")
+
+
+class AnthropicModelSettings(ModelSettings):
+    provider: Literal["anthropic"] = Field("anthropic", description="The provider of the model.")
+    temperature: float = Field(1.0, description="The temperature of the model.")
+    thinking: AnthropicThinking = Field(
+        AnthropicThinking(type="enabled", budget_tokens=1024), description="The thinking configuration for the model."
+    )
+
+    # gpt-5 models only
+    verbosity: Optional[Literal["low", "medium", "high"]] = Field(
+        None,
+        description="Soft control for how verbose model output should be, used for GPT-5 models.",
+    )
+
+    # TODO: implement support for these
+    # top_k: Optional[int] = Field(None, description="The number of top tokens to return.")
+    # top_p: Optional[float] = Field(None, description="The top-p value to use when generating text.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "extended_thinking": self.thinking.type == "enabled",
+            "thinking_budget_tokens": self.thinking.budget_tokens,
+            "verbosity": self.verbosity,
+        }
+
+
+class GeminiThinkingConfig(BaseModel):
+    include_thoughts: bool = Field(True, description="Whether to include thoughts in the model's response.")
+    thinking_budget: int = Field(1024, description="The thinking budget for the model.")
+
+
+class GoogleAIModelSettings(ModelSettings):
+    provider: Literal["google_ai"] = Field("google_ai", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    thinking_config: GeminiThinkingConfig = Field(
+        GeminiThinkingConfig(include_thoughts=True, thinking_budget=1024), description="The thinking configuration for the model."
+    )
+    response_schema: Optional[ResponseFormatUnion] = Field(None, description="The response schema for the model.")
+    max_output_tokens: int = Field(65536, description="The maximum number of tokens the model can generate.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "max_reasoning_tokens": self.thinking_config.thinking_budget if self.thinking_config.include_thoughts else 0,
+        }
+
+
+class GoogleVertexModelSettings(GoogleAIModelSettings):
+    provider: Literal["google_vertex"] = Field("google_vertex", description="The provider of the model.")
+
+
+class AzureModelSettings(ModelSettings):
+    """Azure OpenAI model configuration (OpenAI-compatible)."""
+
+    provider: Literal["azure"] = Field("azure", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class XAIModelSettings(ModelSettings):
+    """xAI model configuration (OpenAI-compatible)."""
+
+    provider: Literal["xai"] = Field("xai", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class GroqModelSettings(ModelSettings):
+    """Groq model configuration (OpenAI-compatible)."""
+
+    provider: Literal["groq"] = Field("groq", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class DeepseekModelSettings(ModelSettings):
+    """Deepseek model configuration (OpenAI-compatible)."""
+
+    provider: Literal["deepseek"] = Field("deepseek", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class TogetherModelSettings(ModelSettings):
+    """Together AI model configuration (OpenAI-compatible)."""
+
+    provider: Literal["together"] = Field("together", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+class BedrockModelSettings(ModelSettings):
+    """AWS Bedrock model configuration."""
+
+    provider: Literal["bedrock"] = Field("bedrock", description="The provider of the model.")
+    temperature: float = Field(0.7, description="The temperature of the model.")
+    response_format: Optional[ResponseFormatUnion] = Field(None, description="The response format for the model.")
+
+    def _to_legacy_config_params(self) -> dict:
+        return {
+            "temperature": self.temperature,
+            "max_tokens": self.max_output_tokens,
+            "response_format": self.response_format,
+        }
+
+
+ModelSettingsUnion = Annotated[
+    Union[
+        OpenAIModelSettings,
+        AnthropicModelSettings,
+        GoogleAIModelSettings,
+        GoogleVertexModelSettings,
+        AzureModelSettings,
+        XAIModelSettings,
+        GroqModelSettings,
+        DeepseekModelSettings,
+        TogetherModelSettings,
+        BedrockModelSettings,
+    ],
+    Field(discriminator="provider"),
+]
+
+
+class EmbeddingModelSettings(BaseModel):
+    model: str = Field(..., description="The name of the model.")
+    provider: Literal["openai", "ollama"] = Field(..., description="The provider of the model.")

letta/schemas/organization.py

@@ -4,12 +4,13 @@ from typing import Optional
 from pydantic import Field
 
 from letta.helpers.datetime_helpers import get_utc_time
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import LettaBase
 from letta.utils import create_random_username
 
 
 class OrganizationBase(LettaBase):
-    __id_prefix__ = "org"
+    __id_prefix__ = PrimitiveType.ORGANIZATION.value
 
 
 class Organization(OrganizationBase):

letta/schemas/passage.py

@@ -6,11 +6,12 @@ from pydantic import Field, field_validator
 from letta.constants import MAX_EMBEDDING_DIM
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import OrmMetadataBase
 
 
 class PassageBase(OrmMetadataBase):
-    __id_prefix__ = "passage"
+    __id_prefix__ = PrimitiveType.PASSAGE.value
 
     is_deleted: bool = Field(False, description="Whether this passage is deleted or not.")
 

letta/schemas/provider_trace.py

@@ -6,11 +6,12 @@ from typing import Any, Dict, Optional
 from pydantic import BaseModel, Field
 
 from letta.helpers.datetime_helpers import get_utc_time
+from letta.schemas.enums import PrimitiveType
 from letta.schemas.letta_base import OrmMetadataBase
 
 
 class BaseProviderTrace(OrmMetadataBase):
-    __id_prefix__ = "provider_trace"
+    __id_prefix__ = PrimitiveType.PROVIDER_TRACE.value
 
 
 class ProviderTraceCreate(BaseModel):

letta/schemas/providers/openrouter.py

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

letta/schemas/run_metrics.py

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

letta/schemas/sandbox_config.py

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

letta/schemas/step_metrics.py

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

letta/schemas/tool_rule.py

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

letta/schemas/user.py

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

letta/server/rest_api/app.py

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

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

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

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

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

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

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