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

alita_sdk/tools/bitbucket/__init__.py

@@ -6,7 +6,10 @@ from .api_wrapper import BitbucketAPIWrapper
 from langchain_core.tools import BaseToolkit
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel, Field, ConfigDict, create_model
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+
+from ..base.tool import BaseAction
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.bitbucket import BitbucketConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 import requests
@@ -18,7 +21,6 @@ name = "bitbucket"
 def get_tools(tool):
     return AlitaBitbucketToolkit.get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        url=tool['settings']['url'],
         project=tool['settings']['project'],
         repository=tool['settings']['repository'],
         bitbucket_configuration=tool['settings']['bitbucket_configuration'],
@@ -36,20 +38,18 @@ def get_tools(tool):
 
 class AlitaBitbucketToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in
                           BitbucketAPIWrapper.model_construct().get_available_tools()}
-        AlitaBitbucketToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            project=(str, Field(description="Project/Workspace", json_schema_extra={'configuration': True})),
-            repository=(str, Field(description="Repository", json_schema_extra={'max_toolkit_length': AlitaBitbucketToolkit.toolkit_max_length, 'configuration': True})),
+            project=(str, Field(description="Project/Workspace")),
+            repository=(str, Field(description="Repository")),
             branch=(str, Field(description="Main branch", default="main")),
             cloud=(Optional[bool], Field(description="Hosting Option", default=None)),
-            bitbucket_configuration=(Optional[BitbucketConfiguration], Field(description="Bitbucket Configuration", json_schema_extra={'configuration_types': ['bitbucket']})),
+            bitbucket_configuration=(BitbucketConfiguration, Field(description="Bitbucket Configuration", json_schema_extra={'configuration_types': ['bitbucket']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
             embedding_model=(Optional[str], Field(default=None, description="Embedding configuration.", json_schema_extra={'configuration_model': 'embedding'})),
@@ -83,6 +83,7 @@ class AlitaBitbucketToolkit(BaseToolkit):
         return m
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
@@ -96,15 +97,21 @@ class AlitaBitbucketToolkit(BaseToolkit):
         }
         bitbucket_api_wrapper = BitbucketAPIWrapper(**wrapper_payload)
         available_tools: List[Dict] = bitbucket_api_wrapper.get_available_tools()
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         tools = []
         for tool in available_tools:
             if selected_tools:
                 if tool['name'] not in selected_tools:
                     continue
-            initiated_tool = tool['tool'](api_wrapper=bitbucket_api_wrapper)
-            initiated_tool.name = prefix + tool['name']
-            tools.append(initiated_tool)
+            description = tool["description"] + f"\nrepo: {bitbucket_api_wrapper.repository}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
+            tools.append(BaseAction(
+                api_wrapper=bitbucket_api_wrapper,
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"]
+            ))
         return cls(tools=tools)
 
     def get_tools(self):

alita_sdk/tools/bitbucket/api_wrapper.py

@@ -11,7 +11,9 @@ from .bitbucket_constants import create_pr_data
 from .cloud_api_wrapper import BitbucketCloudApi, BitbucketServerApi
 from pydantic.fields import PrivateAttr
 
-from ..elitea_base import BaseCodeToolApiWrapper, extend_with_vector_tools
+from ..code_indexer_toolkit import CodeIndexerToolkit
+from ..utils.available_tools_decorator import extend_with_parent_available_tools
+from ..elitea_base import extend_with_file_operations
 
 logger = logging.getLogger(__name__)
 
@@ -61,7 +63,7 @@ ListBranchesInRepoModel = create_model(
 
 ListFilesModel = create_model(
     "ListFilesModel",
-    path=(Optional[str], Field(description="The path to list files from")),
+    path=(Optional[str], Field(description="The path to list files from", default=None)),
     recursive=(bool, Field(description="Whether to list files recursively", default=True)),
     branch=(Optional[str], Field(description="The branch to list files from")),
 )
@@ -117,7 +119,7 @@ CommentOnIssueModel = create_model(
 )
 
 
-class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
+class BitbucketAPIWrapper(CodeIndexerToolkit):
     """Wrapper for Bitbucket API."""
 
     _bitbucket: Any = PrivateAttr()
@@ -167,7 +169,7 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
             repository=values['repository']
         )
         cls._active_branch = values.get('branch')
-        return values
+        return super().validate_toolkit(values)
 
     def set_active_branch(self, branch_name: str) -> str:
         """Set the active branch for the bot."""
@@ -194,7 +196,7 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
             if limit is not None:
                 branches = branches[:limit]
 
-            return branches
+            return "Found branches: " + ", ".join(branches)
         except Exception as e:
             return f"Failed to list branches: {str(e)}"
 
@@ -359,12 +361,15 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
     #     except Exception as e:
     #         raise ToolException(f"Can't extract file commit hash (`{file_path}`) due to error:\n{str(e)}")
 
-    def _read_file(self, file_path: str, branch: str) -> str:
+    def _read_file(self, file_path: str, branch: str, **kwargs) -> str:
         """
-        Reads a file from the gitlab repo
+        Reads a file from the bitbucket repo with optional partial read support.
+        
         Parameters:
             file_path(str): the file path
             branch(str): branch name (by default: active_branch)
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
         Returns:
             str: The file decoded as a string
         """
@@ -398,8 +403,46 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
             return self._read_file(file_path, branch)
         except Exception as e:
             return f"Failed to read file {file_path}: {str(e)}"
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None
+    ) -> str:
+        """
+        Write content to a file (create or update).
+        
+        Parameters:
+            file_path: Path to the file
+            content: New file content
+            branch: Branch name (uses active branch if None)
+            commit_message: Commit message (not used by Bitbucket API)
+            
+        Returns:
+            Success message
+        """
+        try:
+            branch = branch or self._active_branch
+            
+            # Check if file exists by attempting to read it
+            try:
+                self._read_file(file_path, branch)
+                # File exists, update it using OLD/NEW format
+                old_content = self._read_file(file_path, branch)
+                update_query = f"OLD <<<<\n{old_content}\n>>>> OLD\nNEW <<<<\n{content}\n>>>> NEW"
+                self._bitbucket.update_file(file_path=file_path, update_query=update_query, branch=branch)
+                return f"Updated file {file_path}"
+            except:
+                # File doesn't exist, create it
+                self._bitbucket.create_file(file_path=file_path, file_contents=content, branch=branch)
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
-    @extend_with_vector_tools
+    @extend_with_parent_available_tools
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {
@@ -473,5 +516,5 @@ class BitbucketAPIWrapper(BaseCodeToolApiWrapper):
                 "ref": self.add_pull_request_comment,
                 "description": self.add_pull_request_comment.__doc__ or "Add a comment to a pull request in the repository.",
                 "args_schema": AddPullRequestCommentModel,
-            },
+            }
         ]

alita_sdk/tools/bitbucket/cloud_api_wrapper.py

@@ -35,7 +35,7 @@ def normalize_response(response) -> Dict[str, Any]:
 class BitbucketApiAbstract(ABC):
 
     @abstractmethod
-    def list_branches(self) -> str:
+    def list_branches(self) -> List[str]:
         pass
 
     @abstractmethod
@@ -86,9 +86,9 @@ class BitbucketServerApi(BitbucketApiAbstract):
         self.password = password
         self.api_client = Bitbucket(url=url, username=username, password=password)
 
-    def list_branches(self) -> str:
+    def list_branches(self) -> List[str]:
         branches = self.api_client.get_branches(project_key=self.project, repository_slug=self.repository)
-        return json.dumps([branch['displayId'] for branch in branches])
+        return [branch['displayId'] for branch in branches]
 
     def create_branch(self, branch_name: str, branch_from: str) -> Response:
         return self.api_client.create_branch(
@@ -257,10 +257,10 @@ class BitbucketCloudApi(BitbucketApiAbstract):
         except Exception as e:
             raise ToolException(f"Unable to connect to the repository '{self.repository_name}' due to error:\n{str(e)}")
 
-    def list_branches(self) -> str:
+    def list_branches(self) -> List[str]:
         branches = self.repository.branches.each()
         branch_names = [branch.name for branch in branches]
-        return ', '.join(branch_names)
+        return branch_names
 
     def _get_branch(self, branch_name: str) -> Response:
         return self.repository.branches.get(branch_name)

alita_sdk/tools/browser/__init__.py

@@ -1,16 +1,19 @@
 from typing import List, Optional, Literal
 from langchain_core.tools import BaseTool, BaseToolkit
 
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr, model_validator
+from pydantic import create_model, BaseModel, ConfigDict, Field, model_validator
 
 from langchain_community.utilities.google_search import GoogleSearchAPIWrapper
 from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
 from .google_search_rag import GoogleSearchResults
 from .crawler import SingleURLCrawler, MultiURLCrawler, GetHTMLContent, GetPDFContent
 from .wiki import WikipediaQueryRun
-from ..utils import get_max_toolkit_length, clean_string, TOOLKIT_SPLITTER
+from ..utils import get_max_toolkit_length, clean_string
+from ...configurations.browser import BrowserConfiguration
 from logging import getLogger
 
+from ...configurations.pgvector import PgVectorConfiguration
+
 logger = getLogger(__name__)
 
 name = "browser"
@@ -19,8 +22,9 @@ name = "browser"
 def get_tools(tool):
     return BrowserToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        google_api_key=tool['settings'].get('google_api_key'),
-        google_cse_id=tool['settings'].get("google_cse_id"),
+        browser_configuration=tool['settings']['browser_configuration'],
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
+        embedding_model=tool['settings'].get('embedding_model'),
         toolkit_name=tool.get('toolkit_name', '')
     ).get_tools()
 
@@ -38,22 +42,29 @@ class BrowserToolkit(BaseToolkit):
             'google': GoogleSearchResults.__pydantic_fields__['args_schema'].default.schema(),
             'wiki': WikipediaQueryRun.__pydantic_fields__['args_schema'].default.schema()
         }
-        BrowserToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
 
         def validate_google_fields(cls, values):
             if 'google' in values.get('selected_tools', []):
-                google_cse_id = values.get('google_cse_id') is not None
-                google_api_key = values.get('google_api_key') is not None
+                browser_config = values.get('browser_configuration', {})
+                google_cse_id = browser_config.get('google_cse_id') is not None if browser_config else False
+                google_api_key = browser_config.get('google_api_key') is not None if browser_config else False
                 if not (google_cse_id and google_api_key):
                     raise ValueError("google_cse_id and google_api_key are required when 'google' is in selected_tools")
             return values
 
         return create_model(
             name,
-            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Browser", "icon_url": None, "categories": ["testing"], "extra_categories": ["web scraping", "search", "crawler"]}}),
-            google_cse_id=(Optional[str], Field(description="Google CSE id", default=None)),
-            google_api_key=(Optional[SecretStr],
-                            Field(description="Google API key", default=None, json_schema_extra={'secret': True})),
+            __config__=ConfigDict(json_schema_extra={'metadata': {"label": "Browser", "icon_url": None,
+                                                                  "categories": ["testing"],
+                                                                  "extra_categories": [
+                                                                      "web scraping", "search", "crawler"
+                                                                  ]}}),
+            browser_configuration=(Optional[BrowserConfiguration],
+                                   Field(description="Browser Configuration (required for tools and `google`)",
+                                         default=None, json_schema_extra={'configuration_types': ['browser']})),
+            pgvector_configuration=(Optional[PgVectorConfiguration],
+                                    Field(description="PgVector configuration (required for tools `multi_url_crawler`)",
+                                          default=None, json_schema_extra={'configuration_types': ['pgvector']})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __validators__={
@@ -65,8 +76,19 @@ class BrowserToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
+
+        wrapper_payload_google = {
+            **kwargs,
+            **kwargs.get('browser_configuration', {}),
+            **kwargs.get('pgvector_configuration', {}),
+        }
+
+        wrapper_payload_rag_based = {
+            **kwargs,
+            **kwargs.get('pgvector_configuration', {}),
+        }
+
         tools = []
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         if not selected_tools:
             selected_tools = [
                 'single_url_crawler',
@@ -80,7 +102,7 @@ class BrowserToolkit(BaseToolkit):
             if tool == 'single_url_crawler':
                 tool_entry = SingleURLCrawler()
             elif tool == 'multi_url_crawler':
-                tool_entry = MultiURLCrawler()
+                tool_entry = MultiURLCrawler(**wrapper_payload_rag_based)
             elif tool == 'get_html_content':
                 tool_entry = GetHTMLContent()
             elif tool == 'get_pdf_content':
@@ -88,8 +110,8 @@ class BrowserToolkit(BaseToolkit):
             elif tool == 'google':
                 try:
                     google_api_wrapper = GoogleSearchAPIWrapper(
-                        google_api_key=kwargs.get("google_api_key"),
-                        google_cse_id=kwargs.get("google_cse_id"),
+                        google_api_key=wrapper_payload_google.get('google_api_key'),
+                        google_cse_id=wrapper_payload_google.get('google_cse_id')
                     )
                     tool_entry = GoogleSearchResults(api_wrapper=google_api_wrapper)
                     # rename the tool to avoid conflicts
@@ -103,7 +125,9 @@ class BrowserToolkit(BaseToolkit):
 
             # Only add the tool if it was successfully created
             if tool_entry is not None:
-                tool_entry.name = f"{prefix}{tool_entry.name}"
+                if toolkit_name:
+                    tool_entry.description = f"{tool_entry.description}\nToolkit: {toolkit_name}"
+                    tool_entry.description = tool_entry.description[:1000]
                 tools.append(tool_entry)
         return cls(tools=tools)
 

alita_sdk/tools/browser/crawler.py

@@ -27,13 +27,15 @@ class MultiURLCrawler(BaseTool):
     max_response_size: int = 3000
     name: str = "multi_url_crawler"
     description: str = "Crawls multiple URLs and returns the content related to query"
+    connection_string: str = None
     args_schema: Type[BaseModel] = create_model("MultiURLCrawlerModel",
                                                 query=(str, Field(description="Query text to search pages")),
                                                 urls=(list[str], Field(description="list of URLs to search like ['url1', 'url2']")))
 
     def _run(self, query: str, urls: list[str], run_manager=None):
         urls = [url.strip() for url in urls]
-        return webRag(urls, self.max_response_size, query)
+        return webRag(urls=urls, max_response_size=self.max_response_size, query=query,
+                      connection_string=self.connection_string)
 
 
 class GetHTMLContent(BaseTool):

alita_sdk/tools/browser/utils.py

@@ -6,9 +6,9 @@ from langchain.text_splitter import CharacterTextSplitter
 import fitz
 
 try:
-    from langchain_chroma import Chroma
+    from langchain_postgres import PGVector
 except ImportError:
-    Chroma = None
+    PGVector = None
 
 from langchain_community.embeddings.sentence_transformer import (
     SentenceTransformerEmbeddings,
@@ -32,13 +32,22 @@ def get_page(urls, html_only=False):
     return docs_transformed
 
 
-def webRag(urls, max_response_size, query):
-    if Chroma is None:
-        return "Chroma is not initialized. Web rag is not available."
+def webRag(urls, max_response_size, query, connection_string=None):
+    if PGVector is None:
+        return "PGVector is not initialized. Web rag is not available."
+
+    if not connection_string:
+        return "Connection string or embedding model is missing. Web rag is not available."
     text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
     docs = text_splitter.split_documents(get_page(urls))
     embedding_function = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")
-    db = Chroma.from_documents(docs, embedding_function)
+    db = PGVector.from_documents(
+        documents=docs,
+        embedding=embedding_function,
+        collection_name="web_rag",
+        pre_delete_collection=True,
+        connection=connection_string
+    )
     docs = db.search(query, "mmr", k=10)
     text = ""
     for doc in docs:

alita_sdk/tools/carrier/__init__.py

@@ -1,12 +1,14 @@
 import logging
 from typing import Dict, List, Optional, Literal
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 from functools import lru_cache
 
 from .api_wrapper import CarrierAPIWrapper
 from .tools import __all__
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length
+from ...configurations.carrier import CarrierConfiguration
 
 logger = logging.getLogger(__name__)
 
@@ -15,7 +17,6 @@ name = 'carrier'
 
 class AlitaCarrierToolkit(BaseToolkit):
     tools: List[BaseTool] = []
-    toolkit_max_length: int = 100
 
     @classmethod
     @lru_cache(maxsize=32)
@@ -24,15 +25,10 @@ class AlitaCarrierToolkit(BaseToolkit):
         for t in __all__:
             default = t['tool'].__pydantic_fields__['args_schema'].default
             selected_tools[t['name']] = default.schema() if default else default
-        cls.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            url=(str, Field(description="Carrier Platform Base URL")),
-            organization=(str, Field(description="Carrier Organization Name", json_schema_extra={'toolkit_name': True,
-                                                                                                 'max_toolkit_length': cls.toolkit_max_length})),
-            private_token=(
-                SecretStr, Field(description="Carrier Platform Authentication Token", json_schema_extra={'secret': True})),
             project_id=(Optional[str], Field(None, description="Optional project ID for scoped operations")),
+            carrier_configuration=(CarrierConfiguration, Field(description="Carrier Configuration", json_schema_extra={'configuration_types': ['carrier']})),
             selected_tools=(
                 List[Literal[tuple(selected_tools)]],
                 Field(default=[], json_schema_extra={"args_schemas": selected_tools}),
@@ -49,6 +45,7 @@ class AlitaCarrierToolkit(BaseToolkit):
         )
 
     @classmethod
+    @filter_missconfigured_index_tools
     def get_toolkit(
             cls,
             selected_tools: Optional[List[str]] = None,
@@ -58,23 +55,28 @@ class AlitaCarrierToolkit(BaseToolkit):
         selected_tools = selected_tools or []
         logger.info(f"[AlitaCarrierToolkit] Initializing toolkit with selected tools: {selected_tools}")
 
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('carrier_configuration', {}),
+        }
+
         try:
-            carrier_api_wrapper = CarrierAPIWrapper(**kwargs)
+            carrier_api_wrapper = CarrierAPIWrapper(**wrapper_payload)
             logger.info(
-                f"[AlitaCarrierToolkit] CarrierAPIWrapper initialized successfully with URL: {kwargs.get('url')}")
+                f"[AlitaCarrierToolkit] CarrierAPIWrapper initialized successfully with URL: {wrapper_payload.get('url')}")
         except Exception as e:
             logger.exception(f"[AlitaCarrierToolkit] Error initializing CarrierAPIWrapper: {e}")
             raise ValueError(f"CarrierAPIWrapper initialization error: {e}")
 
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
-
         tools = []
         for tool_def in __all__:
             if selected_tools and tool_def['name'] not in selected_tools:
                 continue
             try:
                 tool_instance = tool_def['tool'](api_wrapper=carrier_api_wrapper)
-                tool_instance.name = prefix + tool_instance.name
+                if toolkit_name:
+                    tool_instance.description = f"{tool_instance.description}\nToolkit: {toolkit_name}"
+                    tool_instance.description = tool_instance.description[:1000]
                 tools.append(tool_instance)
                 logger.info(f"[AlitaCarrierToolkit] Successfully initialized tool '{tool_instance.name}'")
             except Exception as e:
@@ -92,9 +94,7 @@ class AlitaCarrierToolkit(BaseToolkit):
 def get_tools(tool_config: Dict) -> List[BaseTool]:
     return AlitaCarrierToolkit.get_toolkit(
         selected_tools=tool_config.get('selected_tools', []),
-        url=tool_config['settings']['url'],
         project_id=tool_config['settings'].get('project_id'),
-        organization=tool_config['settings']['organization'],
-        private_token=tool_config['settings']['private_token'],
+        carrier_configuration=tool_config['settings']['carrier_configuration'],
         toolkit_name=tool_config.get('toolkit_name')
     ).get_tools()

alita_sdk/tools/carrier/backend_reports_tool.py

@@ -154,6 +154,7 @@ class CreateExcelReportTool(BaseTool):
             "tp_threshold": (int, Field(default=None, description="Throughput threshold")),
             "rt_threshold": (int, Field(default=None, description="Response time threshold")),
             "er_threshold": (int, Field(default=None, description="Error rate threshold")),
+            "include_group_pauses": (bool, Field(default=False, description="Include group pauses in Gatling Excel report")),
         }
     )
 
@@ -200,6 +201,7 @@ class CreateExcelReportTool(BaseTool):
             "tp_threshold": 10,
             "rt_threshold": 500,
             "er_threshold": 5,
+            "include_group_pauses": False,
         }
 
     def _request_parameter_confirmation(self, default_parameters):
@@ -217,7 +219,8 @@ class CreateExcelReportTool(BaseTool):
         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(test_log_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"],
+                                            parameters["include_group_pauses"], is_absolute_file_path=True)
         calc_thr_j = self._calculate_thresholds(result_stats_j, parameters)
 
         return self._generate_and_upload_report(
@@ -233,21 +236,22 @@ class CreateExcelReportTool(BaseTool):
         excel_report_file_name = f'{file_path}_{current_date}.xlsx'
         bucket_name = bucket
 
-        result_stats_j = self._parse_report(file_path, lg_type, parameters["think_time"], is_absolute_file_path=True)
+        result_stats_j = self._parse_report(file_path, lg_type, parameters["think_time"],
+                                            parameters["include_group_pauses"], 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
         )
 
-    def _parse_report(self, file_path, lg_type, think_time, is_absolute_file_path=False):
+    def _parse_report(self, file_path, lg_type, think_time, include_group_pauses, is_absolute_file_path=False):
         """Parse the report based on its type."""
         if lg_type == "gatling":
             if is_absolute_file_path:
                 report_file = file_path
             else:
                 report_file = get_latest_log_file(file_path, "simulation.log")
-            parser = GatlingReportParser(report_file, think_time)
+            parser = GatlingReportParser(report_file, include_group_pauses, think_time)
             result_stats_j = parser.parse()
             result_stats_j["requests"].update(result_stats_j["groups"])
         elif lg_type == "jmeter":

alita_sdk/tools/carrier/excel_reporter.py

@@ -118,9 +118,10 @@ class JMeterReportParser(PerformanceReportParser):
 
 class GatlingReportParser(PerformanceReportParser):
 
-    def __init__(self, log_file: str, think_times="5,0-10,0"):
+    def __init__(self, log_file: str, include_group_pauses, think_times="5,0-10,0"):
         self.calculated_think_time = think_times
         self.log_file = log_file
+        self.include_group_pauses = include_group_pauses
 
     @staticmethod
     def convert_timestamp_to_datetime(timestamp: int) -> datetime:
@@ -210,7 +211,7 @@ class GatlingReportParser(PerformanceReportParser):
                                 ramp_end = self.convert_timestamp_to_datetime(int(line.split('\t')[3]))
 
                     elif line.startswith('GROUP'):
-                        self.parse_group_line(groups, line)
+                        self.parse_group_line(groups, line, self.include_group_pauses)
         except FileNotFoundError as e:
             print(f"File not found: {e}")
             raise
@@ -242,11 +243,14 @@ class GatlingReportParser(PerformanceReportParser):
             requests[request_name].append((response_time, status))
 
     @staticmethod
-    def parse_group_line(groups, line):
+    def parse_group_line(groups, line, include_group_pauses):
         parts = line.split('\t')
         if len(parts) >= 6:
             group_name = parts[1]
-            response_time = int(parts[4])
+            if include_group_pauses:
+                response_time = int(parts[3]) - int(parts[2])
+            else:
+                response_time = int(parts[4])
             status = parts[5].strip()
             groups[group_name].append((response_time, status))
 

alita_sdk/tools/chunkers/__init__.py

@@ -3,6 +3,7 @@ from .sematic.statistical_chunker import statistical_chunker
 from .sematic.markdown_chunker import markdown_chunker
 from .sematic.proposal_chunker import proposal_chunker
 from .sematic.json_chunker import json_chunker
+from .universal_chunker import universal_chunker, chunk_single_document, get_file_type
 from .models import StatisticalChunkerConfig, MarkdownChunkerConfig, ProposalChunkerConfig
 
 __all__ = {
@@ -10,7 +11,8 @@ __all__ = {
     'statistical': statistical_chunker,
     'markdown': markdown_chunker,
     'proposal': proposal_chunker,
-    'json': json_chunker
+    'json': json_chunker,
+    'universal': universal_chunker,
 }
 
 __confluence_chunkers__ = {

alita_sdk/tools/chunkers/code/codeparser.py

@@ -79,7 +79,7 @@ def parse_code_files_for_db(file_content_generator: Generator[str, None, None],
                     for splitted_document in splitted_documents:
                         metadata = {
                             "filename": file_name,
-                            "method_name": node.name,
+                            "method_name": node.name if node.name else 'unknown',
                             "language": programming_language.value,
                         }
                         commit_hash = data.get("commit_hash")

alita_sdk/tools/chunkers/sematic/json_chunker.py

@@ -17,6 +17,7 @@ def json_chunker(file_content_generator: Generator[Document, None, None], config
             for chunk in chunks:
                 metadata = doc.metadata.copy()
                 metadata['chunk_id'] = chunk_id
+                metadata['method_name'] = 'json'
                 chunk_id += 1
                 yield Document(page_content=json.dumps(chunk), metadata=metadata)
         except Exception as e: