letta-nightly 0.11.3.dev20250819104229__py3-none-any.whl → 0.11.4.dev20250820213507__py3-none-any.whl

letta/embeddings.py

@@ -1,13 +1,9 @@
-import uuid
-from typing import Any, List, Optional
+from typing import List
 
-import numpy as np
 import tiktoken
-from openai import OpenAI
 
-from letta.constants import EMBEDDING_TO_TOKENIZER_DEFAULT, EMBEDDING_TO_TOKENIZER_MAP, MAX_EMBEDDING_DIM
-from letta.schemas.embedding_config import EmbeddingConfig
-from letta.utils import is_valid_url, printd
+from letta.constants import EMBEDDING_TO_TOKENIZER_DEFAULT, EMBEDDING_TO_TOKENIZER_MAP
+from letta.utils import printd
 
 
 def parse_and_chunk_text(text: str, chunk_size: int) -> List[str]:
@@ -55,236 +51,3 @@ def check_and_split_text(text: str, embedding_model: str) -> List[str]:
         text = truncate_text(formatted_text, max_length, encoding)
 
     return [text]
-
-
-class EmbeddingEndpoint:
-    """Implementation for OpenAI compatible endpoint"""
-
-    # """ Based off llama index https://github.com/run-llama/llama_index/blob/a98bdb8ecee513dc2e880f56674e7fd157d1dc3a/llama_index/embeddings/text_embeddings_inference.py """
-
-    # _user: str = PrivateAttr()
-    # _timeout: float = PrivateAttr()
-    # _base_url: str = PrivateAttr()
-
-    def __init__(
-        self,
-        model: str,
-        base_url: str,
-        user: str,
-        timeout: float = 60.0,
-        **kwargs: Any,
-    ):
-        if not is_valid_url(base_url):
-            raise ValueError(
-                f"Embeddings endpoint was provided an invalid URL (set to: '{base_url}'). Make sure embedding_endpoint is set correctly in your Letta config."
-            )
-        # TODO: find a neater solution - re-mapping for letta endpoint
-        if model == "letta-free":
-            model = "BAAI/bge-large-en-v1.5"
-        self.model_name = model
-        self._user = user
-        self._base_url = base_url
-        self._timeout = timeout
-
-    def _call_api(self, text: str) -> List[float]:
-        if not is_valid_url(self._base_url):
-            raise ValueError(
-                f"Embeddings endpoint does not have a valid URL (set to: '{self._base_url}'). Make sure embedding_endpoint is set correctly in your Letta config."
-            )
-        import httpx
-
-        headers = {"Content-Type": "application/json"}
-        json_data = {"input": text, "model": self.model_name, "user": self._user}
-
-        with httpx.Client() as client:
-            response = client.post(
-                f"{self._base_url}/embeddings",
-                headers=headers,
-                json=json_data,
-                timeout=self._timeout,
-            )
-
-        response_json = response.json()
-
-        if isinstance(response_json, list):
-            # embedding directly in response
-            embedding = response_json
-        elif isinstance(response_json, dict):
-            # TEI embedding packaged inside openai-style response
-            try:
-                embedding = response_json["data"][0]["embedding"]
-            except (KeyError, IndexError):
-                raise TypeError(f"Got back an unexpected payload from text embedding function, response=\n{response_json}")
-        else:
-            # unknown response, can't parse
-            raise TypeError(f"Got back an unexpected payload from text embedding function, response=\n{response_json}")
-
-        return embedding
-
-    def get_text_embedding(self, text: str) -> List[float]:
-        return self._call_api(text)
-
-
-class AzureOpenAIEmbedding:
-    def __init__(self, api_endpoint: str, api_key: str, api_version: str, model: str):
-        from openai import AzureOpenAI
-
-        self.client = AzureOpenAI(api_key=api_key, api_version=api_version, azure_endpoint=api_endpoint)
-        self.model = model
-
-    def get_text_embedding(self, text: str):
-        embeddings = self.client.embeddings.create(input=[text], model=self.model).data[0].embedding
-        return embeddings
-
-
-class OllamaEmbeddings:
-
-    # Uses OpenAI API standard
-    # Format:
-    # curl http://localhost:11434/v1/embeddings -d '{
-    #   "model": "mxbai-embed-large",
-    #   "input": "Llamas are members of the camelid family"
-    # }'
-
-    def __init__(self, model: str, base_url: str, ollama_additional_kwargs: dict):
-        self.model = model
-        self.base_url = base_url
-        self.ollama_additional_kwargs = ollama_additional_kwargs
-
-    def get_text_embedding(self, text: str):
-        import httpx
-
-        headers = {"Content-Type": "application/json"}
-        json_data = {"model": self.model, "input": text}
-        json_data.update(self.ollama_additional_kwargs)
-
-        with httpx.Client() as client:
-            response = client.post(
-                f"{self.base_url}/embeddings",
-                headers=headers,
-                json=json_data,
-            )
-
-        response_json = response.json()
-        return response_json["data"][0]["embedding"]
-
-
-class GoogleEmbeddings:
-    def __init__(self, api_key: str, model: str, base_url: str):
-        self.api_key = api_key
-        self.model = model
-        self.base_url = base_url  # Expected to be "https://generativelanguage.googleapis.com"
-
-    def get_text_embedding(self, text: str):
-        import httpx
-
-        headers = {"Content-Type": "application/json"}
-        # Build the URL based on the provided base_url, model, and API key.
-        url = f"{self.base_url}/v1beta/models/{self.model}:embedContent?key={self.api_key}"
-        payload = {"model": self.model, "content": {"parts": [{"text": text}]}}
-        with httpx.Client() as client:
-            response = client.post(url, headers=headers, json=payload)
-        # Raise an error for non-success HTTP status codes.
-        response.raise_for_status()
-        response_json = response.json()
-        return response_json["embedding"]["values"]
-
-
-class GoogleVertexEmbeddings:
-    def __init__(self, model: str, project_id: str, region: str):
-        from google import genai
-
-        self.client = genai.Client(vertexai=True, project=project_id, location=region, http_options={"api_version": "v1"})
-        self.model = model
-
-    def get_text_embedding(self, text: str):
-        response = self.client.generate_embeddings(content=text, model=self.model)
-        return response.embeddings[0].embedding
-
-
-class OpenAIEmbeddings:
-    def __init__(self, api_key: str, model: str, base_url: str):
-        if base_url:
-            self.client = OpenAI(api_key=api_key, base_url=base_url)
-        else:
-            self.client = OpenAI(api_key=api_key)
-        self.model = model
-
-    def get_text_embedding(self, text: str):
-        response = self.client.embeddings.create(input=text, model=self.model)
-
-        return response.data[0].embedding
-
-
-def query_embedding(embedding_model, query_text: str):
-    """Generate padded embedding for querying database"""
-    query_vec = embedding_model.get_text_embedding(query_text)
-    query_vec = np.array(query_vec)
-    query_vec = np.pad(query_vec, (0, MAX_EMBEDDING_DIM - query_vec.shape[0]), mode="constant").tolist()
-    return query_vec
-
-
-def embedding_model(config: EmbeddingConfig, user_id: Optional[uuid.UUID] = None):
-    """Return LlamaIndex embedding model to use for embeddings"""
-
-    endpoint_type = config.embedding_endpoint_type
-
-    # TODO: refactor to pass in settings from server
-    from letta.settings import model_settings
-
-    if endpoint_type == "openai":
-        return OpenAIEmbeddings(
-            api_key=model_settings.openai_api_key,
-            model=config.embedding_model,
-            base_url=config.embedding_endpoint or model_settings.openai_api_base,
-        )
-
-    elif endpoint_type == "azure":
-        assert all(
-            [
-                model_settings.azure_api_key is not None,
-                model_settings.azure_base_url is not None,
-                model_settings.azure_api_version is not None,
-            ]
-        )
-        return AzureOpenAIEmbedding(
-            api_endpoint=model_settings.azure_base_url,
-            api_key=model_settings.azure_api_key,
-            api_version=model_settings.azure_api_version,
-            model=config.embedding_model,
-        )
-
-    elif endpoint_type == "hugging-face":
-        return EmbeddingEndpoint(
-            model=config.embedding_model,
-            base_url=config.embedding_endpoint,
-            user=user_id,
-        )
-    elif endpoint_type == "ollama":
-
-        model = OllamaEmbeddings(
-            model=config.embedding_model,
-            base_url=config.embedding_endpoint,
-            ollama_additional_kwargs={},
-        )
-        return model
-
-    elif endpoint_type == "google_ai":
-        assert all([model_settings.gemini_api_key is not None, model_settings.gemini_base_url is not None])
-        model = GoogleEmbeddings(
-            model=config.embedding_model,
-            api_key=model_settings.gemini_api_key,
-            base_url=model_settings.gemini_base_url,
-        )
-        return model
-
-    elif endpoint_type == "google_vertex":
-        model = GoogleVertexEmbeddings(
-            model=config.embedding_model,
-            api_key=model_settings.gemini_api_key,
-            base_url=model_settings.gemini_base_url,
-        )
-        return model
-
-    else:
-        raise ValueError(f"Unknown endpoint type {endpoint_type}")

letta/errors.py

@@ -236,5 +236,33 @@ class AgentFileExportError(Exception):
     """Exception raised during agent file export operations"""
 
 
+class AgentNotFoundForExportError(AgentFileExportError):
+    """Exception raised when requested agents are not found during export"""
+
+    def __init__(self, missing_ids: List[str]):
+        self.missing_ids = missing_ids
+        super().__init__(f"The following agent IDs were not found: {missing_ids}")
+
+
+class AgentExportIdMappingError(AgentFileExportError):
+    """Exception raised when ID mapping fails during export conversion"""
+
+    def __init__(self, db_id: str, entity_type: str):
+        self.db_id = db_id
+        self.entity_type = entity_type
+        super().__init__(
+            f"Unexpected new {entity_type} ID '{db_id}' encountered during conversion. "
+            f"All IDs should have been mapped during agent processing."
+        )
+
+
+class AgentExportProcessingError(AgentFileExportError):
+    """Exception raised when general export processing fails"""
+
+    def __init__(self, message: str, original_error: Optional[Exception] = None):
+        self.original_error = original_error
+        super().__init__(f"Export failed: {message}")
+
+
 class AgentFileImportError(Exception):
     """Exception raised during agent file import operations"""

letta/functions/function_sets/base.py

@@ -63,7 +63,7 @@ def conversation_search(self: "Agent", query: str, page: Optional[int] = 0) -> O
     return results_str
 
 
-def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
+async def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     """
     Add to archival memory. Make sure to phrase the memory contents such that it can be easily queried later.
 
@@ -73,7 +73,7 @@ def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     Returns:
         Optional[str]: None is always returned as this function does not produce a response.
     """
-    self.passage_manager.insert_passage(
+    await self.passage_manager.insert_passage(
         agent_state=self.agent_state,
         text=content,
         actor=self.user,
@@ -82,7 +82,7 @@ def archival_memory_insert(self: "Agent", content: str) -> Optional[str]:
     return None
 
 
-def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0, start: Optional[int] = 0) -> Optional[str]:
+async def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0, start: Optional[int] = 0) -> Optional[str]:
     """
     Search archival memory using semantic (embedding-based) search.
 
@@ -107,7 +107,7 @@ def archival_memory_search(self: "Agent", query: str, page: Optional[int] = 0, s
 
     try:
         # Get results using passage manager
-        all_results = self.agent_manager.list_passages(
+        all_results = await self.agent_manager.list_passages_async(
             actor=self.user,
             agent_id=self.agent_state.id,
             query_text=query,

letta/functions/functions.py

@@ -1,3 +1,4 @@
+import ast
 import importlib
 import inspect
 from collections.abc import Callable
@@ -8,45 +9,299 @@ from typing import Any, Dict, List, Literal, Optional
 from letta.errors import LettaToolCreateError
 from letta.functions.schema_generator import generate_schema
 
+# NOTE: THIS FILE WILL BE DEPRECATED
+
+
+class MockFunction:
+    """A mock function object that mimics the attributes expected by generate_schema."""
+
+    def __init__(self, name: str, docstring: str, signature: inspect.Signature):
+        self.__name__ = name
+        self.__doc__ = docstring
+        self.__signature__ = signature
+
+    def __call__(self, *args, **kwargs):
+        raise NotImplementedError("This is a mock function and cannot be called")
+
+
+def _parse_type_annotation(annotation_node: ast.AST, imports_map: Dict[str, Any]) -> Any:
+    """Parse an AST type annotation node back into a Python type object."""
+    if annotation_node is None:
+        return inspect.Parameter.empty
+
+    if isinstance(annotation_node, ast.Name):
+        type_name = annotation_node.id
+        return imports_map.get(type_name, type_name)
+
+    elif isinstance(annotation_node, ast.Subscript):
+        # Generic type like 'List[str]', 'Optional[int]'
+        value_name = annotation_node.value.id if isinstance(annotation_node.value, ast.Name) else str(annotation_node.value)
+        origin_type = imports_map.get(value_name, value_name)
+
+        # Parse the slice (the part inside the brackets)
+        if isinstance(annotation_node.slice, ast.Name):
+            slice_type = _parse_type_annotation(annotation_node.slice, imports_map)
+            if hasattr(origin_type, "__getitem__"):
+                try:
+                    return origin_type[slice_type]
+                except (TypeError, AttributeError):
+                    pass
+            return f"{origin_type}[{slice_type}]"
+        else:
+            slice_type = _parse_type_annotation(annotation_node.slice, imports_map)
+            if hasattr(origin_type, "__getitem__"):
+                try:
+                    return origin_type[slice_type]
+                except (TypeError, AttributeError):
+                    pass
+            return f"{origin_type}[{slice_type}]"
+
+    else:
+        # Fallback - return string representation
+        return ast.unparse(annotation_node)
+
+
+def _build_imports_map(tree: ast.AST) -> Dict[str, Any]:
+    """Build a mapping of imported names to their Python objects."""
+    imports_map = {
+        "Optional": Optional,
+        "List": List,
+        "Dict": Dict,
+        "Literal": Literal,
+        # Built-in types
+        "str": str,
+        "int": int,
+        "bool": bool,
+        "float": float,
+        "list": list,
+        "dict": dict,
+    }
+
+    # Try to resolve Pydantic imports if they exist in the source
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ImportFrom):
+            if node.module == "pydantic":
+                for alias in node.names:
+                    if alias.name == "BaseModel":
+                        try:
+                            from pydantic import BaseModel
+
+                            imports_map["BaseModel"] = BaseModel
+                        except ImportError:
+                            pass
+                    elif alias.name == "Field":
+                        try:
+                            from pydantic import Field
+
+                            imports_map["Field"] = Field
+                        except ImportError:
+                            pass
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                if alias.name == "typing":
+                    imports_map.update(
+                        {
+                            "typing.Optional": Optional,
+                            "typing.List": List,
+                            "typing.Dict": Dict,
+                            "typing.Literal": Literal,
+                        }
+                    )
+
+    return imports_map
+
+
+def _extract_pydantic_classes(tree: ast.AST, imports_map: Dict[str, Any]) -> Dict[str, Any]:
+    """Extract Pydantic model classes from the AST and create them dynamically."""
+    pydantic_classes = {}
+
+    # Check if BaseModel is available
+    if "BaseModel" not in imports_map:
+        return pydantic_classes
+
+    BaseModel = imports_map["BaseModel"]
+    Field = imports_map.get("Field")
+
+    # First pass: collect all class definitions
+    class_definitions = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            # Check if this class inherits from BaseModel
+            inherits_basemodel = False
+            for base in node.bases:
+                if isinstance(base, ast.Name) and base.id == "BaseModel":
+                    inherits_basemodel = True
+                    break
+
+            if inherits_basemodel:
+                class_definitions.append(node)
+
+    # Create classes in order, handling dependencies
+    created_classes = {}
+    remaining_classes = class_definitions.copy()
+
+    while remaining_classes:
+        progress_made = False
+
+        for node in remaining_classes.copy():
+            class_name = node.name
+
+            # Try to create this class
+            try:
+                fields = {}
+                annotations = {}
+
+                # Parse class body for field definitions
+                for stmt in node.body:
+                    if isinstance(stmt, ast.AnnAssign) and isinstance(stmt.target, ast.Name):
+                        field_name = stmt.target.id
+
+                        # Update imports_map with already created classes for type resolution
+                        current_imports = {**imports_map, **created_classes}
+                        field_annotation = _parse_type_annotation(stmt.annotation, current_imports)
+                        annotations[field_name] = field_annotation
+
+                        # Handle Field() definitions
+                        if stmt.value and isinstance(stmt.value, ast.Call):
+                            if isinstance(stmt.value.func, ast.Name) and stmt.value.func.id == "Field" and Field:
+                                # Parse Field arguments
+                                field_kwargs = {}
+                                for keyword in stmt.value.keywords:
+                                    if keyword.arg == "description":
+                                        if isinstance(keyword.value, ast.Constant):
+                                            field_kwargs["description"] = keyword.value.value
+
+                                # Handle positional args for required fields
+                                if stmt.value.args:
+                                    try:
+                                        default_val = ast.literal_eval(stmt.value.args[0])
+                                        if default_val == ...:  # Ellipsis means required
+                                            pass  # Field is required, no default
+                                        else:
+                                            field_kwargs["default"] = default_val
+                                    except:
+                                        pass
+
+                                fields[field_name] = Field(**field_kwargs)
+                            else:
+                                # Not a Field call, try to evaluate the default value
+                                try:
+                                    default_val = ast.literal_eval(stmt.value)
+                                    fields[field_name] = default_val
+                                except:
+                                    pass
+
+                # Create the dynamic Pydantic model
+                model_dict = {"__annotations__": annotations, **fields}
+
+                DynamicModel = type(class_name, (BaseModel,), model_dict)
+                created_classes[class_name] = DynamicModel
+                remaining_classes.remove(node)
+                progress_made = True
+
+            except Exception:
+                # This class might depend on others, try later
+                continue
+
+        if not progress_made:
+            # If we can't make progress, create remaining classes without proper field types
+            for node in remaining_classes:
+                class_name = node.name
+                # Create a minimal mock class
+                MockModel = type(class_name, (BaseModel,), {})
+                created_classes[class_name] = MockModel
+            break
+
+    return created_classes
+
+
+def _parse_function_from_source(source_code: str, desired_name: Optional[str] = None) -> MockFunction:
+    """Parse a function from source code without executing it."""
+    try:
+        tree = ast.parse(source_code)
+    except SyntaxError as e:
+        raise LettaToolCreateError(f"Failed to parse source code: {e}")
+
+    # Build imports mapping and find pydantic classes
+    imports_map = _build_imports_map(tree)
+    pydantic_classes = _extract_pydantic_classes(tree, imports_map)
+    imports_map.update(pydantic_classes)
+
+    # Find function definitions
+    functions = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            functions.append(node)
+
+    if not functions:
+        raise LettaToolCreateError("No functions found in source code")
+
+    # Use the last function (matching original behavior)
+    func_node = functions[-1]
+
+    # Extract function name
+    func_name = func_node.name
+
+    # Extract docstring
+    docstring = None
+    if (
+        func_node.body
+        and isinstance(func_node.body[0], ast.Expr)
+        and isinstance(func_node.body[0].value, ast.Constant)
+        and isinstance(func_node.body[0].value.value, str)
+    ):
+        docstring = func_node.body[0].value.value
+
+    if not docstring:
+        raise LettaToolCreateError(f"Function {func_name} missing docstring")
+
+    # Build function signature
+    parameters = []
+    for arg in func_node.args.args:
+        param_name = arg.arg
+        param_annotation = _parse_type_annotation(arg.annotation, imports_map)
+
+        # Handle default values
+        defaults_offset = len(func_node.args.args) - len(func_node.args.defaults)
+        param_index = func_node.args.args.index(arg)
+
+        if param_index >= defaults_offset:
+            default_index = param_index - defaults_offset
+            try:
+                default_value = ast.literal_eval(func_node.args.defaults[default_index])
+            except (ValueError, TypeError):
+                # Can't evaluate the default, use Parameter.empty
+                default_value = inspect.Parameter.empty
+            param = inspect.Parameter(
+                param_name, inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=param_annotation, default=default_value
+            )
+        else:
+            param = inspect.Parameter(param_name, inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=param_annotation)
+        parameters.append(param)
+
+    signature = inspect.Signature(parameters)
+
+    return MockFunction(func_name, docstring, signature)
+
 
 def derive_openai_json_schema(source_code: str, name: Optional[str] = None) -> dict:
     """Derives the OpenAI JSON schema for a given function source code.
 
-    # TODO (cliandy): I don't think we need to or should execute here
-    # TODO (cliandy): CONFIRM THIS BEFORE MERGING.
-    First, attempts to execute the source code in a custom environment with only the necessary imports.
-    Then, it generates the schema from the function's docstring and signature.
+    Parses the source code statically to extract function signature and docstring,
+    then generates the schema without executing any code.
+
+    Limitations:
+    - Complex nested Pydantic models with forward references may not be fully supported
+    - Only basic Pydantic Field definitions are parsed (description, ellipsis for required)
+    - Simple types (str, int, bool, float, list, dict) and basic Pydantic models work well
     """
     try:
-        # Define a custom environment with necessary imports
-        env = {
-            "Optional": Optional,
-            "List": List,
-            "Dict": Dict,
-            "Literal": Literal,
-            # To support Pydantic models
-            # "BaseModel": BaseModel,
-            # "Field": Field,
-        }
-        env.update(globals())
-        # print("About to execute source code...")
-        exec(source_code, env)
-        # print("Source code executed successfully")
-
-        functions = [f for f in env if callable(env[f]) and not f.startswith("__")]
-        if not functions:
-            raise LettaToolCreateError("No callable functions found in source code")
-
-        # print(f"Found functions: {functions}")
-        func = env[functions[-1]]
-
-        if not hasattr(func, "__doc__") or not func.__doc__:
-            raise LettaToolCreateError(f"Function {func.__name__} missing docstring")
-
-        # print("About to generate schema...")
+        # Parse the function from source code without executing it
+        mock_func = _parse_function_from_source(source_code, name)
+
+        # Generate schema using the mock function
         try:
-            schema = generate_schema(func, name=name)
-            # print("Schema generated successfully")
+            schema = generate_schema(mock_func, name=name)
             return schema
         except TypeError as e:
             raise LettaToolCreateError(f"Type error in schema generation: {str(e)}")

letta/functions/mcp_client/types.py

@@ -18,9 +18,20 @@ TEMPLATED_VARIABLE_REGEX = (
 logger = get_logger(__name__)
 
 
+class MCPToolHealth(BaseModel):
+    """Health status for an MCP tool's schema."""
+
+    # TODO: @jnjpng use the enum provided in schema_validator.py
+    status: str = Field(..., description="Schema health status: STRICT_COMPLIANT, NON_STRICT_ONLY, or INVALID")
+    reasons: List[str] = Field(default_factory=list, description="List of reasons for the health status")
+
+
 class MCPTool(Tool):
     """A simple wrapper around MCP's tool definition (to avoid conflict with our own)"""
 
+    # Optional health information added at runtime
+    health: Optional[MCPToolHealth] = Field(None, description="Schema health status for OpenAI strict mode")
+
 
 class MCPServerType(str, Enum):
     SSE = "sse"