letta-nightly 0.11.7.dev20250909104137__py3-none-any.whl → 0.11.7.dev20250911104039__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:
@@ -98,15 +106,19 @@ class AnthropicStreamingInterface:
         try:
             tool_input = json.loads(self.accumulated_tool_call_args)
         except json.JSONDecodeError as e:
-            logger.warning(
-                f"Failed to decode tool call arguments for tool_call_id={self.tool_call_id}, "
-                f"name={self.tool_call_name}. Raw input: {self.accumulated_tool_call_args!r}. Error: {e}"
-            )
-            raise
+            # Attempt to use OptimisticJSONParser to handle incomplete/malformed JSON
+            try:
+                tool_input = self.json_parser.parse(self.accumulated_tool_call_args)
+            except:
+                logger.warning(
+                    f"Failed to decode tool call arguments for tool_call_id={self.tool_call_id}, "
+                    f"name={self.tool_call_name}. Raw input: {self.accumulated_tool_call_args!r}. Error: {e}"
+                )
+                raise e
         if "id" in tool_input and tool_input["id"].startswith("toolu_") and "function" in tool_input:
             arguments = str(json.dumps(tool_input["function"]["arguments"], indent=2))
         else:
-            arguments = self.accumulated_tool_call_args
+            arguments = str(json.dumps(tool_input, indent=2))
         return ToolCall(id=self.tool_call_id, function=FunctionCall(arguments=arguments, name=self.tool_call_name))
 
     def _check_inner_thoughts_complete(self, combined_args: str) -> bool:
@@ -218,11 +230,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 +269,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 +368,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 +411,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 +441,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/google_vertex_client.py

@@ -272,7 +272,7 @@ class GoogleVertexClient(LLMClientBase):
             tool_names = []
 
         contents = self.add_dummy_model_messages(
-            [m.to_google_ai_dict() for m in messages],
+            PydanticMessage.to_google_dicts_from_list(messages),
         )
 
         request_data = {

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/agent.py

@@ -34,7 +34,10 @@ if TYPE_CHECKING:
 class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin, TemplateMixin, AsyncAttrs):
     __tablename__ = "agents"
     __pydantic_model__ = PydanticAgentState
-    __table_args__ = (Index("ix_agents_created_at", "created_at", "id"),)
+    __table_args__ = (
+        Index("ix_agents_created_at", "created_at", "id"),
+        Index("ix_agents_organization_id", "organization_id"),
+    )
 
     # agent generates its own id
     # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase

letta/orm/block.py

@@ -24,6 +24,7 @@ class Block(OrganizationMixin, SqlalchemyBase, ProjectMixin, TemplateEntityMixin
     __table_args__ = (
         UniqueConstraint("id", "label", name="unique_block_id_label"),
         Index("created_at_label_idx", "created_at", "label"),
+        Index("ix_block_label", "label"),
     )
 
     template_name: Mapped[Optional[str]] = mapped_column(
@@ -41,6 +42,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/blocks_agents.py

@@ -20,6 +20,7 @@ class BlocksAgents(Base):
         UniqueConstraint("agent_id", "block_id", name="unique_agent_block"),
         Index("ix_blocks_agents_block_label_agent_id", "block_label", "agent_id"),
         Index("ix_blocks_block_label", "block_label"),
+        Index("ix_blocks_agents_block_id", "block_id"),
     )
 
     # unique agent + block label

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/sources_agents.py

@@ -1,4 +1,4 @@
-from sqlalchemy import ForeignKey, String
+from sqlalchemy import ForeignKey, Index, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.orm.base import Base
@@ -8,6 +8,7 @@ class SourcesAgents(Base):
     """Agents can have zero to many sources"""
 
     __tablename__ = "sources_agents"
+    __table_args__ = (Index("ix_sources_agents_source_id", "source_id"),)
 
     agent_id: Mapped[String] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=True)
     source_id: Mapped[String] = mapped_column(String, ForeignKey("sources.id", ondelete="CASCADE"), primary_key=True)

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/orm/tools_agents.py

@@ -1,4 +1,4 @@
-from sqlalchemy import ForeignKey, String, UniqueConstraint
+from sqlalchemy import ForeignKey, Index, String, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column
 
 from letta.orm import Base
@@ -8,7 +8,10 @@ class ToolsAgents(Base):
     """Agents can have one or many tools associated with them."""
 
     __tablename__ = "tools_agents"
-    __table_args__ = (UniqueConstraint("agent_id", "tool_id", name="unique_agent_tool"),)
+    __table_args__ = (
+        UniqueConstraint("agent_id", "tool_id", name="unique_agent_tool"),
+        Index("ix_tools_agents_tool_id", "tool_id"),
+    )
 
     # Each agent must have unique tool names
     agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=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")