letta-nightly 0.11.4.dev20250825104222__py3-none-any.whl → 0.11.5__py3-none-any.whl

letta/__init__.py

@@ -5,7 +5,7 @@ try:
     __version__ = version("letta")
 except PackageNotFoundError:
     # Fallback for development installations
-    __version__ = "0.11.4"
+    __version__ = "0.11.5"
 
 if os.environ.get("LETTA_VERSION"):
     __version__ = os.environ["LETTA_VERSION"]

letta/agent.py

@@ -42,6 +42,7 @@ from letta.log import get_logger
 from letta.memory import summarize_messages
 from letta.orm import User
 from letta.otel.tracing import log_event, trace_method
+from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import AgentState, AgentStepResponse, UpdateAgent, get_prompt_template_for_agent_type
 from letta.schemas.block import BlockUpdate
 from letta.schemas.embedding_config import EmbeddingConfig
@@ -59,7 +60,7 @@ from letta.schemas.tool_rule import TerminalToolRule
 from letta.schemas.usage import LettaUsageStatistics
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.helpers.agent_manager_helper import check_supports_structured_output, compile_memory_metadata_block
+from letta.services.helpers.agent_manager_helper import check_supports_structured_output
 from letta.services.helpers.tool_parser_helper import runtime_override_tool_json_schema
 from letta.services.job_manager import JobManager
 from letta.services.mcp.base_client import AsyncBaseMCPClient
@@ -330,8 +331,13 @@ class Agent(BaseAgent):
                 return None
 
         allowed_functions = [func for func in agent_state_tool_jsons if func["name"] in allowed_tool_names]
+        # Extract terminal tool names from tool rules
+        terminal_tool_names = {rule.tool_name for rule in self.tool_rules_solver.terminal_tool_rules}
         allowed_functions = runtime_override_tool_json_schema(
-            tool_list=allowed_functions, response_format=self.agent_state.response_format, request_heartbeat=True
+            tool_list=allowed_functions,
+            response_format=self.agent_state.response_format,
+            request_heartbeat=True,
+            terminal_tools=terminal_tool_names,
         )
 
         # For the first message, force the initial tool if one is specified
@@ -1246,7 +1252,7 @@ class Agent(BaseAgent):
 
         agent_manager_passage_size = self.agent_manager.passage_size(actor=self.user, agent_id=self.agent_state.id)
         message_manager_size = self.message_manager.size(actor=self.user, agent_id=self.agent_state.id)
