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

alita_sdk/tools/jira/api_wrapper.py

@@ -4,7 +4,7 @@ import re
 import traceback
 from json import JSONDecodeError
 from traceback import format_exc
-from typing import List, Optional, Any, Dict, Generator
+from typing import List, Optional, Any, Dict, Generator, Literal
 import os
 
 from atlassian import Jira
@@ -13,10 +13,11 @@ from langchain_core.tools import ToolException
 from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
 import requests
 
-from ..elitea_base import BaseVectorStoreToolApiWrapper, extend_with_vector_tools
 from ..llm.img_utils import ImageDescriptionCache
+from ..non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ..utils import is_cookie_token, parse_cookie_string
-from ..utils.content_parser import parse_file_content, load_content_from_bytes
+from ..utils.available_tools_decorator import extend_with_parent_available_tools
+from ..utils.content_parser import file_extension_by_chunker, process_content_by_type
 from ...runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
@@ -131,6 +132,13 @@ GetRemoteLinks = create_model(
     jira_issue_key=(str, Field(description="Jira issue key from which remote links will be extracted, e.g. TEST-1234"))
 )
 
+GetIssueAttachments = create_model(
+    "GetIssueAttachments",
+    jira_issue_key=(str, Field(description="Jira issue key from which remote links will be extracted, e.g. TEST-1234")),
+    attachment_pattern=(Optional[str], Field(description="Regex pattern to filter attachment filenames. If not provided,"
+                                                         " all attachments will be processed", default=None))
+)
+
 ListCommentsInput = create_model(
     "ListCommentsInputModel",
     issue_key=(str, Field(description="The issue key of the Jira issue from which comments will be extracted, e.g. 'TEST-123'."))
@@ -391,7 +399,7 @@ def process_search_response(jira_url, response, payload_params: Dict[str, Any] =
 
     return str(processed_issues)
 
-class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
+class JiraApiWrapper(NonCodeIndexerToolkit):
     base_url: str
     api_version: Optional[str] = "2",
     api_key: Optional[SecretStr] = None,
@@ -436,50 +444,72 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             cls._client = Jira(url=url, token=token, cloud=cloud, verify_ssl=values['verify_ssl'], api_version=api_version)
         else:
             cls._client = Jira(url=url, username=username, password=api_key, cloud=cloud, verify_ssl=values['verify_ssl'], api_version=api_version)
-        custom_headers = values.get('custom_headers', {})
+        custom_headers = values.get('custom_headers') or {}
         logger.info(f"Jira tool: custom headers length: {len(custom_headers)}")
         for header, value in custom_headers.items():
             cls._client._update_header(header, value)
 
         cls.llm=values.get('llm')
-        return values
+        return super().validate_toolkit(values)
 
     def _parse_issues(self, issues: Dict) -> List[dict]:
-        parsed = []
-        for issue in issues["issues"]:
-            if len(parsed) >= self.limit:
+        parsed: List[dict] = []
+        issues_list = issues.get("issues") if isinstance(issues, dict) else None
+        if not isinstance(issues_list, list):
+            return parsed
+
+        for issue in issues_list:
+            if self.limit and len(parsed) >= self.limit:
                 break
-            issue_fields = issue["fields"]
-            key = issue["key"]
-            id = issue["id"]
-            summary = issue_fields["summary"]
-            description = issue_fields["description"]
-            created = issue_fields["created"][0:10]
-            updated = issue_fields["updated"]
-            duedate = issue_fields["duedate"]
-            priority = issue_fields["priority"]["name"]
-            status = issue_fields["status"]["name"]
-            project_id = issue_fields["project"]["id"]
-            issue_url = f"{self._client.url}browse/{key}"
-            try:
-                assignee = issue_fields["assignee"]["displayName"]
-            except Exception:
-                assignee = "None"
+
+            issue_fields = issue.get("fields") or {}
+            key = issue.get("key", "")
+            issue_id = issue.get("id", "")
+
+            summary = issue_fields.get("summary") or ""
+            description = issue_fields.get("description") or ""
+            created_raw = issue_fields.get("created") or ""
+            created = created_raw[:10] if created_raw else ""
+            updated = issue_fields.get("updated") or ""
+            duedate = issue_fields.get("duedate")
+
+            priority_info = issue_fields.get("priority") or {}
+            priority = priority_info.get("name") or "None"
+
+            status_info = issue_fields.get("status") or {}
+            status = status_info.get("name") or "Unknown"
+
+            project_info = issue_fields.get("project") or {}
+            project_id = project_info.get("id") or ""
+
+            issue_url = f"{self._client.url}browse/{key}" if key else self._client.url
+
+            assignee_info = issue_fields.get("assignee") or {}
+            assignee = assignee_info.get("displayName") or "None"
+
             rel_issues = {}
-            for related_issue in issue_fields["issuelinks"]:
-                if "inwardIssue" in related_issue.keys():
-                    rel_type = related_issue["type"]["inward"]
-                    rel_key = related_issue["inwardIssue"]["key"]
+            for related_issue in issue_fields.get("issuelinks") or []:
+                rel_type = None
+                rel_key = None
+                if related_issue.get("inwardIssue"):
+                    rel_type = related_issue.get("type", {}).get("inward")
+                    rel_key = related_issue["inwardIssue"].get("key")
                     # rel_summary = related_issue["inwardIssue"]["fields"]["summary"]
-                if "outwardIssue" in related_issue.keys():
-                    rel_type = related_issue["type"]["outward"]
-                    rel_key = related_issue["outwardIssue"]["key"]
+                elif related_issue.get("outwardIssue"):
+                    rel_type = related_issue.get("type", {}).get("outward")
+                    rel_key = related_issue["outwardIssue"].get("key")
                     # rel_summary = related_issue["outwardIssue"]["fields"]["summary"]
-                rel_issues = {"type": rel_type, "key": rel_key, "url": f"{self._client.url}browse/{rel_key}"}
+
+                if rel_type and rel_key:
+                    rel_issues = {
+                        "type": rel_type,
+                        "key": rel_key,
+                        "url": f"{self._client.url}browse/{rel_key}",
+                    }
 
             parsed_issue = {
                 "key": key,
-                "id": id,
+                "id": issue_id,
                 "projectId": project_id,
                 "summary": summary,
                 "description": description,
@@ -492,10 +522,13 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
                 "url": issue_url,
                 "related_issues": rel_issues,
             }
-            for field in self.additional_fields:
-                field_value = issue_fields.get(field, None)
+
+            for field in (self.additional_fields or []):
+                field_value = issue_fields.get(field)
                 parsed_issue[field] = field_value
+
             parsed.append(parsed_issue)
+
         return parsed
 
     @staticmethod
@@ -555,12 +588,14 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
         Use the appropriate issue link type (e.g., "Test", "Relates", "Blocks").
         If we use "Test" linktype, the test is inward issue, the story/other issue is outward issue.."""
 
+        comment = f"Issue {inward_issue_key} was linked to {outward_issue_key}."
+        comment_body = {"content": [{"content": [{"text": comment,"type": "text"}],"type": "paragraph"}],"type": "doc","version": 1} if self.api_version == "3" else comment
         link_data = {
             "type": {"name": f"{linktype}"},
             "inwardIssue": {"key": f"{inward_issue_key}"},
             "outwardIssue": {"key": f"{outward_issue_key}"},
             "comment": {
-                "body": "This test is linked to the story."
+                "body": comment_body
             }
         }
         self._client.create_issue_link(link_data)
@@ -698,6 +733,8 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
     def add_comments(self, issue_key: str, comment: str):
         """ Add a comment to a Jira issue."""
         try:
+            if self.api_version == '3':
+                comment = {"content": [{"content": [{"text": comment,"type": "text"}],"type": "paragraph"}],"type": "doc","version": 1}
             self._client.issue_add_comment(issue_key, comment)
             issue_url = f"{self._client.url}browse/{issue_key}"
             output = f"Done. Comment is added for issue {issue_key}. You can view it at {issue_url}"
@@ -721,22 +758,48 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             return parsed_projects_str
         except Exception:
             stacktrace = format_exc()
-            logger.error(f"Error creating Jira issue: {stacktrace}")
-            return ToolException(f"Error creating Jira issue: {stacktrace}")
-
-    def get_attachments_content(self, jira_issue_key: str):
-        """ Extract content of all attachments related to specified Jira issue key.
-         NOTE: only parsable attachments will be considered """
+            logger.error(f"Error listing Jira projects: {stacktrace}")
+            return ToolException(f"Error listing Jira projects: {stacktrace}")
+
+    def get_attachments_content(self, jira_issue_key: str, attachment_pattern: Optional[str] = None):
+        """ Extract the content of all attachments related to a specified Jira issue key.
+         NOTE: only parsable attachments will be considered
+         Args:
+            jira_issue_key: The key of the Jira issue, e.g. "TEST-123
+            attachment_pattern: Optional regex pattern to filter attachments by filename.
+            If provided, only attachments with filenames matching this pattern will be processed.
+         Returns:
+            A string containing the content of all relevant attachments, separated by double newlines.
+         """
 
         attachment_data = []
         attachments = self._client.get_attachments_ids_from_issue(issue=jira_issue_key)
+        api_version = str(getattr(self._client, "api_version", "2"))
         for attachment in attachments:
-            if self.api_version == "3":
-                attachment_data.append(self._client.get_attachment_content(attachment['attachment_id']))
-            else:
-                extracted_attachment = self._client.get_attachment(attachment_id=attachment['attachment_id'])
-                if extracted_attachment['mimeType'] in SUPPORTED_ATTACHMENT_MIME_TYPES:
-                    attachment_data.append(self._extract_attachment_content(extracted_attachment))
+            if attachment_pattern and not re.search(attachment_pattern, attachment['filename']):
+                logger.info(f"Skipping attachment {attachment['filename']} as it does not match pattern {attachment_pattern}")
+                continue
+            logger.info(f"Processing attachment {attachment['filename']} with ID {attachment['attachment_id']}")
+            try:
+                attachment_content = None
+
+                # Cloud (REST v3) attachments require signed URLs returned from metadata
+                if api_version in {"3", "latest"} or self.cloud:
+                    attachment_content = self._download_attachment_v3(
+                        attachment['attachment_id'],
+                        attachment['filename']
+                    )
+
+                if attachment_content is None:
+                    attachment_content = self._client.get_attachment_content(attachment['attachment_id'])
+            except Exception as e:
+                logger.error(
+                    f"Failed to download attachment {attachment['filename']} for issue {jira_issue_key}: {str(e)}")
+                attachment_content = self._client.get(
+                    path=f"secure/attachment/{attachment['attachment_id']}/{attachment['filename']}", not_json_response=True)
+            content_docs = process_content_by_type(attachment_content, attachment['filename'], llm=self.llm, fallback_extensions=[".txt", ".png"])
+            attachment_data.append("filename: " + attachment['filename'] + "\ncontent: " + str([doc.page_content for doc in content_docs]))
+
         return "\n\n".join(attachment_data)
 
     def execute_generic_rq(self, method: str, relative_url: str, params: Optional[str] = "", *args):
@@ -770,15 +833,6 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
         logger.debug(response_string)
         return response_string
 
-    def _extract_attachment_content(self, attachment):
-        """Extract attachment's content if possible (used for api v.2)"""
-
-        try:
-            content = self._client.get(attachment['content'].replace(self.base_url, ''))
-        except Exception as e:
-            content = f"Unable to parse content of '{attachment['filename']}' due to: {str(e)}"
-        return f"filename: {attachment['filename']}\ncontent: {content}"
-
     # Helper functions for image processing
     @staticmethod
     def _collect_context_for_image(content: str, image_marker: str, context_radius: int = 500) -> str:
@@ -1011,13 +1065,65 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             logger.error(f"Error downloading attachment: {str(e)}")
             return None
 
+    def _download_attachment_v3(self, attachment_id: str, filename: str | None = None) -> Optional[bytes]:
+        """Download Jira attachment using metadata content URL (required for REST v3 / Cloud)."""
+        try:
+            metadata = self._client.get_attachment(attachment_id)
+        except Exception as e:
+            logger.error(f"Failed to retrieve metadata for attachment {attachment_id}: {str(e)}")
+            return None
+
+        download_url = metadata.get('content') or metadata.get('_links', {}).get('content')
+
+        if not download_url:
+            logger.warning(
+                f"Attachment {attachment_id} ({filename}) metadata does not include a content URL; falling back.")
+            return None
+
+        logger.info(f"Downloading attachment {attachment_id} via metadata content URL (v3).")
+        content = self._download_attachment(download_url)
+
+        if content is None:
+            logger.error(
+                f"Failed to download attachment {attachment_id} ({filename}) from v3 content URL: {download_url}")
+
+        return content
+
     def _extract_image_data(self, field_data):
         """
-        Extracts image data from general JSON response
+        Extracts image data from general JSON response.
+        Handles lists, dicts with image info, and plain strings.
         """
-        if isinstance(field_data, dict) and 'filename' in field_data and 'content' in field_data:
-            return f"!{field_data['filename']}|alt={field_data['filename']}!"
-        return str(field_data)
+        if isinstance(field_data, list):
+            return ' '.join(self._extract_image_data(item) for item in field_data)
+        if isinstance(field_data, dict):
+            if 'filename' in field_data and 'content' in field_data:
+                return f"!{field_data['filename']}|alt={field_data['filename']}!"
+            if 'content' in field_data and isinstance(field_data['content'], list):
+                result = []
+                for content_item in field_data['content']:
+                    if (
+                        isinstance(content_item, dict)
+                        and 'content' in content_item
+                        and isinstance(content_item['content'], list)
+                        and content_item['content']
+                    ):
+                        if content_item.get('type') == 'mediaSingle':
+                            media = content_item['content'][0]
+                            attrs = media.get('attrs', {})
+                            if attrs.get('type') == 'file':
+                                alt = attrs.get('alt', '')
+                                image_str = f'!{alt}|alt="{alt}"!'
+                                result.append(image_str)
+                        elif content_item.get('type') == 'paragraph':
+                            result.append(content_item['content'][0].get('text', ''))
+                        else:
+                            result.append(self._extract_image_data(content_item))
+                return '\n'.join(result)
+            return f"Unsupported format of field content."
+        if isinstance(field_data, str):
+            return field_data
+        return f"Unsupported field content type: {type(field_data)}. Expected a string, list, or dict."
 
     def get_field_with_image_descriptions(self, jira_issue_key: str, field_name: str, prompt: Optional[str] = None,
                                           context_radius: int = 500):
@@ -1052,12 +1158,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
                 return f"Unable to find field '{field_name}' or it's empty. Available fields are: {existing_fields_str}"
 
             # Handle multiple images or non-string content
-            if isinstance(field_content, list):
-                field_content = ' '.join(map(self._extract_image_data, field_content))
-            elif isinstance(field_content, dict):
-                field_content = self._extract_image_data(field_content)
-            elif not isinstance(field_content, str):
-                return f"Unsupported field content type: {type(field_content)}. Expected a string, list, or dict."
+            field_content = self._extract_image_data(field_content)
 
             # Regular expression to find image references in Jira markup
             image_pattern = r'!([^!|]+)(?:\|[^!]*)?!'
@@ -1118,6 +1219,97 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             logger.error(f"Error processing field with images: {stacktrace}")
             return f"Error processing field with images: {str(e)}"
 
+    def process_image_match(self, match, body, attachment_resolver, context_radius=500, prompt=None):
+        """Process each image reference and get its contextual description"""
+        image_ref = match.group(1)
+        full_match = match.group(0)  # The complete image reference with markers
+
+        logger.info(f"Processing image reference: {image_ref} (full match: {full_match})")
+
+        try:
+            # Use the AttachmentResolver to find the attachment
+            attachment = attachment_resolver.find_attachment(image_ref)
+
+            if not attachment:
+                logger.warning(f"Could not find attachment for reference: {image_ref}")
+                if image_ref.startswith("http://") or image_ref.startswith("https://"):
+                    content_url = image_ref
+                    image_name = image_ref.split("/")[-1]  # Extract the name from the URL
+                    response = requests.get(content_url, timeout=10)
+                    response.raise_for_status()
+                    image_data = response.content
+                else:
+                    logger.error(f"Invalid image reference: {image_ref}")
+                    return f"[Image: {image_ref} - attachment not found]"
+            else:
+                # Get the content URL and download the image
+                content_url = attachment.get('content')
+                if not content_url:
+                    logger.error(f"No content URL found in attachment: {attachment}")
+                    return f"[Image: {image_ref} - no content URL]"
+
+                image_name = attachment.get('filename', image_ref)
+
+                # Download the image data
+                logger.info(f"Downloading image from URL: {content_url}")
+                image_data = self._download_attachment(content_url)
+
+                if not image_data:
+                    logger.error(f"Failed to download image from URL: {content_url}")
+                    return f"[Image: {image_ref} - download failed]"
+
+            # Collect surrounding content
+            context_text = self._collect_context_for_image(body, full_match, context_radius)
+
+            # Process with LLM (will use cache if available)
+            description = self._process_image_with_llm(image_data, image_name, context_text, prompt)
+            return f"[Image {image_name} Description: {description}]"
+
+        except Exception as e:
+            logger.error(f"Error retrieving attachment {image_ref}: {str(e)}")
+            return f"[Image: {image_ref} - Error: {str(e)}]"
+
+    def get_processed_comments_list_with_image_description(self, jira_issue_key: str, prompt: Optional[str] = None, context_radius: int = 500):
+        # Retrieve all comments for the issue
+        comments = self._client.issue_get_comments(jira_issue_key)
+
+        if not comments or not comments.get('comments'):
+             return []
+
+        processed_comments = []
+
+        # Create an AttachmentResolver to efficiently handle attachment lookups
+        attachment_resolver = AttachmentResolver(self._client, jira_issue_key)
+
+        # Regular expression to find image references in Jira markup
+        image_pattern = r'!([^!|]+)(?:\|[^!]*)?!'
+
+        # Process each comment
+        for comment in comments['comments']:
+            comment_body = comment.get('body', '')
+            if not comment_body:
+                continue
+
+            comment_author = comment.get('author', {}).get('displayName', 'Unknown')
+            comment_created = comment.get('created', 'Unknown date')
+            comment_body = self._extract_image_data(comment_body)
+
+            # Process the comment body by replacing image references with descriptions
+            processed_body = re.sub(image_pattern,
+                                    lambda match: self.process_image_match(match, comment_body, attachment_resolver, context_radius, prompt),
+                                    comment_body)
+
+            # Add the processed comment to our results
+            processed_comments.append({
+                "author": comment_author,
+                "created": comment_created,
+                "id": comment.get('id'),
+                "original_content": comment_body,
+                "processed_content": processed_body
+            })
+        
+        return processed_comments
+
     def get_comments_with_image_descriptions(self, jira_issue_key: str, prompt: Optional[str] = None, context_radius: int = 500):
         """
         Get all comments from Jira issue and augment any images in them with textual descriptions.
@@ -1137,84 +1329,11 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             The comments with image references replaced with contextual descriptions
         """
         try:
-            # Retrieve all comments for the issue
-            comments = self._client.issue_get_comments(jira_issue_key)
-
-            if not comments or not comments.get('comments'):
+            processed_comments = self.get_processed_comments_list_with_image_description(jira_issue_key=jira_issue_key,
+                                                                                         prompt=prompt,
+                                                                                         context_radius=context_radius)
+            if not processed_comments:
                 return f"No comments found for issue '{jira_issue_key}'"
-
-            processed_comments = []
-
-            # Create an AttachmentResolver to efficiently handle attachment lookups
-            attachment_resolver = AttachmentResolver(self._client, jira_issue_key)
-
-            # Regular expression to find image references in Jira markup
-            image_pattern = r'!([^!|]+)(?:\|[^!]*)?!'
-
-            # Process each comment
-            for comment in comments['comments']:
-                comment_body = comment.get('body', '')
-                if not comment_body:
-                    continue
-
-                comment_author = comment.get('author', {}).get('displayName', 'Unknown')
-                comment_created = comment.get('created', 'Unknown date')
-
-                # Function to process images in comment text
-                def process_image_match(match):
-                    """Process each image reference and get its contextual description"""
-                    image_ref = match.group(1)
-                    full_match = match.group(0)  # The complete image reference with markers
-
-                    logger.info(f"Processing image reference: {image_ref} (full match: {full_match})")
-
-                    try:
-                        # Use the AttachmentResolver to find the attachment
-                        attachment = attachment_resolver.find_attachment(image_ref)
-
-                        if not attachment:
-                            logger.warning(f"Could not find attachment for reference: {image_ref}")
-                            return f"[Image: {image_ref} - attachment not found]"
-
-                        # Get the content URL and download the image
-                        content_url = attachment.get('content')
-                        if not content_url:
-                            logger.error(f"No content URL found in attachment: {attachment}")
-                            return f"[Image: {image_ref} - no content URL]"
-
-                        image_name = attachment.get('filename', image_ref)
-
-                        # Collect surrounding content
-                        context_text = self._collect_context_for_image(comment_body, full_match, context_radius)
-
-                        # Download the image data
-                        logger.info(f"Downloading image from URL: {content_url}")
-                        image_data = self._download_attachment(content_url)
-
-                        if not image_data:
-                            logger.error(f"Failed to download image from URL: {content_url}")
-                            return f"[Image: {image_ref} - download failed]"
-
-                        # Process with LLM (will use cache if available)
-                        description = self._process_image_with_llm(image_data, image_name, context_text, prompt)
-                        return f"[Image {image_name} Description: {description}]"
-
-                    except Exception as e:
-                        logger.error(f"Error retrieving attachment {image_ref}: {str(e)}")
-                        return f"[Image: {image_ref} - Error: {str(e)}]"
-
-                # Process the comment body by replacing image references with descriptions
-                processed_body = re.sub(image_pattern, process_image_match, comment_body)
-
-                # Add the processed comment to our results
-                processed_comments.append({
-                    "author": comment_author,
-                    "created": comment_created,
-                    "id": comment.get('id'),
-                    "original_content": comment_body,
-                    "processed_content": processed_body
-                })
-
             # Format the output
             result = f"Comments from issue '{jira_issue_key}' with image descriptions:\n\n"
             for idx, comment in enumerate(processed_comments, 1):
@@ -1243,6 +1362,8 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
         self._skipped_attachment_extensions = kwargs.get('skip_attachment_extensions', [])
         self._include_attachments = kwargs.get('include_attachments', False)
         self._included_fields = fields_to_extract.copy() if fields_to_extract else []
+        self._include_comments = kwargs.get('include_comments', True)
+        self._chunking_tool = kwargs.get('chunking_tool', None)
 
         try:
             # Prepare fields to extract
@@ -1257,7 +1378,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
 
             # Use provided JQL query or default to all issues
             if not jql:
-                jql_query = "ORDER BY updated DESC"  # Default to get all issues ordered by update time
+                jql_query = "created >= \"1970-01-01\" ORDER BY updated DESC"  # Default to get all issues ordered by update time
             else:
                 jql_query = jql
 
@@ -1285,6 +1406,19 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             logger.error(f"Error loading Jira issues: {str(e)}")
             raise ToolException(f"Unable to load Jira issues: {str(e)}")
 
+    def _extend_data(self, documents: Generator[Document, None, None]):
+        image_pattern = r'!([^!|]+)(?:\|[^!]*)?!'
+        for doc in documents:
+            attachment_resolver = AttachmentResolver(self._client, doc.metadata['issue_key'])
+            processed_content = re.sub(image_pattern,
+                                    lambda match: self.process_image_match(match,
+                                                                           doc.page_content,
+                                                                           attachment_resolver),
+                                    doc.page_content)
+            doc.metadata[IndexerKeywords.CONTENT_IN_BYTES.value] = processed_content.encode('utf-8')
+            doc.metadata[IndexerKeywords.CONTENT_FILE_NAME.value] = f"base_doc{file_extension_by_chunker(self._chunking_tool)}"
+            yield doc
+
     def _process_document(self, base_document: Document) -> Generator[Document, None, None]:
         """
         Process a base document to extract and index Jira issues extra fields: comments, attachments, etc..
@@ -1306,21 +1440,36 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
                     except Exception as e:
                         logger.error(f"Failed to download attachment {attachment['filename']} for issue {issue_key}: {str(e)}")
                         attachment_content = self._client.get(path=f"secure/attachment/{attachment['id']}/{attachment['filename']}", not_json_response=True)
-                    content = load_content_from_bytes(attachment_content, ext, llm=self.llm) if ext not in '.pdf' \
-                        else parse_file_content(file_content=attachment_content, file_name=attachment['filename'], llm=self.llm, is_capture_image=True)
-                    if not content:
-                        continue
-                    yield Document(page_content=content,
+
+                    yield Document(page_content='',
+                                   metadata={
+                                           IndexerKeywords.CONTENT_IN_BYTES.value: attachment_content,
+                                           IndexerKeywords.CONTENT_FILE_NAME.value: attachment['filename'],
+                                           'id': attachment_id,
+                                           'issue_key': issue_key,
+                                           'source': f"{self.base_url}/browse/{issue_key}",
+                                           'filename': attachment['filename'],
+                                           'created': attachment['created'],
+                                           'mimeType': attachment['mimeType'],
+                                           'author': attachment.get('author', {}).get('name'),
+                                           IndexerKeywords.PARENT.value: base_document.metadata.get('id', None),
+                                           'type': 'attachment',
+                                       })
+        if self._include_comments:
+            comments = self.get_processed_comments_list_with_image_description(issue_key)
+            if comments:
+                for comment in comments:
+                    yield Document(page_content='',
                                    metadata={
-                                       'id': attachment_id,
+                                       IndexerKeywords.CONTENT_IN_BYTES.value: comment.get('processed_content').encode('utf-8'),
+                                       IndexerKeywords.CONTENT_FILE_NAME.value: "comment.md",
+                                       'id': comment.get('id'),
                                        'issue_key': issue_key,
                                        'source': f"{self.base_url}/browse/{issue_key}",
-                                       'filename': attachment['filename'],
-                                       'created': attachment['created'],
-                                       'mimeType': attachment['mimeType'],
-                                       'author': attachment.get('author', {}).get('name'),
+                                       'created': comment.get('created'),
+                                       'author': comment.get('author'),
                                        IndexerKeywords.PARENT.value: base_document.metadata.get('id', None),
-                                       'type': 'attachment',
+                                       'type': 'comment',
                                    })
 
     def _jql_get_tickets(self, jql, fields="*all", start=0, limit=None, expand=None, validate_query=None):
@@ -1343,7 +1492,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
         if validate_query is not None:
             params["validateQuery"] = validate_query
 
-        url = self._client.resource_url("search")
+        url = self._client.resource_url("search/jql" if self.api_version == '3' else "search")
 
         while True:
             params["startAt"] = int(start)
@@ -1361,6 +1510,8 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
                 break
             if not response["issues"]:
                 break
+            if len(issues) < limit:
+                break
             start += len(issues)
 
     def _process_issue_for_indexing(self, issue: dict, fields_to_index=None) -> Document:
@@ -1370,21 +1521,16 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
         """
         try:
             # Build content starting with summary
-            content = f"{issue['fields']['summary']}\n"
+            content = f"# Summary\n{issue['fields']['summary']}\n\n"
 
             # Add description if present
             description = issue['fields'].get('description', '')
             if description:
-                content += f"{description}\n"
+                content += f"# Description\n{description}\n\n"
             else:
                 # If no description, still create document but with minimal content
                 logger.debug(f"Issue {issue.get('key', 'unknown')} has no description")
 
-            # Add comments if present
-            if 'comment' in issue['fields'] and issue['fields']['comment'].get('comments'):
-                for comment in issue['fields']['comment']['comments']:
-                    content += f"{comment['body']}\n"
-
             # Add additional fields to index
             if fields_to_index:
                 for field in fields_to_index:
@@ -1395,7 +1541,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
                             field_value = str(field_value)
                         elif isinstance(field_value, list):
                             field_value = ', '.join(str(item) for item in field_value)
-                        content += f"{field_value}\n"
+                        content += f"# {field}\n{field_value}\n\n"
 
             # Create metadata
             metadata = {
@@ -1433,6 +1579,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             'skip_attachment_extensions': (Optional[List[str]], Field(
                 description="List of file extensions to skip when processing attachments: i.e. ['.png', '.jpg']",
                 default=[])),
+            'chunking_tool': (Literal['markdown', ''], Field(description="Name of chunking tool for base document", default='markdown')),
         }
 
     # def index_data(self,
@@ -1505,7 +1652,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
     #         logger.error(f"Error indexing Jira issues: {str(e)}")
     #         raise ToolException(f"Error indexing Jira issues: {str(e)}")
 
-    @extend_with_vector_tools
+    @extend_with_parent_available_tools
     def get_available_tools(self):
         return [
             {
@@ -1589,7 +1736,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             {
                 "name": "get_attachments_content",
                 "description": self.get_attachments_content.__doc__,
-                "args_schema": GetRemoteLinks,
+                "args_schema": GetIssueAttachments,
                 "ref": self.get_attachments_content,
             },
             {