alita-sdk 0.3.346__py3-none-any.whl → 0.3.348__py3-none-any.whl

alita_sdk/runtime/clients/artifact.py

@@ -42,7 +42,17 @@ class Artifact:
             return f"{data['error']}. {data['content'] if data['content'] else ''}"
         detected = chardet.detect(data)
         if detected['encoding'] is not None:
-            return data.decode(detected['encoding'])
+            try:
+                return data.decode(detected['encoding'])
+            except Exception:
+                logger.error("Error while default encoding")
+                return parse_file_content(file_name=artifact_name,
+                                          file_content=data,
+                                          is_capture_image=is_capture_image,
+                                          page_number=page_number,
+                                          sheet_name=sheet_name,
+                                          excel_by_sheets=excel_by_sheets,
+                                          llm=llm)
         else:
             return parse_file_content(file_name=artifact_name,
                                   file_content=data,

alita_sdk/runtime/clients/client.py

@@ -69,6 +69,7 @@ class AlitaClient:
         self.configurations_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=configurations&unsecret=true'
         self.ai_section_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=ai'
         self.configurations: list = configurations or []
+        self.model_timeout = kwargs.get('model_timeout', 120)
 
     def get_mcp_toolkits(self):
         if user_id := self._get_real_user_id():
@@ -85,7 +86,12 @@ class AlitaClient:
             # This loop iterates over each key-value pair in the arguments dictionary,
             # and if a value is a Pydantic object, it replaces it with its dictionary representation using .dict().
             for arg_name, arg_value in params.get('params', {}).get('arguments', {}).items():
-                if hasattr(arg_value, "dict") and callable(arg_value.dict):
+                if isinstance(arg_value, list):
+                    params['params']['arguments'][arg_name] = [
+                        item.dict() if hasattr(item, "dict") and callable(item.dict) else item
+                        for item in arg_value
+                    ]
+                elif hasattr(arg_value, "dict") and callable(arg_value.dict):
                     params['params']['arguments'][arg_name] = arg_value.dict()
             #
             response = requests.post(url, headers=self.headers, json=params, verify=False)
@@ -179,6 +185,7 @@ class AlitaClient:
             model=embedding_model,
             api_key=self.auth_token,
             openai_organization=str(self.project_id),
+            request_timeout=self.model_timeout
         )
 
     def get_llm(self, model_name: str, model_config: dict) -> ChatOpenAI:

alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py

@@ -12,27 +12,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import io
+import os
 from typing import Iterator
 import pandas as pd
 from json import loads
 
 from openpyxl import load_workbook
+from xlrd import open_workbook
 from langchain_core.documents import Document
 from .AlitaTableLoader import AlitaTableLoader
-    
-cell_delimeter = " | "
 
-class AlitaExcelLoader(AlitaTableLoader):
+cell_delimiter = " | "
 
+class AlitaExcelLoader(AlitaTableLoader):
     excel_by_sheets: bool = False
     sheet_name: str = None
     return_type: str = 'str'
+    file_name: str = None
 
     def __init__(self, **kwargs):
         if not kwargs.get('file_path'):
             file_content = kwargs.get('file_content')
             if file_content:
+                self.file_name = kwargs.get('file_name')
                 kwargs['file_path'] = io.BytesIO(file_content)
+        else:
+            self.file_name = kwargs.get('file_path')
         super().__init__(**kwargs)
         self.excel_by_sheets = kwargs.get('excel_by_sheets')
         self.return_type = kwargs.get('return_type')
@@ -40,36 +45,82 @@ class AlitaExcelLoader(AlitaTableLoader):
 
     def get_content(self):
         try:
