alita-sdk 0.3.257__py3-none-any.whl → 0.3.562__py3-none-any.whl

alita_sdk/tools/ado/work_item/ado_wrapper.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import re
 import urllib.parse
 from typing import Dict, List, Generator, Optional
 
@@ -7,6 +8,7 @@ from azure.devops.connection import Connection
 from azure.devops.v7_1.core import CoreClient
 from azure.devops.v7_1.wiki import WikiClient
 from azure.devops.v7_1.work_item_tracking import TeamContext, Wiql, WorkItemTrackingClient
+from bs4 import BeautifulSoup
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
 from msrest.authentication import BasicAuthentication
@@ -15,6 +17,8 @@ from pydantic import model_validator
 from pydantic.fields import Field
 
 from alita_sdk.tools.non_code_indexer_toolkit import NonCodeIndexerToolkit
+from ...utils.content_parser import parse_file_content
+from ....runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
 
@@ -52,7 +56,11 @@ ADOGetWorkItem = create_model(
     id=(int, Field(description="The work item id")),
     fields=(Optional[list[str]], Field(description="Comma-separated list of requested fields", default=None)),
     as_of=(Optional[str], Field(description="AsOf UTC date time string", default=None)),
-    expand=(Optional[str], Field(description="The expand parameters for work item attributes. Possible options are { None, Relations, Fields, Links, All }.", default=None))
+    expand=(Optional[str], Field(description="The expand parameters for work item attributes. Possible options are { None, Relations, Fields, Links, All }.", default=None)),
+    parse_attachments=(Optional[bool], Field(description="Value that defines is attachment should be parsed.", default=False)),
+    image_description_prompt=(Optional[str],
+                     Field(description="Prompt which is used for image description", default=None)),
+
 )
 
 ADOLinkWorkItem = create_model(
@@ -283,8 +291,23 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
             logger.error(f"Error searching work items: {e}")
             return ToolException(f"Error searching work items: {e}")
 
-
-    def get_work_item(self, id: int, fields: Optional[list[str]] = None, as_of: Optional[str] = None, expand: Optional[str] = None):
+    def parse_attachment_by_url(self, attachment_url, file_name=None, image_description_prompt=None):
+        match = re.search(r'attachments/([\w-]+)(?:\?fileName=([^&]+))?', attachment_url)
+        if match:
+            attachment_id = match.group(1)
+            if not file_name:
+                file_name = match.group(2)
+            if not file_name:
+                raise ToolException("File name must be provided either in the URL or as a parameter.")
+            return self.parse_attachment_by_id(attachment_id, file_name, image_description_prompt)
+        raise ToolException(f"Attachment '{attachment_url}' was not found.")
+
+    def parse_attachment_by_id(self, attachment_id, file_name, image_description_prompt):
+        file_content = self.get_attachment_content(attachment_id)
+        return parse_file_content(file_content=file_content, file_name=file_name,
+                                            llm=self.llm, prompt=image_description_prompt)
+
+    def get_work_item(self, id: int, fields: Optional[list[str]] = None, as_of: Optional[str] = None, expand: Optional[str] = None, parse_attachments=False, image_description_prompt=None):
         """Get a single work item by ID."""
         try:
             # Validate that the Azure DevOps client is initialized
@@ -306,11 +329,38 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
                 parsed_item.update(fields_data)
 
             # extract relations if any
-            relations_data = work_item.relations
+            relations_data = None
+            if expand and str(expand).lower() in ("relations", "all"):
+                try:
+                    relations_data = getattr(work_item, 'relations', None)
+                except KeyError:
+                    relations_data = None
             if relations_data:
-                parsed_item['relations'] = []
-                for relation in relations_data:
-                    parsed_item['relations'].append(relation.as_dict())
+                parsed_item['relations'] = [relation.as_dict() for relation in relations_data]
+
+            if parse_attachments:
+                # describe images in work item fields if present
+                for field_name, field_value in fields_data.items():
+                    if isinstance(field_value, str):
+                        soup = BeautifulSoup(field_value, 'html.parser')
+                        images = soup.find_all('img')
+                        for img in images:
+                            src = img.get('src')
+                            if src:
+                                description = self.parse_attachment_by_url(src, image_description_prompt=image_description_prompt)
+                                img['image-description'] = description
+                        parsed_item[field_name] = str(soup)
+                # parse attached documents if present
+                for relation in parsed_item.get('relations', []):
+                    # Only process actual file attachments
+                    if relation.get('rel') == 'AttachedFile':
+                        file_name = relation.get('attributes', {}).get('name')
+                        if file_name:
+                            try:
+                                relation['content'] = self.parse_attachment_by_url(relation['url'], file_name, image_description_prompt=image_description_prompt)
+                            except Exception as att_e:
+                                logger.warning(f"Failed to parse attachment {file_name}: {att_e}")
+
 
             return parsed_item
         except Exception as e:
@@ -521,11 +571,45 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
                 'attachment_ids': {rel.url.split('/')[-1]:rel.attributes.get('name', '') for rel in wi.relations or [] if rel.rel == 'AttachedFile'}
             })
 
