letta-nightly 0.10.0.dev20250806104523__tar.gz → 0.11.0.dev20250807104511__tar.gz

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/PKG-INFO

@@ -1,14 +1,13 @@
 Metadata-Version: 2.1
 Name: letta-nightly
-Version: 0.10.0.dev20250806104523
+Version: 0.11.0.dev20250807104511
 Summary: Create LLM agents with long-term memory and custom tools
 License: Apache License
 Author: Letta Team
 Author-email: contact@letta.com
-Requires-Python: >=3.10,<3.14
+Requires-Python: >=3.11,<3.14
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Provides-Extra: all
@@ -79,7 +78,7 @@ Requires-Dist: orjson (>=3.11.1,<4.0.0)
 Requires-Dist: pathvalidate (>=3.2.1,<4.0.0)
 Requires-Dist: pexpect (>=4.9.0,<5.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: pg8000 (>=1.30.3,<2.0.0) ; extra == "postgres" or extra == "all"
-Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres" or extra == "all"
+Requires-Dist: pgvector (>=0.2.3,<0.3.0) ; extra == "postgres" or extra == "desktop" or extra == "all"
 Requires-Dist: pinecone[asyncio] (>=7.3.0,<8.0.0) ; extra == "pinecone" or extra == "all"
 Requires-Dist: pre-commit (>=3.5.0,<4.0.0) ; extra == "dev" or extra == "all"
 Requires-Dist: prettytable (>=3.9.0,<4.0.0)
@@ -285,7 +284,7 @@ In the CLI tool, you'll be able to create new agents, or load existing agents:
 ```
 🧬 Creating new agent...
 ? Select LLM model: letta-free [type=openai] [ip=https://inference.letta.com]
-? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.memgpt.ai]
+? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.letta.com]
 ->  🤖 Using persona profile: 'sam_pov'
 ->  🧑 Using human profile: 'basic'
 ->  🛠️  8 tools: send_message, pause_heartbeats, conversation_search, conversation_search_date, archival_memory_insert, archival_memory_search, core_memory_append, core_memory_replace
@@ -351,7 +350,7 @@ letta run
 ```
 🧬 Creating new agent...
 ? Select LLM model: letta-free [type=openai] [ip=https://inference.letta.com]
-? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.memgpt.ai]
+? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.letta.com]
 ->  🤖 Using persona profile: 'sam_pov'
 ->  🧑 Using human profile: 'basic'
 ->  🛠️  8 tools: send_message, pause_heartbeats, conversation_search, conversation_search_date, archival_memory_insert, archival_memory_search, core_memory_append, core_memory_replace

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/README.md

@@ -168,7 +168,7 @@ In the CLI tool, you'll be able to create new agents, or load existing agents:
 ```
 🧬 Creating new agent...
 ? Select LLM model: letta-free [type=openai] [ip=https://inference.letta.com]
-? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.memgpt.ai]
+? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.letta.com]
 ->  🤖 Using persona profile: 'sam_pov'
 ->  🧑 Using human profile: 'basic'
 ->  🛠️  8 tools: send_message, pause_heartbeats, conversation_search, conversation_search_date, archival_memory_insert, archival_memory_search, core_memory_append, core_memory_replace
@@ -234,7 +234,7 @@ letta run
 ```
 🧬 Creating new agent...
 ? Select LLM model: letta-free [type=openai] [ip=https://inference.letta.com]
-? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.memgpt.ai]
+? Select embedding model: letta-free [type=hugging-face] [ip=https://embeddings.letta.com]
 ->  🤖 Using persona profile: 'sam_pov'
 ->  🧑 Using human profile: 'basic'
 ->  🛠️  8 tools: send_message, pause_heartbeats, conversation_search, conversation_search_date, archival_memory_insert, archival_memory_search, core_memory_append, core_memory_replace

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/__init__.py

@@ -5,14 +5,11 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.10.0"
+    __version__ = "0.11.0"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]
 
-# import clients
-from letta.client.client import RESTClient
-
 # Import sqlite_functions early to ensure event handlers are registered
 from letta.orm import sqlite_functions
 

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/agent.py

@@ -41,12 +41,11 @@ from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_mes
 from letta.log import get_logger
 from letta.memory import summarize_messages
 from letta.orm import User
-from letta.orm.enums import ToolType
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent, get_prompt_template_for_agent_type
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
-from letta.schemas.enums import MessageRole, ProviderType
+from letta.schemas.enums import MessageRole, ProviderType, ToolType
 from letta.schemas.letta_message_content import ImageContent, TextContent
 from letta.schemas.memory import ContextWindowOverview, Memory
 from letta.schemas.message import Message, MessageCreate, ToolReturn

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/agents/base_agent.py

@@ -17,7 +17,7 @@ from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
-from letta.services.helpers.agent_manager_helper import compile_system_message_async
+from letta.services.helpers.agent_manager_helper import get_system_message_from_compiled_memory
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.utils import united_diff
@@ -122,7 +122,7 @@ class BaseAgent(ABC):
             curr_dynamic_section = extract_dynamic_section(curr_system_message_text)
 
             # generate just the memory string with current state for comparison
-            curr_memory_str = await agent_state.memory.compile_async(
+            curr_memory_str = await agent_state.memory.compile_in_thread_async(
                 tool_usage_rules=tool_constraint_block, sources=agent_state.sources, max_files_open=agent_state.max_files_open
             )
             new_dynamic_section = extract_dynamic_section(curr_memory_str)
@@ -142,16 +142,13 @@ class BaseAgent(ABC):
             if num_archival_memories is None:
                 num_archival_memories = await self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
 
-            new_system_message_str = await compile_system_message_async(
+            new_system_message_str = get_system_message_from_compiled_memory(
                 system_prompt=agent_state.system,
-                in_context_memory=agent_state.memory,
+                memory_with_sources=curr_memory_str,
                 in_context_memory_last_edit=memory_edit_timestamp,
                 timezone=agent_state.timezone,
                 previous_message_count=num_messages - len(in_context_messages),
                 archival_memory_size=num_archival_memories,
-                tool_rules_solver=tool_rules_solver,
-                sources=agent_state.sources,
-                max_files_open=agent_state.max_files_open,
             )
 
             diff = united_diff(curr_system_message_text, new_system_message_str)

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/agents/letta_agent.py

@@ -30,12 +30,11 @@ from letta.llm_api.llm_client import LLMClient
 from letta.llm_api.llm_client_base import LLMClientBase
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
-from letta.orm.enums import ToolType
 from letta.otel.context import get_ctx_attributes
 from letta.otel.metric_registry import MetricRegistry
 from letta.otel.tracing import log_event, trace_method, tracer
 from letta.schemas.agent import AgentState, UpdateAgent
-from letta.schemas.enums import JobStatus, MessageRole, ProviderType
+from letta.schemas.enums import JobStatus, MessageRole, ProviderType, ToolType
 from letta.schemas.letta_message import MessageType
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent
 from letta.schemas.letta_response import LettaResponse
@@ -362,8 +361,16 @@ class LettaAgent(BaseAgent):
                 if settings.track_stop_reason:
                     if step_progression == StepProgression.FINISHED and should_continue:
                         continue
+
+                    self.logger.debug("Running cleanup for agent loop run: %s", self.current_run_id)
                     self.logger.info("Running final update. Step Progression: %s", step_progression)
                     try:
+                        if step_progression == StepProgression.FINISHED and not should_continue:
+                            if stop_reason is None:
+                                stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+                            await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
+                            break
+
                         if step_progression < StepProgression.STEP_LOGGED:
                             await self.step_manager.log_step_async(
                                 actor=self.actor,
@@ -392,12 +399,11 @@ class LettaAgent(BaseAgent):
                                 self.logger.error("Error in step after logging step")
                                 stop_reason = LettaStopReason(stop_reason=StopReasonType.error.value)
                             await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
-                        elif step_progression == StepProgression.FINISHED and not should_continue:
-                            if stop_reason is None:
-                                stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
-                            await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
                         else:
                             self.logger.error("Invalid StepProgression value")
+
+                        await self._log_request(request_start_timestamp_ns, request_span)
+
                     except Exception as e:
                         self.logger.error("Failed to update step: %s", e)
 
@@ -414,17 +420,7 @@ class LettaAgent(BaseAgent):
                 force=False,
             )
 
-        # log request time
-        if request_start_timestamp_ns:
-            now = get_utc_timestamp_ns()
-            duration_ms = ns_to_ms(now - request_start_timestamp_ns)
-            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": duration_ms})
-
-            # update agent's last run metrics
-            now_datetime = get_utc_time()
-            await self._update_agent_last_run_metrics(now_datetime, duration_ms)
-
-        request_span.end()
+        await self._log_request(request_start_timestamp_ns, request_span)
 
         # Return back usage
         for finish_chunk in self.get_finish_chunks_for_stream(usage, stop_reason):
@@ -591,8 +587,16 @@ class LettaAgent(BaseAgent):
                 if settings.track_stop_reason:
                     if step_progression == StepProgression.FINISHED and should_continue:
                         continue
+
+                    self.logger.debug("Running cleanup for agent loop run: %s", self.current_run_id)
                     self.logger.info("Running final update. Step Progression: %s", step_progression)
                     try:
+                        if step_progression == StepProgression.FINISHED and not should_continue:
+                            if stop_reason is None:
+                                stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+                            await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
+                            break
+
                         if step_progression < StepProgression.STEP_LOGGED:
                             await self.step_manager.log_step_async(
                                 actor=self.actor,
@@ -621,30 +625,17 @@ class LettaAgent(BaseAgent):
                                 self.logger.error("Error in step after logging step")
                                 stop_reason = LettaStopReason(stop_reason=StopReasonType.error.value)
                             await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
-                        elif step_progression == StepProgression.FINISHED and not should_continue:
-                            if stop_reason is None:
-                                stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
-                            await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
                         else:
                             self.logger.error("Invalid StepProgression value")
+
+                        await self._log_request(request_start_timestamp_ns, request_span)
+
                     except Exception as e:
                         self.logger.error("Failed to update step: %s", e)
 
             if not should_continue:
                 break
 
-        # log request time
-        if request_start_timestamp_ns:
-            now = get_utc_timestamp_ns()
-            duration_ms = ns_to_ms(now - request_start_timestamp_ns)
-            request_span.add_event(name="request_ms", attributes={"duration_ms": duration_ms})
-
-            # update agent's last run metrics
-            now_datetime = get_utc_time()
-            await self._update_agent_last_run_metrics(now_datetime, duration_ms)
-
-        request_span.end()
-
         # Extend the in context message ids
         if not agent_state.message_buffer_autoclear:
             await self._rebuild_context_window(
@@ -655,6 +646,8 @@ class LettaAgent(BaseAgent):
                 force=False,
             )
 
+        await self._log_request(request_start_timestamp_ns, request_span)
+
         return current_in_context_messages, new_in_context_messages, stop_reason, usage
 
     async def _update_agent_last_run_metrics(self, completion_time: datetime, duration_ms: float) -> None:
@@ -756,7 +749,6 @@ class LettaAgent(BaseAgent):
                 elif agent_state.llm_config.model_endpoint_type == ProviderType.openai:
                     interface = OpenAIStreamingInterface(
                         use_assistant_message=use_assistant_message,
-                        put_inner_thoughts_in_kwarg=agent_state.llm_config.put_inner_thoughts_in_kwargs,
                         is_openai_proxy=agent_state.llm_config.provider_name == "lmstudio_openai",
                         messages=current_in_context_messages + new_in_context_messages,
                         tools=request_data.get("tools", []),
@@ -767,16 +759,20 @@ class LettaAgent(BaseAgent):
                 async for chunk in interface.process(
                     stream,
                     ttft_span=request_span,
-                    provider_request_start_timestamp_ns=provider_request_start_timestamp_ns,
                 ):
-                    # Measure time to first token
+                    # Measure TTFT (trace, metric, and db). This should be consolidated.
                     if first_chunk and request_span is not None:
                         now = get_utc_timestamp_ns()
                         ttft_ns = now - request_start_timestamp_ns
+
                         request_span.add_event(name="time_to_first_token_ms", attributes={"ttft_ms": ns_to_ms(ttft_ns)})
                         metric_attributes = get_ctx_attributes()
                         metric_attributes["model.name"] = agent_state.llm_config.model
                         MetricRegistry().ttft_ms_histogram.record(ns_to_ms(ttft_ns), metric_attributes)
+
+                        if self.current_run_id and self.job_manager:
+                            await self.job_manager.record_ttft(self.current_run_id, ttft_ns, self.actor)
+
                         first_chunk = False
 
                     if include_return_message_types is None or chunk.message_type in include_return_message_types:
@@ -914,8 +910,16 @@ class LettaAgent(BaseAgent):
                 if settings.track_stop_reason:
                     if step_progression == StepProgression.FINISHED and should_continue:
                         continue
+
+                    self.logger.debug("Running cleanup for agent loop run: %s", self.current_run_id)
                     self.logger.info("Running final update. Step Progression: %s", step_progression)
                     try:
+                        if step_progression == StepProgression.FINISHED and not should_continue:
+                            if stop_reason is None:
+                                stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
+                            await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
+                            break
+
                         if step_progression < StepProgression.STEP_LOGGED:
                             await self.step_manager.log_step_async(
                                 actor=self.actor,
@@ -943,12 +947,12 @@ class LettaAgent(BaseAgent):
                                 self.logger.error("Error in step after logging step")
                                 stop_reason = LettaStopReason(stop_reason=StopReasonType.error.value)
                             await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
-                        elif step_progression == StepProgression.FINISHED and not should_continue:
-                            if stop_reason is None:
-                                stop_reason = LettaStopReason(stop_reason=StopReasonType.end_turn.value)
-                            await self.step_manager.update_step_stop_reason(self.actor, step_id, stop_reason.stop_reason)
                         else:
                             self.logger.error("Invalid StepProgression value")
+
+                        # Do tracking for failure cases. Can consolidate with success conditions later.
+                        await self._log_request(request_start_timestamp_ns, request_span)
+
                     except Exception as e:
                         self.logger.error("Failed to update step: %s", e)
 
@@ -964,21 +968,23 @@ class LettaAgent(BaseAgent):
                 force=False,
             )
 
-        # log time of entire request
-        if request_start_timestamp_ns:
-            now = get_utc_timestamp_ns()
-            duration_ms = ns_to_ms(now - request_start_timestamp_ns)
-            request_span.add_event(name="letta_request_ms", attributes={"duration_ms": duration_ms})
-
-            # update agent's last run metrics
-            completion_time = get_utc_time()
-            await self._update_agent_last_run_metrics(completion_time, duration_ms)
-
-        request_span.end()
+        await self._log_request(request_start_timestamp_ns, request_span)
 
         for finish_chunk in self.get_finish_chunks_for_stream(usage, stop_reason):
             yield f"data: {finish_chunk}\n\n"
 
+    async def _log_request(self, request_start_timestamp_ns: int, request_span: "Span | None"):
+        if request_start_timestamp_ns:
+            now_ns, now = get_utc_timestamp_ns(), get_utc_time()
+            duration_ns = now_ns - request_start_timestamp_ns
+            if request_span:
+                request_span.add_event(name="letta_request_ms", attributes={"duration_ms": ns_to_ms(duration_ns)})
+            await self._update_agent_last_run_metrics(now, ns_to_ms(duration_ns))
+            if self.current_run_id:
+                await self.job_manager.record_response_duration(self.current_run_id, duration_ns, self.actor)
+        if request_span:
+            request_span.end()
+
     # noinspection PyInconsistentReturns
     async def _build_and_request_from_llm(
         self,
@@ -1429,6 +1435,8 @@ class LettaAgent(BaseAgent):
                 status="error",
             )
 
+        print(target_tool)
+
         # TODO: This temp. Move this logic and code to executors
 
         if agent_step_span:

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/agents/letta_agent_batch.py

@@ -16,10 +16,9 @@ from letta.jobs.types import RequestStatusUpdateInfo, StepStatusUpdateInfo
 from letta.llm_api.llm_client import LLMClient
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
-from letta.orm.enums import ToolType
 from letta.otel.tracing import log_event, trace_method
 from letta.schemas.agent import AgentState
-from letta.schemas.enums import AgentStepStatus, JobStatus, MessageStreamStatus, ProviderType, SandboxType
+from letta.schemas.enums import AgentStepStatus, JobStatus, MessageStreamStatus, ProviderType, SandboxType, ToolType
 from letta.schemas.job import JobUpdate
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
 from letta.schemas.letta_message_content import OmittedReasoningContent, ReasoningContent, RedactedReasoningContent, TextContent

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/agents/voice_agent.py

@@ -13,9 +13,8 @@ from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.tool_execution_helper import add_pre_execution_message, enable_strict_mode, remove_request_heartbeat
 from letta.interfaces.openai_chat_completions_streaming_interface import OpenAIChatCompletionsStreamingInterface
 from letta.log import get_logger
-from letta.orm.enums import ToolType
 from letta.schemas.agent import AgentState, AgentType
-from letta.schemas.enums import MessageRole
+from letta.schemas.enums import MessageRole, ToolType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import Message, MessageCreate
 from letta.schemas.openai.chat_completion_request import (

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/agents/voice_sleeptime_agent.py

@@ -3,11 +3,10 @@ from typing import AsyncGenerator, List, Optional, Tuple, Union
 from letta.agents.helpers import _create_letta_response, serialize_message_history
 from letta.agents.letta_agent import LettaAgent
 from letta.constants import DEFAULT_MAX_STEPS
-from letta.orm.enums import ToolType
 from letta.otel.tracing import trace_method
 from letta.schemas.agent import AgentState
 from letta.schemas.block import BlockUpdate
-from letta.schemas.enums import MessageStreamStatus
+from letta.schemas.enums import MessageStreamStatus, ToolType
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage, MessageType
 from letta.schemas.letta_response import LettaResponse
 from letta.schemas.message import MessageCreate
@@ -166,7 +165,6 @@ class VoiceSleeptimeAgent(LettaAgent):
             memory = serialize_message_history(messages, context)
             self.agent_manager.passage_manager.insert_passage(
                 agent_state=agent_state,
-                agent_id=agent_state.id,
                 text=memory,
                 actor=self.actor,
             )

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/constants.py

@@ -5,7 +5,7 @@ from logging import CRITICAL, DEBUG, ERROR, INFO, NOTSET, WARN, WARNING
 LETTA_DIR = os.path.join(os.path.expanduser("~"), ".letta")
 LETTA_TOOL_EXECUTION_DIR = os.path.join(LETTA_DIR, "tool_execution_dir")
 
-LETTA_MODEL_ENDPOINT = "https://inference.letta.com"
+LETTA_MODEL_ENDPOINT = "https://inference.letta.com/v1/"
 DEFAULT_TIMEZONE = "UTC"
 
 ADMIN_PREFIX = "/v1/admin"
@@ -385,3 +385,6 @@ PINECONE_THROTTLE_DELAY = 0.75  # seconds base delay between batches
 # builtin web search
 WEB_SEARCH_MODEL_ENV_VAR_NAME = "LETTA_BUILTIN_WEBSEARCH_OPENAI_MODEL_NAME"
 WEB_SEARCH_MODEL_ENV_VAR_DEFAULT_VALUE = "gpt-4.1-mini-2025-04-14"
+
+# Excluded providers from base tool rules
+EXCLUDED_PROVIDERS_FROM_BASE_TOOL_RULES = {"anthropic", "openai", "google_ai", "google_vertex"}

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/embeddings.py

@@ -235,7 +235,7 @@ def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None
         return OpenAIEmbeddings(
             api_key=model_settings.openai_api_key,
             model=config.embedding_model,
-            base_url=model_settings.openai_api_base,
+            base_url=config.embedding_endpoint or model_settings.openai_api_base,
         )
 
     elif endpoint_type == "azure":

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/functions/function_sets/base.py

@@ -75,7 +75,6 @@ def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     """
     self.passage_manager.insert_passage(
         agent_state=self.agent_state,
-        agent_id=self.agent_state.id,
         text=content,
         actor=self.user,
     )

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/functions/mcp_client/types.py

@@ -6,6 +6,8 @@ from typing import Dict, List, Optional
 from mcp import Tool
 from pydantic import BaseModel, Field
 
+from letta.utils import get_logger
+
 # MCP Authentication Constants
 MCP_AUTH_HEADER_AUTHORIZATION = "Authorization"
 MCP_AUTH_TOKEN_BEARER_PREFIX = "Bearer"
@@ -13,6 +15,8 @@ TEMPLATED_VARIABLE_REGEX = (
     r"\{\{\s*([A-Z_][A-Z0-9_]*)\s*(?:\|\s*([^}]+?)\s*)?\}\}"  # Allows for optional whitespace around the variable name and default value
 )
 
+logger = get_logger(__name__)
+
 
 class MCPTool(Tool):
     """A simple wrapper around MCP's tool definition (to avoid conflict with our own)"""

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/groups/supervisor_multi_agent.py

@@ -7,7 +7,7 @@ from letta.functions.functions import parse_source_code
 from letta.functions.schema_generator import generate_schema
 from letta.interface import AgentInterface
 from letta.orm import User
-from letta.orm.enums import ToolType
+from letta.schemas.enums import ToolType
 from letta.schemas.letta_message_content import TextContent
 from letta.schemas.message import MessageCreate
 from letta.schemas.tool import Tool

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/interfaces/anthropic_streaming_interface.py

@@ -25,11 +25,8 @@ from anthropic.types.beta import (
 )
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.helpers.datetime_helpers import get_utc_timestamp_ns, ns_to_ms
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
-from letta.otel.context import get_ctx_attributes
-from letta.otel.metric_registry import MetricRegistry
 from letta.schemas.letta_message import (
     AssistantMessage,
     HiddenReasoningMessage,
@@ -133,28 +130,12 @@ class AnthropicStreamingInterface:
         self,
         stream: AsyncStream[BetaRawMessageStreamEvent],
         ttft_span: Optional["Span"] = None,
-        provider_request_start_timestamp_ns: int | None = None,
     ) -> AsyncGenerator[LettaMessage | LettaStopReason, None]:
         prev_message_type = None
         message_index = 0
-        first_chunk = True
         try:
             async with stream:
                 async for event in stream:
-                    # TODO (cliandy): reconsider in stream cancellations
-                    # await cancellation_token.check_and_raise_if_cancelled()
-                    if first_chunk and ttft_span is not None and provider_request_start_timestamp_ns is not None:
-                        now = get_utc_timestamp_ns()
-                        ttft_ns = now - provider_request_start_timestamp_ns
-                        ttft_span.add_event(
-                            name="anthropic_time_to_first_token_ms", attributes={"anthropic_time_to_first_token_ms": ns_to_ms(ttft_ns)}
-                        )
-                        metric_attributes = get_ctx_attributes()
-                        if isinstance(event, BetaRawMessageStartEvent):
-                            metric_attributes["model.name"] = event.message.model
-                        MetricRegistry().ttft_ms_histogram.record(ns_to_ms(ttft_ns), metric_attributes)
-                        first_chunk = False
-
                     # TODO: Support BetaThinkingBlock, BetaRedactedThinkingBlock
                     if isinstance(event, BetaRawContentBlockStartEvent):
                         content = event.content_block
@@ -389,13 +370,24 @@ class AnthropicStreamingInterface:
 
                         self.anthropic_mode = None
         except asyncio.CancelledError as e:
-            logger.info("Cancelled stream %s", e)
-            yield LettaStopReason(stop_reason=StopReasonType.cancelled)
-            raise
+            import traceback
+
+            logger.error("Cancelled stream %s: %s", e, traceback.format_exc())
+            ttft_span.add_event(
+                name="stop_reason",
+                attributes={"stop_reason": StopReasonType.cancelled.value, "error": str(e), "stacktrace": traceback.format_exc()},
+            )
+            raise e
         except Exception as e:
-            logger.error("Error processing stream: %s", e)
+            import traceback
+
+            logger.error("Error processing stream: %s", e, traceback.format_exc())
+            ttft_span.add_event(
+                name="stop_reason",
+                attributes={"stop_reason": StopReasonType.error.value, "error": str(e), "stacktrace": traceback.format_exc()},
+            )
             yield LettaStopReason(stop_reason=StopReasonType.error)
-            raise
+            raise e
         finally:
             logger.info("AnthropicStreamingInterface: Stream processing complete.")
 

{letta_nightly-0.10.0.dev20250806104523 → letta_nightly-0.11.0.dev20250807104511}/letta/interfaces/openai_streaming_interface.py

@@ -7,12 +7,9 @@ from openai import AsyncStream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 
 from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
-from letta.helpers.datetime_helpers import get_utc_timestamp_ns, ns_to_ms
 from letta.llm_api.openai_client import is_openai_reasoning_model
 from letta.local_llm.utils import num_tokens_from_functions, num_tokens_from_messages
 from letta.log import get_logger
-from letta.otel.context import get_ctx_attributes
-from letta.otel.metric_registry import MetricRegistry
 from letta.schemas.letta_message import AssistantMessage, LettaMessage, ReasoningMessage, ToolCallDelta, ToolCallMessage
 from letta.schemas.letta_message_content import OmittedReasoningContent, TextContent
 from letta.schemas.letta_stop_reason import LettaStopReason, StopReasonType
@@ -35,7 +32,6 @@ class OpenAIStreamingInterface:
     def __init__(
         self,
         use_assistant_message: bool = False,
-        put_inner_thoughts_in_kwarg: bool = False,
         is_openai_proxy: bool = False,
         messages: Optional[list] = None,
         tools: Optional[list] = None,
@@ -107,7 +103,6 @@ class OpenAIStreamingInterface:
         self,
         stream: AsyncStream[ChatCompletionChunk],
         ttft_span: Optional["Span"] = None,
-        provider_request_start_timestamp_ns: int | None = None,
     ) -> AsyncGenerator[LettaMessage | LettaStopReason, None]:
         """
         Iterates over the OpenAI stream, yielding SSE events.
@@ -125,29 +120,11 @@ class OpenAIStreamingInterface:
                 tool_dicts = [tool["function"] if isinstance(tool, dict) and "function" in tool else tool for tool in self.tools]
                 self.fallback_input_tokens += num_tokens_from_functions(tool_dicts)
 
-        first_chunk = True
         try:
             async with stream:
                 prev_message_type = None
                 message_index = 0
                 async for chunk in stream:
-                    # TODO (cliandy): reconsider in stream cancellations
-                    # await cancellation_token.check_and_raise_if_cancelled()
-                    if first_chunk and ttft_span is not None and provider_request_start_timestamp_ns is not None:
-                        now = get_utc_timestamp_ns()
-                        ttft_ns = now - provider_request_start_timestamp_ns
-                        ttft_span.add_event(
-                            name="openai_time_to_first_token_ms", attributes={"openai_time_to_first_token_ms": ns_to_ms(ttft_ns)}
-                        )
-                        metric_attributes = get_ctx_attributes()
-                        metric_attributes["model.name"] = chunk.model
-                        MetricRegistry().ttft_ms_histogram.record(ns_to_ms(ttft_ns), metric_attributes)
-
-                        if self.is_openai_proxy:
-                            self.fallback_output_tokens += count_tokens(chunk.model_dump_json())
-
-                        first_chunk = False
-
                     if not self.model or not self.message_id:
                         self.model = chunk.model
                         self.message_id = chunk.id
@@ -389,12 +366,23 @@ class OpenAIStreamingInterface:
                                                 yield tool_call_msg
                                                 self.function_id_buffer = None
         except asyncio.CancelledError as e:
-            logger.info("Cancelled stream %s", e)
-            yield LettaStopReason(stop_reason=StopReasonType.cancelled)
-            raise
+            import traceback
+
+            logger.error("Cancelled stream %s: %s", e, traceback.format_exc())
+            ttft_span.add_event(
+                name="stop_reason",
+                attributes={"stop_reason": StopReasonType.cancelled.value, "error": str(e), "stacktrace": traceback.format_exc()},
+            )
+            raise e
         except Exception as e:
-            logger.error("Error processing stream: %s", e)
+            import traceback
+
+            logger.error("Error processing stream: %s", e, traceback.format_exc())
+            ttft_span.add_event(
+                name="stop_reason",
+                attributes={"stop_reason": StopReasonType.error.value, "error": str(e), "stacktrace": traceback.format_exc()},
+            )
             yield LettaStopReason(stop_reason=StopReasonType.error)
-            raise
+            raise e
         finally:
             logger.info("OpenAIStreamingInterface: Stream processing complete.")