alita-sdk 0.3.532__py3-none-any.whl → 0.3.602__py3-none-any.whl

alita_sdk/tools/slack/__init__.py

@@ -15,6 +15,7 @@ from .api_wrapper import SlackApiWrapper
 from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from slack_sdk.errors import SlackApiError
 from slack_sdk import WebClient
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "slack"
 
@@ -85,12 +86,12 @@ class SlackToolkit(BaseToolkit):
             if toolkit_name:
                 description = f"{description}\nToolkit: {toolkit_name}"
             description = description[:1000]
-            tools.append(BaseAction(                
+            tools.append(BaseAction(
                 api_wrapper=slack_api_wrapper,
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/slack/api_wrapper.py

@@ -17,8 +17,8 @@ SendMessageModel = create_model(
 
 ReadMessagesModel = create_model(
                     "ReadMessagesModel",
-                    channel_id=(Optional[str], Field(default=None,description="Channel ID, user ID, or conversation ID to read messages from. (like C12345678 for public channels, D12345678 for DMs)")),                    
-                    limit=(int, Field(default=10, description="The number of messages to fetch (default is 10)."))
+                    channel_id=(Optional[str], Field(default=None,description="Channel ID, user ID, or conversation ID to read messages from. (like C12345678 for public channels, D12345678 for DMs)")),
+                    limit=(int, Field(default=10, description="The number of messages to fetch (default is 10).", gt=0))
                     )
 
 CreateChannelModel = create_model(

alita_sdk/tools/sql/__init__.py

@@ -9,6 +9,7 @@ from .models import SQLDialect
 from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.sql import SqlConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "sql"
 
@@ -31,7 +32,7 @@ class SQLToolkit(BaseToolkit):
         supported_dialects = (d.value for d in SQLDialect)
         return create_model(
             name,
-            dialect=(Literal[tuple(supported_dialects)], Field(description="Database dialect (mysql or postgres)")),
+            dialect=(Literal[tuple(supported_dialects)], Field(default=SQLDialect.POSTGRES.value, description="Database dialect (mysql or postgres)")),
             database_name=(str, Field(description="Database name")),
             sql_configuration=(SqlConfiguration, Field(description="SQL Configuration", json_schema_extra={'configuration_types': ['sql']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
@@ -68,7 +69,7 @@ class SQLToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/testio/__init__.py

@@ -8,6 +8,7 @@ from ..base.tool import BaseAction
 from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.testio import TestIOConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "testio"
 
@@ -59,7 +60,7 @@ class TestIOToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/testrail/__init__.py

@@ -10,6 +10,7 @@ from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length, check_connection_response
 from ...configurations.testrail import TestRailConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "testrail"
 
@@ -90,7 +91,7 @@ class TestrailToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/utils/content_parser.py

@@ -109,7 +109,15 @@ def parse_file_content(file_name=None, file_content=None, is_capture_image: bool
                                     loader_extra_config=loader_kwargs,
                                     llm=llm)
     except Exception as e:
-        return ToolException(f"Error reading file ({file_name or file_path}) content. Make sure these types are supported: {str(e)}")
+        # Surface full underlying error message (including nested causes) so that
+        # JSONDecodeError or other specific issues are not hidden behind
+        # generic RuntimeError messages from loaders.
+        root_msg = str(e)
+        if getattr(e, "__cause__", None):
+            root_msg = f"{root_msg} | Cause: {e.__cause__}"
+        return ToolException(
+            f"Error reading file ({file_name or file_path}) content. Make sure these types are supported: {root_msg}"
+        )
 
 def load_file_docs(file_name=None, file_content=None, is_capture_image: bool = False, page_number: int = None,
                        sheet_name: str = None, llm=None, file_path: str = None, excel_by_sheets: bool = False) -> List[Document] | ToolException:
@@ -130,7 +138,38 @@ def load_file_docs(file_name=None, file_content=None, is_capture_image: bool = F
 
 def get_loader_kwargs(loader_object, file_name=None, file_content=None, is_capture_image: bool = False, page_number: int = None,
                     sheet_name: str = None, llm=None, file_path: str = None, excel_by_sheets: bool = False, prompt=None):
-    loader_kwargs = deepcopy(loader_object['kwargs'])
+    """Build loader kwargs safely without deepcopying non-picklable objects like LLMs.
+
+    We avoid copying keys that are going to be overridden by this function anyway
+    (file_path, file_content, file_name, extract_images, llm, page_number,
+    sheet_name, excel_by_sheets, prompt, row_content, json_documents) to
+    prevent errors such as `cannot pickle '_thread.RLock' object` when an LLM
+    or client with internal locks is stored in the original kwargs.
+    """
+    if not loader_object:
+        raise ToolException("Loader configuration is missing.")
+
+    original_kwargs = loader_object.get("kwargs", {}) or {}
+
+    # Keys that will be overwritten below – skip them when copying
+    overridden_keys = {
+        "file_path",
+        "file_content",
+        "file_name",
+        "extract_images",
+        "llm",
+        "page_number",
+        "sheet_name",
+        "excel_by_sheets",
+        "prompt",
+        "row_content",
+        "json_documents",
+    }
+
+    # Build a safe shallow copy without overridden keys to avoid deepcopy
+    # of potentially non-picklable objects (e.g., llm with internal RLock).
+    loader_kwargs = {k: v for k, v in original_kwargs.items() if k not in overridden_keys}
+
     loader_kwargs.update({
         "file_path": file_path,
         "file_content": file_content,
@@ -212,6 +251,41 @@ def load_content_from_bytes(file_content: bytes, extension: str = None, loader_e
         if temp_file_path and os.path.exists(temp_file_path):
             os.remove(temp_file_path)
 
+
+def _load_content_from_bytes_with_prompt(file_content: bytes, extension: str = None, loader_extra_config: dict = None, llm = None, prompt: str = image_processing_prompt) -> str:
+    """Internal helper that behaves like load_content_from_bytes but also propagates prompt.
+
+    This keeps the public load_content_from_bytes API unchanged while allowing newer
+    code paths to pass an explicit prompt through to the loader.
+    """
+    temp_file_path = None
+    try:
+        with tempfile.NamedTemporaryFile(mode='w+b', delete=False, suffix=extension or '') as temp_file:
+            temp_file.write(file_content)
+            temp_file.flush()
+            temp_file_path = temp_file.name
+
+        # Use prepare_loader so that prompt and other kwargs are handled consistently
+        loader = prepare_loader(
+            file_name=None,
+            file_content=None,
+            is_capture_image=loader_extra_config.get('extract_images') if loader_extra_config else False,
+            page_number=loader_extra_config.get('page_number') if loader_extra_config else None,
+            sheet_name=loader_extra_config.get('sheet_name') if loader_extra_config else None,
+            llm=llm or (loader_extra_config.get('llm') if loader_extra_config else None),
+            file_path=temp_file_path,
+            excel_by_sheets=loader_extra_config.get('excel_by_sheets') if loader_extra_config else False,
+            prompt=prompt or (loader_extra_config.get('prompt') if loader_extra_config else image_processing_prompt),
+        )
+
+        documents = loader.load()
+        page_contents = [doc.page_content for doc in documents]
+        return "\n".join(page_contents)
+    finally:
+        if temp_file_path and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+
 def process_document_by_type(content, extension_source: str, document: Document = None, llm = None, chunking_config=None) \
         -> Generator[Document, None, None]:
     """Process the content of a file based on its type using a configured loader cosidering the origin document."""
@@ -338,4 +412,4 @@ def file_extension_by_chunker(chunker_name: str) -> str | None:
         return ".xml"
     if name == "csv":
         return ".csv"
-    return None
+    return None

alita_sdk/tools/utils/text_operations.py

@@ -24,81 +24,50 @@ TEXT_EDITABLE_EXTENSIONS = {
 
 
 def parse_old_new_markers(file_query: str) -> List[Tuple[str, str]]:
-    """
-    Parse OLD/NEW marker-based edit instructions.
-    
-    Extracts pairs of old and new content from a file query using markers:
+    """Parse OLD/NEW marker-based edit instructions.
+
+    Extracts pairs of old and new content from a file query using markers in
+    a minimal, regex-based way without additional line splitting logic.
+
+    Supported forms (OLD/NEW blocks must appear in pairs):
     - OLD <<<< ... >>>> OLD
-    - NEW <<<< ... >>>> NEW
-    
+      NEW <<<< ... >>>> NEW
+    - If no such pairs are found, we also accept the slightly incorrect
+      "<<<" form as a fallback:
+      OLD <<< ... >>> OLD
+      NEW <<< ... >>> NEW
+
     Args:
-        file_query: String containing marked old and new content sections
-        
+        file_query: String containing marked old and new content sections.
+
     Returns:
-        List of tuples (old_content, new_content) for each edit pair
-        
-    Example:
-        >>> query = '''
-        ... OLD <<<<
-        ... Hello World
-        ... >>>> OLD
-        ... NEW <<<<
-        ... Hello Mars
-        ... >>>> NEW
-        ... '''
-        >>> parse_old_new_markers(query)
-        [('Hello World', 'Hello Mars')]
+        List of (old_content, new_content) tuples, where each content string
+        is the raw inner block (with leading/trailing whitespace stripped),
+        but otherwise unmodified.
     """
-    # Split the file content by lines
-    code_lines = file_query.split("\n")
-
-    # Initialize lists to hold the contents of OLD and NEW sections
-    old_contents = []
-    new_contents = []
-
-    # Initialize variables to track whether the current line is within an OLD or NEW section
-    in_old_section = False
-    in_new_section = False
-
-    # Temporary storage for the current section's content
-    current_section_content = []
-
-    # Iterate through each line in the file content
-    for line in code_lines:
-        # Check for OLD section start
-        if "OLD <<<" in line:
-            in_old_section = True
-            current_section_content = []  # Reset current section content
-            continue  # Skip the line with the marker
-
-        # Check for OLD section end
-        if ">>>> OLD" in line:
-            in_old_section = False
-            old_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-            current_section_content = []  # Reset current section content
-            continue  # Skip the line with the marker
-
-        # Check for NEW section start
-        if "NEW <<<" in line:
-            in_new_section = True
-            current_section_content = []  # Reset current section content
-            continue  # Skip the line with the marker
-
-        # Check for NEW section end
-        if ">>>> NEW" in line:
-            in_new_section = False
-            new_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-            current_section_content = []  # Reset current section content
-            continue  # Skip the line with the marker
-
-        # If currently in an OLD or NEW section, add the line to the current section content
-        if in_old_section or in_new_section:
-            current_section_content.append(line)
-
-    # Pair the OLD and NEW contents
-    paired_contents = list(zip(old_contents, new_contents))
-
-    return paired_contents
+    # Primary pattern: correct 4-< markers
+    pattern_primary = re.compile(
+        r"OLD <<<<(\s*.*?\s*)>>>> OLD"  # OLD block
+        r"\s*"                          # optional whitespace between OLD/NEW
+        r"NEW <<<<(\s*.*?\s*)>>>> NEW",  # NEW block
+        re.DOTALL,
+    )
+
+    matches = pattern_primary.findall(file_query)
+
+    # Fallback pattern: accept 3-< markers if no proper 4-< markers found
+    if not matches:
+        pattern_fallback = re.compile(
+            r"OLD <<<(\s*.*?\s*)>>>> OLD"   # OLD block (3 < and 4 > to support previous version)
+            r"\s*"                          # optional whitespace between OLD/NEW
+            r"NEW <<<(\s*.*?\s*)>>>> NEW",  # NEW block (3 < and 4 > to support previous version)
+            re.DOTALL,
+        )
+        matches = pattern_fallback.findall(file_query)
+
+    # Preserve block content exactly as captured so Stage 1 can use exact
+    # substring replacement (including indentation and trailing spaces).
+    return [(old_block, new_block) for old_block, new_block in matches]
 
 
 def is_text_editable(filename: str) -> bool:
@@ -252,3 +221,126 @@ def search_in_content(
             })
     
     return matches
+
+
+def _normalize_for_match(text: str) -> str:
+    """Normalize text for tolerant OLD/NEW matching.
+
+    - Split into lines
+    - Replace common Unicode spaces with regular spaces
+    - Strip leading/trailing whitespace per line
+    - Collapse internal whitespace runs to a single space
+    - Join with '\n'
+    """
+    lines = text.splitlines()
+    norm_lines = []
+    for line in lines:
+        # Normalize common Unicode spaces to regular space
+        line = line.replace("\u00A0", " ").replace("\u2009", " ")
+        # Strip outer whitespace
+        line = line.strip()
+        # Collapse internal whitespace
+        line = re.sub(r"\s+", " ", line)
+        norm_lines.append(line)
+    return "\n".join(norm_lines)
+
+
+def try_apply_edit(
+    content: str,
+    old_text: str,
+    new_text: str,
+    file_path: Optional[str] = None,
+) -> Tuple[str, bool]:
+    """Apply a single OLD/NEW edit with a tolerant fallback.
+
+    This helper is used by edit_file to apply one (old_text, new_text) pair:
+    
+    1. First tries exact substring replacement (old_text in content).
+    2. If that fails, performs a tolerant, line-based match:
+       - Builds a logical OLD sequence without empty/whitespace-only lines
+       - Scans content while skipping empty/whitespace-only lines
+       - Compares using `_normalize_for_match` so minor spacing differences
+         don't break the match
+       - If exactly one such region is found, replaces that region with new_text
+       - If zero or multiple regions are found, no change is applied
+    
+    Args:
+        content: Current file content
+        old_text: OLD block extracted from markers
+        new_text: NEW block extracted from markers
+        file_path: Optional path for logging context
+    
+    Returns:
+        (updated_content, used_fallback)
+    """
+    # Stage 1: exact match
+    if old_text in content:
+        return content.replace(old_text, new_text), False
+
+    # Stage 2: tolerant match
+    if not old_text.strip() or not content:
+        return content, False
+
+    # Logical OLD: drop empty/whitespace-only lines
+    old_lines_raw = old_text.splitlines()
+    old_lines = [l for l in old_lines_raw if l.strip()]
+    if not old_lines:
+        return content, False
+
+    # Precompute normalized OLD (joined by '\n')
+    norm_old = _normalize_for_match("\n".join(old_lines))
+
+    content_lines = content.splitlines(keepends=True)
+    total = len(content_lines)
+    candidates: list[tuple[int, int, str]] = []  # (start_idx, end_idx, block)
+
+    # Scan content for regions whose non-empty, normalized lines match norm_old
+    for start in range(total):
+        idx = start
+        collected_non_empty: list[str] = []
+        window_lines: list[str] = []
+
+        while idx < total and len(collected_non_empty) < len(old_lines):
+            line = content_lines[idx]
+            window_lines.append(line)
+            if line.strip():
+                collected_non_empty.append(line)
+            idx += 1
+
+        if len(collected_non_empty) < len(old_lines):
+            # Not enough non-empty lines from this start; no more windows possible
+            break
+
+        # Compare normalized non-empty content lines to normalized OLD
+        candidate_norm = _normalize_for_match("".join(collected_non_empty))
+        if candidate_norm == norm_old:
+            block = "".join(window_lines)
+            candidates.append((start, idx, block))
+
+    if not candidates:
+        logger.warning(
+            "Fallback match: normalized OLD block not found in %s.",
+            file_path or "<unknown>",
+        )
+        return content, False
+
+    if len(candidates) > 1:
+        logger.warning(
+            "Fallback match: multiple candidate regions for OLD block in %s; "
+            "no change applied to avoid ambiguity.",
+            file_path or "<unknown>",
+        )
+        return content, False
+
+    start_idx, end_idx, candidate_block = candidates[0]
+    updated = content.replace(candidate_block, new_text, 1)
+
+    logger.info(
+        "Fallback match: applied tolerant OLD/NEW replacement in %s around lines %d-%d",
+        file_path or "<unknown>",
+        start_idx + 1,
+        start_idx + len(old_lines),
+    )
+
+    return updated, True
+

alita_sdk/tools/xray/__init__.py

@@ -11,6 +11,7 @@ from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.xray import XrayConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "xray_cloud"
 
@@ -40,7 +41,7 @@ class XrayToolkit(BaseToolkit):
         selected_tools = {x['name']: x['args_schema'].schema() for x in XrayApiWrapper.model_construct().get_available_tools()}
         return create_model(
             name,
-            limit=(Optional[int], Field(description="Limit", default=100)),
+            limit=(Optional[int], Field(description="Limit", default=100, gt=0)),
             xray_configuration=(XrayConfiguration, Field(description="Xray Configuration", json_schema_extra={'configuration_types': ['xray']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
                                                                            description="PgVector Configuration",
@@ -89,7 +90,7 @@ class XrayToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/yagmail/__init__.py

@@ -6,6 +6,7 @@ from pydantic import create_model, BaseModel, Field, SecretStr
 
 from .yagmail_wrapper import YagmailWrapper, SMTP_SERVER
 from ..base.tool import BaseAction
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "yagmail"
 
@@ -53,7 +54,7 @@ class AlitaYagmailToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/zephyr/__init__.py

@@ -9,6 +9,7 @@ from ..base.tool import BaseAction
 from .api_wrapper import ZephyrV1ApiWrapper
 from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "zephyr"
 
@@ -62,7 +63,7 @@ class ZephyrToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/zephyr_enterprise/__init__.py

@@ -8,6 +8,7 @@ from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.zephyr_enterprise import ZephyrEnterpriseConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "zephyr_enterprise"
 
@@ -80,7 +81,7 @@ class ZephyrEnterpriseToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/zephyr_essential/__init__.py

@@ -9,6 +9,7 @@ from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.zephyr_essential import ZephyrEssentialConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "zephyr_essential"
 
@@ -75,7 +76,7 @@ class ZephyrEssentialToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/zephyr_scale/__init__.py

@@ -10,6 +10,7 @@ from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
 from ...configurations.pgvector import PgVectorConfiguration
 from ...configurations.zephyr import ZephyrConfiguration
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "zephyr_scale"
 
@@ -38,7 +39,7 @@ class ZephyrScaleToolkit(BaseToolkit):
         selected_tools = {x['name']: x['args_schema'].schema() for x in ZephyrScaleApiWrapper.model_construct().get_available_tools()}
         return create_model(
             name,
-            max_results=(int, Field(default=100, description="Results count to show")),
+            max_results=(int, Field(default=100, description="Results count to show", gt=0)),
             zephyr_configuration=(ZephyrConfiguration, Field(description="Zephyr Configuration",
                                                                        json_schema_extra={'configuration_types': ['zephyr']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None, description="PgVector Configuration",
@@ -88,7 +89,7 @@ class ZephyrScaleToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/zephyr_scale/api_wrapper.py

@@ -177,13 +177,13 @@ ZephyrSearchTestCases = create_model(
     "ZephyrSearchTestCases",
     project_key=(str, Field(description="Jira project key filter")),
     search_term=(Optional[str], Field(description="Optional search term to filter test cases", default=None)),
-    max_results=(Optional[int], Field(description="Maximum number of results to query from the API", default=1000)),
+    max_results=(Optional[int], Field(description="Maximum number of results to query from the API", default=1000, gt=0)),
     start_at=(Optional[int], Field(description="Zero-indexed starting position", default=0)),
     order_by=(Optional[str], Field(description="Field to order results by", default="name")),
     order_direction=(Optional[str], Field(description="Order direction", default="ASC")),
     archived=(Optional[bool], Field(description="Include archived test cases", default=False)),
     fields=(Optional[List[str]], Field(description="Fields to include in the response (default: key, name). Regular fields include key, name, id, labels, folder, etc. Custom fields can be included in the following ways:Individual custom fields via customFields.field_name format, All custom fields via customFields in the fields list", default=["key", "name"])),
-    limit_results=(Optional[int], Field(description="Maximum number of filtered results to return", default=10)),
+    limit_results=(Optional[int], Field(description="Maximum number of filtered results to return", default=10, gt=0)),
     folder_id=(Optional[str], Field(description="Filter test cases by folder ID", default=None)),
     folder_name=(Optional[str], Field(description="Filter test cases by folder name (full or partial)", default=None)),
     exact_folder_match=(Optional[bool], Field(description="Whether to match the folder name exactly or allow partial matches", default=False)),

alita_sdk/tools/zephyr_squad/__init__.py

@@ -7,6 +7,7 @@ from .api_wrapper import ZephyrSquadApiWrapper
 from ..base.tool import BaseAction
 from ..elitea_base import filter_missconfigured_index_tools
 from ..utils import clean_string, get_max_toolkit_length
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "zephyr_squad"
 
@@ -56,7 +57,7 @@ class ZephyrSquadToolkit(BaseToolkit):
                 name=tool["name"],
                 description=description,
                 args_schema=tool["args_schema"],
-                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
+                metadata={TOOLKIT_NAME_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)
 

{alita_sdk-0.3.532.dist-info → alita_sdk-0.3.602.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.532
+Version: 0.3.602
 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
@@ -68,12 +68,13 @@ Requires-Dist: pytesseract==0.3.13; extra == "runtime"
 Requires-Dist: markdown==3.5.1; extra == "runtime"
 Requires-Dist: beautifulsoup4==4.12.2; extra == "runtime"
 Requires-Dist: charset_normalizer==3.3.2; extra == "runtime"
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc==1.25.0; extra == "runtime"
-Requires-Dist: opentelemetry_api==1.25.0; extra == "runtime"
-Requires-Dist: opentelemetry_instrumentation==0.46b0; extra == "runtime"
-Requires-Dist: grpcio_status==1.63.0rc1; extra == "runtime"
-Requires-Dist: protobuf==4.25.7; extra == "runtime"
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.25.0; extra == "runtime"
+Requires-Dist: opentelemetry_api>=1.25.0; extra == "runtime"
+Requires-Dist: opentelemetry_instrumentation>=0.46b0; extra == "runtime"
+Requires-Dist: grpcio_status>=1.63.0rc1; extra == "runtime"
+Requires-Dist: protobuf>=4.25.7; extra == "runtime"
 Requires-Dist: langchain-sandbox>=0.0.6; extra == "runtime"
+Requires-Dist: langchain-mcp-adapters<0.2.0,>=0.1.14; extra == "runtime"
 Provides-Extra: tools
 Requires-Dist: dulwich==0.21.6; extra == "tools"
 Requires-Dist: paramiko==3.3.1; extra == "tools"