letta-nightly 0.10.0.dev20250806104523__py3-none-any.whl → 0.11.0.dev20250807000848__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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.")

letta/llm_api/llm_api_tools.py

@@ -5,7 +5,7 @@ from typing import List, Optional, Union
 
 import requests
 
-from letta.constants import CLI_WARNING_PREFIX, LETTA_MODEL_ENDPOINT
+from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LettaConfigurationError, RateLimitExceededError
 from letta.llm_api.anthropic import (
     anthropic_bedrock_chat_completions_request,
@@ -193,8 +193,8 @@ def create(
             # force function calling for reliability, see https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice
             # TODO(matt) move into LLMConfig
             # TODO: This vllm checking is very brittle and is a patch at most
-            if llm_config.model_endpoint == LETTA_MODEL_ENDPOINT or (llm_config.handle and "vllm" in llm_config.handle):
-                function_call = "auto"  # TODO change to "required" once proxy supports it
+            if llm_config.handle and "vllm" in llm_config.handle:
+                function_call = "auto"
             else:
                 function_call = "required"
 

letta/local_llm/vllm/api.py

@@ -32,6 +32,9 @@ def get_vllm_completion(endpoint, auth_type, auth_key, model, prompt, context_wi
     if not endpoint.startswith(("http://", "https://")):
         raise ValueError(f"Endpoint ({endpoint}) must begin with http:// or https://")
 
+    if not endpoint.endswith("/v1"):
+        endpoint = endpoint.rstrip("/") + "/v1"
+
     try:
         URI = urljoin(endpoint.strip("/") + "/", WEBUI_API_SUFFIX.strip("/"))
         response = post_json_auth_request(uri=URI, json_payload=request, auth_type=auth_type, auth_key=auth_key)

letta/orm/__init__.py

@@ -1,5 +1,7 @@
 from letta.orm.agent import Agent
 from letta.orm.agents_tags import AgentsTags
+from letta.orm.archive import Archive
+from letta.orm.archives_agents import ArchivesAgents
 from letta.orm.base import Base
 from letta.orm.block import Block
 from letta.orm.block_history import BlockHistory
@@ -19,7 +21,7 @@ from letta.orm.llm_batch_job import LLMBatchJob
 from letta.orm.mcp_server import MCPServer
 from letta.orm.message import Message
 from letta.orm.organization import Organization
-from letta.orm.passage import AgentPassage, BasePassage, SourcePassage
+from letta.orm.passage import ArchivalPassage, BasePassage, SourcePassage
 from letta.orm.prompt import Prompt
 from letta.orm.provider import Provider
 from letta.orm.provider_trace import ProviderTrace

letta/orm/agent.py

@@ -24,6 +24,7 @@ from letta.utils import calculate_file_defaults_based_on_context_window
 
 if TYPE_CHECKING:
     from letta.orm.agents_tags import AgentsTags
+    from letta.orm.archives_agents import ArchivesAgents
     from letta.orm.files_agents import FileAgent
     from letta.orm.identity import Identity
     from letta.orm.organization import Organization
@@ -156,6 +157,13 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, AsyncAttrs):
         cascade="all, delete-orphan",
         lazy="selectin",
     )
+    archives_agents: Mapped[List["ArchivesAgents"]] = relationship(
+        "ArchivesAgents",
+        back_populates="agent",
+        cascade="all, delete-orphan",
+        lazy="noload",
+        doc="Archives accessible by this agent.",
+    )
 
     def _get_per_file_view_window_char_limit(self) -> int:
         """Get the per_file_view_window_char_limit, calculating defaults if None."""