alita-sdk 0.3.271__py3-none-any.whl → 0.3.273__py3-none-any.whl

alita_sdk/tools/carrier/__init__.py

@@ -1,12 +1,13 @@
 import logging
 from typing import Dict, List, Optional, Literal
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 from functools import lru_cache
 
 from .api_wrapper import CarrierAPIWrapper
 from .tools import __all__
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.carrier import CarrierConfiguration
 
 logger = logging.getLogger(__name__)
 
@@ -27,12 +28,8 @@ class AlitaCarrierToolkit(BaseToolkit):
         cls.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            url=(str, Field(description="Carrier Platform Base URL")),
-            organization=(str, Field(description="Carrier Organization Name", json_schema_extra={'toolkit_name': True,
-                                                                                                 'max_toolkit_length': cls.toolkit_max_length})),
-            private_token=(
-                SecretStr, Field(description="Carrier Platform Authentication Token", json_schema_extra={'secret': True})),
             project_id=(Optional[str], Field(None, description="Optional project ID for scoped operations")),
+            carrier_configuration=(CarrierConfiguration, Field(description="Carrier Configuration", json_schema_extra={'configuration_types': ['carrier']})),
             selected_tools=(
                 List[Literal[tuple(selected_tools)]],
                 Field(default=[], json_schema_extra={"args_schemas": selected_tools}),
@@ -58,10 +55,15 @@ class AlitaCarrierToolkit(BaseToolkit):
         selected_tools = selected_tools or []
         logger.info(f"[AlitaCarrierToolkit] Initializing toolkit with selected tools: {selected_tools}")
 
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('carrier_configuration', {}),
+        }
+
         try:
-            carrier_api_wrapper = CarrierAPIWrapper(**kwargs)
+            carrier_api_wrapper = CarrierAPIWrapper(**wrapper_payload)
             logger.info(
-                f"[AlitaCarrierToolkit] CarrierAPIWrapper initialized successfully with URL: {kwargs.get('url')}")
+                f"[AlitaCarrierToolkit] CarrierAPIWrapper initialized successfully with URL: {wrapper_payload.get('url')}")
         except Exception as e:
             logger.exception(f"[AlitaCarrierToolkit] Error initializing CarrierAPIWrapper: {e}")
             raise ValueError(f"CarrierAPIWrapper initialization error: {e}")
@@ -92,9 +94,7 @@ class AlitaCarrierToolkit(BaseToolkit):
 def get_tools(tool_config: Dict) -> List[BaseTool]:
     return AlitaCarrierToolkit.get_toolkit(
         selected_tools=tool_config.get('selected_tools', []),
-        url=tool_config['settings']['url'],
         project_id=tool_config['settings'].get('project_id'),
-        organization=tool_config['settings']['organization'],
-        private_token=tool_config['settings']['private_token'],
+        carrier_configuration=tool_config['settings']['carrier_configuration'],
         toolkit_name=tool_config.get('toolkit_name')
     ).get_tools()

alita_sdk/tools/code/sonar/__init__.py

@@ -1,19 +1,19 @@
 from typing import List, Literal, Optional
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import SonarApiWrapper
 from ...base.tool import BaseAction
 from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ....configurations.sonar import SonarConfiguration
 
 name = "sonar"
 
 def get_tools(tool):
     return SonarToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        url=tool['settings']['url'],
-        sonar_token=tool['settings']['sonar_token'],
         sonar_project_name=tool['settings']['sonar_project_name'],
+        sonar_configuration=tool['settings']['sonar_configuration'],
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
@@ -28,9 +28,8 @@ class SonarToolkit(BaseToolkit):
         SonarToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            url=(str, Field(description="SonarQube Server URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': SonarToolkit.toolkit_max_length})),
-            sonar_token=(SecretStr, Field(description="SonarQube user token for authentication", json_schema_extra={'secret': True})),
-            sonar_project_name=(str, Field(description="Project name of the desired repository")),
+            sonar_project_name=(str, Field(description="Project name of the desired repository", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': SonarToolkit.toolkit_max_length})),
+            sonar_configuration=(SonarConfiguration, Field(description="Sonar Configuration", json_schema_extra={'configuration_types': ['sonar']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra=
                                   {
@@ -47,7 +46,11 @@ class SonarToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        sonar_api_wrapper = SonarApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('sonar_configuration', {}),
+        }
+        sonar_api_wrapper = SonarApiWrapper(**wrapper_payload)
         available_tools = sonar_api_wrapper.get_available_tools()
         tools = []
         prefix = clean_string(toolkit_name, SonarToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''

alita_sdk/tools/confluence/__init__.py

@@ -81,7 +81,7 @@ class ConfluenceToolkit(BaseToolkit):
             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']})),
+            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']})),

alita_sdk/tools/elitea_base.py

@@ -90,22 +90,23 @@ BaseStepbackSearchParams = create_model(
     )),
     cut_off=(Optional[float], Field(description="Cut-off score for search results", default=0.5, ge=0, le=1)),
     search_top=(Optional[int], Field(description="Number of top results to return", default=10, ge=0)),
-    reranker=(Optional[dict], Field(
-        description="Reranker configuration. Can be a dictionary with reranking parameters.",
-        default={}
-    )),
     full_text_search=(Optional[Dict[str, Any]], Field(
         description="Full text search parameters. Can be a dictionary with search options.",
         default=None
     )),
-    reranking_config=(Optional[Dict[str, Dict[str, Any]]], Field(
-        description="Reranking configuration. Can be a dictionary with reranking settings.",
-        default=None
-    )),
     extended_search=(Optional[List[str]], Field(
         description="List of additional fields to include in the search results.",
         default=None
     )),
+    reranker=(Optional[dict], Field(
+        description="Reranker configuration. Can be a dictionary with reranking parameters.",
+        default={}
+    )),
+    reranking_config=(Optional[Dict[str, Dict[str, Any]]], Field(
+        description="Reranking configuration. Can be a dictionary with reranking settings.",
+        default=None
+    )),
+
 )
 
 BaseIndexDataParams = create_model(

alita_sdk/tools/figma/__init__.py

@@ -53,7 +53,7 @@ class FigmaToolkit(BaseToolkit):
                 Field(default=[], json_schema_extra={"args_schemas": selected_tools}),
             ),
             # Figma configuration
-            figma_configuration=(Optional[FigmaConfiguration], Field(description="Figma configuration", json_schema_extra={'configuration_types': ['figma']})),
+            figma_configuration=(FigmaConfiguration, Field(description="Figma configuration", json_schema_extra={'configuration_types': ['figma']})),
 
             # indexer settings
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),

alita_sdk/tools/github/__init__.py

@@ -57,8 +57,8 @@ class AlitaGitHubToolkit(BaseToolkit):
                     },
                 }
             ),
-            github_configuration=(Optional[GithubConfiguration], Field(description="Github configuration", default=None,
-                                                                     json_schema_extra={'configuration_types': ['github']})),
+            github_configuration=(GithubConfiguration, Field(description="Github configuration",
+                                                             json_schema_extra={'configuration_types': ['github']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector configuration", default=None,
                                                                      json_schema_extra={'configuration_types': ['pgvector']})),
             repository=(str, Field(description="Github repository", json_schema_extra={'toolkit_name': True,

alita_sdk/tools/gitlab_org/__init__.py

@@ -30,7 +30,7 @@ class AlitaGitlabSpaceToolkit(BaseToolkit):
             name,
             name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True,
                                                                             'max_toolkit_length': AlitaGitlabSpaceToolkit.toolkit_max_length})),
-            gitlab_configuration=(Optional[GitlabConfiguration], Field(description="GitLab configuration",
+            gitlab_configuration=(GitlabConfiguration, Field(description="GitLab configuration",
                                                                        json_schema_extra={
                                                                            'configuration_types': ['gitlab']})),
             repositories=(str, Field(

alita_sdk/tools/google/bigquery/__init__.py

@@ -46,7 +46,7 @@ class BigQueryToolkitConfig(BaseModel):
             }
         }
 
-    bigquery_configuration: Optional[BigQueryConfiguration] = Field(
+    bigquery_configuration: BigQueryConfiguration = Field(
         description="BigQuery configuration", json_schema_extra={"configuration_types": ["bigquery"]}
     )
     selected_tools: List[str] = Field(

alita_sdk/tools/google_places/__init__.py

@@ -1,19 +1,20 @@
 from typing import List, Literal, Optional
 from langchain_core.tools import BaseToolkit, BaseTool
-from pydantic import create_model, BaseModel, ConfigDict, SecretStr
+from pydantic import create_model, BaseModel, ConfigDict
 from pydantic.fields import Field
 
 from .api_wrapper import GooglePlacesAPIWrapper
 from ..base.tool import BaseAction
 from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ...configurations.google_places import GooglePlacesConfiguration
 
 name = "google_places"
 
 def get_tools(tool):
     return GooglePlacesToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        api_key=tool['settings']['api_key'],
         results_count=tool['settings'].get('results_count'),
+        google_places_configuration=tool['settings']['google_places_configuration'],
         toolkit_name=tool.get('toolkit_name')
     ).get_tools()
 
@@ -28,8 +29,8 @@ class GooglePlacesToolkit(BaseToolkit):
         GooglePlacesToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            api_key=(SecretStr, Field(description="Google Places API key", json_schema_extra={'secret': True, 'max_toolkit_length': GooglePlacesToolkit.toolkit_max_length})),
-            results_count=(Optional[int], Field(description="Results number to show", default=None)),
+            results_count=(Optional[int], Field(description="Results number to show", default=None, json_schema_extra={'toolkit_name': True, 'max_toolkit_length': GooglePlacesToolkit.toolkit_max_length})),
+            google_places_configuration=(GooglePlacesConfiguration, Field(description="Google Places Configuration", json_schema_extra={'configuration_types': ['google_places']})),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra=
                                   {
@@ -47,7 +48,11 @@ class GooglePlacesToolkit(BaseToolkit):
     def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
-        google_places_api_wrapper = GooglePlacesAPIWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            **kwargs.get('google_places_configuration', {}),
+        }
+        google_places_api_wrapper = GooglePlacesAPIWrapper(**wrapper_payload)
         prefix = clean_string(toolkit_name, GooglePlacesToolkit.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = google_places_api_wrapper.get_available_tools()
         tools = []

alita_sdk/tools/jira/__init__.py

@@ -75,7 +75,7 @@ class JiraToolkit(BaseToolkit):
             custom_headers=(Optional[dict], Field(description="Custom headers for API requests", default=None)),
             verify_ssl=(bool, Field(description="Verify SSL", default=True)),
             additional_fields=(Optional[str], Field(description="Additional fields", default="")),
-            jira_configuration=(Optional[JiraConfiguration], Field(description="Jira Configuration", json_schema_extra={'configuration_types': ['jira']})),
+            jira_configuration=(JiraConfiguration, Field(description="Jira Configuration", json_schema_extra={'configuration_types': ['jira']})),
             pgvector_configuration=(Optional[PgVectorConfiguration], Field(default=None,
                                                                            description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings

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
@@ -15,8 +15,9 @@ 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.content_parser import load_file_docs
 from ...runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
@@ -391,7 +392,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,
@@ -442,7 +443,7 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             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 = []
@@ -721,8 +722,8 @@ 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}")
+            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):
         """ Extract content of all attachments related to specified Jira issue key.
@@ -1118,103 +1119,119 @@ class JiraApiWrapper(BaseVectorStoreToolApiWrapper):
             logger.error(f"Error processing field with images: {stacktrace}")
             return f"Error processing field with images: {str(e)}"
 
-    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.
-
-        This method will:
-        1. Extract all comments from the specified Jira issue
-        2. Detect images in each comment
-        3. Retrieve and process each image with an LLM, providing surrounding context
-        4. Replace image references with the generated text descriptions
+    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
 
-        Args:
-            jira_issue_key: The Jira issue key to retrieve comments from (e.g., 'TEST-1234')
-            prompt: Custom prompt for the LLM when analyzing images. If None, a default prompt will be used.
-            context_radius: Number of characters to include before and after each image for context. Default is 500.
+        logger.info(f"Processing image reference: {image_ref} (full match: {full_match})")
 
-        Returns:
-            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'):
-                return f"No comments found for issue '{jira_issue_key}'"
+            # 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]"
 
-            processed_comments = []
+                image_name = attachment.get('filename', image_ref)
 
-            # Create an AttachmentResolver to efficiently handle attachment lookups
-            attachment_resolver = AttachmentResolver(self._client, jira_issue_key)
+                # Download the image data
+                logger.info(f"Downloading image from URL: {content_url}")
+                image_data = self._download_attachment(content_url)
 
-            # Regular expression to find image references in Jira markup
-            image_pattern = r'!([^!|]+)(?:\|[^!]*)?!'
+                if not image_data:
+                    logger.error(f"Failed to download image from URL: {content_url}")
+                    return f"[Image: {image_ref} - download failed]"
 
-            # Process each comment
-            for comment in comments['comments']:
-                comment_body = comment.get('body', '')
-                if not comment_body:
-                    continue
+            # Collect surrounding content
+            context_text = self._collect_context_for_image(body, full_match, context_radius)
 
-                comment_author = comment.get('author', {}).get('displayName', 'Unknown')
-                comment_created = comment.get('created', 'Unknown date')
+            # 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}]"
 
-                # 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
+        except Exception as e:
+            logger.error(f"Error retrieving attachment {image_ref}: {str(e)}")
+            return f"[Image: {image_ref} - Error: {str(e)}]"
 
-                    logger.info(f"Processing image reference: {image_ref} (full match: {full_match})")
+    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)
 
-                    try:
-                        # Use the AttachmentResolver to find the attachment
-                        attachment = attachment_resolver.find_attachment(image_ref)
+        if not comments or not comments.get('comments'):
+             return []
 
-                        if not attachment:
-                            logger.warning(f"Could not find attachment for reference: {image_ref}")
-                            return f"[Image: {image_ref} - attachment not found]"
+        processed_comments = []
 
-                        # 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]"
+        # Create an AttachmentResolver to efficiently handle attachment lookups
+        attachment_resolver = AttachmentResolver(self._client, jira_issue_key)
 
-                        image_name = attachment.get('filename', image_ref)
+        # Regular expression to find image references in Jira markup
+        image_pattern = r'!([^!|]+)(?:\|[^!]*)?!'
 
-                        # Collect surrounding content
-                        context_text = self._collect_context_for_image(comment_body, full_match, context_radius)
+        # Process each comment
+        for comment in comments['comments']:
+            comment_body = comment.get('body', '')
+            if not comment_body:
+                continue
 
-                        # Download the image data
-                        logger.info(f"Downloading image from URL: {content_url}")
-                        image_data = self._download_attachment(content_url)
+            comment_author = comment.get('author', {}).get('displayName', 'Unknown')
+            comment_created = comment.get('created', 'Unknown date')
 
-                        if not image_data:
-                            logger.error(f"Failed to download image from URL: {content_url}")
-                            return f"[Image: {image_ref} - download failed]"
+            # 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)
 
-                        # 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}]"
+            # 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
 
-                    except Exception as e:
-                        logger.error(f"Error retrieving attachment {image_ref}: {str(e)}")
-                        return f"[Image: {image_ref} - Error: {str(e)}]"
+    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.
 
-                # Process the comment body by replacing image references with descriptions
-                processed_body = re.sub(image_pattern, process_image_match, comment_body)
+        This method will:
+        1. Extract all comments from the specified Jira issue
+        2. Detect images in each comment
+        3. Retrieve and process each image with an LLM, providing surrounding context
+        4. Replace image references with the generated text descriptions
 
-                # 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
-                })
+        Args:
+            jira_issue_key: The Jira issue key to retrieve comments from (e.g., 'TEST-1234')
+            prompt: Custom prompt for the LLM when analyzing images. If None, a default prompt will be used.
+            context_radius: Number of characters to include before and after each image for context. Default is 500.
 
+        Returns:
+            The comments with image references replaced with contextual descriptions
+        """
+        try:
+            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}'"
             # 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 +1260,7 @@ 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)
 
         try:
             # Prepare fields to extract
@@ -1285,6 +1303,18 @@ 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.page_content = processed_content
+            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 +1336,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:
+                    content_docs = load_file_docs(file_content=attachment_content, file_name=attachment['filename'], llm=self.llm, is_capture_image=True, excel_by_sheets=True)
+                    if not content_docs or isinstance(content_docs, ToolException):
                         continue
-                    yield Document(page_content=content,
+                    for doc in content_docs:
+                        yield Document(page_content=doc.page_content,
+                                       metadata={
+                                           **doc.metadata,
+                                           '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=comment.get('processed_content'),
                                    metadata={
-                                       'id': attachment_id,
+                                       '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):
@@ -1370,21 +1415,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 +1435,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 +1473,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,

alita_sdk/tools/qtest/__init__.py

@@ -33,7 +33,7 @@ class QtestToolkit(BaseToolkit):
         QtestToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            qtest_configuration=(Optional[QtestConfiguration], Field(description="QTest API token", json_schema_extra={
+            qtest_configuration=(QtestConfiguration, Field(description="QTest API token", json_schema_extra={
                 'configuration_types': ['qtest']})),
             qtest_project_id=(int, Field(default=None, description="QTest project id", json_schema_extra={'toolkit_name': True,
                                                                                             'max_toolkit_length': QtestToolkit.toolkit_max_length})),

alita_sdk/tools/rally/__init__.py

@@ -30,7 +30,7 @@ class RallyToolkit(BaseToolkit):
             name,
             name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True,
                                                                             'max_toolkit_length': RallyToolkit.toolkit_max_length})),
-            rally_configuration=(Optional[RallyConfiguration], Field(description="Rally configuration", json_schema_extra={'configuration_types': ['rally']})),
+            rally_configuration=(RallyConfiguration, Field(description="Rally configuration", json_schema_extra={'configuration_types': ['rally']})),
             workspace=(Optional[str], Field(default=None, description="Rally workspace")),
             project=(Optional[str], Field(default=None, description="Rally project")),
             selected_tools=(List[Literal[tuple(selected_tools)]], Field(default=[], json_schema_extra={'args_schemas': selected_tools})),