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

letta/schemas/message.py

@@ -1027,10 +1027,13 @@ class Message(BaseMessage):
         result = [m for m in result if m is not None]
         return result
 
-    def to_google_ai_dict(self, put_inner_thoughts_in_kwargs: bool = True) -> dict:
+    def to_google_dict(self, put_inner_thoughts_in_kwargs: bool = True) -> dict | None:
         """
         Go from Message class to Google AI REST message object
         """
+        if self.role == "approval" and self.tool_calls is None:
+            return None
+
         # type Content: https://ai.google.dev/api/rest/v1/Content / https://ai.google.dev/api/rest/v1beta/Content
         #     parts[]: Part
         #     role: str ('user' or 'model')
@@ -1076,7 +1079,7 @@ class Message(BaseMessage):
                 "parts": content_parts,
             }
 
-        elif self.role == "assistant":
+        elif self.role == "assistant" or self.role == "approval":
             assert self.tool_calls is not None or text_content is not None
             google_ai_message = {
                 "role": "model",  # NOTE: different
@@ -1164,6 +1167,20 @@ class Message(BaseMessage):
 
         return google_ai_message
 
+    @staticmethod
+    def to_google_dicts_from_list(
+        messages: List[Message],
+        put_inner_thoughts_in_kwargs: bool = True,
+    ):
+        result = [
+            m.to_google_dict(
+                put_inner_thoughts_in_kwargs=put_inner_thoughts_in_kwargs,
+            )
+            for m in messages
+        ]
+        result = [m for m in result if m is not None]
+        return result
+
     @staticmethod
     def generate_otid_from_id(message_id: str, index: int) -> str:
         """
@@ -1187,3 +1204,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/interface.py

@@ -295,6 +295,25 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
         self.optimistic_json_parser = OptimisticJSONParser()
         self.current_json_parse_result = {}
 
+        # NOTE (fix): OpenAI deltas may split a key and its value across chunks
+        # (e.g. '"request_heartbeat"' in one chunk, ': true' in the next). The
+        # old behavior passed through each fragment verbatim, which could emit
+        # a bare key (or a key+opening quote) without its value, producing
+        # invalid JSON slices and the "missing end-quote" symptom downstream.
+        #
+        # To make streamed arguments robust, we add a JSON-aware incremental
+        # reader that only releases safe updates for the "main" JSON portion of
+        # the tool_call arguments. This prevents partial-key emissions while
+        # preserving incremental streaming for consumers.
+        #
+        # We still stream 'name' fragments as-is (safe), but 'arguments' are
+        # parsed incrementally and emitted only when a boundary is safe.
+        self._raw_args_reader = JSONInnerThoughtsExtractor(
+            inner_thoughts_key=inner_thoughts_kwarg,
+            wait_for_first_key=False,
+        )
+        self._raw_args_tool_call_id = None
+
         # Store metadata passed from server
         self.metadata = {}
 
@@ -654,11 +673,24 @@ class StreamingServerInterface(AgentChunkStreamingInterface):
                     tool_call_delta = {}
                     if tool_call.id:
                         tool_call_delta["id"] = tool_call.id
+                        # Reset raw args reader per tool_call id
+                        if self._raw_args_tool_call_id != tool_call.id:
+                            self._raw_args_tool_call_id = tool_call.id
+                            self._raw_args_reader = JSONInnerThoughtsExtractor(
+                                inner_thoughts_key=self.inner_thoughts_kwarg,
+                                wait_for_first_key=False,
+                            )
                     if tool_call.function:
-                        if tool_call.function.arguments:
-                            tool_call_delta["arguments"] = tool_call.function.arguments
+                        # Stream name fragments as-is (names are short and harmless to emit)
                         if tool_call.function.name:
                             tool_call_delta["name"] = tool_call.function.name
+                        # For arguments, incrementally parse to avoid emitting partial keys
+                        if tool_call.function.arguments:
+                            self.current_function_arguments += tool_call.function.arguments
+                            updates_main_json, _ = self._raw_args_reader.process_fragment(tool_call.function.arguments)
+                            # Only emit argument updates when a safe boundary is reached
+                            if updates_main_json:
+                                tool_call_delta["arguments"] = updates_main_json
 
                     # We might end up with a no-op, in which case we should omit
                     if (

letta/server/rest_api/json_parser.py

@@ -63,6 +63,8 @@ class OptimisticJSONParser(JSONParser):
             '"': self._parse_string,
             "t": self._parse_true,
             "f": self._parse_false,
+            "T": self._parse_true,
+            "F": self._parse_false,
             "n": self._parse_null,
         }
         # Register number parser for digits and signs

letta/server/rest_api/redis_stream_manager.py

@@ -8,6 +8,7 @@ from typing import AsyncIterator, Dict, List, Optional
 
 from letta.data_sources.redis_client import AsyncRedisClient
 from letta.log import get_logger
+from letta.utils import safe_create_task
 
 logger = get_logger(__name__)
 
@@ -62,7 +63,7 @@ class RedisSSEStreamWriter:
         """Start the background flush task."""
         if not self._running:
             self._running = True
-            self._flush_task = asyncio.create_task(self._periodic_flush())
+            self._flush_task = safe_create_task(self._periodic_flush(), label="redis_periodic_flush")
 
     async def stop(self):
         """Stop the background flush task and flush remaining data."""

letta/server/rest_api/routers/openai/chat_completions/chat_completions.py

@@ -14,6 +14,7 @@ from letta.server.rest_api.chat_completions_interface import ChatCompletionsStre
 
 # TODO this belongs in a controller!
 from letta.server.rest_api.utils import get_letta_server, get_user_message_from_chat_completions_request, sse_async_generator
+from letta.utils import safe_create_task
 
 if TYPE_CHECKING:
     from letta.server.server import SyncServer
@@ -98,7 +99,7 @@ async def send_message_to_agent_chat_completions(
 
         # Offload the synchronous message_func to a separate thread
         streaming_interface.stream_start()
-        asyncio.create_task(
+        safe_create_task(
             asyncio.to_thread(
                 server.send_messages,
                 actor=actor,
@@ -106,7 +107,8 @@ async def send_message_to_agent_chat_completions(
                 input_messages=messages,
                 interface=streaming_interface,
                 put_inner_thoughts_first=False,
-            )
+            ),
+            label="openai_send_messages",
         )
 
         # return a stream

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,