letta-nightly 0.12.1.dev20251024104217__py3-none-any.whl → 0.13.0.dev20251025104015__py3-none-any.whl

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

@@ -1,14 +1,9 @@
 from typing import TYPE_CHECKING, Any, Dict
 
-import openai
 from fastapi import APIRouter, Body, Depends
-from fastapi.responses import StreamingResponse
 
-from letta.agents.voice_agent import VoiceAgent
 from letta.log import get_logger
 from letta.server.rest_api.dependencies import HeaderParams, get_headers, get_letta_server
-from letta.server.rest_api.utils import get_user_message_from_chat_completions_request
-from letta.settings import model_settings
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -23,11 +18,16 @@ logger = get_logger(__name__)
     "/{agent_id}/chat/completions",
     response_model=None,
     operation_id="create_voice_chat_completions",
+    deprecated=True,
     responses={
         200: {
             "description": "Successful response",
             "content": {"text/event-stream": {}},
-        }
+        },
+        410: {
+            "description": "Endpoint deprecated",
+            "content": {"application/json": {"example": {"detail": "This endpoint has been deprecated"}}},
+        },
     },
 )
 async def create_voice_chat_completions(
@@ -36,28 +36,19 @@ async def create_voice_chat_completions(
     server: "SyncServer" = Depends(get_letta_server),
     headers: HeaderParams = Depends(get_headers),
 ):
-    actor = await server.user_manager.get_actor_or_default_async(actor_id=headers.actor_id)
+    """
+    DEPRECATED: This voice-beta endpoint has been deprecated.
 
-    # Create OpenAI async client
-    client = openai.AsyncClient(
-        api_key=model_settings.openai_api_key,
-        max_retries=0,
-        http_client=server.httpx_client,
-    )
+    The voice functionality has been integrated into the main chat completions endpoint.
+    Please use the standard /v1/agents/{agent_id}/messages endpoint instead.
 
-    # Instantiate our LowLatencyAgent
-    agent = VoiceAgent(
-        agent_id=agent_id,
-        openai_client=client,
-        message_manager=server.message_manager,
-        agent_manager=server.agent_manager,
-        block_manager=server.block_manager,
-        run_manager=server.run_manager,
-        passage_manager=server.passage_manager,
-        actor=actor,
-    )
+    This endpoint will be removed in a future version.
+    """
+    from fastapi import HTTPException
+
+    logger.warning(f"Deprecated voice-beta endpoint called for agent {agent_id}")
 
-    # Return the streaming generator
-    return StreamingResponse(
-        agent.step_stream(input_messages=get_user_message_from_chat_completions_request(completion_request)), media_type="text/event-stream"
+    raise HTTPException(
+        status_code=410,
+        detail="The /voice-beta endpoint has been deprecated and is no longer available.",
     )

letta/server/rest_api/streaming_response.py

@@ -5,6 +5,8 @@
 import asyncio
 import json
 from collections.abc import AsyncIterator
+from datetime import datetime, timezone
+from uuid import uuid4
 
 import anyio
 from fastapi import HTTPException
@@ -14,7 +16,7 @@ from starlette.types import Send
 from letta.errors import LettaUnexpectedStreamCancellationError, PendingApprovalError
 from letta.log import get_logger
 from letta.schemas.enums import RunStatus
-from letta.schemas.letta_ping import LettaPing
+from letta.schemas.letta_message import LettaPing
 from letta.schemas.user import User
 from letta.server.rest_api.utils import capture_sentry_exception
 from letta.services.run_manager import RunManager
@@ -34,6 +36,7 @@ class RunCancelledException(Exception):
 
 async def add_keepalive_to_stream(
     stream_generator: AsyncIterator[str | bytes],
+    run_id: str,
     keepalive_interval: float = 30.0,
 ) -> AsyncIterator[str | bytes]:
     """
@@ -83,7 +86,7 @@ async def add_keepalive_to_stream(
                 # No data received within keepalive interval
                 if not stream_exhausted:
                     # Send keepalive ping in the same format as [DONE]
-                    yield f"data: {LettaPing().model_dump_json()}\n\n"
+                    yield f"data: {LettaPing(id=f'ping-{uuid4()}', date=datetime.now(timezone.utc), run_id=run_id).model_dump_json()}\n\n"
                 else:
                     # Stream is done but queue might be processing
                     # Check if there's anything left

letta/server/rest_api/utils.py

@@ -3,7 +3,7 @@ import json
 import os
 import uuid
 from enum import Enum
-from typing import AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
+from typing import Any, AsyncGenerator, Dict, Iterable, List, Optional, Union, cast
 
 from fastapi import Header, HTTPException
 from openai.types.chat import ChatCompletionMessageParam
@@ -27,6 +27,7 @@ from letta.otel.metric_registry import MetricRegistry
 from letta.otel.tracing import tracer
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageRole
+from letta.schemas.letta_message import ToolReturn as LettaToolReturn
 from letta.schemas.letta_message_content import (
     OmittedReasoningContent,
     ReasoningContent,
@@ -120,7 +121,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(exclude={"steps_messages"}))
+                yield sse_formatter(usage.model_dump())
 
             except ContextWindowExceededError as e:
                 capture_sentry_exception(e)
@@ -168,7 +169,23 @@ def create_input_messages(input_messages: List[MessageCreate], agent_id: str, ti
     return messages
 
 
-def create_approval_response_message_from_input(agent_state: AgentState, input_message: ApprovalCreate) -> List[Message]:
+def create_approval_response_message_from_input(
+    agent_state: AgentState, input_message: ApprovalCreate, run_id: Optional[str] = None
+) -> List[Message]:
+    def maybe_convert_tool_return_message(maybe_tool_return: LettaToolReturn):
+        if isinstance(maybe_tool_return, LettaToolReturn):
+            packaged_function_response = package_function_response(
+                maybe_tool_return.status == "success", maybe_tool_return.tool_return, agent_state.timezone
+            )
+            return ToolReturn(
+                tool_call_id=maybe_tool_return.tool_call_id,
+                status=maybe_tool_return.status,
+                func_response=packaged_function_response,
+                stdout=maybe_tool_return.stdout,
+                stderr=maybe_tool_return.stderr,
+            )
+        return maybe_tool_return
+
     return [
         Message(
             role=MessageRole.approval,
@@ -177,6 +194,8 @@ def create_approval_response_message_from_input(agent_state: AgentState, input_m
             approval_request_id=input_message.approval_request_id,
             approve=input_message.approve,
             denial_reason=input_message.reason,
+            approvals=[maybe_convert_tool_return_message(approval) for approval in input_message.approvals],
+            run_id=run_id,
         )
     ]
 
@@ -184,45 +203,77 @@ def create_approval_response_message_from_input(agent_state: AgentState, input_m
 def create_approval_request_message_from_llm_response(
     agent_id: str,
     model: str,
-    function_name: str,
-    function_arguments: Dict,
-    tool_call_id: str,
-    actor: User,
-    continue_stepping: bool = False,
+    requested_tool_calls: List[OpenAIToolCall],
+    allowed_tool_calls: List[OpenAIToolCall] = [],
     reasoning_content: Optional[List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent]]] = None,
     pre_computed_assistant_message_id: Optional[str] = None,
     step_id: str | None = None,
     run_id: str = None,
-    append_request_heartbeat: bool = True,
 ) -> Message:
+    messages = []
+    if allowed_tool_calls:
+        oai_tool_calls = [
+            OpenAIToolCall(
+                id=tool_call.id,
+                function=OpenAIFunction(
+                    name=tool_call.function.name,
+                    arguments=tool_call.function.arguments,
+                ),
+                type="function",
+            )
+            for tool_call in allowed_tool_calls
+        ]
+        tool_message = Message(
+            role=MessageRole.assistant,
+            content=reasoning_content if reasoning_content else [],
+            agent_id=agent_id,
+            model=model,
+            tool_calls=oai_tool_calls,
+            tool_call_id=allowed_tool_calls[0].id,
+            created_at=get_utc_time(),
+            step_id=step_id,
+            run_id=run_id,
+        )
+        if pre_computed_assistant_message_id:
+            tool_message.id = pre_computed_assistant_message_id
+        messages.append(tool_message)
     # Construct the tool call with the assistant's message
-    # Optionally set request_heartbeat in tool args (v2 behavior only)
-    if append_request_heartbeat:
-        function_arguments[REQUEST_HEARTBEAT_PARAM] = continue_stepping
-    tool_call = OpenAIToolCall(
-        id=tool_call_id,
-        function=OpenAIFunction(
-            name=function_name,
-            arguments=json.dumps(function_arguments),
-        ),
-        type="function",
-    )
+    oai_tool_calls = [
+        OpenAIToolCall(
+            id=tool_call.id,
+            function=OpenAIFunction(
+                name=tool_call.function.name,
+                arguments=tool_call.function.arguments,
+            ),
+            type="function",
+        )
+        for tool_call in requested_tool_calls
+    ]
     # TODO: Use ToolCallContent instead of tool_calls
     # TODO: This helps preserve ordering
     approval_message = Message(
         role=MessageRole.approval,
-        content=reasoning_content if reasoning_content else [],
+        content=reasoning_content if reasoning_content and not allowed_tool_calls else [],
         agent_id=agent_id,
         model=model,
-        tool_calls=[tool_call],
-        tool_call_id=tool_call_id,
+        tool_calls=oai_tool_calls,
+        tool_call_id=oai_tool_calls[0].id,
         created_at=get_utc_time(),
         step_id=step_id,
         run_id=run_id,
     )
     if pre_computed_assistant_message_id:
-        approval_message.id = pre_computed_assistant_message_id
-    return approval_message
+        approval_message.id = decrement_message_uuid(pre_computed_assistant_message_id)
+    messages.append(approval_message)
+    return messages
+
+
+def decrement_message_uuid(message_id: str):
+    message_uuid = uuid.UUID(message_id.split("-", maxsplit=1)[1])
+    uuid_as_int = message_uuid.int
+    decremented_int = uuid_as_int - 1
+    decremented_uuid = uuid.UUID(int=decremented_int)
+    return "message-" + str(decremented_uuid)
 
 
 def create_letta_messages_from_llm_response(
@@ -361,6 +412,117 @@ def create_letta_messages_from_llm_response(
     return messages
 
 
+def create_parallel_tool_messages_from_llm_response(
+    agent_id: str,
+    model: str,
+    tool_call_specs: List[Dict[str, Any]],  # List of tool call specs: {"name": str, "arguments": Dict, "id": Optional[str]}
+    tool_execution_results: List[ToolExecutionResult],
+    function_responses: List[Optional[str]],
+    timezone: str,
+    run_id: Optional[str] = None,
+    step_id: Optional[str] = None,
+    reasoning_content: Optional[
+        List[Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent | SummarizedReasoningContent]]
+    ] = None,
+    pre_computed_assistant_message_id: Optional[str] = None,
+    llm_batch_item_id: Optional[str] = None,
+    is_approval_response: bool = False,
+    tool_returns: List[ToolReturn] = [],
+) -> List[Message]:
+    """
+    Build two messages representing a parallel tool-call step:
+    - One assistant message with ALL tool_calls populated (tool_call_id left empty)
+    - One tool message with ALL tool_returns populated (tool_call_id left empty)
+
+    Notes:
+    - Consumers should read tool_calls/tool_returns arrays for per-call details.
+    - The tool message's content includes only the first call's packaged response for
+      backward-compatibility with legacy renderers. UIs should prefer tool_returns.
+    - When invoked for an approval response, the assistant message is omitted (the approval
+      tool call was previously surfaced).
+    """
+
+    # Construct OpenAI-style tool_calls for the assistant message
+    openai_tool_calls: List[OpenAIToolCall] = []
+    for spec in tool_call_specs:
+        name = spec.get("name")
+        args = spec.get("arguments", {})
+        call_id = spec.get("id") or str(uuid.uuid4())
+        # Ensure the spec carries the resolved id so returns/content can reference it
+        if not spec.get("id"):
+            spec["id"] = call_id
+        openai_tool_calls.append(
+            OpenAIToolCall(
+                id=call_id,
+                function=OpenAIFunction(name=name, arguments=json.dumps(args)),
+                type="function",
+            )
+        )
+
+    messages: List[Message] = []
+
+    if not is_approval_response:
+        # Assistant message with all tool_calls (no single tool_call_id)
+        # Safeguard against empty text messages
+        content: List[
+            Union[TextContent, ReasoningContent, RedactedReasoningContent, OmittedReasoningContent, SummarizedReasoningContent]
+        ] = []
+        if reasoning_content:
+            for content_part in reasoning_content:
+                if isinstance(content_part, TextContent) and content_part.text == "":
+                    continue
+                content.append(content_part)
+
+        assistant_message = Message(
+            role=MessageRole.assistant,
+            content=content,
+            agent_id=agent_id,
+            model=model,
+            tool_calls=openai_tool_calls,
+            tool_call_id=None,
+            created_at=get_utc_time(),
+            batch_item_id=llm_batch_item_id,
+            run_id=run_id,
+        )
+        if step_id:
+            assistant_message.step_id = step_id
+        if pre_computed_assistant_message_id:
+            assistant_message.id = pre_computed_assistant_message_id
+        messages.append(assistant_message)
+
+    content: List[TextContent] = []
+    for spec, exec_result, response in zip(tool_call_specs, tool_execution_results, function_responses):
+        packaged = package_function_response(exec_result.success_flag, response, timezone)
+        content.append(TextContent(text=packaged))
+        tool_returns.append(
+            ToolReturn(
+                tool_call_id=spec.get("id"),
+                status=exec_result.status,
+                stdout=exec_result.stdout,
+                stderr=exec_result.stderr,
+                func_response=packaged,
+            )
+        )
+
+    tool_message = Message(
+        role=MessageRole.tool,
+        content=content,
+        agent_id=agent_id,
+        model=model,
+        tool_calls=[],
+        tool_call_id=tool_returns[0].tool_call_id,  # For legacy reasons, set to first one
+        created_at=get_utc_time(),
+        batch_item_id=llm_batch_item_id,
+        tool_returns=tool_returns,
+        run_id=run_id,
+    )
+    if step_id:
+        tool_message.step_id = step_id
+
+    messages.append(tool_message)
+    return messages
+
+
 def create_heartbeat_system_message(
     agent_id: str,
     model: str,

letta/server/server.py

@@ -2,7 +2,6 @@ import asyncio
 import json
 import os
 import traceback
-import warnings
 from abc import abstractmethod
 from datetime import datetime
 from pathlib import Path
@@ -94,6 +93,7 @@ from letta.services.mcp.base_client import AsyncBaseMCPClient
 from letta.services.mcp.sse_client import MCP_CONFIG_TOPLEVEL_KEY, AsyncSSEMCPClient
 from letta.services.mcp.stdio_client import AsyncStdioMCPClient
 from letta.services.mcp_manager import MCPManager
+from letta.services.mcp_server_manager import MCPServerManager
 from letta.services.message_manager import MessageManager
 from letta.services.organization_manager import OrganizationManager
 from letta.services.passage_manager import PassageManager
@@ -154,6 +154,7 @@ class SyncServer(object):
         self.user_manager = UserManager()
         self.tool_manager = ToolManager()
         self.mcp_manager = MCPManager()
+        self.mcp_server_manager = MCPServerManager()
         self.block_manager = BlockManager()
         self.source_manager = SourceManager()
         self.sandbox_config_manager = SandboxConfigManager()
@@ -482,8 +483,21 @@ class SyncServer(object):
         request: UpdateAgent,
         actor: User,
     ) -> AgentState:
-        if request.model is not None:
-            request.llm_config = await self.get_llm_config_from_handle_async(handle=request.model, actor=actor)
+        # Build llm_config from convenience fields if llm_config is not provided
+        if request.llm_config is None and (
+            request.model is not None or request.context_window_limit is not None or request.max_tokens is not None
+        ):
+            if request.model is None:
+                agent = await self.agent_manager.get_agent_by_id_async(agent_id=agent_id, actor=actor)
+                request.model = agent.llm_config.handle
+            config_params = {
+                "handle": request.model,
+                "context_window_limit": request.context_window_limit,
+                "max_tokens": request.max_tokens,
+            }
+            log_event(name="start get_cached_llm_config", attributes=config_params)
+            request.llm_config = await self.get_cached_llm_config_async(actor=actor, **config_params)
+            log_event(name="end get_cached_llm_config", attributes=config_params)
 
         if request.embedding is not None:
             request.embedding_config = await self.get_embedding_config_from_handle_async(handle=request.embedding, actor=actor)
@@ -761,8 +775,6 @@ class SyncServer(object):
 
         # TODO: move this into a thread
         source = await self.source_manager.get_source_by_id(source_id=source_id)
-        if source is None:
-            raise NoResultFound(f"Source {source_id} does not exist")
         connector = DirectoryConnector(input_files=[file_path])
         num_passages, num_documents = await self.load_data(user_id=source.created_by_id, source_name=source.name, connector=connector)
 
@@ -925,11 +937,10 @@ class SyncServer(object):
                 async with asyncio.timeout(constants.GET_PROVIDERS_TIMEOUT_SECONDS):
                     return await provider.list_llm_models_async()
             except asyncio.TimeoutError:
-                warnings.warn(f"Timeout while listing LLM models for provider {provider}")
+                logger.warning(f"Timeout while listing LLM models for provider {provider}")
                 return []
             except Exception as e:
-                traceback.print_exc()
-                warnings.warn(f"Error while listing LLM models for provider {provider}: {e}")
+                logger.exception(f"Error while listing LLM models for provider {provider}: {e}")
                 return []
 
         # Execute all provider model listing tasks concurrently
@@ -968,10 +979,7 @@ class SyncServer(object):
                 # All providers now have list_embedding_models_async
                 return await provider.list_embedding_models_async()
             except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                warnings.warn(f"An error occurred while listing embedding models for provider {provider}: {e}")
+                logger.exception(f"An error occurred while listing embedding models for provider {provider}: {e}")
                 return []
 
         # Execute all provider model listing tasks concurrently
@@ -1140,9 +1148,9 @@ class SyncServer(object):
         #                        llm_config = LLMConfig(**config_data)
         #                        llm_models.append(llm_config)
         #                except (json.JSONDecodeError, ValueError) as e:
-        #                    warnings.warn(f"Error parsing LLM config file {filename}: {e}")
+        #                    logger.warning(f"Error parsing LLM config file {filename}: {e}")
         # except Exception as e:
-        #    warnings.warn(f"Error reading LLM configs directory: {e}")
+        #    logger.warning(f"Error reading LLM configs directory: {e}")
         return llm_models
 
     def get_local_embedding_configs(self):
@@ -1160,9 +1168,9 @@ class SyncServer(object):
         #                        embedding_config = EmbeddingConfig(**config_data)
         #                        embedding_models.append(embedding_config)
         #                except (json.JSONDecodeError, ValueError) as e:
-        #                    warnings.warn(f"Error parsing embedding config file {filename}: {e}")
+        #                    logger.warning(f"Error parsing embedding config file {filename}: {e}")
         # except Exception as e:
-        #    warnings.warn(f"Error reading embedding configs directory: {e}")
+        #    logger.warning(f"Error reading embedding configs directory: {e}")
         return embedding_models
 
     def add_llm_model(self, request: LLMConfig) -> LLMConfig:
@@ -1501,7 +1509,7 @@ class SyncServer(object):
             # 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):
-                warnings.warn(
+                logger.warning(
                     f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
                 )
                 stream_tokens = False
@@ -1603,10 +1611,7 @@ class SyncServer(object):
         except HTTPException:
             raise
         except Exception as e:
-            print(e)
-            import traceback
-
-            traceback.print_exc()
+            logger.exception(f"Error sending message to agent: {e}")
             raise HTTPException(status_code=500, detail=f"{e}")
 
     @trace_method
@@ -1636,7 +1641,7 @@ class SyncServer(object):
         llm_config = letta_multi_agent.agent_state.llm_config
         supports_token_streaming = ["openai", "anthropic", "deepseek"]
         if stream_tokens and (llm_config.model_endpoint_type not in supports_token_streaming):
-            warnings.warn(
+            logger.warning(
                 f"Token streaming is only supported for models with type {' or '.join(supports_token_streaming)} in the model_endpoint: agent has endpoint type {llm_config.model_endpoint_type} and {llm_config.model_endpoint}. Setting stream_tokens to False."
             )
             stream_tokens = False

letta/server/ws_api/server.py

@@ -6,10 +6,13 @@ import traceback
 import websockets
 
 import letta.server.ws_api.protocol as protocol
+from letta.log import get_logger
 from letta.server.constants import WS_DEFAULT_PORT
 from letta.server.server import SyncServer
 from letta.server.ws_api.interface import SyncWebSocketInterface
 
+logger = get_logger(__name__)
+
 
 class WebSocketServer:
     def __init__(self, host="localhost", port=WS_DEFAULT_PORT):
@@ -68,8 +71,7 @@ class WebSocketServer:
                             await websocket.send(protocol.server_command_response("OK: Agent initialized"))
                         except Exception as e:
                             self.agent = None
-                            print(f"[server] self.create_new_agent failed with:\n{e}")
-                            print(f"{traceback.format_exc()}")
+                            logger.exception(f"[server] self.create_new_agent failed with: {e}")
                             await websocket.send(protocol.server_command_response(f"Error: Failed to init agent - {str(e)}"))
 
                     else:
@@ -88,8 +90,7 @@ class WebSocketServer:
                         # self.run_step(user_message)
                         self.server.user_message(user_id="NULL", agent_id=data["agent_id"], message=user_message)
                     except Exception as e:
-                        print(f"[server] self.server.user_message failed with:\n{e}")
-                        print(f"{traceback.format_exc()}")
+                        logger.exception(f"[server] self.server.user_message failed with: {e}")
                         await websocket.send(protocol.server_agent_response_error(f"server.user_message failed with: {e}"))
                     await asyncio.sleep(1)  # pause before sending the terminating message, w/o this messages may be missed
                     await websocket.send(protocol.server_agent_response_end())