letta-nightly 0.6.50.dev20250411104155__py3-none-any.whl → 0.6.52.dev20250412051016__py3-none-any.whl

letta/llm_api/openai_client.py

@@ -21,6 +21,7 @@ from letta.llm_api.helpers import add_inner_thoughts_to_functions, convert_to_st
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG, INNER_THOUGHTS_KWARG_DESCRIPTION, INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST
 from letta.log import get_logger
+from letta.schemas.llm_config import LLMConfig
 from letta.schemas.message import Message as PydanticMessage
 from letta.schemas.openai.chat_completion_request import ChatCompletionRequest
 from letta.schemas.openai.chat_completion_request import FunctionCall as ToolFunctionChoiceFunctionCall
@@ -45,17 +46,18 @@ class OpenAIClient(LLMClientBase):
     def build_request_data(
         self,
         messages: List[PydanticMessage],
+        llm_config: LLMConfig,
         tools: Optional[List[dict]] = None,  # Keep as dict for now as per base class
         force_tool_call: Optional[str] = None,
     ) -> dict:
         """
         Constructs a request object in the expected data format for the OpenAI API.
         """
-        if tools and self.llm_config.put_inner_thoughts_in_kwargs:
+        if tools and llm_config.put_inner_thoughts_in_kwargs:
             # Special case for LM Studio backend since it needs extra guidance to force out the thoughts first
             # TODO(fix)
             inner_thoughts_desc = (
-                INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST if ":1234" in self.llm_config.model_endpoint else INNER_THOUGHTS_KWARG_DESCRIPTION
+                INNER_THOUGHTS_KWARG_DESCRIPTION_GO_FIRST if ":1234" in llm_config.model_endpoint else INNER_THOUGHTS_KWARG_DESCRIPTION
             )
             tools = add_inner_thoughts_to_functions(
                 functions=tools,
@@ -64,22 +66,28 @@ class OpenAIClient(LLMClientBase):
                 put_inner_thoughts_first=True,
             )
 
+        use_developer_message = llm_config.model.startswith("o1") or llm_config.model.startswith("o3")  # o-series models
         openai_message_list = [
-            cast_message_to_subtype(m.to_openai_dict(put_inner_thoughts_in_kwargs=self.llm_config.put_inner_thoughts_in_kwargs))
+            cast_message_to_subtype(
+                m.to_openai_dict(
+                    put_inner_thoughts_in_kwargs=llm_config.put_inner_thoughts_in_kwargs,
+                    use_developer_message=use_developer_message,
+                )
+            )
             for m in messages
         ]
 
-        if self.llm_config.model:
-            model = self.llm_config.model
+        if llm_config.model:
+            model = llm_config.model
         else:
-            logger.warning(f"Model type not set in llm_config: {self.llm_config.model_dump_json(indent=4)}")
+            logger.warning(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
             model = None
 
         # force function calling for reliability, see https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice
         # TODO(matt) move into LLMConfig
         # TODO: This vllm checking is very brittle and is a patch at most
         tool_choice = None
-        if self.llm_config.model_endpoint == "https://inference.memgpt.ai" or (self.llm_config.handle and "vllm" in self.llm_config.handle):
+        if llm_config.model_endpoint == "https://inference.memgpt.ai" or (llm_config.handle and "vllm" in self.llm_config.handle):
             tool_choice = "auto"  # TODO change to "required" once proxy supports it
         elif tools:
             # only set if tools is non-Null
@@ -94,11 +102,11 @@ class OpenAIClient(LLMClientBase):
             tools=[OpenAITool(type="function", function=f) for f in tools] if tools else None,
             tool_choice=tool_choice,
             user=str(),
-            max_completion_tokens=self.llm_config.max_tokens,
-            temperature=self.llm_config.temperature,
+            max_completion_tokens=llm_config.max_tokens,
+            temperature=llm_config.temperature,
         )
 
-        if "inference.memgpt.ai" in self.llm_config.model_endpoint:
+        if "inference.memgpt.ai" in llm_config.model_endpoint:
             # override user id for inference.memgpt.ai
             import uuid
 

