alita-sdk 0.3.462__py3-none-any.whl → 0.3.627__py3-none-any.whl

alita_sdk/runtime/utils/utils.py

@@ -1,6 +1,11 @@
+import base64
+import logging
 import re
 from enum import Enum
+from typing import Any
 
+# DEPRECATED: Tool names no longer use prefixes
+# Kept for backward compatibility only
 TOOLKIT_SPLITTER = "___"
 
 class IndexerKeywords(Enum):
@@ -30,3 +35,34 @@ def clean_node_str(s: str) -> str:
     """Cleans a node string by removing all non-alphanumeric characters except underscores and spaces."""
     cleaned_string = re.sub(r'[^\w\s]', '', s)
     return cleaned_string
+
+
+def resolve_image_from_cache(client: Any, cached_image_id: str) -> bytes:
+    """
+    Resolve cached_image_id from client's image cache and return decoded binary data.
+
+    Args:
+        client: AlitaClient instance with _generated_images_cache attribute
+        cached_image_id: The cached image ID to resolve
+
+    Returns:
+        bytes: Decoded binary image data
+
+    Raises:
+        ValueError: If cached_image_id not found or decoding fails
+    """
+    cache = getattr(client, '_generated_images_cache', {})
+
+    if cached_image_id not in cache:
+        raise ValueError(f"Image reference '{cached_image_id}' not found. The image may have expired.")
+
+    cached_data = cache[cached_image_id]
+    base64_data = cached_data.get('base64_data', '')
+    logging.debug(f"Resolved cached_image_id '{cached_image_id}' from cache (length: {len(base64_data)} chars)")
+    # Decode base64 to binary data for image files
+    try:
+        binary_data = base64.b64decode(base64_data)
+        logging.debug(f"Decoded base64 to binary data ({len(binary_data)} bytes)")
+        return binary_data
+    except Exception as e:
+        raise ValueError(f"Failed to decode image data for '{cached_image_id}': {e}")

alita_sdk/tools/__init__.py

@@ -13,6 +13,30 @@ AVAILABLE_TOOLS = {}
 AVAILABLE_TOOLKITS = {}
 FAILED_IMPORTS = {}
 
+
+def _inject_toolkit_id(tool_conf: dict, toolkit_tools) -> None:
+    """Inject `toolkit_id` into tools that expose `api_wrapper.toolkit_id`.
+
+    This reads 'id' from the tool configuration and, if it is an integer,
+    assigns it to the 'toolkit_id' attribute of the 'api_wrapper' for each
+    tool in 'toolkit_tools' that supports it.
+
+    Args:
+        tool_conf: Raw tool configuration item from 'tools_list'.
+        toolkit_tools: List of instantiated tools produced by a toolkit.
+    """
+    toolkit_id = tool_conf.get('id')
+    if isinstance(toolkit_id, int):
+        for t in toolkit_tools:
+            if hasattr(t, 'api_wrapper') and hasattr(t.api_wrapper, 'toolkit_id'):
+                t.api_wrapper.toolkit_id = toolkit_id
+    else:
+        logger.error(
+            f"Toolkit ID is missing or not an integer for tool "
+            f"`{tool_conf.get('type', '')}` with name `{tool_conf.get('name', '')}`"
+        )
+
+
 def _safe_import_tool(tool_name, module_path, get_tools_name=None, toolkit_class_name=None):
     """Safely import a tool module and register available functions/classes."""
     try:
@@ -21,6 +45,12 @@ def _safe_import_tool(tool_name, module_path, get_tools_name=None, toolkit_class
         imported = {}
         if get_tools_name and hasattr(module, get_tools_name):
             imported['get_tools'] = getattr(module, get_tools_name)
+        
+        if hasattr(module, 'get_toolkit'):
+            imported['get_toolkit'] = getattr(module, 'get_toolkit')
+
+        if hasattr(module, 'get_toolkit_available_tools'):
+            imported['get_toolkit_available_tools'] = getattr(module, 'get_toolkit_available_tools')
 
         if toolkit_class_name and hasattr(module, toolkit_class_name):
             imported['toolkit_class'] = getattr(module, toolkit_class_name)
@@ -34,9 +64,10 @@ def _safe_import_tool(tool_name, module_path, get_tools_name=None, toolkit_class
         FAILED_IMPORTS[tool_name] = str(e)
         logger.debug(f"Failed to import {tool_name}: {e}")
 
+
 # Safe imports for all tools
 _safe_import_tool('github', 'github', 'get_tools', 'AlitaGitHubToolkit')
-_safe_import_tool('openapi', 'openapi', 'get_tools')
+_safe_import_tool('openapi', 'openapi', 'get_tools', 'AlitaOpenAPIToolkit')
 _safe_import_tool('jira', 'jira', 'get_tools', 'JiraToolkit')
 _safe_import_tool('confluence', 'confluence', 'get_tools', 'ConfluenceToolkit')
 _safe_import_tool('service_now', 'servicenow', 'get_tools', 'ServiceNowToolkit')
@@ -71,7 +102,7 @@ _safe_import_tool('k8s', 'cloud.k8s', None, 'KubernetesToolkit')
 _safe_import_tool('elastic', 'elastic', None, 'ElasticToolkit')
 _safe_import_tool('keycloak', 'keycloak', None, 'KeycloakToolkit')
 _safe_import_tool('localgit', 'localgit', None, 'AlitaLocalGitToolkit')
-_safe_import_tool('pandas', 'pandas', 'get_tools', 'PandasToolkit')
+# pandas toolkit removed - use Data Analysis internal tool instead
 _safe_import_tool('azure_search', 'azure_ai.search', 'get_tools', 'AzureSearchToolkit')
 _safe_import_tool('figma', 'figma', 'get_tools', 'FigmaToolkit')
 _safe_import_tool('salesforce', 'salesforce', 'get_tools', 'SalesforceToolkit')
@@ -90,11 +121,19 @@ available_count = len(AVAILABLE_TOOLS)
 total_attempted = len(AVAILABLE_TOOLS) + len(FAILED_IMPORTS)
 logger.info(f"Tool imports completed: {available_count}/{total_attempted} successful")
 
+# Import community module to trigger community toolkit registration
+try:
+    from alita_sdk import community  # noqa: F401
+    logger.debug("Community toolkits registered successfully")
+except ImportError as e:
+    logger.debug(f"Community module not available: {e}")
+
 
 def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args, **kwargs):
     tools = []
 
     for tool in tools_list:
+        toolkit_tools = []
         settings = tool.get('settings')
 
         # Skip tools without settings early
@@ -116,53 +155,49 @@ def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args,
 
         # Set pgvector collection schema if present
         if settings.get('pgvector_configuration'):
-            settings['pgvector_configuration']['collection_schema'] = str(tool['id'])
+            # Use tool id if available, otherwise use toolkit_name or type as fallback
+            collection_id = tool.get('id') or tool.get('toolkit_name') or tool_type
+            settings['pgvector_configuration']['collection_schema'] = str(collection_id)
 
         # Handle ADO special cases
         if tool_type in ['ado_boards', 'ado_wiki', 'ado_plans']:
-            tools.extend(AVAILABLE_TOOLS['ado']['get_tools'](tool_type, tool))
-            continue
-
-        # Handle ADO repos aliases
-        if tool_type in ['ado_repos', 'azure_devops_repos'] and 'ado_repos' in AVAILABLE_TOOLS:
+            toolkit_tools.extend(AVAILABLE_TOOLS['ado']['get_tools'](tool_type, tool))
+        elif tool_type in ['ado_repos', 'azure_devops_repos'] and 'ado_repos' in AVAILABLE_TOOLS:
             try:
-                tools.extend(AVAILABLE_TOOLS['ado_repos']['get_tools'](tool))
+                toolkit_tools.extend(AVAILABLE_TOOLS['ado_repos']['get_tools'](tool))
             except Exception as e:
                 logger.error(f"Error getting ADO repos tools: {e}")
-            continue
-
-        # Skip MCP toolkit - it's handled by runtime/toolkits/tools.py to avoid duplicate loading
-        if tool_type == 'mcp':
+        elif tool_type == 'mcp':
             logger.debug(f"Skipping MCP toolkit '{tool.get('toolkit_name')}' - handled by runtime toolkit system")
-            continue
-
-        # Handle standard tools
-        if tool_type in AVAILABLE_TOOLS and 'get_tools' in AVAILABLE_TOOLS[tool_type]:
+        elif tool_type == 'planning':
+            logger.debug(f"Skipping planning toolkit '{tool.get('toolkit_name')}' - handled by runtime toolkit system")
+        elif tool_type in AVAILABLE_TOOLS and 'get_tools' in AVAILABLE_TOOLS[tool_type]:
             try:
-                tools.extend(AVAILABLE_TOOLS[tool_type]['get_tools'](tool))
+                toolkit_tools.extend(AVAILABLE_TOOLS[tool_type]['get_tools'](tool))
             except Exception as e:
                 logger.error(f"Error getting tools for {tool_type}: {e}")
                 raise ToolException(f"Error getting tools for {tool_type}: {e}")
-            continue
-
-        # Handle custom modules
-        if settings.get("module"):
+        elif settings.get("module"):
             try:
                 mod = import_module(settings.pop("module"))
                 tkitclass = getattr(mod, settings.pop("class"))
                 get_toolkit_params = settings.copy()
                 get_toolkit_params["name"] = tool.get("name")
                 toolkit = tkitclass.get_toolkit(**get_toolkit_params)
-                tools.extend(toolkit.get_tools())
+                toolkit_tools.extend(toolkit.get_tools())
             except Exception as e:
+                import traceback
                 logger.error(f"Error in getting custom toolkit: {e}")
-            continue
-
-        # Tool not available
-        if tool_type in FAILED_IMPORTS:
-            logger.warning(f"Tool '{tool_type}' is not available: {FAILED_IMPORTS[tool_type]}")
+                logger.error(f"Traceback:\n{traceback.format_exc()}")
         else:
-            logger.warning(f"Unknown tool type: {tool_type}")
+            if tool_type in FAILED_IMPORTS:
+                logger.warning(f"Tool '{tool_type}' is not available: {FAILED_IMPORTS[tool_type]}")
+            else:
+                logger.warning(f"Unknown tool type: {tool_type}")
+        #
+        # Always inject toolkit_id to each tool 
+        _inject_toolkit_id(tool, toolkit_tools)
+        tools.extend(toolkit_tools)
 
     return tools
 
@@ -182,6 +217,18 @@ def get_toolkits():
     logger.info(f"Successfully loaded {len(toolkit_configs)} toolkit configurations")
     return toolkit_configs
 
+def instantiate_toolkit(tool_config):
+    """Instantiate a toolkit from its configuration."""
+    tool_type = tool_config.get('type')
+    
+    if tool_type in AVAILABLE_TOOLS:
+        tool_module = AVAILABLE_TOOLS[tool_type]
+        
+        if 'get_toolkit' in tool_module:
+             return tool_module['get_toolkit'](tool_config)
+             
+    raise ValueError(f"Toolkit type '{tool_type}' does not support direct instantiation or is not available.")
+
 def get_available_tools():
     """Return list of available tool types."""
     return list(AVAILABLE_TOOLS.keys())
@@ -198,6 +245,42 @@ def get_available_toolkit_models():
     """Return dict with available toolkit classes."""
     return deepcopy(AVAILABLE_TOOLS)
 
+
+def get_toolkit_available_tools(toolkit_type: str, settings: dict) -> dict:
+    """Return dynamic available tools + per-tool JSON schemas for a toolkit instance.
+
+    This is the single SDK entrypoint used by backend services (e.g. indexer_worker)
+    when the UI needs spec/instance-dependent tool enumeration. Toolkits that don't
+    support dynamic enumeration should return an empty payload.
+
+    Args:
+        toolkit_type: toolkit type string (e.g. 'openapi')
+        settings: persisted toolkit settings
+
+    Returns:
+        {
+          "tools": [{"name": str, "description": str}],
+          "args_schemas": {"tool_name": <json schema dict>}
+        }
+    """
+    toolkit_type = (toolkit_type or '').strip().lower()
+    if not isinstance(settings, dict):
+        settings = {}
+
+    tool_module = AVAILABLE_TOOLS.get(toolkit_type) or {}
+    enumerator = tool_module.get('get_toolkit_available_tools')
+    if not callable(enumerator):
+        return {"tools": [], "args_schemas": {}}
+
+    try:
+        result = enumerator(settings)
+        if not isinstance(result, dict):
+            return {"tools": [], "args_schemas": {}, "error": "Invalid response from toolkit enumerator"}
+        return result
+    except Exception as e:  # pylint: disable=W0718
+        logger.exception("Failed to compute available tools for toolkit_type=%s", toolkit_type)
+        return {"tools": [], "args_schemas": {}, "error": str(e)}
+
 def diagnose_imports():
     """Print diagnostic information about tool imports."""
     available_count = len(AVAILABLE_TOOLS)
@@ -234,6 +317,7 @@ def diagnose_imports():
 __all__ = [
     'get_tools',
     'get_toolkits',
+    'get_toolkit_available_tools',
     'get_available_tools',
     'get_failed_imports',
     'get_available_toolkits',

alita_sdk/tools/ado/repos/__init__.py

@@ -6,23 +6,25 @@ from pydantic import BaseModel, Field, create_model
 import requests
 
 from ...elitea_base import filter_missconfigured_index_tools
-from ....configurations.ado import AdoReposConfiguration
+from ....configurations.ado import AdoConfiguration
 from ....configurations.pgvector import PgVectorConfiguration
 from ...base.tool import BaseAction
 from .repos_wrapper import ReposApiWrapper
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+from ...utils import check_connection_response
+from ....runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "ado_repos"
 
 
-def _get_toolkit(tool) -> BaseToolkit:
+def get_toolkit(tool) -> BaseToolkit:
     return AzureDevOpsReposToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        ado_repos_configuration=tool['settings']['ado_repos_configuration'],
+        ado_configuration=tool['settings']['ado_configuration'],
+        repository_id=tool['settings']['repository_id'],
         limit=tool['settings'].get('limit', 5),
-        base_branch=tool['settings'].get('base_branch', ""),
-        active_branch=tool['settings'].get('active_branch', ""),
-        toolkit_name=tool['settings'].get('toolkit_name', ""),
+        base_branch=tool['settings'].get('base_branch', "main"),
+        active_branch=tool['settings'].get('active_branch', "main"),
+        toolkit_name=tool.get('toolkit_name', ''),
         pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
         embedding_model=tool['settings'].get('embedding_model'),
         collection_name=tool['toolkit_name'],
@@ -30,26 +32,22 @@ def _get_toolkit(tool) -> BaseToolkit:
         llm=tool['settings'].get('llm', None),
     )
 
-def get_toolkit():
-    return AzureDevOpsReposToolkit.toolkit_config_schema()
-
 def get_tools(tool):
-    return _get_toolkit(tool).get_tools()
+    return get_toolkit(tool).get_tools()
 
 class AzureDevOpsReposToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in ReposApiWrapper.model_construct().get_available_tools()}
-        AzureDevOpsReposToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            ado_repos_configuration=(AdoReposConfiguration, Field(description="Ado Repos configuration", default=None,
-                                                                       json_schema_extra={'configuration_types': ['ado_repos']})),
-            base_branch=(Optional[str], Field(default="", title="Base branch", description="ADO base branch (e.g., main)")),
-            active_branch=(Optional[str], Field(default="", title="Active branch", description="ADO active branch (e.g., main)")),
+            ado_configuration=(AdoConfiguration, Field(description="ADO configuration", default=None,
+                                                       json_schema_extra={'configuration_types': ['ado']})),
+            repository_id=(str, Field(description="ADO repository ID or name")),
+            base_branch=(Optional[str], Field(default="main", title="Base branch", description="ADO base branch (e.g., main)")),
+            active_branch=(Optional[str], Field(default="main", title="Active branch", description="ADO active branch (e.g., main)")),
 
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
@@ -57,21 +55,38 @@ class AzureDevOpsReposToolkit(BaseToolkit):
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_model': 'embedding'})),
 
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
-            __config__={'json_schema_extra': {'metadata':
-                {
-                    "label": "ADO repos",
-                    "icon_url": "ado-repos-icon.svg",
-                    "categories": ["code repositories"],
-                    "extra_categories": ["code", "repository", "version control"],
-                    "max_length": AzureDevOpsReposToolkit.toolkit_max_length
-                }}}
+            __config__={
+                'json_schema_extra': {
+                    'metadata': {
+                        "label": "ADO repos",
+                        "icon_url": "ado-repos-icon.svg",
+                        "categories": ["code repositories"],
+                        "extra_categories": ["code", "repository", "version control"],
+                        "sections": {
+                            "auth": {
+                                "required": True,
+                                "subsections": [
+                                    {
+                                        "name": "Token",
+                                        "fields": ["token"]
+                                    }
+                                ]
+                            }
+                        },
+                        "configuration_group": {
+                            "name": "ado",
+                        }
+                    }
+                }
+            }
         )
 
         @check_connection_response
         def check_connection(self):
+            ado_config = self.ado_configuration
             response = requests.get(
-                f'{self.organization_url}/{self.project}/_apis/git/repositories/{self.repository_id}?api-version=7.0',
-                headers = {'Authorization': f'Bearer {self.token}'},
+                f'{ado_config.organization_url}/{ado_config.project}/_apis/git/repositories/{self.repository_id}?api-version=7.0',
+                headers = {'Authorization': f'Bearer {ado_config.token.get_secret_value() if ado_config.token else ""}'},
                 timeout=5
             )
             return response
@@ -91,25 +106,28 @@ class AzureDevOpsReposToolkit(BaseToolkit):
 
         wrapper_payload = {
             **kwargs,
-            # TODO use ado_repos_configuration fields
-            **kwargs['ado_repos_configuration'],
-            **kwargs['ado_repos_configuration']['ado_configuration'],
+            # Extract ADO configuration fields
+            **kwargs['ado_configuration'],
             **(kwargs.get('pgvector_configuration') or {}),
         }
         azure_devops_repos_wrapper = ReposApiWrapper(**wrapper_payload)
         available_tools = azure_devops_repos_wrapper.get_available_tools()
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"] + f"\nADO instance: {azure_devops_repos_wrapper.organization_url}/{azure_devops_repos_wrapper.project}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(
                 BaseAction(
                     api_wrapper=azure_devops_repos_wrapper,
-                    name=prefix + tool["name"],
-                    description=tool["description"] + f"\nADO instance: {azure_devops_repos_wrapper.organization_url}/{azure_devops_repos_wrapper.project}",
+                    name=tool["name"],
+                    description=description,
                     args_schema=tool["args_schema"],
+                    metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
                 )
             )
         return cls(tools=tools)