letta-nightly 0.12.1.dev20251023104211__py3-none-any.whl → 0.13.0.dev20251024223017__py3-none-any.whl

letta/agents/voice_agent.py

@@ -36,9 +36,9 @@ from letta.server.rest_api.utils import (
 )
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
+from letta.services.run_manager import RunManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.summarizer.summarizer import Summarizer
 from letta.services.tool_executor.tool_execution_manager import ToolExecutionManager
@@ -63,7 +63,7 @@ class VoiceAgent(BaseAgent):
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
-        job_manager: JobManager,
+        run_manager: RunManager,
         passage_manager: PassageManager,
         actor: User,
     ):
@@ -73,7 +73,7 @@ class VoiceAgent(BaseAgent):
 
         # Summarizer settings
         self.block_manager = block_manager
-        self.job_manager = job_manager
+        self.run_manager = run_manager
         self.passage_manager = passage_manager
         # TODO: This is not guaranteed to exist!
         self.summary_block_label = "human"
@@ -99,7 +99,7 @@ class VoiceAgent(BaseAgent):
                 agent_manager=self.agent_manager,
                 actor=self.actor,
                 block_manager=self.block_manager,
-                job_manager=self.job_manager,
+                run_manager=self.run_manager,
                 passage_manager=self.passage_manager,
                 target_block_label=self.summary_block_label,
             ),
@@ -153,6 +153,7 @@ class VoiceAgent(BaseAgent):
             archival_memory_size=self.num_archival_memories,
             sources=agent_state.sources,
             max_files_open=agent_state.max_files_open,
+            llm_config=agent_state.llm_config,
         )
         letta_message_db_queue = create_input_messages(
             input_messages=input_messages, agent_id=agent_state.id, timezone=agent_state.timezone, actor=self.actor
@@ -437,13 +438,14 @@ class VoiceAgent(BaseAgent):
             )
 
         # Use ToolExecutionManager for modern tool execution
-        sandbox_env_vars = {var.key: var.value for var in agent_state.secrets}
+        # Decrypt environment variable values
+        sandbox_env_vars = {var.key: var.get_value_secret().get_plaintext() for var in agent_state.secrets}
         tool_execution_manager = ToolExecutionManager(
             agent_state=agent_state,
             message_manager=self.message_manager,
             agent_manager=self.agent_manager,
             block_manager=self.block_manager,
-            job_manager=self.job_manager,
+            run_manager=self.run_manager,
             passage_manager=self.passage_manager,
             sandbox_env_vars=sandbox_env_vars,
             actor=self.actor,

letta/agents/voice_sleeptime_agent.py

@@ -14,9 +14,9 @@ from letta.schemas.tool_rule import ChildToolRule, ContinueToolRule, InitToolRul
 from letta.schemas.user import User
 from letta.services.agent_manager import AgentManager
 from letta.services.block_manager import BlockManager
-from letta.services.job_manager import JobManager
 from letta.services.message_manager import MessageManager
 from letta.services.passage_manager import PassageManager
+from letta.services.run_manager import RunManager
 from letta.services.summarizer.enums import SummarizationMode
 from letta.services.summarizer.summarizer import Summarizer
 from letta.types import JsonDict
@@ -34,7 +34,7 @@ class VoiceSleeptimeAgent(LettaAgent):
         message_manager: MessageManager,
         agent_manager: AgentManager,
         block_manager: BlockManager,
-        job_manager: JobManager,
+        run_manager: RunManager,
         passage_manager: PassageManager,
         target_block_label: str,
         actor: User,
@@ -44,7 +44,7 @@ class VoiceSleeptimeAgent(LettaAgent):
             message_manager=message_manager,
             agent_manager=agent_manager,
             block_manager=block_manager,
-            job_manager=job_manager,
+            job_manager=run_manager,
             passage_manager=passage_manager,
             actor=actor,
         )

letta/constants.py

@@ -33,8 +33,6 @@ LETTA_TOOL_MODULE_NAMES = [
 DEFAULT_ORG_ID = "org-00000000-0000-4000-8000-000000000000"
 DEFAULT_ORG_NAME = "default_org"
 
-AGENT_ID_PATTERN = re.compile(r"^agent-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$", re.IGNORECASE)
-
 # String in the error message for when the context window is too large
 # Example full message:
 # This model's maximum context length is 8192 tokens. However, your messages resulted in 8198 tokens (7450 in the messages, 748 in the functions). Please reduce the length of the messages or functions.
@@ -127,10 +125,10 @@ LOCAL_ONLY_MULTI_AGENT_TOOLS = ["send_message_to_agent_async"]
 
 # Used to catch if line numbers are pushed in
 # MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(r"^Line \d+: ", re.MULTILINE)
-# More "robust" version that handles different kinds of whitespace
+# Updated to match new arrow format: "1→ content"
 # shared constant for both memory_insert and memory_replace
 MEMORY_TOOLS_LINE_NUMBER_PREFIX_REGEX = re.compile(
-    r"^[ \t]*Line[ \t]+\d+[ \t]*:",  # allow any leading whitespace and flexible spacing
+    r"^[ \t]*\d+→[ \t]*",  # match number followed by arrow, with optional whitespace
     re.MULTILINE,
 )
 
@@ -157,6 +155,16 @@ LETTA_TOOL_SET = set(
     + FILES_TOOLS
 )
 
+LETTA_PARALLEL_SAFE_TOOLS = {
+    "conversation_search",
+    "archival_memory_search",
+    "run_code",
+    "web_search",
+    "fetch_webpage",
+    "grep_files",
+    "semantic_search_files",
+}
+
 
 def FUNCTION_RETURN_VALUE_TRUNCATED(return_str, return_char: int, return_char_limit: int):
     return (
@@ -202,9 +210,7 @@ ERROR_MESSAGE_PREFIX = "Error"
 
 NON_USER_MSG_PREFIX = "[This is an automated system message hidden from the user] "
 
-CORE_MEMORY_LINE_NUMBER_WARNING = (
-    "# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls."
-)
+CORE_MEMORY_LINE_NUMBER_WARNING = "# NOTE: Line numbers shown below (with arrows like '1→') are to help during editing. Do NOT include line number prefixes in your memory edit tool calls."
 
 
 # Constants to do with summarization / conversation length window
@@ -318,6 +324,23 @@ LLM_MAX_TOKENS = {
     "gemini-2.0-flash-thinking-exp-1219": 1048576,
     "gemini-2.5-flash-preview-tts": 32768,
     "gemini-2.5-pro-preview-tts": 65536,
+    # gemini 2.5 stable releases
+    "gemini-2.5-flash": 1048576,
+    "gemini-2.5-flash-lite": 1048576,
+    "gemini-2.5-pro": 1048576,
+    "gemini-2.5-pro-preview-06-05": 1048576,
+    "gemini-2.5-flash-lite-preview-06-17": 1048576,
+    "gemini-2.5-flash-image": 1048576,
+    "gemini-2.5-flash-image-preview": 1048576,
+    "gemini-2.5-flash-preview-09-2025": 1048576,
+    "gemini-2.5-flash-lite-preview-09-2025": 1048576,
+    "gemini-2.5-computer-use-preview-10-2025": 1048576,
+    # gemini latest aliases
+    "gemini-flash-latest": 1048576,
+    "gemini-flash-lite-latest": 1048576,
+    "gemini-pro-latest": 1048576,
+    # gemini specialized models
+    "gemini-robotics-er-1.5-preview": 1048576,
 }
 # The error message that Letta will receive
 # MESSAGE_SUMMARY_WARNING_STR = f"Warning: the conversation history will soon reach its maximum length and be trimmed. Make sure to save any important information from the conversation to your memory before it is removed."

letta/errors.py

@@ -19,6 +19,7 @@ class ErrorCode(Enum):
     RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED"
     TIMEOUT = "TIMEOUT"
     CONFLICT = "CONFLICT"
+    EXPIRED = "EXPIRED"
 
 
 class LettaError(Exception):
@@ -97,6 +98,10 @@ class LettaUserNotFoundError(LettaError):
     """Error raised when a user is not found."""
 
 
+class LettaUnsupportedFileUploadError(LettaError):
+    """Error raised when an unsupported file upload is attempted."""
+
+
 class LettaInvalidArgumentError(LettaError):
     """Error raised when an invalid argument is provided."""
 
@@ -137,10 +142,25 @@ class LettaMCPTimeoutError(LettaMCPError):
         super().__init__(message=message, code=ErrorCode.TIMEOUT, details=details)
 
 
+class LettaServiceUnavailableError(LettaError):
+    """Error raised when a required service is unavailable."""
+
+    def __init__(self, message: str, service_name: Optional[str] = None):
+        details = {"service_name": service_name} if service_name else {}
+        super().__init__(message=message, code=ErrorCode.INTERNAL_SERVER_ERROR, details=details)
+
+
 class LettaUnexpectedStreamCancellationError(LettaError):
     """Error raised when a streaming request is terminated unexpectedly."""
 
 
+class LettaExpiredError(LettaError):
+    """Error raised when a resource has expired."""
+
+    def __init__(self, message: str):
+        super().__init__(message=message, code=ErrorCode.EXPIRED)
+
+
 class LLMError(LettaError):
     pass
 

letta/functions/function_sets/base.py

@@ -294,6 +294,7 @@ SNIPPET_LINES: int = 4
 def memory_replace(agent_state: "AgentState", label: str, old_str: str, new_str: str) -> str:  # type: ignore
     """
     The memory_replace command allows you to replace a specific string in a memory block with a new string. This is used for making precise edits.
+    Do NOT attempt to replace long strings, e.g. do not attempt to replace the entire contents of a memory block with a new string.
 
     Args:
         label (str): Section of the memory to be edited, identified by its label.
@@ -311,10 +312,10 @@ def memory_replace(agent_state: "AgentState", label: str, old_str: str, new_str:
         memory_replace(label="human", old_str="Their name is Alice", new_str="")
 
         # Bad example - do NOT add (view-only) line numbers to the args
-        memory_replace(label="human", old_str="Line 1: Their name is Alice", new_str="Line 1: Their name is Bob")
+        memory_replace(label="human", old_str="1: Their name is Alice", new_str="1: Their name is Bob")
 
-        # Bad example - do NOT include the number number warning either
-        memory_replace(label="human", old_str="# NOTE: Line numbers shown below are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\\nLine 1: Their name is Alice", new_str="Line 1: Their name is Bob")
+        # Bad example - do NOT include the line number warning either
+        memory_replace(label="human", old_str="# NOTE: Line numbers shown below (with arrows like '1→') are to help during editing. Do NOT include line number prefixes in your memory edit tool calls.\\n1→ Their name is Alice", new_str="1→ Their name is Bob")
 
         # Good example - no line numbers or line number warning (they are view-only), just the text
         memory_replace(label="human", old_str="Their name is Alice", new_str="Their name is Bob")
@@ -449,6 +450,57 @@ def memory_insert(agent_state: "AgentState", label: str, new_str: str, insert_li
     return success_msg
 
 
+def memory_apply_patch(agent_state: "AgentState", label: str, patch: str) -> str:  # type: ignore
+    """
+    Apply a unified-diff style patch to a memory block by anchoring on content and context (not line numbers).
+
+    The patch format is a simplified unified diff that supports one or more hunks. Each hunk may optionally
+    start with a line beginning with `@@` and then contains lines that begin with one of:
+    - " " (space): context lines that must match the current memory content
+    - "-": lines to remove (must match exactly in the current content)
+    - "+": lines to add
+
+    Notes:
+    - Do not include line number prefixes like "Line 12:" anywhere in the patch. Line numbers are for display only.
+    - Do not include the line-number warning banner. Provide only the text to edit.
+    - Tabs are normalized to spaces for matching consistency.
+
+    Args:
+        label (str): The memory block to edit, identified by its label.
+        patch (str): The simplified unified-diff patch text composed of context (" "), deletion ("-"), and addition ("+") lines. Optional
+            lines beginning with "@@" can be used to delimit hunks. Do not include visual line numbers or warning banners.
+
+    Examples:
+        Simple replacement:
+            label="human",
+            patch:
+                @@
+                -Their name is Alice
+                +Their name is Bob
+
+        Replacement with surrounding context for disambiguation:
+            label="persona",
+            patch:
+                @@
+                 Persona:
+                -Friendly and curious
+                +Friendly, curious, and precise
+                 Likes: Hiking
+
+        Insertion (no deletions) between two context lines:
+            label="todos",
+            patch:
+                @@
+                 - [ ] Step 1: Gather requirements
+                 + [ ] Step 1.5: Clarify stakeholders
+                 - [ ] Step 2: Draft design
+
+    Returns:
+        str: A success message if the patch applied cleanly; raises ValueError otherwise.
+    """
+    raise NotImplementedError("This should never be invoked directly. Contact Letta if you see this error message.")
+
+
 def memory_rethink(agent_state: "AgentState", label: str, new_memory: str) -> None:
     """
     The memory_rethink command allows you to completely rewrite the contents of a memory block. Use this tool to make large sweeping changes (e.g. when you want to condense or reorganize the memory blocks), do NOT use this tool to make small precise edits (e.g. add or remove a line, replace a specific string, etc).

letta/functions/mcp_client/types.py

@@ -129,9 +129,9 @@ class BaseServerConfig(BaseModel):
         raise NotImplementedError
 
 
-class SSEServerConfig(BaseServerConfig):
+class HTTPBasedServerConfig(BaseServerConfig):
     """
-    Configuration for an MCP server using SSE
+    Base configuration for HTTP-based MCP servers (SSE and Streamable HTTP).
 
     Authentication can be provided in multiple ways:
     1. Using auth_header + auth_token: Will add a specific header with the token
@@ -141,11 +141,10 @@ class SSEServerConfig(BaseServerConfig):
        Example: custom_headers={"X-API-Key": "abc123", "X-Custom-Header": "value"}
     """
 
-    type: MCPServerType = MCPServerType.SSE
-    server_url: str = Field(..., description="The URL of the server (MCP SSE client will connect to this URL)")
+    server_url: str = Field(..., description="The URL of the server")
     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 HTTP headers to include with SSE requests")
+    custom_headers: Optional[dict[str, str]] = Field(None, description="Custom HTTP headers to include with requests")
 
     def resolve_token(self) -> Optional[str]:
         """
@@ -170,13 +169,13 @@ class SSEServerConfig(BaseServerConfig):
 
         self.custom_headers = super().resolve_custom_headers(self.custom_headers, environment_variables)
 
-    def to_dict(self) -> dict:
-        values = {
-            "transport": "sse",
-            "url": self.server_url,
-        }
+    def _build_headers_dict(self) -> Optional[dict[str, str]]:
+        """
+        Build headers dictionary from custom_headers and auth_header/auth_token.
 
-        # TODO: handle custom headers
+        Returns:
+            Dictionary of headers or None if no headers are configured
+        """
         if self.custom_headers is not None or (self.auth_header is not None and self.auth_token is not None):
             headers = self.custom_headers.copy() if self.custom_headers else {}
 
@@ -184,6 +183,24 @@ class SSEServerConfig(BaseServerConfig):
             if self.auth_header is not None and self.auth_token is not None:
                 headers[self.auth_header] = self.auth_token
 
+            return headers
+        return None
+
+
+class SSEServerConfig(HTTPBasedServerConfig):
+    """Configuration for an MCP server using SSE"""
+
+    type: MCPServerType = MCPServerType.SSE
+
+    def to_dict(self) -> dict:
+        values = {
+            "transport": "sse",
+            "url": self.server_url,
+        }
+
+        # Handle custom headers using shared method
+        headers = self._build_headers_dict()
+        if headers:
             values["headers"] = headers
 
         return values
@@ -210,46 +227,10 @@ class StdioServerConfig(BaseServerConfig):
         return values
 
 
-class StreamableHTTPServerConfig(BaseServerConfig):
-    """
-    Configuration for an MCP server using Streamable HTTP
-
-    Authentication can be provided in multiple ways:
-    1. Using auth_header + auth_token: Will add a specific header with the token
-       Example: auth_header="Authorization", auth_token="Bearer abc123"
-
-    2. Using the custom_headers dict: For more complex authentication scenarios
-       Example: custom_headers={"X-API-Key": "abc123", "X-Custom-Header": "value"}
-    """
+class StreamableHTTPServerConfig(HTTPBasedServerConfig):
+    """Configuration for an MCP server using Streamable HTTP"""
 
     type: MCPServerType = MCPServerType.STREAMABLE_HTTP
-    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 HTTP headers to include with streamable HTTP requests")
-
-    def resolve_token(self) -> Optional[str]:
-        """
-        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):
-            self.auth_token = super().get_tool_variable(self.auth_token, environment_variables)
-
-        self.custom_headers = super().resolve_custom_headers(self.custom_headers, environment_variables)
 
     def model_post_init(self, __context) -> None:
         """Validate the server URL format."""
@@ -275,14 +256,9 @@ class StreamableHTTPServerConfig(BaseServerConfig):
             "url": self.server_url,
         }
 
-        # Handle custom headers
-        if self.custom_headers is not None or (self.auth_header is not None and self.auth_token is not None):
-            headers = self.custom_headers.copy() if self.custom_headers else {}
-
-            # Add auth header if specified
-            if self.auth_header is not None and self.auth_token is not None:
-                headers[self.auth_header] = self.auth_token
-
+        # Handle custom headers using shared method
+        headers = self._build_headers_dict()
+        if headers:
             values["headers"] = headers
 
         return values

letta/functions/schema_generator.py

@@ -1,5 +1,4 @@
 import inspect
-import warnings
 from typing import Any, Dict, List, Optional, Tuple, Type, Union, get_args, get_origin
 
 from docstring_parser import parse
@@ -101,7 +100,7 @@ def type_to_json_schema_type(py_type) -> dict:
         args = get_args(py_type)
         if len(args) == 0:
             # is this correct
-            warnings.warn("Defaulting to string type for untyped List")
+            logger.warning("Defaulting to string type for untyped List")
             return {
                 "type": "array",
                 "items": {"type": "string"},
@@ -662,6 +661,16 @@ def normalize_mcp_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
                     # Handle anyOf (complex union types)
                     if "anyOf" in prop_schema:
                         for option in prop_schema["anyOf"]:
+                            # Add explicit type to $ref options for flattening support
+                            if "$ref" in option and "type" not in option:
+                                if defs and option["$ref"].startswith("#/$defs/"):
+                                    def_name = option["$ref"].split("/")[-1]
+                                    if def_name in defs and "type" in defs[def_name]:
+                                        option["type"] = defs[def_name]["type"]
+                                # Default to object if type can't be resolved
+                                if "type" not in option:
+                                    option["type"] = "object"
+                            # Recursively normalize object types
                             if isinstance(option, dict) and option.get("type") == "object":
                                 normalize_object_schema(option, defs)
 
@@ -710,28 +719,131 @@ 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
-    # TODO: de-duplicate with handling in normalize_mcp_schema
+    # Get $defs for $ref resolution
+    defs = parameters_schema.get("$defs", {})
+
+    def deduplicate_anyof(anyof_list):
+        """
+        Deduplicate entries in an anyOf array based on their content.
+
+        Rules:
+        1. Remove exact duplicates (same type, same properties)
+        2. For duplicate types with different metadata (e.g., format):
+           - Keep the most specific version (with format/constraints)
+           - If one has format and others don't, keep only the one with format
+        """
+        if not anyof_list:
+            return anyof_list
+
+        seen = []
+        result = []
+
+        for item in anyof_list:
+            if not isinstance(item, dict):
+                if item not in seen:
+                    seen.append(item)
+                    result.append(item)
+                continue
+
+            # Create a hashable representation for comparison
+            # Sort keys to ensure consistent comparison
+            item_type = item.get("type")
+            item_format = item.get("format")
+
+            # Check if we've seen this exact item
+            is_duplicate = False
+            for existing_idx, existing in enumerate(result):
+                if not isinstance(existing, dict):
+                    continue
+
+                existing_type = existing.get("type")
+                existing_format = existing.get("format")
+
+                # Exact match - skip this item
+                if item == existing:
+                    is_duplicate = True
+                    break
+
+                # Same type with different format handling
+                if item_type and item_type == existing_type:
+                    # Both have same type
+                    if item_format and not existing_format:
+                        # New item has format, existing doesn't - replace existing with new
+                        result[existing_idx] = item
+                        is_duplicate = True
+                        break
+                    elif not item_format and existing_format:
+                        # Existing has format, new doesn't - keep existing, skip new
+                        is_duplicate = True
+                        break
+                    elif item_format == existing_format:
+                        # Same type and format (or both None) - compare full objects
+                        # Prefer the one with more properties/constraints
+                        if len(item) >= len(existing):
+                            result[existing_idx] = item
+                        is_duplicate = True
+                        break
+
+            if not is_duplicate:
+                result.append(item)
+
+        return result
+
+    def inline_ref(schema_node, defs, depth=0, max_depth=10):
+        """
+        Recursively inline all $ref references in a schema node.
+        Returns a new schema with all $refs replaced by their definitions.
+        """
+        if depth > max_depth:
+            return schema_node  # Prevent infinite recursion
+
+        if not isinstance(schema_node, dict):
+            return schema_node
+
+        # Make a copy to avoid modifying the original
+        result = schema_node.copy()
+
+        # If this node has a $ref, resolve it and merge
+        if "$ref" in result:
+            ref_path = result["$ref"]
+            if ref_path.startswith("#/$defs/"):
+                def_name = ref_path.split("/")[-1]
+                if def_name in defs:
+                    # Get the referenced schema
+                    ref_schema = defs[def_name].copy()
+                    # Remove the $ref
+                    del result["$ref"]
+                    # Merge the referenced schema into result
+                    # The referenced schema properties take precedence
+                    for key, value in ref_schema.items():
+                        if key not in result:
+                            result[key] = value
+                    # Recursively inline any $refs in the merged schema
+                    result = inline_ref(result, defs, depth + 1, max_depth)
+
+        # Recursively process nested structures
+        if "anyOf" in result:
+            # Inline refs in each anyOf option
+            result["anyOf"] = [inline_ref(opt, defs, depth + 1, max_depth) for opt in result["anyOf"]]
+            # Deduplicate anyOf entries
+            result["anyOf"] = deduplicate_anyof(result["anyOf"])
+        if "properties" in result and isinstance(result["properties"], dict):
+            result["properties"] = {
+                prop_name: inline_ref(prop_schema, defs, depth + 1, max_depth) for prop_name, prop_schema in result["properties"].items()
+            }
+        if "items" in result:
+            result["items"] = inline_ref(result["items"], defs, depth + 1, max_depth)
+
+        return result
+
+    # Process properties to inline all $refs while keeping anyOf structure
     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(dict.fromkeys(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 field_name in list(parameters_schema["properties"].keys()):
+            field_props = parameters_schema["properties"][field_name]
+
+            # Inline all $refs in this property (recursively)
+            field_props = inline_ref(field_props, defs)
+            parameters_schema["properties"][field_name] = field_props
 
             # For strict mode: heal optional fields by making them required with null type
             if strict and field_name not in parameters_schema["required"]: