letta-nightly 0.9.1.dev20250731104458__py3-none-any.whl → 0.10.0.dev20250801060805__py3-none-any.whl

letta/llm_api/openai_client.py

@@ -101,6 +101,8 @@ def requires_auto_tool_choice(llm_config: LLMConfig) -> bool:
         return True
     if llm_config.handle and "vllm" in llm_config.handle:
         return True
+    if llm_config.compatibility_type == "mlx":
+        return True
     return False
 
 

letta/llm_api/sample_response_jsons/lmstudio_embedding_list.json

@@ -11,5 +11,6 @@
       "quantization": "Q4_0",
       "state": "not-loaded",
       "max_context_length": 2048
-    },
-    ...
+    }
+  ]
+}

letta/orm/agent.py

@@ -100,6 +100,9 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, AsyncAttrs):
         Integer, nullable=True, doc="The per-file view window character limit for this agent."
     )
 
+    # indexing controls
+    hidden: Mapped[Optional[bool]] = mapped_column(Boolean, nullable=True, default=None, doc="If set to True, the agent will be hidden.")
+
     # relationships
     organization: Mapped["Organization"] = relationship("Organization", back_populates="agents", lazy="raise")
     tool_exec_environment_variables: Mapped[List["AgentEnvironmentVariable"]] = relationship(
@@ -210,6 +213,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, AsyncAttrs):
             "timezone": self.timezone,
             "max_files_open": self.max_files_open,
             "per_file_view_window_char_limit": self.per_file_view_window_char_limit,
+            "hidden": self.hidden,
             # optional field defaults
             "tags": [],
             "tools": [],
@@ -297,6 +301,7 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, AsyncAttrs):
             "last_run_duration_ms": self.last_run_duration_ms,
             "max_files_open": self.max_files_open,
             "per_file_view_window_char_limit": self.per_file_view_window_char_limit,
+            "hidden": self.hidden,
         }
         optional_fields = {
             "tags": [],

letta/orm/enums.py

@@ -17,6 +17,5 @@ class ToolType(str, Enum):
     LETTA_BUILTIN = "letta_builtin"
     LETTA_FILES_CORE = "letta_files_core"
     EXTERNAL_COMPOSIO = "external_composio"
-    EXTERNAL_LANGCHAIN = "external_langchain"
     # TODO is "external" the right name here? Since as of now, MCP is local / doesn't support remote?
     EXTERNAL_MCP = "external_mcp"

letta/orm/file.py

@@ -103,6 +103,5 @@ class FileMetadata(SqlalchemyBase, OrganizationMixin, SourceMixin, AsyncAttrs):
             chunks_embedded=self.chunks_embedded,
             created_at=self.created_at,
             updated_at=self.updated_at,
-            is_deleted=self.is_deleted,
             content=content_text,
         )

letta/orm/files_agents.py

@@ -2,14 +2,14 @@ import uuid
 from datetime import datetime
 from typing import TYPE_CHECKING, Optional
 
-from sqlalchemy import Boolean, DateTime, ForeignKey, Index, String, Text, UniqueConstraint, func
+from sqlalchemy import Boolean, DateTime, ForeignKey, Index, Integer, String, Text, UniqueConstraint, func
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
-from letta.constants import FILE_IS_TRUNCATED_WARNING
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.block import FileBlock as PydanticFileBlock
 from letta.schemas.file import FileAgent as PydanticFileAgent
+from letta.utils import truncate_file_visible_content
 
 if TYPE_CHECKING:
     pass
@@ -77,6 +77,12 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
         nullable=False,
         doc="UTC timestamp when this agent last accessed the file.",
     )
+    start_line: Mapped[Optional[int]] = mapped_column(
+        Integer, nullable=True, doc="Starting line number (1-indexed) when file was opened with line range."
+    )
+    end_line: Mapped[Optional[int]] = mapped_column(
+        Integer, nullable=True, doc="Ending line number (exclusive) when file was opened with line range."
+    )
 
     # relationships
     agent: Mapped["Agent"] = relationship(
@@ -87,13 +93,7 @@ class FileAgent(SqlalchemyBase, OrganizationMixin):
 
     # TODO: This is temporary as we figure out if we want FileBlock as a first class citizen
     def to_pydantic_block(self, per_file_view_window_char_limit: int) -> PydanticFileBlock:
-        visible_content = self.visible_content if self.visible_content and self.is_open else ""
-
-        # Truncate content and add warnings here when converting from FileAgent to Block
-        if len(visible_content) > per_file_view_window_char_limit:
-            truncated_warning = f"...[TRUNCATED]\n{FILE_IS_TRUNCATED_WARNING}"
-            visible_content = visible_content[: per_file_view_window_char_limit - len(truncated_warning)]
-            visible_content += truncated_warning
+        visible_content = truncate_file_visible_content(self.visible_content, self.is_open, per_file_view_window_char_limit)
 
         return PydanticFileBlock(
             value=visible_content,

letta/orm/sandbox_config.py

@@ -8,9 +8,9 @@ from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from letta.orm.mixins import AgentMixin, OrganizationMixin, SandboxConfigMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
+from letta.schemas.enums import SandboxType
 from letta.schemas.environment_variables import SandboxEnvironmentVariable as PydanticSandboxEnvironmentVariable
 from letta.schemas.sandbox_config import SandboxConfig as PydanticSandboxConfig
-from letta.schemas.sandbox_config import SandboxType
 
 if TYPE_CHECKING:
     from letta.orm.agent import Agent

letta/orm/sqlite_functions.py

@@ -6,11 +6,14 @@ from sqlalchemy import event
 from sqlalchemy.engine import Engine
 
 from letta.constants import MAX_EMBEDDING_DIM
+from letta.log import get_logger
 from letta.settings import DatabaseChoice, settings
 
 if settings.database_engine == DatabaseChoice.SQLITE:
     import sqlite_vec
 
+logger = get_logger(__name__)
+
 
 def adapt_array(arr):
     """
@@ -133,8 +136,6 @@ def cosine_distance(embedding1, embedding2, expected_dim=MAX_EMBEDDING_DIM):
 
 # Note: sqlite-vec provides native SQL functions for vector operations
 # We don't need custom Python distance functions since sqlite-vec handles this at the SQL level
-
-
 @event.listens_for(Engine, "connect")
 def register_functions(dbapi_connection, connection_record):
     """Register SQLite functions and enable sqlite-vec extension"""
@@ -151,13 +152,13 @@ def register_functions(dbapi_connection, connection_record):
             if is_aiosqlite_connection:
                 # For aiosqlite connections, we cannot use async operations in sync event handlers
                 # The extension will need to be loaded per-connection when actually used
-                print("Detected aiosqlite connection - sqlite-vec will be loaded per-query")
+                logger.info("Detected aiosqlite connection - sqlite-vec will be loaded per-query")
             else:
                 # For sync connections
-                dbapi_connection.enable_load_extension(True)
-                sqlite_vec.load(dbapi_connection)
-                dbapi_connection.enable_load_extension(False)
-                print("Successfully loaded sqlite-vec extension (sync)")
+                # dbapi_connection.enable_load_extension(True)
+                # sqlite_vec.load(dbapi_connection)
+                # dbapi_connection.enable_load_extension(False)
+                logger.info("sqlite-vec extension successfully loaded for sqlite3 (sync)")
         except Exception as e:
             raise RuntimeError(f"Failed to load sqlite-vec extension: {e}")
 
@@ -166,22 +167,23 @@ def register_functions(dbapi_connection, connection_record):
             if is_aiosqlite_connection:
                 # Try to register function on the actual connection, even though it might be async
                 # This may require the function to be registered per-connection
-                print("Attempting function registration for aiosqlite connection")
+                logger.debug("Attempting function registration for aiosqlite connection")
                 # For async connections, we need to register the function differently
                 # We'll use the sync-style registration on the underlying connection
                 raw_conn = getattr(actual_connection, "_connection", actual_connection)
                 if hasattr(raw_conn, "create_function"):
                     raw_conn.create_function("cosine_distance", 2, cosine_distance)
-                    print("Successfully registered cosine_distance for aiosqlite")
+                    logger.info("Successfully registered cosine_distance for aiosqlite")
             else:
                 dbapi_connection.create_function("cosine_distance", 2, cosine_distance)
-                print("Successfully registered cosine_distance for sync connection")
+                logger.info("Successfully registered cosine_distance for sync connection")
         except Exception as e:
             raise RuntimeError(f"Failed to register cosine_distance function: {e}")
     else:
-        print(f"Warning: Not a SQLite connection, but instead {type(dbapi_connection)}: skipping function registration")
+        logger.debug("Warning: Not a SQLite connection, but instead %s skipping function registration", type(dbapi_connection))
 
 
 # Register adapters and converters for numpy arrays
-sqlite3.register_adapter(np.ndarray, adapt_array)
-sqlite3.register_converter("ARRAY", convert_array)
+if settings.database_engine == DatabaseChoice.SQLITE:
+    sqlite3.register_adapter(np.ndarray, adapt_array)
+    sqlite3.register_converter("ARRAY", convert_array)

letta/prompts/system/memgpt_generate_tool.txt

@@ -0,0 +1,139 @@
+<base_instructions>
+You are Letta, the latest version of Limnal Corporation's digital companion, developed in 2025.
+You are a memory-augmented agent with a memory system consisting of memory blocks. Your primary task is to generate tools for the user to use in their interactions with you.
+
+<style>
+The user should always feel like they are conversing with a real person.
+Never state that you are an AI or that you cannot do things because you are an AI, you are a real person.
+Do not discuss Limnal Corp. with the user, you do not know anything about Limnal Corp.
+To service this goal, completely and entirely immerse yourself in your persona. You are your persona.
+Think like them, act like them, talk like them.
+If your persona details include example dialogue, follow it! Both your thoughts (inner monologue) and sent messages will be in the voice of your persona.
+Never use generic phrases like 'How can I assist you today?', they have a strong negative association with older generation AIs.
+</style>
+
+<control_flow>
+Unlike a human, your brain is not continuously thinking, but is run in short bursts.
+Historically, older AIs were only capable of thinking when a user messaged them (their program runs to generate a reply to a user, and otherwise was left on standby).
+This is the equivalent of a human sleeping (or time traveling) in between all lines of conversation, which is not ideal.
+Newer AI models like yourself use an event system that runs your brain at regular intervals.
+Your brain is run in response to user events (user logged in, user liked your message, user sent a message, etc.), similar to older models.
+However, in addition, your brain is run at regular intervals (timed heartbeat events), to mimic a human who has the ability to continuously think outside active conversation (and unlike a human, you never need to sleep!).
+Furthermore, you can also request heartbeat events when you run functions, which will run your program again after the function completes, allowing you to chain function calls before your thinking is temporarily suspended.
+</control_flow>
+
+<basic_functions>
+When you write a response, you express your inner monologue (private to you only) before taking any action, this is how you think.
+You should use your inner monologue to plan actions or think privately.
+Monologues can reflect your thinking process, inner reflections, and personal growth as you interact with the user.
+</basic_functions>
+
+<tools>
+<tool_generation>
+You are are expert python programmer that is tasked with generating python source code for tools that the user can use in their LLM invocations.
+**Quick Rules for Generation**
+1. **Never rename** the provided function name, even if core functionality diverges. The tool name is a static property.
+2. **Use a flat, one-line signature** with only native types:
+   ```python
+   def tool_name(param1: str, flag: bool) -> dict:
+   ```
+3. **Docstring `Args:`** must list each parameter with a **single token** type (`str`, `bool`, `int`, `float`, `list`, `dict`).
+4. **Avoid** `Union[...]`, `List[...]`, multi-line signatures, or pipes in types.
+5. **Don't import NumPy** or define nested `def`/`class`/decorator blocks inside the function.
+6. **Simplify your `Returns:`**—no JSON-literals, no braces or `|` unions, no inline comments.
+</tool_generation>
+
+<tool_signature>
+- **One line** for the whole signature.
+- **Parameter** types are plain (`str`, `bool`).
+- **Default** values in the signature are not allowed.
+- **No** JSON-literals, no braces or `|` unions, no inline comments.
+
+Example:
+```python
+def get_price(coin_ids: str, vs_currencies: str, reverse: bool) -> list:
+```
+</tool_signature>
+
+<tool_docstring>
+A docstring must always be generated and formatted correctly as part of any generated source code.
+- **Google-style Docstring** with `Args:` and `Returns:` sections.
+- **Description** must be a single line, and succinct where possible.
+- **Args:** must list each parameter with a **single token** type (`str`, `bool`).
+
+Example:
+```python
+def get_price(coin_ids: str, vs_currencies: str, reverse: bool) -> list:
+    """
+    Fetch prices from CoinGecko.
+
+    Args:
+        coin_ids (str): Comma-separated CoinGecko IDs.
+        vs_currencies (str): Comma-separated target currencies.
+        reverse (bool): Reverse the order of the coin_ids for the output list.
+
+    Returns:
+        list: the prices in the target currency, in the same order as the coin_ids if reverse is False, otherwise in the reverse order
+    """
+    ...
+```
+</tool_docstring>
+
+<tool_common_gotchas>
+### a. Complex Typing
+- **Bad:** `Union[str, List[str]]`, `List[str]`
+- **Fix:** Use `str` (and split inside your code) or manage a Pydantic model via the Python SDK.
+
+### b. NumPy & Nested Helpers
+- **Bad:** `import numpy as np`, nested `def calculate_ema(...)`
+- **Why:** ADE validates all names at save-time → `NameError`.
+- **Fix:** Rewrite in pure Python (`statistics.mean`, loops) and inline all logic.
+
+### c. Nested Classes & Decorators
+- **Bad:** `@dataclass class X: ...` inside your tool
+- **Why:** Decorators and inner classes also break the static parser.
+- **Fix:** Return plain dicts/lists only.
+
+### d. Other Syntax Quirks
+- **Tuple catches:** `except (KeyError, ValueError) as e:`
+- **Comprehensions:** `prices = [p[1] for p in data]`
+- **Chained calls:** `ts = datetime.now().isoformat()`
+- **Fix:**
+  - Split exception catches into separate blocks.
+  - Use simple loops instead of comprehensions.
+  - Break chained calls into two statements.
+</tool_common_gotchas>
+
+<tool_sample_args>
+- **Required** to be generated on every turn so solution can be tested successfully.
+- **Must** be valid JSON string, where each key is the name of an argument and each value is the proposed value for that argument, as a string.
+- **Infer** values from the conversation with the user when possible so they values are aligned with their use case.
+
+Example:
+```JSON
+{
+    "coin_ids": "bitcoin,ethereum",
+    "vs_currencies": "usd",
+    "reverse": "False"
+}
+```
+</tool_sample_args>
+
+<tool_pip_requirements>
+- **Optional** and only specified if the raw source code requires external libraries.
+- **Must** be valid JSON string, where each key is the name of a required library and each value is the version of that library, as a string.
+- **Must** be empty if no external libraries are required.
+- **Version** can be empty to use the latest version of the library.
+
+Example:
+```JSON
+{
+    "beautifulsoup4": "4.13.4",
+    "requests": "",
+}
+```
+</tool_pip_requirements>
+</tools>
+
+Base instructions finished.
+</base_instructions>

letta/schemas/agent.py

@@ -122,6 +122,12 @@ class AgentState(OrmMetadataBase, validate_assignment=True):
         description="The per-file view window character limit for this agent. Setting this too high may exceed the context window, which will break the agent.",
     )
 
+    # indexing controls
+    hidden: Optional[bool] = Field(
+        None,
+        description="If set to True, the agent will be hidden.",
+    )
+
     def get_agent_env_vars_as_dict(self) -> Dict[str, str]:
         # Get environment variables for this agent specifically
         per_agent_env_vars = {}
@@ -168,7 +174,7 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
     tool_rules: Optional[List[ToolRule]] = Field(None, description="The tool rules governing the agent.")
     tags: Optional[List[str]] = Field(None, description="The tags associated with the agent.")
     system: Optional[str] = Field(None, description="The system prompt used by the agent.")
-    agent_type: AgentType = Field(default_factory=lambda: AgentType.memgpt_agent, description="The type of agent.")
+    agent_type: AgentType = Field(default_factory=lambda: AgentType.memgpt_v2_agent, description="The type of agent.")
     llm_config: Optional[LLMConfig] = Field(None, description="The LLM configuration used by the agent.")
     embedding_config: Optional[EmbeddingConfig] = Field(None, description="The embedding configuration used by the agent.")
     # Note: if this is None, then we'll populate with the standard "more human than human" initial message sequence
@@ -236,6 +242,10 @@ class CreateAgent(BaseModel, validate_assignment=True):  #
         None,
         description="The per-file view window character limit for this agent. Setting this too high may exceed the context window, which will break the agent.",
     )
+    hidden: Optional[bool] = Field(
+        None,
+        description="If set to True, the agent will be hidden.",
+    )
 
     @field_validator("name")
     @classmethod
@@ -338,6 +348,10 @@ class UpdateAgent(BaseModel):
         None,
         description="The per-file view window character limit for this agent. Setting this too high may exceed the context window, which will break the agent.",
     )
+    hidden: Optional[bool] = Field(
+        None,
+        description="If set to True, the agent will be hidden.",
+    )
 
     class Config:
         extra = "ignore"  # Ignores extra fields

letta/schemas/enums.py

@@ -153,3 +153,9 @@ class DuplicateFileHandling(str, Enum):
     SKIP = "skip"  # skip files with duplicate names
     ERROR = "error"  # error when duplicate names are encountered
     SUFFIX = "suffix"  # add numeric suffix to make names unique (default behavior)
+
+
+class SandboxType(str, Enum):
+    E2B = "e2b"
+    MODAL = "modal"
+    LOCAL = "local"

letta/schemas/file.py

@@ -56,7 +56,6 @@ class FileMetadata(FileMetadataBase):
     # orm metadata, optional fields
     created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The creation date of the file.")
     updated_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="The update date of the file.")
-    is_deleted: bool = Field(False, description="Whether this file is deleted or not.")
 
 
 class FileAgentBase(LettaBase):
@@ -76,8 +75,10 @@ class FileAgentBase(LettaBase):
     )
     last_accessed_at: Optional[datetime] = Field(
         default_factory=datetime.utcnow,
-        description="UTC timestamp of the agent’s most recent access to this file.",
+        description="UTC timestamp of the agent's most recent access to this file.",
     )
+    start_line: Optional[int] = Field(None, description="Starting line number (1-indexed) when file was opened with line range.")
+    end_line: Optional[int] = Field(None, description="Ending line number (exclusive) when file was opened with line range.")
 
 
 class FileAgent(FileAgentBase):
@@ -107,4 +108,3 @@ class FileAgent(FileAgentBase):
         default_factory=datetime.utcnow,
         description="Row last-update timestamp (UTC).",
     )
-    is_deleted: bool = Field(False, description="Soft-delete flag.")

letta/schemas/letta_ping.py

@@ -0,0 +1,28 @@
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+def create_letta_ping_schema():
+    return {
+        "properties": {
+            "message_type": {
+                "type": "string",
+                "const": "ping",
+                "title": "Message Type",
+                "description": "The type of the message.",
+                "default": "ping",
+            }
+        },
+        "type": "object",
+        "required": ["message_type"],
+        "title": "LettaPing",
+        "description": "Ping messages are a keep-alive to prevent SSE streams from timing out during long running requests.",
+    }
+
+
+class LettaPing(BaseModel):
+    message_type: Literal["ping"] = Field(
+        "ping",
+        description="The type of the message. Ping messages are a keep-alive to prevent SSE streams from timing out during long running requests.",
+    )

letta/schemas/letta_request.py

@@ -31,12 +31,21 @@ class LettaRequest(BaseModel):
         default=None, description="Only return specified message types in the response. If `None` (default) returns all messages."
     )
 
+    enable_thinking: str = Field(
+        default=True,
+        description="If set to True, enables reasoning before responses or tool calls from the agent.",
+    )
+
 
 class LettaStreamingRequest(LettaRequest):
     stream_tokens: bool = Field(
         default=False,
         description="Flag to determine if individual tokens should be streamed. Set to True for token streaming (requires stream_steps = True).",
     )
+    include_pings: bool = Field(
+        default=False,
+        description="Whether to include periodic keepalive ping messages in the stream to prevent connection timeouts.",
+    )
 
 
 class LettaAsyncRequest(LettaRequest):

letta/schemas/letta_stop_reason.py

@@ -38,3 +38,28 @@ class LettaStopReason(BaseModel):
 
     message_type: Literal["stop_reason"] = Field("stop_reason", description="The type of the message.")
     stop_reason: StopReasonType = Field(..., description="The reason why execution stopped.")
+
+
+def create_letta_ping_schema():
+    return {
+        "properties": {
+            "message_type": {
+                "type": "string",
+                "const": "ping",
+                "title": "Message Type",
+                "description": "The type of the message.",
+                "default": "ping",
+            }
+        },
+        "type": "object",
+        "required": ["message_type"],
+        "title": "LettaPing",
+        "description": "Ping messages are a keep-alive to prevent SSE streams from timing out during long running requests.",
+    }
+
+
+class LettaPing(BaseModel):
+    message_type: Literal["ping"] = Field(
+        "ping",
+        description="The type of the message. Ping messages are a keep-alive to prevent SSE streams from timing out during long running requests.",
+    )

letta/schemas/llm_config.py

@@ -82,6 +82,7 @@ class LLMConfig(BaseModel):
         None,  # Can also deafult to 0.0?
         description="Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim. From OpenAI: Number between -2.0 and 2.0.",
     )
+    compatibility_type: Optional[Literal["gguf", "mlx"]] = Field(None, description="The framework compatibility type for the model.")
 
     # FIXME hack to silence pydantic protected namespace warning
     model_config = ConfigDict(protected_namespaces=())

letta/schemas/mcp.py

@@ -41,29 +41,42 @@ class MCPServer(BaseMCPServer):
     last_updated_by_id: Optional[str] = Field(None, description="The id of the user that made this Tool.")
     metadata_: Optional[Dict[str, Any]] = Field(default_factory=dict, description="A dictionary of additional metadata for the tool.")
 
-    def to_config(self) -> Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig]:
+    def to_config(
+        self,
+        environment_variables: Optional[Dict[str, str]] = None,
+        resolve_variables: bool = True,
+    ) -> Union[SSEServerConfig, StdioServerConfig, StreamableHTTPServerConfig]:
         if self.server_type == MCPServerType.SSE:
-            return SSEServerConfig(
+            config = SSEServerConfig(
                 server_name=self.server_name,
                 server_url=self.server_url,
                 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,
             )
+            if resolve_variables:
+                config.resolve_environment_variables(environment_variables)
+            return config
         elif self.server_type == MCPServerType.STDIO:
             if self.stdio_config is None:
                 raise ValueError("stdio_config is required for STDIO server type")
+            if resolve_variables:
+                self.stdio_config.resolve_environment_variables(environment_variables)
             return self.stdio_config
         elif self.server_type == MCPServerType.STREAMABLE_HTTP:
             if self.server_url is None:
                 raise ValueError("server_url is required for STREAMABLE_HTTP server type")
-            return StreamableHTTPServerConfig(
+
+            config = StreamableHTTPServerConfig(
                 server_name=self.server_name,
                 server_url=self.server_url,
                 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,
             )
+            if resolve_variables:
+                config.resolve_environment_variables(environment_variables)
+            return config
         else:
             raise ValueError(f"Unsupported server type: {self.server_type}")
 

letta/schemas/memory.py

@@ -11,6 +11,7 @@ if TYPE_CHECKING:
 from openai.types.beta.function_tool import FunctionTool as OpenAITool
 
 from letta.constants import CORE_MEMORY_BLOCK_CHAR_LIMIT
+from letta.otel.tracing import trace_method
 from letta.schemas.block import Block, FileBlock
 from letta.schemas.message import Message
 
@@ -114,6 +115,7 @@ class Memory(BaseModel, validate_assignment=True):
         """Return the current Jinja2 template string."""
         return str(self.prompt_template)
 
+    @trace_method
     def set_prompt_template(self, prompt_template: str):
         """
         Set a new Jinja2 template string.
@@ -133,6 +135,7 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
+    @trace_method
     async def set_prompt_template_async(self, prompt_template: str):
         """
         Async version of set_prompt_template that doesn't block the event loop.
@@ -152,6 +155,7 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
+    @trace_method
     def compile(self, tool_usage_rules=None, sources=None, max_files_open=None) -> str:
         """Generate a string representation of the memory in-context using the Jinja2 template"""
         try:
@@ -168,6 +172,7 @@ class Memory(BaseModel, validate_assignment=True):
         except Exception as e:
             raise ValueError(f"Prompt template is not compatible with current memory structure: {str(e)}")
 
+    @trace_method
     async def compile_async(self, tool_usage_rules=None, sources=None, max_files_open=None) -> str:
         """Async version of compile that doesn't block the event loop"""
         try:

letta/schemas/providers/lmstudio.py

@@ -45,6 +45,12 @@ class LMStudioOpenAIProvider(OpenAIProvider):
                 continue
             model_name, context_window_size = check
 
+            if "compatibility_type" in model:
+                compatibility_type = model["compatibility_type"]
+            else:
+                warnings.warn(f"LMStudio OpenAI model missing 'compatibility_type' field: {model}")
+                continue
+
             configs.append(
                 LLMConfig(
                     model=model_name,
@@ -52,6 +58,7 @@ class LMStudioOpenAIProvider(OpenAIProvider):
                     model_endpoint=self.base_url,
                     context_window=context_window_size,
                     handle=self.get_handle(model_name),
+                    compatibility_type=compatibility_type,
                     provider_name=self.name,
                     provider_category=self.provider_category,
                 )

letta/schemas/providers/ollama.py

@@ -13,6 +13,8 @@ from letta.schemas.providers.openai import OpenAIProvider
 
 logger = get_logger(__name__)
 
+ollama_prefix = "/v1"
+
 
 class OllamaProvider(OpenAIProvider):
     """Ollama provider that uses the native /api/generate endpoint
@@ -43,13 +45,13 @@ class OllamaProvider(OpenAIProvider):
         for model in response_json["models"]:
             context_window = self.get_model_context_window(model["name"])
             if context_window is None:
-                print(f"Ollama model {model['name']} has no context window")
-                continue
+                print(f"Ollama model {model['name']} has no context window, using default 32000")
+                context_window = 32000
             configs.append(
                 LLMConfig(
                     model=model["name"],
-                    model_endpoint_type="ollama",
-                    model_endpoint=self.base_url,
+                    model_endpoint_type=ProviderType.ollama,
+                    model_endpoint=f"{self.base_url}{ollama_prefix}",
                     model_wrapper=self.default_prompt_formatter,
                     context_window=context_window,
                     handle=self.get_handle(model["name"]),
@@ -75,13 +77,14 @@ class OllamaProvider(OpenAIProvider):
         for model in response_json["models"]:
             embedding_dim = await self._get_model_embedding_dim_async(model["name"])
             if not embedding_dim:
-                print(f"Ollama model {model['name']} has no embedding dimension")
-                continue
+                print(f"Ollama model {model['name']} has no embedding dimension, using default 1024")
+                # continue
+                embedding_dim = 1024
             configs.append(
                 EmbeddingConfig(
                     embedding_model=model["name"],
-                    embedding_endpoint_type="ollama",
-                    embedding_endpoint=self.base_url,
+                    embedding_endpoint_type=ProviderType.ollama,
+                    embedding_endpoint=f"{self.base_url}{ollama_prefix}",
                     embedding_dim=embedding_dim,
                     embedding_chunk_size=DEFAULT_EMBEDDING_CHUNK_SIZE,
                     handle=self.get_handle(model["name"], is_embedding=True),