+    def get_attachment_content(self, attachment_id):
+        content_generator = self._client.get_attachment_content(id=attachment_id, download=True)
+        return b"".join(content_generator)
+
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        for attachment_id, file_name in document.metadata.get('attachment_ids', {}).items():
-            content_generator = self._client.get_attachment_content(id=attachment_id, download=True)
-            content = b"".join(x for x in content_generator)
-            yield Document(page_content="", metadata={'id': attachment_id, 'loader_content_type': file_name, 'loader_content': content})
+        raw_attachment_ids = document.metadata.get('attachment_ids', {})
+
+        # Normalize attachment_ids: accept dict or JSON string, raise otherwise
+        if isinstance(raw_attachment_ids, str):
+            try:
+                loaded = json.loads(raw_attachment_ids)
+            except json.JSONDecodeError:
+                raise TypeError(
+                    f"Expected dict or JSON string for 'attachment_ids', got non-JSON string for id="
+                    f"{document.metadata.get('id')}: {raw_attachment_ids!r}"
+                )
+            if not isinstance(loaded, dict):
+                raise TypeError(
+                    f"'attachment_ids' JSON did not decode to dict for id={document.metadata.get('id')}: {loaded!r}"
+                )
+            attachment_ids = loaded
+        elif isinstance(raw_attachment_ids, dict):
+            attachment_ids = raw_attachment_ids
+        else:
+            raise TypeError(
+                f"Expected 'attachment_ids' to be dict or JSON string, got {type(raw_attachment_ids)} "
+                f"for id={document.metadata.get('id')}: {raw_attachment_ids!r}"
+            )
+
+        for attachment_id, file_name in attachment_ids.items():
+            content = self.get_attachment_content(attachment_id=attachment_id)
+            yield Document(
+                page_content="",
+                metadata={
+                    'id': attachment_id,
+                    IndexerKeywords.CONTENT_FILE_NAME.value: file_name,
+                    IndexerKeywords.CONTENT_IN_BYTES.value: content,
+                },
+            )
 
     def _index_tool_params(self):
         """Return the parameters for indexing data."""

alita_sdk/tools/advanced_jira_mining/__init__.py

@@ -5,7 +5,8 @@ from pydantic import create_model, BaseModel, Field, SecretStr
 
 from .data_mining_wrapper import AdvancedJiraMiningWrapper
 from ..base.tool import BaseAction
-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
 
 name = "advanced_jira_mining"
 
@@ -27,15 +28,13 @@ def get_tools(tool):
 
 class AdvancedJiraMiningToolkit(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 AdvancedJiraMiningWrapper.model_construct().get_available_tools()}
-        AdvancedJiraMiningToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            jira_base_url=(str, Field(default="", title="Jira URL", description="Jira URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AdvancedJiraMiningToolkit.toolkit_max_length})),
+            jira_base_url=(str, Field(default="", title="Jira URL", description="Jira URL", json_schema_extra={'toolkit_name': True})),
             confluence_base_url=(str, Field(default="", title="Confluence URL", description="Confluence URL")),
             model_type=(str, Field(default="", title="Model type", description="Model type")),
             summarization_prompt=(Optional[str], Field(default=None, title="Summarization prompt", description="Summarization prompt")),
@@ -59,22 +58,27 @@ class AdvancedJiraMiningToolkit(BaseToolkit):
         )
 
     @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 = []
         jira_mining_wrapper = AdvancedJiraMiningWrapper(**kwargs)
         available_tools = jira_mining_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
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=jira_mining_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/aws/delta_lake/__init__.py

@@ -3,10 +3,10 @@ from functools import lru_cache
 from typing import List, Optional, Type
 
 from langchain_core.tools import BaseTool, BaseToolkit
-from pydantic import BaseModel, Field, SecretStr, computed_field, field_validator
+from pydantic import BaseModel, Field, computed_field, field_validator
 
 from alita_sdk.configurations.delta_lake import DeltaLakeConfiguration
-from ...utils import TOOLKIT_SPLITTER, clean_string, get_max_toolkit_length
+from ...utils import clean_string, get_max_toolkit_length
 from .api_wrapper import DeltaLakeApiWrapper
 from .tool import DeltaLakeAction
 
@@ -21,10 +21,6 @@ def get_available_tools() -> dict[str, dict]:
     }
     return available_tools
 
-toolkit_max_length = lru_cache(maxsize=1)(
-    lambda: get_max_toolkit_length(get_available_tools())
-)
-
 class DeltaLakeToolkitConfig(BaseModel):
     class Config:
         title = name
@@ -54,7 +50,7 @@ class DeltaLakeToolkitConfig(BaseModel):
             }
         }
 
-    delta_lake_configuration: Optional[DeltaLakeConfiguration] = Field(description="Delta Lake Configuration", json_schema_extra={"configuration_types": ["delta_lake"]})
+    delta_lake_configuration: DeltaLakeConfiguration = Field(description="Delta Lake Configuration", json_schema_extra={"configuration_types": ["delta_lake"]})
     selected_tools: List[str] = Field(default=[], description="Selected tools", json_schema_extra={"args_schemas": get_available_tools()})
 
     @field_validator("selected_tools", mode="before", check_fields=False)
@@ -87,9 +83,10 @@ class DeltaLakeToolkit(BaseToolkit):
 
     @computed_field
     @property
-    def tool_prefix(self) -> str:
+    def toolkit_context(self) -> str:
+        """Returns toolkit context for descriptions (max 1000 chars)."""
         return (
-            clean_string(self.toolkit_name, toolkit_max_length()) + TOOLKIT_SPLITTER
+            f" [Toolkit: {clean_string(self.toolkit_name, 0)}]"
             if self.toolkit_name
             else ""
         )
@@ -118,12 +115,18 @@ class DeltaLakeToolkit(BaseToolkit):
             selected_tools = set(selected_tools)
             for t in instance.available_tools:
                 if t["name"] in selected_tools:
+                    description = t["description"]
+                    if toolkit_name:
+                        description = f"Toolkit: {toolkit_name}\n{description}"
+                    description = f"S3 Path: {getattr(instance.api_wrapper, 's3_path', '')} Table Path: {getattr(instance.api_wrapper, 'table_path', '')}\n{description}"
+                    description = description[:1000]
                     instance.tools.append(
                         DeltaLakeAction(
                             api_wrapper=instance.api_wrapper,
-                            name=instance.tool_prefix + t["name"],
-                            description=f"S3 Path: {getattr(instance.api_wrapper, 's3_path', '')} Table Path: {getattr(instance.api_wrapper, 'table_path', '')}\n" + t["description"],
+                            name=t["name"],
+                            description=description,
                             args_schema=t["args_schema"],
+                            metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
                         )
                     )
         return instance

alita_sdk/tools/aws/delta_lake/tool.py

@@ -29,7 +29,11 @@ class DeltaLakeAction(BaseTool):
     ) -> str:
         """Use the Delta Lake API to run an operation."""
         try:
+            # Strip numeric suffix added for deduplication (_2, _3, etc.)
+            # to get the original tool name that exists in the wrapper
+            import re
+            tool_name = re.sub(r'_\d+$', '', self.name)
             # Use the tool name to dispatch to the correct API wrapper method
-            return self.api_wrapper.run(self.name, *args, **kwargs)
+            return self.api_wrapper.run(tool_name, *args, **kwargs)
         except Exception as e:
             return f"Error: {format_exc()}"

alita_sdk/tools/azure_ai/search/__init__.py

@@ -4,7 +4,9 @@ from .api_wrapper import AzureSearchApiWrapper
 from ...base.tool import BaseAction
 from langchain_core.tools import BaseToolkit, BaseTool
 from pydantic import create_model, BaseModel, ConfigDict, Field
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
+
+from ...elitea_base import filter_missconfigured_index_tools
+from ...utils import clean_string, get_max_toolkit_length, check_connection_response
 from ....configurations.azure_search import AzureSearchConfiguration
 import requests
 
@@ -29,17 +31,15 @@ def get_toolkit():
 
 class AzureSearchToolkit(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 AzureSearchApiWrapper.model_construct().get_available_tools()}
-        AzureSearchToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
             index_name=(str, Field(description="Azure Search index name")),
             azure_search_configuration=(
-                Optional[AzureSearchConfiguration],
+                AzureSearchConfiguration,
                 Field(description="Azure Search Configuration", json_schema_extra={'configuration_types': ['azure_search']})
             ),
             api_version=(Optional[str], Field(description="API version", default=None)),
@@ -66,6 +66,7 @@ class AzureSearchToolkit(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 = []
@@ -76,17 +77,21 @@ class AzureSearchToolkit(BaseToolkit):
         }
         azure_search_api_wrapper = AzureSearchApiWrapper(**wrapper_payload)
         available_tools = azure_search_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
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=azure_search_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/base/tool.py

@@ -23,6 +23,10 @@ class BaseAction(BaseTool):
     ) -> ToolException | str:
         """Use the Confluence API to run an operation."""
         try:
-            return self.api_wrapper.run(self.name, *args, **kwargs)
+            # Strip numeric suffix added for deduplication (_2, _3, etc.)
+            # to get the original tool name that exists in the wrapper
+            import re
+            tool_name = re.sub(r'_\d+$', '', self.name)
+            return self.api_wrapper.run(tool_name, *args, **kwargs)
         except Exception as e:
             return ToolException(f"An exception occurred: {e}")