alita-sdk 0.3.257__py3-none-any.whl → 0.3.562__py3-none-any.whl

alita_sdk/tools/openapi/tool.py

@@ -0,0 +1,20 @@
+from typing import Optional, Type
+
+from pydantic import BaseModel, Field, field_validator
+
+from ..base.tool import BaseAction
+from .api_wrapper import OpenApiApiWrapper
+
+
+class OpenApiAction(BaseAction):
+    """Tool for executing a single OpenAPI operation."""
+
+    api_wrapper: OpenApiApiWrapper = Field(default_factory=OpenApiApiWrapper)
+    name: str
+    description: str = ""
+    args_schema: Optional[Type[BaseModel]] = None
+
+    @field_validator('name', mode='before')
+    @classmethod
+    def remove_spaces(cls, v: str) -> str:
+        return v.replace(' ', '')

alita_sdk/tools/pandas/__init__.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, ConfigDict, create_model, Field
 
 from .api_wrapper import PandasWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 name = "pandas"
 
@@ -21,19 +21,22 @@ def get_tools(tool):
 
 class PandasToolkit(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 PandasWrapper.model_construct().get_available_tools()}
-        PandasToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            bucket_name=(str, Field(default=None, title="Bucket name", description="Bucket where the content file is stored", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': PandasToolkit.toolkit_max_length})),
+            bucket_name=(str, Field(default=None, title="Bucket name", description="Bucket where the content file is stored")),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
-            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Pandas", "icon_url": "pandas-icon.svg",
-                                                                  "categories": ["analysis"],
-                                                                    "extra_categories": ["data science", "data manipulation", "dataframes"]}})
+            __config__=ConfigDict(json_schema_extra={'metadata': {
+                "label": "Pandas (Deprecated)",
+                "icon_url": "pandas-icon.svg",
+                "categories": ["analysis"],
+                "deprecated": True,
+                "deprecation_message": "This toolkit is deprecated. Use the 'Data Analysis' internal tool instead. Enable it via the 'Internal Tools' menu in chat.",
+                "extra_categories": ["data science", "data manipulation", "dataframes"]
+            }})
         )
 
     @classmethod
@@ -41,17 +44,21 @@ class PandasToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         csv_tool_api_wrapper = PandasWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = csv_tool_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=csv_tool_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/pandas/api_wrapper.py

@@ -93,7 +93,7 @@ class PandasWrapper(BaseToolApiWrapper):
             if file_extension in ['csv', 'txt']:
                 df = pd.read_csv(file_obj)
             elif file_extension in ['xlsx', 'xls']:
-                df = pd.read_excel(file_obj)
+                df = pd.read_excel(file_obj, engine='calamine')
             elif file_extension == 'parquet':
                 df = pd.read_parquet(file_obj)
             elif file_extension == 'json':
@@ -158,57 +158,62 @@ class PandasWrapper(BaseToolApiWrapper):
                         f"Retrying Code Generation ({attempts}/{max_retries})..."
                     )
     
-    def process_query(self, query: str, filename: str) -> str:
-        """Analyze and process using query on dataset""" 
+    def pandas_analyze_data(self, query: str, filename: str) -> str:
+        """Analyze data from a file using natural language query.
+        
+        This tool allows you to perform data analysis operations on files using natural language.
+        It automatically generates and executes Python pandas code based on your query.
+        
+        Supported file formats: CSV, Excel (.xlsx, .xls), Parquet, JSON, XML, HDF5, Feather, Pickle
+        
+        Parameters:
+            query: Natural language description of the analysis to perform. Examples:
+                - "Calculate the average sales by region"
+                - "Show me a bar chart of products by revenue"
+                - "Filter rows where price > 100 and status is 'active'"
+                - "What is the correlation between age and income?"
+            filename: Name of the file in the artifact bucket (e.g., 'sales_data.csv', 'report.xlsx')
+        
+        Returns:
+            Analysis results as text, or confirmation message if a chart was generated and saved.
+            Charts are automatically saved to the artifact bucket as PNG files.
+        
+        Examples:
+            - pandas_analyze_data(query="Show summary statistics", filename="data.csv")
+            - pandas_analyze_data(query="Create a histogram of ages", filename="customers.xlsx")
+            - pandas_analyze_data(query="What's the total revenue by month?", filename="sales.parquet")
+        """
         df = self._get_dataframe(filename)
         code = self.generate_code_with_retries(df, query)
-        dispatch_custom_event(
-                name="thinking_step",
-                data={
-                    "message": f"Executing generated code... \n\n```python\n{code}\n```",
-                    "tool_name": "process_query",
-                    "toolkit": "pandas"
-                }
-            )
+        self._log_tool_event(tool_name="pandas_analyze_data",
+                             message=f"Executing generated code... \n\n```python\n{code}\n```")
         try:
             result = self.execute_code(df, code)
         except Exception as e:
             logger.error(f"Code execution failed: {format_exc()}")