letta/orm/organization.py

@@ -51,8 +51,10 @@ class Organization(SqlalchemyBase):
     providers: Mapped[List["Provider"]] = relationship("Provider", back_populates="organization", cascade="all, delete-orphan")
     identities: Mapped[List["Identity"]] = relationship("Identity", back_populates="organization", cascade="all, delete-orphan")
     groups: Mapped[List["Group"]] = relationship("Group", back_populates="organization", cascade="all, delete-orphan")
-    llm_batch_jobs: Mapped[List["Agent"]] = relationship("LLMBatchJob", back_populates="organization", cascade="all, delete-orphan")
-    llm_batch_items: Mapped[List["Agent"]] = relationship("LLMBatchItem", back_populates="organization", cascade="all, delete-orphan")
+    llm_batch_jobs: Mapped[List["LLMBatchJob"]] = relationship("LLMBatchJob", back_populates="organization", cascade="all, delete-orphan")
+    llm_batch_items: Mapped[List["LLMBatchItem"]] = relationship(
+        "LLMBatchItem", back_populates="organization", cascade="all, delete-orphan"
+    )
 
     @property
     def passages(self) -> List[Union["SourcePassage", "AgentPassage"]]:

letta/orm/sqlalchemy_base.py

@@ -334,6 +334,9 @@ class SqlalchemyBase(CommonSqlalchemyMetaMixins, Base):
         if len(identifiers) > 0:
             query = query.where(cls.id.in_(identifiers))
             query_conditions.append(f"id='{identifiers}'")
+        elif not kwargs:
+            logger.debug(f"No identifiers provided for {cls.__name__}, returning empty list")
+            return []
 
         if kwargs:
             query = query.filter_by(**kwargs)

letta/schemas/enums.py

@@ -64,3 +64,4 @@ class ToolRuleType(str, Enum):
     conditional = "conditional"
     constrain_child_tools = "constrain_child_tools"
     max_count_per_step = "max_count_per_step"
+    parent_last_tool = "parent_last_tool"

letta/schemas/group.py

@@ -42,11 +42,21 @@ class RoundRobinManager(ManagerConfig):
     max_turns: Optional[int] = Field(None, description="")
 
 
+class RoundRobinManagerUpdate(ManagerConfig):
+    manager_type: Literal[ManagerType.round_robin] = Field(ManagerType.round_robin, description="")
+    max_turns: Optional[int] = Field(None, description="")
+
+
 class SupervisorManager(ManagerConfig):
     manager_type: Literal[ManagerType.supervisor] = Field(ManagerType.supervisor, description="")
     manager_agent_id: str = Field(..., description="")
 
 
+class SupervisorManagerUpdate(ManagerConfig):
+    manager_type: Literal[ManagerType.supervisor] = Field(ManagerType.supervisor, description="")
+    manager_agent_id: Optional[str] = Field(..., description="")
+
+
 class DynamicManager(ManagerConfig):
     manager_type: Literal[ManagerType.dynamic] = Field(ManagerType.dynamic, description="")
     manager_agent_id: str = Field(..., description="")
@@ -54,12 +64,25 @@ class DynamicManager(ManagerConfig):
     max_turns: Optional[int] = Field(None, description="")
 
 
+class DynamicManagerUpdate(ManagerConfig):
+    manager_type: Literal[ManagerType.dynamic] = Field(ManagerType.dynamic, description="")
+    manager_agent_id: Optional[str] = Field(None, description="")
+    termination_token: Optional[str] = Field(None, description="")
+    max_turns: Optional[int] = Field(None, description="")
+
+
 class SleeptimeManager(ManagerConfig):
     manager_type: Literal[ManagerType.sleeptime] = Field(ManagerType.sleeptime, description="")
     manager_agent_id: str = Field(..., description="")
     sleeptime_agent_frequency: Optional[int] = Field(None, description="")
 
 
+class SleeptimeManagerUpdate(ManagerConfig):
+    manager_type: Literal[ManagerType.sleeptime] = Field(ManagerType.sleeptime, description="")
+    manager_agent_id: Optional[str] = Field(None, description="")
+    sleeptime_agent_frequency: Optional[int] = Field(None, description="")
+
+
 # class SwarmGroup(ManagerConfig):
 #   manager_type: Literal[ManagerType.swarm] = Field(ManagerType.swarm, description="")
 
@@ -70,6 +93,12 @@ ManagerConfigUnion = Annotated[
 ]
 
 
+ManagerConfigUpdateUnion = Annotated[
+    Union[RoundRobinManagerUpdate, SupervisorManagerUpdate, DynamicManagerUpdate, SleeptimeManagerUpdate],
+    Field(discriminator="manager_type"),
+]
+
+
 class GroupCreate(BaseModel):
     agent_ids: List[str] = Field(..., description="")
     description: str = Field(..., description="")
@@ -80,5 +109,5 @@ class GroupCreate(BaseModel):
 class GroupUpdate(BaseModel):
     agent_ids: Optional[List[str]] = Field(None, description="")
     description: Optional[str] = Field(None, description="")
-    manager_config: Optional[ManagerConfigUnion] = Field(None, description="")
+    manager_config: Optional[ManagerConfigUpdateUnion] = Field(None, description="")
     shared_block_ids: Optional[List[str]] = Field(None, description="")

letta/schemas/identity.py

@@ -61,6 +61,16 @@ class IdentityCreate(LettaBase):
     properties: Optional[List[IdentityProperty]] = Field(None, description="List of properties associated with the identity.")
 
 
+class IdentityUpsert(LettaBase):
+    identifier_key: str = Field(..., description="External, user-generated identifier key of the identity.")
+    name: str = Field(..., description="The name of the identity.")
+    identity_type: IdentityType = Field(..., description="The type of the identity.")
+    project_id: Optional[str] = Field(None, description="The project id of the identity, if applicable.")
+    agent_ids: Optional[List[str]] = Field(None, description="The agent ids that are associated with the identity.")
+    block_ids: Optional[List[str]] = Field(None, description="The IDs of the blocks associated with the identity.")
+    properties: Optional[List[IdentityProperty]] = Field(None, description="List of properties associated with the identity.")
+
+
 class IdentityUpdate(LettaBase):
     identifier_key: Optional[str] = Field(None, description="External, user-generated identifier key of the identity.")
     name: Optional[str] = Field(None, description="The name of the identity.")

letta/schemas/letta_request.py

@@ -27,3 +27,7 @@ class LettaStreamingRequest(LettaRequest):
         default=False,
         description="Flag to determine if individual tokens should be streamed. Set to True for token streaming (requires stream_steps = True).",
     )
+
+
+class LettaBatchRequest(LettaRequest):
+    agent_id: str = Field(..., description="The ID of the agent to send this batch request for")

letta/schemas/letta_response.py

@@ -1,12 +1,13 @@
 import html
 import json
 import re
+from datetime import datetime
 from typing import List, Union
 
 from pydantic import BaseModel, Field
 
 from letta.helpers.json_helpers import json_dumps
-from letta.schemas.enums import MessageStreamStatus
+from letta.schemas.enums import JobStatus, MessageStreamStatus
 from letta.schemas.letta_message import LettaMessage, LettaMessageUnion
 from letta.schemas.usage import LettaUsageStatistics
 
@@ -165,3 +166,10 @@ class LettaResponse(BaseModel):
 
 # The streaming response is either [DONE], [DONE_STEP], [DONE], an error, or a LettaMessage
 LettaStreamingResponse = Union[LettaMessage, MessageStreamStatus, LettaUsageStatistics]
+
+
+class LettaBatchResponse(BaseModel):
+    batch_id: str = Field(..., description="A unique identifier for this batch request.")
+    status: JobStatus = Field(..., description="The current status of the batch request.")
+    last_polled_at: datetime = Field(..., description="The timestamp when the batch was last polled for updates.")
+    created_at: datetime = Field(..., description="The timestamp when the batch request was created.")

letta/schemas/llm_config.py

@@ -74,6 +74,13 @@ class LLMConfig(BaseModel):
     # FIXME hack to silence pydantic protected namespace warning
     model_config = ConfigDict(protected_namespaces=())
 
+    @model_validator(mode="before")
+    @classmethod
+    def set_default_enable_reasoner(cls, values):
+        if any(openai_reasoner_model in values.get("model", "") for openai_reasoner_model in ["o3-mini", "o1"]):
+            values["enable_reasoner"] = True
+        return values
+
     @model_validator(mode="before")
     @classmethod
     def set_default_put_inner_thoughts(cls, values):
@@ -100,6 +107,9 @@ class LLMConfig(BaseModel):
                 logger.warning("max_tokens must be greater than max_reasoning_tokens (thinking budget)")
             if self.put_inner_thoughts_in_kwargs:
                 logger.warning("Extended thinking is not compatible with put_inner_thoughts_in_kwargs")
+        elif self.max_reasoning_tokens and not self.enable_reasoner:
+            logger.warning("model will not use reasoning unless enable_reasoner is set to True")
+
         return self
 
     @classmethod

letta/schemas/message.py

@@ -137,19 +137,26 @@ class Message(BaseMessage):
     """
 
     id: str = BaseMessage.generate_id_field()
-    role: MessageRole = Field(..., description="The role of the participant.")
-    content: Optional[List[LettaMessageContentUnion]] = Field(None, description="The content of the message.")
     organization_id: Optional[str] = Field(None, description="The unique identifier of the organization.")
     agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
     model: Optional[str] = Field(None, description="The model used to make the function call.")
-    name: Optional[str] = Field(None, description="The name of the participant.")
-    tool_calls: Optional[List[OpenAIToolCall]] = Field(None, description="The list of tool calls requested.")
-    tool_call_id: Optional[str] = Field(None, description="The id of the tool call.")
+    # Basic OpenAI-style fields
+    role: MessageRole = Field(..., description="The role of the participant.")
+    content: Optional[List[LettaMessageContentUnion]] = Field(None, description="The content of the message.")
+    # NOTE: in OpenAI, this field is only used for roles 'user', 'assistant', and 'function' (now deprecated). 'tool' does not use it.
+    name: Optional[str] = Field(
+        None,
+        description="For role user/assistant: the (optional) name of the participant. For role tool/function: the name of the function called.",
+    )
+    tool_calls: Optional[List[OpenAIToolCall]] = Field(
+        None, description="The list of tool calls requested. Only applicable for role assistant."
+    )
+    tool_call_id: Optional[str] = Field(None, description="The ID of the tool call. Only applicable for role tool.")
+    # Extras
     step_id: Optional[str] = Field(None, description="The id of the step that this message was created in.")
     otid: Optional[str] = Field(None, description="The offline threading id associated with this message")
     tool_returns: Optional[List[ToolReturn]] = Field(None, description="Tool execution return information for prior tool calls")
     group_id: Optional[str] = Field(None, description="The multi-agent group that the message was sent 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.")
 
@@ -406,7 +413,6 @@ class Message(BaseMessage):
 
     @staticmethod
     def dict_to_message(
-        user_id: str,
         agent_id: str,
         openai_message_dict: dict,
         model: Optional[str] = None,  # model used to make function call
@@ -560,7 +566,7 @@ class Message(BaseMessage):
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
                     content=content,
-                    name=name,
+                    name=openai_message_dict["name"] if "name" in openai_message_dict else name,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
@@ -575,7 +581,7 @@ class Message(BaseMessage):
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
                     content=content,
-                    name=name,
+                    name=openai_message_dict["name"] if "name" in openai_message_dict else name,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
                     created_at=created_at,
@@ -592,6 +598,7 @@ class Message(BaseMessage):
         self,
         max_tool_id_length: int = TOOL_CALL_ID_MAX_LEN,
         put_inner_thoughts_in_kwargs: bool = False,
+        use_developer_message: bool = False,
     ) -> dict:
         """Go from Message class to ChatCompletion message object"""
 
@@ -619,7 +626,7 @@ class Message(BaseMessage):
             assert all([v is not None for v in [self.role]]), vars(self)
             openai_message = {
                 "content": text_content,
-                "role": self.role,
+                "role": "developer" if use_developer_message else self.role,
             }
 
         elif self.role == "user":
@@ -809,7 +816,7 @@ class Message(BaseMessage):
             text_content = None
 
         if self.role != "tool" and self.name is not None:
-            warnings.warn(f"Using Google AI with non-null 'name' field ({self.name}) not yet supported.")
+            warnings.warn(f"Using Google AI with non-null 'name' field (name={self.name} role={self.role}), not yet supported.")
 
         if self.role == "system":
             # NOTE: Gemini API doesn't have a 'system' role, use 'user' instead
@@ -908,7 +915,9 @@ class Message(BaseMessage):
         if "parts" not in google_ai_message or not google_ai_message["parts"]:
             # If parts is empty, add a default text part
             google_ai_message["parts"] = [{"text": "empty message"}]
-            warnings.warn(f"Empty 'parts' detected in message with role '{self.role}'. Added default empty text part.")
+            warnings.warn(
+                f"Empty 'parts' detected in message with role '{self.role}'. Added default empty text part. Full message:\n{vars(self)}"
+            )
 
         return google_ai_message
 

letta/schemas/openai/chat_completion_request.py

@@ -133,6 +133,7 @@ class ChatCompletionRequest(BaseModel):
     temperature: Optional[float] = 1
     top_p: Optional[float] = 1
     user: Optional[str] = None  # unique ID of the end-user (for monitoring)
+    parallel_tool_calls: Optional[bool] = None
 
     # function-calling related
     tools: Optional[List[Tool]] = None

letta/schemas/tool_rule.py

@@ -29,6 +29,19 @@ class ChildToolRule(BaseToolRule):
         return set(self.children) if last_tool == self.tool_name else available_tools
 
 
+class ParentToolRule(BaseToolRule):
+    """
+    A ToolRule that only allows a child tool to be called if the parent has been called.
+    """
+
+    type: Literal[ToolRuleType.parent_last_tool] = ToolRuleType.parent_last_tool
+    children: List[str] = Field(..., description="The children tools that can be invoked.")
+
+    def get_valid_tools(self, tool_call_history: List[str], available_tools: Set[str], last_function_response: Optional[str]) -> Set[str]:
+        last_tool = tool_call_history[-1] if tool_call_history else None
+        return set(self.children) if last_tool == self.tool_name else available_tools - set(self.children)
+
+
 class ConditionalToolRule(BaseToolRule):
     """
     A ToolRule that conditionally maps to different child tools based on the output.
@@ -128,6 +141,6 @@ class MaxCountPerStepToolRule(BaseToolRule):
 
 
 ToolRule = Annotated[
-    Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule, MaxCountPerStepToolRule],
+    Union[ChildToolRule, InitToolRule, TerminalToolRule, ConditionalToolRule, ContinueToolRule, MaxCountPerStepToolRule, ParentToolRule],
     Field(discriminator="type"),
 ]

letta/server/rest_api/interface.py

@@ -29,6 +29,7 @@ from letta.schemas.openai.chat_completion_response import ChatCompletionChunkRes
 from letta.server.rest_api.optimistic_json_parser import OptimisticJSONParser
 from letta.streaming_interface import AgentChunkStreamingInterface
 from letta.streaming_utils import FunctionArgumentsStreamHandler, JSONInnerThoughtsExtractor
+from letta.utils import parse_json
 
 
 # TODO strip from code / deprecate
@@ -408,7 +409,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         # if self.expect_reasoning_content_buffer is not None:
         #     try:
         #         # NOTE: this is hardcoded for our DeepSeek API integration
-        #         json_reasoning_content = json.loads(self.expect_reasoning_content_buffer)
+        #         json_reasoning_content = parse_json(self.expect_reasoning_content_buffer)
 
         #         if "name" in json_reasoning_content:
         #             self._push_to_buffer(
