letta-nightly 0.6.45.dev20250328104141__py3-none-any.whl → 0.6.46.dev20250330050944__py3-none-any.whl

letta/server/rest_api/interface.py

@@ -465,6 +465,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         # if we expect `reasoning_content``, then that's what gets mapped to ReasoningMessage
         # and `content` needs to be handled outside the interface
         expect_reasoning_content: bool = False,
+        name: Optional[str] = None,
     ) -> Optional[Union[ReasoningMessage, ToolCallMessage, AssistantMessage]]:
         """
         Example data from non-streaming response looks like:
@@ -497,6 +498,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 reasoning=message_delta.reasoning_content,
                 signature=message_delta.reasoning_content_signature,
                 source="reasoner_model" if message_delta.reasoning_content_signature else "non_reasoner_model",
+                name=name,
             )
         elif expect_reasoning_content and message_delta.redacted_reasoning_content is not None:
             processed_chunk = HiddenReasoningMessage(
@@ -504,6 +506,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 date=message_date,
                 hidden_reasoning=message_delta.redacted_reasoning_content,
                 state="redacted",
+                name=name,
             )
         elif expect_reasoning_content and message_delta.content is not None:
             # "ignore" content if we expect reasoning content
@@ -530,6 +533,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         arguments=json.dumps(json_reasoning_content.get("arguments")),
                         tool_call_id=None,
                     ),
+                    name=name,
                 )
 
             except json.JSONDecodeError as e:
@@ -559,6 +563,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 id=message_id,
                 date=message_date,
                 reasoning=message_delta.content,
+                name=name,
             )
 
         # tool calls
@@ -607,7 +612,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                         # TODO: Assumes consistent state and that prev_content is subset of new_content
                         diff = new_content.replace(prev_content, "", 1)
                         self.current_json_parse_result = parsed_args
-                        processed_chunk = AssistantMessage(id=message_id, date=message_date, content=diff)
+                        processed_chunk = AssistantMessage(id=message_id, date=message_date, content=diff, name=name)
                     else:
                         return None
 
@@ -639,6 +644,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                 arguments=tool_call_delta.get("arguments"),
                                 tool_call_id=tool_call_delta.get("id"),
                             ),
+                            name=name,
                         )
 
             elif self.inner_thoughts_in_kwargs and tool_call.function:
@@ -674,6 +680,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             id=message_id,
                             date=message_date,
                             reasoning=updates_inner_thoughts,
+                            name=name,
                         )
                         # Additionally inner thoughts may stream back with a chunk of main JSON
                         # In that case, since we can only return a chunk at a time, we should buffer it
@@ -709,6 +716,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                         arguments=None,
                                         tool_call_id=self.function_id_buffer,
                                     ),
+                                    name=name,
                                 )
 
                             # Record what the last function name we flushed was
@@ -765,6 +773,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                         id=message_id,
                                         date=message_date,
                                         content=combined_chunk,
+                                        name=name,
                                     )
                                     # Store the ID of the tool call so allow skipping the corresponding response
                                     if self.function_id_buffer:
@@ -789,7 +798,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                         # TODO: Assumes consistent state and that prev_content is subset of new_content
                                         diff = new_content.replace(prev_content, "", 1)
                                         self.current_json_parse_result = parsed_args
-                                        processed_chunk = AssistantMessage(id=message_id, date=message_date, content=diff)
+                                        processed_chunk = AssistantMessage(id=message_id, date=message_date, content=diff, name=name)
                                     else:
                                         return None
 
@@ -813,6 +822,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                             arguments=combined_chunk,
                                             tool_call_id=self.function_id_buffer,
                                         ),
+                                        name=name,
                                     )
                                     # clear buffer
                                     self.function_args_buffer = None
@@ -827,6 +837,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                             arguments=updates_main_json,
                                             tool_call_id=self.function_id_buffer,
                                         ),
+                                        name=name,
                                     )
                                     self.function_id_buffer = None
 
@@ -955,6 +966,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             arguments=tool_call_delta.get("arguments"),
                             tool_call_id=tool_call_delta.get("id"),
                         ),
+                        name=name,
                     )
 
         elif choice.finish_reason is not None:
@@ -1035,6 +1047,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         message_id: str,
         message_date: datetime,
         expect_reasoning_content: bool = False,
+        name: Optional[str] = None,
     ):
         """Process a streaming chunk from an OpenAI-compatible server.
 
@@ -1060,6 +1073,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 message_id=message_id,
                 message_date=message_date,
                 expect_reasoning_content=expect_reasoning_content,
+                name=name,
             )
 
         if processed_chunk is None:
@@ -1087,6 +1101,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     id=msg_obj.id,
                     date=msg_obj.created_at,
                     reasoning=msg,