-            dispatch_custom_event(
-                name="thinking_step",
-                data={
-                    "message": f"Code execution failed: {format_exc()}",
-                    "tool_name": "process_query",
-                    "toolkit": "pandas"
-                }
-            )
             raise
-        dispatch_custom_event(
-            name="thinking_step",
-            data={
-                "message": f"Result of code execution... \n\n```\n{result['result']}\n```",
-                "tool_name": "process_query",
-                "toolkit": "pandas"
-            }
-        )
         if result.get("df") is not None:
             df = result.pop("df")
             # Not saving dataframe to artifact repo for now
             # self._save_dataframe(df, filename)
         if result.get('chart'):
+            chart_results = []
             if isinstance(result['chart'], list):
                 for ind, chart in enumerate(result['chart']):
                     chart_filename = f"chart_{uuid4()}.png"
                     chart_data = base64.b64decode(chart)
                     self.alita.create_artifact(self.bucket_name, chart_filename, chart_data)
-                    result['result'] = f"Chart #{ind} saved to {chart_filename}"
+                    chart_url = f"{self.alita.base_url}/api/v1/artifacts/artifact/default/{self.alita.project_id}/{self.bucket_name}/{chart_filename}"
+                    chart_results.append(f"Chart #{ind+1} saved and available at: {chart_url}")
+                result['result'] = "\n".join(chart_results)
             else:
                 # Handle single chart case (not in a list)
                 chart = result['chart']
                 chart_filename = f"chart_{uuid4()}.png"
                 chart_data = base64.b64decode(chart)
                 self.alita.create_artifact(self.bucket_name, chart_filename, chart_data)
-                result['result'] = f"Chart saved to {chart_filename}"
+                chart_url = f"{self.alita.base_url}/api/v1/artifacts/artifact/default/{self.alita.project_id}/{self.bucket_name}/{chart_filename}"
+                result['result'] = f"Chart saved and available at: {chart_url}\n\nYou can embed this image in your response using markdown: ![Chart]({chart_url})"
         return result.get("result", None)
 
     def save_dataframe(self, source_df: str, target_file: str) -> str:
@@ -271,23 +276,13 @@ class PandasWrapper(BaseToolApiWrapper):
     def get_available_tools(self):
         return [
             {
-                "name": "process_query",
-                "ref": self.process_query,
-                "description": self.process_query.__doc__,
-                "args_schema": create_model(
-                    "ProcessQueryModel",
-                    query=(str, Field(description="Task to solve")),
-                    filename=(str, Field(description="File to be processed"))
-                )
-            },
-            {
-                "name": "save_dataframe",
-                "ref": self.save_dataframe,
-                "description": self.save_dataframe.__doc__,
+                "name": "pandas_analyze_data",
+                "ref": self.pandas_analyze_data,
+                "description": self.pandas_analyze_data.__doc__,
                 "args_schema": create_model(
-                    "SaveDataFrameModel",
-                    source_df=(str, Field(description="Source dataframe file to be saved")),
-                    target_file=(str, Field(description="Target filename with extension for saving"))
+                    "AnalyseDataModel",
+                    query=(str, Field(description="Natural language query describing what analysis to perform on the data")),
+                    filename=(str, Field(description="Name of the file to analyze (e.g., 'data.csv', 'report.xlsx')"))
                 )
             }
         ]

alita_sdk/tools/pandas/dataframe/generator/base.py

@@ -39,7 +39,9 @@ class CodeGenerator:
                 {"role": "user",  "content": [{"type": "text", "text": prompt}]}
             ]
             # Generate the code
-            code = self.llm.invoke(messages).content
+            from alita_sdk.runtime.langchain.utils import extract_text_from_completion
+            completion = self.llm.invoke(messages)
+            code = extract_text_from_completion(completion)
             return self.validate_and_clean_code(code)
 
         except Exception as e:

alita_sdk/tools/postman/__init__.py

@@ -6,7 +6,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, field_validator
 from ..base.tool import BaseAction
 
 from .api_wrapper import PostmanApiWrapper
-from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER, check_connection_response
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.postman import PostmanConfiguration
 
 name = "postman"
@@ -43,20 +43,16 @@ def get_tools(tool):
 
 class PostmanToolkit(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 PostmanApiWrapper.model_construct().get_available_tools()}
-        PostmanToolkit.toolkit_max_length = get_max_toolkit_length(
-            selected_tools)
         m = create_model(
             name,
             postman_configuration=(Optional[PostmanConfiguration], Field(description="Postman Configuration",
                                                                          json_schema_extra={'configuration_types': ['postman']})),
-            collection_id=(str, Field(description="Default collection ID", json_schema_extra={
-                           'toolkit_name': True, 'max_toolkit_length': PostmanToolkit.toolkit_max_length})),
+            collection_id=(str, Field(description="Default collection ID")),
             environment_config=(dict, Field(
                 description="JSON configuration for request execution (auth headers, project IDs, base URLs, etc.)",
                 default={})),
@@ -90,20 +86,23 @@ class PostmanToolkit(BaseToolkit):
             **kwargs['postman_configuration'],
         }
         postman_api_wrapper = PostmanApiWrapper(**wrapper_payload)
-        prefix = clean_string(str(toolkit_name), cls.toolkit_max_length) + \
-            TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = postman_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"{tool['description']}\nAPI URL: {postman_api_wrapper.base_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(PostmanAction(
                 api_wrapper=postman_api_wrapper,
-                name=prefix + tool["name"],
+                name=tool["name"],
                 mode=tool["mode"],
-                description=f"{tool['description']}\nAPI URL: {postman_api_wrapper.base_url}",
-                args_schema=tool["args_schema"]
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/postman/api_wrapper.py

@@ -340,7 +340,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Invalid JSON response from Postman API: {str(e)}")
 
-    def _apply_authentication(self, headers, params, all_variables, resolve_variables):
+    def _apply_authentication(self, headers, params, all_variables, native_auth, resolve_variables):
         """Apply authentication based on environment_config auth settings.
         
         Supports multiple authentication types:
@@ -363,14 +363,15 @@ class PostmanApiWrapper(BaseToolApiWrapper):
         import base64
         
         # Handle structured auth configuration only - no backward compatibility
-        auth_config = self.environment_config.get('auth')
+        auth_config = self.environment_config.get('auth', native_auth)
         if auth_config and isinstance(auth_config, dict):
             auth_type = auth_config.get('type', '').lower()
             auth_params = auth_config.get('params', {})
             
             if auth_type == 'bearer':
                 # Bearer token authentication
-                token = resolve_variables(str(auth_params.get('token', '')))
+                tokent_raw = auth_config.get('bearer', [{}])[0].get('value', '')
+                token = resolve_variables(str(tokent_raw))
                 if token:
                     headers['Authorization'] = f'Bearer {token}'
                     
@@ -739,7 +740,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             all_variables = {}
             
             # 1. Start with environment_config variables (lowest priority)
-            all_variables.update(self.environment_config)
+            all_variables.update(self._get_variables_from_env_config())
             
             # 2. Add collection variables
             collection_variables = collection_data.get('variable', [])
@@ -760,8 +761,9 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 import re
                 def replace_var(match):
                     var_name = match.group(1)
-                    return str(all_variables.get(var_name, match.group(0)))
-                
+                    value = all_variables.get(var_name, None)
+                    return resolve_variables(str(value)) if value else match.group(0)
+
                 return re.sub(r'\{\{([^}]+)\}\}', replace_var, text)
             
             # Prepare the request
@@ -791,7 +793,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             headers = {}
             
             # Handle authentication from environment_config
-            self._apply_authentication(headers, params, all_variables, resolve_variables)
+            self._apply_authentication(headers, params, all_variables, request_data.get('auth', None), resolve_variables)
             
             # Add headers from request
             request_headers = request_data.get('header', [])
@@ -1640,7 +1642,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
 
         # Find the request
         request_item = self.analyzer.find_request_by_path(
-            collection_data["item"], request_path)
+            collection_data["item"], request_path, collection_data.get("auth", None))
         if not request_item:
             raise ToolException(f"Request '{request_path}' not found")
 
@@ -2161,3 +2163,12 @@ class PostmanApiWrapper(BaseToolApiWrapper):
         parse_items(items)
         
         return result
+    
+    def _get_variables_from_env_config(self):
+        """Extracts all enabled variables from the 'values' field in environment_config."""
+        result = {}
+        values = self.environment_config.get("values", [])
+        for var in values:
+            if var.get("enabled", True) and "key" in var and "value" in var:
+                result[var["key"]] = var["value"]
+        return result

alita_sdk/tools/postman/postman_analysis.py

@@ -1049,13 +1049,14 @@ class PostmanAnalyzer:
         find_in_items(items, path_parts)
         return results
 
-    def find_request_by_path(self, items: List[Dict], request_path: str) -> Optional[Dict]:
+    def find_request_by_path(self, items: List[Dict], request_path: str, auth = None) -> Optional[Dict]:
         """Find a request by its path."""
         path_parts = [part.strip() for part in request_path.split('/') if part.strip()]
         if not path_parts:
             return None
 
         current_items = items
+        current_auth = auth
 
         # Navigate through folders to the request
         for i, part in enumerate(path_parts):
@@ -1065,6 +1066,9 @@ class PostmanAnalyzer:
                     if i == len(path_parts) - 1:
                         # This should be the request
                         if item.get('request'):
+                            # if request has no auth, inherit from parent
+                            if not item['request'].get('auth') and current_auth:
+                                item['request']['auth'] = current_auth
                             return item
                         else:
                             return None
@@ -1072,6 +1076,9 @@ class PostmanAnalyzer:
                         # This should be a folder
                         if item.get('item'):
                             current_items = item['item']
+                            # Update current_auth if folder has auth
+                            if item.get('auth'):
+                                current_auth = item['auth']
                             found = True
                             break
                         else:

alita_sdk/tools/pptx/__init__.py

@@ -7,7 +7,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 from .pptx_wrapper import PPTXWrapper
 
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 logger = logging.getLogger(__name__)
 
@@ -27,8 +27,6 @@ def get_tools(tool):
     ).get_tools()
 
 
-TOOLKIT_MAX_LENGTH = 25
-
 class PPTXToolkit(BaseToolkit):
     """
     PowerPoint (PPTX) manipulation toolkit for Alita.