@@ -528,7 +529,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
             try:
                 # NOTE: this is hardcoded for our DeepSeek API integration
-                json_reasoning_content = json.loads(self.expect_reasoning_content_buffer)
+                json_reasoning_content = parse_json(self.expect_reasoning_content_buffer)
                 print(f"json_reasoning_content: {json_reasoning_content}")
 
                 processed_chunk = ToolCallMessage(
@@ -1188,7 +1189,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     #   "date": "2024-06-22T23:04:32.141923+00:00"
                     # }
                     try:
-                        func_args = json.loads(function_call.function.arguments)
+                        func_args = parse_json(function_call.function.arguments)
                     except:
                         func_args = function_call.function.arguments
                     # processed_chunk = {
@@ -1224,7 +1225,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 else:
 
                     try:
-                        func_args = json.loads(function_call.function.arguments)
+                        func_args = parse_json(function_call.function.arguments)
                     except:
                         warnings.warn(f"Failed to parse function arguments: {function_call.function.arguments}")
                         func_args = {}

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

@@ -1,14 +1,15 @@
 import json
 import traceback
 from datetime import datetime
-from typing import Annotated, List, Optional
+from typing import Annotated, Any, List, Optional
 
 from fastapi import APIRouter, BackgroundTasks, Body, Depends, File, Header, HTTPException, Query, UploadFile, status
 from fastapi.responses import JSONResponse
 from marshmallow import ValidationError
+from orjson import orjson
 from pydantic import Field
 from sqlalchemy.exc import IntegrityError, OperationalError
-from starlette.responses import StreamingResponse
+from starlette.responses import Response, StreamingResponse
 
 from letta.agents.letta_agent import LettaAgent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
@@ -22,7 +23,6 @@ from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.memory import ContextWindowOverview, CreateArchivalMemory, Memory
 from letta.schemas.message import MessageCreate
-from letta.schemas.openai.chat_completion_request import UserMessage
 from letta.schemas.passage import Passage, PassageUpdate
 from letta.schemas.run import Run
 from letta.schemas.source import Source
@@ -103,19 +103,30 @@ def list_agents(
     )
 
 
-@router.get("/{agent_id}/export", operation_id="export_agent_serialized", response_model=AgentSchema)
+class IndentedORJSONResponse(Response):
+    media_type = "application/json"
+
+    def render(self, content: Any) -> bytes:
+        return orjson.dumps(content, option=orjson.OPT_INDENT_2)
+
+
+@router.get("/{agent_id}/export", response_class=IndentedORJSONResponse, operation_id="export_agent_serialized")
 def export_agent_serialized(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),
-) -> AgentSchema:
+    # do not remove, used to autogeneration of spec
+    # TODO: Think of a better way to export AgentSchema
+    spec: Optional[AgentSchema] = None,
+) -> JSONResponse:
     """
-    Export the serialized JSON representation of an agent.
+    Export the serialized JSON representation of an agent, formatted with indentation.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
 
     try:
-        return server.agent_manager.serialize(agent_id=agent_id, actor=actor)
+        agent = server.agent_manager.serialize(agent_id=agent_id, actor=actor)
+        return agent.model_dump()
     except NoResultFound:
         raise HTTPException(status_code=404, detail=f"Agent with id={agent_id} not found for user_id={actor.id}.")
 
@@ -610,9 +621,7 @@ async def send_message(
             actor=actor,
         )
 
-        messages = request.messages
-        content = messages[0].content[0].text if messages and not isinstance(messages[0].content, str) else messages[0].content
-        result = await experimental_agent.step(UserMessage(content=content), max_steps=10)
+        result = await experimental_agent.step(request.messages, max_steps=10)
     else:
         result = await server.send_message_to_agent(
             agent_id=agent_id,
@@ -672,10 +681,8 @@ async def send_message_streaming(
             actor=actor,
         )
 
-        messages = request.messages
-        content = messages[0].content[0].text if messages and not isinstance(messages[0].content, str) else messages[0].content
         result = StreamingResponse(
-            experimental_agent.step_stream(UserMessage(content=content), max_steps=10, use_assistant_message=request.use_assistant_message),
+            experimental_agent.step_stream(request.messages, max_steps=10, use_assistant_message=request.use_assistant_message),
             media_type="text/event-stream",
         )
     else:

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

@@ -74,7 +74,7 @@ def create_group(
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@router.put("/{group_id}", response_model=Group, operation_id="modify_group")
+@router.patch("/{group_id}", response_model=Group, operation_id="modify_group")
 def modify_group(
     group_id: str,
     group: GroupUpdate = Body(...),

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

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, List, Optional
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query
 
 from letta.orm.errors import NoResultFound, UniqueConstraintViolationError
-from letta.schemas.identity import Identity, IdentityCreate, IdentityType, IdentityUpdate
+from letta.schemas.identity import Identity, IdentityCreate, IdentityProperty, IdentityType, IdentityUpdate, IdentityUpsert
 from letta.server.rest_api.utils import get_letta_server
 
 if TYPE_CHECKING:
@@ -88,7 +88,7 @@ def create_identity(
 
 @router.put("/", tags=["identities"], response_model=Identity, operation_id="upsert_identity")
 def upsert_identity(
-    identity: IdentityCreate = Body(...),
+    identity: IdentityUpsert = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
     x_project: Optional[str] = Header(None, alias="X-Project"),  # Only handled by next js middleware
@@ -118,6 +118,27 @@ def modify_identity(
         raise
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
+    except Exception as e:
+        import traceback
+
+        print(traceback.format_exc())
+        raise HTTPException(status_code=500, detail=f"{e}")
+
+
+@router.put("/{identity_id}/properties", tags=["identities"], operation_id="upsert_identity_properties")
+def upsert_identity_properties(
+    identity_id: str,
+    properties: List[IdentityProperty] = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
+):
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=actor_id)
+        return server.identity_manager.upsert_identity_properties(identity_id=identity_id, properties=properties, actor=actor)
+    except HTTPException:
+        raise
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
 

letta/server/rest_api/utils.py

@@ -19,7 +19,7 @@ from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
 from letta.schemas.enums import MessageRole
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
-from letta.schemas.message import Message
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.server.rest_api.interface import StreamingServerInterface
@@ -140,31 +140,29 @@ def log_error_to_sentry(e):
         sentry_sdk.capture_exception(e)
 
 
-def create_user_message(input_message: dict, agent_id: str, actor: User) -> Message:
+def create_input_messages(input_messages: List[MessageCreate], agent_id: str, actor: User) -> List[Message]:
     """
     Converts a user input message into the internal structured format.
     """
-    # Generate timestamp in the correct format
-    # Skip pytz for performance reasons
-    now = get_utc_time().isoformat()
-
-    # Format message as structured JSON
-    structured_message = {"type": "user_message", "message": input_message["content"], "time": now}
-
-    # Construct the Message object
-    user_message = Message(
-        id=f"message-{uuid.uuid4()}",
-        role=MessageRole.user,
-        content=[TextContent(text=json.dumps(structured_message, indent=2))],  # Store structured JSON
-        organization_id=actor.organization_id,
-        agent_id=agent_id,
-        model=None,
-        tool_calls=None,
-        tool_call_id=None,
-        created_at=get_utc_time(),
-    )
+    new_messages = []
+    for input_message in input_messages:
+        # Construct the Message object
+        new_message = Message(
+            id=f"message-{uuid.uuid4()}",
+            role=input_message.role,
+            content=input_message.content,
+            name=input_message.name,
+            otid=input_message.otid,
+            organization_id=actor.organization_id,
+            agent_id=agent_id,
+            model=None,
+            tool_calls=None,
+            tool_call_id=None,
+            created_at=get_utc_time(),
+        )
+        new_messages.append(new_message)
 
-    return user_message
+    return new_messages
 
 
 def create_letta_messages_from_llm_response(