alita-sdk 0.3.263__py3-none-any.whl → 0.3.499__py3-none-any.whl

alita_sdk/tools/keycloak/__init__.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, ConfigDict, create_model, Field, SecretStr
 
 from .api_wrapper import KeycloakApiWrapper
 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 = "keycloak"
 
@@ -21,15 +21,13 @@ def get_tools(tool):
 
 class KeycloakToolkit(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 KeycloakApiWrapper.model_construct().get_available_tools()}
-        KeycloakToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            base_url=(str, Field(default="", title="Server URL", description="Keycloak server URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': KeycloakToolkit.toolkit_max_length})),
+            base_url=(str, Field(default="", title="Server URL", description="Keycloak server URL", json_schema_extra={'toolkit_name': True})),
             realm=(str, Field(default="", title="Realm", description="Keycloak realm")),
             client_id=(str, Field(default="", title="Client ID", description="Keycloak client ID")),
             client_secret=(SecretStr, Field(default="", title="Client sercet", description="Keycloak client secret", json_schema_extra={'secret': True})),
@@ -42,16 +40,19 @@ class KeycloakToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         keycloak_api_wrapper = KeycloakApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = keycloak_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = f"{tool['description']}\nUrl: {keycloak_api_wrapper.base_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=keycloak_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nUrl: {keycloak_api_wrapper.base_url}",
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

alita_sdk/tools/localgit/local_git.py

@@ -8,7 +8,8 @@ from git import Repo
 from pydantic import BaseModel, Field, create_model, model_validator
 from langchain_core.tools import ToolException
 
-from ..elitea_base import BaseToolApiWrapper
+from ..elitea_base import BaseToolApiWrapper, extend_with_file_operations
+from ..utils.text_operations import parse_old_new_markers
 
 logger = logging.getLogger(__name__)
 CREATE_FILE_PROMPT = """Create new file in your local repository."""
@@ -128,58 +129,6 @@ class LocalGit(BaseToolApiWrapper):
             repo.head.reset(commit=commit_sha, working_tree=True)
         return values
 
-    def extract_old_new_pairs(self, file_query):
-        # Split the file content by lines
-        code_lines = file_query.split("\n")
-
-        # Initialize lists to hold the contents of OLD and NEW sections
-        old_contents = []
-        new_contents = []
-
-        # Initialize variables to track whether the current line is within an OLD or NEW section
-        in_old_section = False
-        in_new_section = False
-
-        # Temporary storage for the current section's content
-        current_section_content = []
-
-        # Iterate through each line in the file content
-        for line in code_lines:
-            # Check for OLD section start
-            if "OLD <<<" in line:
-                in_old_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for OLD section end
-            if ">>>> OLD" in line:
-                in_old_section = False
-                old_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section start
-            if "NEW <<<" in line:
-                in_new_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section end
-            if ">>>> NEW" in line:
-                in_new_section = False
-                new_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # If currently in an OLD or NEW section, add the line to the current section content
-            if in_old_section or in_new_section:
-                current_section_content.append(line)
-
-        # Pair the OLD and NEW contents
-        paired_contents = list(zip(old_contents, new_contents))
-
-        return paired_contents
-
     def checkout_commit(self, commit_sha: str) -> str:
         """ Checkout specific commit from repository """
         try:
@@ -233,6 +182,58 @@ class LocalGit(BaseToolApiWrapper):
                 return f.read()
         else:
             return "File '{}' cannot be read because it is not existed".format(file_path)
+    
+    def _read_file(self, file_path: str, branch: str = None, **kwargs) -> str:
+        """
+        Read a file from the repository with optional partial read support.
+        
+        Parameters:
+            file_path: the file path (relative to repo root)
+            branch: branch name (not used for local git, always reads from working dir)
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
+        
+        Returns:
+            File content as string
+        """
+        return self.read_file(file_path)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None
+    ) -> str:
+        """
+        Write content to a file (create or update).
+        
+        Parameters:
+            file_path: Path to the file (relative to repo root)
+            content: New file content
+            branch: Branch name (not used for local git)
+            commit_message: Commit message (not used - files are written without commit)
+            
+        Returns:
+            Success message
+        """
+        try:
+            full_path = os.path.normpath(os.path.join(self.repo.working_dir, file_path))
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            
+            # Write the file
+            with open(full_path, 'w') as f:
+                f.write(content)
+            
+            # Determine if file was created or updated
+            if os.path.exists(full_path):
+                return f"Updated file {file_path}"
+            else:
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def update_file_content_by_lines(self, file_path: str, start_line_index: int, end_line_index: int,
                                      new_content: str) -> str:
@@ -314,7 +315,7 @@ class LocalGit(BaseToolApiWrapper):
             file_path = os.path.normpath(os.path.join(self.repo.working_dir, file_path))
             file_content = self.read_file(file_path)
             updated_file_content = file_content
-            for old, new in self.extract_old_new_pairs(file_query):
+            for old, new in parse_old_new_markers(file_query):  # Use shared utility
                 if not old.strip():
                     continue
                 updated_file_content = updated_file_content.replace(old, new)
@@ -332,6 +333,7 @@ class LocalGit(BaseToolApiWrapper):
         except Exception as e:
             return "Unable to update file due to error:\n" + str(e)
 
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {

alita_sdk/tools/memory/__init__.py

@@ -1,6 +1,8 @@
-from typing import Optional, List
+from typing import List, Literal
 
-from langchain_core.tools import BaseToolkit, BaseTool
+from langchain_core.tools import BaseToolkit, BaseTool, ToolException
+
+from alita_sdk.configurations.pgvector import PgVectorConfiguration
 
 try:
     from langmem import create_manage_memory_tool, create_search_memory_tool
@@ -15,7 +17,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 
 name = "memory"
 
-def get_tools(tools_list: list, alita_client, llm, memory_store=None):
+def get_tools(tools_list: list, memory_store=None):
     """
     Get memory tools for the provided tool configurations.
     
@@ -35,8 +37,9 @@ def get_tools(tools_list: list, alita_client, llm, memory_store=None):
             try:
                 toolkit_instance = MemoryToolkit().get_toolkit(
                     namespace=tool['settings'].get('namespace', str(tool['id'])),
-                    username=tool['settings'].get('username', ''),
+                    # username=tool['settings'].get('username', ''),
                     store=tool['settings'].get('store', memory_store),
+                    pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
                     toolkit_name=tool.get('toolkit_name', '')
                 )
                 all_tools.extend(toolkit_instance.get_tools())
@@ -53,18 +56,23 @@ class MemoryToolkit(BaseToolkit):
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
+        memory_tools = [create_manage_memory_tool('test'), create_search_memory_tool('test')]
+        selected_tools = {x.name: x.args_schema.schema() for x in memory_tools}
+
         return create_model(
-            '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",
-                                                          default=None,
-                                                          json_schema_extra={'secret': True})),
+            'memory',
+            namespace=(str, Field(description="Memory namespace")),
+            pgvector_configuration=(PgVectorConfiguration, Field(description="PgVector Configuration",
+                                                                           json_schema_extra={
+                                                                               'configuration_types': ['pgvector']})),
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
+
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "Memory",
                     "icon_url": "memory.svg",
-                    "hidden": True,
+                    "hidden": False,
                     "categories": ["other"],
                     "extra_categories": ["long-term memory", "langmem"],
                 }
@@ -88,6 +96,14 @@ class MemoryToolkit(BaseToolkit):
                 "PostgreSQL dependencies (psycopg) are required for MemoryToolkit. "
                 "Install with: pip install psycopg[binary]"
             )
+
+        if store is None:
+            # The store is not provided, attempt to create it from configuration
+            from ...runtime.langchain.store_manager import get_manager
+            conn_str = (kwargs.get('pgvector_configuration') or {}).get('connection_string', '')
+            if not conn_str:
+                raise ToolException("Connection string is required to create PostgresStore for memory toolkit.")
+            store = get_manager().get_store(conn_str)
         
         # Validate store type
         if store is not None and not isinstance(store, PostgresStore):

alita_sdk/tools/non_code_indexer_toolkit.py

@@ -1,12 +1,17 @@
 from langchain_core.documents import Document
+from langchain_core.tools import ToolException
 
 from alita_sdk.runtime.utils.utils import IndexerKeywords
 from alita_sdk.tools.base_indexer_toolkit import BaseIndexerToolkit
 
 
 class NonCodeIndexerToolkit(BaseIndexerToolkit):
-    def _get_indexed_data(self, collection_suffix: str):
-        return self.vector_adapter.get_indexed_data(self, collection_suffix)
+    def _get_indexed_data(self, index_name: str):
+        self._ensure_vectorstore_initialized()
+        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, index_name)
 
     def key_fn(self, document: Document):
         return document.metadata.get('id')

alita_sdk/tools/ocr/__init__.py

@@ -5,7 +5,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import OCRApiWrapper
 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 = "ocr"
 
@@ -23,15 +23,13 @@ def get_tools(tool):
 
 class OCRToolkit(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 OCRApiWrapper.model_construct().get_available_tools()}
-        OCRToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            artifacts_folder=(str, Field(description="Folder path containing artifacts to process", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': OCRToolkit.toolkit_max_length})),
+            artifacts_folder=(str, Field(description="Folder path containing artifacts to process", json_schema_extra={'toolkit_name': True})),
             tesseract_settings=(dict, Field(description="Settings for Tesseract OCR processing", default={})),
             structured_output=(bool, Field(description="Whether to return structured JSON output", default=False)),
             expected_fields=(dict, Field(description="Expected fields for structured output", default={})),
@@ -47,16 +45,19 @@ class OCRToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         ocr_api_wrapper = OCRApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = ocr_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=ocr_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         return cls(tools=tools)

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

@@ -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,15 +21,13 @@ 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"],
@@ -41,16 +39,19 @@ 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"],
+                name=tool["name"],
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         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':
@@ -162,35 +162,17 @@ class PandasWrapper(BaseToolApiWrapper):
         """Analyze and process using query on dataset""" 
         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="process_query",
+                             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"
-                }
-            )
+            self._log_tool_event(tool_name="process_query",
+                                 message=f"Executing generated code... \n\n```python\n{code}\n```")
             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"
-            }
-        )
+        self._log_tool_event(tool_name="process_query",
+                             message=f"Executing generated code... \n\n```python\n{code}\n```")
         if result.get("df") is not None:
             df = result.pop("df")
             # Not saving dataframe to artifact repo for now

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,19 +86,21 @@ 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}",
+                description=description,
                 args_schema=tool["args_schema"]
             ))
         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: