alita-sdk 0.3.376__py3-none-any.whl → 0.3.435__py3-none-any.whl

alita_sdk/runtime/tools/mcp_server_tool.py

@@ -3,7 +3,7 @@ from logging import getLogger
 from typing import Any, Type, Literal, Optional, Union, List
 
 from langchain_core.tools import BaseTool
-from pydantic import BaseModel, Field, create_model, EmailStr, constr
+from pydantic import BaseModel, Field, create_model, EmailStr, constr, ConfigDict
 
 from ...tools.utils import TOOLKIT_SPLITTER
 
@@ -15,9 +15,61 @@ class McpServerTool(BaseTool):
     description: str
     args_schema: Optional[Type[BaseModel]] = None
     return_type: str = "str"
-    client: Any
+    client: Any = Field(default=None, exclude=True)  # Exclude from serialization
     server: str
     tool_timeout_sec: int = 60
+    is_prompt: bool = False  # Flag to indicate if this is a prompt tool
+    prompt_name: Optional[str] = None  # Original prompt name if this is a prompt
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __getstate__(self):
+        """Custom serialization to exclude non-serializable objects."""
+        state = self.__dict__.copy()
+        # Remove the client since it contains threading objects that can't be pickled
+        state['client'] = None
+        # Store args_schema as a schema dict instead of the dynamic class
+        if hasattr(self, 'args_schema') and self.args_schema is not None:
+            # Convert the Pydantic model back to schema dict for pickling
+            try:
+                state['_args_schema_dict'] = self.args_schema.model_json_schema()
+                state['args_schema'] = None
+            except Exception as e:
+                logger.warning(f"Failed to serialize args_schema: {e}")
+                # If conversion fails, just remove it
+                state['args_schema'] = None
+                state['_args_schema_dict'] = {}
+        return state
+
+    def __setstate__(self, state):
+        """Custom deserialization to handle missing objects."""
+        # Restore the args_schema from the stored schema dict
+        args_schema_dict = state.pop('_args_schema_dict', {})
+
+        # Initialize required Pydantic internal attributes
+        if '__pydantic_fields_set__' not in state:
+            state['__pydantic_fields_set__'] = set(state.keys())
+        if '__pydantic_extra__' not in state:
+            state['__pydantic_extra__'] = None
+        if '__pydantic_private__' not in state:
+            state['__pydantic_private__'] = None
+
+        # Directly update the object's __dict__ to bypass Pydantic validation
+        self.__dict__.update(state)
+
+        # Recreate the args_schema from the stored dict if available
+        if args_schema_dict:
+            try:
+                recreated_schema = self.create_pydantic_model_from_schema(args_schema_dict)
+                self.__dict__['args_schema'] = recreated_schema
+            except Exception as e:
+                logger.warning(f"Failed to recreate args_schema: {e}")
+                self.__dict__['args_schema'] = None
+        else:
+            self.__dict__['args_schema'] = None
+
+        # Note: client will be None after unpickling
+        # The toolkit should reinitialize the client when needed
 
 
     @staticmethod
@@ -90,14 +142,31 @@ class McpServerTool(BaseTool):
         return create_model(model_name, **fields)
 
     def _run(self, *args, **kwargs):
