letta-nightly 0.6.28.dev20250220163833__py3-none-any.whl → 0.6.29.dev20250221033538__py3-none-any.whl

letta/server/rest_api/routers/openai/chat_completions/chat_completions.py

@@ -1,21 +1,30 @@
 import asyncio
-from typing import TYPE_CHECKING, Iterable, List, Optional, Union, cast
+from typing import TYPE_CHECKING, List, Optional, Union
 
+import httpx
+import openai
 from fastapi import APIRouter, Body, Depends, Header, HTTPException
 from fastapi.responses import StreamingResponse
-from openai.types.chat import ChatCompletionMessageParam
 from openai.types.chat.completion_create_params import CompletionCreateParams
+from starlette.concurrency import run_in_threadpool
 
 from letta.agent import Agent
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.log import get_logger
-from letta.schemas.message import MessageCreate
-from letta.schemas.openai.chat_completion_response import Message
+from letta.schemas.message import Message, MessageCreate
 from letta.schemas.user import User
 from letta.server.rest_api.chat_completions_interface import ChatCompletionsStreamingInterface
 
 # TODO this belongs in a controller!
-from letta.server.rest_api.utils import get_letta_server, sse_async_generator
+from letta.server.rest_api.utils import (
+    convert_letta_messages_to_openai,
+    create_assistant_message_from_openai_response,
+    create_user_message,
+    get_letta_server,
+    get_messages_from_completion_request,
+    sse_async_generator,
+)
+from letta.settings import model_settings
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -25,6 +34,88 @@ router = APIRouter(prefix="/v1", tags=["chat_completions"])
 logger = get_logger(__name__)
 
 
+@router.post(
+    "/fast/chat/completions",
+    response_model=None,
+    operation_id="create_fast_chat_completions",
+    responses={
+        200: {
+            "description": "Successful response",
+            "content": {
+                "text/event-stream": {"description": "Server-Sent Events stream"},
+            },
+        }
+    },
+)
+async def create_fast_chat_completions(
+    completion_request: CompletionCreateParams = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    # TODO: This is necessary, we need to factor out CompletionCreateParams due to weird behavior
+    agent_id = str(completion_request.get("user", None))
+    if agent_id is None:
+        error_msg = "Must pass agent_id in the 'user' field"
+        logger.error(error_msg)
+        raise HTTPException(status_code=400, detail=error_msg)
+    model = completion_request.get("model")
+
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+    client = openai.AsyncClient(
+        api_key=model_settings.openai_api_key,
+        max_retries=0,
+        http_client=httpx.AsyncClient(
+            timeout=httpx.Timeout(connect=15.0, read=5.0, write=5.0, pool=5.0),
+            follow_redirects=True,
+            limits=httpx.Limits(
+                max_connections=50,
+                max_keepalive_connections=50,
+                keepalive_expiry=120,
+            ),
+        ),
+    )
+
+    # Magic message manipulating
+    input_message = get_messages_from_completion_request(completion_request)[-1]
+    completion_request.pop("messages")
+
+    # Get in context messages
+    in_context_messages = server.agent_manager.get_in_context_messages(agent_id=agent_id, actor=actor)
+    openai_dict_in_context_messages = convert_letta_messages_to_openai(in_context_messages)
+    openai_dict_in_context_messages.append(input_message)
+
+    async def event_stream():
+        # TODO: Factor this out into separate interface
+        response_accumulator = []
+
+        stream = await client.chat.completions.create(**completion_request, messages=openai_dict_in_context_messages)
+
+        async with stream:
+            async for chunk in stream:
+                if chunk.choices and chunk.choices[0].delta.content:
+                    # TODO: This does not support tool calling right now
+                    response_accumulator.append(chunk.choices[0].delta.content)
+                yield f"data: {chunk.model_dump_json()}\n\n"
+
+        # Construct messages
+        user_message = create_user_message(input_message=input_message, agent_id=agent_id, actor=actor)
+        assistant_message = create_assistant_message_from_openai_response(
+            response_text="".join(response_accumulator), agent_id=agent_id, model=str(model), actor=actor
+        )
+
+        # Persist both in one synchronous DB call, done in a threadpool
+        await run_in_threadpool(
+            server.agent_manager.append_to_in_context_messages,
+            [user_message, assistant_message],
+            agent_id=agent_id,
+            actor=actor,
+        )
+
+        yield "data: [DONE]\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+
 @router.post(
     "/chat/completions",
     response_model=None,
@@ -44,26 +135,8 @@ async def create_chat_completions(
     user_id: Optional[str] = Header(None, alias="user_id"),
 ):
     # Validate and process fields
-    try:
-        messages = list(cast(Iterable[ChatCompletionMessageParam], completion_request["messages"]))
-    except KeyError:
-        # Handle the case where "messages" is not present in the request
-        raise HTTPException(status_code=400, detail="The 'messages' field is missing in the request.")
-    except TypeError:
-        # Handle the case where "messages" is not iterable
-        raise HTTPException(status_code=400, detail="The 'messages' field must be an iterable.")
-    except Exception as e:
-        # Catch any other unexpected errors and include the exception message
-        raise HTTPException(status_code=400, detail=f"An error occurred while processing 'messages': {str(e)}")
-
-    if messages[-1]["role"] != "user":
-        logger.error(f"The last message does not have a `user` role: {messages}")
-        raise HTTPException(status_code=400, detail="'messages[-1].role' must be a 'user'")
-
+    messages = get_messages_from_completion_request(completion_request)
     input_message = messages[-1]
-    if not isinstance(input_message["content"], str):
-        logger.error(f"The input message does not have valid content: {input_message}")
-        raise HTTPException(status_code=400, detail="'messages[-1].content' must be a 'string'")
 
     # Process remaining fields
     if not completion_request["stream"]:
@@ -138,6 +211,7 @@ async def send_message_to_agent_chat_completions(
                 agent_id=letta_agent.agent_state.id,
                 messages=messages,
                 interface=streaming_interface,
+                put_inner_thoughts_first=False,
             )
         )
 

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

@@ -1,3 +1,4 @@
+import traceback
 from datetime import datetime
 from typing import Annotated, List, Optional
 
@@ -51,7 +52,7 @@ def list_agents(
     project_id: Optional[str] = Query(None, description="Search agents by project id"),
     template_id: Optional[str] = Query(None, description="Search agents by template id"),
     base_template_id: Optional[str] = Query(None, description="Search agents by base template id"),
-    identifier_key: Optional[str] = Query(None, description="Search agents by identifier key"),
+    identifier_keys: Optional[List[str]] = Query(None, description="Search agents by identifier keys"),
 ):
     """
     List all agents associated with a given user.
@@ -67,7 +68,6 @@ def list_agents(
             "project_id": project_id,
             "template_id": template_id,
             "base_template_id": base_template_id,
-            "identifier_key": identifier_key,
         }.items()
         if value is not None
     }
@@ -81,6 +81,7 @@ def list_agents(
         query_text=query_text,
         tags=tags,
         match_all_tags=match_all_tags,
+        identifier_keys=identifier_keys,
         **kwargs,
     )
     return agents
@@ -119,8 +120,12 @@ def create_agent(
     """
     Create a new agent with the specified configuration.
     """
-    actor = server.user_manager.get_user_or_default(user_id=user_id)
-    return server.create_agent(agent, actor=actor)
+    try:
+        actor = server.user_manager.get_user_or_default(user_id=user_id)
+        return server.create_agent(agent, actor=actor)
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.patch("/{agent_id}", response_model=AgentState, operation_id="modify_agent")

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

@@ -16,6 +16,7 @@ router = APIRouter(prefix="/identities", tags=["identities"])
 def list_identities(
     name: Optional[str] = Query(None),
     project_id: Optional[str] = Query(None),
+    identifier_key: Optional[str] = Query(None),
     identity_type: Optional[IdentityType] = Query(None),
     before: Optional[str] = Query(None),
     after: Optional[str] = Query(None),
@@ -30,7 +31,14 @@ def list_identities(
         actor = server.user_manager.get_user_or_default(user_id=user_id)
 
         identities = server.identity_manager.list_identities(
-            name=name, project_id=project_id, identity_type=identity_type, before=before, after=after, limit=limit, actor=actor
+            name=name,
+            project_id=project_id,
+            identifier_key=identifier_key,
+            identity_type=identity_type,
+            before=before,
+            after=after,
+            limit=limit,
+            actor=actor,
         )
     except HTTPException:
         raise
@@ -39,13 +47,15 @@ def list_identities(
     return identities
 
 
-@router.get("/{identifier_key}", tags=["identities"], response_model=Identity, operation_id="get_identity_from_identifier_key")
+@router.get("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="retrieve_identity")
 def retrieve_identity(
-    identifier_key: str,
+    identity_id: str,
     server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
     try:
-        return server.identity_manager.get_identity_from_identifier_key(identifier_key=identifier_key)
+        actor = server.user_manager.get_user_or_default(user_id=user_id)
+        return server.identity_manager.get_identity(identity_id=identity_id, actor=actor)
     except NoResultFound as e:
         raise HTTPException(status_code=404, detail=str(e))
 
@@ -82,25 +92,25 @@ def upsert_identity(
         raise HTTPException(status_code=500, detail=f"{e}")
 
 
-@router.patch("/{identifier_key}", tags=["identities"], response_model=Identity, operation_id="update_identity")
+@router.patch("/{identity_id}", tags=["identities"], response_model=Identity, operation_id="update_identity")
 def modify_identity(
-    identifier_key: str,
+    identity_id: str,
     identity: IdentityUpdate = Body(...),
     server: "SyncServer" = Depends(get_letta_server),
     user_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=user_id)
-        return server.identity_manager.update_identity_by_key(identifier_key=identifier_key, identity=identity, actor=actor)
+        return server.identity_manager.update_identity(identity_id=identity_id, identity=identity, actor=actor)
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"{e}")
 
 
-@router.delete("/{identifier_key}", tags=["identities"], operation_id="delete_identity")
+@router.delete("/{identity_id}", tags=["identities"], operation_id="delete_identity")
 def delete_identity(
-    identifier_key: str,
+    identity_id: str,
     server: "SyncServer" = Depends(get_letta_server),
     user_id: Optional[str] = Header(None, alias="user_id"),  # Extract user_id from header, default to None if not present
 ):
@@ -108,4 +118,4 @@ def delete_identity(
     Delete an identity by its identifier key
     """
     actor = server.user_manager.get_user_or_default(user_id=user_id)
-    server.identity_manager.delete_identity_by_key(identifier_key=identifier_key, actor=actor)
+    server.identity_manager.delete_identity(identity_id=identity_id, actor=actor)

letta/server/rest_api/utils.py

@@ -1,23 +1,33 @@
 import asyncio
 import json
 import os
+import uuid
 import warnings
+from datetime import datetime, timezone
 from enum import Enum
-from typing import TYPE_CHECKING, AsyncGenerator, Optional, Union
+from typing import TYPE_CHECKING, AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
 
-from fastapi import Header
+import pytz
+from fastapi import Header, HTTPException
+from openai.types.chat import ChatCompletionMessageParam
+from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall as OpenAIToolCall
+from openai.types.chat.chat_completion_message_tool_call import Function as OpenAIFunction
+from openai.types.chat.completion_create_params import CompletionCreateParams
 from pydantic import BaseModel
 
+from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.errors import ContextWindowExceededError, RateLimitExceededError
 from letta.log import get_logger
+from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message import TextContent
+from letta.schemas.message import Message
 from letta.schemas.usage import LettaUsageStatistics
+from letta.schemas.user import User
 from letta.server.rest_api.interface import StreamingServerInterface
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
 
-# from letta.orm.user import User
-# from letta.orm.utilities import get_db_session
 
 SSE_PREFIX = "data: "
 SSE_SUFFIX = "\n\n"
@@ -128,3 +138,172 @@ def log_error_to_sentry(e):
         import sentry_sdk
 
         sentry_sdk.capture_exception(e)
+
+
+def create_user_message(input_message: dict, agent_id: str, actor: User) -> Message:
+    """
+    Converts a user input message into the internal structured format.
+    """
+    # Generate timestamp in the correct format
+    now = datetime.now(pytz.timezone("US/Pacific")).strftime("%Y-%m-%d %I:%M:%S %p %Z%z")
+
+    # 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=datetime.now(timezone.utc),
+    )
+
+    return user_message
+
+
+def create_assistant_message_from_openai_response(
+    response_text: str,
+    agent_id: str,
+    model: str,
+    actor: User,
+) -> Message:
+    """
+    Converts an OpenAI response into a Message that follows the internal
+    paradigm where LLM responses are structured as tool calls instead of content.
+    """
+    tool_call_id = str(uuid.uuid4())
+
+    # Construct the tool call with the assistant's message
+    tool_call = OpenAIToolCall(
+        id=tool_call_id,
+        function=OpenAIFunction(
+            name=DEFAULT_MESSAGE_TOOL,
+            arguments='{\n  "' + DEFAULT_MESSAGE_TOOL_KWARG + '": ' + f'"{response_text}",\n  "request_heartbeat": true\n' + "}",
+        ),
+        type="function",
+    )
+
+    # Construct the Message object
+    assistant_message = Message(
+        id=f"message-{uuid.uuid4()}",
+        role=MessageRole.assistant,
+        content=[],
+        organization_id=actor.organization_id,
+        agent_id=agent_id,
+        model=model,
+        tool_calls=[tool_call],
+        tool_call_id=None,
+        created_at=datetime.now(timezone.utc),
+    )
+
+    return assistant_message
+
+
+def convert_letta_messages_to_openai(messages: List[Message]) -> List[dict]:
+    """
+    Flattens Letta's messages (with system, user, assistant, tool roles, etc.)
+    into standard OpenAI chat messages (system, user, assistant).
+
+    Transformation rules:
+      1. Assistant + send_message tool_call => content = tool_call's "message"
+      2. Tool (role=tool) referencing send_message => skip
+      3. User messages might store actual text inside JSON => parse that into content
+      4. System => pass through as normal
+    """
+
+    openai_messages = []
+
+    for msg in messages:
+        # 1. Assistant + 'send_message' tool_calls => flatten
+        if msg.role == MessageRole.assistant and msg.tool_calls:
+            # Find any 'send_message' tool_calls
+            send_message_calls = [tc for tc in msg.tool_calls if tc.function.name == "send_message"]
+            if send_message_calls:
+                # If we have multiple calls, just pick the first or merge them
+                # Typically there's only one.
+                tc = send_message_calls[0]
+                arguments = json.loads(tc.function.arguments)
+                # Extract the "message" string
+                extracted_text = arguments.get("message", "")
+
+                # Create a new content with the extracted text
+                msg = Message(
+                    id=msg.id,
+                    role=msg.role,
+                    content=[TextContent(text=extracted_text)],
+                    organization_id=msg.organization_id,
+                    agent_id=msg.agent_id,
+                    model=msg.model,
+                    name=msg.name,
+                    tool_calls=None,  # no longer needed
+                    tool_call_id=None,
+                    created_at=msg.created_at,
+                )
+
+        # 2. If role=tool and it's referencing send_message => skip
+        if msg.role == MessageRole.tool and msg.name == "send_message":
+            # Usually 'tool' messages with `send_message` are just status/OK messages
+            # that OpenAI doesn't need to see. So skip them.
+            continue
+
+        # 3. User messages might store text in JSON => parse it
+        if msg.role == MessageRole.user:
+            # Example: content=[TextContent(text='{"type": "user_message","message":"Hello"}')]
+            # Attempt to parse JSON and extract "message"
+            if msg.content and msg.content[0].text.strip().startswith("{"):
+                try:
+                    parsed = json.loads(msg.content[0].text)
+                    # If there's a "message" field, use that as the content
+                    if "message" in parsed:
+                        actual_user_text = parsed["message"]
+                        msg = Message(
+                            id=msg.id,
+                            role=msg.role,
+                            content=[TextContent(text=actual_user_text)],
+                            organization_id=msg.organization_id,
+                            agent_id=msg.agent_id,
+                            model=msg.model,
+                            name=msg.name,
+                            tool_calls=msg.tool_calls,
+                            tool_call_id=msg.tool_call_id,
+                            created_at=msg.created_at,
+                        )
+                except json.JSONDecodeError:
+                    pass  # It's not JSON, leave as-is
+
+        # 4. System is left as-is (or any other role that doesn't need special handling)
+        #
+        # Finally, convert to dict using your existing method
+        openai_messages.append(msg.to_openai_dict())
+
+    return openai_messages
+
+
+def get_messages_from_completion_request(completion_request: CompletionCreateParams) -> List[Dict]:
+    try:
+        messages = list(cast(Iterable[ChatCompletionMessageParam], completion_request["messages"]))
+    except KeyError:
+        # Handle the case where "messages" is not present in the request
+        raise HTTPException(status_code=400, detail="The 'messages' field is missing in the request.")
+    except TypeError:
+        # Handle the case where "messages" is not iterable
+        raise HTTPException(status_code=400, detail="The 'messages' field must be an iterable.")
+    except Exception as e:
+        # Catch any other unexpected errors and include the exception message
+        raise HTTPException(status_code=400, detail=f"An error occurred while processing 'messages': {str(e)}")
+
+    if messages[-1]["role"] != "user":
+        logger.error(f"The last message does not have a `user` role: {messages}")
+        raise HTTPException(status_code=400, detail="'messages[-1].role' must be a 'user'")
+
+    input_message = messages[-1]
+    if not isinstance(input_message["content"], str):
+        logger.error(f"The input message does not have valid content: {input_message}")
+        raise HTTPException(status_code=400, detail="'messages[-1].content' must be a 'string'")
+
+    return messages

letta/server/server.py

@@ -336,6 +336,7 @@ class SyncServer(Server):
         agent_id: str,
         input_messages: Union[Message, List[Message]],
         interface: Union[AgentInterface, None] = None,  # needed to getting responses
+        put_inner_thoughts_first: bool = True,
         # timestamp: Optional[datetime],
     ) -> LettaUsageStatistics:
         """Send the input message through the agent"""
@@ -368,6 +369,7 @@ class SyncServer(Server):
                 stream=token_streaming,
                 skip_verify=True,
                 metadata=metadata,
+                put_inner_thoughts_first=put_inner_thoughts_first,
             )
 
         except Exception as e:
@@ -625,6 +627,7 @@ class SyncServer(Server):
         wrap_system_message: bool = True,
         interface: Union[AgentInterface, ChatCompletionsStreamingInterface, None] = None,  # needed to getting responses
         metadata: Optional[dict] = None,  # Pass through metadata to interface
+        put_inner_thoughts_first: bool = True,
     ) -> LettaUsageStatistics:
         """Send a list of messages to the agent
 
@@ -675,7 +678,13 @@ class SyncServer(Server):
             interface.metadata = metadata
 
         # Run the agent state forward
-        return self._step(actor=actor, agent_id=agent_id, input_messages=message_objects, interface=interface)
+        return self._step(
+            actor=actor,
+            agent_id=agent_id,
+            input_messages=message_objects,
+            interface=interface,
+            put_inner_thoughts_first=put_inner_thoughts_first,
+        )
 
     # @LockingServer.agent_lock_decorator
     def run_command(self, user_id: str, agent_id: str, command: str) -> LettaUsageStatistics:

letta/services/agent_manager.py

@@ -11,6 +11,7 @@ from letta.log import get_logger
 from letta.orm import Agent as AgentModel
 from letta.orm import AgentPassage, AgentsTags
 from letta.orm import Block as BlockModel
+from letta.orm import Identity as IdentityModel
 from letta.orm import Source as SourceModel
 from letta.orm import SourcePassage, SourcesAgents
 from letta.orm import Tool as ToolModel
@@ -34,7 +35,6 @@ from letta.schemas.user import User as PydanticUser
 from letta.serialize_schemas import SerializedAgentSchema
 from letta.services.block_manager import BlockManager
 from letta.services.helpers.agent_manager_helper import (
-    _process_identity,
     _process_relationship,
     _process_tags,
     check_supports_structured_output,
@@ -138,6 +138,7 @@ class AgentManager:
             tool_ids=tool_ids,
             source_ids=agent_create.source_ids or [],
             tags=agent_create.tags or [],
+            identity_ids=agent_create.identity_ids or [],
             description=agent_create.description,
             metadata=agent_create.metadata,
             tool_rules=tool_rules,
@@ -145,7 +146,6 @@ class AgentManager:
             project_id=agent_create.project_id,
             template_id=agent_create.template_id,
             base_template_id=agent_create.base_template_id,
-            identifier_key=agent_create.identifier_key,
             message_buffer_autoclear=agent_create.message_buffer_autoclear,
         )
 
@@ -203,13 +203,13 @@ class AgentManager:
         tool_ids: List[str],
         source_ids: List[str],
         tags: List[str],
+        identity_ids: List[str],
         description: Optional[str] = None,
         metadata: Optional[Dict] = None,
         tool_rules: Optional[List[PydanticToolRule]] = None,
         project_id: Optional[str] = None,
         template_id: Optional[str] = None,
         base_template_id: Optional[str] = None,
-        identifier_key: Optional[str] = None,
         message_buffer_autoclear: bool = False,
     ) -> PydanticAgentState:
         """Create a new agent."""
@@ -237,9 +237,7 @@ class AgentManager:
             _process_relationship(session, new_agent, "sources", SourceModel, source_ids, replace=True)
             _process_relationship(session, new_agent, "core_memory", BlockModel, block_ids, replace=True)
             _process_tags(new_agent, tags, replace=True)
-            if identifier_key is not None:
-                identity = self.identity_manager.get_identity_from_identifier_key(identifier_key)
-                _process_identity(new_agent, identifier_key, identity)
+            _process_relationship(session, new_agent, "identities", IdentityModel, identity_ids, replace=True)
 
             new_agent.create(session, actor=actor)
 
@@ -313,9 +311,8 @@ class AgentManager:
                 _process_relationship(session, agent, "core_memory", BlockModel, agent_update.block_ids, replace=True)
             if agent_update.tags is not None:
                 _process_tags(agent, agent_update.tags, replace=True)
-            if agent_update.identifier_key is not None:
-                identity = self.identity_manager.get_identity_from_identifier_key(agent_update.identifier_key)
-                _process_identity(agent, agent_update.identifier_key, identity)
+            if agent_update.identity_ids is not None:
+                _process_relationship(session, agent, "identities", IdentityModel, agent_update.identity_ids, replace=True)
 
             # Commit and refresh the agent
             agent.update(session, actor=actor)
@@ -333,6 +330,7 @@ class AgentManager:
         tags: Optional[List[str]] = None,
         match_all_tags: bool = False,
         query_text: Optional[str] = None,
+        identifier_keys: Optional[List[str]] = None,
         **kwargs,
     ) -> List[PydanticAgentState]:
         """
@@ -348,6 +346,7 @@ class AgentManager:
                 match_all_tags=match_all_tags,
                 organization_id=actor.organization_id if actor else None,
                 query_text=query_text,
+                identifier_keys=identifier_keys,
                 **kwargs,
             )
 

letta/services/helpers/agent_manager_helper.py

@@ -11,7 +11,6 @@ from letta.orm.errors import NoResultFound
 from letta.prompts import gpt_system
 from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.enums import MessageRole
-from letta.schemas.identity import Identity
 from letta.schemas.memory import Memory
 from letta.schemas.message import Message, MessageCreate, TextContent
 from letta.schemas.tool_rule import ToolRule
@@ -85,20 +84,6 @@ def _process_tags(agent: AgentModel, tags: List[str], replace=True):
         agent.tags.extend([tag for tag in new_tags if tag.tag not in existing_tags])
 
 
-def _process_identity(agent: AgentModel, identifier_key: str, identity: Identity):
-    """
-    Handles identity for an agent.
-
-    Args:
-        agent: The AgentModel instance.
-        identifier_key: The identifier key of the identity to set or update.
-        identity: The Identity object to set or update.
-    """
-    agent.identifier_key = identifier_key
-    agent.identity = identity
-    agent.identity_id = identity.id
-
-
 def derive_system_message(agent_type: AgentType, system: Optional[str] = None):
     if system is None:
         # TODO: don't hardcode