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

letta/llm_api/llm_api_tools.py

@@ -9,6 +9,9 @@ import requests
 from letta.constants import CLI_WARNING_PREFIX
 from letta.errors import LettaConfigurationError, RateLimitExceededError
 from letta.llm_api.helpers import unpack_all_inner_thoughts_from_kwargs
+from letta.log import get_logger
+
+logger = get_logger(__name__)
 from letta.llm_api.openai import (
     build_openai_chat_completions_request,
     openai_chat_completions_process_stream,
@@ -95,7 +98,7 @@ def retry_with_exponential_backoff(
 
                     # Sleep for the delay
                     # printd(f"Got a rate limit error ('{http_err}') on LLM backend request, waiting {int(delay)}s then retrying...")
-                    print(
+                    logger.warning(
                         f"{CLI_WARNING_PREFIX}Got a rate limit error ('{http_err}') on LLM backend request, waiting {int(delay)}s then retrying..."
                     )
                     time.sleep(delay)

letta/llm_api/openai.py

@@ -1,4 +1,3 @@
-import warnings
 from typing import Generator, List, Optional, Union
 
 import httpx
@@ -70,9 +69,10 @@ def openai_get_model_list(url: str, api_key: Optional[str] = None, fix_url: bool
     # In Letta config the address for vLLM is w/o a /v1 suffix for simplicity
     # However if we're treating the server as an OpenAI proxy we want the /v1 suffix on our model hit
 
-    import warnings
-
-    warnings.warn("The synchronous version of openai_get_model_list function is deprecated. Use the async one instead.", DeprecationWarning)
+    logger.warning(
+        "The synchronous version of openai_get_model_list function is deprecated. Use the async one instead.",
+        stacklevel=2,
+    )
 
     if fix_url:
         if not url.endswith("/v1"):
@@ -224,7 +224,7 @@ def build_openai_chat_completions_request(
     if llm_config.model:
         model = llm_config.model
     else:
-        warnings.warn(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
+        logger.warning(f"Model type not set in llm_config: {llm_config.model_dump_json(indent=4)}")
         model = None
 
     if use_tool_naming:
@@ -285,7 +285,7 @@ def build_openai_chat_completions_request(
                     structured_output_version = convert_to_structured_output(tool.function.model_dump())
                     tool.function = FunctionSchema(**structured_output_version)
                 except ValueError as e:
-                    warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
+                    logger.warning(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
     return data
 
 
@@ -377,7 +377,7 @@ def openai_chat_completions_process_stream(
         ):
             assert isinstance(chat_completion_chunk, ChatCompletionChunkResponse), type(chat_completion_chunk)
             if chat_completion_chunk.choices is None or len(chat_completion_chunk.choices) == 0:
-                warnings.warn(f"No choices in chunk: {chat_completion_chunk}")
+                logger.warning(f"No choices in chunk: {chat_completion_chunk}")
                 continue
 
             # NOTE: this assumes that the tool call ID will only appear in one of the chunks during the stream
@@ -472,7 +472,7 @@ def openai_chat_completions_process_stream(
                             try:
                                 accum_message.tool_calls[tool_call_delta.index].id = tool_call_delta.id
                             except IndexError:
-                                warnings.warn(
+                                logger.warning(
                                     f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
                                 )
                                 # force index 0
@@ -486,14 +486,14 @@ def openai_chat_completions_process_stream(
                                         tool_call_delta.index
                                     ].function.name += tool_call_delta.function.name  # TODO check for parallel tool calls
                                 except IndexError:
-                                    warnings.warn(
+                                    logger.warning(
                                         f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
                                     )
                             if tool_call_delta.function.arguments is not None:
                                 try:
                                     accum_message.tool_calls[tool_call_delta.index].function.arguments += tool_call_delta.function.arguments
                                 except IndexError:
-                                    warnings.warn(
+                                    logger.warning(
                                         f"Tool call index out of range ({tool_call_delta.index})\ncurrent tool calls: {accum_message.tool_calls}\ncurrent delta: {tool_call_delta}"
                                     )
 
@@ -578,7 +578,7 @@ def openai_chat_completions_request_stream(
             # TODO: Use the native OpenAI objects here?
             yield ChatCompletionChunkResponse(**chunk.model_dump(exclude_none=True))
     except Exception as e:
-        print(f"Error request stream from /v1/chat/completions, url={url}, data={data}:\n{e}")
+        logger.error(f"Error request stream from /v1/chat/completions, url={url}, data={data}: {e}")
         raise e
 
 
@@ -642,7 +642,7 @@ def prepare_openai_payload(chat_completion_request: ChatCompletionRequest):
     #         try:
     #             tool["function"] = convert_to_structured_output(tool["function"])
     #         except ValueError as e:
-    #             warnings.warn(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
+    #             logger.warning(f"Failed to convert tool function to structured output, tool={tool}, error={e}")
 
     if not supports_parallel_tool_calling(chat_completion_request.model):
         data.pop("parallel_tool_calls", None)

letta/llm_api/openai_client.py

@@ -649,6 +649,24 @@ class OpenAIClient(LLMClientBase):
         # We just need to instantiate the Pydantic model for validation and type safety.
         chat_completion_response = ChatCompletionResponse(**response_data)
         chat_completion_response = self._fix_truncated_json_response(chat_completion_response)
+
+        # Parse reasoning_content from vLLM/OpenRouter/OpenAI proxies that return this field
+        # This handles cases where the proxy returns .reasoning_content in the response
+        if (
+            chat_completion_response.choices
+            and len(chat_completion_response.choices) > 0
+            and chat_completion_response.choices[0].message
+            and not chat_completion_response.choices[0].message.reasoning_content
+        ):
+            if "choices" in response_data and len(response_data["choices"]) > 0:
+                choice_data = response_data["choices"][0]
+                if "message" in choice_data and "reasoning_content" in choice_data["message"]:
+                    reasoning_content = choice_data["message"]["reasoning_content"]
+                    if reasoning_content:
+                        chat_completion_response.choices[0].message.reasoning_content = reasoning_content
+
+                        chat_completion_response.choices[0].message.reasoning_content_signature = None
+
         # Unpack inner thoughts if they were embedded in function arguments
         if llm_config.put_inner_thoughts_in_kwargs:
             chat_completion_response = unpack_all_inner_thoughts_from_kwargs(
@@ -696,7 +714,13 @@ class OpenAIClient(LLMClientBase):
 
     @trace_method
     async def request_embeddings(self, inputs: List[str], embedding_config: EmbeddingConfig) -> List[List[float]]:
-        """Request embeddings given texts and embedding config with chunking and retry logic"""
+        """Request embeddings given texts and embedding config with chunking and retry logic
+
+        Retry strategy prioritizes reducing batch size before chunk size to maintain retrieval quality:
+        1. Start with batch_size=2048 (texts per request)
+        2. On failure, halve batch_size until it reaches 1
+        3. Only then start reducing chunk_size (for very large individual texts)
+        """
         if not inputs:
             return []
 
@@ -705,35 +729,48 @@ class OpenAIClient(LLMClientBase):
 
         # track results by original index to maintain order
         results = [None] * len(inputs)
-
-        # queue of (start_idx, chunk_inputs) to process
-        chunks_to_process = [(i, inputs[i : i + 2048]) for i in range(0, len(inputs), 2048)]
-
-        min_chunk_size = 256
+        initial_batch_size = 2048
+        chunks_to_process = [(i, inputs[i : i + initial_batch_size], initial_batch_size) for i in range(0, len(inputs), initial_batch_size)]
+        min_chunk_size = 128
 
         while chunks_to_process:
             tasks = []
             task_metadata = []
 
-            for start_idx, chunk_inputs in chunks_to_process:
+            for start_idx, chunk_inputs, current_batch_size in chunks_to_process:
                 task = client.embeddings.create(model=embedding_config.embedding_model, input=chunk_inputs)
                 tasks.append(task)
-                task_metadata.append((start_idx, chunk_inputs))
+                task_metadata.append((start_idx, chunk_inputs, current_batch_size))
 
             task_results = await asyncio.gather(*tasks, return_exceptions=True)
 
             failed_chunks = []
-            for (start_idx, chunk_inputs), result in zip(task_metadata, task_results):
+            for (start_idx, chunk_inputs, current_batch_size), result in zip(task_metadata, task_results):
                 if isinstance(result, Exception):
-                    # check if we can retry with smaller chunks
-                    if len(chunk_inputs) > min_chunk_size:
-                        # split chunk in half and queue for retry
+                    current_size = len(chunk_inputs)
+
+                    if current_batch_size > 1:
+                        new_batch_size = max(1, current_batch_size // 2)
+                        logger.warning(
+                            f"Embeddings request failed for batch starting at {start_idx} with size {current_size}. "
+                            f"Reducing batch size from {current_batch_size} to {new_batch_size} and retrying."
+                        )
                         mid = len(chunk_inputs) // 2
-                        failed_chunks.append((start_idx, chunk_inputs[:mid]))
-                        failed_chunks.append((start_idx + mid, chunk_inputs[mid:]))
+                        failed_chunks.append((start_idx, chunk_inputs[:mid], new_batch_size))
+                        failed_chunks.append((start_idx + mid, chunk_inputs[mid:], new_batch_size))
+                    elif current_size > min_chunk_size:
+                        logger.warning(
+                            f"Embeddings request failed for single item at {start_idx} with size {current_size}. "
+                            f"Splitting individual text content and retrying."
+                        )
+                        mid = len(chunk_inputs) // 2
+                        failed_chunks.append((start_idx, chunk_inputs[:mid], 1))
+                        failed_chunks.append((start_idx + mid, chunk_inputs[mid:], 1))
                     else:
-                        # can't split further, re-raise the error
-                        logger.error(f"Failed to get embeddings for chunk starting at {start_idx} even with minimum size {min_chunk_size}")
+                        logger.error(
+                            f"Failed to get embeddings for chunk starting at {start_idx} even with batch_size=1 "
+                            f"and minimum chunk size {min_chunk_size}. Error: {result}"
+                        )
                         raise result
                 else:
                     embeddings = [r.embedding for r in result.data]

letta/local_llm/constants.py

@@ -1,9 +1,10 @@
+# Import constants from settings to avoid circular import
+# (settings.py imports from this module indirectly through log.py)
+# Import this here to avoid circular dependency at module level
 from letta.local_llm.llm_chat_completion_wrappers.chatml import ChatMLInnerMonologueWrapper
+from letta.settings import DEFAULT_WRAPPER_NAME, INNER_THOUGHTS_KWARG
 
 DEFAULT_WRAPPER = ChatMLInnerMonologueWrapper
-DEFAULT_WRAPPER_NAME = "chatml"
-
-INNER_THOUGHTS_KWARG = "thinking"
 INNER_THOUGHTS_KWARG_VERTEX = "thinking"
 VALID_INNER_THOUGHTS_KWARGS = ("thinking", "inner_thoughts")
 INNER_THOUGHTS_KWARG_DESCRIPTION = "Deep inner monologue private to you only."

letta/local_llm/json_parser.py

@@ -1,6 +1,9 @@
 import json
 import re
-import warnings
+
+from letta.log import get_logger
+
+logger = get_logger(__name__)
 
 from letta.errors import LLMJSONParsingError
 from letta.helpers.json_helpers import json_loads
@@ -83,7 +86,7 @@ def clean_and_interpret_send_message_json(json_string):
 
     kwarg = model_settings.inner_thoughts_kwarg
     if kwarg not in VALID_INNER_THOUGHTS_KWARGS:
-        warnings.warn(f"INNER_THOUGHTS_KWARG is not valid: {kwarg}")
+        logger.warning(f"INNER_THOUGHTS_KWARG is not valid: {kwarg}")
         kwarg = INNER_THOUGHTS_KWARG
 
     # If normal parsing fails, attempt to clean and extract manually

letta/local_llm/utils.py

@@ -1,5 +1,4 @@
 import os
-import warnings
 from typing import List, Union
 
 import requests
@@ -84,11 +83,11 @@ def num_tokens_from_functions(functions: List[dict], model: str = "gpt-4"):
         function_tokens = len(encoding.encode(function["name"]))
         if function["description"]:
             if not isinstance(function["description"], str):
-                warnings.warn(f"Function {function['name']} has non-string description: {function['description']}")
+                logger.warning(f"Function {function['name']} has non-string description: {function['description']}")
             else:
                 function_tokens += len(encoding.encode(function["description"]))
         else:
-            warnings.warn(f"Function {function['name']} has no description, function: {function}")
+            logger.warning(f"Function {function['name']} has no description, function: {function}")
 
         if "parameters" in function:
             parameters = function["parameters"]

letta/log.py

@@ -1,14 +1,136 @@
+import json
 import logging
+import traceback
+from datetime import datetime, timezone
 from logging.config import dictConfig
 from pathlib import Path
 from sys import stdout
-from typing import Optional
+from typing import Any, Optional
 
-from letta.settings import settings
+from letta.settings import log_settings, settings, telemetry_settings
 
 selected_log_level = logging.DEBUG if settings.debug else logging.INFO
 
 
+class JSONFormatter(logging.Formatter):
+    """
+    Custom JSON formatter for structured logging with Datadog integration.
+
+    Outputs logs in JSON format with fields compatible with Datadog log ingestion.
+    Automatically includes trace correlation fields when Datadog tracing is enabled.
+
+    Usage:
+        Enable JSON logging by setting the environment variable:
+            LETTA_LOGGING_JSON_LOGGING=true
+
+        Add custom structured fields to logs using the 'extra' parameter:
+            logger.info("User action", extra={"user_id": "123", "action": "login"})
+
+        These fields will be automatically included in the JSON output and
+        indexed by Datadog for filtering and analysis.
+
+    Output format:
+        {
+            "timestamp": "2025-10-23T18:34:24.931739+00:00",
+            "level": "INFO",
+            "logger": "Letta.module",
+            "message": "Log message",
+            "module": "module_name",
+            "function": "function_name",
+            "line": 123,
+            "dd.trace_id": "1234567890",  # Added when Datadog tracing is enabled
+            "dd.span_id": "9876543210",   # Added when Datadog tracing is enabled
+            "custom_field": "custom_value" # Any extra fields you provide
+        }
+    """
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format log record as JSON with Datadog-compatible fields."""
+        # Base log structure
+        log_data: dict[str, Any] = {
+            "timestamp": datetime.fromtimestamp(record.created, tz=timezone.utc).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "module": record.module,
+            "function": record.funcName,
+            "line": record.lineno,
+        }
+
+        # Add Datadog trace correlation if available
+        # ddtrace automatically injects these attributes when logging is patched
+        if hasattr(record, "dd.trace_id"):
+            log_data["dd.trace_id"] = getattr(record, "dd.trace_id")
+        if hasattr(record, "dd.span_id"):
+            log_data["dd.span_id"] = getattr(record, "dd.span_id")
+        if hasattr(record, "dd.service"):
+            log_data["dd.service"] = getattr(record, "dd.service")
+        if hasattr(record, "dd.env"):
+            log_data["dd.env"] = getattr(record, "dd.env")
+        if hasattr(record, "dd.version"):
+            log_data["dd.version"] = getattr(record, "dd.version")
+
+        # Add exception info if present
+        if record.exc_info:
+            log_data["exception"] = {
+                "type": record.exc_info[0].__name__ if record.exc_info[0] else None,
+                "message": str(record.exc_info[1]) if record.exc_info[1] else None,
+                "stacktrace": "".join(traceback.format_exception(*record.exc_info)),
+            }
+
+        # Add any extra fields from the log record
+        # These are custom fields passed via logging.info("msg", extra={...})
+        for key, value in record.__dict__.items():
+            if key not in [
+                "name",
+                "msg",
+                "args",
+                "created",
+                "filename",
+                "funcName",
+                "levelname",
+                "levelno",
+                "lineno",
+                "module",
+                "msecs",
+                "message",
+                "pathname",
+                "process",
+                "processName",
+                "relativeCreated",
+                "thread",
+                "threadName",
+                "exc_info",
+                "exc_text",
+                "stack_info",
+                "dd_env",
+                "dd_service",
+            ] and not key.startswith("dd."):
+                log_data[key] = value
+
+        return json.dumps(log_data, default=str)
+
+
+class DatadogEnvFilter(logging.Filter):
+    """
+    Logging filter that adds Datadog-specific attributes to log records.
+
+    This enables log-trace correlation by injecting environment and service metadata
+    that Datadog can use to link logs with traces and other telemetry data.
+    """
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Add Datadog attributes to log record if Datadog is enabled."""
+        if telemetry_settings.enable_datadog:
+            record.dd_env = telemetry_settings.datadog_env
+            record.dd_service = "letta-server"
+        else:
+            # Provide defaults to prevent attribute errors if filter is applied incorrectly
+            record.dd_env = ""
+            record.dd_service = ""
+        return True
+
+
 def _setup_logfile() -> "Path":
     """ensure the logger filepath is in place
 
@@ -20,28 +142,65 @@ def _setup_logfile() -> "Path":
     return logfile
 
 
-# TODO: production logging should be much less invasive
+# Determine which formatter to use based on configuration
+def _get_console_formatter() -> str:
+    """Determine the appropriate console formatter based on settings."""
+    if log_settings.json_logging:
+        return "json"
+    elif telemetry_settings.enable_datadog:
+        return "datadog"
+    else:
+        return "no_datetime"
+
+
+def _get_file_formatter() -> str:
+    """Determine the appropriate file formatter based on settings."""
+    if log_settings.json_logging:
+        return "json"
+    elif telemetry_settings.enable_datadog:
+        return "datadog"
+    else:
+        return "standard"
+
+
+# Logging configuration with optional Datadog integration and JSON support
 DEVELOPMENT_LOGGING = {
     "version": 1,
     "disable_existing_loggers": False,  # Allow capturing from all loggers
     "formatters": {
         "standard": {"format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"},
         "no_datetime": {"format": "%(name)s - %(levelname)s - %(message)s"},
+        "datadog": {
+            # Datadog-compatible format with key=value pairs for better parsing
+            # ddtrace's log injection will add dd.trace_id, dd.span_id automatically when logging is patched
+            "format": "%(asctime)s - %(name)s - %(levelname)s - [dd.env=%(dd_env)s dd.service=%(dd_service)s] - %(message)s"
+        },
+        "json": {
+            # JSON formatter for structured logging with full Datadog integration
+            "()": JSONFormatter,
+        },
+    },
+    "filters": {
+        "datadog_env": {
+            "()": DatadogEnvFilter,
+        },
     },
     "handlers": {
         "console": {
             "level": selected_log_level,
             "class": "logging.StreamHandler",
             "stream": stdout,
-            "formatter": "no_datetime",
+            "formatter": _get_console_formatter(),
+            "filters": ["datadog_env"] if telemetry_settings.enable_datadog and not log_settings.json_logging else [],
         },
         "file": {
             "level": "DEBUG",
             "class": "logging.handlers.RotatingFileHandler",
             "filename": _setup_logfile(),
-            "maxBytes": 1024**2 * 10,
-            "backupCount": 3,
-            "formatter": "standard",
+            "maxBytes": 1024**2 * 10,  # 10 MB per file
+            "backupCount": 3,  # Keep 3 backup files
+            "formatter": _get_file_formatter(),
+            "filters": ["datadog_env"] if telemetry_settings.enable_datadog and not log_settings.json_logging else [],
         },
     },
     "root": {  # Root logger handles all logs
@@ -58,6 +217,11 @@ DEVELOPMENT_LOGGING = {
             "handlers": ["console"],
             "propagate": True,
         },
+        # Reduce noise from ddtrace internal logging
+        "ddtrace": {
+            "level": "WARNING",
+            "propagate": True,
+        },
     },
 }
 

letta/orm/agent.py

@@ -241,7 +241,9 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             "tools": [],
             "sources": [],
             "memory": Memory(blocks=[]),
+            "blocks": [],
             "identity_ids": [],
+            "identities": [],
             "multi_agent_group": None,
             "tool_exec_environment_variables": [],
             "secrets": [],
@@ -262,8 +264,11 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
                 ],
                 agent_type=self.agent_type,
             ),
+            "blocks": lambda: [b.to_pydantic() for b in self.core_memory],
             "identity_ids": lambda: [i.id for i in self.identities],
+            "identities": lambda: [i.to_pydantic() for i in self.identities],  # TODO: fix this
             "multi_agent_group": lambda: self.multi_agent_group,
+            "managed_group": lambda: self.multi_agent_group,
             "tool_exec_environment_variables": lambda: self.tool_exec_environment_variables,
             "secrets": lambda: self.tool_exec_environment_variables,
         }
@@ -277,7 +282,11 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
 
         return self.__pydantic_model__(**state)
 
-    async def to_pydantic_async(self, include_relationships: Optional[Set[str]] = None) -> PydanticAgentState:
+    async def to_pydantic_async(
+        self,
+        include_relationships: Optional[Set[str]] = None,
+        include: Optional[List[str]] = None,
+    ) -> PydanticAgentState:
         """
         Converts the SQLAlchemy Agent model into its Pydantic counterpart.
 
@@ -334,8 +343,11 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             "tools": [],
             "sources": [],
             "memory": Memory(blocks=[]),
+            "blocks": [],
             "identity_ids": [],
+            "identities": [],
             "multi_agent_group": None,
+            "managed_group": None,
             "tool_exec_environment_variables": [],
             "secrets": [],
         }
@@ -343,6 +355,9 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
         # Initialize include_relationships to an empty set if it's None
         include_relationships = set(optional_fields.keys() if include_relationships is None else include_relationships)
 
+        # Convert include list to set for efficient membership checks
+        include_set = set(include) if include else set()
+
         async def empty_list_async():
             return []
 
@@ -350,18 +365,34 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             return None
 
         # Only load requested relationships
-        tags = self.awaitable_attrs.tags if "tags" in include_relationships else empty_list_async()
-        tools = self.awaitable_attrs.tools if "tools" in include_relationships else empty_list_async()
-        sources = self.awaitable_attrs.sources if "sources" in include_relationships else empty_list_async()
-        memory = self.awaitable_attrs.core_memory if "memory" in include_relationships else empty_list_async()
-        identities = self.awaitable_attrs.identities if "identity_ids" in include_relationships else empty_list_async()
-        multi_agent_group = self.awaitable_attrs.multi_agent_group if "multi_agent_group" in include_relationships else none_async()
+        tags = self.awaitable_attrs.tags if "tags" in include_relationships or "agent.tags" in include_set else empty_list_async()
+        tools = self.awaitable_attrs.tools if "tools" in include_relationships or "agent.tools" in include_set else empty_list_async()
+        sources = (
+            self.awaitable_attrs.sources if "sources" in include_relationships or "agent.sources" in include_set else empty_list_async()
+        )
+        memory = (
+            self.awaitable_attrs.core_memory if "memory" in include_relationships or "agent.blocks" in include_set else empty_list_async()
+        )
+        identities = (
+            self.awaitable_attrs.identities
+            if "identity_ids" in include_relationships or "agent.identities" in include_set
+            else empty_list_async()
+        )
+        multi_agent_group = (
+            self.awaitable_attrs.multi_agent_group
+            if "multi_agent_group" in include_relationships or "agent.managed_group" in include_set
+            else none_async()
+        )
         tool_exec_environment_variables = (
             self.awaitable_attrs.tool_exec_environment_variables
-            if "tool_exec_environment_variables" in include_relationships or "secrets" in include_relationships
+            if "tool_exec_environment_variables" in include_relationships
+            or "secrets" in include_relationships
+            or "agent.secrets" in include_set
             else empty_list_async()
         )
-        file_agents = self.awaitable_attrs.file_agents if "memory" in include_relationships else empty_list_async()
+        file_agents = (
+            self.awaitable_attrs.file_agents if "memory" in include_relationships or "agent.blocks" in include_set else empty_list_async()
+        )
 
         (tags, tools, sources, memory, identities, multi_agent_group, tool_exec_environment_variables, file_agents) = await asyncio.gather(
             tags, tools, sources, memory, identities, multi_agent_group, tool_exec_environment_variables, file_agents
@@ -379,8 +410,11 @@ class Agent(SqlalchemyBase, OrganizationMixin, ProjectMixin, TemplateEntityMixin
             ],
             agent_type=self.agent_type,
         )
+        state["blocks"] = [m.to_pydantic() for m in memory]
         state["identity_ids"] = [i.id for i in identities]
+        state["identities"] = [i.to_pydantic() for i in identities]
         state["multi_agent_group"] = multi_agent_group
+        state["managed_group"] = multi_agent_group
         state["tool_exec_environment_variables"] = tool_exec_environment_variables
         state["secrets"] = tool_exec_environment_variables
 

letta/orm/archive.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, List, Optional
 from sqlalchemy import JSON, Enum, Index, String
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
+from letta.orm.custom_columns import EmbeddingConfigColumn
 from letta.orm.mixins import OrganizationMixin
 from letta.orm.sqlalchemy_base import SqlalchemyBase
 from letta.schemas.archive import Archive as PydanticArchive
@@ -45,6 +46,9 @@ class Archive(SqlalchemyBase, OrganizationMixin):
         default=VectorDBProvider.NATIVE,
         doc="The vector database provider used for this archive's passages",
     )
+    embedding_config: Mapped[dict] = mapped_column(
+        EmbeddingConfigColumn, nullable=False, doc="Embedding configuration for passages in this archive"
+    )
     metadata_: Mapped[Optional[dict]] = mapped_column(JSON, nullable=True, doc="Additional metadata for the archive")
     _vector_db_namespace: Mapped[Optional[str]] = mapped_column(String, nullable=True, doc="Private field for vector database namespace")
 

letta/orm/custom_columns.py

@@ -3,6 +3,7 @@ from sqlalchemy.types import BINARY, TypeDecorator
 
 from letta.helpers.converters import (
     deserialize_agent_step_state,
+    deserialize_approvals,
     deserialize_batch_request_result,
     deserialize_create_batch_response,
     deserialize_embedding_config,
@@ -16,6 +17,7 @@ from letta.helpers.converters import (
     deserialize_tool_rules,
     deserialize_vector,
     serialize_agent_step_state,
+    serialize_approvals,
     serialize_batch_request_result,
     serialize_create_batch_response,
     serialize_embedding_config,
@@ -96,6 +98,19 @@ class ToolReturnColumn(TypeDecorator):
         return deserialize_tool_returns(value)
 
 
+class ApprovalsColumn(TypeDecorator):
+    """Custom SQLAlchemy column type for storing the approval responses of a tool call request as JSON."""
+
+    impl = JSON
+    cache_ok = True
+
+    def process_bind_param(self, value, dialect):
+        return serialize_approvals(value)
+
+    def process_result_value(self, value, dialect):
+        return deserialize_approvals(value)
+
+
 class MessageContentColumn(TypeDecorator):
     """Custom SQLAlchemy column type for storing the content parts of a message as JSON."""