alita-sdk 0.3.163__py3-none-any.whl → 0.3.164__py3-none-any.whl

alita_sdk/runtime/langchain/assistant.py

@@ -61,8 +61,8 @@ class Assistant:
                                 "Review toolkits configuration or use pipeline as master agent.")
 
         # configure memory store if memory tool is defined
-        # memory_tool = next((tool for tool in data['tools'] if tool['type'] == 'memory'), None)
-        # self._configure_store(memory_tool)
+        memory_tool = next((tool for tool in data['tools'] if tool['type'] == 'memory'), None)
+        self._configure_store(memory_tool)
         
         # Lazy import to avoid circular dependency
         from ..toolkits.tools import get_tools

alita_sdk/runtime/langchain/store_manager.py

@@ -1,6 +1,8 @@
 import threading
 import atexit
 import logging
+from urllib.parse import urlparse, unquote
+
 from psycopg import Connection
 from langgraph.store.postgres import PostgresStore
 
@@ -18,11 +20,30 @@ class StoreManager:
                     cls._instance._stores = {}
         return cls._instance
 
+    def _parse_connection_string(self, conn_str: str) -> dict:
+        """
+        Parse the connection string from SQLAlchemy style to args dict.
+        """
+        if conn_str.startswith("postgresql+psycopg://"):
+            url = conn_str[len("postgresql+psycopg://"):]
+
+        parsed = urlparse(f"//{url}")
+
+        return {
+            "user": unquote(parsed.username) if parsed.username else None,
+            "password": unquote(parsed.password) if parsed.password else None,
+            "host": parsed.hostname,
+            "port": parsed.port,
+            "dbname": parsed.path.lstrip("/") if parsed.path else None
+        }
+
     def get_store(self, conn_str: str) -> PostgresStore:
         store = self._stores.get(conn_str)
         if store is None:
             logger.info(f"Creating new PostgresStore for connection: {conn_str}")
-            conn = Connection.connect(conn_str, autocommit=True, prepare_threshold=0)
+            conn_params = self._parse_connection_string(conn_str)
+            conn_params.update({'autocommit': True, 'prepare_threshold': 0})
+            conn = Connection.connect(**conn_params)
             store = PostgresStore(conn)
             store.setup()
             self._stores[conn_str] = store

alita_sdk/runtime/toolkits/tools.py

@@ -95,7 +95,7 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
     # Add community tools
     tools += community_tools(tools_list, alita_client, llm)
     # Add alita tools
-    tools += alita_tools(tools_list, alita_client, llm)
+    tools += alita_tools(tools_list, alita_client, llm, memory_store)
     # Add MCP tools
     tools += _mcp_tools(tools_list, alita_client)
     

alita_sdk/tools/__init__.py

@@ -1,5 +1,8 @@
 import logging
 from importlib import import_module
+from typing import Optional
+
+from langgraph.store.base import BaseStore
 
 logger = logging.getLogger(__name__)
 
@@ -74,6 +77,7 @@ _safe_import_tool('carrier', 'carrier', 'get_tools', 'AlitaCarrierToolkit')
 _safe_import_tool('ocr', 'ocr', 'get_tools', 'OCRToolkit')
 _safe_import_tool('pptx', 'pptx', 'get_tools', 'PPTXToolkit')
 _safe_import_tool('postman', 'postman', 'get_tools', 'PostmanToolkit')
+_safe_import_tool('memory', 'memory', 'get_tools', 'MemoryToolkit')
 _safe_import_tool('zephyr_squad', 'zephyr_squad', 'get_tools', 'ZephyrSquadToolkit')
 
 # Log import summary
@@ -81,7 +85,7 @@ available_count = len(AVAILABLE_TOOLS)
 total_attempted = len(AVAILABLE_TOOLS) + len(FAILED_IMPORTS)
 logger.info(f"Tool imports completed: {available_count}/{total_attempted} successful")
 
-def get_tools(tools_list, alita, llm, *args, **kwargs):
+def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args, **kwargs):
     tools = []
     for tool in tools_list:
         # validate tool name syntax - it cannot be started with _
@@ -91,6 +95,7 @@ def get_tools(tools_list, alita, llm, *args, **kwargs):
         
         tool['settings']['alita'] = alita
         tool['settings']['llm'] = llm
+        tool['settings']['store'] = store
         tool_type = tool['type']
         
         # Check if tool is available and has get_tools function

alita_sdk/tools/carrier/api_wrapper.py

@@ -80,8 +80,8 @@ class CarrierAPIWrapper(BaseModel):
     def get_report_file_log(self, bucket: str, file_name: str):
         return self._client.get_report_file_log(bucket, file_name)
 
-    def upload_excel_report(self, bucket_name: str, excel_report_name: str):
-        return self._client.upload_excel_report(bucket_name, excel_report_name)
+    def upload_file(self, bucket_name: str, file_name: str):
+        return self._client.upload_file(bucket_name, file_name)
 
     def get_ui_reports_list(self) -> List[Dict[str, Any]]:
         """Get list of UI test reports from the Carrier platform."""

alita_sdk/tools/carrier/backend_reports_tool.py

@@ -1,6 +1,8 @@
 import logging
 from datetime import datetime
 import json
+import zipfile
+from itertools import islice
 import traceback
 from typing import Type
 from langchain_core.tools import BaseTool, ToolException
@@ -78,14 +80,31 @@ class GetReportByIDTool(BaseTool):
 
     def _run(self, report_id: str):
         try:
-            reports = self.api_wrapper.get_reports_list()
-            report_data = {}
-            for report in reports:
-                if report_id == str(report["id"]):
-                    report_data = report
-                    break
-
-            return json.dumps(report_data)
+            report, test_log_file_path, errors_log_file_path = self.api_wrapper.get_report_file_name(report_id)
+            try:
+                with open(errors_log_file_path, mode='r') as f:
+                    # Use islice to read up to 100 lines
+                    errors = list(islice(f, 100))
+                report["errors_log"] = errors
+                # Archive with errors log file path
+                zip_file_path = f'/tmp/{report["build_id"]}_error_log_archive.zip'
+
+                # Create zip archive
+                with zipfile.ZipFile(zip_file_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                    arcname = os.path.basename(errors_log_file_path)
+                    zipf.write(errors_log_file_path, arcname)
+
+                bucket_name = report["name"].replace("_", "").replace(" ", "").lower()
+                self.api_wrapper.upload_file(bucket_name, zip_file_path)
+                report["link_to_errors_file"] = f"{self.api_wrapper.url.rstrip('/')}/api/v1/artifacts/artifact/default/" \
+                                                f"{self.api_wrapper.project_id}/{bucket_name}/" \
+                                                f"{zip_file_path.replace('/tmp/', '')}"
+            except Exception as e:
+                logger.error(e)
+                report["errors_log"] = []
+                report["link_to_errors_file"] = "link is not available"
+
+            return json.dumps(report)
         except Exception:
             stacktrace = traceback.format_exc()
             logger.error(f"Error downloading reports: {stacktrace}")
@@ -164,17 +183,17 @@ class CreateExcelReportTool(BaseTool):
 
     def _process_report_by_id(self, report_id, parameters):
         """Process report using report ID."""
-        report, file_path = self.api_wrapper.get_report_file_name(report_id)
+        report, test_log_file_path, errors_log_file_path = self.api_wrapper.get_report_file_name(report_id)
         carrier_report = f"{self.api_wrapper.url.rstrip('/')}/-/performance/backend/results?result_id={report_id}"
         lg_type = report.get("lg_type")
         excel_report_file_name = f'/tmp/reports_test_results_{report["build_id"]}_excel_report.xlsx'
         bucket_name = report["name"].replace("_", "").replace(" ", "").lower()
 
-        result_stats_j = self._parse_report(file_path, lg_type, parameters["think_time"], is_absolute_file_path=True)
+        result_stats_j = self._parse_report(test_log_file_path, lg_type, parameters["think_time"], is_absolute_file_path=True)
         calc_thr_j = self._calculate_thresholds(result_stats_j, parameters)
 
         return self._generate_and_upload_report(
-            result_stats_j, carrier_report, calc_thr_j, parameters, excel_report_file_name, bucket_name, file_path
+            result_stats_j, carrier_report, calc_thr_j, parameters, excel_report_file_name, bucket_name, test_log_file_path
         )
 
     def _process_report_by_file(self, bucket, file_name, parameters):
@@ -233,7 +252,7 @@ class CreateExcelReportTool(BaseTool):
         excel_reporter_object.prepare_headers_and_titles()
         excel_reporter_object.write_to_excel(result_stats_j, carrier_report, calc_thr_j, parameters["pct"])
 
-        self.api_wrapper.upload_excel_report(bucket_name, excel_report_file_name)
+        self.api_wrapper.upload_file(bucket_name, excel_report_file_name)
 
         # Clean up
         self._cleanup(file_path, excel_report_file_name)

alita_sdk/tools/carrier/backend_tests_tool.py

@@ -80,22 +80,28 @@ class RunTestByIDTool(BaseTool):
     description: str = "Execute test plan from the Carrier platform."
     args_schema: Type[BaseModel] = create_model(
         "RunTestByIdInput",
-        test_id=(str, Field(default="", description="Test id to execute")),
+        test_id=(str, Field(default=None, description="Test id to execute")),
+        name=(str, Field(default=None, description="Test name to execute")),
         test_parameters=(dict, Field(default=None, description="Test parameters to override")),
     )
 
-    def _run(self, test_id: str, test_parameters=None):
+    def _run(self, test_id=None, name=None, test_parameters=None):
         try:
+            if not test_id and not name:
+                return {"message": "Please provide test id or test name to start"}
+
             # Fetch test data
             tests = self.api_wrapper.get_tests_list()
-            test_data = {}
-            for test in tests:
-                if test_id == str(test["id"]):
-                    test_data = test
-                    break
+
+            # Find the test data based on test_id or name
+            test_data = next(
+                (test for test in tests if
+                 (test_id and str(test["id"]) == test_id) or (name and str(test["name"]) == name)),
+                None
+            )
 
             if not test_data:
-                raise ValueError(f"Test with id {test_id} not found.")
+                raise ValueError(f"Test with id {test_id} or name {name} not found.")
 
             # Default test parameters
             default_test_parameters = test_data.get("test_parameters", [])

alita_sdk/tools/carrier/carrier_sdk.py

@@ -128,15 +128,17 @@ class CarrierClient(BaseModel):
         for file_name in file_list:
             if file_name.startswith(report_archive_prefix) and "excel_report" not in file_name:
                 report_files_list.append(file_name)
-        file_path = self.download_and_merge_reports(report_files_list, lg_type, bucket_name, extract_to)
+        test_log_file_path, errors_log_file_path = self.download_and_merge_reports(report_files_list, lg_type, bucket_name, extract_to)
 
-        return report_info, file_path
+        return report_info, test_log_file_path, errors_log_file_path
 
-    def download_and_merge_reports(self, report_files_list: list, lg_type: str, bucket: str, extract_to: str = "/tmp") -> str:
+    def download_and_merge_reports(self, report_files_list: list, lg_type: str, bucket: str, extract_to: str = "/tmp"):
         if lg_type == "jmeter":
             summary_log_file_path = f"summary_{bucket}_jmeter.jtl"
+            error_log_file_path = f"error_{bucket}_jmeter.log"
         else:
             summary_log_file_path = f"summary_{bucket}_simulation.log"
+            error_log_file_path = f"error_{bucket}_simulation.log"
         extracted_reports = []
         for each in report_files_list:
             endpoint = f"api/v1/artifacts/artifact/{self.credentials.project_id}/{bucket}/{each}"
@@ -158,10 +160,21 @@ class CarrierClient(BaseModel):
                 os.remove(local_file_path)
             extracted_reports.append(extract_dir)
 
-        # get files from extract_dirs and merge to summary_log_file_path
+        # get files from extract_dirs and merge to summary_log_file_path and error_log_file_path
         self.merge_log_files(summary_log_file_path, extracted_reports, lg_type)
+        try:
+            self.merge_error_files(error_log_file_path, extracted_reports)
+        except Exception as e:
+            logger.error(f"Failed to merge errors log: {e}")
+
+        # Clean up
+        for each in extracted_reports:
+            try:
+                shutil.rmtree(each)
+            except Exception as e:
+                logger.error(e)
 
-        return summary_log_file_path
+        return summary_log_file_path, error_log_file_path
 
     def merge_log_files(self, summary_file, extracted_reports, lg_type):
         with open(summary_file, mode='w') as summary:
@@ -178,11 +191,14 @@ class CarrierClient(BaseModel):
                     else:
                         # Skip the first line (header) for subsequent files
                         summary.writelines(lines[1:])
-        for each in extracted_reports:
-            try:
-                shutil.rmtree(each)
-            except Exception as e:
-                logger.error(e)
+
+    def merge_error_files(self, error_file, extracted_reports):
+        with open(error_file, mode='w') as summary_errors:
+            for i, log_file in enumerate(extracted_reports):
+                report_file = f"{log_file}/simulation-errors.log"
+                with open(report_file, mode='r') as f:
+                    lines = f.readlines()
+                    summary_errors.writelines(lines)
 
     def get_report_file_log(self, bucket: str, file_name: str):
         bucket_endpoint = f"api/v1/artifacts/artifact/default/{self.credentials.project_id}/{bucket}/{file_name}"
@@ -195,10 +211,10 @@ class CarrierClient(BaseModel):
             f.write(response.content)
         return file_path
 
-    def upload_excel_report(self, bucket_name: str, excel_report_name: str):
+    def upload_file(self, bucket_name: str, file_name: str):
         upload_url = f'api/v1/artifacts/artifacts/{self.credentials.project_id}/{bucket_name}'
         full_url = f"{self.credentials.url.rstrip('/')}/{upload_url.lstrip('/')}"
-        files = {'file': open(excel_report_name, 'rb')}
+        files = {'file': open(file_name, 'rb')}
         headers = {'Authorization': f'bearer {self.credentials.token}'}
         s3_config = {'integration_id': 1, 'is_local': False}
         requests.post(full_url, params=s3_config, allow_redirects=True, files=files, headers=headers)
@@ -231,22 +247,22 @@ class CarrierClient(BaseModel):
     def create_ui_test(self, json_body: Dict[str, Any]) -> Dict[str, Any]:
         """Create a new UI test."""
         endpoint = f"api/v1/ui_performance/tests/{self.credentials.project_id}"
-        
+
         # Print full JSON POST body for debugging
         print("=" * 60)
         print("DEBUG: Full JSON POST body for create_ui_test:")
         print("=" * 60)
         print(json.dumps(json_body, indent=2))
         print("=" * 60)
-        
+
         # Use multipart/form-data with data field containing the JSON body
         form_data = {'data': json.dumps(json_body)}
-        
+
         # Temporarily remove Content-Type header to let requests set it for multipart
         original_headers = self.session.headers.copy()
         if 'Content-Type' in self.session.headers:
             del self.session.headers['Content-Type']
-        
+
         try:
             full_url = f"{self.credentials.url.rstrip('/')}/{endpoint.lstrip('/')}"
             response = self.session.post(full_url, data=form_data)
@@ -265,7 +281,7 @@ class CarrierClient(BaseModel):
     def cancel_ui_test(self, test_id: str) -> Dict[str, Any]:
         """Cancel a UI test by setting its status to Canceled."""
         endpoint = f"api/v1/ui_performance/report_status/{self.credentials.project_id}/{test_id}"
-        
+
         cancel_body = {
             "test_status": {
                 "status": "Canceled",
@@ -273,5 +289,5 @@ class CarrierClient(BaseModel):
                 "description": "Test was canceled"
             }
         }
-        
+
         return self.request('put', endpoint, json=cancel_body)

alita_sdk/tools/carrier/create_ui_excel_report_tool.py

@@ -148,7 +148,7 @@ class CreateUIExcelReportTool(BaseTool):
             bucket_name = report_name.replace("_", "").replace(" ", "").lower()
             excel_file_basename = os.path.basename(excel_file_name)
             
-            self.api_wrapper.upload_excel_report(bucket_name, excel_file_name)
+            self.api_wrapper.upload_file(bucket_name, excel_file_name)
             
             # Clean up temporary file
             if os.path.exists(excel_file_name):

alita_sdk/tools/memory/__init__.py

@@ -15,6 +15,13 @@ 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'])),
+        store=tool['settings'].get('store', None),
+        toolkit_name=tool.get('toolkit_name', '')
+).get_tools()
+
 class MemoryToolkit(BaseToolkit):
     tools: List[BaseTool] = []
 

alita_sdk/tools/postman/__init__.py

@@ -1,4 +1,5 @@
 from typing import List, Literal, Optional, Type
+import json
 
 import requests
 from langchain_core.tools import BaseToolkit, BaseTool
@@ -25,6 +26,8 @@ class PostmanAction(BaseAction):
         return v.replace(' ', '')
 
 def get_tools(tool):
+    # Parse environment_config if it's a string (from UI)
+    environment_config = tool['settings'].get('environment_config', {})
     toolkit = PostmanToolkit.get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         api_key=tool['settings'].get('api_key', None),
@@ -32,6 +35,7 @@ def get_tools(tool):
             'base_url', 'https://api.getpostman.com'),
         collection_id=tool['settings'].get('collection_id', None),
         workspace_id=tool['settings'].get('workspace_id', None),
+        environment_config=environment_config,
         toolkit_name=tool.get('toolkit_name')
     )
     return toolkit.tools
@@ -57,6 +61,9 @@ class PostmanToolkit(BaseToolkit):
                            'toolkit_name': True, 'max_toolkit_length': PostmanToolkit.toolkit_max_length})),
             workspace_id=(str, Field(description="Default workspace ID",
                           default="", json_schema_extra={'configuration': True})),
+            environment_config=(dict, Field(
+                description="JSON configuration for request execution (auth headers, project IDs, base URLs, etc.)",
+                default={})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(
                 default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {

alita_sdk/tools/postman/api_wrapper.py

@@ -256,6 +256,12 @@ PostmanGetRequestScript = create_model(
     script_type=(str, Field(description="The type of script to retrieve: 'test' or 'prerequest'", default="prerequest"))
 )
 
+PostmanExecuteRequest = create_model(
+    "PostmanExecuteRequest",
+    request_path=(str, Field(description="The path to the request in the collection (e.g., 'API/Users/Get User')")),
+    override_variables=(Optional[Dict[str, Any]], Field(description="Optional variables to override environment/collection variables", default=None))
+)
+
 
 class PostmanApiWrapper(BaseToolApiWrapper):
     """Wrapper for Postman API."""
@@ -264,6 +270,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     base_url: str = "https://api.getpostman.com"
     collection_id: Optional[str] = None
     workspace_id: Optional[str] = None
+    environment_config: dict = {}
     timeout: int = 30
     session: Any = None
     analyzer: PostmanAnalyzer = None
@@ -318,6 +325,108 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Invalid JSON response from Postman API: {str(e)}")
 
+    def _apply_authentication(self, headers, params, all_variables, resolve_variables):
+        """Apply authentication based on environment_config auth settings.
+        
+        Supports multiple authentication types:
+        - bearer: Bearer token in Authorization header
+        - basic: Basic authentication in Authorization header  
+        - api_key: API key in header, query parameter, or cookie
+        - oauth2: OAuth2 access token in Authorization header
+        - custom: Custom headers, cookies, or query parameters
+        
+        Required format:
+        environment_config = {
+            "auth": {
+                "type": "bearer|basic|api_key|oauth2|custom",
+                "params": {
+                    # type-specific parameters
+                }
+            }
+        }
+        """
+        import base64
+        
+        # Handle structured auth configuration only - no backward compatibility
+        auth_config = self.environment_config.get('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', '')))
+                if token:
+                    headers['Authorization'] = f'Bearer {token}'
+                    
+            elif auth_type == 'basic':
+                # Basic authentication
+                username = resolve_variables(str(auth_params.get('username', '')))
+                password = resolve_variables(str(auth_params.get('password', '')))
+                if username and password:
+                    credentials = base64.b64encode(f"{username}:{password}".encode()).decode()
+                    headers['Authorization'] = f'Basic {credentials}'
+                    
+            elif auth_type == 'api_key':
+                # API key authentication
+                key_name = resolve_variables(str(auth_params.get('key', '')))
+                key_value = resolve_variables(str(auth_params.get('value', '')))
+                key_location = auth_params.get('in', 'header').lower()
+                
+                if key_name and key_value:
+                    if key_location == 'header':
+                        headers[key_name] = key_value
+                    elif key_location == 'query':
+                        params[key_name] = key_value
+                    elif key_location == 'cookie':
+                        # Add to Cookie header
+                        existing_cookies = headers.get('Cookie', '')
+                        new_cookie = f"{key_name}={key_value}"
+                        if existing_cookies:
+                            headers['Cookie'] = f"{existing_cookies}; {new_cookie}"
+                        else:
+                            headers['Cookie'] = new_cookie
+                            
+            elif auth_type == 'oauth2':
+                # OAuth2 access token
+                access_token = resolve_variables(str(auth_params.get('access_token', '')))
+                if access_token:
+                    headers['Authorization'] = f'Bearer {access_token}'
+                    
+            elif auth_type == 'custom':
+                # Custom authentication - allows full control
+                custom_headers = auth_params.get('headers', {})
+                custom_cookies = auth_params.get('cookies', {})
+                custom_query = auth_params.get('query', {})
+                
+                # Add custom headers
+                for key, value in custom_headers.items():
+                    resolved_key = resolve_variables(str(key))
+                    resolved_value = resolve_variables(str(value))
+                    headers[resolved_key] = resolved_value
+                
+                # Add custom query parameters
+                for key, value in custom_query.items():
+                    resolved_key = resolve_variables(str(key))
+                    resolved_value = resolve_variables(str(value))
+                    params[resolved_key] = resolved_value
+                
+                # Add custom cookies
+                if custom_cookies:
+                    cookie_parts = []
+                    for key, value in custom_cookies.items():
+                        resolved_key = resolve_variables(str(key))
+                        resolved_value = resolve_variables(str(value))
+                        cookie_parts.append(f"{resolved_key}={resolved_value}")
+                    
+                    existing_cookies = headers.get('Cookie', '')
+                    new_cookies = "; ".join(cookie_parts)
+                    if existing_cookies:
+                        headers['Cookie'] = f"{existing_cookies}; {new_cookies}"
+                    else:
+                        headers['Cookie'] = new_cookies
+
+
     def get_available_tools(self):
         """Return list of available tools with their configurations."""
         return [
@@ -398,6 +507,13 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "args_schema": PostmanAnalyze,
                 "ref": self.analyze
             },
+            {
+                "name": "execute_request",
+                "mode": "execute_request",
+                "description": "Execute a Postman request with environment variables and custom configuration",
+                "args_schema": PostmanExecuteRequest,
+                "ref": self.execute_request
+            },
             # {
             #     "name": "create_collection",
             #     "mode": "create_collection",
@@ -583,6 +699,224 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(f"Exception when getting collections: {stacktrace}")
             raise ToolException(f"Unable to get collections: {str(e)}")
 
+    def execute_request(self, request_path: str, override_variables: Dict = None, **kwargs) -> str:
+        """Execute a Postman request with environment variables and custom configuration.
+        
+        This method uses the environment_config to make actual HTTP requests 
+        using the requests library with structured authentication.
+        
+        Args:
+            request_path: The path to the request in the collection
+            override_variables: Optional variables to override environment/collection variables
+        
+        Returns:
+            JSON string with comprehensive response data
+        """
+        try:
+            import time
+            from urllib.parse import urlencode, parse_qs, urlparse
+            
+            # Get the request from the collection
+            request_item, _, collection_data = self._get_request_item_and_id(request_path)
+            request_data = request_item.get('request', {})
+            
+            # Gather all variables from different sources
+            all_variables = {}
+            
+            # 1. Start with environment_config variables (lowest priority)
+            all_variables.update(self.environment_config)
+            
+            # 2. Add collection variables
+            collection_variables = collection_data.get('variable', [])
+            for var in collection_variables:
+                if isinstance(var, dict) and 'key' in var:
+                    all_variables[var['key']] = var.get('value', '')
+            
+            # 3. Add override variables (highest priority)
+            if override_variables:
+                all_variables.update(override_variables)
+            
+            # Helper function to resolve variables in strings
+            def resolve_variables(text):
+                if not isinstance(text, str):
+                    return text
+                
+                # Replace {{variable}} patterns
+                import re
+                def replace_var(match):
+                    var_name = match.group(1)
+                    return str(all_variables.get(var_name, match.group(0)))
+                
+                return re.sub(r'\{\{([^}]+)\}\}', replace_var, text)
+            
+            # Prepare the request
+            method = request_data.get('method', 'GET').upper()
+            
+            # Handle URL
+            url_data = request_data.get('url', '')
+            if isinstance(url_data, str):
+                url = resolve_variables(url_data)
+                params = {}
+            else:
+                # URL is an object
+                raw_url = resolve_variables(url_data.get('raw', ''))
+                url = raw_url
+                
+                # Extract query parameters
+                params = {}
+                query_params = url_data.get('query', [])
+                for param in query_params:
+                    if isinstance(param, dict) and not param.get('disabled', False):
+                        key = resolve_variables(param.get('key', ''))
+                        value = resolve_variables(param.get('value', ''))
+                        if key:
+                            params[key] = value
+            
+            # Prepare headers
+            headers = {}
+            
+            # Handle authentication from environment_config
+            self._apply_authentication(headers, params, all_variables, resolve_variables)
+            
+            # Add headers from request
+            request_headers = request_data.get('header', [])
+            for header in request_headers:
+                if isinstance(header, dict) and not header.get('disabled', False):
+                    key = resolve_variables(header.get('key', ''))
+                    value = resolve_variables(header.get('value', ''))
+                    if key:
+                        headers[key] = value
+            
+            # Prepare body
+            body = None
+            content_type = headers.get('Content-Type', '').lower()
+            
+            request_body = request_data.get('body', {})
+            if request_body:
+                body_mode = request_body.get('mode', '')
+                
+                if body_mode == 'raw':
+                    raw_body = request_body.get('raw', '')
+                    body = resolve_variables(raw_body)
+                    
+                    # Try to parse as JSON if content type suggests it
+                    if 'application/json' in content_type:
+                        try:
+                            # Validate JSON
+                            json.loads(body)
+                        except json.JSONDecodeError:
+                            logger.warning("Body is not valid JSON despite Content-Type")
+                    
+                elif body_mode == 'formdata':
+                    # Handle form data
+                    form_data = {}
+                    formdata_items = request_body.get('formdata', [])
+                    for item in formdata_items:
+                        if isinstance(item, dict) and not item.get('disabled', False):
+                            key = resolve_variables(item.get('key', ''))
+                            value = resolve_variables(item.get('value', ''))
+                            if key:
+                                form_data[key] = value
+                    body = form_data
+                    
+                elif body_mode == 'urlencoded':
+                    # Handle URL encoded data
+                    urlencoded_data = {}
+                    urlencoded_items = request_body.get('urlencoded', [])
+                    for item in urlencoded_items:
+                        if isinstance(item, dict) and not item.get('disabled', False):
+                            key = resolve_variables(item.get('key', ''))
+                            value = resolve_variables(item.get('value', ''))
+                            if key:
+                                urlencoded_data[key] = value
+                    body = urlencode(urlencoded_data)
+                    if 'content-type' not in [h.lower() for h in headers.keys()]:
+                        headers['Content-Type'] = 'application/x-www-form-urlencoded'
+            
+            # Execute the request
+            start_time = time.time()
+            
+            logger.info(f"Executing {method} request to {url}")
+            
+            # Create a new session for this request (separate from Postman API session)
+            exec_session = requests.Session()
+            
+            # Prepare request kwargs
+            request_kwargs = {
+                'timeout': self.timeout,
+                'params': params if params else None,
+                'headers': headers if headers else None
+            }
+            
+            # Add body based on content type and method
+            if body is not None and method in ['POST', 'PUT', 'PATCH']:
+                if isinstance(body, dict):
+                    # Form data
+                    request_kwargs['data'] = body
+                elif isinstance(body, str):
+                    if 'application/json' in content_type:
+                        request_kwargs['json'] = json.loads(body) if body.strip() else {}
+                    else:
+                        request_kwargs['data'] = body
+                else:
+                    request_kwargs['data'] = body
+            
+            # Execute the request
+            response = exec_session.request(method, url, **request_kwargs)
+            
+            end_time = time.time()
+            elapsed_time = end_time - start_time
+            
+            # Parse response
+            response_data = {
+                "request": {
+                    "path": request_path,
+                    "method": method,
+                    "url": url,
+                    "headers": dict(headers) if headers else {},
+                    "params": dict(params) if params else {},
+                    "body": body if body is not None else None
+                },
+                "response": {
+                    "status_code": response.status_code,
+                    "status_text": response.reason,
+                    "headers": dict(response.headers),
+                    "elapsed_time_seconds": round(elapsed_time, 3),
+                    "size_bytes": len(response.content)
+                },
+                "variables_used": dict(all_variables),
+                "success": response.ok
+            }
+            
+            # Add response body
+            try:
+                # Try to parse as JSON
+                response_data["response"]["body"] = response.json()
+                response_data["response"]["content_type"] = "application/json"
+            except json.JSONDecodeError:
+                # Fall back to text
+                try:
+                    response_data["response"]["body"] = response.text
+                    response_data["response"]["content_type"] = "text/plain"
+                except UnicodeDecodeError:
+                    # Binary content
+                    response_data["response"]["body"] = f"<binary content: {len(response.content)} bytes>"
+                    response_data["response"]["content_type"] = "binary"
+            
+            # Add error details if request failed
+            if not response.ok:
+                response_data["error"] = {
+                    "message": f"HTTP {response.status_code}: {response.reason}",
+                    "status_code": response.status_code
+                }
+            
+            return json.dumps(response_data, indent=2)
+            
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when executing request: {stacktrace}")
+            raise ToolException(f"Unable to execute request '{request_path}': {str(e)}")
+
     def get_collection(self, **kwargs) -> str:
         """Get a specific collection by ID."""
         try:
@@ -1699,6 +2033,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 # Check if this is a folder (has 'item' property) or a request
                 if 'item' in item:
                     # This is a folder
+                   
                     result['items'][current_path] = {
                         "type": "folder",
                         "id": item.get('id'),

{alita_sdk-0.3.163.dist-info → alita_sdk-0.3.164.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.163
+Version: 0.3.164
 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>
 License-Expression: Apache-2.0
@@ -31,8 +31,8 @@ Requires-Dist: langchain_community~=0.3.7; extra == "runtime"
 Requires-Dist: langchain-openai~=0.3.0; extra == "runtime"
 Requires-Dist: langgraph-checkpoint-sqlite~=2.0.0; extra == "runtime"
 Requires-Dist: langgraph-checkpoint-postgres~=2.0.1; extra == "runtime"
-Requires-Dist: langsmith==0.1.144; extra == "runtime"
-Requires-Dist: langgraph~=0.2.53; extra == "runtime"
+Requires-Dist: langsmith>=0.3.45; extra == "runtime"
+Requires-Dist: langgraph>=0.4.8; extra == "runtime"
 Requires-Dist: langchain_chroma~=0.2.2; extra == "runtime"
 Requires-Dist: langchain-unstructured~=0.1.6; extra == "runtime"
 Requires-Dist: langchain-postgres~=0.0.13; extra == "runtime"
@@ -122,6 +122,7 @@ Requires-Dist: yagmail==0.15.293; extra == "tools"
 Requires-Dist: pysnc==1.1.10; extra == "tools"
 Requires-Dist: shortuuid==1.0.13; extra == "tools"
 Requires-Dist: yarl==1.17.1; extra == "tools"
+Requires-Dist: langmem==0.0.27; extra == "tools"
 Provides-Extra: community
 Requires-Dist: retry-extended==0.2.3; extra == "community"
 Requires-Dist: browser-use==0.1.43; extra == "community"

{alita_sdk-0.3.163.dist-info → alita_sdk-0.3.164.dist-info}/RECORD

@@ -48,14 +48,14 @@ alita_sdk/runtime/clients/client.py,sha256=jbC_M72CybwZgFfMRL6paj-NmICrSuk1vVnVT
 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
-alita_sdk/runtime/langchain/assistant.py,sha256=1G4yBhBc-tXgqerujUVu5Z8T49m_7ov-7zYYsm-jGb4,7511
+alita_sdk/runtime/langchain/assistant.py,sha256=QJEMiEOrFMJ4GpnK24U2pKFblrvdQpKFdfhZsI2wAUI,7507
 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=BkrbYMy4BPAvy9uANH3s9ffBzaGewKFK97evN90L5kY,39917
 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=2MSbk8Zy969R2YjA5lV6qIPoFRPZYAIUHyoK_2apoGw,1420
+alita_sdk/runtime/langchain/store_manager.py,sha256=w5-0GbPGJAw14g0CCD9BKFMznzk1I-iJ5OGj_HZJZgA,2211
 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
@@ -102,7 +102,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=gCIEtdeD9u-za-oIZtJ916r9oSR9_0gCWE5FIKynWdU,6148
+alita_sdk/runtime/toolkits/tools.py,sha256=TfnXSDMPlCt-L_CcV59XQNqkH1bzyu0bh9k9CijJWT4,6162
 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
@@ -129,7 +129,7 @@ alita_sdk/runtime/utils/logging.py,sha256=svPyiW8ztDfhqHFITv5FBCj8UhLxz6hWcqGIY6
 alita_sdk/runtime/utils/save_dataframe.py,sha256=i-E1wp-t4wb17Zq3nA3xYwgSILjoXNizaQAA9opWvxY,1576
 alita_sdk/runtime/utils/streamlit.py,sha256=z4J_bdxkA0zMROkvTB4u379YBRFCkKh-h7PD8RlnZWQ,85644
 alita_sdk/runtime/utils/utils.py,sha256=dM8whOJAuFJFe19qJ69-FLzrUp6d2G-G6L7d4ss2XqM,346
-alita_sdk/tools/__init__.py,sha256=Ttjp6AVkjuh-WqGE_cc_nUwi4qvU1khf7_BVKdwO7gU,9801
+alita_sdk/tools/__init__.py,sha256=iuEQDwXHY8MQvHt6qIkYpXD7VC_3no-iVgDCpHqwIy4,10018
 alita_sdk/tools/elitea_base.py,sha256=NQaIxPX6DVIerHCb18jwUR6maZxxk73NZaTsFHkBQWE,21119
 alita_sdk/tools/ado/__init__.py,sha256=mD6GHcYMTtffPJkJvFPe2rzvye_IRmXmWfI7xYuZhO4,912
 alita_sdk/tools/ado/utils.py,sha256=PTCludvaQmPLakF2EbCGy66Mro4-rjDtavVP-xcB2Wc,1252
@@ -160,12 +160,12 @@ alita_sdk/tools/browser/google_search_rag.py,sha256=QVHFbVwymiJGuno_HLSJOK1c_Mpg
 alita_sdk/tools/browser/utils.py,sha256=4k3YM_f1Kqlhjz9vt2pNsGkvCjhy-EmY3nvcwdFCsLA,2501
 alita_sdk/tools/browser/wiki.py,sha256=Qh3HBFd4dkS2VavXbFJOm4b8SjVSIe5xSD7CY1vEkKE,1126
 alita_sdk/tools/carrier/__init__.py,sha256=pP-nk-dpqOkrvwcRY_szgwqoowyVNl_GobD4Inp-Qus,4435
-alita_sdk/tools/carrier/api_wrapper.py,sha256=smcc1Q7H6U1_18qDYBFpeGnu5cX3OrsUoKaSn3s6vkw,8728
-alita_sdk/tools/carrier/backend_reports_tool.py,sha256=WNZVGBIZusakOdbd7lG6o6xL180VZfER-uDw_SSGupo,11005
-alita_sdk/tools/carrier/backend_tests_tool.py,sha256=arq275qiP9t3ST-MPn7FlxbLLSPiIGEnyPdgJ-AvOoQ,5917
+alita_sdk/tools/carrier/api_wrapper.py,sha256=Y_Qznko3ReDZipDn64_IivehdN92hUpX0HLCfiLpYTw,8696
+alita_sdk/tools/carrier/backend_reports_tool.py,sha256=2Z1DCt6f0XTrQcEoynxMFUnenhtYMuIt_epq4YBSLDE,12234
+alita_sdk/tools/carrier/backend_tests_tool.py,sha256=Y1Va-VxDtnbRvrEdlwe63t-oDvqzQv5jxZW1eH0XeTY,6246
 alita_sdk/tools/carrier/cancel_ui_test_tool.py,sha256=pD1sKEcZGBWJqFpgjeohMk93uuUPWruVJRPVVg90rpo,6438
-alita_sdk/tools/carrier/carrier_sdk.py,sha256=sYdPWcpH8ti0MggOvU2pbsKYiaKR1zuXlbiCtcTfc3A,12913
-alita_sdk/tools/carrier/create_ui_excel_report_tool.py,sha256=sYAz54ILk8CIF_n76zH_hcmbW9xw7oTNnf_d9d-N-_Q,20171
+alita_sdk/tools/carrier/carrier_sdk.py,sha256=wb3d1W6dvo5NRLMiJcBcKy663J6IkbTwpKFTZX30QFQ,13672
+alita_sdk/tools/carrier/create_ui_excel_report_tool.py,sha256=8aSpkyIGXsOBTo8Ye_6p19v8OOl1y7QW47IJxZ6QDgM,20163
 alita_sdk/tools/carrier/create_ui_test_tool.py,sha256=sHi7-D1uqIUHEyoywI92h6MdUVybKfBXs_XttTu-Ck4,8624
 alita_sdk/tools/carrier/excel_reporter.py,sha256=fXptz7iaBDBcFSc8Ah8nZ9CSgugTONc5JMC1XcQEnfM,21487
 alita_sdk/tools/carrier/lighthouse_excel_reporter.py,sha256=mVuU63tl2n-Gntx9RuedjEU0U5AP1APKsSx1DvJs7wk,6684
@@ -254,7 +254,7 @@ alita_sdk/tools/llm/llm_utils.py,sha256=v3_lWP_Nk6tJLkj0BYohOun0OWNfvzqLjPdPAMl-
 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=QBzuOQapovmbcFS4nG39p3g-fUPp3kQrjh8EGk6VmBs,1901
+alita_sdk/tools/memory/__init__.py,sha256=SOB5Lhf8v8v0-IDUXUgb1KNdv5je-ooi6oGor8iYPpI,2148
 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
@@ -278,8 +278,8 @@ alita_sdk/tools/pandas/statsmodels/base_stats.py,sha256=jeKW1KfyaNi4M6wkru2iXHNr
 alita_sdk/tools/pandas/statsmodels/descriptive.py,sha256=APdofBnEiRhMrn6tLKwH076NPp5uHe8VwmblN3lQLfQ,10217
 alita_sdk/tools/pandas/statsmodels/hypothesis_testing.py,sha256=fdNAayMB3W7avMfKJCcbf2_P54vUXbq8KVebOB48348,10508
 alita_sdk/tools/pandas/statsmodels/regression.py,sha256=Y1pWK4u_qzrfA740K-FX0nZ5FREGGPk8mfvykPIYoiI,9164
-alita_sdk/tools/postman/__init__.py,sha256=W0HdtACnTZw6tnzj7_qY_X5RoRyX3czcUSVaZJjBW-Y,4236
-alita_sdk/tools/postman/api_wrapper.py,sha256=DvdZtLPpe6LpsGfsF38UmNyDHjORwWWutisd5AVIogg,78094
+alita_sdk/tools/postman/__init__.py,sha256=mrRwZlmpWh9zMrdNmq1QLu69E-7sA1uwzL8UDs-gaRo,4617
+alita_sdk/tools/postman/api_wrapper.py,sha256=K7Vq06DX7uMeuhpnc3EQfYvc4szY0_ElrRf9P4FLlfk,93501
 alita_sdk/tools/postman/postman_analysis.py,sha256=2d-Oi2UORosIePIUyncSONw9hY7dw8Zc7BQvCd4aqpg,45115
 alita_sdk/tools/pptx/__init__.py,sha256=LNSTQk0BncfdWLXAOGX2WXezG3D4qSEuYwLpokmF9iM,3438
 alita_sdk/tools/pptx/pptx_wrapper.py,sha256=yyCYcTlIY976kJ4VfPo4dyxj4yeii9j9TWP6W8ZIpN8,29195
@@ -326,8 +326,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=UHVQUVqcBc3SZvDfO78HSuBzwAsRw
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=rq4jOb3lRW2GXvAguk4H1KinO5f-zpygzhBJf-E1Ucw,2773
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=iOMxyE7vOc_LwFB_nBMiSFXkNtvbptA4i-BrTlo7M0A,5854
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=IYUJoMFOMA70knLhLtAnuGoy3OK80RuqeQZ710oyIxE,3631
-alita_sdk-0.3.163.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.163.dist-info/METADATA,sha256=3Fd8T3ods52lKrlnTjGDxEAn_svB00x64xg65cCi8rY,18667
-alita_sdk-0.3.163.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.163.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.163.dist-info/RECORD,,
+alita_sdk-0.3.164.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.164.dist-info/METADATA,sha256=ua1W0SERtmM1b56h-ZR065ZopyUHC6YPXWV-mtCYPqM,18714
+alita_sdk-0.3.164.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.164.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.164.dist-info/RECORD,,