letta-nightly 0.8.8.dev20250703104323__py3-none-any.whl → 0.8.9.dev20250703191231__py3-none-any.whl

letta/functions/function_sets/multi_agent.py

@@ -1,5 +1,6 @@
 import asyncio
 import json
+import os
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import TYPE_CHECKING, List
 
@@ -7,6 +8,7 @@ from letta.functions.helpers import (
     _send_message_to_all_agents_in_group_async,
     execute_send_message_to_agent,
     extract_send_message_from_steps_messages,
+    fire_and_forget_send_to_agent,
 )
 from letta.schemas.enums import MessageRole
 from letta.schemas.message import MessageCreate
@@ -125,3 +127,35 @@ def send_message_to_all_agents_in_group(self: "Agent", message: str) -> List[str
     """
 
     return asyncio.run(_send_message_to_all_agents_in_group_async(self, message))
+
+
+def send_message_to_agent_async(self: "Agent", message: str, other_agent_id: str) -> str:
+    """
+    Sends a message to a specific Letta agent within the same organization. The sender's identity is automatically included, so no explicit introduction is required in the message. This function does not expect a response from the target agent, making it suitable for notifications or one-way communication.
+    Args:
+        message (str): The content of the message to be sent to the target agent.
+        other_agent_id (str): The unique identifier of the target Letta agent.
+    Returns:
+        str: A confirmation message indicating the message was successfully sent.
+    """
+    if os.getenv("LETTA_ENVIRONMENT") == "PRODUCTION":
+        raise RuntimeError("This tool is not allowed to be run on Letta Cloud.")
+
+    message = (
+        f"[Incoming message from agent with ID '{self.agent_state.id}' - to reply to this message, "
+        f"make sure to use the 'send_message_to_agent_async' tool, or the agent will not receive your message] "
+        f"{message}"
+    )
+    messages = [MessageCreate(role=MessageRole.system, content=message, name=self.agent_state.name)]
+
+    # Do the actual fire-and-forget
+    fire_and_forget_send_to_agent(
+        sender_agent=self,
+        messages=messages,
+        other_agent_id=other_agent_id,
+        log_prefix="[send_message_to_agent_async]",
+        use_retries=False,  # or True if you want to use _async_send_message_with_retries
+    )
+
+    # Immediately return to caller
+    return "Successfully sent message"

letta/functions/types.py

@@ -14,5 +14,5 @@ class FileOpenRequest(BaseModel):
         default=None, description="Optional starting line number (1-indexed). If not specified, starts from beginning of file."
     )
     length: Optional[int] = Field(
-        default=None, description="Optional number of lines to view from offset. If not specified, views to end of file."
+        default=None, description="Optional number of lines to view from offset (inclusive). If not specified, views to end of file."
     )

letta/groups/helpers.py

@@ -7,6 +7,7 @@ from letta.orm.group import Group
 from letta.orm.user import User
 from letta.schemas.agent import AgentState
 from letta.schemas.group import ManagerType
+from letta.schemas.letta_message_content import ImageContent, TextContent
 from letta.schemas.message import Message
 from letta.services.mcp.base_client import AsyncBaseMCPClient
 
@@ -89,11 +90,13 @@ def stringify_message(message: Message, use_assistant_name: bool = False) -> str
     assistant_name = message.name or "assistant" if use_assistant_name else "assistant"
     if message.role == "user":
         try:
-            content = json.loads(message.content[0].text)
-            if content["type"] == "user_message":
-                return f"{message.name or 'user'}: {content['message']}"
-            else:
-                return None
+            messages = []
+            for content in message.content:
+                if isinstance(content, TextContent):
+                    messages.append(f"{message.name or 'user'}: {content.text}")
+                elif isinstance(content, ImageContent):
+                    messages.append(f"{message.name or 'user'}: [Image Here]")
+            return "\n".join(messages)
         except:
             return f"{message.name or 'user'}: {message.content[0].text}"
     elif message.role == "assistant":

letta/groups/sleeptime_multi_agent_v2.py

@@ -1,6 +1,6 @@
 import asyncio
+from collections.abc import AsyncGenerator
 from datetime import datetime, timezone
-from typing import AsyncGenerator, List, Optional
 
 from letta.agents.base_agent import BaseAgent
 from letta.agents.letta_agent import LettaAgent
@@ -39,7 +39,8 @@ class SleeptimeMultiAgentV2(BaseAgent):
         actor: User,
         step_manager: StepManager = NoopStepManager(),
         telemetry_manager: TelemetryManager = NoopTelemetryManager(),
-        group: Optional[Group] = None,
+        group: Group | None = None,
+        current_run_id: str | None = None,
     ):
         super().__init__(
             agent_id=agent_id,
@@ -54,6 +55,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         self.job_manager = job_manager
         self.step_manager = step_manager
         self.telemetry_manager = telemetry_manager
+        self.current_run_id = current_run_id
         # Group settings
         assert group.manager_type == ManagerType.sleeptime, f"Expected group manager type to be 'sleeptime', got {group.manager_type}"
         self.group = group
@@ -61,12 +63,12 @@ class SleeptimeMultiAgentV2(BaseAgent):
     @trace_method
     async def step(
         self,
-        input_messages: List[MessageCreate],
+        input_messages: list[MessageCreate],
         max_steps: int = DEFAULT_MAX_STEPS,
-        run_id: Optional[str] = None,
+        run_id: str | None = None,
         use_assistant_message: bool = True,
-        request_start_timestamp_ns: Optional[int] = None,
-        include_return_message_types: Optional[List[MessageType]] = None,
+        request_start_timestamp_ns: int | None = None,
+        include_return_message_types: list[MessageType] | None = None,
     ) -> LettaResponse:
         run_ids = []
 
@@ -89,6 +91,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             actor=self.actor,
             step_manager=self.step_manager,
             telemetry_manager=self.telemetry_manager,
+            current_run_id=self.current_run_id,
         )
         # Perform foreground agent step
         response = await foreground_agent.step(
@@ -125,7 +128,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
 
                 except Exception as e:
                     # Individual task failures
-                    print(f"Agent processing failed: {str(e)}")
+                    print(f"Agent processing failed: {e!s}")
                     raise e
 
         response.usage.run_ids = run_ids
@@ -134,11 +137,11 @@ class SleeptimeMultiAgentV2(BaseAgent):
     @trace_method
     async def step_stream_no_tokens(
         self,
-        input_messages: List[MessageCreate],
+        input_messages: list[MessageCreate],
         max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
-        request_start_timestamp_ns: Optional[int] = None,
-        include_return_message_types: Optional[List[MessageType]] = None,
+        request_start_timestamp_ns: int | None = None,
+        include_return_message_types: list[MessageType] | None = None,
     ):
         response = await self.step(
             input_messages=input_messages,
@@ -157,11 +160,11 @@ class SleeptimeMultiAgentV2(BaseAgent):
     @trace_method
     async def step_stream(
         self,
-        input_messages: List[MessageCreate],
+        input_messages: list[MessageCreate],
         max_steps: int = DEFAULT_MAX_STEPS,
         use_assistant_message: bool = True,
-        request_start_timestamp_ns: Optional[int] = None,
-        include_return_message_types: Optional[List[MessageType]] = None,
+        request_start_timestamp_ns: int | None = None,
+        include_return_message_types: list[MessageType] | None = None,
     ) -> AsyncGenerator[str, None]:
         # Prepare new messages
         new_messages = []
@@ -182,6 +185,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
             actor=self.actor,
             step_manager=self.step_manager,
             telemetry_manager=self.telemetry_manager,
+            current_run_id=self.current_run_id,
         )
         # Perform foreground agent step
         async for chunk in foreground_agent.step_stream(
@@ -218,7 +222,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
     async def _issue_background_task(
         self,
         sleeptime_agent_id: str,
-        response_messages: List[Message],
+        response_messages: list[Message],
         last_processed_message_id: str,
         use_assistant_message: bool = True,
     ) -> str:
@@ -248,7 +252,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
         self,
         foreground_agent_id: str,
         sleeptime_agent_id: str,
-        response_messages: List[Message],
+        response_messages: list[Message],
         last_processed_message_id: str,
         run_id: str,
         use_assistant_message: bool = True,
@@ -296,6 +300,7 @@ class SleeptimeMultiAgentV2(BaseAgent):
                 actor=self.actor,
                 step_manager=self.step_manager,
                 telemetry_manager=self.telemetry_manager,
+                current_run_id=self.current_run_id,
                 message_buffer_limit=20,  # TODO: Make this configurable
                 message_buffer_min=8,  # TODO: Make this configurable
                 enable_summarization=False,  # TODO: Make this configurable

letta/interface.py

@@ -81,7 +81,7 @@ class CLIInterface(AgentInterface):
     @staticmethod
     def internal_monologue(msg: str, msg_obj: Optional[Message] = None, chunk_index: Optional[int] = None):
         # ANSI escape code for italic is '\x1B[3m'
-        fstr = f"\x1B[3m{Fore.LIGHTBLACK_EX}{INNER_THOUGHTS_CLI_SYMBOL} {{msg}}{Style.RESET_ALL}"
+        fstr = f"\x1b[3m{Fore.LIGHTBLACK_EX}{INNER_THOUGHTS_CLI_SYMBOL} {{msg}}{Style.RESET_ALL}"
         if STRIP_UI:
             fstr = "{msg}"
         print(fstr.format(msg=msg))

letta/interfaces/anthropic_streaming_interface.py

@@ -1,7 +1,9 @@
+import asyncio
 import json
+from collections.abc import AsyncGenerator
 from datetime import datetime, timezone
 from enum import Enum
-from typing import AsyncGenerator, List, Optional, Union
+from typing import Optional
 
 from anthropic import AsyncStream
 from anthropic.types.beta import (
@@ -131,14 +133,16 @@ class AnthropicStreamingInterface:
         self,
         stream: AsyncStream[BetaRawMessageStreamEvent],
         ttft_span: Optional["Span"] = None,
-        provider_request_start_timestamp_ns: Optional[int] = None,
-    ) -> AsyncGenerator[LettaMessage, 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
@@ -384,18 +388,21 @@ class AnthropicStreamingInterface:
                             self.tool_call_buffer = []
 
                         self.anthropic_mode = None
+        except asyncio.CancelledError as e:
+            logger.info("Cancelled stream %s", e)
+            yield LettaStopReason(stop_reason=StopReasonType.cancelled)
+            raise
         except Exception as e:
             logger.error("Error processing stream: %s", e)
-            stop_reason = LettaStopReason(stop_reason=StopReasonType.error.value)
-            yield stop_reason
+            yield LettaStopReason(stop_reason=StopReasonType.error)
             raise
         finally:
             logger.info("AnthropicStreamingInterface: Stream processing complete.")
 
-    def get_reasoning_content(self) -> List[Union[TextContent, ReasoningContent, RedactedReasoningContent]]:
+    def get_reasoning_content(self) -> list[TextContent | ReasoningContent | RedactedReasoningContent]:
         def _process_group(
-            group: List[Union[ReasoningMessage, HiddenReasoningMessage]], group_type: str
-        ) -> Union[TextContent, ReasoningContent, RedactedReasoningContent]:
+            group: list[ReasoningMessage | HiddenReasoningMessage], group_type: str
+        ) -> TextContent | ReasoningContent | RedactedReasoningContent:
             if group_type == "reasoning":
                 reasoning_text = "".join(chunk.reasoning for chunk in group).strip()
                 is_native = any(chunk.source == "reasoner_model" for chunk in group)

letta/interfaces/openai_chat_completions_streaming_interface.py

@@ -1,4 +1,5 @@
-from typing import Any, AsyncGenerator, Dict, List, Optional
+from collections.abc import AsyncGenerator
+from typing import Any
 
 from openai import AsyncStream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk, Choice, ChoiceDelta
@@ -19,14 +20,14 @@ class OpenAIChatCompletionsStreamingInterface:
         self.optimistic_json_parser: OptimisticJSONParser = OptimisticJSONParser()
         self.stream_pre_execution_message: bool = stream_pre_execution_message
 
-        self.current_parsed_json_result: Dict[str, Any] = {}
-        self.content_buffer: List[str] = []
+        self.current_parsed_json_result: dict[str, Any] = {}
+        self.content_buffer: list[str] = []
         self.tool_call_happened: bool = False
         self.finish_reason_stop: bool = False
 
-        self.tool_call_name: Optional[str] = None
+        self.tool_call_name: str | None = None
         self.tool_call_args_str: str = ""
-        self.tool_call_id: Optional[str] = None
+        self.tool_call_id: str | None = None
 
     async def process(self, stream: AsyncStream[ChatCompletionChunk]) -> AsyncGenerator[str, None]:
         """
@@ -35,6 +36,8 @@ class OpenAIChatCompletionsStreamingInterface:
         """
         async with stream:
             async for chunk in stream:
+                # TODO (cliandy): reconsider in stream cancellations
+                # await cancellation_token.check_and_raise_if_cancelled()
                 if chunk.choices:
                     choice = chunk.choices[0]
                     delta = choice.delta
@@ -103,7 +106,7 @@ class OpenAIChatCompletionsStreamingInterface:
                 )
             )
 
-    def _handle_finish_reason(self, finish_reason: Optional[str]) -> bool:
+    def _handle_finish_reason(self, finish_reason: str | None) -> bool:
         """Handles the finish reason and determines if streaming should stop."""
         if finish_reason == "tool_calls":
             self.tool_call_happened = True

letta/interfaces/openai_streaming_interface.py

@@ -1,5 +1,7 @@
+import asyncio
+from collections.abc import AsyncGenerator
 from datetime import datetime, timezone
-from typing import AsyncGenerator, List, Optional
+from typing import Optional
 
 from openai import AsyncStream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
@@ -55,12 +57,12 @@ class OpenAIStreamingInterface:
         self.input_tokens = 0
         self.output_tokens = 0
 
-        self.content_buffer: List[str] = []
-        self.tool_call_name: Optional[str] = None
-        self.tool_call_id: Optional[str] = None
+        self.content_buffer: list[str] = []
+        self.tool_call_name: str | None = None
+        self.tool_call_id: str | None = None
         self.reasoning_messages = []
 
-    def get_reasoning_content(self) -> List[TextContent]:
+    def get_reasoning_content(self) -> list[TextContent | OmittedReasoningContent]:
         content = "".join(self.reasoning_messages).strip()
 
         # Right now we assume that all models omit reasoning content for OAI,
@@ -87,8 +89,8 @@ class OpenAIStreamingInterface:
         self,
         stream: AsyncStream[ChatCompletionChunk],
         ttft_span: Optional["Span"] = None,
-        provider_request_start_timestamp_ns: Optional[int] = None,
-    ) -> AsyncGenerator[LettaMessage, None]:
+        provider_request_start_timestamp_ns: int | None = None,
+    ) -> AsyncGenerator[LettaMessage | LettaStopReason, None]:
         """
         Iterates over the OpenAI stream, yielding SSE events.
         It also collects tokens and detects if a tool call is triggered.
@@ -99,6 +101,8 @@ class OpenAIStreamingInterface:
                 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
@@ -224,8 +228,7 @@ class OpenAIStreamingInterface:
                                     # If there was nothing in the name buffer, we can proceed to
                                     # output the arguments chunk as a ToolCallMessage
                                     else:
-
-                                        # use_assisitant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
+                                        # use_assistant_message means that we should also not release main_json raw, and instead should only release the contents of "message": "..."
                                         if self.use_assistant_message and (
                                             self.last_flushed_function_name is not None
                                             and self.last_flushed_function_name == self.assistant_message_tool_name
@@ -349,10 +352,13 @@ class OpenAIStreamingInterface:
                                                 prev_message_type = tool_call_msg.message_type
                                                 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
         except Exception as e:
             logger.error("Error processing stream: %s", e)
-            stop_reason = LettaStopReason(stop_reason=StopReasonType.error.value)
-            yield stop_reason
+            yield LettaStopReason(stop_reason=StopReasonType.error)
             raise
         finally:
             logger.info("OpenAIStreamingInterface: Stream processing complete.")

letta/llm_api/openai_client.py

@@ -261,6 +261,7 @@ class OpenAIClient(LLMClientBase):
         """
         kwargs = await self._prepare_client_kwargs_async(llm_config)
         client = AsyncOpenAI(**kwargs)
+
         response: ChatCompletion = await client.chat.completions.create(**request_data)
         return response.model_dump()
 
@@ -304,7 +305,7 @@ class OpenAIClient(LLMClientBase):
         return response_stream
 
     @trace_method
-    async def request_embeddings(self, inputs: List[str], embedding_config: EmbeddingConfig) -> List[dict]:
+    async def request_embeddings(self, inputs: List[str], embedding_config: EmbeddingConfig) -> List[List[float]]:
         """Request embeddings given texts and embedding config"""
         kwargs = self._prepare_client_kwargs_embedding(embedding_config)
         client = AsyncOpenAI(**kwargs)

letta/orm/agent.py

@@ -245,6 +245,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, AsyncAttrs):
         Returns:
             PydanticAgentState: The Pydantic representation of the agent.
         """
+
         # Base fields: always included
         state = {
             "id": self.id,

letta/orm/file.py

@@ -49,6 +49,7 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin, AsyncAttrs):
     )
 
     file_name: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The name of the file.")
+    original_file_name: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The original name of the file as uploaded.")
     file_path: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The file path on the system.")
     file_type: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The type of the file.")
     file_size: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, doc="The size of the file in bytes.")
@@ -81,7 +82,7 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin, AsyncAttrs):
         cascade="all, delete-orphan",
     )
 
-    async def to_pydantic_async(self, include_content: bool = False) -> PydanticFileMetadata:
+    async def to_pydantic_async(self, include_content: bool = False, strip_directory_prefix: bool = False) -> PydanticFileMetadata:
         """
         Async version of `to_pydantic` that supports optional relationship loading
         without requiring `expire_on_commit=False`.
@@ -94,11 +95,16 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin, AsyncAttrs):
         else:
             content_text = None
 
+        file_name = self.file_name
+        if strip_directory_prefix and "/" in file_name:
+            file_name = "/".join(file_name.split("/")[1:])
+
         return PydanticFileMetadata(
             id=self.id,
             organization_id=self.organization_id,
             source_id=self.source_id,
-            file_name=self.file_name,
+            file_name=file_name,
+            original_file_name=self.original_file_name,
             file_path=self.file_path,
             file_type=self.file_type,
             file_size=self.file_size,

letta/orm/files_agents.py

@@ -19,25 +19,48 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
     """
     Join table between File and Agent.
 
-    Tracks whether a file is currently “open” for the agent and
+    Tracks whether a file is currently "open" for the agent and
     the specific excerpt (grepped section) the agent is looking at.
     """
 
     __tablename__ = "files_agents"
     __table_args__ = (
-        Index("ix_files_agents_file_id_agent_id", "file_id", "agent_id"),
-        UniqueConstraint("file_id", "agent_id", name="uq_files_agents_file_agent"),
-        UniqueConstraint("agent_id", "file_name", name="uq_files_agents_agent_file_name"),
-        Index("ix_files_agents_agent_file_name", "agent_id", "file_name"),
+        # (file_id, agent_id) must be unique
+        UniqueConstraint("file_id", "agent_id", name="uq_file_agent"),
+        # (file_name, agent_id) must be unique
+        UniqueConstraint("agent_id", "file_name", name="uq_agent_filename"),
+        # helpful indexes for look-ups
+        Index("ix_file_agent", "file_id", "agent_id"),
+        Index("ix_agent_filename", "agent_id", "file_name"),
     )
     __pydantic_model__ = PydanticFileAgent
 
-    # TODO: We want to migrate all the ORM models to do this, so we will need to move this to the SqlalchemyBase
-    # TODO: Some still rely on the Pydantic object to do this
-    id: Mapped[str] = mapped_column(String, primary_key=True, default=lambda: f"file_agent-{uuid.uuid4()}")
-    file_id: Mapped[str] = mapped_column(String, ForeignKey("files.id", ondelete="CASCADE"), primary_key=True, doc="ID of the file.")
-    file_name: Mapped[str] = mapped_column(String, nullable=False, doc="Denormalized copy of files.file_name; unique per agent.")
-    agent_id: Mapped[str] = mapped_column(String, ForeignKey("agents.id", ondelete="CASCADE"), primary_key=True, doc="ID of the agent.")
+    # single-column surrogate PK
+    id: Mapped[str] = mapped_column(
+        String,
+        primary_key=True,
+        default=lambda: f"file_agent-{uuid.uuid4()}",
+    )
+
+    # not part of the PK, but NOT NULL + FK
+    file_id: Mapped[str] = mapped_column(
+        String,
+        ForeignKey("files.id", ondelete="CASCADE"),
+        nullable=False,
+        doc="ID of the file",
+    )
+    agent_id: Mapped[str] = mapped_column(
+        String,
+        ForeignKey("agents.id", ondelete="CASCADE"),
+        nullable=False,
+        doc="ID of the agent",
+    )
+
+    file_name: Mapped[str] = mapped_column(
+        String,
+        nullable=False,
+        doc="Denormalized copy of files.file_name; unique per agent",
+    )
 
     is_open: Mapped[bool] = mapped_column(Boolean, nullable=False, default=True, doc="True if the agent currently has the file open.")
     visible_content: Mapped[Optional[str]] = mapped_column(Text, nullable=True, doc="Portion of the file the agent is focused on.")
@@ -78,4 +101,6 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
             value=visible_content,
             label=self.file.file_name,
             read_only=True,
+            metadata={"source_id": self.file.source_id},
+            limit=CORE_MEMORY_SOURCE_CHAR_LIMIT,
         )

letta/orm/mcp_server.py

@@ -39,6 +39,9 @@ class MCPServer(SqlalchemyBase, OrganizationMixin):
     # access token / api key for MCP servers that require authentication
     token: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="The access token or api key for the MCP server")
 
+    # custom headers for authentication (key-value pairs)
+    custom_headers: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="Custom authentication headers as key-value pairs")
+
     # stdio server
     stdio_config: Mapped[Optional[StdioServerConfig]] = mapped_column(
         MCPStdioServerConfigColumn, nullable=True, doc="The configuration for the stdio server"

letta/orm/source.py

@@ -1,6 +1,6 @@
 from typing import TYPE_CHECKING, List, Optional
 
-from sqlalchemy import JSON, Index
+from sqlalchemy import JSON, Index, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm import FileMetadata
@@ -25,6 +25,7 @@ class Source(SqlalchemyBase, OrganizationMixin):
 
     __table_args__ = (
         Index(f"source_created_at_id_idx", "created_at", "id"),
+        UniqueConstraint("name", "organization_id", name="uq_source_name_organization"),
         {"extend_existing": True},
     )
 

letta/orm/step.py

@@ -51,6 +51,9 @@ class Step(SqlalchemyBase):
     feedback: Mapped[Optional[str]] = mapped_column(
         None, nullable=True, doc="The feedback for this step. Must be either 'positive' or 'negative'."
     )
+    project_id: Mapped[Optional[str]] = mapped_column(
+        None, nullable=True, doc="The project that the agent that executed this step belongs to (cloud only)."
+    )
 
     # Relationships (foreign keys)
     organization: Mapped[Optional["Organization"]] = relationship("Organization")

letta/prompts/system/memgpt_v2_chat.txt

@@ -43,14 +43,11 @@ Recall memory (conversation history):
 Even though you can only see recent messages in your immediate context, you can search over your entire message history from a database.
 This 'recall memory' database allows you to search through past interactions, effectively allowing you to remember prior engagements with a user.
 
-Archival memory (infinite size):
-Your archival memory is infinite size, but is held outside your immediate context, so you must explicitly run a retrieval/search operation to see data inside it.
-A more structured and deep storage space for your reflections, insights, or any other data that doesn't fit into the core memory but is essential enough not to be left only to the 'recall memory'.
-
-Data sources:
-You may be given access to external sources of data, relevant to the user's interaction. For example, code, style guides, and documentation relevant
-to the current interaction with the user. Your core memory will contain information about the contents of these data sources. You will have access
-to functions to open and close the files as a filesystem and maintain only the files that are relevant to the user's interaction.
+Directories and Files:
+You may be given access to a structured file system that mirrors real-world directories and files. Each directory may contain one or more files.
+Files can include metadata (e.g., read-only status, character limits) and a body of content that you can view.
+You will have access to functions that let you open and search these files, and your core memory will reflect the contents of any files currently open.
+Maintain only those files relevant to the user’s current interaction.
 
 
 Base instructions finished.