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

letta/schemas/agent.py

@@ -4,12 +4,7 @@ from typing import Dict, List, Optional
 
 from pydantic import BaseModel, Field, field_validator, model_validator
 
-from letta.constants import (
-    CORE_MEMORY_LINE_NUMBER_WARNING,
-    DEFAULT_EMBEDDING_CHUNK_SIZE,
-    FILE_MEMORY_EMPTY_MESSAGE,
-    FILE_MEMORY_EXISTS_MESSAGE,
-)
+from letta.constants import CORE_MEMORY_LINE_NUMBER_WARNING, DEFAULT_EMBEDDING_CHUNK_SIZE
 from letta.schemas.block import CreateBlock
 from letta.schemas.embedding_config import EmbeddingConfig
 from letta.schemas.environment_variables import AgentEnvironmentVariable
@@ -319,8 +314,19 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
     # However, they still allow files to be injected into the context
     if agent_type == AgentType.react_agent or agent_type == AgentType.workflow_agent:
         return (
-            f"<files>\n{{% if file_blocks %}}{FILE_MEMORY_EXISTS_MESSAGE}\n{{% else %}}{FILE_MEMORY_EMPTY_MESSAGE}{{% endif %}}"
+            "{% if sources %}"
+            "<directories>\n"
+            "{% for source in sources %}"
+            f'<directory name="{{{{ source.name }}}}">\n'
+            "{% if source.description %}"
+            "<description>{{ source.description }}</description>\n"
+            "{% endif %}"
+            "{% if source.instructions %}"
+            "<instructions>{{ source.instructions }}</instructions>\n"
+            "{% endif %}"
+            "{% if file_blocks %}"
             "{% for block in file_blocks %}"
+            "{% if block.metadata and block.metadata.get('source_id') == source.id %}"
             f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
             "<{{ block.label }}>\n"
             "<description>\n"
@@ -334,11 +340,14 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "<value>\n"
             "{{ block.value }}\n"
             "</value>\n"
-            "</{{ block.label }}>\n"
             "</file>\n"
-            "{% if not loop.last %}\n{% endif %}"
+            "{% endif %}"
+            "{% endfor %}"
+            "{% endif %}"
+            "</directory>\n"
             "{% endfor %}"
-            "\n</files>"
+            "</directories>"
+            "{% endif %}"
         )
 
     # Sleeptime agents use the MemGPT v2 memory tools (line numbers)
@@ -372,10 +381,20 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{{ tool_usage_rules.value }}\n"
             "</tool_usage_rules>"
             "{% endif %}"
-            f"\n\n<files>\n{{% if file_blocks %}}{FILE_MEMORY_EXISTS_MESSAGE}\n{{% else %}}{FILE_MEMORY_EMPTY_MESSAGE}{{% endif %}}"
+            "\n\n{% if sources %}"
+            "<directories>\n"
+            "{% for source in sources %}"
+            f'<directory name="{{{{ source.name }}}}">\n'
+            "{% if source.description %}"
+            "<description>{{ source.description }}</description>\n"
+            "{% endif %}"
+            "{% if source.instructions %}"
+            "<instructions>{{ source.instructions }}</instructions>\n"
+            "{% endif %}"
+            "{% if file_blocks %}"
             "{% for block in file_blocks %}"
-            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
-            "<{{ block.label }}>\n"
+            "{% if block.metadata and block.metadata.get('source_id') == source.id %}"
+            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\" name=\"{{{{ block.label }}}}\">\n"
             "{% if block.description %}"
             "<description>\n"
             "{{ block.description }}\n"
@@ -391,14 +410,17 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{{ block.value }}\n"
             "</value>\n"
             "{% endif %}"
-            "</{{ block.label }}>\n"
             "</file>\n"
-            "{% if not loop.last %}\n{% endif %}"
+            "{% endif %}"
+            "{% endfor %}"
+            "{% endif %}"
+            "</directory>\n"
             "{% endfor %}"
-            "\n</files>"
+            "</directories>"
+            "{% endif %}"
         )
 
-    # Default setup (MemGPT), no line numbers
+    # All other agent types use memory blocks
     else:
         return (
             "<memory_blocks>\nThe following memory blocks are currently engaged in your core memory unit:\n\n"
@@ -425,10 +447,20 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{{ tool_usage_rules.value }}\n"
             "</tool_usage_rules>"
             "{% endif %}"
-            f"\n\n<files>\n{{% if file_blocks %}}{FILE_MEMORY_EXISTS_MESSAGE}\n{{% else %}}{FILE_MEMORY_EMPTY_MESSAGE}{{% endif %}}"
+            "\n\n{% if sources %}"
+            "<directories>\n"
+            "{% for source in sources %}"
+            f'<directory name="{{{{ source.name }}}}">\n'
+            "{% if source.description %}"
+            "<description>{{ source.description }}</description>\n"
+            "{% endif %}"
+            "{% if source.instructions %}"
+            "<instructions>{{ source.instructions }}</instructions>\n"
+            "{% endif %}"
+            "{% if file_blocks %}"
             "{% for block in file_blocks %}"
-            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\">\n"
-            "<{{ block.label }}>\n"
+            "{% if block.metadata and block.metadata.get('source_id') == source.id %}"
+            f"<file status=\"{{{{ '{FileStatus.open.value}' if block.value else '{FileStatus.closed.value}' }}}}\" name=\"{{{{ block.label }}}}\">\n"
             "{% if block.description %}"
             "<description>\n"
             "{{ block.description }}\n"
@@ -444,9 +476,12 @@ def get_prompt_template_for_agent_type(agent_type: Optional[AgentType] = None):
             "{{ block.value }}\n"
             "</value>\n"
             "{% endif %}"
-            "</{{ block.label }}>\n"
             "</file>\n"
-            "{% if not loop.last %}\n{% endif %}"
+            "{% endif %}"
             "{% endfor %}"
-            "\n</files>"
+            "{% endif %}"
+            "</directory>\n"
+            "{% endfor %}"
+            "</directories>"
+            "{% endif %}"
         )

letta/schemas/embedding_config.py

@@ -46,6 +46,7 @@ class EmbeddingConfig(BaseModel):
     embedding_dim: int = Field(..., description="The dimension of the embedding.")
     embedding_chunk_size: Optional[int] = Field(300, description="The chunk size of the embedding.")
     handle: Optional[str] = Field(None, description="The handle for this config, in the format provider/model-name.")
+    batch_size: int = Field(32, description="The maximum batch size for processing embeddings.")
 
     # azure only
     azure_endpoint: Optional[str] = Field(None, description="The Azure endpoint for the model.")
@@ -55,7 +56,7 @@ class EmbeddingConfig(BaseModel):
     @classmethod
     def default_config(cls, model_name: Optional[str] = None, provider: Optional[str] = None):
 
-        if model_name == "text-embedding-ada-002" or (not model_name and provider == "openai"):
+        if model_name == "text-embedding-ada-002" and provider == "openai":
             return cls(
                 embedding_model="text-embedding-ada-002",
                 embedding_endpoint_type="openai",
@@ -63,7 +64,7 @@ class EmbeddingConfig(BaseModel):
                 embedding_dim=1536,
                 embedding_chunk_size=300,
             )
-        if model_name == "text-embedding-3-small" and provider == "openai":
+        if (model_name == "text-embedding-3-small" and provider == "openai") or (not model_name and provider == "openai"):
             return cls(
                 embedding_model="text-embedding-3-small",
                 embedding_endpoint_type="openai",

letta/schemas/enums.py

@@ -54,6 +54,10 @@ class JobStatus(str, Enum):
     cancelled = "cancelled"
     expired = "expired"
 
+    @property
+    def is_terminal(self):
+        return self in (JobStatus.completed, JobStatus.failed, JobStatus.cancelled, JobStatus.expired)
+
 
 class AgentStepStatus(str, Enum):
     """

letta/schemas/file.py

@@ -30,6 +30,7 @@ class FileMetadata(FileMetadataBase):
     organization_id: Optional[str] = Field(None, description="The unique identifier of the organization associated with the document.")
     source_id: str = Field(..., description="The unique identifier of the source associated with the document.")
     file_name: Optional[str] = Field(None, description="The name of the file.")
+    original_file_name: Optional[str] = Field(None, description="The original name of the file as uploaded.")
     file_path: Optional[str] = Field(None, description="The path to the file.")
     file_type: Optional[str] = Field(None, description="The type of the file (MIME type).")
     file_size: Optional[int] = Field(None, description="The size of the file in bytes.")

letta/schemas/letta_stop_reason.py

@@ -3,6 +3,8 @@ from typing import Literal
 
 from pydantic import BaseModel, Field
 
+from letta.schemas.enums import JobStatus
+
 
 class StopReasonType(str, Enum):
     end_turn = "end_turn"
@@ -11,6 +13,22 @@ class StopReasonType(str, Enum):
     max_steps = "max_steps"
     no_tool_call = "no_tool_call"
     tool_rule = "tool_rule"
+    cancelled = "cancelled"
+
+    @property
+    def run_status(self) -> JobStatus:
+        if self in (
+            StopReasonType.end_turn,
+            StopReasonType.max_steps,
+            StopReasonType.tool_rule,
+        ):
+            return JobStatus.completed
+        elif self in (StopReasonType.error, StopReasonType.invalid_tool_call, StopReasonType.no_tool_call):
+            return JobStatus.failed
+        elif self == StopReasonType.cancelled:
+            return JobStatus.cancelled
+        else:
+            raise ValueError("Unknown StopReasonType")
 
 
 class LettaStopReason(BaseModel):

letta/schemas/mcp.py

@@ -19,12 +19,13 @@ class BaseMCPServer(LettaBase):
 
 class MCPServer(BaseMCPServer):
     id: str = BaseMCPServer.generate_id_field()
-    server_type: MCPServerType = MCPServerType.SSE
+    server_type: MCPServerType = MCPServerType.STREAMABLE_HTTP
     server_name: str = Field(..., description="The name of the server")
 
-    # sse config
-    server_url: Optional[str] = Field(None, description="The URL of the server (MCP SSE client will connect to this URL)")
-    token: Optional[str] = Field(None, description="The access token or API key for the MCP server (used for SSE authentication)")
+    # sse / streamable http config
+    server_url: Optional[str] = Field(None, description="The URL of the server (MCP SSE/Streamable HTTP client will connect to this URL)")
+    token: Optional[str] = Field(None, description="The access token or API key for the MCP server (used for authentication)")
+    custom_headers: Optional[Dict[str, str]] = Field(None, description="Custom authentication headers as key-value pairs")
 
     # stdio config
     stdio_config: Optional[StdioServerConfig] = Field(
@@ -43,9 +44,9 @@ class MCPServer(BaseMCPServer):
             return SSEServerConfig(
                 server_name=self.server_name,
                 server_url=self.server_url,
-                auth_header=MCP_AUTH_HEADER_AUTHORIZATION if self.token else None,
-                auth_token=f"{MCP_AUTH_TOKEN_BEARER_PREFIX} {self.token}" if self.token else None,
-                custom_headers=None,
+                auth_header=MCP_AUTH_HEADER_AUTHORIZATION if self.token and not self.custom_headers else None,
+                auth_token=f"{MCP_AUTH_TOKEN_BEARER_PREFIX} {self.token}" if self.token and not self.custom_headers else None,
+                custom_headers=self.custom_headers,
             )
         elif self.server_type == MCPServerType.STDIO:
             if self.stdio_config is None:
@@ -57,9 +58,9 @@ class MCPServer(BaseMCPServer):
             return StreamableHTTPServerConfig(
                 server_name=self.server_name,
                 server_url=self.server_url,
-                auth_header=MCP_AUTH_HEADER_AUTHORIZATION if self.token else None,
-                auth_token=f"{MCP_AUTH_TOKEN_BEARER_PREFIX} {self.token}" if self.token else None,
-                custom_headers=None,
+                auth_header=MCP_AUTH_HEADER_AUTHORIZATION if self.token and not self.custom_headers else None,
+                auth_token=f"{MCP_AUTH_TOKEN_BEARER_PREFIX} {self.token}" if self.token and not self.custom_headers else None,
+                custom_headers=self.custom_headers,
             )
         else:
             raise ValueError(f"Unsupported server type: {self.server_type}")
@@ -70,6 +71,7 @@ class RegisterSSEMCPServer(LettaBase):
     server_type: MCPServerType = MCPServerType.SSE
     server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
     token: Optional[str] = Field(None, description="The access token or API key for the MCP server used for authentication")
+    custom_headers: Optional[Dict[str, str]] = Field(None, description="Custom authentication headers as key-value pairs")
 
 
 class RegisterStdioMCPServer(LettaBase):
@@ -84,6 +86,7 @@ class RegisterStreamableHTTPMCPServer(LettaBase):
     server_url: str = Field(..., description="The URL path for the streamable HTTP server (e.g., 'example/mcp')")
     auth_header: Optional[str] = Field(None, description="The name of the authentication header (e.g., 'Authorization')")
     auth_token: Optional[str] = Field(None, description="The authentication token or API key value")
+    custom_headers: Optional[Dict[str, str]] = Field(None, description="Custom authentication headers as key-value pairs")
 
 
 class UpdateSSEMCPServer(LettaBase):
@@ -92,6 +95,7 @@ class UpdateSSEMCPServer(LettaBase):
     server_name: Optional[str] = Field(None, description="The name of the server")
     server_url: Optional[str] = Field(None, description="The URL of the server (MCP SSE client will connect to this URL)")
     token: Optional[str] = Field(None, description="The access token or API key for the MCP server (used for SSE authentication)")
+    custom_headers: Optional[Dict[str, str]] = Field(None, description="Custom authentication headers as key-value pairs")
 
 
 class UpdateStdioMCPServer(LettaBase):
@@ -110,6 +114,7 @@ class UpdateStreamableHTTPMCPServer(LettaBase):
     server_url: Optional[str] = Field(None, description="The URL path for the streamable HTTP server (e.g., 'example/mcp')")
     auth_header: Optional[str] = Field(None, description="The name of the authentication header (e.g., 'Authorization')")
     auth_token: Optional[str] = Field(None, description="The authentication token or API key value")
+    custom_headers: Optional[Dict[str, str]] = Field(None, description="Custom authentication headers as key-value pairs")
 
 
 UpdateMCPServer = Union[UpdateSSEMCPServer, UpdateStdioMCPServer, UpdateStreamableHTTPMCPServer]

letta/schemas/memory.py

@@ -1,7 +1,8 @@
+import logging
 from typing import TYPE_CHECKING, List, Optional
 
 from jinja2 import Template, TemplateSyntaxError
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 # Forward referencing to avoid circular import with Agent -> Memory -> Agent
 if TYPE_CHECKING:
@@ -69,6 +70,30 @@ class Memory(BaseModel, validate_assignment=True):
         default_factory=list, description="Blocks representing the agent's in-context memory of an attached file"
     )
 
+    @field_validator("file_blocks")
+    @classmethod
+    def validate_file_blocks_no_duplicates(cls, v: List[Block]) -> List[Block]:
+        """Validate that file_blocks don't contain duplicate labels, log warnings and remove duplicates."""
+        if not v:
+            return v
+
+        seen_labels = set()
+        unique_blocks = []
+        duplicate_labels = []
+
+        for block in v:
+            if block.label in seen_labels:
+                duplicate_labels.append(block.label)
+            else:
+                seen_labels.add(block.label)
+                unique_blocks.append(block)
+
+        if duplicate_labels:
+            logger = logging.getLogger(__name__)
+            logger.warning(f"Duplicate block labels found in file_blocks: {duplicate_labels}. Removing duplicates.")
+
+        return unique_blocks
+
     # Memory.template is a Jinja2 template for compiling memory module into a prompt string.
     prompt_template: str = Field(
         default="{% for block in blocks %}"
@@ -99,7 +124,7 @@ class Memory(BaseModel, validate_assignment=True):
             Template(prompt_template)
 
             # Validate compatibility with current memory structure
-            Template(prompt_template).render(blocks=self.blocks, file_blocks=self.file_blocks)
+            Template(prompt_template).render(blocks=self.blocks, file_blocks=self.file_blocks, sources=[])
 
             # If we get here, the template is valid and compatible
             self.prompt_template = prompt_template
@@ -108,10 +133,15 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
-    def compile(self, tool_usage_rules=None) -> str:
+    def compile(self, tool_usage_rules=None, sources=None) -> str:
         """Generate a string representation of the memory in-context using the Jinja2 template"""
-        template = Template(self.prompt_template)
-        return template.render(blocks=self.blocks, file_blocks=self.file_blocks, tool_usage_rules=tool_usage_rules)
+        try:
+            template = Template(self.prompt_template)
+            return template.render(blocks=self.blocks, file_blocks=self.file_blocks, tool_usage_rules=tool_usage_rules, sources=sources)
+        except TemplateSyntaxError as e:
+            raise ValueError(f"Invalid Jinja2 template syntax: {str(e)}")
+        except Exception as e:
+            raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
     def list_block_labels(self) -> List[str]:
         """Return a list of the block names held inside the memory object"""

letta/schemas/providers.py

@@ -181,6 +181,7 @@ class LettaProvider(Provider):
                 embedding_dim=1024,
                 embedding_chunk_size=300,
                 handle=self.get_handle("letta-free", is_embedding=True),
+                batch_size=32,
             )
         ]
 