-        call_data = {
-            "server": self.server,
-            "tool_timeout_sec": self.tool_timeout_sec,
-            "tool_call_id": str(uuid.uuid4()),
-            "params": {
-                "name": self.name.rsplit(TOOLKIT_SPLITTER)[1] if TOOLKIT_SPLITTER in self.name else self.name,
-                "arguments": kwargs
+        # Extract the actual tool/prompt name (remove toolkit prefix)
+        actual_name = self.name.rsplit(TOOLKIT_SPLITTER)[1] if TOOLKIT_SPLITTER in self.name else self.name
+        
+        if self.is_prompt:
+            # For prompts, use prompts/get endpoint
+            call_data = {
+                "server": self.server,
+                "tool_timeout_sec": self.tool_timeout_sec,
+                "tool_call_id": str(uuid.uuid4()),
+                "method": "prompts/get",
+                "params": {
+                    "name": self.prompt_name or actual_name.replace("prompt_", ""),
+                    "arguments": kwargs.get("arguments", kwargs)
+                }
+            }
+        else:
+            # For regular tools, use tools/call endpoint
+            call_data = {
+                "server": self.server,
+                "tool_timeout_sec": self.tool_timeout_sec,
+                "tool_call_id": str(uuid.uuid4()),
+                "params": {
+                    "name": actual_name,
+                    "arguments": kwargs
+                }
             }
-        }
         
         return self.client.mcp_tool_call(call_data)

alita_sdk/runtime/tools/sandbox.py

@@ -2,21 +2,60 @@ import asyncio
 import logging
 import subprocess
 import os
-from typing import Any, Type, Optional, Dict
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel, create_model
+from typing import Any, Type, Optional, Dict, List, Literal, Union
+from copy import deepcopy
+from pathlib import Path
+
+from langchain_core.tools import BaseTool, BaseToolkit
+from langchain_core.messages import ToolCall
+from pydantic import BaseModel, create_model, ConfigDict, Field
 from pydantic.fields import FieldInfo
 
 logger = logging.getLogger(__name__)
 
+name = "pyodide"
+
+
+def get_tools(tools_list: list, alita_client=None, llm=None, memory_store=None):
+    """
+    Get sandbox tools for the provided tool configurations.
+
+    Args:
+        tools_list: List of tool configurations
+        alita_client: Alita client instance for sandbox tools
+        llm: LLM client instance (unused for sandbox)
+        memory_store: Optional memory store instance (unused for sandbox)
+
+    Returns:
+        List of sandbox tools
+    """
+    all_tools = []
+
+    for tool in tools_list:
+        if tool.get('type') == 'sandbox' or tool.get('toolkit_name') == 'sandbox':
+            try:
+                toolkit_instance = SandboxToolkit.get_toolkit(
+                    stateful=tool['settings'].get('stateful', False),
+                    allow_net=tool['settings'].get('allow_net', True),
+                    alita_client=alita_client,
+                    toolkit_name=tool.get('toolkit_name', '')
+                )
+                all_tools.extend(toolkit_instance.get_tools())
+            except Exception as e:
+                logger.error(f"Error in sandbox toolkit get_tools: {e}")
+                logger.error(f"Tool config: {tool}")
+                raise
+
+    return all_tools
+
 
 def _is_deno_available() -> bool:
     """Check if Deno is available in the PATH"""
     try:
         result = subprocess.run(
-            ["deno", "--version"], 
-            capture_output=True, 
-            text=True, 
+            ["deno", "--version"],
+            capture_output=True,
+            text=True,
             timeout=10
         )
         return result.returncode == 0
@@ -25,43 +64,17 @@ def _is_deno_available() -> bool:
 
 
 def _setup_pyodide_cache_env() -> None:
-    """Setup Pyodide caching environment variables for performance optimization"""
+    """Setup Pyodide caching environment variables for performance optimization [NO-OP]"""
     try:
-        # Check if cache environment file exists and source it
-        cache_env_file = os.path.expanduser("~/.pyodide_cache_env")
-        if os.path.exists(cache_env_file):
-            with open(cache_env_file, 'r') as f:
-                for line in f:
-                    line = line.strip()
-                    if line.startswith('export ') and '=' in line:
-                        # Parse export VAR=value format
-                        var_assignment = line[7:]  # Remove 'export '
-                        if '=' in var_assignment:
-                            key, value = var_assignment.split('=', 1)
-                            # Remove quotes if present
-                            value = value.strip('"').strip("'")
-                            os.environ[key] = value
-                            logger.debug(f"Set Pyodide cache env: {key}={value}")
-        
-        # Set default caching environment variables if not already set
-        cache_defaults = {
-            'PYODIDE_PACKAGES_PATH': os.path.expanduser('~/.cache/pyodide'),
-            'DENO_DIR': os.path.expanduser('~/.cache/deno'),
-            'PYODIDE_CACHE_DIR': os.path.expanduser('~/.cache/pyodide'),
-        }
-        
-        for key, default_value in cache_defaults.items():
-            if key not in os.environ:
-                os.environ[key] = default_value
-                logger.debug(f"Set default Pyodide env: {key}={default_value}")
-                
+        for key in ["SANDBOX_BASE", "DENO_DIR"]:
+            logger.info("Sandbox env: %s -> %s", key, os.environ.get(key, "n/a"))
     except Exception as e:
         logger.warning(f"Could not setup Pyodide cache environment: {e}")
 
 
 # Create input schema for the sandbox tool
 sandbox_tool_input = create_model(
-    "SandboxToolInput", 
+    "SandboxToolInput",
     code=(str, FieldInfo(description="Python code to execute in the sandbox environment"))
 )
 
@@ -72,7 +85,7 @@ class PyodideSandboxTool(BaseTool):
     This tool leverages langchain-sandbox to provide a safe environment for running untrusted Python code.
     Optimized for performance with caching and stateless execution by default.
     """
-    
+
     name: str = "pyodide_sandbox"
     description: str = """Execute Python code in a secure sandbox environment using Pyodide.
     This tool allows safe execution of Python code without access to the host system.
@@ -81,7 +94,7 @@ class PyodideSandboxTool(BaseTool):
     - Perform calculations or data analysis
     - Test Python algorithms
     - Run code that requires isolation from the host system
-    
+
     The sandbox supports most Python standard library modules and can install additional packages.
     Note: File access and some system operations are restricted for security.
     Optimized for performance with local caching (stateless by default for faster execution).
@@ -91,14 +104,37 @@ class PyodideSandboxTool(BaseTool):
     allow_net: bool = True
     session_bytes: Optional[bytes] = None
     session_metadata: Optional[Dict] = None
-    
+    alita_client: Optional[Any] = None
+
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._sandbox = None
         # Setup caching environment for optimal performance
         _setup_pyodide_cache_env()
         self._initialize_sandbox()
-    
+
+    def _prepare_pyodide_input(self, code: str) -> str:
+        """Prepare input for PyodideSandboxTool by injecting state and alita_client into the code block."""
+        pyodide_predata = ""
+
+        # Add alita_client if available
+        if self.alita_client:
+            try:
+                # Get the directory of the current file and construct the path to sandbox_client.py
+                current_dir = Path(__file__).parent
+                sandbox_client_path = current_dir.parent / 'clients' / 'sandbox_client.py'
+
+                with open(sandbox_client_path, 'r') as f:
+                    sandbox_client_code = f.read()
+                pyodide_predata += f"{sandbox_client_code}\n"
+                pyodide_predata += (f"alita_client = SandboxClient(base_url='{self.alita_client.base_url}',"
+                                    f"project_id={self.alita_client.project_id},"
+                                    f"auth_token='{self.alita_client.auth_token}')\n")
+            except FileNotFoundError:
+                logger.error(f"sandbox_client.py not found. Ensure the file exists.")
+
+        return f"#elitea simplified client\n{pyodide_predata}{code}"
+
     def _initialize_sandbox(self) -> None:
         """Initialize the PyodideSandbox instance with optimized settings"""
         try:
@@ -110,12 +146,22 @@ class PyodideSandboxTool(BaseTool):
                 )
                 logger.error(error_msg)
                 raise RuntimeError(error_msg)
-            
+
             from langchain_sandbox import PyodideSandbox
-            
+
+            # Air-gapped settings
+            sandbox_base = os.environ.get("SANDBOX_BASE", os.path.expanduser('~/.cache/pyodide'))
+            sandbox_tmp = os.path.join(sandbox_base, "tmp")
+            deno_cache = os.environ.get("DENO_DIR", os.path.expanduser('~/.cache/deno'))
+
             # Configure sandbox with performance optimizations
             self._sandbox = PyodideSandbox(
                 stateful=self.stateful,
+                #
+                allow_env=["SANDBOX_BASE"],
+                allow_read=[sandbox_base, sandbox_tmp, deno_cache],
+                allow_write=[sandbox_tmp, deno_cache],
+                #
                 allow_net=self.allow_net,
                 # Use auto node_modules_dir for better caching
                 node_modules_dir="auto"
@@ -135,7 +181,7 @@ class PyodideSandboxTool(BaseTool):
         except Exception as e:
             logger.error(f"Failed to initialize PyodideSandbox: {e}")
             raise
-    
+
     def _run(self, code: str) -> str:
         """
         Synchronous version - runs the async method in a new event loop
@@ -144,7 +190,10 @@ class PyodideSandboxTool(BaseTool):
             # Check if sandbox is initialized, if not try to initialize
             if self._sandbox is None:
                 self._initialize_sandbox()
-            
+
+            # Prepare code with state and client injection
+            prepared_code = self._prepare_pyodide_input(code)
+
             # Check if we're already in an async context
             try:
                 loop = asyncio.get_running_loop()
@@ -152,11 +201,11 @@ class PyodideSandboxTool(BaseTool):
                 # We'll need to use a different approach
                 import concurrent.futures
                 with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(asyncio.run, self._arun(code))
+                    future = executor.submit(asyncio.run, self._arun(prepared_code))
                     return future.result()
             except RuntimeError:
                 # No running loop, safe to use asyncio.run
-                return asyncio.run(self._arun(code))
+                return asyncio.run(self._arun(prepared_code))
         except (ImportError, RuntimeError) as e:
             # Handle specific dependency errors gracefully
             error_msg = str(e)
@@ -169,7 +218,7 @@ class PyodideSandboxTool(BaseTool):
         except Exception as e:
             logger.error(f"Error executing code in sandbox: {e}")
             return f"Error executing code: {str(e)}"
-    
+
     async def _arun(self, code: str) -> str:
         """
         Execute Python code in the Pyodide sandbox
@@ -177,19 +226,19 @@ class PyodideSandboxTool(BaseTool):
         try:
             if self._sandbox is None:
                 self._initialize_sandbox()
-            
+
             # Execute the code with session state if available
             result = await self._sandbox.execute(
                 code,
                 session_bytes=self.session_bytes,
                 session_metadata=self.session_metadata
             )
-            
+
             # Update session state for stateful execution
             if self.stateful:
                 self.session_bytes = result.session_bytes
                 self.session_metadata = result.session_metadata
-            
+
             result_dict = {}
 
             if result.result is not None:
@@ -212,10 +261,10 @@ class PyodideSandboxTool(BaseTool):
 
             result_dict["execution_info"] = execution_info
             return result_dict
-            
+
         except Exception as e:
             logger.error(f"Error executing code in sandbox: {e}")
-            return f"Error executing code: {str(e)}"
+            return {"error": f"Error executing code: {str(e)}"}
 
 
 class StatefulPyodideSandboxTool(PyodideSandboxTool):
@@ -223,7 +272,7 @@ class StatefulPyodideSandboxTool(PyodideSandboxTool):
     A stateful version of the PyodideSandboxTool that maintains state between executions.
     This version preserves variables, imports, and function definitions across multiple tool calls.
     """
-    
+
     name: str = "stateful_pyodide_sandbox"
     description: str = """Execute Python code in a stateful sandbox environment using Pyodide.
     This tool maintains state between executions, preserving variables, imports, and function definitions.
@@ -232,41 +281,95 @@ class StatefulPyodideSandboxTool(PyodideSandboxTool):
     - Maintain variables across multiple calls
     - Develop complex programs step by step
     - Preserve imported libraries and defined functions
-    
+
     The sandbox supports most Python standard library modules and can install additional packages.
     Note: File access and some system operations are restricted for security.
     """
-    
+
     def __init__(self, **kwargs: Any) -> None:
         kwargs['stateful'] = True  # Force stateful mode
         super().__init__(**kwargs)
 
 
 # Factory function for creating sandbox tools
-def create_sandbox_tool(stateful: bool = False, allow_net: bool = True) -> BaseTool:
+def create_sandbox_tool(stateful: bool = False, allow_net: bool = True, alita_client: Optional[Any] = None) -> BaseTool:
     """
     Factory function to create sandbox tools with specified configuration.
-    
+
     Note: This tool requires Deno to be installed and available in PATH.
     For installation and optimization, run the bootstrap.sh script.
-    
+
     Args:
         stateful: Whether to maintain state between executions (default: False for better performance)
         allow_net: Whether to allow network access (for package installation)
-    
+
     Returns:
         Configured sandbox tool instance
-        
+
     Raises:
         ImportError: If langchain-sandbox is not installed
         RuntimeError: If Deno is not found in PATH
-        
+
     Performance Notes:
         - Stateless mode (default) is faster and avoids session state overhead
         - Run bootstrap.sh script to enable local caching and reduce initialization time
         - Cached wheels reduce package download time from ~4.76s to near-instant
     """
     if stateful:
-        return StatefulPyodideSandboxTool(allow_net=allow_net)
+        return StatefulPyodideSandboxTool(allow_net=allow_net, alita_client=alita_client)
     else:
-        return PyodideSandboxTool(stateful=False, allow_net=allow_net)
+        return PyodideSandboxTool(stateful=False, allow_net=allow_net, alita_client=alita_client)
+
+
+class SandboxToolkit(BaseToolkit):
+    tools: List[BaseTool] = []
+
+    @staticmethod
+    def toolkit_config_schema() -> Type[BaseModel]:
+        # Create sample tools to get their schemas
+        sample_tools = [
+            PyodideSandboxTool(),
+            StatefulPyodideSandboxTool()
+        ]
+        selected_tools = {x.name: x.args_schema.model_json_schema() for x in sample_tools}
+
+        return create_model(
+            'sandbox',
+            stateful=(bool, Field(default=False, description="Whether to maintain state between executions")),
+            allow_net=(bool, Field(default=True, description="Whether to allow network access for package installation")),
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
+
+            __config__=ConfigDict(json_schema_extra={
+                'metadata': {
+                    "label": "Python Sandbox",
+                    "icon_url": "sandbox.svg",
+                    "hidden": False,
+                    "categories": ["code", "execution", "internal_tool"],
+                    "extra_categories": ["python", "pyodide", "sandbox", "code execution"],
+                }
+            })
+        )
+
+    @classmethod
+    def get_toolkit(cls, stateful: bool = False, allow_net: bool = True, alita_client=None, **kwargs):
+        """
+        Get toolkit with sandbox tools.
+
+        Args:
+            stateful: Whether to maintain state between executions
+            allow_net: Whether to allow network access
+            alita_client: Alita client instance for sandbox tools
+            **kwargs: Additional arguments
+        """
+        tools = []
+
+        if stateful:
+            tools.append(StatefulPyodideSandboxTool(allow_net=allow_net, alita_client=alita_client))
+        else:
+            tools.append(PyodideSandboxTool(stateful=False, allow_net=allow_net, alita_client=alita_client))
+
+        return cls(tools=tools)
+
+    def get_tools(self):
+        return self.tools

alita_sdk/runtime/tools/vectorstore.py

@@ -215,7 +215,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         """List all collections in the vectorstore.
         Returns a list of collection names, or if no collections exist,
         returns a dict with an empty list and a message."""
-        raw = self.vector_adapter.list_indexes(self)
+        raw = self.vector_adapter.list_collections(self)
         # Normalize raw result to a list of names
         if not raw:
             # No collections found
@@ -414,7 +414,8 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 return {"status": "error", "message": f"Error: {format_exc()}"}
         if _documents:
             add_documents(vectorstore=self.vectorstore, documents=_documents)
-        return {"status": "ok", "message": f"successfully indexed {documents_count} documents"}
+        return {"status": "ok", "message": f"successfully indexed {documents_count} documents" if documents_count > 0
+        else "No new documents to index."}
 
     def search_documents(self, query:str, doctype: str = 'code', 
                          filter:dict|str={}, cut_off: float=0.5,

alita_sdk/runtime/tools/vectorstore_base.py

@@ -208,10 +208,10 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
             logger.error(f"Error during similarity search: {str(e)}")
             raise ToolException(f"Search failed: {str(e)}")
 
-    def list_indexes(self) -> List[str]:
+    def list_collections(self) -> List[str]:
         """List all collections in the vectorstore."""
 
-        collections = self.vector_adapter.list_indexes(self)
+        collections = self.vector_adapter.list_collections(self)
         if not collections:
             return "No indexed collections"
         return collections
@@ -308,7 +308,8 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                 return {"status": "error", "message": f"Error: {format_exc()}"}
         if _documents:
             add_documents(vectorstore=self.vectorstore, documents=_documents)
-        return {"status": "ok", "message": f"successfully indexed {documents_count} documents"}
+        return {"status": "ok", "message": f"successfully indexed {documents_count} documents" if documents_count > 0
+        else "no documents to index"}
 
     def search_documents(self, query:str, doctype: str = 'code', 
                          filter:dict|str={}, cut_off: float=0.5,

alita_sdk/runtime/utils/streamlit.py

@@ -868,10 +868,24 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
                                 label = f"{'🔒 ' if is_secret else ''}{'*' if is_required else ''}{field_name.replace('_', ' ').title()}"
                                 
                                 if field_type == 'string':
-                                    if is_secret:
+                                    # Check if this is an enum field
+                                    if field_schema.get('enum'):
+                                        # Dropdown for enum values
+                                        options = field_schema['enum']
+                                        default_index = 0
+                                        if default_value and str(default_value) in options:
+                                            default_index = options.index(str(default_value))
+                                        toolkit_config_values[field_name] = st.selectbox(
+                                            label,
+                                            options=options,
+                                            index=default_index,
+                                            help=field_description,
+                                            key=f"config_{field_name}_{selected_toolkit_idx}"
+                                        )
+                                    elif is_secret:
                                         toolkit_config_values[field_name] = st.text_input(
                                             label,
-                                            value=str(default_value) if default_value else '', 
+                                            value=str(default_value) if default_value else '',
                                             help=field_description,
                                             type="password",
                                             key=f"config_{field_name}_{selected_toolkit_idx}"
@@ -879,7 +893,7 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
                                     else:
                                         toolkit_config_values[field_name] = st.text_input(
                                             label,
-                                            value=str(default_value) if default_value else '', 
+                                            value=str(default_value) if default_value else '',
                                             help=field_description,
                                             key=f"config_{field_name}_{selected_toolkit_idx}"
                                         )
@@ -971,6 +985,23 @@ def run_streamlit(st, ai_icon=None, user_icon=None):
                                                 key=f"config_{field_name}_{selected_toolkit_idx}"
                                             )
                                         toolkit_config_values[field_name] = [line.strip() for line in array_input.split('\n') if line.strip()]
+                                elif field_type == 'object':
+                                    # Handle object/dict types (like headers)
+                                    obj_input = st.text_area(
+                                        f"{label} (JSON object)",
+                                        value=json.dumps(default_value) if isinstance(default_value, dict) else str(default_value) if default_value else '',
+                                        help=f"{field_description} - Enter as JSON object, e.g. {{\"Authorization\": \"Bearer token\"}}",
+                                        placeholder='{"key": "value"}',
+                                        key=f"config_{field_name}_{selected_toolkit_idx}"
+                                    )
+                                    try:
+                                        if obj_input.strip():
+                                            toolkit_config_values[field_name] = json.loads(obj_input)
+                                        else:
+                                            toolkit_config_values[field_name] = None
+                                    except json.JSONDecodeError as e:
+                                        st.error(f"Invalid JSON format for {field_name}: {e}")
+                                        toolkit_config_values[field_name] = None
                         else:
                             st.info("This toolkit doesn't require additional configuration.")
                         

alita_sdk/runtime/utils/toolkit_utils.py

@@ -46,11 +46,14 @@ def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any],
         # Log the configuration being used
         logger.info(f"Instantiating toolkit {toolkit_name} with LLM client")
         logger.debug(f"Toolkit {toolkit_name} configuration: {toolkit_config}")
-        
+
+        # Use toolkit type from config, or fall back to lowercase toolkit name
+        toolkit_type = toolkit_config.get('type', toolkit_name.lower())
+
         # Create a tool configuration dict with required fields
         tool_config = {
             'id': toolkit_config.get('id', random.randint(1, 1000000)),
-            'type': toolkit_config.get('type', toolkit_name.lower()),
+            'type': toolkit_config.get('type', toolkit_type),
             'settings': settings,
             'toolkit_name': toolkit_name
         }

alita_sdk/runtime/utils/utils.py

@@ -14,6 +14,7 @@ class IndexerKeywords(Enum):
     INDEX_META_TYPE = 'index_meta'
     INDEX_META_IN_PROGRESS = 'in_progress'
     INDEX_META_COMPLETED = 'completed'
+    INDEX_META_FAILED = 'failed'
 
 # This pattern matches characters that are NOT alphanumeric, underscores, or hyphens
 clean_string_pattern = re.compile(r'[^a-zA-Z0-9_.-]')