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

alita_sdk/tools/code_indexer_toolkit.py

@@ -0,0 +1,199 @@
+import ast
+import fnmatch
+import json
+import logging
+from typing import Optional, List, Generator
+
+from langchain_core.documents import Document
+from langchain_core.tools import ToolException
+from pydantic import Field
+
+from alita_sdk.tools.base_indexer_toolkit import BaseIndexerToolkit
+
+logger = logging.getLogger(__name__)
+
+
+class CodeIndexerToolkit(BaseIndexerToolkit):
+    def _get_indexed_data(self, index_name: str):
+        self._ensure_vectorstore_initialized()
+        if not self.vector_adapter:
+            raise ToolException("Vector adapter is not initialized. "
+                             "Check your configuration: embedding_model and vectorstore_type.")
+        return self.vector_adapter.get_code_indexed_data(self, index_name)
+
+    def key_fn(self, document: Document):
+        return document.metadata.get("filename")
+
+    def compare_fn(self, document: Document, idx_data):
+        return (document.metadata.get('commit_hash') and
+            idx_data.get('commit_hashes') and
+            document.metadata.get('commit_hash') in idx_data.get('commit_hashes')
+        )
+
+    def remove_ids_fn(self, idx_data, key: str):
+        return idx_data[key]['ids']
+
+    def _base_loader(
+            self,
+            branch: Optional[str] = None,
+            whitelist: Optional[List[str]] = None,
+            blacklist: Optional[List[str]] = None,
+            **kwargs) -> Generator[Document, None, None]:
+        """Index repository files in the vector store using code parsing."""
+        yield from self.loader(
+            branch=branch,
+            whitelist=whitelist,
+            blacklist=blacklist
+        )
+
+    def _extend_data(self, documents: Generator[Document, None, None]):
+        yield from documents
+
+    def _index_tool_params(self):
+        """Return the parameters for indexing data."""
+        return {
+            "branch": (Optional[str], Field(
+                description="Branch to index files from. Defaults to active branch if None.",
+                default=None)),
+            "whitelist": (Optional[List[str]], Field(
+                description='File extensions or paths to include. Defaults to all files if None. Example: ["*.md", "*.java"]',
+                default=None)),
+            "blacklist": (Optional[List[str]], Field(
+                description='File extensions or paths to exclude. Defaults to no exclusions if None. Example: ["*.md", "*.java"]',
+                default=None)),
+        }
+
+    def loader(self,
+               branch: Optional[str] = None,
+               whitelist: Optional[List[str]] = None,
+               blacklist: Optional[List[str]] = None,
+               chunked: bool = True) -> Generator[Document, None, None]:
+        """
+        Generates Documents from files in a branch, respecting whitelist and blacklist patterns.
+    
+        Parameters:
+        - branch (Optional[str]): Branch for listing files. Defaults to the current branch if None.
+        - whitelist (Optional[List[str]]): File extensions or paths to include. Defaults to all files if None.
+        - blacklist (Optional[List[str]]): File extensions or paths to exclude. Defaults to no exclusions if None.
+        - chunked (bool): If True (default), applies universal chunker based on file type.
+                         If False, returns raw Documents without chunking.
+    
+        Returns:
+        - generator: Yields Documents from files matching the whitelist but not the blacklist.
+                    Each document has exactly the key 'filename' in metadata, which is used as an ID
+                    for further operations (indexing, deduplication, and retrieval).
+    
+        Example:
+        # Use 'feature-branch', include '.py' files, exclude 'test_' files
+        for doc in loader(branch='feature-branch', whitelist=['*.py'], blacklist=['*test_*']):
+            print(doc.page_content)
+    
+        Notes:
+        - Whitelist and blacklist use Unix shell-style wildcards.
+        - Files must match the whitelist and not the blacklist to be included.
+        - Each document MUST have exactly the key 'filename' in metadata. This key is used as an ID
+          for further operations such as indexing, deduplication, and retrieval.
+        - When chunked=True:
+          - .md files → markdown chunker (header-based splitting)
+          - .py/.js/.ts/etc → code parser (TreeSitter-based)
+          - .json files → JSON chunker
+          - other files → default text chunker
+        """
+        import hashlib
+    
+        _files = self.__handle_get_files("", self.__get_branch(branch))
+        self._log_tool_event(message="Listing files in branch", tool_name="loader")
+        logger.info(f"Files in branch: {_files}")
+    
+        def is_whitelisted(file_path: str) -> bool:
+            if whitelist:
+                return (any(fnmatch.fnmatch(file_path, pattern) for pattern in whitelist)
+                        or any(file_path.endswith(f'.{pattern}') for pattern in whitelist))
+            return True
+    
+        def is_blacklisted(file_path: str) -> bool:
+            if blacklist:
+                return (any(fnmatch.fnmatch(file_path, pattern) for pattern in blacklist)
+                        or any(file_path.endswith(f'.{pattern}') for pattern in blacklist))
+            return False
+    
+        def raw_document_generator() -> Generator[Document, None, None]:
+            """Yields raw Documents without chunking."""
+            self._log_tool_event(message="Reading the files", tool_name="loader")
+            total_files = len(_files)
+            processed = 0
+            
+            for idx, file in enumerate(_files, 1):
+                if is_whitelisted(file) and not is_blacklisted(file):
+                    try:
+                        file_content = self._read_file(file, self.__get_branch(branch))
+                    except Exception as e:
+                        logger.error(f"Failed to read file {file}: {e}")
+                        continue
+                    
+                    if not file_content:
+                        continue
+                    
+                    # Ensure file content is a string
+                    if isinstance(file_content, bytes):
+                        file_content = file_content.decode("utf-8", errors="ignore")
+                    elif isinstance(file_content, dict) and file.endswith('.json'):
+                        file_content = json.dumps(file_content)
+                    elif not isinstance(file_content, str):
+                        file_content = str(file_content)
+                    
+                    # Hash the file content for uniqueness tracking
+                    file_hash = hashlib.sha256(file_content.encode("utf-8")).hexdigest()
+                    processed += 1
+                    
+                    yield Document(
+                        page_content=file_content,
+                        metadata={
+                            'file_path': file,
+                            'filename': file,
+                            'source': file,
+                            'commit_hash': file_hash,
+                        }
+                    )
+                
+                if idx % 10 == 0 or idx == total_files:
+                    self._log_tool_event(
+                        message=f"{idx} out of {total_files} files checked, {processed} matched",
+                        tool_name="loader"
+                    )
+            
+            self._log_tool_event(message=f"{processed} files loaded", tool_name="loader")
+
+        if not chunked:
+            # Return raw documents without chunking
+            return raw_document_generator()
+        
+        # Apply universal chunker based on file type
+        from .chunkers.universal_chunker import universal_chunker
+        return universal_chunker(raw_document_generator())
+
+    def __handle_get_files(self, path: str, branch: str):
+        """
+        Handles the retrieval of files from a specific path and branch.
+        This method should be implemented in subclasses to provide the actual file retrieval logic.
+        """
+        _files = self._get_files(path=path, branch=branch)
+        if isinstance(_files, str):
+            try:
+                # Attempt to convert the string to a list using ast.literal_eval
+                _files = ast.literal_eval(_files)
+                # Ensure that the result is actually a list of strings
+                if not isinstance(_files, list) or not all(isinstance(item, str) for item in _files):
+                    raise ValueError("The evaluated result is not a list of strings")
+            except (SyntaxError, ValueError):
+                # Handle the case where the string cannot be converted to a list
+                raise ValueError("Expected a list of strings, but got a string that cannot be converted")
+
+            # Ensure _files is a list of strings
+        if not isinstance(_files, list) or not all(isinstance(item, str) for item in _files):
+            raise ValueError("Expected a list of strings")
+        return _files
+
+    def __get_branch(self, branch):
+       return (branch or getattr(self, 'active_branch', None)
+               or getattr(self, '_active_branch', None) or getattr(self, 'branch', None))

alita_sdk/tools/confluence/__init__.py

@@ -4,17 +4,19 @@ from .api_wrapper import ConfluenceAPIWrapper
 from langchain_core.tools import BaseTool
 from ..base.tool import BaseAction
 from pydantic import create_model, BaseModel, ConfigDict, Field
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, parse_list, check_connection_response
+
+from ..elitea_base import filter_missconfigured_index_tools
+from ..utils import clean_string, get_max_toolkit_length, parse_list, check_connection_response
 from ...configurations.confluence import ConfluenceConfiguration
 from ...configurations.pgvector import PgVectorConfiguration
 import requests
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "confluence"
 
-def get_tools(tool):
+def get_toolkit(tool):
     return ConfluenceToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        base_url=tool['settings']['base_url'],
         space=tool['settings'].get('space', None),
         cloud=tool['settings'].get('cloud', True),
         confluence_configuration=tool['settings']['confluence_configuration'],
@@ -32,18 +34,19 @@ def get_tools(tool):
         doctype='doc',
         embedding_model=tool['settings'].get('embedding_model'),
         vectorstore_type="PGVector"
-    ).get_tools()
+    )
+
+def get_tools(tool):
+    return get_toolkit(tool).get_tools()
 
 
 class ConfluenceToolkit(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
                           ConfluenceAPIWrapper.model_construct().get_available_tools()}
-        ConfluenceToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
 
         @check_connection_response
         def check_connection(self):
@@ -66,8 +69,7 @@ class ConfluenceToolkit(BaseToolkit):
 
         model = create_model(
             name,
-            space=(str, Field(description="Space", json_schema_extra={'toolkit_name': True,
-                                                                                    'max_toolkit_length': ConfluenceToolkit.toolkit_max_length})),
+            space=(str, Field(description="Space")),
             cloud=(bool, Field(description="Hosting Option", json_schema_extra={'configuration': True})),
             limit=(int, Field(description="Pages limit per request", default=5)),
             labels=(Optional[str], Field(
@@ -80,8 +82,8 @@ class ConfluenceToolkit(BaseToolkit):
             min_retry_seconds=(int, Field(description="Min retry, sec", default=10)),
             max_retry_seconds=(int, Field(description="Max retry, sec", default=60)),
             # optional field for custom headers as dictionary
-            custom_headers=(Optional[dict], Field(description="Custom headers for API requests", default=None)),
-            confluence_configuration=(Optional[ConfluenceConfiguration], Field(description="Confluence Configuration", json_schema_extra={'configuration_types': ['confluence']})),
+            custom_headers=(Optional[dict], Field(description="Custom headers for API requests", default={})),
+            confluence_configuration=(ConfluenceConfiguration, Field(description="Confluence Configuration", json_schema_extra={'configuration_types': ['confluence']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default = None,
                                                                            description="PgVector Configuration",
                                                                            json_schema_extra={'configuration_types': ['pgvector']})),
@@ -103,6 +105,7 @@ class ConfluenceToolkit(BaseToolkit):
         return model
 
     @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 = []
@@ -113,18 +116,23 @@ class ConfluenceToolkit(BaseToolkit):
             **(kwargs.get('pgvector_configuration') or {}),
         }
         confluence_api_wrapper = ConfluenceAPIWrapper(**wrapper_payload)
-        prefix = clean_string(toolkit_name, ConfluenceToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = confluence_api_wrapper.get_available_tools()
         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 = f"Confluence space: {confluence_api_wrapper.space}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=confluence_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"Confluence space: {confluence_api_wrapper.space}" + tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                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/confluence/api_wrapper.py

@@ -1,24 +1,27 @@
-import re
-import logging
-import requests
-import json
 import base64
+import json
+import logging
+import re
 import traceback
-from typing import Optional, List, Any, Dict, Callable, Generator, Literal
 from json import JSONDecodeError
+from typing import Optional, List, Any, Dict, Callable, Generator, Literal
 
-from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
-from tenacity import retry, stop_after_attempt, wait_exponential, before_sleep_log
-
+import requests
+from atlassian.errors import ApiError
+from langchain_community.document_loaders.confluence import ContentFormat
 from langchain_core.documents import Document
-from langchain_core.tools import ToolException
 from langchain_core.messages import HumanMessage
+from langchain_core.tools import ToolException
 from markdownify import markdownify
-from langchain_community.document_loaders.confluence import ContentFormat
+from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
+from requests import HTTPError
+from tenacity import retry, stop_after_attempt, wait_exponential, before_sleep_log
 
-from ..elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
+from alita_sdk.tools.non_code_indexer_toolkit import NonCodeIndexerToolkit
+from alita_sdk.tools.utils.available_tools_decorator import extend_with_parent_available_tools
 from ..llm.img_utils import ImageDescriptionCache
 from ..utils import is_cookie_token, parse_cookie_string
+from ...runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
 
@@ -171,7 +174,7 @@ def parse_payload_params(params: Optional[str]) -> Dict[str, Any]:
     return {}
 
 
-class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
+class ConfluenceAPIWrapper(NonCodeIndexerToolkit):
     # Changed from PrivateAttr to Optional field with exclude=True
     client: Optional[Any] = Field(default=None, exclude=True)
     base_url: str
@@ -193,15 +196,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
     keep_markdown_format: Optional[bool] = True
     ocr_languages: Optional[str] = None
     keep_newlines: Optional[bool] = True
-    llm: Any = None
-    # indexer related
-    connection_string: Optional[SecretStr] = None
-    collection_name: Optional[str] = None
-    doctype: Optional[str] = 'doc'
-    embedding_model: Optional[str] = "HuggingFaceEmbeddings"
-    embedding_model_params: Optional[Dict[str, Any]] = {"model_name": "sentence-transformers/all-MiniLM-L6-v2"}
-    vectorstore_type: Optional[str] = "PGVector"
-
+    _errors: Optional[list[str]] = None
     _image_cache: ImageDescriptionCache = PrivateAttr(default_factory=ImageDescriptionCache)
 
     @model_validator(mode='before')
@@ -232,13 +227,13 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
         else:
             client_instance = Confluence(url=url, username=username, password=api_key, cloud=cloud)
 
-        custom_headers = values.get('custom_headers', {})
-        logger.info(f"Jira tool: custom headers length: {len(custom_headers)}")
+        custom_headers = values.get('custom_headers') or {}
+        logger.info(f"Confluence tool: custom headers length: {len(custom_headers)}")
         for header, value in custom_headers.items():
             client_instance._update_header(header, value)
 
         values['client'] = client_instance
-        return values
+        return super().validate_toolkit(values)
 
     def __unquote_confluence_space(self) -> str | None:
         if self.space:
@@ -485,28 +480,78 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
         """Gets pages with specific label in the Confluence space."""
 
         start = 0
-        pages_info = []
-        for _ in range((self.max_pages + self.limit - 1) // self.limit):
-            pages = self.client.get_all_pages_by_label(label, start=start,
-                                                       limit=self.limit)  # , expand="body.view.value"
+        pages_info: List[Dict[str, Any]] = []
+        seen_ids: set[str] = set()
+
+        # Use a while-loop driven by unique pages collected and
+        # presence of additional results instead of a fixed number
+        # of iterations based purely on max_pages/limit.
+        while len(pages_info) < (self.max_pages or 0):
+            pages = self.client.get_all_pages_by_label(
+                label,
+                start=start,
+                limit=self.limit,
+            )  # , expand="body.view.value"
             if not pages:
                 break
 
-            pages_info += [{
-                'page_id': page.metadata['id'],
-                'page_title': page.metadata['title'],
-                'page_url': page.metadata['source'],
-                'content': page.page_content
-            } for page in self.get_pages_by_id([page["id"] for page in pages])]
+            # Collect only ids we haven't processed yet to avoid
+            # calling get_page_by_id multiple times for the same
+            # Confluence page.
+            new_ids: List[str] = []
+            for p in pages:
+                page_id = p["id"] if isinstance(p, dict) else getattr(p, "id", None)
+                if page_id is None:
+                    continue
+                if page_id in seen_ids:
+                    continue
+                seen_ids.add(page_id)
+                new_ids.append(page_id)
+
+            if new_ids:
+                for page in self.get_pages_by_id(new_ids):
+                    meta = getattr(page, "metadata", {}) or {}
+                    page_id = meta.get("id")
+                    page_title = meta.get("title")
+                    page_url = meta.get("source")
+                    content = getattr(page, "page_content", None)
+
+                    if page_id is None:
+                        continue
+
+                    pages_info.append(
+                        {
+                            "page_id": page_id,
+                            "page_title": page_title,
+                            "page_url": page_url,
+                            "content": content,
+                        }
+                    )
+
+                    # Respect max_pages on unique pages collected.
+                    if len(pages_info) >= (self.max_pages or 0):
+                        break
+
+            # Advance the offset by the requested page size.
             start += self.limit
-        return pages_info
+
+            # Defensive break: if the API returns fewer items than
+            # requested, there are likely no more pages to fetch.
+            if len(pages) < self.limit:
+                break
+
+        # Slice as an extra safety net in case of any race conditions
+        # around the max_pages guard in the loop above.
+        return pages_info[: (self.max_pages or len(pages_info))]
 
     def is_public_page(self, page: dict) -> bool:
         """Check if a page is publicly accessible."""
         restrictions = self.client.get_all_restrictions_for_content(page["id"])
 
         return (
-                page["status"] == "current"
+                (page["status"] == "current"
+                # allow user to see archived content if needed
+                 or page["status"] == "archived")
                 and not restrictions["read"]["restrictions"]["user"]["results"]
                 and not restrictions["read"]["restrictions"]["group"]["results"]
         )
@@ -526,18 +571,35 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
                 ),
                 before_sleep=before_sleep_log(logger, logging.WARNING),
             )(self.client.get_page_by_id)
-            page = get_page(
-                page_id=page_id, expand=f"{self.content_format.value},version"
-            )
-            if not self.include_restricted_content and not self.is_public_page(page):
-                continue
+            try:
+                page = get_page(
+                    page_id=page_id, expand=f"{self.content_format.value},version"
+                )
+            except (ApiError, HTTPError) as e:
+                logger.error(f"Error fetching page with ID {page_id}: {e}")
+                page_content_temp = f"Confluence API Error: cannot fetch the page with ID {page_id}: {e}"
+                # store errors
+                if self._errors is None:
+                    self._errors = []
+                self._errors.append(page_content_temp)
+                return Document(page_content=page_content_temp,
+                                metadata={})
+            # TODO: update on toolkit advanced settings level as a separate feature
+            # if not self.include_restricted_content and not self.is_public_page(page):
+            #     continue
             yield self.process_page(page, skip_images)
 
+    def _log_errors(self):
+        """ Log errors encountered during toolkit execution. """
+        if self._errors:
+            logger.info(f"Errors encountered during toolkit execution: {self._errors}")
+
     def read_page_by_id(self, page_id: str, skip_images: bool = False):
         """Reads a page by its id in the Confluence space. If id is not available, but there is a title - use get_page_id first."""
         result = list(self.get_pages_by_id([page_id], skip_images))
         if not result:
-            "Page not found"
+            return f"Pages not found. Errors: {self._errors}" if self._errors \
+                else "Pages not found or you do not have access to them."
         return result[0].page_content
         # return self._strip_base64_images(result[0].page_content) if skip_images else result[0].page_content
 
@@ -547,7 +609,9 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
         :param title: title
         :param type: type of content: page or blogpost. Defaults to page
         """
-        return self.client.get_page_id(space=self.space, title=title, type=type)
+
+        result = self.client.get_page_id(space=self.space, title=title, type=type)
+        return result if result else "Page not found. Check the title or space."
 
     def _strip_base64_images(self, content):
         base64_md_pattern = r'data:image/(png|jpeg|gif);base64,[a-zA-Z0-9+/=]+'
@@ -570,7 +634,7 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
                 }
                 pages_info.append(page_info)
             start += self.limit
-        return str(pages_info)
+        return str(pages_info) if pages_info else f"Unable to find anything using query {cql}. Check space or query."
 
     def search_pages(self, query: str, skip_images: bool = False):
         """Search pages in Confluence by query text in title or page content."""
@@ -821,6 +885,10 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
         from .loader import AlitaConfluenceLoader
         from copy import copy
         content_format = kwargs.get('content_format', 'view').lower()
+
+        self._index_include_attachments = kwargs.get('include_attachments', False)
+        self._include_extensions = kwargs.get('include_extensions', [])
+        self._skip_extensions = kwargs.get('skip_extensions', [])
         base_params = {
             'url': self.base_url,
             'space_key': self.space,
@@ -852,12 +920,81 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
             yield document
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        attachments = self.get_page_attachments(document.metadata.get('id'))
-        if isinstance(attachments, str):
-            logger.info(f" {document.metadata.get('id')}: {attachments}")
-            return
-        for attachment in attachments:
-            yield Document(page_content=attachment.get('content', '') or attachment.get('llm_analysis', ''), metadata=attachment.get('metadata', {}))
+        try:
+            if self._index_include_attachments:
+                page_id = document.metadata.get('id')
+                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
+
+                import re
+                for attachment in attachments['results']:
+                    title = attachment.get('title', '')
+                    file_ext = title.lower().split('.')[-1] if '.' in title else ''
+
+                    # Re-verify extension filters
+                    # Check if file should be skipped based on skip_extensions
+                    if any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', title, re.IGNORECASE)
+                           for pattern in self._skip_extensions):
+                        continue
+
+                    # Check if file should be included based on include_extensions
+                    # If include_extensions is empty, process all files (that weren't skipped)
+                    if self._include_extensions and not (
+                    any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', title, re.IGNORECASE)
+                        for pattern in self._include_extensions)):
+                        continue
+
+                    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 ''
+
+                    attachment_path = attachment['_links']['download'] if attachment.get(
+                            '_links', {}).get('download') else ''
+                    download_url = self.client.url.rstrip('/') + attachment_path
+                    metadata = {
+                        'name': 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': download_url
+                    }
+                    try:
+                        resp = self.client.request(method="GET", path=attachment_path, advanced_mode=True)
+                        if resp.status_code == 200:
+                            content = resp.content
+                        else:
+                            content = f"[Failed to download {download_url}: HTTP status code {resp.status_code}]"
+                    except Exception as e:
+                        content = f"[Error downloading content: {str(e)}]"
+
+                    if isinstance(content, str):
+                        yield Document(page_content=content, metadata=metadata)
+                    else:
+                        yield Document(page_content="", metadata={
+                            **metadata,
+                            IndexerKeywords.CONTENT_FILE_NAME.value: f".{file_ext}",
+                            IndexerKeywords.CONTENT_IN_BYTES.value: content
+                        })
+        except Exception as e:
+            yield from ()
 
     def _download_image(self, image_url):
         """
@@ -1598,18 +1735,24 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
             "include_restricted_content": (Optional[bool], Field(description="Include restricted content.", default=False)),
             "include_archived_content": (Optional[bool], Field(description="Include archived content.", default=False)),
             "include_attachments": (Optional[bool], Field(description="Include attachments.", default=False)),
+            'include_extensions': (Optional[List[str]], Field(
+                description="List of file extensions to include when processing attachments: i.e. ['*.png', '*.jpg']. "
+                            "If empty, all files will be processed (except skip_extensions).",
+                default=[])),
+            'skip_extensions': (Optional[List[str]], Field(
+                description="List of file extensions to skip when processing attachments: i.e. ['*.png', '*.jpg']",
+                default=[])),
             "include_comments": (Optional[bool], Field(description="Include comments.", default=False)),
-            "include_labels": (Optional[bool], Field(description="Include labels.", default=True)),
+            "include_labels": (Optional[bool], Field(description="Include labels.", default=False)),
             "ocr_languages": (Optional[str], Field(description="OCR languages for processing attachments.", default='eng')),
             "keep_markdown_format": (Optional[bool], Field(description="Keep the markdown format.", default=True)),
             "keep_newlines": (Optional[bool], Field(description="Keep newlines in the content.", default=True)),
             "bins_with_llm": (Optional[bool], Field(description="Use LLM for processing binary files.", default=False)),
         }
 
-    @extend_with_vector_tools
+    @extend_with_parent_available_tools
     def get_available_tools(self):
-        # Confluence-specific tools
-        confluence_tools = [
+        return [
             {
                 "name": "create_page",
                 "ref": self.create_page,
@@ -1726,7 +1869,3 @@ class ConfluenceAPIWrapper(BaseVectorStoreToolApiWrapper):
             }
         ]
 
-        # Add standardized vector search tools from base class
-        vector_search_tools = self._get_vector_search_tools()
-
-        return confluence_tools + vector_search_tools