letta-nightly 0.11.7.dev20250909104137__py3-none-any.whl → 0.11.7.dev20250910104051__py3-none-any.whl

letta/interfaces/anthropic_streaming_interface.py

@@ -28,6 +28,7 @@ from letta.constants import DEFAULT_MESSAGE_TOOL, DEFAULT_MESSAGE_TOOL_KWARG
 from letta.local_llm.constants import INNER_THOUGHTS_KWARG
 from letta.log import get_logger
 from letta.schemas.letta_message import (
+    ApprovalRequestMessage,
     AssistantMessage,
     HiddenReasoningMessage,
     LettaMessage,
@@ -59,7 +60,12 @@ class AnthropicStreamingInterface:
     and detection of tool call events.
     """
 
-    def __init__(self, use_assistant_message: bool = False, put_inner_thoughts_in_kwarg: bool = False):
+    def __init__(
+        self,
+        use_assistant_message: bool = False,
+        put_inner_thoughts_in_kwarg: bool = False,
+        requires_approval_tools: list = [],
+    ):
         self.json_parser: JSONParser = PydanticJSONParser()
         self.use_assistant_message = use_assistant_message
 
@@ -90,6 +96,8 @@ class AnthropicStreamingInterface:
         # Buffer to handle partial XML tags across chunks
         self.partial_tag_buffer = ""
 
+        self.requires_approval_tools = requires_approval_tools
+
     def get_tool_call_object(self) -> ToolCall:
         """Useful for agent loop"""
         if not self.tool_call_name:
@@ -218,11 +226,12 @@ class AnthropicStreamingInterface:
         except Exception as 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()},
-            )
+            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            if ttft_span:
+                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 e
         finally:
@@ -256,13 +265,15 @@ class AnthropicStreamingInterface:
                 self.inner_thoughts_complete = False
 
                 if not self.use_assistant_message:
-                    # Buffer the initial tool call message instead of yielding immediately
-                    tool_call_msg = ToolCallMessage(
-                        id=self.letta_message_id,
-                        tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id),
-                        date=datetime.now(timezone.utc).isoformat(),
-                    )
-                    self.tool_call_buffer.append(tool_call_msg)
+                    # Only buffer the initial tool call message if it doesn't require approval
+                    # For approval-required tools, we'll create the ApprovalRequestMessage later
+                    if self.tool_call_name not in self.requires_approval_tools:
+                        tool_call_msg = ToolCallMessage(
+                            id=self.letta_message_id,
+                            tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id),
+                            date=datetime.now(timezone.utc).isoformat(),
+                        )
+                        self.tool_call_buffer.append(tool_call_msg)
             elif isinstance(content, BetaThinkingBlock):
                 self.anthropic_mode = EventMode.THINKING
                 # TODO: Can capture signature, etc.
@@ -353,11 +364,36 @@ class AnthropicStreamingInterface:
                     prev_message_type = reasoning_message.message_type
                     yield reasoning_message
 
-                # Check if inner thoughts are complete - if so, flush the buffer
+                # Check if inner thoughts are complete - if so, flush the buffer or create approval message
                 if not self.inner_thoughts_complete and self._check_inner_thoughts_complete(self.accumulated_tool_call_args):
                     self.inner_thoughts_complete = True
-                    # Flush all buffered tool call messages
-                    if len(self.tool_call_buffer) > 0:
+
+                    # Check if this tool requires approval
+                    if self.tool_call_name in self.requires_approval_tools:
+                        # Create ApprovalRequestMessage directly (buffer should be empty)
+                        if prev_message_type and prev_message_type != "approval_request_message":
+                            message_index += 1
+
+                        # Strip out inner thoughts from arguments
+                        tool_call_args = self.accumulated_tool_call_args
+                        if current_inner_thoughts:
+                            tool_call_args = tool_call_args.replace(f'"{INNER_THOUGHTS_KWARG}": "{current_inner_thoughts}"', "")
+
+                        approval_msg = ApprovalRequestMessage(
+                            id=self.letta_message_id,
+                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                            date=datetime.now(timezone.utc).isoformat(),
+                            name=self.tool_call_name,
+                            tool_call=ToolCallDelta(
+                                name=self.tool_call_name,
+                                tool_call_id=self.tool_call_id,
+                                arguments=tool_call_args,
+                            ),
+                        )
+                        prev_message_type = approval_msg.message_type
+                        yield approval_msg
+                    elif len(self.tool_call_buffer) > 0:
+                        # Flush buffered tool call messages for non-approval tools
                         if prev_message_type and prev_message_type != "tool_call_message":
                             message_index += 1
 
@@ -371,9 +407,6 @@ class AnthropicStreamingInterface:
                             id=self.tool_call_buffer[0].id,
                             otid=Message.generate_otid_from_id(self.tool_call_buffer[0].id, message_index),
                             date=self.tool_call_buffer[0].date,
-                            name=self.tool_call_buffer[0].name,
-                            sender_id=self.tool_call_buffer[0].sender_id,
-                            step_id=self.tool_call_buffer[0].step_id,
                             tool_call=ToolCallDelta(
                                 name=self.tool_call_name,
                                 tool_call_id=self.tool_call_id,
@@ -404,11 +437,18 @@ class AnthropicStreamingInterface:
                         yield assistant_msg
                 else:
                     # Otherwise, it is a normal tool call - buffer or yield based on inner thoughts status
-                    tool_call_msg = ToolCallMessage(
-                        id=self.letta_message_id,
-                        tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json),
-                        date=datetime.now(timezone.utc).isoformat(),
-                    )
+                    if self.tool_call_name in self.requires_approval_tools:
+                        tool_call_msg = ApprovalRequestMessage(
+                            id=self.letta_message_id,
+                            tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json),
+                            date=datetime.now(timezone.utc).isoformat(),
+                        )
+                    else:
+                        tool_call_msg = ToolCallMessage(
+                            id=self.letta_message_id,
+                            tool_call=ToolCallDelta(name=self.tool_call_name, tool_call_id=self.tool_call_id, arguments=delta.partial_json),
+                            date=datetime.now(timezone.utc).isoformat(),
+                        )
                     if self.inner_thoughts_complete:
                         if prev_message_type and prev_message_type != "tool_call_message":
                             message_index += 1

letta/interfaces/openai_streaming_interface.py

@@ -11,6 +11,7 @@ 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.schemas.letta_message import (
+    ApprovalRequestMessage,
     AssistantMessage,
     HiddenReasoningMessage,
     LettaMessage,
@@ -43,6 +44,7 @@ class OpenAIStreamingInterface:
         messages: Optional[list] = None,
         tools: Optional[list] = None,
         put_inner_thoughts_in_kwarg: bool = True,
+        requires_approval_tools: list = [],
     ):
         self.use_assistant_message = use_assistant_message
         self.assistant_message_tool_name = DEFAULT_MESSAGE_TOOL
@@ -86,6 +88,8 @@ class OpenAIStreamingInterface:
         self.reasoning_messages = []
         self.emitted_hidden_reasoning = False  # Track if we've emitted hidden reasoning message
 
+        self.requires_approval_tools = requires_approval_tools
+
     def get_reasoning_content(self) -> list[TextContent | OmittedReasoningContent]:
         content = "".join(self.reasoning_messages).strip()
 
@@ -162,11 +166,12 @@ class OpenAIStreamingInterface:
         except Exception as 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()},
-            )
+            logger.error("Error processing stream: %s\n%s", e, traceback.format_exc())
+            if ttft_span:
+                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 e
         finally:
@@ -274,16 +279,28 @@ class OpenAIStreamingInterface:
                                 if prev_message_type and prev_message_type != "tool_call_message":
                                     message_index += 1
                                 self.tool_call_name = str(self.function_name_buffer)
-                                tool_call_msg = ToolCallMessage(
-                                    id=self.letta_message_id,
-                                    date=datetime.now(timezone.utc),
-                                    tool_call=ToolCallDelta(
-                                        name=self.function_name_buffer,
-                                        arguments=None,
-                                        tool_call_id=self.function_id_buffer,
-                                    ),
-                                    otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
-                                )
+                                if self.tool_call_name in self.requires_approval_tools:
+                                    tool_call_msg = ApprovalRequestMessage(
+                                        id=self.letta_message_id,
+                                        date=datetime.now(timezone.utc),
+                                        tool_call=ToolCallDelta(
+                                            name=self.function_name_buffer,
+                                            arguments=None,
+                                            tool_call_id=self.function_id_buffer,
+                                        ),
+                                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                    )
+                                else:
+                                    tool_call_msg = ToolCallMessage(
+                                        id=self.letta_message_id,
+                                        date=datetime.now(timezone.utc),
+                                        tool_call=ToolCallDelta(
+                                            name=self.function_name_buffer,
+                                            arguments=None,
+                                            tool_call_id=self.function_id_buffer,
+                                        ),
+                                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                    )
                                 prev_message_type = tool_call_msg.message_type
                                 yield tool_call_msg
 
@@ -404,17 +421,30 @@ class OpenAIStreamingInterface:
                                     combined_chunk = self.function_args_buffer + updates_main_json
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
-                                    tool_call_msg = ToolCallMessage(
-                                        id=self.letta_message_id,
-                                        date=datetime.now(timezone.utc),
-                                        tool_call=ToolCallDelta(
-                                            name=self.function_name_buffer,
-                                            arguments=combined_chunk,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
-                                        # name=name,
-                                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
-                                    )
+                                    if self.function_name_buffer in self.requires_approval_tools:
+                                        tool_call_msg = ApprovalRequestMessage(
+                                            id=self.letta_message_id,
+                                            date=datetime.now(timezone.utc),
+                                            tool_call=ToolCallDelta(
+                                                name=self.function_name_buffer,
+                                                arguments=combined_chunk,
+                                                tool_call_id=self.function_id_buffer,
+                                            ),
+                                            # name=name,
+                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                        )
+                                    else:
+                                        tool_call_msg = ToolCallMessage(
+                                            id=self.letta_message_id,
+                                            date=datetime.now(timezone.utc),
+                                            tool_call=ToolCallDelta(
+                                                name=self.function_name_buffer,
+                                                arguments=combined_chunk,
+                                                tool_call_id=self.function_id_buffer,
+                                            ),
+                                            # name=name,
+                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                        )
                                     prev_message_type = tool_call_msg.message_type
                                     yield tool_call_msg
                                     # clear buffer
@@ -424,17 +454,30 @@ class OpenAIStreamingInterface:
                                     # If there's no buffer to clear, just output a new chunk with new data
                                     if prev_message_type and prev_message_type != "tool_call_message":
                                         message_index += 1
-                                    tool_call_msg = ToolCallMessage(
-                                        id=self.letta_message_id,
-                                        date=datetime.now(timezone.utc),
-                                        tool_call=ToolCallDelta(
-                                            name=None,
-                                            arguments=updates_main_json,
-                                            tool_call_id=self.function_id_buffer,
-                                        ),
-                                        # name=name,
-                                        otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
-                                    )
+                                    if self.function_name_buffer in self.requires_approval_tools:
+                                        tool_call_msg = ApprovalRequestMessage(
+                                            id=self.letta_message_id,
+                                            date=datetime.now(timezone.utc),
+                                            tool_call=ToolCallDelta(
+                                                name=None,
+                                                arguments=updates_main_json,
+                                                tool_call_id=self.function_id_buffer,
+                                            ),
+                                            # name=name,
+                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                        )
+                                    else:
+                                        tool_call_msg = ToolCallMessage(
+                                            id=self.letta_message_id,
+                                            date=datetime.now(timezone.utc),
+                                            tool_call=ToolCallDelta(
+                                                name=None,
+                                                arguments=updates_main_json,
+                                                tool_call_id=self.function_id_buffer,
+                                            ),
+                                            # name=name,
+                                            otid=Message.generate_otid_from_id(self.letta_message_id, message_index),
+                                        )
                                     prev_message_type = tool_call_msg.message_type
                                     yield tool_call_msg
                                     self.function_id_buffer = None

letta/llm_api/openai_client.py

@@ -1,3 +1,4 @@
+import asyncio
 import os
 from typing import List, Optional
 
@@ -319,13 +320,53 @@ class OpenAIClient(LLMClientBase):
 
     @trace_method
     async def request_embeddings(self, inputs: List[str], embedding_config: EmbeddingConfig) -> List[List[float]]:
-        """Request embeddings given texts and embedding config"""
+        """Request embeddings given texts and embedding config with chunking and retry logic"""
+        if not inputs:
+            return []
+
         kwargs = self._prepare_client_kwargs_embedding(embedding_config)
         client = AsyncOpenAI(**kwargs)
-        response = await client.embeddings.create(model=embedding_config.embedding_model, input=inputs)
 
-        # TODO: add total usage
-        return [r.embedding for r in response.data]
+        # track results by original index to maintain order
+        results = [None] * len(inputs)
+
+        # queue of (start_idx, chunk_inputs) to process
+        chunks_to_process = [(i, inputs[i : i + 2048]) for i in range(0, len(inputs), 2048)]
+
+        min_chunk_size = 256
+
+        while chunks_to_process:
+            tasks = []
+            task_metadata = []
+
+            for start_idx, chunk_inputs in chunks_to_process:
+                task = client.embeddings.create(model=embedding_config.embedding_model, input=chunk_inputs)
+                tasks.append(task)
+                task_metadata.append((start_idx, chunk_inputs))
+
+            task_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            failed_chunks = []
+            for (start_idx, chunk_inputs), result in zip(task_metadata, task_results):
+                if isinstance(result, Exception):
+                    # check if we can retry with smaller chunks
+                    if len(chunk_inputs) > min_chunk_size:
+                        # split chunk in half and queue for retry
+                        mid = len(chunk_inputs) // 2
+                        failed_chunks.append((start_idx, chunk_inputs[:mid]))
+                        failed_chunks.append((start_idx + mid, chunk_inputs[mid:]))
+                    else:
+                        # can't split further, re-raise the error
+                        logger.error(f"Failed to get embeddings for chunk starting at {start_idx} even with minimum size {min_chunk_size}")
+                        raise result
+                else:
+                    embeddings = [r.embedding for r in result.data]
+                    for i, embedding in enumerate(embeddings):
+                        results[start_idx + i] = embedding
+
+            chunks_to_process = failed_chunks
+
+        return results
 
     @trace_method
     def handle_llm_error(self, e: Exception) -> Exception:

letta/orm/block.py

@@ -41,6 +41,7 @@ class Block(OrganizationMixin, SqlalchemyBase, ProjectMixin, TemplateEntityMixin
 
     # permissions of the agent
     read_only: Mapped[bool] = mapped_column(doc="whether the agent has read-only access to the block", default=False)
+    hidden: Mapped[Optional[bool]] = mapped_column(nullable=True, doc="If set to True, the block will be hidden.")
 
     # history pointers / locking mechanisms
     current_history_entry_id: Mapped[Optional[str]] = mapped_column(

letta/orm/group.py

@@ -24,6 +24,7 @@ class Group(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateMixin):
     min_message_buffer_length: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
     turns_counter: Mapped[Optional[int]] = mapped_column(nullable=True, doc="")
     last_processed_message_id: Mapped[Optional[str]] = mapped_column(nullable=True, doc="")
+    hidden: Mapped[Optional[bool]] = mapped_column(nullable=True, doc="If set to True, the group will be hidden.")
 
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="groups")

letta/orm/source.py

@@ -1,12 +1,13 @@
 from typing import TYPE_CHECKING, Optional
 
-from sqlalchemy import JSON, Index, UniqueConstraint
+from sqlalchemy import JSON, Enum, Index, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.orm.custom_columns import EmbeddingConfigColumn
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import VectorDBProvider
 from letta.schemas.source import Source as PydanticSource
 
 if TYPE_CHECKING:
@@ -30,3 +31,9 @@ class Source(SqlalchemyBase, OrganizationMixin):
     instructions: Mapped[str] = mapped_column(nullable=True, doc="instructions for how to use the source")
     embedding_config: Mapped[EmbeddingConfig] = mapped_column(EmbeddingConfigColumn, doc="Configuration settings for embedding.")
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="metadata for the source.")
+    vector_db_provider: Mapped[VectorDBProvider] = mapped_column(
+        Enum(VectorDBProvider),
+        nullable=False,
+        default=VectorDBProvider.NATIVE,
+        doc="The vector database provider used for this source's passages",
+    )

letta/orm/step_metrics.py

@@ -43,6 +43,16 @@ class StepMetrics(SqlalchemyBase, ProjectMixin, AgentMixin):
         nullable=True,
         doc="The unique identifier of the job",
     )
+    step_start_ns: Mapped[Optional[int]] = mapped_column(
+        BigInteger,
+        nullable=True,
+        doc="The timestamp of the start of the step in nanoseconds",
+    )
+    llm_request_start_ns: Mapped[Optional[int]] = mapped_column(
+        BigInteger,
+        nullable=True,
+        doc="The timestamp of the start of the LLM request in nanoseconds",
+    )
     llm_request_ns: Mapped[Optional[int]] = mapped_column(
         BigInteger,
         nullable=True,

letta/schemas/block.py

@@ -38,6 +38,10 @@ class BaseBlock(LettaBase, validate_assignment=True):
     # metadata
     description: Optional[str] = Field(None, description="Description of the block.")
     metadata: Optional[dict] = Field({}, description="Metadata of the block.")
+    hidden: Optional[bool] = Field(
+        None,
+        description="If set to True, the block will be hidden.",
+    )
 
     # def __len__(self):
     #     return len(self.value)

letta/schemas/enums.py

@@ -180,6 +180,7 @@ class VectorDBProvider(str, Enum):
 
     NATIVE = "native"
     TPUF = "tpuf"
+    PINECONE = "pinecone"
 
 
 class TagMatchMode(str, Enum):

letta/schemas/group.py

@@ -49,6 +49,10 @@ class Group(GroupBase):
         None,
         description="The desired minimum length of messages in the context window of the convo agent. This is a best effort, and may be off-by-one due to user/assistant interleaving.",
     )
+    hidden: Optional[bool] = Field(
+        None,
+        description="If set to True, the group will be hidden.",
+    )
 
     @property
     def manager_config(self) -> ManagerConfig:
@@ -170,6 +174,10 @@ class GroupCreate(BaseModel):
     manager_config: ManagerConfigUnion = Field(RoundRobinManager(), description="")
     project_id: Optional[str] = Field(None, description="The associated project id.")
     shared_block_ids: List[str] = Field([], description="")
+    hidden: Optional[bool] = Field(
+        None,
+        description="If set to True, the group will be hidden.",
+    )
 
 
 class InternalTemplateGroupCreate(GroupCreate):

letta/schemas/letta_message.py

@@ -265,7 +265,7 @@ class ApprovalRequestMessage(LettaMessage):
     message_type: Literal[MessageType.approval_request_message] = Field(
         default=MessageType.approval_request_message, description="The type of the message."
     )
-    tool_call: ToolCall = Field(..., description="The tool call that has been requested by the llm to run")
+    tool_call: Union[ToolCall, ToolCallDelta] = Field(..., description="The tool call that has been requested by the llm to run")
 
 
 class ApprovalResponseMessage(LettaMessage):

letta/schemas/letta_request.py

@@ -60,7 +60,7 @@ class LettaStreamingRequest(LettaRequest):
         description="Flag to determine if individual tokens should be streamed, rather than streaming per step.",
     )
     include_pings: bool = Field(
-        default=False,
+        default=True,
         description="Whether to include periodic keepalive ping messages in the stream to prevent connection timeouts.",
     )
     background: bool = Field(
@@ -94,7 +94,7 @@ class RetrieveStreamRequest(BaseModel):
         0, description="Sequence id to use as a cursor for pagination. Response will start streaming after this chunk sequence id"
     )
     include_pings: Optional[bool] = Field(
-        default=False,
+        default=True,
         description="Whether to include periodic keepalive ping messages in the stream to prevent connection timeouts.",
     )
     poll_interval: Optional[float] = Field(

letta/schemas/mcp.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from pydantic import Field
 
@@ -175,3 +175,11 @@ class MCPOAuthSessionUpdate(BaseMCPOAuth):
     client_secret: Optional[str] = Field(None, description="OAuth client secret")
     redirect_uri: Optional[str] = Field(None, description="OAuth redirect URI")
     status: Optional[OAuthSessionStatus] = Field(None, description="Session status")
+
+
+class MCPServerResyncResult(LettaBase):
+    """Result of resyncing MCP server tools."""
+
+    deleted: List[str] = Field(default_factory=list, description="List of deleted tool names")
+    updated: List[str] = Field(default_factory=list, description="List of updated tool names")
+    added: List[str] = Field(default_factory=list, description="List of added tool names")

letta/schemas/message.py

@@ -1187,3 +1187,26 @@ class ToolReturn(BaseModel):
     stdout: Optional[List[str]] = Field(default=None, description="Captured stdout (e.g. prints, logs) from the tool invocation")
     stderr: Optional[List[str]] = Field(default=None, description="Captured stderr from the tool invocation")
     # func_return: Optional[Any] = Field(None, description="The function return object")
+
+
+class MessageSearchRequest(BaseModel):
+    """Request model for searching messages across the organization"""
+
+    query: Optional[str] = Field(None, description="Text query for full-text search")
+    search_mode: Literal["vector", "fts", "hybrid"] = Field("hybrid", description="Search mode to use")
+    roles: Optional[List[MessageRole]] = Field(None, description="Filter messages by role")
+    project_id: Optional[str] = Field(None, description="Filter messages by project ID")
+    template_id: Optional[str] = Field(None, description="Filter messages by template ID")
+    limit: int = Field(50, description="Maximum number of results to return", ge=1, le=100)
+    start_date: Optional[datetime] = Field(None, description="Filter messages created after this date")
+    end_date: Optional[datetime] = Field(None, description="Filter messages created on or before this date")
+
+
+class MessageSearchResult(BaseModel):
+    """Result from a message search operation with scoring details."""
+
+    embedded_text: str = Field(..., description="The embedded content (LLM-friendly)")
+    message: Message = Field(..., description="The raw message object")
+    fts_rank: Optional[int] = Field(None, description="Full-text search rank position if FTS was used")
+    vector_rank: Optional[int] = Field(None, description="Vector search rank position if vector search was used")
+    rrf_score: float = Field(..., description="Reciprocal Rank Fusion combined score")

letta/schemas/providers/ollama.py

@@ -3,7 +3,7 @@ from typing import Literal
 import aiohttp
 from pydantic import Field
 
-from letta.constants import DEFAULT_EMBEDDING_CHUNK_SIZE, DEFAULT_CONTEXT_WINDOW, DEFAULT_EMBEDDING_DIM, OLLAMA_API_PREFIX
+from letta.constants import DEFAULT_CONTEXT_WINDOW, DEFAULT_EMBEDDING_CHUNK_SIZE, DEFAULT_EMBEDDING_DIM, OLLAMA_API_PREFIX
 from letta.log import get_logger
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.enums import ProviderCategory, ProviderType

letta/schemas/providers.py

@@ -777,7 +777,6 @@ class AnthropicProvider(Provider):
 
         configs = []
         for model in models:
-
             if model["type"] != "model":
                 continue
 
@@ -1069,7 +1068,7 @@ class GroqProvider(OpenAIProvider):
         response = openai_get_model_list(self.base_url, api_key=self.api_key)
         configs = []
         for model in response["data"]:
-            if not "context_window" in model:
+            if "context_window" not in model:
                 continue
             configs.append(
                 LLMConfig(

letta/schemas/source.py

@@ -3,7 +3,9 @@ from typing import Optional
 
 from pydantic import Field
 
+from letta.helpers.tpuf_client import should_use_tpuf
 from letta.schemas.embedding_config import EmbeddingConfig
+from letta.schemas.enums import VectorDBProvider
 from letta.schemas.letta_base import LettaBase
 
 
@@ -40,6 +42,10 @@ class Source(BaseSource):
     metadata: Optional[dict] = Field(None, validation_alias="metadata_", description="Metadata associated with the source.")
 
     # metadata fields
+    vector_db_provider: VectorDBProvider = Field(
+        default=VectorDBProvider.NATIVE,
+        description="The vector database provider used for this source's passages",
+    )
     created_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     created_at: Optional[datetime] = Field(None, description="The timestamp when the source was created.")

letta/schemas/step_metrics.py

@@ -15,6 +15,8 @@ class StepMetrics(StepMetricsBase):
     provider_id: Optional[str] = Field(None, description="The unique identifier of the provider.")
     job_id: Optional[str] = Field(None, description="The unique identifier of the job.")
     agent_id: Optional[str] = Field(None, description="The unique identifier of the agent.")
+    step_start_ns: Optional[int] = Field(None, description="The timestamp of the start of the step in nanoseconds.")
+    llm_request_start_ns: Optional[int] = Field(None, description="The timestamp of the start of the llm request in nanoseconds.")
     llm_request_ns: Optional[int] = Field(None, description="Time spent on LLM requests in nanoseconds.")
     tool_execution_ns: Optional[int] = Field(None, description="Time spent on tool execution in nanoseconds.")
     step_ns: Optional[int] = Field(None, description="Total time for the step in nanoseconds.")

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

@@ -5,6 +5,7 @@ from letta.server.rest_api.routers.v1.folders import router as folders_router
 from letta.server.rest_api.routers.v1.groups import router as groups_router
 from letta.server.rest_api.routers.v1.health import router as health_router
 from letta.server.rest_api.routers.v1.identities import router as identities_router
+from letta.server.rest_api.routers.v1.internal_templates import router as internal_templates_router
 from letta.server.rest_api.routers.v1.jobs import router as jobs_router
 from letta.server.rest_api.routers.v1.llms import router as llm_router
 from letta.server.rest_api.routers.v1.messages import router as messages_router
@@ -25,6 +26,7 @@ ROUTERS = [
     agents_router,
     groups_router,
     identities_router,
+    internal_templates_router,
     llm_router,
     blocks_router,
     jobs_router,