-        external_memory_summary = compile_memory_metadata_block(
+        external_memory_summary = PromptGenerator.compile_memory_metadata_block(
             memory_edit_timestamp=get_utc_time(),
             timezone=self.agent_state.timezone,
             previous_message_count=self.message_manager.size(actor=self.user, agent_id=self.agent_state.id),

letta/agents/base_agent.py

@@ -7,6 +7,7 @@ from letta.constants import DEFAULT_MAX_STEPS
 from letta.helpers import ToolRulesSolver
 from letta.helpers.datetime_helpers import get_utc_time
 from letta.log import get_logger
+from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import AgentState
 from letta.schemas.enums import MessageStreamStatus
 from letta.schemas.letta_message import LegacyLettaMessage, LettaMessage
@@ -17,7 +18,6 @@ from letta.schemas.message import Message, MessageCreate, MessageUpdate
 from letta.schemas.usage import LettaUsageStatistics
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
-from letta.services.helpers.agent_manager_helper import get_system_message_from_compiled_memory
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
 from letta.utils import united_diff
@@ -142,7 +142,7 @@ class BaseAgent(ABC):
             if num_archival_memories is None:
                 num_archival_memories = await self.passage_manager.agent_passage_size_async(actor=self.actor, agent_id=agent_state.id)
 
-            new_system_message_str = get_system_message_from_compiled_memory(
+            new_system_message_str = PromptGenerator.get_system_message_from_compiled_memory(
                 system_prompt=agent_state.system,
                 memory_with_sources=curr_memory_str,
                 in_context_memory_last_edit=memory_edit_timestamp,

letta/agents/letta_agent.py

@@ -137,6 +137,10 @@ class LettaAgent(BaseAgent):
             message_buffer_limit=message_buffer_limit,
             message_buffer_min=message_buffer_min,
             partial_evict_summarizer_percentage=partial_evict_summarizer_percentage,
+            agent_manager=self.agent_manager,
+            message_manager=self.message_manager,
+            actor=self.actor,
+            agent_id=self.agent_id,
         )
 
     async def _check_run_cancellation(self) -> bool:
@@ -345,16 +349,17 @@ class LettaAgent(BaseAgent):
                 agent_step_span.end()
 
                 # Log LLM Trace
-                await self.telemetry_manager.create_provider_trace_async(
-                    actor=self.actor,
-                    provider_trace_create=ProviderTraceCreate(
-                        request_json=request_data,
-                        response_json=response_data,
-                        step_id=step_id,  # Use original step_id for telemetry
-                        organization_id=self.actor.organization_id,
-                    ),
-                )
-                step_progression = StepProgression.LOGGED_TRACE
+                if settings.track_provider_trace:
+                    await self.telemetry_manager.create_provider_trace_async(
+                        actor=self.actor,
+                        provider_trace_create=ProviderTraceCreate(
+                            request_json=request_data,
+                            response_json=response_data,
+                            step_id=step_id,  # Use original step_id for telemetry
+                            organization_id=self.actor.organization_id,
+                        ),
+                    )
+                    step_progression = StepProgression.LOGGED_TRACE
 
                 # stream step
                 # TODO: improve TTFT
@@ -642,17 +647,18 @@ class LettaAgent(BaseAgent):
                 agent_step_span.end()
 
                 # Log LLM Trace
-                await self.telemetry_manager.create_provider_trace_async(
-                    actor=self.actor,
-                    provider_trace_create=ProviderTraceCreate(
-                        request_json=request_data,
-                        response_json=response_data,
-                        step_id=step_id,  # Use original step_id for telemetry
-                        organization_id=self.actor.organization_id,
-                    ),
-                )
+                if settings.track_provider_trace:
+                    await self.telemetry_manager.create_provider_trace_async(
+                        actor=self.actor,
+                        provider_trace_create=ProviderTraceCreate(
+                            request_json=request_data,
+                            response_json=response_data,
+                            step_id=step_id,  # Use original step_id for telemetry
+                            organization_id=self.actor.organization_id,
+                        ),
+                    )
+                    step_progression = StepProgression.LOGGED_TRACE
 
-                step_progression = StepProgression.LOGGED_TRACE
                 MetricRegistry().step_execution_time_ms_histogram.record(get_utc_timestamp_ns() - step_start, get_ctx_attributes())
                 step_progression = StepProgression.FINISHED
 
@@ -1003,31 +1009,32 @@ class LettaAgent(BaseAgent):
                 # Log LLM Trace
                 # We are piecing together the streamed response here.
                 # Content here does not match the actual response schema as streams come in chunks.
-                await self.telemetry_manager.create_provider_trace_async(
-                    actor=self.actor,
-                    provider_trace_create=ProviderTraceCreate(
-                        request_json=request_data,
-                        response_json={
-                            "content": {
-                                "tool_call": tool_call.model_dump_json(),
-                                "reasoning": [content.model_dump_json() for content in reasoning_content],
+                if settings.track_provider_trace:
+                    await self.telemetry_manager.create_provider_trace_async(
+                        actor=self.actor,
+                        provider_trace_create=ProviderTraceCreate(
+                            request_json=request_data,
+                            response_json={
+                                "content": {
+                                    "tool_call": tool_call.model_dump_json(),
+                                    "reasoning": [content.model_dump_json() for content in reasoning_content],
+                                },
+                                "id": interface.message_id,
+                                "model": interface.model,
+                                "role": "assistant",
+                                # "stop_reason": "",
+                                # "stop_sequence": None,
+                                "type": "message",
+                                "usage": {
+                                    "input_tokens": usage.prompt_tokens,
+                                    "output_tokens": usage.completion_tokens,
+                                },
                             },
-                            "id": interface.message_id,
-                            "model": interface.model,
-                            "role": "assistant",
-                            # "stop_reason": "",
-                            # "stop_sequence": None,
-                            "type": "message",
-                            "usage": {
-                                "input_tokens": usage.prompt_tokens,
-                                "output_tokens": usage.completion_tokens,
-                            },
-                        },
-                        step_id=step_id,  # Use original step_id for telemetry
-                        organization_id=self.actor.organization_id,
-                    ),
-                )
-                step_progression = StepProgression.LOGGED_TRACE
+                            step_id=step_id,  # Use original step_id for telemetry
+                            organization_id=self.actor.organization_id,
+                        ),
+                    )
+                    step_progression = StepProgression.LOGGED_TRACE
 
                 # yields tool response as this is handled from Letta and not the response from the LLM provider
                 tool_return = [msg for msg in persisted_messages if msg.role == "tool"][-1].to_letta_messages()[0]
@@ -1352,6 +1359,7 @@ class LettaAgent(BaseAgent):
     ) -> list[Message]:
         # If total tokens is reached, we truncate down
         # TODO: This can be broken by bad configs, e.g. lower bound too high, initial messages too fat, etc.
+        # TODO: `force` and `clear` seem to no longer be used, we should remove
         if force or (total_tokens and total_tokens > llm_config.context_window):
             self.logger.warning(
                 f"Total tokens {total_tokens} exceeds configured max tokens {llm_config.context_window}, forcefully clearing message history."
@@ -1363,6 +1371,7 @@ class LettaAgent(BaseAgent):
                 clear=True,
             )
         else:
+            # NOTE (Sarah): Seems like this is doing nothing?
             self.logger.info(
                 f"Total tokens {total_tokens} does not exceed configured max tokens {llm_config.context_window}, passing summarizing w/o force."
             )
@@ -1453,8 +1462,10 @@ class LettaAgent(BaseAgent):
             force_tool_call = valid_tool_names[0]
 
         allowed_tools = [enable_strict_mode(t.json_schema) for t in tools if t.name in set(valid_tool_names)]
+        # Extract terminal tool names from tool rules
+        terminal_tool_names = {rule.tool_name for rule in tool_rules_solver.terminal_tool_rules}
         allowed_tools = runtime_override_tool_json_schema(
-            tool_list=allowed_tools, response_format=agent_state.response_format, request_heartbeat=True
+            tool_list=allowed_tools, response_format=agent_state.response_format, request_heartbeat=True, terminal_tools=terminal_tool_names
         )
 
         return (

letta/agents/voice_agent.py

@@ -13,6 +13,7 @@ from letta.helpers.datetime_helpers import get_utc_time
 from letta.helpers.tool_execution_helper import add_pre_execution_message, enable_strict_mode, remove_request_heartbeat
 from letta.interfaces.openai_chat_completions_streaming_interface import OpenAIChatCompletionsStreamingInterface
 from letta.log import get_logger
+from letta.prompts.prompt_generator import PromptGenerator
 from letta.schemas.agent import AgentState, AgentType
 from letta.schemas.enums import MessageRole, ToolType
 from letta.schemas.letta_response import LettaResponse
@@ -35,7 +36,6 @@ from letta.server.rest_api.utils import (
 )
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.helpers.agent_manager_helper import compile_system_message_async
 from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
@@ -144,7 +144,7 @@ class VoiceAgent(BaseAgent):
 
         in_context_messages = await self.message_manager.get_messages_by_ids_async(message_ids=agent_state.message_ids, actor=self.actor)
         memory_edit_timestamp = get_utc_time()
-        in_context_messages[0].content[0].text = await compile_system_message_async(
+        in_context_messages[0].content[0].text = await PromptGenerator.compile_system_message_async(
             system_prompt=agent_state.system,
             in_context_memory=agent_state.memory,
             in_context_memory_last_edit=memory_edit_timestamp,

letta/data_sources/redis_client.py

@@ -1,6 +1,6 @@
 import asyncio
 from functools import wraps
-from typing import Any, Optional, Set, Union
+from typing import Any, Dict, List, Optional, Set, Union
 
 from letta.constants import REDIS_EXCLUDE, REDIS_INCLUDE, REDIS_SET_DEFAULT_VAL
 from letta.log import get_logger
@@ -218,6 +218,126 @@ class AsyncRedisClient:
         client = await self.get_client()
         return await client.decr(key)
 
+    # Stream operations
+    @with_retry()
+    async def xadd(self, stream: str, fields: Dict[str, Any], id: str = "*", maxlen: Optional[int] = None, approximate: bool = True) -> str:
+        """Add entry to a stream.
+
+        Args:
+            stream: Stream name
+            fields: Dict of field-value pairs to add
+            id: Entry ID ('*' for auto-generation)
+            maxlen: Maximum length of the stream
+            approximate: Whether maxlen is approximate
+
+        Returns:
+            The ID of the added entry
+        """
+        client = await self.get_client()
+        return await client.xadd(stream, fields, id=id, maxlen=maxlen, approximate=approximate)
+
+    @with_retry()
+    async def xread(self, streams: Dict[str, str], count: Optional[int] = None, block: Optional[int] = None) -> List[Dict]:
+        """Read from streams.
+
+        Args:
+            streams: Dict mapping stream names to IDs
+            count: Maximum number of entries to return
+            block: Milliseconds to block waiting for data (None = no blocking)
+
+        Returns:
+            List of entries from the streams
+        """
+        client = await self.get_client()
+        return await client.xread(streams, count=count, block=block)
+
+    @with_retry()
+    async def xrange(self, stream: str, start: str = "-", end: str = "+", count: Optional[int] = None) -> List[Dict]:
+        """Read range of entries from a stream.
+
+        Args:
+            stream: Stream name
+            start: Start ID (inclusive)
+            end: End ID (inclusive)
+            count: Maximum number of entries to return
+
+        Returns:
+            List of entries in the specified range
+        """
+        client = await self.get_client()
+        return await client.xrange(stream, start, end, count=count)
+
+    @with_retry()
+    async def xrevrange(self, stream: str, start: str = "+", end: str = "-", count: Optional[int] = None) -> List[Dict]:
+        """Read range of entries from a stream in reverse order.
+
+        Args:
+            stream: Stream name
+            start: Start ID (inclusive)
+            end: End ID (inclusive)
+            count: Maximum number of entries to return
+
+        Returns:
+            List of entries in the specified range in reverse order
+        """
+        client = await self.get_client()
+        return await client.xrevrange(stream, start, end, count=count)
+
+    @with_retry()
+    async def xlen(self, stream: str) -> int:
+        """Get the length of a stream.
+
+        Args:
+            stream: Stream name
+
+        Returns:
+            Number of entries in the stream
+        """
+        client = await self.get_client()
+        return await client.xlen(stream)
+
+    @with_retry()
+    async def xdel(self, stream: str, *ids: str) -> int:
+        """Delete entries from a stream.
+
+        Args:
+            stream: Stream name
+            ids: IDs of entries to delete
+
+        Returns:
+            Number of entries deleted
+        """
+        client = await self.get_client()
+        return await client.xdel(stream, *ids)
+
+    @with_retry()
+    async def xinfo_stream(self, stream: str) -> Dict:
+        """Get information about a stream.
+
+        Args:
+            stream: Stream name
+
+        Returns:
+            Dict with stream information
+        """
+        client = await self.get_client()
+        return await client.xinfo_stream(stream)
+
+    @with_retry()
+    async def xtrim(self, stream: str, maxlen: int, approximate: bool = True) -> int:
+        """Trim a stream to a maximum length.
+
+        Args:
+            stream: Stream name
+            maxlen: Maximum length
+            approximate: Whether maxlen is approximate
+
+        Returns:
+            Number of entries removed
+        """
+        client = await self.get_client()
+        return await client.xtrim(stream, maxlen=maxlen, approximate=approximate)
+
     async def check_inclusion_and_exclusion(self, member: str, group: str) -> bool:
         exclude_key = self._get_group_exclusion_key(group)
         include_key = self._get_group_inclusion_key(group)
@@ -290,6 +410,31 @@ class NoopAsyncRedisClient(AsyncRedisClient):
     async def srem(self, key: str, *members: Union[str, int, float]) -> int:
         return 0
 
+    # Stream operations
+    async def xadd(self, stream: str, fields: Dict[str, Any], id: str = "*", maxlen: Optional[int] = None, approximate: bool = True) -> str:
+        return ""
+
+    async def xread(self, streams: Dict[str, str], count: Optional[int] = None, block: Optional[int] = None) -> List[Dict]:
+        return []
+
+    async def xrange(self, stream: str, start: str = "-", end: str = "+", count: Optional[int] = None) -> List[Dict]:
+        return []
+
+    async def xrevrange(self, stream: str, start: str = "+", end: str = "-", count: Optional[int] = None) -> List[Dict]:
+        return []
+
+    async def xlen(self, stream: str) -> int:
+        return 0
+
+    async def xdel(self, stream: str, *ids: str) -> int:
+        return 0
+
+    async def xinfo_stream(self, stream: str) -> Dict:
+        return {}
+
+    async def xtrim(self, stream: str, maxlen: int, approximate: bool = True) -> int:
+        return 0
+
 
 async def get_redis_client() -> AsyncRedisClient:
     global _client_instance

letta/errors.py

@@ -76,6 +76,10 @@ class LettaUserNotFoundError(LettaError):
     """Error raised when a user is not found."""
 
 
+class LettaUnexpectedStreamCancellationError(LettaError):
+    """Error raised when a streaming request is terminated unexpectedly."""
+
+
 class LLMError(LettaError):
     pass
 

letta/functions/function_sets/files.py

@@ -21,8 +21,8 @@ async def open_files(agent_state: "AgentState", file_requests: List[FileOpenRequ
 
         Open multiple files with different view ranges:
             file_requests = [
-                FileOpenRequest(file_name="project_utils/config.py", offset=1, length=50),     # Lines 1-50
-                FileOpenRequest(file_name="project_utils/main.py", offset=100, length=100),    # Lines 100-199
+                FileOpenRequest(file_name="project_utils/config.py", offset=0, length=50),     # Lines 1-50
+                FileOpenRequest(file_name="project_utils/main.py", offset=100, length=100),    # Lines 101-200
                 FileOpenRequest(file_name="project_utils/utils.py")                            # Entire file
             ]
 

letta/functions/mcp_client/types.py

@@ -148,9 +148,21 @@ class SSEServerConfig(BaseServerConfig):
     custom_headers: Optional[dict[str, str]] = Field(None, description="Custom HTTP headers to include with SSE requests")
 
     def resolve_token(self) -> Optional[str]:
-        if self.auth_token and self.auth_token.startswith(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} "):
-            return self.auth_token[len(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} ") :]
-        return self.auth_token
+        """
+        Extract token for storage if auth_header/auth_token are provided
+        and not already in custom_headers.
+
+        Returns:
+            The resolved token (without Bearer prefix) if it should be stored separately, None otherwise
+        """
+        if self.auth_token and self.auth_header:
+            # Check if custom_headers already has the auth header
+            if not self.custom_headers or self.auth_header not in self.custom_headers:
+                # Strip Bearer prefix if present
+                if self.auth_token.startswith(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} "):
+                    return self.auth_token[len(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} ") :]
+                return self.auth_token
+        return None
 
     def resolve_environment_variables(self, environment_variables: Optional[Dict[str, str]] = None) -> None:
         if self.auth_token and super().is_templated_tool_variable(self.auth_token):
@@ -217,9 +229,21 @@ class StreamableHTTPServerConfig(BaseServerConfig):
     custom_headers: Optional[dict[str, str]] = Field(None, description="Custom HTTP headers to include with streamable HTTP requests")
 
     def resolve_token(self) -> Optional[str]:
-        if self.auth_token and self.auth_token.startswith(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} "):
-            return self.auth_token[len(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} ") :]
-        return self.auth_token
+        """
+        Extract token for storage if auth_header/auth_token are provided
+        and not already in custom_headers.
+
+        Returns:
+            The resolved token (without Bearer prefix) if it should be stored separately, None otherwise
+        """
+        if self.auth_token and self.auth_header:
+            # Check if custom_headers already has the auth header
+            if not self.custom_headers or self.auth_header not in self.custom_headers:
+                # Strip Bearer prefix if present
+                if self.auth_token.startswith(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} "):
+                    return self.auth_token[len(f"{MCP_AUTH_TOKEN_BEARER_PREFIX} ") :]
+                return self.auth_token
+        return None
 
     def resolve_environment_variables(self, environment_variables: Optional[Dict[str, str]] = None) -> None:
         if self.auth_token and super().is_templated_tool_variable(self.auth_token):

letta/functions/schema_generator.py

@@ -608,13 +608,58 @@ def generate_tool_schema_for_mcp(
     # Normalise so downstream code can treat it consistently.
     parameters_schema.setdefault("required", [])
 
+    # Process properties to handle anyOf types and make optional fields strict-compatible
+    if "properties" in parameters_schema:
+        for field_name, field_props in parameters_schema["properties"].items():
+            # Handle anyOf types by flattening to type array
+            if "anyOf" in field_props and "type" not in field_props:
+                types = []
+                format_value = None
+                for option in field_props["anyOf"]:
+                    if "type" in option:
+                        types.append(option["type"])
+                        # Capture format if present (e.g., uuid format for strings)
+                        if "format" in option and not format_value:
+                            format_value = option["format"]
+                if types:
+                    # Deduplicate types using set
+                    field_props["type"] = list(set(types))
+                    # Only add format if the field is not optional (doesn't have null type)
+                    if format_value and len(field_props["type"]) == 1 and "null" not in field_props["type"]:
+                        field_props["format"] = format_value
+                    # Remove the anyOf since we've flattened it
+                    del field_props["anyOf"]
+
+            # For strict mode: heal optional fields by making them required with null type
+            if strict and field_name not in parameters_schema["required"]:
+                # Field is optional - add it to required array
+                parameters_schema["required"].append(field_name)
+
+                # Ensure the field can accept null to maintain optionality
+                if "type" in field_props:
+                    if isinstance(field_props["type"], list):
+                        # Already an array of types - add null if not present
+                        if "null" not in field_props["type"]:
+                            field_props["type"].append("null")
+                        # Deduplicate
+                        field_props["type"] = list(set(field_props["type"]))
+                    elif field_props["type"] != "null":
+                        # Single type - convert to array with null
+                        field_props["type"] = list(set([field_props["type"], "null"]))
+                elif "anyOf" in field_props:
+                    # If there's still an anyOf, ensure null is one of the options
+                    has_null = any(opt.get("type") == "null" for opt in field_props["anyOf"])
+                    if not has_null:
+                        field_props["anyOf"].append({"type": "null"})
+
     # Add the optional heartbeat parameter
     if append_heartbeat:
         parameters_schema["properties"][REQUEST_HEARTBEAT_PARAM] = {
             "type": "boolean",
             "description": REQUEST_HEARTBEAT_DESCRIPTION,
         }
-        parameters_schema["required"].append(REQUEST_HEARTBEAT_PARAM)
+        if REQUEST_HEARTBEAT_PARAM not in parameters_schema["required"]:
+            parameters_schema["required"].append(REQUEST_HEARTBEAT_PARAM)
 
     # Return the final schema
     if strict:

letta/functions/schema_validator.py

@@ -116,15 +116,21 @@ def validate_complete_json_schema(schema: Dict[str, Any]) -> Tuple[SchemaHealth,
 
             required = node.get("required")
             if required is None:
+                # TODO: @jnjpng skip this check for now, seems like OpenAI strict mode doesn't enforce this
                 # Only mark as non-strict for nested objects, not root
-                if not is_root:
-                    mark_non_strict(f"{path}: 'required' not specified for object")
+                # if not is_root:
+                #     mark_non_strict(f"{path}: 'required' not specified for object")
                 required = []
             elif not isinstance(required, list):
                 mark_invalid(f"{path}: 'required' must be a list if present")
                 required = []
 
             # OpenAI strict-mode extra checks:
+            # NOTE: We no longer flag properties not in required array as non-strict
+            # because we can heal these schemas by adding null to the type union
+            # This allows MCP tools with optional fields to be used with strict mode
+            # The healing happens in generate_tool_schema_for_mcp() when strict=True
+
             for req_key in required:
                 if props and req_key not in props:
                     mark_invalid(f"{path}: required contains '{req_key}' not found in properties")
@@ -161,6 +167,15 @@ def validate_complete_json_schema(schema: Dict[str, Any]) -> Tuple[SchemaHealth,
             # These are generally fine, but check for specific constraints
             pass
 
+        # TYPE ARRAYS (e.g., ["string", "null"] for optional fields)
+        elif isinstance(node_type, list):
+            # Type arrays are allowed in OpenAI strict mode
+            # They represent union types (e.g., string | null)
+            for t in node_type:
+                # TODO: @jnjpng handle enum types?
+                if t not in ["string", "number", "integer", "boolean", "null", "array", "object"]:
+                    mark_invalid(f"{path}: Invalid type '{t}' in type array")
+
         # UNION TYPES
         for kw in ("anyOf", "oneOf", "allOf"):
             if kw in node:

letta/functions/types.py

@@ -11,7 +11,7 @@ class SearchTask(BaseModel):
 class FileOpenRequest(BaseModel):
     file_name: str = Field(description="Name of the file to open")
     offset: Optional[int] = Field(
-        default=None, description="Optional starting line number (1-indexed). If not specified, starts from beginning of file."
+        default=None, description="Optional offset for starting line number (0-indexed). If not specified, starts from beginning of file."
     )
     length: Optional[int] = Field(
         default=None, description="Optional number of lines to view from offset (inclusive). If not specified, views to end of file."

letta/helpers/tool_execution_helper.py

@@ -39,12 +39,10 @@ def enable_strict_mode(tool_schema: Dict[str, Any]) -> Dict[str, Any]:
 
     # Ensure parameters is a valid dictionary
     parameters = schema.get("parameters", {})
-
     if isinstance(parameters, dict) and parameters.get("type") == "object":
         # Set additionalProperties to False
         parameters["additionalProperties"] = False
         schema["parameters"] = parameters
-
     # Remove the metadata fields from the schema
     schema.pop(MCP_TOOL_METADATA_SCHEMA_STATUS, None)
     schema.pop(MCP_TOOL_METADATA_SCHEMA_WARNINGS, None)