@@ -45,8 +43,7 @@ class PPTXToolkit(BaseToolkit):
         
         return create_model(
             name,
-            bucket_name=(str, Field(description="Bucket name where PPTX files are stored", 
-                                   json_schema_extra={'toolkit_name': True, 'max_toolkit_length': TOOLKIT_MAX_LENGTH})),
+            bucket_name=(str, Field(description="Bucket name where PPTX files are stored")),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
@@ -75,19 +72,22 @@ class PPTXToolkit(BaseToolkit):
             selected_tools = []
             
         pptx_api_wrapper = PPTXWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, TOOLKIT_MAX_LENGTH) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = pptx_api_wrapper.get_available_tools()
         tools = []
         
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
-                
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=pptx_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
             
         return cls(tools=tools)

alita_sdk/tools/qtest/__init__.py

@@ -6,7 +6,8 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 
 from .api_wrapper import QtestApiWrapper
 from .tool import QtestAction
-from ..utils import clean_string, get_max_toolkit_length, TOOLKIT_SPLITTER, check_connection_response
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.qtest import QtestConfiguration
 
 name = "qtest"
@@ -15,29 +16,30 @@ name = "qtest"
 def get_tools(tool):
     toolkit = QtestToolkit.get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        base_url=tool['settings'].get('base_url', None),
         qtest_project_id=tool['settings'].get('qtest_project_id', tool['settings'].get('project_id', None)),
+        no_of_tests_shown_in_dql_search=tool['settings'].get('no_of_tests_shown_in_dql_search'),
         qtest_configuration=tool['settings']['qtest_configuration'],
-        toolkit_name=tool.get('toolkit_name')
+        toolkit_name=tool.get('toolkit_name'),
+        llm=tool['settings'].get('llm', None)
     )
     return toolkit.tools
 
 
 class QtestToolkit(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 QtestApiWrapper.model_construct().get_available_tools()}
-        QtestToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            qtest_configuration=(Optional[QtestConfiguration], Field(description="QTest API token", json_schema_extra={
+            qtest_configuration=(QtestConfiguration, Field(description="QTest API token", json_schema_extra={
                 'configuration_types': ['qtest']})),
-            qtest_project_id=(int, Field(default=None, description="QTest project id", json_schema_extra={'toolkit_name': True,
-                                                                                            'max_toolkit_length': QtestToolkit.toolkit_max_length})),
-            selected_tools=(List[Literal[tuple(selected_tools)]],
+            qtest_project_id=(int, Field(description="QTest project id")),
+            no_of_tests_shown_in_dql_search=(Optional[int], Field(description="Max number of items returned by dql search",
+                                                                  default=10)),
+
+        selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "QTest", "icon_url": "qtest.svg",
                                                                   "categories": ["test management"],
@@ -61,6 +63,7 @@ class QtestToolkit(BaseToolkit):
         return m
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -70,21 +73,25 @@ class QtestToolkit(BaseToolkit):
             **kwargs['qtest_configuration'],
         }
         qtest_api_wrapper = QtestApiWrapper(**wrapper_payload)
-        prefix = clean_string(str(toolkit_name), cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = qtest_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = f"{tool['description']}\nUrl: {qtest_api_wrapper.base_url}. Project id: {qtest_api_wrapper.qtest_project_id}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(QtestAction(
                 api_wrapper=qtest_api_wrapper,
-                name=prefix + tool["name"],
+                name=tool["name"],
                 mode=tool["mode"],
-                description=f"{tool['description']}\nUrl: {qtest_api_wrapper.base_url}. Project id: {qtest_api_wrapper.qtest_project_id}",
-                args_schema=tool["args_schema"]
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 
     def get_tools(self):
-        return self.tools
+        return self.tools