+                    name=msg_obj.name,
                 )
 
                 self._push_to_buffer(processed_chunk)
@@ -1097,6 +1112,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             id=msg_obj.id,
                             date=msg_obj.created_at,
                             reasoning=content.text,
+                            name=msg_obj.name,
                         )
                     elif isinstance(content, ReasoningContent):
                         processed_chunk = ReasoningMessage(
@@ -1105,6 +1121,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             source="reasoner_model",
                             reasoning=content.reasoning,
                             signature=content.signature,
+                            name=msg_obj.name,
                         )
                     elif isinstance(content, RedactedReasoningContent):
                         processed_chunk = HiddenReasoningMessage(
@@ -1112,6 +1129,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             date=msg_obj.created_at,
                             state="redacted",
                             hidden_reasoning=content.data,
+                            name=msg_obj.name,
                         )
 
                     self._push_to_buffer(processed_chunk)
@@ -1172,6 +1190,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                 id=msg_obj.id,
                                 date=msg_obj.created_at,
                                 content=func_args["message"],
+                                name=msg_obj.name,
                             )
                             self._push_to_buffer(processed_chunk)
                         except Exception as e:
@@ -1194,6 +1213,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                             id=msg_obj.id,
                             date=msg_obj.created_at,
                             content=func_args[self.assistant_message_tool_kwarg],
+                            name=msg_obj.name,
                         )
                         # Store the ID of the tool call so allow skipping the corresponding response
                         self.prev_assistant_message_id = function_call.id
@@ -1206,6 +1226,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                                 arguments=function_call.function.arguments,
                                 tool_call_id=function_call.id,
                             ),
+                            name=msg_obj.name,
                         )
 
                     # processed_chunk = {
@@ -1245,6 +1266,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     tool_call_id=msg_obj.tool_call_id,
                     stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
                     stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
+                    name=msg_obj.name,
                 )
 
         elif msg.startswith("Error: "):
@@ -1259,6 +1281,7 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                 tool_call_id=msg_obj.tool_call_id,
                 stdout=msg_obj.tool_returns[0].stdout if msg_obj.tool_returns else None,
                 stderr=msg_obj.tool_returns[0].stderr if msg_obj.tool_returns else None,
+                name=msg_obj.name,
             )
 
         else:

letta/server/rest_api/optimistic_json_parser.py

@@ -10,7 +10,7 @@ class OptimisticJSONParser:
     tries to tolerate incomplete strings and incomplete numbers.
     """
 
-    def __init__(self, strict=True):
+    def __init__(self, strict=False):
         self.strict = strict
         self.parsers = {
             " ": self.parse_space,

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

@@ -9,6 +9,7 @@ from marshmallow import ValidationError
 from pydantic import Field
 from sqlalchemy.exc import IntegrityError, OperationalError
 
+from letta.agents.letta_agent import LettaAgent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
 from letta.orm.errors import NoResultFound
@@ -19,6 +20,8 @@ from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUni
 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
@@ -27,6 +30,7 @@ from letta.schemas.user import User
 from letta.serialize_schemas.pydantic_agent_schema import AgentSchema
 from letta.server.rest_api.utils import get_letta_server
 from letta.server.server import SyncServer
+from letta.settings import settings
 
 # These can be forward refs, but because Fastapi needs them at runtime the must be imported normally
 
@@ -523,6 +527,7 @@ def list_messages(
     after: Optional[str] = Query(None, description="Message after which to retrieve the returned messages."),
     before: Optional[str] = Query(None, description="Message before which to retrieve the returned messages."),
     limit: int = Query(10, description="Maximum number of messages to retrieve."),
+    group_id: Optional[str] = Query(None, description="Group ID to filter messages by."),
     use_assistant_message: bool = Query(True, description="Whether to use assistant messages"),
     assistant_message_tool_name: str = Query(DEFAULT_MESSAGE_TOOL, description="The name of the designated message tool."),
     assistant_message_tool_kwarg: str = Query(DEFAULT_MESSAGE_TOOL_KWARG, description="The name of the message argument."),
@@ -539,6 +544,7 @@ def list_messages(
         after=after,
         before=before,
         limit=limit,
+        group_id=group_id,
         reverse=True,
         return_message_object=False,
         use_assistant_message=use_assistant_message,
@@ -579,17 +585,32 @@ async def send_message(
     This endpoint accepts a message from a user and processes it through the agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    result = await server.send_message_to_agent(
-        agent_id=agent_id,
-        actor=actor,
-        messages=request.messages,
-        stream_steps=False,
-        stream_tokens=False,
-        # Support for AssistantMessage
-        use_assistant_message=request.use_assistant_message,
-        assistant_message_tool_name=request.assistant_message_tool_name,
-        assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
-    )
+    if settings.use_experimental:
+        logger.warning("USING EXPERIMENTAL!")
+        experimental_agent = LettaAgent(
+            agent_id=agent_id,
+            message_manager=server.message_manager,
+            agent_manager=server.agent_manager,
+            block_manager=server.block_manager,
+            passage_manager=server.passage_manager,
+            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)
+    else:
+        result = await server.send_message_to_agent(
+            agent_id=agent_id,
+            actor=actor,
+            messages=request.messages,
+            stream_steps=False,
+            stream_tokens=False,
+            # Support for AssistantMessage
+            use_assistant_message=request.use_assistant_message,
+            assistant_message_tool_name=request.assistant_message_tool_name,
+            assistant_message_tool_kwarg=request.assistant_message_tool_kwarg,
+        )
     return result
 
 
@@ -637,7 +658,7 @@ async def process_message_background(
     server: SyncServer,
     actor: User,
     agent_id: str,
-    messages: list,
+    messages: List[MessageCreate],
     use_assistant_message: bool,
     assistant_message_tool_name: str,
     assistant_message_tool_kwarg: str,
@@ -645,17 +666,30 @@ async def process_message_background(
     """Background task to process the message and update job status."""
     try:
         # TODO(matt) we should probably make this stream_steps and log each step as it progresses, so the job update GET can see the total steps so far + partial usage?
-        result = await server.send_message_to_agent(
-            agent_id=agent_id,
-            actor=actor,
-            messages=messages,
-            stream_steps=False,  # NOTE(matt)
-            stream_tokens=False,
-            use_assistant_message=use_assistant_message,
-            assistant_message_tool_name=assistant_message_tool_name,
-            assistant_message_tool_kwarg=assistant_message_tool_kwarg,
-            metadata={"job_id": job_id},  # Pass job_id through metadata
-        )
+        if settings.use_experimental:
+            logger.warning("USING EXPERIMENTAL!")
+            experimental_agent = LettaAgent(
+                agent_id=agent_id,
+                message_manager=server.message_manager,
+                agent_manager=server.agent_manager,
+                block_manager=server.block_manager,
+                passage_manager=server.passage_manager,
+                actor=actor,
+            )
+            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)
+        else:
+            result = await server.send_message_to_agent(
+                agent_id=agent_id,
+                actor=actor,
+                messages=messages,
+                stream_steps=False,  # NOTE(matt)
+                stream_tokens=False,
+                use_assistant_message=use_assistant_message,
+                assistant_message_tool_name=assistant_message_tool_name,
+                assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+                metadata={"job_id": job_id},  # Pass job_id through metadata
+            )
 
         # Update job status to completed
         job_update = JobUpdate(

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

@@ -1,11 +1,13 @@
 from typing import Annotated, List, Optional
 
-from fastapi import APIRouter, Body, Depends, Header, Query
+from fastapi import APIRouter, Body, Depends, Header, HTTPException, Query, status
+from fastapi.responses import JSONResponse
 from pydantic import Field
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.schemas.group import Group, GroupCreate, ManagerType
-from letta.schemas.letta_message import LettaMessageUnion
+from letta.orm.errors import NoResultFound
+from letta.schemas.group import Group, GroupCreate, GroupUpdate, ManagerType
+from letta.schemas.letta_message import LettaMessageUnion, LettaMessageUpdateUnion
 from letta.schemas.letta_request import LettaRequest, LettaStreamingRequest
 from letta.schemas.letta_response import LettaResponse
 from letta.server.rest_api.utils import get_letta_server
@@ -14,21 +16,6 @@ from letta.server.server import SyncServer
 router = APIRouter(prefix="/groups", tags=["groups"])
 
 
-@router.post("/", response_model=Group, operation_id="create_group")
-async def create_group(
-    server: SyncServer = Depends(get_letta_server),
-    request: GroupCreate = Body(...),
-    actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
-):
-    """
-    Create a multi-agent group with a specified management pattern. When no
-    management config is specified, this endpoint will use round robin for
-    speaker selection.
-    """
-    actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    return server.group_manager.create_group(request, actor=actor)
-
-
 @router.get("/", response_model=List[Group], operation_id="list_groups")
 def list_groups(
     server: "SyncServer" = Depends(get_letta_server),
@@ -53,6 +40,23 @@ def list_groups(
     )
 
 
+@router.get("/{group_id}", response_model=Group, operation_id="retrieve_group")
+def retrieve_group(
+    group_id: str,
+    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
+):
+    """
+    Retrieve the group by id.
+    """
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+
+    try:
+        return server.group_manager.retrieve_group(group_id=group_id, actor=actor)
+    except NoResultFound as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
 @router.post("/", response_model=Group, operation_id="create_group")
 def create_group(
     group: GroupCreate = Body(...),
@@ -70,9 +74,10 @@ def create_group(
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@router.put("/", response_model=Group, operation_id="upsert_group")
-def upsert_group(
-    group: GroupCreate = Body(...),
+@router.put("/{group_id}", response_model=Group, operation_id="modify_group")
+def modify_group(
+    group_id: str,
+    group: GroupUpdate = 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
@@ -82,7 +87,7 @@ def upsert_group(
     """
     try:
         actor = server.user_manager.get_user_or_default(user_id=actor_id)
-        return server.group_manager.create_group(group, actor=actor)
+        return server.group_manager.modify_group(group_id=group_id, group_update=group, actor=actor)
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -110,7 +115,7 @@ def delete_group(
     operation_id="send_group_message",
 )
 async def send_group_message(
-    agent_id: str,
+    group_id: str,
     server: SyncServer = Depends(get_letta_server),
     request: LettaRequest = Body(...),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
@@ -178,6 +183,22 @@ GroupMessagesResponse = Annotated[
 ]
 
 
+@router.patch("/{group_id}/messages/{message_id}", response_model=LettaMessageUnion, operation_id="modify_group_message")
+def modify_group_message(
+    group_id: str,
+    message_id: str,
+    request: LettaMessageUpdateUnion = 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
+):
+    """
+    Update the details of a message associated with an agent.
+    """
+    # TODO: support modifying tool calls/returns
+    actor = server.user_manager.get_user_or_default(user_id=actor_id)
+    return server.message_manager.update_message_by_letta_message(message_id=message_id, letta_message_update=request, actor=actor)
+
+
 @router.get("/{group_id}/messages", response_model=GroupMessagesResponse, operation_id="list_group_messages")
 def list_group_messages(
     group_id: str,
@@ -194,40 +215,42 @@ def list_group_messages(
     Retrieve message history for an agent.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-
-    return server.group_manager.list_group_messages(
-        group_id=group_id,
-        before=before,
-        after=after,
-        limit=limit,
-        actor=actor,
-        use_assistant_message=use_assistant_message,
-        assistant_message_tool_name=assistant_message_tool_name,
-        assistant_message_tool_kwarg=assistant_message_tool_kwarg,
-    )
+    group = server.group_manager.retrieve_group(group_id=group_id, actor=actor)
+    if group.manager_agent_id:
+        return server.get_agent_recall(
+            user_id=actor.id,
+            agent_id=group.manager_agent_id,
+            after=after,
+            before=before,
+            limit=limit,
+            group_id=group_id,
+            reverse=True,
+            return_message_object=False,
+            use_assistant_message=use_assistant_message,
+            assistant_message_tool_name=assistant_message_tool_name,
+            assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+        )
+    else:
+        return server.group_manager.list_group_messages(
+            group_id=group_id,
+            after=after,
+            before=before,
+            limit=limit,
+            actor=actor,
+            use_assistant_message=use_assistant_message,
+            assistant_message_tool_name=assistant_message_tool_name,
+            assistant_message_tool_kwarg=assistant_message_tool_kwarg,
+        )
 
 
-'''
 @router.patch("/{group_id}/reset-messages", response_model=None, operation_id="reset_group_messages")
 def reset_group_messages(
     group_id: str,
-    add_default_initial_messages: bool = Query(default=False, description="If true, adds the default initial messages after resetting."),
     server: "SyncServer" = Depends(get_letta_server),
     actor_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     """
-    Resets the messages for all agents that are part of the multi-agent group.
-    TODO: only delete group messages not all messages!
+    Delete the group messages for all agents that are part of the multi-agent group.
     """
     actor = server.user_manager.get_user_or_default(user_id=actor_id)
-    group = server.group_manager.retrieve_group(group_id=group_id, actor=actor)
-    agent_ids = group.agent_ids
-    if group.manager_agent_id:
-        agent_ids.append(group.manager_agent_id)
-    for agent_id in agent_ids:
-        server.agent_manager.reset_messages(
-            agent_id=agent_id,
-            actor=actor,
-            add_default_initial_messages=add_default_initial_messages,
-        )
-'''
+    server.group_manager.reset_messages(group_id=group_id, actor=actor)

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

@@ -4,6 +4,7 @@ from typing import List, Optional
 
 from fastapi import APIRouter, BackgroundTasks, Depends, Header, HTTPException, Query, UploadFile
 
+import letta.constants as constants
 from letta.schemas.file import FileMetadata
 from letta.schemas.job import Job
 from letta.schemas.passage import Passage

letta/server/rest_api/utils.py

@@ -211,7 +211,6 @@ def create_tool_call_messages_from_openai_response(
         tool_calls=[],
         tool_call_id=tool_call_id,
         created_at=get_utc_time(),
-        name=function_name,
     )
     messages.append(tool_message)