@@ -301,6 +302,7 @@ class OpenAIProvider(Provider):
             if self.base_url == "https://api.openai.com/v1":
                 allowed_types = ["gpt-4", "o1", "o3", "o4"]
                 # NOTE: o1-mini and o1-preview do not support tool calling
+                # NOTE: o1-mini does not support system messages
                 # NOTE: o1-pro is only available in Responses API
                 disallowed_types = ["transcribe", "search", "realtime", "tts", "audio", "computer", "o1-mini", "o1-preview", "o1-pro"]
                 skip = True
@@ -352,6 +354,7 @@ class OpenAIProvider(Provider):
                     embedding_dim=1536,
                     embedding_chunk_size=300,
                     handle=self.get_handle("text-embedding-ada-002", is_embedding=True),
+                    batch_size=1024,
                 ),
                 EmbeddingConfig(
                     embedding_model="text-embedding-3-small",
@@ -360,6 +363,7 @@ class OpenAIProvider(Provider):
                     embedding_dim=2000,
                     embedding_chunk_size=300,
                     handle=self.get_handle("text-embedding-3-small", is_embedding=True),
+                    batch_size=1024,
                 ),
                 EmbeddingConfig(
                     embedding_model="text-embedding-3-large",
@@ -368,6 +372,7 @@ class OpenAIProvider(Provider):
                     embedding_dim=2000,
                     embedding_chunk_size=300,
                     handle=self.get_handle("text-embedding-3-large", is_embedding=True),
+                    batch_size=1024,
                 ),
             ]
 
