letta-nightly 0.6.43.dev20250324104208__py3-none-any.whl → 0.6.44.dev20250325050316__py3-none-any.whl

letta/schemas/message.py

@@ -19,6 +19,7 @@ from letta.schemas.enums import MessageRole
 from letta.schemas.letta_base import OrmMetadataBase
 from letta.schemas.letta_message import (
     AssistantMessage,
+    HiddenReasoningMessage,
     LettaMessage,
     ReasoningMessage,
     SystemMessage,
@@ -27,7 +28,13 @@ from letta.schemas.letta_message import (
     ToolReturnMessage,
     UserMessage,
 )
-from letta.schemas.letta_message_content import LettaMessageContentUnion, TextContent, get_letta_message_content_union_str_json_schema
+from letta.schemas.letta_message_content import (
+    LettaMessageContentUnion,
+    ReasoningContent,
+    RedactedReasoningContent,
+    TextContent,
+    get_letta_message_content_union_str_json_schema,
+)
 from letta.system import unpack_message
 
 
@@ -206,23 +213,58 @@ class Message(BaseMessage):
         assistant_message_tool_kwarg: str = DEFAULT_MESSAGE_TOOL_KWARG,
     ) -> List[LettaMessage]:
         """Convert message object (in DB format) to the style used by the original Letta API"""
-        if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
-            text_content = self.content[0].text
-        else:
-            text_content = None
-
         messages = []
 
         if self.role == MessageRole.assistant:
-            if text_content is not None:
-                # This is type InnerThoughts
-                messages.append(
-                    ReasoningMessage(
-                        id=self.id,
-                        date=self.created_at,
-                        reasoning=text_content,
+
+            # Handle reasoning
+            if self.content:
+                # Check for ReACT-style COT inside of TextContent
+                if len(self.content) == 1 and isinstance(self.content[0], TextContent):
+                    messages.append(
+                        ReasoningMessage(
+                            id=self.id,
+                            date=self.created_at,
+                            reasoning=self.content[0].text,
+                        )
                     )
-                )
+                # Otherwise, we may have a list of multiple types
+                else:
+                    # TODO we can probably collapse these two cases into a single loop
+                    for content_part in self.content:
+                        if isinstance(content_part, TextContent):
+                            # COT
+                            messages.append(
+                                ReasoningMessage(
+                                    id=self.id,
+                                    date=self.created_at,
+                                    reasoning=content_part.text,
+                                )
+                            )
+                        elif isinstance(content_part, ReasoningContent):
+                            # "native" COT
+                            messages.append(
+                                ReasoningMessage(
+                                    id=self.id,
+                                    date=self.created_at,
+                                    reasoning=content_part.reasoning,
+                                    source="reasoner_model",  # TODO do we want to tag like this?
+                                    signature=content_part.signature,
+                                )
+                            )
+                        elif isinstance(content_part, RedactedReasoningContent):
+                            # "native" redacted/hidden COT
+                            messages.append(
+                                HiddenReasoningMessage(
+                                    id=self.id,
+                                    date=self.created_at,
+                                    state="redacted",
+                                    hidden_reasoning=content_part.data,
+                                )
+                            )
+                        else:
+                            warnings.warn(f"Unrecognized content part in assistant message: {content_part}")
+
             if self.tool_calls is not None:
                 # This is type FunctionCall
                 for tool_call in self.tool_calls:
@@ -264,7 +306,11 @@ class Message(BaseMessage):
             #         "message": response_string,
             #         "time": formatted_time,
             #     }
-            assert text_content is not None, self
+            if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
+                text_content = self.content[0].text
+            else:
+                raise ValueError(f"Invalid tool return (no text object on message): {self.content}")
+
             try:
                 function_return = json.loads(text_content)
                 status = function_return["status"]
@@ -292,7 +338,11 @@ class Message(BaseMessage):
             )
         elif self.role == MessageRole.user:
             # This is type UserMessage
-            assert text_content is not None, self
+            if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
+                text_content = self.content[0].text
+            else:
+                raise ValueError(f"Invalid user message (no text object on message): {self.content}")
+
             message_str = unpack_message(text_content)
             messages.append(
                 UserMessage(
@@ -303,7 +353,11 @@ class Message(BaseMessage):
             )
         elif self.role == MessageRole.system:
             # This is type SystemMessage
-            assert text_content is not None, self
+            if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
+                text_content = self.content[0].text
+            else:
+                raise ValueError(f"Invalid system message (no text object on system): {self.content}")
+
             messages.append(
                 SystemMessage(
                     id=self.id,
@@ -335,6 +389,29 @@ class Message(BaseMessage):
         assert "role" in openai_message_dict, openai_message_dict
         assert "content" in openai_message_dict, openai_message_dict
 
+        # TODO(caren) implicit support for only non-parts/list content types
+        if openai_message_dict["content"] is not None and type(openai_message_dict["content"]) is not str:
+            raise ValueError(f"Invalid content type: {type(openai_message_dict['content'])}")
+        content = [TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else []
+
+        # TODO(caren) bad assumption here that "reasoning_content" always comes before "redacted_reasoning_content"
+        if "reasoning_content" in openai_message_dict and openai_message_dict["reasoning_content"]:
+            content.append(
+                ReasoningContent(
+                    reasoning=openai_message_dict["reasoning_content"],
+                    is_native=True,
+                    signature=(
+                        openai_message_dict["reasoning_content_signature"] if openai_message_dict["reasoning_content_signature"] else None
+                    ),
+                ),
+            )
+        if "redacted_reasoning_content" in openai_message_dict and openai_message_dict["redacted_reasoning_content"]:
+            content.append(
+                RedactedReasoningContent(
+                    data=openai_message_dict["redacted_reasoning_content"] if "redacted_reasoning_content" in openai_message_dict else None,
+                ),
+            )
+
         # If we're going from deprecated function form
         if openai_message_dict["role"] == "function":
             if not allow_functions_style:
@@ -348,7 +425,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
-                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
+                    content=content,
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -362,7 +439,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole.tool,  # NOTE
-                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
+                    content=content,
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=openai_message_dict["tool_calls"] if "tool_calls" in openai_message_dict else None,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -395,7 +472,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
+                    content=content,
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
@@ -409,7 +486,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
+                    content=content,
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=None,  # NOTE: None, since this field is only non-null for role=='tool'
@@ -442,7 +519,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
+                    content=content,
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -456,7 +533,7 @@ class Message(BaseMessage):
                     model=model,
                     # standard fields expected in an OpenAI ChatCompletion message object
                     role=MessageRole(openai_message_dict["role"]),
-                    content=[TextContent(text=openai_message_dict["content"])] if openai_message_dict["content"] else [],
+                    content=content,
                     name=openai_message_dict["name"] if "name" in openai_message_dict else None,
                     tool_calls=tool_calls,
                     tool_call_id=openai_message_dict["tool_call_id"] if "tool_call_id" in openai_message_dict else None,
@@ -477,11 +554,25 @@ class Message(BaseMessage):
         """Go from Message class to ChatCompletion message object"""
 
         # TODO change to pydantic casting, eg `return SystemMessageModel(self)`
+        # If we only have one content part and it's text, treat it as COT
+        parse_content_parts = False
         if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
             text_content = self.content[0].text
+        # Otherwise, check if we have TextContent and multiple other parts
+        elif self.content and len(self.content) > 1:
+            text = [content for content in self.content if isinstance(self.content[0], TextContent)]
+            if len(text) > 1:
+                assert len(text) == 1, f"multiple text content parts found in a single message: {self.content}"
+                text_content = text[0].text
+                parse_content_parts = True
         else:
             text_content = None
 
+        # TODO(caren) we should eventually support multiple content parts here?
+        # ie, actually make dict['content'] type list
+        # But for now, it's OK until we support multi-modal,
+        # since the only "parts" we have are for supporting various COT
+
         if self.role == "system":
             assert all([v is not None for v in [self.role]]), vars(self)
             openai_message = {
@@ -539,6 +630,15 @@ class Message(BaseMessage):
         else:
             raise ValueError(self.role)
 
+        if parse_content_parts:
+            for content in self.content:
+                if isinstance(content, ReasoningContent):
+                    openai_message["reasoning_content"] = content.reasoning
+                    if content.signature:
+                        openai_message["reasoning_content_signature"] = content.signature
+                if isinstance(content, RedactedReasoningContent):
+                    openai_message["redacted_reasoning_content"] = content.data
+
         return openai_message
 
     def to_anthropic_dict(
@@ -552,6 +652,8 @@ class Message(BaseMessage):
         Args:
             inner_thoughts_xml_tag (str): The XML tag to wrap around inner thoughts
         """
+
+        # Check for COT
         if self.content and len(self.content) == 1 and isinstance(self.content[0], TextContent):
             text_content = self.content[0].text
         else:
@@ -587,7 +689,24 @@ class Message(BaseMessage):
             }
             content = []
             # COT / reasoning / thinking
-            if text_content is not None and not put_inner_thoughts_in_kwargs:
+            if len(self.content) > 1:
+                for content_part in self.content:
+                    if isinstance(content_part, ReasoningContent):
+                        content.append(
+                            {
+                                "type": "thinking",
+                                "thinking": content_part.reasoning,
+                                "signature": content_part.signature,
+                            }
+                        )
+                    if isinstance(content_part, RedactedReasoningContent):
+                        content.append(
+                            {
+                                "type": "redacted_thinking",
+                                "data": content_part.data,
+                            }
+                        )
+            elif text_content is not None:
                 content.append(
                     {
                         "type": "text",

letta/schemas/openai/chat_completion_response.py

@@ -40,6 +40,8 @@ class Message(BaseModel):
     role: str
     function_call: Optional[FunctionCall] = None  # Deprecated
     reasoning_content: Optional[str] = None  # Used in newer reasoning APIs
+    reasoning_content_signature: Optional[str] = None  # NOTE: for Anthropic
+    redacted_reasoning_content: Optional[str] = None  # NOTE: for Anthropic
 
 
 class Choice(BaseModel):
@@ -117,6 +119,8 @@ class MessageDelta(BaseModel):
 
     content: Optional[str] = None
     reasoning_content: Optional[str] = None
+    reasoning_content_signature: Optional[str] = None  # NOTE: for Anthropic
+    redacted_reasoning_content: Optional[str] = None  # NOTE: for Anthropic
     tool_calls: Optional[List[ToolCallDelta]] = None
     role: Optional[str] = None
     function_call: Optional[FunctionCallDelta] = None  # Deprecated
@@ -140,3 +144,4 @@ class ChatCompletionChunkResponse(BaseModel):
     system_fingerprint: Optional[str] = None
     # object: str = Field(default="chat.completion")
     object: Literal["chat.completion.chunk"] = "chat.completion.chunk"
+    output_tokens: int = 0

letta/schemas/organization.py

@@ -16,7 +16,14 @@ class Organization(OrganizationBase):
     id: str = OrganizationBase.generate_id_field()
     name: str = Field(create_random_username(), description="The name of the organization.", json_schema_extra={"default": "SincereYogurt"})
     created_at: Optional[datetime] = Field(default_factory=get_utc_time, description="The creation date of the organization.")
+    privileged_tools: bool = Field(False, description="Whether the organization has access to privileged tools.")
 
 
 class OrganizationCreate(OrganizationBase):
     name: Optional[str] = Field(None, description="The name of the organization.")
+    privileged_tools: Optional[bool] = Field(False, description="Whether the organization has access to privileged tools.")
+
+
+class OrganizationUpdate(OrganizationBase):
+    name: Optional[str] = Field(None, description="The name of the organization.")
+    privileged_tools: Optional[bool] = Field(False, description="Whether the organization has access to privileged tools.")

letta/schemas/providers.py

@@ -157,6 +157,23 @@ class OpenAIProvider(Provider):
                 # if "config" in data and "chat_template" in data["config"] and "tools" not in data["config"]["chat_template"]:
                 # continue
 
+            # for openai, filter models
+            if self.base_url == "https://api.openai.com/v1":
+                allowed_types = ["gpt-4", "o1", "o3"]
+                disallowed_types = ["transcribe", "search", "realtime", "tts", "audio", "computer"]
+                skip = True
+                for model_type in allowed_types:
+                    if model_name.startswith(model_type):
+                        skip = False
+                        break
+                for keyword in disallowed_types:
+                    if keyword in model_name:
+                        skip = True
+                        break
+                # ignore this model
+                if skip:
+                    continue
+
             configs.append(
                 LLMConfig(
                     model=model_name,

letta/schemas/tool.py

@@ -93,7 +93,11 @@ class Tool(BaseTool):
                         description=description,
                     )
                 else:
-                    self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+                    try:
+                        self.json_schema = derive_openai_json_schema(source_code=self.source_code)
+                    except Exception as e:
+                        error_msg = f"Failed to derive json schema for tool with id={self.id} name={self.name}. Error: {str(e)}"
+                        logger.error(error_msg)
         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)

letta/schemas/usage.py

@@ -1,7 +1,9 @@
-from typing import Literal
+from typing import List, Literal, Optional
 
 from pydantic import BaseModel, Field
 
+from letta.schemas.message import Message
+
 
 class LettaUsageStatistics(BaseModel):
     """
@@ -19,3 +21,5 @@ class LettaUsageStatistics(BaseModel):
     prompt_tokens: int = Field(0, description="The number of tokens in the prompt.")
     total_tokens: int = Field(0, description="The total number of tokens processed by the agent.")
     step_count: int = Field(0, description="The number of steps taken by the agent.")
+    # TODO: Optional for now. This field makes everyone's lives easier
+    steps_messages: Optional[List[List[Message]]] = Field(None, description="The messages generated per step")

letta/serialize_schemas/pydantic_agent_schema.py

@@ -92,7 +92,7 @@ class AgentSchema(BaseModel):
     agent_type: str
     core_memory: List[CoreMemoryBlockSchema]
     created_at: str
-    description: str
+    description: Optional[str]
     embedding_config: EmbeddingConfig
     groups: List[Any]
     identities: List[Any]

letta/server/rest_api/interface.py

@@ -13,6 +13,7 @@ from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import (
     AssistantMessage,
+    HiddenReasoningMessage,
     LegacyFunctionCallMessage,
     LegacyLettaMessage,
     LettaMessage,
@@ -22,6 +23,7 @@ from letta.schemas.letta_message import (
     ToolCallMessage,
     ToolReturnMessage,
 )
+from letta.schemas.letta_message_content import ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.message import Message
 from letta.schemas.openai.chat_completion_response import ChatCompletionChunkResponse
 from letta.server.rest_api.optimistic_json_parser import OptimisticJSONParser
@@ -478,7 +480,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
 
         if (
             message_delta.content is None
-            and (expect_reasoning_content and message_delta.reasoning_content is None)
+            and (expect_reasoning_content and message_delta.reasoning_content is None and message_delta.redacted_reasoning_content is None)
             and message_delta.tool_calls is None
             and message_delta.function_call is None
             and choice.finish_reason is None
@@ -493,6 +495,15 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 id=message_id,
                 date=message_date,
                 reasoning=message_delta.reasoning_content,
+                signature=message_delta.reasoning_content_signature,
+                source="reasoner_model" if message_delta.reasoning_content_signature else "non_reasoner_model",
+            )
+        elif expect_reasoning_content and message_delta.redacted_reasoning_content is not None:
+            processed_chunk = HiddenReasoningMessage(
+                id=message_id,
+                date=message_date,
+                hidden_reasoning=message_delta.redacted_reasoning_content,
+                state="redacted",
             )
         elif expect_reasoning_content and message_delta.content is not None:
             # "ignore" content if we expect reasoning content
@@ -1071,13 +1082,39 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
             #     "id": str(msg_obj.id) if msg_obj is not None else None,
             # }
             assert msg_obj is not None, "Internal monologue requires msg_obj references for metadata"
-            processed_chunk = ReasoningMessage(
-                id=msg_obj.id,
-                date=msg_obj.created_at,
-                reasoning=msg,
-            )
+            if msg_obj.content and len(msg_obj.content) == 1 and isinstance(msg_obj.content[0], TextContent):
+                processed_chunk = ReasoningMessage(
+                    id=msg_obj.id,
+                    date=msg_obj.created_at,
+                    reasoning=msg,
+                )
+
+                self._push_to_buffer(processed_chunk)
+            else:
+                for content in msg_obj.content:
+                    if isinstance(content, TextContent):
+                        processed_chunk = ReasoningMessage(
+                            id=msg_obj.id,
+                            date=msg_obj.created_at,
+                            reasoning=content.text,
+                        )
+                    elif isinstance(content, ReasoningContent):
+                        processed_chunk = ReasoningMessage(
+                            id=msg_obj.id,
+                            date=msg_obj.created_at,
+                            source="reasoner_model",
+                            reasoning=content.reasoning,
+                            signature=content.signature,
+                        )
+                    elif isinstance(content, RedactedReasoningContent):
+                        processed_chunk = HiddenReasoningMessage(
+                            id=msg_obj.id,
+                            date=msg_obj.created_at,
+                            state="redacted",
+                            hidden_reasoning=content.data,
+                        )
 
-            self._push_to_buffer(processed_chunk)
+                    self._push_to_buffer(processed_chunk)
 
         return
 

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

@@ -63,6 +63,10 @@ def list_agents(
             "Using this can optimize performance by reducing unnecessary joins."
         ),
     ),
+    ascending: bool = Query(
+        False,
+        description="Whether to sort agents oldest to newest (True) or newest to oldest (False, default)",
+    ),
 ):
     """
     List all agents associated with a given user.
@@ -90,6 +94,7 @@ def list_agents(
         identity_id=identity_id,
         identifier_keys=identifier_keys,
         include_relationships=include_relationships,
+        ascending=ascending,
     )
 
 
@@ -432,9 +437,13 @@ def detach_block(
 def list_passages(
     agent_id: str,
     server: "SyncServer" = Depends(get_letta_server),
-    after: Optional[int] = Query(None, description="Unique ID of the memory to start the query range at."),
-    before: Optional[int] = Query(None, description="Unique ID of the memory to end the query range at."),
+    after: Optional[str] = Query(None, description="Unique ID of the memory to start the query range at."),
+    before: Optional[str] = Query(None, description="Unique ID of the memory to end the query range at."),
     limit: Optional[int] = Query(None, description="How many results to include in the response."),
+    search: Optional[str] = Query(None, description="Search passages by text"),
+    ascending: Optional[bool] = Query(
+        True, description="Whether to sort passages oldest to newest (True, default) or newest to oldest (False)"
+    ),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
@@ -447,7 +456,9 @@ def list_passages(
         agent_id=agent_id,
         after=after,
         before=before,
+        query_text=search,
         limit=limit,
+        ascending=ascending,
     )
 
 

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

@@ -2,7 +2,7 @@ from typing import TYPE_CHECKING, List, Optional
 
 from fastapi import APIRouter, Body, Depends, HTTPException, Query
 
-from letta.schemas.organization import Organization, OrganizationCreate
+from letta.schemas.organization import Organization, OrganizationCreate, OrganizationUpdate
 from letta.server.rest_api.utils import get_letta_server
 
 if TYPE_CHECKING:
@@ -59,3 +59,21 @@ def delete_org(
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
     return org
+
+
+@router.patch("/", tags=["admin"], response_model=Organization, operation_id="update_organization")
+def update_org(
+    org_id: str = Query(..., description="The org_id key to be updated."),
+    request: OrganizationUpdate = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+):
+    try:
+        org = server.organization_manager.get_organization_by_id(org_id=org_id)
+        if org is None:
+            raise HTTPException(status_code=404, detail=f"Organization does not exist")
+        org = server.organization_manager.update_organization(org_id=org_id, name=request.name)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"{e}")
+    return org

letta/server/rest_api/utils.py

@@ -80,7 +80,7 @@ async def sse_async_generator(
                     err_msg = f"Expected LettaUsageStatistics, got {type(usage)}"
                     logger.error(err_msg)
                     raise ValueError(err_msg)
-                yield sse_formatter(usage.model_dump())
+                yield sse_formatter(usage.model_dump(exclude={"steps_messages"}))
 
             except ContextWindowExceededError as e:
                 log_error_to_sentry(e)