alita-sdk 0.3.172__py3-none-any.whl → 0.3.173__py3-none-any.whl

alita_sdk/tools/ado/repos/__init__.py

@@ -46,10 +46,10 @@ class AzureDevOpsReposToolkit(BaseToolkit):
         AzureDevOpsReposToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            organization_url=(Optional[str], Field(default="", title="Organization URL", description="ADO organization url")),
-            project=(Optional[str], Field(default="", title="Project", description="ADO project")),
-            repository_id=(Optional[str], Field(default="", title="Repository ID", description="ADO repository ID", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsReposToolkit.toolkit_max_length})),
-            token=(Optional[SecretStr], Field(default="", title="Token", description="ADO token", json_schema_extra={'secret': True})),
+            organization_url=(Optional[str], Field(default="", title="Organization URL", description="ADO organization url", json_schema_extra={'configuration': True})),
+            project=(Optional[str], Field(default="", title="Project", description="ADO project", json_schema_extra={'configuration': True})),
+            repository_id=(Optional[str], Field(default="", title="Repository ID", description="ADO repository ID", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsReposToolkit.toolkit_max_length, 'configuration': True})),
+            token=(Optional[SecretStr], Field(default="", title="Token", description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             base_branch=(Optional[str], Field(default="", title="Base branch", description="ADO base branch (e.g., main)")),
             active_branch=(Optional[str], Field(default="", title="Active branch", description="ADO active branch (e.g., main)")),
 

alita_sdk/tools/ado/test_plan/__init__.py

@@ -3,9 +3,10 @@ from typing import List, Optional, Literal
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field, SecretStr
 
+import requests
 from .test_plan_wrapper import TestPlanApiWrapper
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
 
 
 name = "azure_devops_plans"
@@ -20,12 +21,12 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in TestPlanApiWrapper.model_construct().get_available_tools()}
         AzureDevOpsPlansToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+        m = create_model(
             name_alias,
             name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsPlansToolkit.toolkit_max_length})),
-            organization_url=(str, Field(description="ADO organization url")),
+            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
-            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True})),
+            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={'json_schema_extra': {'metadata':
                 {
@@ -49,6 +50,18 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
             }
         )
 
+        @check_connection_response
+        def check_connection(self):
+            response = requests.get(
+                f'{self.organization_url}/{self.project}/_apis/testplan/plans?api-version=7.0',
+                headers = {'Authorization': f'Bearer {self.token}'},
+                timeout=5
+            )
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ

alita_sdk/tools/ado/wiki/__init__.py

@@ -3,8 +3,9 @@ from .ado_wrapper import AzureDevOpsApiWrapper  # Import the API wrapper for Azu
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field, SecretStr
 
+import requests
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
 
 name = "azure_devops_wiki"
 name_alias = 'ado_wiki'
@@ -17,16 +18,16 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureDevOpsApiWrapper.model_construct().get_available_tools()}
         AzureDevOpsWikiToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+        m = create_model(
             name_alias,
             name=(str, Field(description="Toolkit name",
                              json_schema_extra={
                                  'toolkit_name': True,
                                  'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length})
                   ),
-            organization_url=(str, Field(description="ADO organization url")),
-            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length})),
-            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True})),
+            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
+            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWikiToolkit.toolkit_max_length, 'configuration': True})),
+            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={
@@ -52,6 +53,18 @@ class AzureDevOpsWikiToolkit(BaseToolkit):
             }
         )
 
+        @check_connection_response
+        def check_connection(self):
+            response = requests.get(
+                f'{self.organization_url}/{self.project}/_apis/wiki/wikis?api-version=7.0',
+                headers={'Authorization': f'Bearer {self.token}'},
+                timeout=5
+            )
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ

alita_sdk/tools/ado/work_item/__init__.py

@@ -3,8 +3,9 @@ from .ado_wrapper import AzureDevOpsApiWrapper  # Import the API wrapper for Azu
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import create_model, BaseModel, Field, SecretStr
 
+import requests
 from ...base.tool import BaseAction
-from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
 
 name = "ado_boards"
 
@@ -16,16 +17,16 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in AzureDevOpsApiWrapper.model_construct().get_available_tools()}
         AzureDevOpsWorkItemsToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+        m = create_model(
             name,
             name=(str, Field(description="Toolkit name",
                              json_schema_extra={
                                  'toolkit_name': True,
                                  'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length})
                   ),
-            organization_url=(str, Field(description="ADO organization url")),
-            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length})),
-            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True})),
+            organization_url=(str, Field(description="ADO organization url", json_schema_extra={'configuration': True})),
+            project=(str, Field(description="ADO project", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsWorkItemsToolkit.toolkit_max_length, 'configuration': True})),
+            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__={
@@ -51,6 +52,18 @@ class AzureDevOpsWorkItemsToolkit(BaseToolkit):
             }
         )
 
+        @check_connection_response
+        def check_connection(self):
+            response = requests.get(
+                f'{self.organization_url}/{self.project}/_apis/wit/workitemtypes?api-version=7.0',
+                headers={'Authorization': f'Bearer {self.token}'},
+                timeout=5
+            )
+            return response
+
+        m.check_connection = check_connection
+        return m
+
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         from os import environ

alita_sdk/tools/confluence/__init__.py

@@ -4,7 +4,8 @@ from .api_wrapper import ConfluenceAPIWrapper
 from langchain_core.tools import BaseTool
 from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list
+from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
+import requests
 
 name = "confluence"
 
@@ -43,7 +44,21 @@ class ConfluenceToolkit(BaseToolkit):
         selected_tools = {x['name']: x['args_schema'].schema() for x in
                           ConfluenceAPIWrapper.model_construct().get_available_tools()}
         ConfluenceToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+
+        @check_connection_response
+        def check_connection(self):
+            url = self.base_url.rstrip('/') + '/wiki/rest/api/space'
+            headers = {'Accept': 'application/json'}
+            auth = None
+            if self.token:
+                headers['Authorization'] = f'Bearer {self.token.get_secret_value()}'
+            elif self.username and self.api_key:
+                auth = (self.username, self.api_key.get_secret_value())
+            else:
+                raise ValueError('Confluence connection requires either token or username+api_key')
+            response = requests.get(url, headers=headers, auth=auth, timeout=5, verify=getattr(self, 'verify_ssl', True))
+            return response
+        model = create_model(
             name,
             base_url=(str, Field(description="Confluence URL", json_schema_extra={'configuration': True, 'configuration_title': True})),
             token=(SecretStr, Field(description="Token", default=None, json_schema_extra={'secret': True, 'configuration': True})),
@@ -92,6 +107,8 @@ class ConfluenceToolkit(BaseToolkit):
                 }
             })
         )
+        model.check_connection = check_connection
+        return model
 
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):

alita_sdk/tools/confluence/api_wrapper.py

@@ -163,7 +163,7 @@ pageId = create_model(
 indexPagesParams = create_model(
     "indexPagesParams",
     __base__=BaseIndexParams,
-    content_format=(Literal['view', 'storage', 'export_view', 'editor', 'anonymous'], 
+    content_format=(Literal['view', 'storage', 'export_view', 'editor', 'anonymous'],
                     Field(description="The format of the content to be retrieved.")),
     ### Loader Parameters
     page_ids=(Optional[List[str]], Field(description="List of page IDs to retrieve.", default=None)),
@@ -196,6 +196,13 @@ GetPageWithImageDescriptions = create_model(
         default=500))
 )
 
+GetPageAttachmentsInput = create_model(
+    "GetPageAttachmentsInput",
+    page_id=(str, Field(description="Confluence page ID from which attachments will be retrieved")),
+    max_content_length=(int, Field(default=10000, description="Maximum number of characters to return for attachment content. Content will be truncated if longer. Default is 10000.")),
+    custom_prompt=(Optional[str], Field(default=None, description="Custom prompt to use for LLM-based analysis of attachments (images, pdfs, etc). If not provided, a default prompt will be used.")),
+)
+
 
 def parse_payload_params(params: Optional[str]) -> Dict[str, Any]:
     if params:
@@ -710,6 +717,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
             metadata=metadata,
         )
 
+    # todo: refactor this method since file processing is not working (self.process_pdf, self.process_image, etc. are not defined)
     def process_attachment(
             self,
             page_id: str,
@@ -893,7 +901,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
             from alita_sdk.langchain.interfaces.llm_processor import get_embeddings
         except ImportError:
             from alita_sdk.runtime.langchain.interfaces.llm_processor import get_embeddings
-        
+
         loader_params = {
             'url': self.base_url,
             'space_key': self.space,
@@ -919,7 +927,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
         embedding = get_embeddings(self.embedding_model, self.embedding_model_params)
 
         chunker = chunkers.get(chunking_tool)
-        
+
         chunking_config = chunking_config or {}
 
         if chunker:
@@ -929,7 +937,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
                 # Set required fields that should come from the instance
                 chunking_config['embedding'] = embedding
                 chunking_config['llm'] = self.llm
-                
+
                 try:
                     # Validate the configuration using the appropriate Pydantic model
                     validated_config = config_model(**chunking_config)
@@ -941,13 +949,13 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
                 # Fallback for chunkers without models
                 chunking_config['embedding'] = embedding
                 chunking_config['llm'] = self.llm
-                
+
             documents = chunker(documents, chunking_config)
-        
+
         # passing embedding to avoid re-initialization
-        vectorstore = self._init_vector_store(collection_suffix, embeddings=embedding) 
+        vectorstore = self._init_vector_store(collection_suffix, embeddings=embedding)
         return vectorstore.index_documents(documents)
-        
+
 
     def _download_image(self, image_url):
         """
@@ -1094,7 +1102,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
         """
         return """
         ## Image Analysis Task:
-        Analyze this image in detail, paying special attention to contextual information provided about it. 
+        Analyze this image in detail, paying special attention to contextual information provided about it.
         Focus on:
         1. Visual elements and their arrangement
         2. Any text visible in the image
@@ -1159,14 +1167,32 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
             return cached_description
 
         try:
-            from io import BytesIO
-            from PIL import Image, UnidentifiedImageError
-
             # Get the LLM instance
             llm = self.llm
             if not llm:
                 return "[LLM not available for image processing]"
 
+            # If image_data is empty or None, do text-only analysis
+            if not image_data:
+                prompt = custom_prompt if custom_prompt else self._get_default_image_analysis_prompt()
+                if image_name or context_text:
+                    prompt += "\n\n## Additional Context Information:\n"
+                    if image_name:
+                        prompt += f"- Image Name/Reference: {image_name}\n"
+                    if context_text:
+                        prompt += f"- Surrounding Content: {context_text}\n"
+                    prompt += "\nPlease incorporate this contextual information in your description when relevant."
+                result = llm.invoke([
+                    HumanMessage(
+                        content=[{"type": "text", "text": prompt}]
+                    )
+                ])
+                description = result.content
+                self._image_cache.set(image_data, description, image_name)
+                return description
+
+            from io import BytesIO
+            from PIL import Image, UnidentifiedImageError
             # Try to load and validate the image with PIL
             try:
                 bio = BytesIO(image_data)
@@ -1402,6 +1428,251 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
             logger.error(f"Error processing page with images: {stacktrace}")
             return f"Error processing page with images: {str(e)}"
 
+    def get_page_attachments(self, page_id: str, max_content_length: int = 10000, custom_prompt: str = None):
+        """
+        Retrieve all attachments for a Confluence page, including core metadata (with creator, created, updated), comments,
+        file content, and LLM-based analysis for supported types.
+        Returns a list of dicts, each with keys: metadata, comments, content, llm_analysis.
+        """
+        try:
+            attachments = self.client.get_attachments_from_content(page_id)
+            if not attachments or not attachments.get('results'):
+                return f"No attachments found for page ID {page_id}."
+
+            # Get attachment history for created/updated info
+            history_map = {}
+            for attachment in attachments['results']:
+                try:
+                    hist = self.client.history(attachment['id'])
+                    history_map[attachment['id']] = hist
+                except Exception as e:
+                    logger.warning(f"Failed to fetch history for attachment {attachment.get('title', '')}: {str(e)}")
+                    history_map[attachment['id']] = None
+
+            results = []
+            for attachment in attachments['results']:
+                media_type = attachment.get('metadata', {}).get('mediaType', '')
+                # Core metadata extraction with history
+                hist = history_map.get(attachment['id']) or {}
+                created_by = hist.get('createdBy', {}).get('displayName', '') if hist else attachment.get('creator', {}).get('displayName', '')
+                created_date = hist.get('createdDate', '') if hist else attachment.get('created', '')
+                last_updated = hist.get('lastUpdated', {}).get('when', '') if hist else ''
+                metadata = {
+                    'name': attachment.get('title', ''),
+                    'size': attachment.get('extensions', {}).get('fileSize', None),
+                    'creator': created_by,
+                    'created': created_date,
+                    'updated': last_updated,
+                    'media_type': media_type,
+                    'labels': [label['name'] for label in attachment.get('metadata', {}).get('labels', {}).get('results', [])],
+                    'download_url': self.base_url.rstrip('/') + attachment['_links']['download'] if attachment.get('_links', {}).get('download') else None
+                }
+                # Fetch comments for the attachment
+                comments = []
+                try:
+                    comments_response = self.client.get_comments_for_attachment(attachment['id'])
+                    if comments_response and 'results' in comments_response:
+                        for comment in comments_response['results']:
+                            comments.append({
+                                'id': comment.get('id'),
+                                'author': comment.get('creator', {}).get('displayName', ''),
+                                'created': comment.get('created', ''),
+                                'body': comment.get('body', {}).get('storage', {}).get('value', '')
+                            })
+                except Exception as e:
+                    logger.warning(f"Failed to fetch comments for attachment {attachment.get('title', '')}: {str(e)}")
+
+                content = None
+                llm_analysis = None
+                title = attachment.get('title', '')
+                download_url = self.base_url.rstrip('/') + attachment['_links']['download']
+
+                # --- Begin: Raw content for xml, json, markdown, txt ---
+                # Check by media type or file extension
+                file_ext = title.lower().split('.')[-1] if '.' in title else ''
+                is_text_type = (
+                    media_type in [
+                        'application/xml', 'text/xml',
+                        'application/json', 'text/json',
+                        'text/markdown', 'text/x-markdown',
+                        'text/plain', 'text/csv',
+                        'text/html', 'image/svg+xml',
+                        'application/vnd.ms-excel',
+                        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                        'application/msword',
+                        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                        'application/vnd.ms-excel.sheet.macroEnabled.12',
+                        'application/csv', 'application/x-csv',
+                        'text/x-csv',
+                        'application/doc',  'application/docx',
+                        'application/xls', 'application/xlsx',
+                        'application/svg', 'application/html',
+                    ]
+                    or file_ext in [
+                        'xml', 'json', 'md', 'markdown', 'txt',
+                        'csv', 'xls', 'xlsx', 'svg', 'html', 'htm', 'doc', 'docx'
+                    ]
+                )
+                if is_text_type:
+                    try:
+                        resp = self.client.request(method="GET", path=download_url[len(self.base_url):], advanced_mode=True)
+                        if resp.status_code == 200:
+                            # Try utf-8, fallback to latin1
+                            try:
+                                content = resp.content.decode('utf-8')
+                            except UnicodeDecodeError:
+                                content = resp.content.decode('latin1')
+                        else:
+                            content = f"[Failed to download: HTTP {resp.status_code}]"
+                    except Exception as e:
+                        content = f"[Error downloading content: {str(e)}]"
+
+                    # For some types, try to extract text if possible
+                    if file_ext in ['doc', 'docx']:
+                        try:
+                            import io
+                            if file_ext == 'docx':
+                                try:
+                                    from docx import Document as DocxDocument
+                                    docx_file = io.BytesIO(resp.content)
+                                    doc = DocxDocument(docx_file)
+                                    paragraphs = [p.text for p in doc.paragraphs]
+                                    content = '\n'.join(paragraphs)
+                                except Exception as e:
+                                    content = f"[Error extracting docx: {str(e)}]"
+                            elif file_ext == 'doc':
+                                try:
+                                    import textract
+                                    content = textract.process(None, extension='doc', input_data=resp.content).decode('utf-8')
+                                except Exception as e:
+                                    content = f"[Error extracting doc: {str(e)}]"
+                        except ImportError:
+                            content = "[python-docx or textract not installed for doc/docx extraction]"
+                    elif file_ext in ['csv']:
+                        try:
+                            import io
+                            import csv
+                            csv_file = io.StringIO(content)
+                            reader = csv.reader(csv_file)
+                            content = '\n'.join([', '.join(row) for row in reader])
+                        except Exception as e:
+                            content = f"[Error extracting csv: {str(e)}]"
+                    elif file_ext in ['xls', 'xlsx']:
+                        try:
+                            import io
+                            import pandas as pd
+                            excel_file = io.BytesIO(resp.content)
+                            df = pd.read_excel(excel_file, sheet_name=None)
+                            content = ''
+                            for sheet, data in df.items():
+                                content += f"\n--- Sheet: {sheet} ---\n"
+                                content += data.to_csv(index=False)
+                        except Exception as e:
+                            content = f"[Error extracting xls/xlsx: {str(e)}]"
+                    elif file_ext in ['svg'] or media_type == 'image/svg+xml':
+                        # SVG is XML, so just return as text
+                        pass
+                    elif file_ext in ['html', 'htm'] or media_type in ['text/html', 'application/html']:
+                        try:
+                            from bs4 import BeautifulSoup
+                            soup = BeautifulSoup(content, 'html.parser')
+                            content = soup.get_text(separator=' ', strip=True)
+                        except Exception as e:
+                            content = f"[Error extracting html: {str(e)}]"
+
+                    # Truncate content if longer than max_content_length
+                    if content and isinstance(content, str) and len(content) > max_content_length:
+                        content = content[:max_content_length] + f"\n...[truncated, showing first {max_content_length} characters]"
+
+                    # No LLM analysis for these types
+                    results.append({
+                        'metadata': metadata,
+                        'comments': comments,
+                        'content': content,
+                        'llm_analysis': llm_analysis
+                    })
+                    continue
+                # --- End: Raw content for xml, json, markdown, txt ---
+
+                # Download content for supported types
+                if media_type.startswith('image/') or media_type == 'application/pdf' or media_type.startswith('application/vnd.jgraph.mxfile'):
+                    if media_type == 'application/pdf':
+                        try:
+                            from pdf2image import convert_from_bytes
+                        except ImportError:
+                            logger.warning("pdf2image is not installed. Please install it to process PDF attachments.")
+                            llm_analysis = '[pdf2image not installed]'
+                            image_data = None
+                        else:
+                            image_data = self._download_image(download_url)
+                            if image_data:
+                                try:
+                                    pdf_images = convert_from_bytes(image_data)
+                                    llm_analysis = []
+                                    for idx, img in enumerate(pdf_images):
+                                        from io import BytesIO
+                                        img_buffer = BytesIO()
+                                        img.save(img_buffer, format='PNG')
+                                        img_buffer.seek(0)
+                                        page_context = f"Attachment: {title} (type: {media_type}, page {idx+1})"
+                                        page_analysis = self._process_image_with_llm(img_buffer.getvalue(), f"{title} (page {idx+1})", page_context, custom_prompt)
+                                        llm_analysis.append(page_analysis)
+                                    llm_analysis = '\n'.join(llm_analysis)
+                                except Exception as e:
+                                    logger.error(f"Failed to process PDF pages: {str(e)}")
+                                    llm_analysis = f"[Error processing PDF: {str(e)}]"
+                            else:
+                                content = None
+                                llm_analysis = None
+                    elif media_type.startswith('application/vnd.jgraph.mxfile'):
+                        # Handle drawio (mxfile): base64 decode & decompress, then run LLM
+                        image_data = self._download_image(download_url)
+                        if image_data:
+                            try:
+                                import xml.etree.ElementTree as ET
+                                import base64
+                                import zlib
+                                xml_str = image_data.decode("utf-8")
+                                root = ET.fromstring(xml_str)
+                                diagram_node = root.find("diagram")
+                                if diagram_node is not None and diagram_node.text:
+                                    diagram_base64 = diagram_node.text
+                                else:
+                                    diagram_base64 = None
+
+                                compressed = base64.b64decode(diagram_base64)
+                                xml_bytes = zlib.decompress(compressed, -15)
+                                xml_string = xml_bytes.decode('utf-8')
+
+                                # Use LLM to analyze the diagram XML string as text
+                                context_text = f"Attachment: {title} (type: {media_type})\nDrawio XML Content: {xml_string[:2000]}"  # Limit context for LLM
+                                llm_analysis = self._process_image_with_llm(b"", title, context_text, custom_prompt)  # Pass empty image, just analyze text
+                            except Exception as e:
+                                logger.error(f"Failed to convert drawio to image: {str(e)}")
+                                llm_analysis = f"[Error processing drawio: {str(e)}]"
+                        else:
+                            content = None
+                            llm_analysis = None
+                    else:
+                        image_data = self._download_image(download_url)
+                        if image_data:
+                            context_text = f"Attachment: {title} (type: {media_type})"
+                            llm_analysis = self._process_image_with_llm(image_data, title, context_text, custom_prompt)
+
+                if llm_analysis and isinstance(llm_analysis, str) and len(llm_analysis) > max_content_length:
+                        llm_analysis = llm_analysis[:max_content_length] + f"\n...[truncated, showing first {max_content_length} characters]"
+
+                results.append({
+                    'metadata': metadata,
+                    'comments': comments,
+                    'content': content,
+                    'llm_analysis': llm_analysis
+                })
+            return results
+        except Exception as e:
+            logger.error(f"Error retrieving attachments for page {page_id}: {str(e)}")
+            return f"Error retrieving attachments: {str(e)}"
+
     def get_available_tools(self):
         # Confluence-specific tools
         confluence_tools = [
@@ -1519,10 +1790,16 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
                 "ref": self.index_data,
                 "description": self.index_data.__doc__,
                 "args_schema": indexPagesParams,
+            },
+            {
+                "name": "get_page_attachments",
+                "ref": self.get_page_attachments,
+                "description": self.get_page_attachments.__doc__,
+                "args_schema": GetPageAttachmentsInput,
             }
         ]
-        
+
         # Add standardized vector search tools from base class
         vector_search_tools = self._get_vector_search_tools()
-        
+
         return confluence_tools + vector_search_tools

alita_sdk/tools/jira/__init__.py

@@ -3,8 +3,9 @@ from .api_wrapper import JiraApiWrapper
 from langchain_core.tools import BaseTool, BaseToolkit
 from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+import requests
 
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list
+from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
 
 name = "jira"
 
@@ -33,7 +34,22 @@ class JiraToolkit(BaseToolkit):
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in JiraApiWrapper.model_construct().get_available_tools()}
         JiraToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
-        return create_model(
+
+        @check_connection_response
+        def check_connection(self):
+            url = self.base_url.rstrip('/') + '/rest/api/2/myself'
+            headers = {'Accept': 'application/json'}
+            auth = None
+            if self.token:
+                headers['Authorization'] = f'Bearer {self.token.get_secret_value()}'
+            elif self.username and self.api_key:
+                auth = (self.username, self.api_key.get_secret_value())
+            else:
+                raise ValueError('Jira connection requires either token or username+api_key')
+            response = requests.get(url, headers=headers, auth=auth, timeout=5, verify=getattr(self, 'verify_ssl', True))
+            return response
+
+        model = create_model(
             name,
             base_url=(
                 str,
@@ -84,6 +100,8 @@ class JiraToolkit(BaseToolkit):
                 }
             })
         )
+        model.check_connection = check_connection
+        return model
 
     @classmethod
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):

{alita_sdk-0.3.172.dist-info → alita_sdk-0.3.173.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.172
+Version: 0.3.173
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.172.dist-info → alita_sdk-0.3.173.dist-info}/RECORD

@@ -133,13 +133,13 @@ alita_sdk/tools/__init__.py,sha256=48DhEi14KkaYhNb-KvXuM9XJ4WGC-v9sRcWfN7GFWd4,9
 alita_sdk/tools/elitea_base.py,sha256=NQaIxPX6DVIerHCb18jwUR6maZxxk73NZaTsFHkBQWE,21119
 alita_sdk/tools/ado/__init__.py,sha256=mD6GHcYMTtffPJkJvFPe2rzvye_IRmXmWfI7xYuZhO4,912
 alita_sdk/tools/ado/utils.py,sha256=PTCludvaQmPLakF2EbCGy66Mro4-rjDtavVP-xcB2Wc,1252
-alita_sdk/tools/ado/repos/__init__.py,sha256=Wro7xo1GcpX4M4yPBqDKFFE2wCCVzj0HyusdAmloxKM,5686
+alita_sdk/tools/ado/repos/__init__.py,sha256=-sMK94fLgtIAGoP26wXs466kF6AiZhdLDdr_--o4ELU,5818
 alita_sdk/tools/ado/repos/repos_wrapper.py,sha256=_OWKAls7VFfFtEPTwqj_DxE1MSvpC0ivxdTIULEz3Tk,48206
-alita_sdk/tools/ado/test_plan/__init__.py,sha256=ctn2CUkH_xS0Wkv2gLrO3FHQ36BvNCc0VcpMuddvU8E,3404
+alita_sdk/tools/ado/test_plan/__init__.py,sha256=PmVBwOQExgDmiywQEL9D29hbX3fC1pJd6bROnyBOu_k,3916
 alita_sdk/tools/ado/test_plan/test_plan_wrapper.py,sha256=oIvVhLUMP5ZGctoAtK6sU0y6Si9gNv9-mbLqcWtw3gY,12525
-alita_sdk/tools/ado/wiki/__init__.py,sha256=92AIAXVYSEYKnNvEG08W2YmR2lC35Bn92CiXJ8T3vpA,3736
+alita_sdk/tools/ado/wiki/__init__.py,sha256=6WRwKBznxXP5vSDpPT6i5njPgPsrUUOJ8U1qeH3wtGk,4265
 alita_sdk/tools/ado/wiki/ado_wrapper.py,sha256=l4bc2QoKSUXg9UqNcx0ylv7YL9JPPQd35Ti5MXyEgC4,12690
-alita_sdk/tools/ado/work_item/__init__.py,sha256=HcPX18wODKCn8oCnhs0DRXYKaRxiQ6GvEGgd1emHud8,3832
+alita_sdk/tools/ado/work_item/__init__.py,sha256=kLIFw7w_3ygqqPjzxWJ8cC9cbOxNl_yfxjhI7RGs1Ys,4368
 alita_sdk/tools/ado/work_item/ado_wrapper.py,sha256=t0D9xubU0yy_JmRJ_zEtRCxwFLyanT1StbIrtHGaqpw,26108
 alita_sdk/tools/advanced_jira_mining/__init__.py,sha256=pUTzECqGvYaR5qWY3JPUhrImrZgc7pCXuqSe5eWIE80,4604
 alita_sdk/tools/advanced_jira_mining/data_mining_wrapper.py,sha256=nZPtuwVWp8VeHw1B8q9kdwf-6ZvHnlXTOGdcIMDkKpw,44211
@@ -216,8 +216,8 @@ alita_sdk/tools/code/linter/api_wrapper.py,sha256=wylpwhAw02Jt8L18CqBq2He5PbwIkx
 alita_sdk/tools/code/loaders/codesearcher.py,sha256=XoXXZtIQZhvjIwZlnl_4wVGHC-3saYzFo5oDR_Zh3EY,529
 alita_sdk/tools/code/sonar/__init__.py,sha256=u8wpgXJ_shToLl3G9-XEtGDor5dhmsnurIImh1-e-U0,3165
 alita_sdk/tools/code/sonar/api_wrapper.py,sha256=nNqxcWN_6W8c0ckj-Er9HkNuAdgQLoWBXh5UyzNutis,2653
-alita_sdk/tools/confluence/__init__.py,sha256=ySsU3XzjQhSdl-XG1z_9H-Vmie-kqIY4_4yvf1NPdXQ,6088
-alita_sdk/tools/confluence/api_wrapper.py,sha256=-0NYvc_vCdNYSVcBq3UP4YN5s3y7h78KhYABMWy3Hxw,72281
+alita_sdk/tools/confluence/__init__.py,sha256=MkAUfSgQTZ6lVOHErwFggA4v_ctD9ADhhq6dKIALko0,6922
+alita_sdk/tools/confluence/api_wrapper.py,sha256=nCU4wAh3f6EN3NVXya3BVZQX47mi7JYAzylxJJOvMMc,88725
 alita_sdk/tools/confluence/loader.py,sha256=aHqgdIQMqkyRry8feHAhyd-a_ASEyW3JrV6epTRG6-c,9162
 alita_sdk/tools/confluence/utils.py,sha256=Lxo6dBD0OlvM4o0JuK6qeB_4LV9BptiwJA9e1vqNcDw,435
 alita_sdk/tools/custom_open_api/__init__.py,sha256=9aT5SPNPWcJC6jMZEM-3rUCXVULj_3-qJLQKmnreKNo,2537
@@ -244,7 +244,7 @@ alita_sdk/tools/gmail/gmail_wrapper.py,sha256=t0IYM3zb77Ub8o9kv6HugNm_OoG5tN9T73
 alita_sdk/tools/gmail/utils.py,sha256=cu6pbSsyMIr1BQOSs9et1rbAkk-Z_u48PB9FtJwFhUs,448
 alita_sdk/tools/google_places/__init__.py,sha256=mHKc7u9P2gqGDzqqJNQC9qiZYEm5gncnM_1XjtrM17o,3152
 alita_sdk/tools/google_places/api_wrapper.py,sha256=7nZly6nk4f4Tm7s2MVdnnwlb-1_WHRrDhyjDiqoyPjA,4674
-alita_sdk/tools/jira/__init__.py,sha256=rHfbnECLMCK0DvPvnYNKnz0ZalbpeLMXnsQl7hDuMcA,5151
+alita_sdk/tools/jira/__init__.py,sha256=es7-lRkd3MPwR4rXWTQTFI_yfP2hRoeD8oJD5SbhJkk,5978
 alita_sdk/tools/jira/api_wrapper.py,sha256=i0TIHhVnh44dAVTt6RWrZ4o9hyhSMfVkYtk6FB3D2zA,62035
 alita_sdk/tools/keycloak/__init__.py,sha256=0WB9yXMUUAHQRni1ghDEmd7GYa7aJPsTVlZgMCM9cQ0,3050
 alita_sdk/tools/keycloak/api_wrapper.py,sha256=cOGr0f3S3-c6tRDBWI8wMnetjoNSxiV5rvC_0VHb8uw,3100
@@ -326,8 +326,8 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=UHVQUVqcBc3SZvDfO78HSuBzwAsRw
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=rq4jOb3lRW2GXvAguk4H1KinO5f-zpygzhBJf-E1Ucw,2773
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=iOMxyE7vOc_LwFB_nBMiSFXkNtvbptA4i-BrTlo7M0A,5854
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=IYUJoMFOMA70knLhLtAnuGoy3OK80RuqeQZ710oyIxE,3631
-alita_sdk-0.3.172.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.172.dist-info/METADATA,sha256=m184rG7yffSAsOEtfvcaqDMj6Xc01NvHefXrFTtYS7E,18757
-alita_sdk-0.3.172.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.172.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.172.dist-info/RECORD,,
+alita_sdk-0.3.173.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.173.dist-info/METADATA,sha256=XTue8f1fKyX4zdPdddEyLCNsSDbFo-VdK7pLuIbZ5mI,18757
+alita_sdk-0.3.173.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.173.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.173.dist-info/RECORD,,