-            # Load the workbook
-            workbook = load_workbook(self.file_path, data_only=True)  # `data_only=True` ensures we get cell values, not formulas
-
-            if self.sheet_name:
-                # If a specific sheet name is provided, parse only that sheet
-                if self.sheet_name in workbook.sheetnames:
-                    sheet_content = self.parse_sheet(workbook[self.sheet_name])
-                    return sheet_content
-                else:
-                    raise ValueError(f"Sheet '{self.sheet_name}' does not exist in the workbook.")
-            elif self.excel_by_sheets:
-                # Parse each sheet individually and return as a dictionary
-                result = {}
-                for sheet_name in workbook.sheetnames:
-                    sheet_content = self.parse_sheet(workbook[sheet_name])
-                    result[sheet_name] = sheet_content
-                return result
+            # Determine file extension
+            file_extension = os.path.splitext(self.file_name)[-1].lower()
+
+            if file_extension == '.xlsx':
+                # Use openpyxl for .xlsx files
+                return self._read_xlsx()
+            elif file_extension == '.xls':
+                # Use xlrd for .xls files
+                return self._read_xls()
             else:
-                # Combine all sheets into a single string result
-                result = []
-                for sheet_name in workbook.sheetnames:
-                    sheet_content = self.parse_sheet(workbook[sheet_name])
-                    result.append(f"====== Sheet name: {sheet_name} ======\n{sheet_content}")
-                return "\n\n".join(result)
+                raise ValueError(f"Unsupported file format: {file_extension}")
         except Exception as e:
             return f"Error reading Excel file: {e}"
 
+    def _read_xlsx(self):
+        """
+        Reads .xlsx files using openpyxl.
+        """
+        workbook = load_workbook(self.file_path, data_only=True)  # `data_only=True` ensures we get cell values, not formulas
+
+        if self.sheet_name:
+            # If a specific sheet name is provided, parse only that sheet
+            if self.sheet_name in workbook.sheetnames:
+                sheet_content = self.parse_sheet(workbook[self.sheet_name])
+                return sheet_content
+            else:
+                raise ValueError(f"Sheet '{self.sheet_name}' does not exist in the workbook.")
+        elif self.excel_by_sheets:
+            # Parse each sheet individually and return as a dictionary
+            result = {}
+            for sheet_name in workbook.sheetnames:
+                sheet_content = self.parse_sheet(workbook[sheet_name])
+                result[sheet_name] = sheet_content
+            return result
+        else:
+            # Combine all sheets into a single string result
+            result = []
+            for sheet_name in workbook.sheetnames:
+                sheet_content = self.parse_sheet(workbook[sheet_name])
+                result.append(f"====== Sheet name: {sheet_name} ======\n{sheet_content}")
+            return "\n\n".join(result)
+
+    def _read_xls(self):
+        """
+        Reads .xls files using xlrd.
+        """
+        workbook = open_workbook(filename=self.file_name, file_contents=self.file_content)
+
+        if self.sheet_name:
+            # If a specific sheet name is provided, parse only that sheet
+            if self.sheet_name in workbook.sheet_names():
+                sheet = workbook.sheet_by_name(self.sheet_name)
+                sheet_content = self.parse_sheet_xls(sheet)
+                return sheet_content
+            else:
+                raise ValueError(f"Sheet '{self.sheet_name}' does not exist in the workbook.")
+        elif self.excel_by_sheets:
+            # Parse each sheet individually and return as a dictionary
+            result = {}
+            for sheet_name in workbook.sheet_names():
+                sheet = workbook.sheet_by_name(sheet_name)
+                sheet_content = self.parse_sheet_xls(sheet)
+                result[sheet_name] = sheet_content
+            return result
+        else:
+            # Combine all sheets into a single string result
+            result = []
+            for sheet_name in workbook.sheet_names():
+                sheet = workbook.sheet_by_name(sheet_name)
+                sheet_content = self.parse_sheet_xls(sheet)
+                result.append(f"====== Sheet name: {sheet_name} ======\n{sheet_content}")
+            return "\n\n".join(result)
+
     def parse_sheet(self, sheet):
         """
-        Parses a single sheet, extracting text and hyperlinks, and formats them.
+        Parses a single .xlsx sheet, extracting text and hyperlinks, and formats them.
         """
         sheet_content = []
 
@@ -85,17 +136,52 @@ class AlitaExcelLoader(AlitaTableLoader):
                     # If no hyperlink, use the cell value (computed value if formula)
                     row_content.append(str(cell.value) if cell.value is not None else "")
             # Join the row content into a single line using `|` as the delimiter
-            sheet_content.append(cell_delimeter.join(row_content))
+            sheet_content.append(cell_delimiter.join(row_content))
+
+        # Format the sheet content based on the return type
+        return self._format_sheet_content(sheet_content)
+
+    def parse_sheet_xls(self, sheet):
+        """
+        Parses a single .xls sheet using xlrd, extracting text and hyperlinks, and formats them.
+        """
+        sheet_content = []
+
+        # Extract hyperlink map (if available)
+        hyperlink_map = getattr(sheet, 'hyperlink_map', {})
+
+        for row_idx in range(sheet.nrows):
+            row_content = []
+            for col_idx in range(sheet.ncols):
+                cell = sheet.cell(row_idx, col_idx)
+                cell_value = cell.value
+
+                # Check if the cell has a hyperlink
+                cell_address = (row_idx, col_idx)
+                if cell_address in hyperlink_map:
+                    hyperlink = hyperlink_map[cell_address].url_or_path
+                    if cell_value:
+                        row_content.append(f"[{cell_value}]({hyperlink})")
+                else:
+                    row_content.append(str(cell_value) if cell_value is not None else "")
+            # Join the row content into a single line using `|` as the delimiter
+            sheet_content.append(cell_delimiter.join(row_content))
 
         # Format the sheet content based on the return type
+        return self._format_sheet_content(sheet_content)
+
+    def _format_sheet_content(self, sheet_content):
+        """
+        Formats the sheet content based on the return type.
+        """
         if self.return_type == 'dict':
             # Convert to a list of dictionaries (each row is a dictionary)
-            headers = sheet_content[0].split(cell_delimeter) if sheet_content else []
+            headers = sheet_content[0].split(cell_delimiter) if sheet_content else []
             data_rows = sheet_content[1:] if len(sheet_content) > 1 else []
-            return [dict(zip(headers, row.split(cell_delimeter))) for row in data_rows]
+            return [dict(zip(headers, row.split(cell_delimiter))) for row in data_rows]
         elif self.return_type == 'csv':
             # Return as CSV (newline-separated rows, comma-separated values)
-            return "\n".join([",".join(row.split(cell_delimeter)) for row in sheet_content])
+            return "\n".join([",".join(row.split(cell_delimiter)) for row in sheet_content])
         else:
             # Default: Return as plain text (newline-separated rows, pipe-separated values)
             return "\n".join(sheet_content)

alita_sdk/runtime/tools/artifact.py

@@ -71,6 +71,7 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         }
 
     def _base_loader(self, **kwargs) -> Generator[Document, None, None]:
+        self._log_tool_event(message=f"Loading the files from artifact's bucket. {kwargs=}", tool_name="loader")
         try:
             all_files = self.list_files(self.bucket, False)['rows']
         except Exception as e:

alita_sdk/runtime/tools/vectorstore.py

@@ -137,7 +137,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
     embedding_model_params: dict
     vectorstore_type: str
     vectorstore_params: dict
-    max_docs_per_add: int = 100
+    max_docs_per_add: int = 20
     dataset: str = None
     embedding: Any = None
     vectorstore: Any = None

alita_sdk/runtime/tools/vectorstore_base.py

@@ -135,7 +135,7 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
     embedding_model: Optional[str] = None
     vectorstore_type: Optional[str]  = None
     vectorstore_params: Optional[dict]  = None
-    max_docs_per_add: int = 100
+    max_docs_per_add: int = 20
     dataset: Optional[str] = None
     vectorstore: Any = None
     pg_helper: Any = None

alita_sdk/tools/figma/api_wrapper.py

@@ -22,7 +22,7 @@ GLOBAL_REMOVE = []
 GLOBAL_DEPTH_START = 4
 GLOBAL_DEPTH_END = 6
 EXTRA_PARAMS = (
-    Optional[Dict[str, Union[str, int, None]]],
+    Optional[Dict[str, Union[str, int, List, None]]],
     Field(
         description=(
             "Additional parameters for customizing response processing:\n"

alita_sdk/tools/testrail/api_wrapper.py

@@ -298,6 +298,18 @@ updateCase = create_model(
     ),
 )
 
+getSuites = create_model(
+    "getSuites",
+    project_id=(str, Field(description="Project id")),
+    output_format=(
+        str,
+        Field(
+            default="json",
+            description="Desired output format. Supported values: 'json', 'csv', 'markdown'. Defaults to 'json'.",
+        ),
+    ),
+)
+
 SUPPORTED_KEYS = {
     "id", "title", "section_id", "template_id", "type_id", "priority_id", "milestone_id",
     "refs", "created_by", "created_on", "updated_by", "updated_on", "estimate",
@@ -330,29 +342,74 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
         cls._client = TestRailAPI(url, email, password)
         return super().validate_toolkit(values)
 
-    def _validate_suite_mode_requirements(self, project_id: str, suite_id: Optional[str] = None) -> None:
+    def _is_suite_id_required(self, project_id: str) -> bool:
         """
-        Validate if project requires suite_id when in multiple suite mode.
-        
+        Returns True if project requires suite_id (multiple suite or baselines mode), otherwise False.
         Args:
             project_id: The TestRail project ID to check
-            suite_id: The suite ID if provided (optional)
-            custom_error_msg: Custom error message to use (optional)
-        
-        Raises:
-            ToolException: If project is in multiple suite mode and no suite_id is provided
         """
-        if suite_id:
-            return  # No validation needed if suite_id is already provided
-            
         try:
             project = self._client.projects.get_project(project_id=project_id)
             # 1 for single suite mode, 2 for single suite + baselines, 3 for multiple suites
             suite_mode = project.get('suite_mode', 1)
-            if suite_mode == 3:
-                raise ToolException("Project is in multiple suite mode, please provide suite_id to extract test cases.")
-        except StatusCodeError as e:
-            logger.warning(f"Unable to check project suite mode: {e}")
+            return suite_mode == 2 or suite_mode == 3
+        except StatusCodeError:
+            return False
+
+    def _fetch_cases_with_suite_handling(
+        self, 
+        project_id: str, 
+        suite_id: Optional[str] = None, 
+        **api_params
+    ) -> List[Dict]:
+        """
+        Unified method to fetch test cases with proper TestRail suite mode handling.
+        
+        Args:
+            project_id: The TestRail project ID
+            suite_id: Optional suite ID to filter by
+            **api_params: Additional parameters to pass to the get_cases API call
+            
+        Returns:
+            List of test case dictionaries
+        """
+        def _extract_cases_from_response(response):
+            """Extract cases from API response, supporting both old and new testrail_api versions."""
+            return response.get('cases', []) if isinstance(response, dict) else response
+
+        suite_required = self._is_suite_id_required(project_id=project_id)
+        all_cases = []
+
+        if suite_required:
+            # Suite modes 2 & 3: Require suite_id parameter
+            if suite_id:
+                response = self._client.cases.get_cases(
+                    project_id=project_id, suite_id=int(suite_id), **api_params
+                )
+                cases_from_suite = _extract_cases_from_response(response)
+                all_cases.extend(cases_from_suite)
+            else:
+                suites = self._get_raw_suites(project_id)
+                suite_ids = [suite['id'] for suite in suites if 'id' in suite]
+                for current_suite_id in suite_ids:
+                    try:
+                        response = self._client.cases.get_cases(
+                            project_id=project_id, suite_id=int(current_suite_id), **api_params
+                        )
+                        cases_from_suite = _extract_cases_from_response(response)
+                        all_cases.extend(cases_from_suite)
+                    except StatusCodeError:
+                        continue
+        else:
+            # Suite mode 1: Can fetch all cases directly without suite_id
+            try:
+                response = self._client.cases.get_cases(project_id=project_id, **api_params)
+                cases_from_project = _extract_cases_from_response(response)
+                all_cases.extend(cases_from_project)
+            except StatusCodeError as e:
+                logger.warning(f"Unable to fetch cases at project level: {e}")
+
+        return all_cases
 
     def add_cases(self, add_test_cases_data: str):
         """Adds new test cases into Testrail per defined parameters.
@@ -442,17 +499,10 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
         invalid_keys = [key for key in keys if key not in SUPPORTED_KEYS]
 
         try:
-            # Check if project requires suite_id for multiple suite mode
-            self._validate_suite_mode_requirements(
-                project_id=project_id,
-                suite_id=suite_id
-            )
-            
-            extracted_cases = self._client.cases.get_cases(project_id=project_id, suite_id=suite_id)
-            # support old versions of testrail_api
-            cases = extracted_cases.get("cases") if isinstance(extracted_cases, dict) else extracted_cases
+            # Use unified suite handling method
+            cases = self._fetch_cases_with_suite_handling(project_id=project_id, suite_id=suite_id)
 
-            if cases is None:
+            if not cases:
                 return ToolException("No test cases found in the extracted data.")
 
             extracted_cases_data = [
@@ -506,31 +556,35 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
                 )
             self._log_tool_event(message=f"Extract test cases per filter {params}", tool_name='get_cases_by_filter')
             
-            # Check if project requires suite_id when not provided in params
-            suite_id_in_params = params.get('suite_id', None)
-            self._validate_suite_mode_requirements(
-                project_id=project_id,
-                suite_id=str(suite_id_in_params) if suite_id_in_params else None
-            )
+            # Extract suite_id from params for unified handling
+            suite_id_in_params = params.pop('suite_id', None)
+            suite_id = str(suite_id_in_params) if suite_id_in_params else None
             
-            extracted_cases = self._client.cases.get_cases(
-                project_id=project_id, **params
+            # Use unified suite handling method with remaining filter parameters
+            cases = self._fetch_cases_with_suite_handling(
+                project_id=project_id, 
+                suite_id=suite_id, 
+                **params
             )
+
             self._log_tool_event(message="Test cases were extracted", tool_name='get_cases_by_filter')
-            # support old versions of testrail_api
-            cases = extracted_cases.get("cases") if isinstance(extracted_cases, dict) else extracted_cases
 
-            if cases is None:
+            if not cases:
                 return ToolException("No test cases found in the extracted data.")
 
             if keys is None:
                 return self._to_markup(cases, output_format)
 
-            extracted_cases_data = [
-                {key: case.get(key, "N/A") for key in keys} for case in cases
-            ]
+            extracted_cases_data = []
+            for case in cases:
+                case_dict = {}
+                for key in keys:
+                    if key in case:
+                        case_dict[key] = case[key]
+                if case_dict:
+                    extracted_cases_data.append(case_dict)
 
-            if extracted_cases_data is None:
+            if not extracted_cases_data:
                 return ToolException("No valid test case data found to format.")
 
             result = self._to_markup(extracted_cases_data, output_format)
@@ -578,6 +632,40 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
         return (
             f"Test case #{case_id} has been updated at '{updated_case['updated_on']}')"
         )
+    
+    def _get_raw_suites(self, project_id: str) -> List[Dict]:
+        """
+        Internal helper to get raw suite data from TestRail API.
+        Handles both old and new testrail_api response formats.
+        """
+        suites_response = self._client.suites.get_suites(project_id=project_id)
+        if isinstance(suites_response, dict) and 'suites' in suites_response:
+            return suites_response['suites']
+        else:
+            return suites_response if isinstance(suites_response, list) else []
+    
+    def get_suites(self, project_id: str, output_format: str = "json",) -> Union[str, ToolException]:
+        """Extracts a list of test suites for a given project from Testrail"""
+        try:
+            suites = self._get_raw_suites(project_id)
+
+            if not suites:
+                return ToolException("No test suites found for the specified project.")
+
+            suite_dicts = []
+            for suite in suites:
+                if isinstance(suite, dict):
+                    suite_dict = {}
+                    for field in ["id", "name", "description", "project_id", "is_baseline", 
+                                 "completed_on", "url", "is_master", "is_completed"]:
+                        if field in suite:
+                            suite_dict[field] = suite[field]
+                    suite_dicts.append(suite_dict)
+                else:
+                    suite_dicts.append({"suite": str(suite)})
+            return self._to_markup(suite_dicts, output_format)
+        except StatusCodeError as e:
+            return ToolException(f"Unable to extract test suites: {e}")
 
     def _base_loader(self, project_id: str,
                      suite_id: Optional[str] = None,
@@ -589,24 +677,13 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
         self._include_attachments = kwargs.get('include_attachments', False)
         self._skip_attachment_extensions = kwargs.get('skip_attachment_extensions', [])
 
-        def _extract_cases_from_response(response):
-            """Extract cases from API response, supporting both old and new testrail_api versions."""
-            return response.get('cases', []) if isinstance(response, dict) else response
-
         try:
-            # Check if project requires suite_id when not provided
-            self._validate_suite_mode_requirements(project_id=project_id, suite_id=suite_id)
-
-            if suite_id:
-                resp = self._client.cases.get_cases(project_id=project_id, suite_id=int(suite_id))
-            else:
-                resp = self._client.cases.get_cases(project_id=project_id)
-            
-            cases = _extract_cases_from_response(resp)
-            
+            # Use unified suite handling method
+            cases = self._fetch_cases_with_suite_handling(project_id=project_id, suite_id=suite_id)
         except StatusCodeError as e:
             raise ToolException(f"Unable to extract test cases: {e}")
-            # Apply filters
+
+        # Apply filters
         if section_id is not None:
             cases = [case for case in cases if case.get('section_id') == section_id]
         if title_keyword is not None:
@@ -810,6 +887,12 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
                 "ref": self.update_case,
                 "description": self.update_case.__doc__,
                 "args_schema": updateCase,
+            },
+            {
+                "name": "get_suites",
+                "ref": self.get_suites,
+                "description": self.get_suites.__doc__,
+                "args_schema": getSuites,
             }
         ]
         return tools

{alita_sdk-0.3.346.dist-info → alita_sdk-0.3.348.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.346
+Version: 0.3.348
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.346.dist-info → alita_sdk-0.3.348.dist-info}/RECORD

@@ -35,8 +35,8 @@ alita_sdk/configurations/zephyr_enterprise.py,sha256=UaBk3qWcT2-bCzko5HEPvgxArw1
 alita_sdk/configurations/zephyr_essential.py,sha256=tUIrh-PRNvdrLBj6rJXqlF-h6oaMXUQI1wgit07kFBw,752
 alita_sdk/runtime/__init__.py,sha256=4W0UF-nl3QF2bvET5lnah4o24CoTwSoKXhuN0YnwvEE,828
 alita_sdk/runtime/clients/__init__.py,sha256=BdehU5GBztN1Qi1Wul0cqlU46FxUfMnI6Vq2Zd_oq1M,296
-alita_sdk/runtime/clients/artifact.py,sha256=TPvROw1qu4IyUEGuf7x40IKRpb5eFZpYGN3-8LfQE0M,3461
-alita_sdk/runtime/clients/client.py,sha256=uG97uviNsbBZvg2h5UbqH2VIW2_jDHwaTa2OKkhwvBc,43313
+alita_sdk/runtime/clients/artifact.py,sha256=Tt3aWcxu20bVW6EX7s_iX5CTmcItKhUnkk8Q2gv2vw0,4036
+alita_sdk/runtime/clients/client.py,sha256=T3hmVnT63iLWEGeuJb8k8Httw-sSWUpy6rsrumD0P0w,43699
 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
@@ -56,7 +56,7 @@ alita_sdk/runtime/langchain/document_loaders/AlitaCSVLoader.py,sha256=3ne-a5qIkB
 alita_sdk/runtime/langchain/document_loaders/AlitaConfluenceLoader.py,sha256=NzpoL4C7UzyzLouTSL_xTQw70MitNt-WZz3Eyl7QkTA,8294
 alita_sdk/runtime/langchain/document_loaders/AlitaDirectoryLoader.py,sha256=fKezkgvIcLG7S2PVJp1a8sZd6C4XQKNZKAFC87DbQts,7003
 alita_sdk/runtime/langchain/document_loaders/AlitaDocxMammothLoader.py,sha256=9hi5eHgDIfa9wBWqTuwMM6D6W64czrDTfZl_htooe8Y,5943
-alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py,sha256=P17csHx94JkXiyo1a2V-CrfP2E5XCG4uZC31ulZ_Ab4,5817
+alita_sdk/runtime/langchain/document_loaders/AlitaExcelLoader.py,sha256=h8x1Xma_IBM4NdGXVVuvHHSlFQgY0S7Xjj8oGZhdFL8,9256
 alita_sdk/runtime/langchain/document_loaders/AlitaGitRepoLoader.py,sha256=5WXGcyHraSVj3ANHj_U6X4EDikoekrIYtS0Q_QqNIng,2608
 alita_sdk/runtime/langchain/document_loaders/AlitaImageLoader.py,sha256=QwgBJE-BvOasjgT1hYHZc0MP0F_elirUjSzKixoM6fY,6610
 alita_sdk/runtime/langchain/document_loaders/AlitaJSONLoader.py,sha256=Nav2cgCQKOHQi_ZgYYn_iFdP_Os56KVlVR5nHGXecBc,3445
@@ -106,7 +106,7 @@ alita_sdk/runtime/toolkits/vectorstore.py,sha256=BGppQADa1ZiLO17fC0uCACTTEvPHlod
 alita_sdk/runtime/tools/__init__.py,sha256=7OA8YPKlEOfXu3-gJA08cyR-VymjSPL-OmbXI-B2xVA,355
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
 alita_sdk/runtime/tools/application.py,sha256=z3vLZODs-_xEEnZFmGF0fKz1j3VtNJxqsAmg5ovExpQ,3129
-alita_sdk/runtime/tools/artifact.py,sha256=9kNZENeGDK4wW3cG0tixmJb0FDJhO-VqujuuuxN8kDo,10682
+alita_sdk/runtime/tools/artifact.py,sha256=4xA_va11WxO0fQclavKivRo24GI1b5qpsp2YZt7RxGY,10795
 alita_sdk/runtime/tools/datasource.py,sha256=pvbaSfI-ThQQnjHG-QhYNSTYRnZB0rYtZFpjCfpzxYI,2443
 alita_sdk/runtime/tools/echo.py,sha256=spw9eCweXzixJqHnZofHE1yWiSUa04L4VKycf3KCEaM,486
 alita_sdk/runtime/tools/function.py,sha256=0iZJ-UxaPbtcXAVX9G5Vsn7vmD7lrz3cBG1qylto1gs,2844
@@ -121,8 +121,8 @@ alita_sdk/runtime/tools/prompt.py,sha256=nJafb_e5aOM1Rr3qGFCR-SKziU9uCsiP2okIMs9
 alita_sdk/runtime/tools/router.py,sha256=wCvZjVkdXK9dMMeEerrgKf5M790RudH68pDortnHSz0,1517
 alita_sdk/runtime/tools/sandbox.py,sha256=WNz-aUMtkGCPg84dDy_0BPkyp-6YjoYB-xjIEFFrtKw,11601
 alita_sdk/runtime/tools/tool.py,sha256=lE1hGi6qOAXG7qxtqxarD_XMQqTghdywf261DZawwno,5631
-alita_sdk/runtime/tools/vectorstore.py,sha256=UFBAJ_N2F6uB0xxIy1VMx581tHco-xDl7v2Hl6u0Xzw,34468
-alita_sdk/runtime/tools/vectorstore_base.py,sha256=F2EFwq5LFwCpV6U9D5Jq1dxYrV3lxOErLfgWTXqEVRI,27293
+alita_sdk/runtime/tools/vectorstore.py,sha256=8vRhi1lGFEs3unvnflEi2p59U2MfV32lStpEizpDms0,34467
+alita_sdk/runtime/tools/vectorstore_base.py,sha256=7ZkbegFG0XTQBYGsJjtrkK-zrqKwketfx8vSJzuPCug,27292
 alita_sdk/runtime/utils/AlitaCallback.py,sha256=E4LlSBuCHWiUq6W7IZExERHZY0qcmdjzc_rJlF2iQIw,7356
 alita_sdk/runtime/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/utils/constants.py,sha256=Xntx1b_uxUzT4clwqHA_U6K8y5bBqf_4lSQwXdcWrp4,13586
@@ -236,7 +236,7 @@ alita_sdk/tools/custom_open_api/api_wrapper.py,sha256=sDSFpvEqpSvXHGiBISdQQcUecf
 alita_sdk/tools/elastic/__init__.py,sha256=iwnSRppRpzvJ1da2K3Glu8Uu41MhBDCYbguboLkEbW0,2818
 alita_sdk/tools/elastic/api_wrapper.py,sha256=pl8CqQxteJAGwyOhMcld-ZgtOTFwwbv42OITQVe8rM0,1948
 alita_sdk/tools/figma/__init__.py,sha256=W6vIMMkZI2Lmpg6_CRRV3oadaIbVI-qTLmKUh6enqWs,4509
-alita_sdk/tools/figma/api_wrapper.py,sha256=KbKet1Xvjq1Vynz_jEE1MtEAVtLYNlSCg67u4dfhe90,33681
+alita_sdk/tools/figma/api_wrapper.py,sha256=yK45guP6oMStTpfNLXRYgIZtNWkuWzgjFm_Vzu-ivNg,33687
 alita_sdk/tools/github/__init__.py,sha256=2rHu0zZyZGnLC5CkHgDIhe14N9yCyaEfrrt7ydH8478,5191
 alita_sdk/tools/github/api_wrapper.py,sha256=uDwYckdnpYRJtb0uZnDkaz2udvdDLVxuCh1tSwspsiU,8411
 alita_sdk/tools/github/github_client.py,sha256=0YkpD6Zm4X46jMNN57ZIypo2YObtgxCGQokJAF-laFs,86597
@@ -325,7 +325,7 @@ alita_sdk/tools/sql/models.py,sha256=AKJgSl_kEEz4fZfw3kbvdGHXaRZ-yiaqfJOB6YOj3i0
 alita_sdk/tools/testio/__init__.py,sha256=NEvQtzsffqAXryaffVk0GpdcxZQ1AMkfeztnxHwNql4,2798
 alita_sdk/tools/testio/api_wrapper.py,sha256=BvmL5h634BzG6p7ajnQLmj-uoAw1gjWnd4FHHu1h--Q,21638
 alita_sdk/tools/testrail/__init__.py,sha256=Xg4nVjULL_D8JpIXLYXppnwUfGF4-lguFwKHmP5VwxM,4696
-alita_sdk/tools/testrail/api_wrapper.py,sha256=kocA4ok7WDN7nGRpH-r7wPiqQaiWfBRrvbHm0Y961L4,36756
+alita_sdk/tools/testrail/api_wrapper.py,sha256=tQcGlFJmftvs5ZiO4tsP19fCo4CrJeq_UEvQR1liVfE,39891
 alita_sdk/tools/utils/__init__.py,sha256=W9rCCUPtHCP5nGAbWp0n5jaNA84572aiRoqKneBnaS4,3330
 alita_sdk/tools/utils/available_tools_decorator.py,sha256=IbrdfeQkswxUFgvvN7-dyLMZMyXLiwvX7kgi3phciCk,273
 alita_sdk/tools/utils/content_parser.py,sha256=q0wj__flyFlmzwlvbzAj3wCdHhLXysFbpcpCtrNfsGg,14437
@@ -350,8 +350,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=kT0TbmMvuKhDUZc0i7KO18O38JM9S
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=0ne8XLJEQSLOWfzd2HdnqOYmQlUliKHbBED5kW_Vias,2895
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.346.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.346.dist-info/METADATA,sha256=OoUbeD3TLR5rkU_L-5H3DOb2tB7yJ9JWqmwAjDpYq_E,19015
-alita_sdk-0.3.346.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.346.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.346.dist-info/RECORD,,
+alita_sdk-0.3.348.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.348.dist-info/METADATA,sha256=_oiAJpxGjG23s01B-P41PkJqG1oUgdAgS7QUnlyS5gc,19015
+alita_sdk-0.3.348.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.348.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.348.dist-info/RECORD,,