letta-nightly 0.6.33.dev20250227104112__py3-none-any.whl → 0.6.34.dev20250227200331__py3-none-any.whl

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

@@ -69,7 +69,6 @@ def list_agents(
             "project_id": project_id,
             "template_id": template_id,
             "base_template_id": base_template_id,
-            "identifier_id": identifier_id,
         }.items()
         if value is not None
     }
@@ -84,6 +83,7 @@ def list_agents(
         tags=tags,
         match_all_tags=match_all_tags,
         identifier_keys=identifier_keys,
+        identifier_id=identifier_id,
         **kwargs,
     )
     return agents

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

@@ -0,0 +1,315 @@
+import json
+import uuid
+from typing import TYPE_CHECKING, Optional
+
+import httpx
+import openai
+from fastapi import APIRouter, Body, Depends, Header, HTTPException
+from fastapi.responses import StreamingResponse
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk, Choice, ChoiceDelta
+from openai.types.chat.completion_create_params import CompletionCreateParams
+from starlette.concurrency import run_in_threadpool
+
+from letta.constants import LETTA_TOOL_SET, NON_USER_MSG_PREFIX, PRE_EXECUTION_MESSAGE_ARG
+from letta.helpers.tool_execution_helper import (
+    add_pre_execution_message,
+    enable_strict_mode,
+    execute_external_tool,
+    remove_request_heartbeat,
+)
+from letta.log import get_logger
+from letta.orm.enums import ToolType
+from letta.schemas.openai.chat_completion_request import (
+    AssistantMessage,
+    ChatCompletionRequest,
+    Tool,
+    ToolCall,
+    ToolCallFunction,
+    ToolMessage,
+    UserMessage,
+)
+from letta.server.rest_api.optimistic_json_parser import OptimisticJSONParser
+from letta.server.rest_api.utils import (
+    convert_letta_messages_to_openai,
+    create_assistant_messages_from_openai_response,
+    create_tool_call_messages_from_openai_response,
+    create_user_message,
+    get_letta_server,
+    get_messages_from_completion_request,
+)
+from letta.settings import model_settings
+
+if TYPE_CHECKING:
+    from letta.server.server import SyncServer
+
+
+router = APIRouter(prefix="/voice", tags=["voice"])
+
+logger = get_logger(__name__)
+
+
+@router.post(
+    "/chat/completions",
+    response_model=None,
+    operation_id="create_voice_chat_completions",
+    responses={
+        200: {
+            "description": "Successful response",
+            "content": {
+                "text/event-stream": {"description": "Server-Sent Events stream"},
+            },
+        }
+    },
+)
+async def create_voice_chat_completions(
+    completion_request: CompletionCreateParams = Body(...),
+    server: "SyncServer" = Depends(get_letta_server),
+    user_id: Optional[str] = Header(None, alias="user_id"),
+):
+    actor = server.user_manager.get_user_or_default(user_id=user_id)
+
+    agent_id = str(completion_request.get("user", None))
+    if agent_id is None:
+        raise HTTPException(status_code=400, detail="Must pass agent_id in the 'user' field")
+
+    agent_state = server.agent_manager.get_agent_by_id(agent_id=agent_id, actor=actor)
+    if agent_state.llm_config.model_endpoint_type != "openai":
+        raise HTTPException(status_code=400, detail="Only OpenAI models are supported by this endpoint.")
+
+    # Convert Letta messages to OpenAI messages
+    in_context_messages = server.message_manager.get_messages_by_ids(message_ids=agent_state.message_ids, actor=actor)
+    openai_messages = convert_letta_messages_to_openai(in_context_messages)
+
+    # Also parse user input from completion_request and append
+    input_message = get_messages_from_completion_request(completion_request)[-1]
+    openai_messages.append(input_message)
+
+    # Tools we allow this agent to call
+    tools = [t for t in agent_state.tools if t.name not in LETTA_TOOL_SET and t.tool_type in {ToolType.EXTERNAL_COMPOSIO, ToolType.CUSTOM}]
+
+    # Initial request
+    openai_request = ChatCompletionRequest(
+        model=agent_state.llm_config.model,
+        messages=openai_messages,
+        # TODO: This nested thing here is so ugly, need to refactor
+        tools=(
+            [
+                Tool(type="function", function=enable_strict_mode(add_pre_execution_message(remove_request_heartbeat(t.json_schema))))
+                for t in tools
+            ]
+            if tools
+            else None
+        ),
+        tool_choice="auto",
+        user=user_id,
+        max_completion_tokens=agent_state.llm_config.max_tokens,
+        temperature=agent_state.llm_config.temperature,
+        stream=True,
+    )
+
+    # Create the OpenAI async client
+    client = openai.AsyncClient(
+        api_key=model_settings.openai_api_key,
+        max_retries=0,
+        http_client=httpx.AsyncClient(
+            timeout=httpx.Timeout(connect=15.0, read=30.0, write=15.0, pool=15.0),
+            follow_redirects=True,
+            limits=httpx.Limits(
+                max_connections=50,
+                max_keepalive_connections=50,
+                keepalive_expiry=120,
+            ),
+        ),
+    )
+
+    # The messages we want to persist to the Letta agent
+    user_message = create_user_message(input_message=input_message, agent_id=agent_id, actor=actor)
+    message_db_queue = [user_message]
+
+    async def event_stream():
+        """
+        A function-calling loop:
+          - We stream partial tokens.
+          - If we detect a tool call (finish_reason="tool_calls"), we parse it,
+            add two messages to the conversation:
+              (a) assistant message with tool_calls referencing the same ID
+              (b) a tool message referencing that ID, containing the tool result.
+          - Re-invoke the OpenAI request with updated conversation, streaming again.
+          - End when finish_reason="stop" or no more tool calls.
+        """
+
+        # We'll keep updating this conversation in a loop
+        conversation = openai_messages[:]
+
+        while True:
+            # Make the streaming request to OpenAI
+            stream = await client.chat.completions.create(**openai_request.model_dump(exclude_unset=True))
+
+            content_buffer = []
+            tool_call_name = None
+            tool_call_args_str = ""
+            tool_call_id = None
+            tool_call_happened = False
+            finish_reason_stop = False
+            optimistic_json_parser = OptimisticJSONParser(strict=True)
+            current_parsed_json_result = {}
+
+            async with stream:
+                async for chunk in stream:
+                    choice = chunk.choices[0]
+                    delta = choice.delta
+                    finish_reason = choice.finish_reason  # "tool_calls", "stop", or None
+
+                    if delta.content:
+                        content_buffer.append(delta.content)
+                        yield f"data: {chunk.model_dump_json()}\n\n"
+
+                    # CASE B: Partial tool call info
+                    if delta.tool_calls:
+                        # Typically there's only one in delta.tool_calls
+                        tc = delta.tool_calls[0]
+                        if tc.function.name:
+                            tool_call_name = tc.function.name
+                        if tc.function.arguments:
+                            tool_call_args_str += tc.function.arguments
+
+                            # See if we can stream out the pre-execution message
+                            parsed_args = optimistic_json_parser.parse(tool_call_args_str)
+                            if parsed_args.get(
+                                PRE_EXECUTION_MESSAGE_ARG
+                            ) and current_parsed_json_result.get(  # Ensure key exists and is not None/empty
+                                PRE_EXECUTION_MESSAGE_ARG
+                            ) != parsed_args.get(
+                                PRE_EXECUTION_MESSAGE_ARG
+                            ):
+                                # Only stream if there's something new to stream
+                                # We do this way to avoid hanging JSON at the end of the stream, e.g. '}'
+                                if parsed_args != current_parsed_json_result:
+                                    current_parsed_json_result = parsed_args
+                                    synthetic_chunk = ChatCompletionChunk(
+                                        id=chunk.id,
+                                        object=chunk.object,
+                                        created=chunk.created,
+                                        model=chunk.model,
+                                        choices=[
+                                            Choice(
+                                                index=choice.index,
+                                                delta=ChoiceDelta(content=tc.function.arguments, role="assistant"),
+                                                finish_reason=None,
+                                            )
+                                        ],
+                                    )
+
+                                    yield f"data: {synthetic_chunk.model_dump_json()}\n\n"
+
+                        # We might generate a unique ID for the tool call
+                        if tc.id:
+                            tool_call_id = tc.id
+
+                    # Check finish_reason
+                    if finish_reason == "tool_calls":
+                        tool_call_happened = True
+                        break
+                    elif finish_reason == "stop":
+                        finish_reason_stop = True
+                        break
+
+            if content_buffer:
+                # We treat that partial text as an assistant message
+                content = "".join(content_buffer)
+                conversation.append({"role": "assistant", "content": content})
+
+                # Create an assistant message here to persist later
+                assistant_messages = create_assistant_messages_from_openai_response(
+                    response_text=content, agent_id=agent_id, model=agent_state.llm_config.model, actor=actor
+                )
+                message_db_queue.extend(assistant_messages)
+
+            if tool_call_happened:
+                # Parse the tool call arguments
+                try:
+                    tool_args = json.loads(tool_call_args_str)
+                except json.JSONDecodeError:
+                    tool_args = {}
+
+                if not tool_call_id:
+                    # If no tool_call_id given by the model, generate one
+                    tool_call_id = f"call_{uuid.uuid4().hex[:8]}"
+
+                # 1) Insert the "assistant" message with the tool_calls field
+                #    referencing the same tool_call_id
+                assistant_tool_call_msg = AssistantMessage(
+                    content=None,
+                    tool_calls=[ToolCall(id=tool_call_id, function=ToolCallFunction(name=tool_call_name, arguments=tool_call_args_str))],
+                )
+
+                conversation.append(assistant_tool_call_msg.model_dump())
+
+                # 2) Execute the tool
+                target_tool = next((x for x in tools if x.name == tool_call_name), None)
+                if not target_tool:
+                    # Tool not found, handle error
+                    yield f"data: {json.dumps({'error': 'Tool not found', 'tool': tool_call_name})}\n\n"
+                    break
+
+                try:
+                    tool_result, _ = execute_external_tool(
+                        agent_state=agent_state,
+                        function_name=tool_call_name,
+                        function_args=tool_args,
+                        target_letta_tool=target_tool,
+                        actor=actor,
+                        allow_agent_state_modifications=False,
+                    )
+                    function_call_success = True
+                except Exception as e:
+                    tool_result = f"Failed to call tool. Error: {e}"
+                    function_call_success = False
+
+                # 3) Insert the "tool" message referencing the same tool_call_id
+                tool_message = ToolMessage(content=json.dumps({"result": tool_result}), tool_call_id=tool_call_id)
+
+                conversation.append(tool_message.model_dump())
+
+                # 4) Add a user message prompting the tool call result summarization
+                heartbeat_user_message = UserMessage(
+                    content=f"{NON_USER_MSG_PREFIX} Tool finished executing. Summarize the result for the user.",
+                )
+                conversation.append(heartbeat_user_message.model_dump())
+
+                # Now, re-invoke OpenAI with the updated conversation
+                openai_request.messages = conversation
+
+                # Create a tool call message and append to message_db_queue
+                tool_call_messages = create_tool_call_messages_from_openai_response(
+                    agent_id=agent_state.id,
+                    model=agent_state.llm_config.model,
+                    function_name=tool_call_name,
+                    function_arguments=tool_args,
+                    tool_call_id=tool_call_id,
+                    function_call_success=function_call_success,
+                    function_response=tool_result,
+                    actor=actor,
+                    add_heartbeat_request_system_message=True,
+                )
+                message_db_queue.extend(tool_call_messages)
+
+                continue  # Start the while loop again
+
+            if finish_reason_stop:
+                break
+
+            # If we reach here, no tool call, no "stop", but we've ended streaming
+            # Possibly a model error or some other finish reason. We'll just end.
+            break
+
+        await run_in_threadpool(
+            server.agent_manager.append_to_in_context_messages,
+            message_db_queue,
+            agent_id=agent_id,
+            actor=actor,
+        )
+
+        yield "data: [DONE]\n\n"
+
+    return StreamingResponse(event_stream(), media_type="text/event-stream")

letta/server/rest_api/utils.py

@@ -3,7 +3,6 @@ import json
 import os
 import uuid
 import warnings
-from datetime import datetime, timezone
 from enum import Enum
 from typing import TYPE_CHECKING, AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
 
@@ -14,8 +13,9 @@ from openai.types.chat.chat_completion_message_tool_call import Function as Open
 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.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG, REQ_HEARTBEAT_MESSAGE
 from letta.errors import ContextWindowExceededError, RateLimitExceededError
+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 import TextContent
@@ -23,6 +23,7 @@ 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
+from letta.system import get_heartbeat, package_function_response
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -144,7 +145,8 @@ def create_user_message(input_message: dict, agent_id: str, actor: User) -> Mess
     Converts a user input message into the internal structured format.
     """
     # Generate timestamp in the correct format
-    now = datetime.now(timezone.utc).isoformat()
+    # 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}
@@ -159,37 +161,36 @@ def create_user_message(input_message: dict, agent_id: str, actor: User) -> Mess
         model=None,
         tool_calls=None,
         tool_call_id=None,
-        created_at=datetime.now(timezone.utc),
+        created_at=get_utc_time(),
     )
 
     return user_message
 
 
-def create_assistant_message_from_openai_response(
-    response_text: str,
+def create_tool_call_messages_from_openai_response(
     agent_id: str,
     model: str,
+    function_name: str,
+    function_arguments: Dict,
+    tool_call_id: str,
+    function_call_success: bool,
+    function_response: Optional[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())
+    add_heartbeat_request_system_message: bool = False,
+) -> List[Message]:
+    messages = []
 
     # Construct the tool call with the assistant's message
+    function_arguments["request_heartbeat"] = True
     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' + "}",
+            name=function_name,
+            arguments=json.dumps(function_arguments),
         ),
         type="function",
     )
-
-    # Construct the Message object
     assistant_message = Message(
-        id=f"message-{uuid.uuid4()}",
         role=MessageRole.assistant,
         content=[],
         organization_id=actor.organization_id,
@@ -197,10 +198,62 @@ def create_assistant_message_from_openai_response(
         model=model,
         tool_calls=[tool_call],
         tool_call_id=tool_call_id,
-        created_at=datetime.now(timezone.utc),
+        created_at=get_utc_time(),
     )
+    messages.append(assistant_message)
+
+    tool_message = Message(
+        role=MessageRole.tool,
+        content=[TextContent(text=package_function_response(function_call_success, function_response))],
+        organization_id=actor.organization_id,
+        agent_id=agent_id,
+        model=model,
+        tool_calls=[],
+        tool_call_id=tool_call_id,
+        created_at=get_utc_time(),
+        name=function_name,
+    )
+    messages.append(tool_message)
+
+    if add_heartbeat_request_system_message:
+        heartbeat_system_message = Message(
+            role=MessageRole.user,
+            content=[TextContent(text=get_heartbeat(REQ_HEARTBEAT_MESSAGE))],
+            organization_id=actor.organization_id,
+            agent_id=agent_id,
+            model=model,
+            tool_calls=[],
+            tool_call_id=None,
+            created_at=get_utc_time(),
+        )
+        messages.append(heartbeat_system_message)
+
+    return messages
+
 
-    return assistant_message
+def create_assistant_messages_from_openai_response(
+    response_text: str,
+    agent_id: str,
+    model: str,
+    actor: User,
+) -> List[Message]:
+    """
+    Converts an OpenAI response into Messages that follow the internal
+    paradigm where LLM responses are structured as tool calls instead of content.
+    """
+    tool_call_id = str(uuid.uuid4())
+
+    return create_tool_call_messages_from_openai_response(
+        agent_id=agent_id,
+        model=model,
+        function_name=DEFAULT_MESSAGE_TOOL,
+        function_arguments={DEFAULT_MESSAGE_TOOL_KWARG: response_text},  # Avoid raw string manipulation
+        tool_call_id=tool_call_id,
+        function_call_success=True,
+        function_response=None,
+        actor=actor,
+        add_heartbeat_request_system_message=False,
+    )
 
 
 def convert_letta_messages_to_openai(messages: List[Message]) -> List[dict]:

letta/server/server.py

@@ -60,6 +60,7 @@ from letta.schemas.providers import (
     TogetherProvider,
     VLLMChatCompletionsProvider,
     VLLMCompletionsProvider,
+    xAIProvider,
 )
 from letta.schemas.sandbox_config import SandboxType
 from letta.schemas.source import Source
@@ -311,6 +312,8 @@ class SyncServer(Server):
             self._enabled_providers.append(LMStudioOpenAIProvider(base_url=lmstudio_url))
         if model_settings.deepseek_api_key:
             self._enabled_providers.append(DeepSeekProvider(api_key=model_settings.deepseek_api_key))
+        if model_settings.xai_api_key:
+            self._enabled_providers.append(xAIProvider(api_key=model_settings.xai_api_key))
 
     def load_agent(self, agent_id: str, actor: User, interface: Union[AgentInterface, None] = None) -> Agent:
         """Updated method to load agents from persisted storage"""
@@ -1197,7 +1200,8 @@ class SyncServer(Server):
             # Disable token streaming if not OpenAI or Anthropic
             # TODO: cleanup this logic
             llm_config = letta_agent.agent_state.llm_config
-            supports_token_streaming = ["openai", "anthropic", "deepseek"]
+            # supports_token_streaming = ["openai", "anthropic", "xai", "deepseek"]
+            supports_token_streaming = ["openai", "anthropic", "deepseek"]  # TODO re-enable xAI once streaming is patched
             if stream_tokens and (
                 llm_config.model_endpoint_type not in supports_token_streaming or "inference.memgpt.ai" in llm_config.model_endpoint
             ):

letta/services/identity_manager.py

@@ -115,8 +115,8 @@ class IdentityManager:
             if replace:
                 existing_identity.properties = [prop.model_dump() for prop in identity.properties]
             else:
-                new_properties = existing_identity.properties + identity.properties
-                existing_identity.properties = [prop.model_dump() for prop in new_properties]
+                new_properties = existing_identity.properties + [prop.model_dump() for prop in identity.properties]
+                existing_identity.properties = new_properties
 
         self._process_agent_relationship(
             session=session, identity=existing_identity, agent_ids=identity.agent_ids, allow_partial=False, replace=replace

letta/settings.py

@@ -63,6 +63,9 @@ class ModelSettings(BaseSettings):
     # deepseek
     deepseek_api_key: Optional[str] = None
 
+    # xAI / Grok
+    xai_api_key: Optional[str] = None
+
     # groq
     groq_api_key: Optional[str] = None
 

{letta_nightly-0.6.33.dev20250227104112.dist-info → letta_nightly-0.6.34.dev20250227200331.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.6.33.dev20250227104112
+Version: 0.6.34.dev20250227200331
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team

{letta_nightly-0.6.33.dev20250227104112.dist-info → letta_nightly-0.6.34.dev20250227200331.dist-info}/RECORD

@@ -1,6 +1,6 @@
-letta/__init__.py,sha256=ZG24l5R0k4y_ttVVqlMdf3VtTG63oUJlIbU0I38-TrM,918
+letta/__init__.py,sha256=a7R3j3Qmd9DXH-PvZSRZ7_Mht5Aw5TPiLgc6yuAmJUw,918
 letta/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
-letta/agent.py,sha256=NqmrtW0gNfo0kT15WzRfY-TzhMDx4TaWfEmPUWSB2FI,60921
+letta/agent.py,sha256=je4571lbHoI0Gt3kbW1gRT445R5KodDKFClYjj9w4bU,61470
 letta/benchmark/benchmark.py,sha256=ebvnwfp3yezaXOQyGXkYCDYpsmre-b9hvNtnyx4xkG0,3701
 letta/benchmark/constants.py,sha256=aXc5gdpMGJT327VuxsT5FngbCK2J41PQYeICBO7g_RE,536
 letta/chat_only_agent.py,sha256=71Lf-df8y3nsE9IFKpEigaZaWHoWnXnhVChkp1L-83I,4760
@@ -48,9 +48,9 @@ letta/llm_api/google_ai.py,sha256=VnoxG6QYcwgFEbH8iJ8MHaMQrW4ROekZy6ZV5ZdHxzI,18
 letta/llm_api/google_constants.py,sha256=ZdABT9l9l-qKcV2QCkVsv9kQbttx6JyIJoOWS8IMS5o,448
 letta/llm_api/google_vertex.py,sha256=Cqr73-jZJJvii1M_0QEmasNajOIJ5TDs5GabsCJjI04,14149
 letta/llm_api/helpers.py,sha256=pXBemF43Ywbwub5dc5V7Slw5K7lNlO0ae8dQBOXgDHs,16773
-letta/llm_api/llm_api_tools.py,sha256=wOm_NqBipE2M_XUN8y5KCDpZrXaEJuuvZ0llqfWFROo,26205
+letta/llm_api/llm_api_tools.py,sha256=AQe-5xiMRRwlx52D1H3LBxt_XHhl7RA3bHM5k9YLcQY,28442
 letta/llm_api/mistral.py,sha256=fHdfD9ug-rQIk2qn8tRKay1U6w9maF11ryhKi91FfXM,1593
-letta/llm_api/openai.py,sha256=NCL_pT35BfSsQ7LSfUdNuhI2hi1nEhBiGffLz_81Mcw,21271
+letta/llm_api/openai.py,sha256=wZHuQX018u2lZEKohWlzSYyQn9iYUSEuVn9QAaXIg0A,22038
 letta/local_llm/README.md,sha256=hFJyw5B0TU2jrh9nb0zGZMgdH-Ei1dSRfhvPQG_NSoU,168
 letta/local_llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/local_llm/chat_completion_proxy.py,sha256=44rvabj2iXPswe5jFt0qWYCasSVXjkT31DivvDoWVMM,13543
@@ -117,7 +117,7 @@ letta/orm/provider.py,sha256=-qA9tvKTZgaM4D7CoDZZiA7zTgjaaWDV4jZvifQv_MM,805
 letta/orm/sandbox_config.py,sha256=DyOy_1_zCMlp13elCqPcuuA6OwUove6mrjhcpROTg50,4150
 letta/orm/source.py,sha256=z89VZUHV9K8Ew9JCYoZqUeRb1WEUKmrn0MMFkppaphE,2117
 letta/orm/sources_agents.py,sha256=Ik_PokCBrXRd9wXWomeNeb8EtLUwjb9VMZ8LWXqpK5A,473
-letta/orm/sqlalchemy_base.py,sha256=tIuKJ0CH4tYCzhpDqqr2EDD6AxGlnXI752oYZtlvM6o,22151
+letta/orm/sqlalchemy_base.py,sha256=8037lD9w5vY7rXhqmXg1mG78UywdHczef7-XGhW7b1U,22511
 letta/orm/sqlite_functions.py,sha256=JCScKiRlYCKxy9hChQ8wsk4GMKknZE24MunnG3fM1Gw,4255
 letta/orm/step.py,sha256=6t_PlVd8pW1Rd6JeECImBG2n9P-yif0Sl9Uzhb-m77w,2982
 letta/orm/tool.py,sha256=JEPHlM4ePaLaGtHpHhYdKCteHTRJnOFgQmfR5wL8TpA,2379
@@ -164,7 +164,7 @@ letta/schemas/letta_base.py,sha256=HTnSHJ2YSyhEdpY-vg9Y7ywqS1zzTjb9j5iVPYsuVSk,3
 letta/schemas/letta_message.py,sha256=QHzIEwnEJEkE02biCwyQo5IvL2fVq_whBRQD3vPYO48,9837
 letta/schemas/letta_request.py,sha256=dzy3kwb5j2QLaSV0sDlwISEMt2xxH3IiK-vR9xJV65k,1123
 letta/schemas/letta_response.py,sha256=pq-SxXQy5yZo1-DiAwV2mMURlUvz1Uu7HHR_tB1hMho,7139
-letta/schemas/llm_config.py,sha256=R0GQvw3DzsShpxZY6eWte4A2f1QjUrAAJ928DvLuBZs,5596
+letta/schemas/llm_config.py,sha256=bqq4LGE9layPcnnkzd_8d2SB8o1x8XdDzfd2ZkYQwcY,5611
 letta/schemas/llm_config_overrides.py,sha256=-oRglCTcajF6UAK3RAa0FLWVuKODPI1v403fDIWMAtA,1815
 letta/schemas/memory.py,sha256=GOYDfPKzbWftUWO9Hv4KW7xAi1EIQmC8zpP7qvEkVHw,10245
 letta/schemas/message.py,sha256=3-0zd-WuasJ1rZPDSqwJ7mRex399icPgpsVk19T7CoQ,37687
@@ -175,7 +175,7 @@ letta/schemas/openai/embedding_response.py,sha256=WKIZpXab1Av7v6sxKG8feW3ZtpQUNo
 letta/schemas/openai/openai.py,sha256=Hilo5BiLAGabzxCwnwfzK5QrWqwYD8epaEKFa4Pwndk,7970
 letta/schemas/organization.py,sha256=_RR8jlOOdJyG31q53IDdIvBVvIfAZrQWAGuvc5HmW24,788
 letta/schemas/passage.py,sha256=RG0vkaewEu4a_NAZM-FVyMammHjqpPP0RDYAdu27g6A,3723
-letta/schemas/providers.py,sha256=JUFdujrLmrGA84tybQ4aquxknEyiod47lRKrpStm9s4,41351
+letta/schemas/providers.py,sha256=k02mAFMn9F8zW6vjHSIL-OfBlfFharJQM43SrJfdmbs,43666
 letta/schemas/run.py,sha256=SRqPRziINIiPunjOhE_NlbnQYgxTvqmbauni_yfBQRA,2085
 letta/schemas/sandbox_config.py,sha256=Nz8K5brqe6jpf66KnTJ0-E7ZeFdPoBFGN-XOI35OeaY,5926
 letta/schemas/source.py,sha256=-BQVolcXA2ziCu2ztR6cbTdGUc8G7vGJy7rvpdf1hpg,2880
@@ -198,14 +198,14 @@ letta/server/rest_api/app.py,sha256=F9XAwZt5nPAE75gHSurXGe4mGmNvmI8DD7RssK8l124,
 letta/server/rest_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/auth/index.py,sha256=fQBGyVylGSRfEMLQ17cZzrHd5Y1xiVylvPqH5Rl-lXQ,1378
 letta/server/rest_api/auth_token.py,sha256=725EFEIiNj4dh70hrSd94UysmFD8vcJLrTRfNHkzxDo,774
-letta/server/rest_api/chat_completions_interface.py,sha256=ORkZ-UmkmSx-FyGp85BDs9sQdNE49GehlmxVSxq4vLs,12073
+letta/server/rest_api/chat_completions_interface.py,sha256=htY1v3eyP6OmoDkBYog2fPZX_2cHsNKkxUAAAvuUbiE,10862
 letta/server/rest_api/interface.py,sha256=jAt7azrk27sNKNCZHgoIzYDIUbEgJ8hsC3Ef7OevH7U,57605
 letta/server/rest_api/optimistic_json_parser.py,sha256=1z4d9unmxMb0ou7owJ62uUQoNjNYf21FmaNdg0ZcqUU,6567
 letta/server/rest_api/routers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 letta/server/rest_api/routers/openai/chat_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=8u7n42niB_6X5uShMa76-ldAMdx7lHG-6ax8GEAr25s,17478
-letta/server/rest_api/routers/v1/__init__.py,sha256=kQUDemPYl4ZcOndpsexbLQRAObkuDN00ZYTnQJYiHNk,1269
-letta/server/rest_api/routers/v1/agents.py,sha256=Ac7IpwwxutLKziJIzTKTrh90cd3u0aC6Nixbxbo7bE0,26274
+letta/server/rest_api/routers/openai/chat_completions/chat_completions.py,sha256=yJo_oiv75QsD324lC0uR2B9su9WG1FxabQhAJKS--6s,5530
+letta/server/rest_api/routers/v1/__init__.py,sha256=Zi2th-okqT_RWAjB8MYGHX8CpHt1OSRyO5V8SJEp6UU,1361
+letta/server/rest_api/routers/v1/agents.py,sha256=gkvlga9MOgtYjlH2dOX4mnLpS6ZxKgMTGQcqHiIQrMU,26267
 letta/server/rest_api/routers/v1/blocks.py,sha256=0j7JX2BQzk31RyhvPZeEb-zh9ImXsVU4_8y5XMiR_WA,3900
 letta/server/rest_api/routers/v1/health.py,sha256=MoOjkydhGcJXTiuJrKIB0etVXiRMdTa51S8RQ8-50DQ,399
 letta/server/rest_api/routers/v1/identities.py,sha256=CCEF-e91yXOaHevEM0cpPoTHGnWNVljvKD5YC1nFvVk,4981
@@ -220,9 +220,10 @@ letta/server/rest_api/routers/v1/steps.py,sha256=IpCQuxpS34-4Qpgdv0FQJO-SffkFkW-
 letta/server/rest_api/routers/v1/tags.py,sha256=coydgvL6-9cuG2Hy5Ea7QY3inhTHlsf69w0tcZenBus,880
 letta/server/rest_api/routers/v1/tools.py,sha256=qIpXzrjihQgEnoGeiKxEzaKmzHIVvBO0V_lR1ciBHZs,13147
 letta/server/rest_api/routers/v1/users.py,sha256=G5DBHSkPfBgVHN2Wkm-rVYiLQAudwQczIq2Z3YLdbVo,2277
+letta/server/rest_api/routers/v1/voice.py,sha256=rvO6U3Vb9Q2l_kIzfsOgToKjpr06UvnovNN2NSzLcI0,13294
 letta/server/rest_api/static_files.py,sha256=NG8sN4Z5EJ8JVQdj19tkFa9iQ1kBPTab9f_CUxd_u4Q,3143
-letta/server/rest_api/utils.py,sha256=fsp5rojySucv3TSSaY9QQ5DUyE6GhxkyKg8rZQQhZVA,11980
-letta/server/server.py,sha256=3TjO0sef8UeQc_0efCoPT6vGz7f673KDZHwd15qKW2Q,57384
+letta/server/rest_api/utils.py,sha256=dpWC_MQijJ66wq4E5KPgXzHmGt6iNsj-Cw0kS4CLOnE,13693
+letta/server/server.py,sha256=RnK8LLmczo0rHDl7nFGuYFA3HmqODFqXSH6Wc2g1BZI,57664
 letta/server/startup.sh,sha256=qEi6dQHJRzEzDIgnIODj-RYp-O1XstfFpc6cFLkUzVs,1576
 letta/server/static_files/assets/index-048c9598.js,sha256=mR16XppvselwKCcNgONs4L7kZEVa4OEERm4lNZYtLSk,146819
 letta/server/static_files/assets/index-0e31b727.css,sha256=SBbja96uiQVLDhDOroHgM6NSl7tS4lpJRCREgSS_hA8,7672
@@ -240,7 +241,7 @@ letta/services/agent_manager.py,sha256=fiLhLgYh65LXGuzwsYD38oT3lfBhnyn6yK1uvY3De
 letta/services/block_manager.py,sha256=PkbiO59VimLyK6PolWR5O29uHxksCH6pP6K4Vkov3NA,5573
 letta/services/helpers/agent_manager_helper.py,sha256=MexqAGoc2e8Bso4_hJhBR6qyiFXtiB2MiMMqL-ur1a0,11302
 letta/services/helpers/tool_execution_helper.py,sha256=q8uSiQcX6VH_iNg5VNloZgC2JkH9lIOXBKCXYPx2Yac,6097
-letta/services/identity_manager.py,sha256=iFkiEqY8Uik8Bzla53Qh1empZvfJug914xzIwWCO9ho,7144
+letta/services/identity_manager.py,sha256=o1XMd5NG2gZ_YWrPOmisfFN0i-2ohoq8n1GM8F49Lf4,7144
 letta/services/job_manager.py,sha256=y7P03ijWrOY1HzhphrRdeEPUQz-wHcNvoi-zrefjbuE,13155
 letta/services/message_manager.py,sha256=miGZ24h6NC16wHiTP95ooo-M-o2x1rxRnj67p8vQyOY,10702
 letta/services/organization_manager.py,sha256=dhQ3cFPXWNYLfMjdahr2HsOAMJ1JtCEWj1G8Nei5MQc,3388
@@ -253,14 +254,14 @@ letta/services/step_manager.py,sha256=svDP_Mv64iIJKzYDFlDT5fabmWBvyjPPa0FIN--L7u
 letta/services/tool_execution_sandbox.py,sha256=mev4oCHy4B_uoXRccTirDNp_pSX_s5wbUVNz1oKrvBU,22067
 letta/services/tool_manager.py,sha256=Q-J8mZKw3zi5Ymxy48DiwpOcv1s6rqdSkRHE6pbnzKk,9568
 letta/services/user_manager.py,sha256=ScHbdJK9kNF8QXjsd3ZWGEL87n_Uyp3YwfKetOJmpHs,4304
-letta/settings.py,sha256=l6jrMyIK3tqLTXhBx5rN06nEEnJh4vafxBQWhUa2WAI,6579
+letta/settings.py,sha256=KAWy4bCE9OWwyNmMKabamFtf2iMWxFNT_fyxDdRuK1U,6635
 letta/streaming_interface.py,sha256=1vuAckIxo1p1UsXtDzE8LTUve5RoTZRdXUe-WBIYDWU,15818
 letta/streaming_utils.py,sha256=jLqFTVhUL76FeOuYk8TaRQHmPTf3HSRc2EoJwxJNK6U,11946
 letta/system.py,sha256=dnOrS2FlRMwijQnOvfrky0Lg8wEw-FUq2zzfAJOUSKA,8477
 letta/tracing.py,sha256=0uCH8j2ipTpS8Vt7bFl74sG5ckgBHy9fu-cyG9SBSsc,7464
 letta/utils.py,sha256=AdHrQ2OQ3V4XhJ1LtYwbLUO71j2IJY37cIUxXPgaaRY,32125
-letta_nightly-0.6.33.dev20250227104112.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
-letta_nightly-0.6.33.dev20250227104112.dist-info/METADATA,sha256=j9ZbD055qC94ibSLqbUQyTtz3VsjR8IYFocSOLJmDvA,22589
-letta_nightly-0.6.33.dev20250227104112.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-letta_nightly-0.6.33.dev20250227104112.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
-letta_nightly-0.6.33.dev20250227104112.dist-info/RECORD,,
+letta_nightly-0.6.34.dev20250227200331.dist-info/LICENSE,sha256=mExtuZ_GYJgDEI38GWdiEYZizZS4KkVt2SF1g_GPNhI,10759
+letta_nightly-0.6.34.dev20250227200331.dist-info/METADATA,sha256=KslT-nJMxofwG6oQv0iy2A8QDQntNGbwTC5RzV4plLY,22589
+letta_nightly-0.6.34.dev20250227200331.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+letta_nightly-0.6.34.dev20250227200331.dist-info/entry_points.txt,sha256=2zdiyGNEZGV5oYBuS-y2nAAgjDgcC9yM_mHJBFSRt5U,40
+letta_nightly-0.6.34.dev20250227200331.dist-info/RECORD,,