alita-sdk 0.3.163__tar.gz → 0.3.165__tar.gz

{alita_sdk-0.3.163 → alita_sdk-0.3.165}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.163
+Version: 0.3.165
 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 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/alita_sdk/tools/github/github_client.py

@@ -491,8 +491,16 @@ class GitHubClient(BaseModel):
         """
         try:
             patch_content = self.alita.download_artifact(bucket_name, file_name)
-            if not patch_content or not isinstance(patch_content, str):
+            
+            if not patch_content:
                 return {"error": "Patch file not found", "message": f"Patch file '{file_name}' not found in bucket '{bucket_name}'."}
+            
+            # Convert bytes to string if necessary
+            if isinstance(patch_content, bytes):
+                patch_content = patch_content.decode('utf-8')
+            elif not isinstance(patch_content, str):
+                return {"error": "Invalid patch content", "message": f"Patch file '{file_name}' contains invalid content type."}
+            
             # Apply the git patch using the content
             return self.apply_git_patch(patch_content, commit_message, repo_name)
         except Exception as e:

{alita_sdk-0.3.163 → alita_sdk-0.3.165}/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-0.3.163 → alita_sdk-0.3.165}/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': {