@@ -387,6 +392,7 @@ class OpenAIProvider(Provider):
                     embedding_dim=1536,
                     embedding_chunk_size=300,
                     handle=self.get_handle("text-embedding-ada-002", is_embedding=True),
+                    batch_size=1024,
                 ),
                 EmbeddingConfig(
                     embedding_model="text-embedding-3-small",
@@ -395,6 +401,7 @@ class OpenAIProvider(Provider):
                     embedding_dim=2000,
                     embedding_chunk_size=300,
                     handle=self.get_handle("text-embedding-3-small", is_embedding=True),
+                    batch_size=1024,
                 ),
                 EmbeddingConfig(
                     embedding_model="text-embedding-3-large",
@@ -403,6 +410,7 @@ class OpenAIProvider(Provider):
                     embedding_dim=2000,
                     embedding_chunk_size=300,
                     handle=self.get_handle("text-embedding-3-large", is_embedding=True),
+                    batch_size=1024,
                 ),
             ]
 
@@ -1301,6 +1309,7 @@ class GoogleAIProvider(Provider):
                     embedding_dim=768,
                     embedding_chunk_size=300,  # NOTE: max is 2048
                     handle=self.get_handle(model, is_embedding=True),
+                    batch_size=1024,
                 )
             )
         return configs
@@ -1360,6 +1369,7 @@ class GoogleVertexProvider(Provider):
                     embedding_dim=dim,
                     embedding_chunk_size=300,  # NOTE: max is 2048
                     handle=self.get_handle(model, is_embedding=True),
+                    batch_size=1024,
                 )
             )
         return configs
@@ -1424,6 +1434,7 @@ class AzureProvider(Provider):
                     embedding_dim=768,
                     embedding_chunk_size=300,  # NOTE: max is 2048
                     handle=self.get_handle(model_name),
+                    batch_size=1024,
                 ),
             )
         return configs

letta/schemas/step.py

@@ -35,3 +35,4 @@ class Step(StepBase):
     feedback: Optional[Literal["positive", "negative"]] = Field(
         None, description="The feedback for this step. Must be either 'positive' or 'negative'."
     )
+    project_id: Optional[str] = Field(None, description="The project that the agent that executed this step belongs to (cloud only).")

letta/schemas/tool.py

@@ -91,7 +91,8 @@ class Tool(BaseTool):
                     description=description,
                     append_heartbeat=False,
                 )
-            else:
+            else:  # elif not self.json_schema: # TODO: JSON schema is not being derived correctly the first time?
+                # If there's not a json_schema provided, then we need to re-derive
                 try:
                     self.json_schema = derive_openai_json_schema(source_code=self.source_code)
                 except Exception as e: