alita-sdk 0.3.206__py3-none-any.whl → 0.3.207__py3-none-any.whl

alita_sdk/runtime/utils/toolkit_runtime.py

@@ -0,0 +1,147 @@
+"""
+Toolkit runtime utilities for event dispatching and execution context.
+This module provides tools with the ability to dispatch custom events during execution.
+"""
+
+import sys
+import logging
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def dispatch_custom_event(event_type: str, data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Dispatch a custom event from within a toolkit tool execution.
+    
+    This function can be called by toolkit tools to send events back to the runtime
+    for monitoring, logging, or other purposes.
+    
+    Args:
+        event_type: Type of the event (e.g., "progress", "warning", "info")
+        data: Event data dictionary
+        
+    Returns:
+        Event dictionary if successful, None if no executor context available
+        
+    Example:
+        ```python
+        from alita_sdk.runtime.utils.toolkit_runtime import dispatch_custom_event
+        
+        def my_tool_function(param1, param2):
+            # Dispatch a progress event
+            dispatch_custom_event("progress", {
+                "message": "Processing started",
+                "step": 1,
+                "total_steps": 3
+            })
+            
+            # Do some work
+            result = process_data(param1, param2)
+            
+            # Dispatch completion event
+            dispatch_custom_event("completion", {
+                "message": "Processing completed",
+                "result_size": len(result)
+            })
+            
+            return result
+        ```
+    """
+    try:
+        # Try to get the current executor context
+        if hasattr(sys.modules[__name__], 'toolkit_dispatch_context'):
+            context = sys.modules[__name__].toolkit_dispatch_context
+            return context.dispatch_custom_event(event_type, data)
+        else:
+            # No executor context available - this is normal when not in test mode
+            logger.debug(f"No toolkit executor context available for event: {event_type}")
+            return None
+    except Exception as e:
+        logger.warning(f"Error dispatching custom event {event_type}: {e}")
+        return None
+
+
+def get_executor_context():
+    """
+    Get the current toolkit executor context if available.
+    
+    Returns:
+        ToolkitExecutor context or None if not in execution context
+    """
+    try:
+        if hasattr(sys.modules[__name__], 'toolkit_dispatch_context'):
+            return sys.modules[__name__].toolkit_dispatch_context.executor
+        return None
+    except Exception:
+        return None
+
+
+def is_in_test_mode() -> bool:
+    """
+    Check if the toolkit is currently running in test mode.
+    
+    Returns:
+        True if running in test mode with executor context, False otherwise
+    """
+    return get_executor_context() is not None
+
+
+class ToolkitRuntimeContext:
+    """
+    Context manager for toolkit runtime execution.
+    
+    This can be used by tools that need to perform setup/cleanup operations
+    when running in test mode vs normal execution.
+    """
+    
+    def __init__(self, tool_name: str):
+        self.tool_name = tool_name
+        self.executor = get_executor_context()
+        
+    def __enter__(self):
+        if self.executor:
+            dispatch_custom_event("tool_start", {
+                "tool_name": self.tool_name,
+                "message": f"Starting execution of {self.tool_name}"
+            })
+        return self
+        
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.executor:
+            if exc_type is None:
+                dispatch_custom_event("tool_end", {
+                    "tool_name": self.tool_name,
+                    "message": f"Completed execution of {self.tool_name}",
+                    "success": True
+                })
+            else:
+                dispatch_custom_event("tool_error", {
+                    "tool_name": self.tool_name,
+                    "message": f"Error in {self.tool_name}: {exc_val}",
+                    "success": False,
+                    "error_type": exc_type.__name__ if exc_type else "Unknown"
+                })
+        return False  # Don't suppress exceptions
+    
+    def dispatch_progress(self, message: str, step: int = None, total_steps: int = None, **kwargs):
+        """Convenience method for dispatching progress events."""
+        data = {"message": message, "tool_name": self.tool_name}
+        if step is not None:
+            data["step"] = step
+        if total_steps is not None:
+            data["total_steps"] = total_steps
+        data.update(kwargs)
+        dispatch_custom_event("progress", data)
+    
+    def dispatch_info(self, message: str, **kwargs):
+        """Convenience method for dispatching info events."""
+        data = {"message": message, "tool_name": self.tool_name}
+        data.update(kwargs)
+        dispatch_custom_event("info", data)
+    
+    def dispatch_warning(self, message: str, **kwargs):
+        """Convenience method for dispatching warning events."""
+        data = {"message": message, "tool_name": self.tool_name}
+        data.update(kwargs)
+        dispatch_custom_event("warning", data)

alita_sdk/runtime/utils/toolkit_utils.py

@@ -0,0 +1,157 @@
+"""
+Toolkit utilities for instantiating and managing toolkits.
+This module provides toolkit management functions that are not tied to any specific interface.
+"""
+
+import logging
+import random
+from typing import Dict, Any, Optional, List
+
+logger = logging.getLogger(__name__)
+
+
+def instantiate_toolkit_with_client(toolkit_config: Dict[str, Any], 
+                                   llm_client: Any, 
+                                   alita_client: Optional[Any] = None) -> List[Any]:
+    """
+    Instantiate a toolkit with LLM client support.
+    
+    This is a variant of instantiate_toolkit that includes LLM client support
+    for toolkits that require LLM capabilities.
+    
+    Args:
+        toolkit_config: Configuration dictionary for the toolkit
+        llm_client: LLM client instance for tools that need LLM capabilities
+        client: Optional additional client instance
+    
+    Returns:
+        List of instantiated tools from the toolkit
+        
+    Raises:
+        ValueError: If required configuration or client is missing
+        Exception: If toolkit instantiation fails
+    """
+    try:
+        from ..toolkits.tools import get_tools
+        
+        toolkit_name = toolkit_config.get('toolkit_name')
+        if not toolkit_name:
+            raise ValueError("toolkit_name is required in configuration")
+        
+        if not llm_client:
+            raise ValueError("LLM client is required but not provided")
+        
+        settings = toolkit_config.get('settings', {})
+        
+        # Log the configuration being used
+        logger.info(f"Instantiating toolkit {toolkit_name} with LLM client")
+        logger.debug(f"Toolkit {toolkit_name} configuration: {toolkit_config}")
+        
+        # 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()),
+            'settings': settings,
+            'toolkit_name': toolkit_name
+        }
+        
+        # Get tools using the toolkit configuration with clients
+        # Parameter order: get_tools(tools_list, alita_client, llm, memory_store)
+        tools = get_tools([tool_config], alita_client, llm_client)
+        
+        if not tools:
+            logger.warning(f"No tools returned for toolkit {toolkit_name}")
+            return []
+        
+        logger.info(f"Successfully instantiated toolkit {toolkit_name} with {len(tools)} tools")
+        return tools
+            
+    except Exception as e:
+        logger.error(f"Error instantiating toolkit {toolkit_name} with client: {str(e)}")
+        raise
+
+
+def get_toolkit_tools(toolkit_instance: Any) -> List[Any]:
+    """
+    Extract tools from an instantiated toolkit instance.
+    
+    This function provides a standardized way to get tools from various
+    toolkit implementations that might have different interfaces.
+    
+    Args:
+        toolkit_instance: An instantiated toolkit object
+        
+    Returns:
+        List of tools from the toolkit
+        
+    Raises:
+        ValueError: If no tools can be extracted from the toolkit
+    """
+    try:
+        # Try different methods to get tools from the toolkit
+        if hasattr(toolkit_instance, 'get_tools'):
+            tools = toolkit_instance.get_tools()
+        elif hasattr(toolkit_instance, 'tools'):
+            tools = toolkit_instance.tools
+        elif hasattr(toolkit_instance, '_tools'):
+            tools = toolkit_instance._tools
+        else:
+            raise ValueError("Could not find tools in the toolkit instance")
+        
+        if not tools:
+            logger.warning("Toolkit instance returned empty tools list")
+            return []
+        
+        logger.info(f"Extracted {len(tools)} tools from toolkit instance")
+        return tools
+        
+    except Exception as e:
+        logger.error(f"Error extracting tools from toolkit: {str(e)}")
+        raise
+
+
+def find_tool_by_name(tools: List[Any], tool_name: str) -> Optional[Any]:
+    """
+    Find a specific tool by name from a list of tools.
+    
+    Args:
+        tools: List of tool instances
+        tool_name: Name of the tool to find
+        
+    Returns:
+        The tool instance if found, None otherwise
+    """
+    for tool in tools:
+        # Check various attributes that might contain the tool name
+        if hasattr(tool, 'name') and tool.name == tool_name:
+            return tool
+        elif hasattr(tool, 'func') and hasattr(tool.func, '__name__') and tool.func.__name__ == tool_name:
+            return tool
+        elif hasattr(tool, '__name__') and tool.__name__ == tool_name:
+            return tool
+    
+    return None
+
+
+def get_tool_names(tools: List[Any]) -> List[str]:
+    """
+    Extract tool names from a list of tools.
+    
+    Args:
+        tools: List of tool instances
+        
+    Returns:
+        List of tool names
+    """
+    tool_names = []
+    for tool in tools:
+        if hasattr(tool, 'name'):
+            tool_names.append(tool.name)
+        elif hasattr(tool, 'func') and hasattr(tool.func, '__name__'):
+            tool_names.append(tool.func.__name__)
+        elif hasattr(tool, '__name__'):
+            tool_names.append(tool.__name__)
+        else:
+            tool_names.append(str(tool))
+    
+    return tool_names

alita_sdk/tools/memory/__init__.py

@@ -1,7 +1,7 @@
 from typing import Optional, List
 
 from langchain_core.tools import BaseToolkit, BaseTool
-from langgraph.store.postgres import PostgresStore
+
 try:
     from langmem import create_manage_memory_tool, create_search_memory_tool
 except ImportError:
@@ -15,13 +15,37 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 
 name = "memory"
 
-def get_tools(tool):
-    return MemoryToolkit().get_toolkit(
-        namespace=tool['settings'].get('namespace', str(tool['id'])),
-        username=tool['settings'].get('username', ''),
-        store=tool['settings'].get('store', None),
-        toolkit_name=tool.get('toolkit_name', '')
-).get_tools()
+def get_tools(tools_list: list, alita_client, llm, memory_store=None):
+    """
+    Get memory tools for the provided tool configurations.
+    
+    Args:
+        tools_list: List of tool configurations
+        alita_client: Alita client instance
+        llm: LLM client instance
+        memory_store: Optional memory store instance
+    
+    Returns:
+        List of memory tools
+    """
+    all_tools = []
+    
+    for tool in tools_list:
+        if tool.get('type') == 'memory' or tool.get('toolkit_name') == 'memory':
+            try:
+                toolkit_instance = MemoryToolkit().get_toolkit(
+                    namespace=tool['settings'].get('namespace', str(tool['id'])),
+                    username=tool['settings'].get('username', ''),
+                    store=tool['settings'].get('store', memory_store),
+                    toolkit_name=tool.get('toolkit_name', '')
+                )
+                all_tools.extend(toolkit_instance.get_tools())
+            except Exception as e:
+                print(f"DEBUG: Error in memory toolkit get_tools: {e}")
+                print(f"DEBUG: Tool config: {tool}")
+                raise
+    
+    return all_tools
 
 class MemoryToolkit(BaseToolkit):
     tools: List[BaseTool] = []
@@ -30,7 +54,7 @@ class MemoryToolkit(BaseToolkit):
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         return create_model(
-            name,
+            'MemoryConfig',
             namespace=(str, Field(description="Memory namespace", json_schema_extra={'toolkit_name': True})),
             username=(Optional[str], Field(description="Username", default='Tester', json_schema_extra={'hidden': True})),
             connection_string=(Optional[SecretStr], Field(description="Connection string for vectorstore",
@@ -48,7 +72,27 @@ class MemoryToolkit(BaseToolkit):
         )
 
     @classmethod
-    def get_toolkit(cls, namespace: str, store: PostgresStore, **kwargs):
+    def get_toolkit(cls, namespace: str, store=None, **kwargs):
+        """
+        Get toolkit with memory tools.
+        
+        Args:
+            namespace: Memory namespace
+            store: PostgresStore instance (imported dynamically)
+            **kwargs: Additional arguments
+        """
+        try:
+            from langgraph.store.postgres import PostgresStore
+        except ImportError:
+            raise ImportError(
+                "PostgreSQL dependencies (psycopg) are required for MemoryToolkit. "
+                "Install with: pip install psycopg[binary]"
+            )
+        
+        # Validate store type
+        if store is not None and not isinstance(store, PostgresStore):
+            raise TypeError(f"Expected PostgresStore, got {type(store)}")
+        
         return cls(tools=[
             create_manage_memory_tool(namespace=namespace, store=store),
             create_search_memory_tool(namespace=namespace, store=store)

{alita_sdk-0.3.206.dist-info → alita_sdk-0.3.207.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.206
+Version: 0.3.207
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.206.dist-info → alita_sdk-0.3.207.dist-info}/RECORD

@@ -1,19 +1,10 @@
 alita_sdk/__init__.py,sha256=fxeNiqiVpIFAJls31Oomifyrtd5gT9iPUTdkWjDOB2Y,656
 alita_sdk/community/__init__.py,sha256=8N7wWwPhoyOq3p8wlV3-pb3l3nJCR8TUrtV9iIPLU88,2523
 alita_sdk/community/utils.py,sha256=lvuCJaNqVPHOORJV6kIPcXJcdprVW_TJvERtYAEgpjM,249
-alita_sdk/community/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/community/analysis/ado_analyse/__init__.py,sha256=ADjjyV2z7XmQhOv873Mrz_-W9jWxhWpiDJ0nujm0eZs,4232
-alita_sdk/community/analysis/ado_analyse/api_wrapper.py,sha256=evWq2GS4SxfOc4bryhhG21QTVHII65_4CmqAJN2iGd0,8721
-alita_sdk/community/analysis/github_analyse/__init__.py,sha256=QmHgXYaUSBmyFNUVV89OMuhoTe0E6Q-7ftG5s8N3j_w,3682
-alita_sdk/community/analysis/github_analyse/api_wrapper.py,sha256=w_umxdeSDRuZvckQIAmihty4YL7Be3K28S1wV5hhgRY,6872
-alita_sdk/community/analysis/gitlab_analyse/__init__.py,sha256=6PgqvD0cX5evpT_vgGv48sXMHCJYn_MPqaOAUxhxS2g,4243
-alita_sdk/community/analysis/gitlab_analyse/api_wrapper.py,sha256=xGX3io2rT_DJl1PMiP9d6lsw6xhr9L2h910raGk1s4w,6373
-alita_sdk/community/analysis/jira_analyse/__init__.py,sha256=oyAVkjq4KZmSA1RiAijeo4oh9hNDgFmOCkDilUJ8DWs,6023
-alita_sdk/community/analysis/jira_analyse/api_wrapper.py,sha256=Ui1GBWizIFGFOi98BtkPWxVITQbrv7xFZxxYjAFq66Q,9701
 alita_sdk/runtime/__init__.py,sha256=4W0UF-nl3QF2bvET5lnah4o24CoTwSoKXhuN0YnwvEE,828
 alita_sdk/runtime/clients/__init__.py,sha256=BdehU5GBztN1Qi1Wul0cqlU46FxUfMnI6Vq2Zd_oq1M,296
 alita_sdk/runtime/clients/artifact.py,sha256=4N2t5x3GibyXLq3Fvrv2o_VA7Z000yNfc-UN4eGsHZg,2679
-alita_sdk/runtime/clients/client.py,sha256=XITXME6UGi-VKEMd8eYJ-PPFIkSyWVigmLH61UMvD_M,23326
+alita_sdk/runtime/clients/client.py,sha256=R2ISXLCi7ODQaw6juPlknCtWkcSeZw-lmq3VOc6V-yM,35783
 alita_sdk/runtime/clients/datasource.py,sha256=HAZovoQN9jBg0_-lIlGBQzb4FJdczPhkHehAiVG3Wx0,1020
 alita_sdk/runtime/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1447
 alita_sdk/runtime/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -21,10 +12,10 @@ alita_sdk/runtime/langchain/assistant.py,sha256=Bn9vUyZlFAP-D9Bh3zc2G1ZQkh5rr2c2
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/runtime/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/runtime/langchain/langraph_agent.py,sha256=ssPJOf_REAx8lx2tQdnZ0ccbdiZX8WwSRcX5ASgLyxs,43327
+alita_sdk/runtime/langchain/langraph_agent.py,sha256=QwD9NZ74Hp4rZvP7nirzOmjFJhfJ7eiuAvsq7aAW4Uw,43563
 alita_sdk/runtime/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/runtime/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
-alita_sdk/runtime/langchain/store_manager.py,sha256=w5-0GbPGJAw14g0CCD9BKFMznzk1I-iJ5OGj_HZJZgA,2211
+alita_sdk/runtime/langchain/store_manager.py,sha256=i8Fl11IXJhrBXq1F1ukEVln57B1IBe-tqSUvfUmBV4A,2218
 alita_sdk/runtime/langchain/utils.py,sha256=Npferkn10dvdksnKzLJLBI5bNGQyVWTBwqp3vQtUqmY,6631
 alita_sdk/runtime/langchain/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/langchain/agents/xml_chat.py,sha256=Mx7PK5T97_GrFCwHHZ3JZP42S7MwtUzV0W-_8j6Amt8,6212
@@ -70,7 +61,7 @@ alita_sdk/runtime/toolkits/artifact.py,sha256=7fTr9VpGd2zwCB3EwW4aqWa5jVKRTunqV3
 alita_sdk/runtime/toolkits/datasource.py,sha256=qk78OdPoReYPCWwahfkKLbKc4pfsu-061oXRryFLP6I,2498
 alita_sdk/runtime/toolkits/prompt.py,sha256=WIpTkkVYWqIqOWR_LlSWz3ug8uO9tm5jJ7aZYdiGRn0,1192
 alita_sdk/runtime/toolkits/subgraph.py,sha256=ZYqI4yVLbEPAjCR8dpXbjbL2ipX598Hk3fL6AgaqFD4,1758
-alita_sdk/runtime/toolkits/tools.py,sha256=Cpde3upReUwQIOM4RAMMdbEem1EBLIPI2GXC2MsX6V0,7951
+alita_sdk/runtime/toolkits/tools.py,sha256=eYAOzxiCcHzwssPTvgS_qDLNbhBu9BHsyqQWjO41_LA,7587
 alita_sdk/runtime/toolkits/vectorstore.py,sha256=BGppQADa1ZiLO17fC0uCACTTEvPHlodEDYEzUcBRbAA,2901
 alita_sdk/runtime/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
@@ -95,7 +86,9 @@ alita_sdk/runtime/utils/constants.py,sha256=Xntx1b_uxUzT4clwqHA_U6K8y5bBqf_4lSQw
 alita_sdk/runtime/utils/evaluate.py,sha256=iM1P8gzBLHTuSCe85_Ng_h30m52hFuGuhNXJ7kB1tgI,1872
 alita_sdk/runtime/utils/logging.py,sha256=svPyiW8ztDfhqHFITv5FBCj8UhLxz6hWcqGIY6wpJJE,3331
 alita_sdk/runtime/utils/save_dataframe.py,sha256=i-E1wp-t4wb17Zq3nA3xYwgSILjoXNizaQAA9opWvxY,1576
-alita_sdk/runtime/utils/streamlit.py,sha256=iuArm_XchIPOSrO60gLpvRKDVLv3-LJDpoI6NP5k6EM,85835
+alita_sdk/runtime/utils/streamlit.py,sha256=ZgHpibL2ARHt6qrWj5JhK6HNZv2UjxQ04qTk6gmz1Eo,104928
+alita_sdk/runtime/utils/toolkit_runtime.py,sha256=MU63Fpxj0b5_r1IUUc0Q3-PN9VwL7rUxp2MRR4tmYR8,5136
+alita_sdk/runtime/utils/toolkit_utils.py,sha256=I9QFqnaqfVgN26LUr6s3XlBlG6y0CoHURnCzG7XcwVs,5311
 alita_sdk/runtime/utils/utils.py,sha256=FoHtcQZ6JFFU8a1FG_V-W22v-bis0XsIc_XQmjH6Mzg,461
 alita_sdk/tools/__init__.py,sha256=kTw83lzfWf4HWlvGzfwwHhQlRhpPAbfCAhKkMWCzLFo,10324
 alita_sdk/tools/elitea_base.py,sha256=WjZYjBb1K5HySsbmkbSXUa9_7HYR3xvTHaMC6XCb_Z4,23391
@@ -232,7 +225,7 @@ alita_sdk/tools/llm/llm_utils.py,sha256=6P2j-42JGbyqpO8lNRuEP8GEhja-LC9E-98jTelK
 alita_sdk/tools/localgit/__init__.py,sha256=NScO0Eu-wl-rc63jjD5Qv1RXXB1qukSIJXx-yS_JQLI,2529
 alita_sdk/tools/localgit/local_git.py,sha256=gsAftNcK7nMCd8VsIkwDLs2SoG0MgpYdkQG5tmoynkA,18074
 alita_sdk/tools/localgit/tool.py,sha256=It_B24rMvFPurB355Oy5IShg2BsZTASsEoSS8hu2SXw,998
-alita_sdk/tools/memory/__init__.py,sha256=8Q02h-PUvIw3bNbWbfklSJZe3qj0zAjfahq9C5XjyzE,2359
+alita_sdk/tools/memory/__init__.py,sha256=Z3txBO3BMEk539_uBhGQaT57JWBVImbmZ8oPcLMj9ik,3900
 alita_sdk/tools/ocr/__init__.py,sha256=pvslKVXyJmK0q23FFDNieuc7RBIuzNXTjTNj-GqhGb0,3335
 alita_sdk/tools/ocr/api_wrapper.py,sha256=08UF8wj1sR8DcW0z16pw19bgLatLkBF8dySW-Ds8iRk,29649
 alita_sdk/tools/ocr/text_detection.py,sha256=1DBxt54r3_HdEi93QynSIVta3rH3UpIvy799TPtDTtk,23825
@@ -306,8 +299,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=VDsSFUTnBne1mFNssX2eLFxThXAhX
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0AI_j27xVO5Gk5HQMFrqPTd4uvuVTpiZUicBrdfEpKg,2796
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.206.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.206.dist-info/METADATA,sha256=XAKlNdJggXGDhxy1Nw6k9pKDJYvPTWv1LAxUhNvnpys,18917
-alita_sdk-0.3.206.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.206.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.206.dist-info/RECORD,,
+alita_sdk-0.3.207.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.207.dist-info/METADATA,sha256=5lVazejNDrCxd8_C-cvo3UuvhtgU7mVpW6WZAUqR_6Q,18917
+alita_sdk-0.3.207.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.207.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.207.dist-info/RECORD,,

alita_sdk/community/analysis/ado_analyse/__init__.py

@@ -1,103 +0,0 @@
-from typing import List, Optional, Literal
-from elitea_analyse.ado.azure_search import AzureSearch
-from pydantic import SecretStr, create_model, BaseModel, ConfigDict, Field
-
-from langchain_core.tools import BaseTool, BaseToolkit
-
-from alita_sdk.tools.utils import get_max_toolkit_length
-from alita_sdk.tools.base.tool import BaseAction
-from alita_sdk.runtime.clients.client import AlitaClient  # Add this import at the top of the file
-from alita_sdk.runtime.tools.artifact import ArtifactWrapper
-from .api_wrapper import AdoAnalyseWrapper
-
-from ...utils import check_schema
-
-
-name = "Analyse_Ado"
-
-
-class AnalyseAdo(BaseToolkit):
-    tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
-
-    @staticmethod
-    def toolkit_config_schema() -> type[BaseModel]:
-        selected_tools = {
-            x["name"]: x["args_schema"].schema()
-            for x in AdoAnalyseWrapper.model_construct().get_available_tools()
-        }
-        AnalyseAdo.toolkit_max_length = get_max_toolkit_length(selected_tools)
-
-        return create_model(
-            "analyse_ado",
-            organization=(str, Field(description="Azure DevOps organization name",
-                json_schema_extra={"toolkit_name": True, "max_toolkit_length": AnalyseAdo.toolkit_max_length})),
-            username=(str, Field(description="Azure DevOps username (e.g., 'john.doe@domain.com')")),
-            token=(SecretStr, Field(description="Azure DevOps Access Token", json_schema_extra={"secret": True})),
-            project_keys=(Optional[str], Field(description="Azure DevOps project keys separated by comma", default=None)),
-            default_branch_name=(Optional[str], Field(description="Default branch name", default="main")),
-            area=(Optional[str], Field(description="Area path filter", default="")),
-            artifact_bucket_path=(Optional[str], Field(description="Artifact Bucket Path", default="analyse-ado")),
-            selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={"args_schemas": selected_tools})),
-            __config__=ConfigDict(json_schema_extra={"metadata": {
-                    "label": "Analyse_Ado",
-                    "icon_url": "ado-icon.svg", # ???
-                    "hidden": True,
-                    "sections": {
-                        "auth": {
-                            "required": True,
-                            "subsections": [{"name": "Token", "fields": ["token"]}],
-                        }
-                    },
-                }
-            })
-        )
-    
-    @classmethod
-    def get_toolkit(cls, client: "AlitaClient", selected_tools: list[str], **kwargs):
-
-        bucket_path = kwargs.get("artifact_bucket_path") or "analyse-ado"
-        artifact_wrapper = ArtifactWrapper(client=client, bucket=bucket_path)
-        check_schema(artifact_wrapper)
-
-        project_keys = kwargs.get("project_keys") or ""
-        area = kwargs.get("area", "")
-
-        organization = kwargs.get("organization")
-        username = kwargs.get("username")
-        token = kwargs.get("token")
-
-        if not organization or not username or not token:
-            raise ValueError("Organization, username, and token must be provided.")
-
-        ado_search = AzureSearch(organization=organization, user=username, token=token)
-
-        ado_analyse_wrapper = AdoAnalyseWrapper(
-            artifacts_wrapper=artifact_wrapper,
-            project_keys=project_keys,
-            default_branch_name=kwargs.get("default_branch_name", "main"),
-            area=area,
-            ado_search=ado_search,
-        )
-
-        selected_tools = selected_tools or []
-        available_tools = ado_analyse_wrapper.get_available_tools()
-
-        tools = []
-        for tool in available_tools:
-            if selected_tools:
-                if tool["name"] not in selected_tools:
-                    continue
-            tools.append(
-                BaseAction(
-                    api_wrapper=ado_analyse_wrapper,
-                    name=tool["name"],
-                    description=tool["description"],
-                    args_schema=tool["args_schema"],
-                )
-            )
-
-        return cls(tools=tools)
-
-    def get_tools(self):
-        return self.tools