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

alita_sdk/tools/non_code_indexer_toolkit.py

@@ -6,11 +6,11 @@ from alita_sdk.tools.base_indexer_toolkit import BaseIndexerToolkit
 
 
 class NonCodeIndexerToolkit(BaseIndexerToolkit):
-    def _get_indexed_data(self, collection_suffix: str):
+    def _get_indexed_data(self, index_name: str):
         if not self.vector_adapter:
             raise ToolException("Vector adapter is not initialized. "
                              "Check your configuration: embedding_model and vectorstore_type.")
-        return self.vector_adapter.get_indexed_data(self, collection_suffix)
+        return self.vector_adapter.get_indexed_data(self, index_name)
 
     def key_fn(self, document: Document):
         return document.metadata.get('id')

alita_sdk/tools/openapi/__init__.py

@@ -1,6 +1,7 @@
 import json
 import re
 import logging
+import yaml
 from typing import List, Any, Optional, Dict
 from langchain_core.tools import BaseTool, BaseToolkit, ToolException
 from requests_openapi import Operation, Client, Server
@@ -101,7 +102,15 @@ class AlitaOpenAPIToolkit(BaseToolkit):
         else:
             tools_set = {}
         if isinstance(openapi_spec, str):
-            openapi_spec = json.loads(openapi_spec)
+            # Try to detect if it's YAML or JSON by attempting to parse as JSON first
+            try:
+                openapi_spec = json.loads(openapi_spec)
+            except json.JSONDecodeError:
+                # If JSON parsing fails, try YAML
+                try:
+                    openapi_spec = yaml.safe_load(openapi_spec)
+                except yaml.YAMLError as e:
+                    raise ToolException(f"Failed to parse OpenAPI spec as JSON or YAML: {e}")
         c = Client()
         c.load_spec(openapi_spec)
         if headers:

alita_sdk/tools/pandas/__init__.py

@@ -29,7 +29,7 @@ class PandasToolkit(BaseToolkit):
         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"],

alita_sdk/tools/postman/__init__.py

@@ -62,7 +62,8 @@ class PostmanToolkit(BaseToolkit):
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(
                 default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {
-                                  "label": "Postman", "icon_url": "postman.svg"}})
+                                  "label": "Postman", "icon_url": "postman.svg",
+                "max_length": PostmanToolkit.toolkit_max_length,}})
         )
 
         @check_connection_response

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,8 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 import re
                 def replace_var(match):
                     var_name = match.group(1)
-                    value = all_variables.get(var_name, match.group(0))
-                    return resolve_variables(value) if isinstance(value, str) else value
+                    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)
             
@@ -792,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', [])
@@ -1641,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")
 
@@ -2162,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

@@ -45,13 +45,13 @@ 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': {
                     "label": "PPTX",
                     "icon_url": "pptx.svg",
+                    "max_length": TOOLKIT_MAX_LENGTH,
                     "categories": ["office"],
                     "extra_categories": ["presentation", "office automation", "document"]
                 }

alita_sdk/tools/qtest/__init__.py

@@ -37,14 +37,14 @@ class QtestToolkit(BaseToolkit):
             name,
             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})),
+            qtest_project_id=(int, Field(default=None, 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",
+                                                                  "max_length": QtestToolkit.toolkit_max_length,
                                                                   "categories": ["test management"],
                                                                   "extra_categories": ["quality assurance",
                                                                                        "test case management",
@@ -93,4 +93,4 @@ class QtestToolkit(BaseToolkit):
         return cls(tools=tools)
 
     def get_tools(self):
-        return self.tools
+        return self.tools