alita-sdk 0.3.374__py3-none-any.whl → 0.3.423__py3-none-any.whl

alita_sdk/tools/qtest/api_wrapper.py

@@ -9,7 +9,7 @@ import swagger_client
 from langchain_core.tools import ToolException
 from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
 from sklearn.feature_extraction.text import strip_tags
-from swagger_client import TestCaseApi, SearchApi, PropertyResource, ModuleApi
+from swagger_client import TestCaseApi, SearchApi, PropertyResource, ModuleApi, ProjectApi, FieldApi
 from swagger_client.rest import ApiException
 
 from ..elitea_base import BaseToolApiWrapper
@@ -26,21 +26,25 @@ If generated data was used, put appropriate note to the test case description fi
 ### CRITERIA
 1. The structure should be as in EXAMPLE.
 2. Case and spaces for field names should be exactly the same as in NOTES.
-3. Extra fields are allowed.
+3. Extra fields are allowed and will be mapped to project's custom fields if they exist.
 4. "{QTEST_ID}" is required to update, change or replace values in test case.
 5. Do not provide "Id" and "{QTEST_ID}" to create test case.
-6  "Steps" is a list of test step objects with fields "Test Step Number", "Test Step Description", "Test Step Expected Result".
+6. "Steps" is a list of test step objects with fields "Test Step Number", "Test Step Description", "Test Step Expected Result".
+7. For updates, provide ONLY the fields you want to change. Omitted fields will remain unchanged.
 
 ### NOTES
-Id: Unique identifier (e.g., TC-123).
-QTest id: Unique identifier (e.g., 4626964).
-Name: Brief title.
-Description: Short purpose.
-Type: 'Manual' or 'Automation - UTAF'. Leave blank if unknown.
-Status: Default 'New'.
-Priority: Leave blank.
-Test Type: Default 'Functional'.
-Precondition: List prerequisites in one cell, formatted as: <Step1> <Step2> Leave blank if none..
+Id: Unique identifier (e.g., TC-123). Read-only.
+QTest id: Unique identifier (e.g., 4626964). Required for updates.
+Name: Brief title of the test case.
+Description: Short description of the test purpose.
+Type: Type of test (e.g., 'Manual', 'Automation - UTAF').
+Status: Current status (e.g., 'New', 'In Progress', 'Completed').
+Priority: Priority level (e.g., 'High', 'Medium', 'Low').
+Test Type: Category of test (e.g., 'Functional', 'Regression', 'Smoke').
+Precondition: Prerequisites for the test, formatted as: <Step1> <Step2> Leave blank if none.
+Steps: Array of test steps with Description and Expected Result.
+
+**For Updates**: Include only the fields you want to modify. The system will validate property values against project configuration.
 
 ### EXAMPLE
 {{
@@ -118,6 +122,17 @@ GetModules = create_model(
 
 )
 
+GetAllTestCasesFieldsForProject = create_model(
+    "GetAllTestCasesFieldsForProject",
+    force_refresh=(Optional[bool],
+                   Field(description="Set to true to reload field definitions from API if project configuration has changed (new fields added, dropdown values modified). Default: false (uses cached data).",
+                         default=False)),
+)
+
+NoInput = create_model(
+    "NoInput"
+)
+
 class QtestApiWrapper(BaseToolApiWrapper):
     base_url: str
     qtest_project_id: int
@@ -126,6 +141,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
     page: int = 1
     no_of_tests_shown_in_dql_search: int = 10
     _client: Any = PrivateAttr()
+    _field_definitions_cache: Optional[dict] = PrivateAttr(default=None)
     llm: Any
 
     @model_validator(mode='before')
@@ -135,9 +151,8 @@ class QtestApiWrapper(BaseToolApiWrapper):
             values['qtest_project_id'] = values.pop('project_id')
         return values
 
-    @model_validator(mode='before')
-    @classmethod
-    def validate_toolkit(cls, values):
+    @model_validator(mode='after')
+    def validate_toolkit(self):
         try:
             import swagger_client  # noqa: F401
         except ImportError:
@@ -146,15 +161,13 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 "`pip install git+https://github.com/Roman-Mitusov/qtest-api.git`"
             )
 
-        url = values['base_url']
-        api_token = values.get('qtest_api_token')
-        if api_token:
+        if self.qtest_api_token:
             configuration = swagger_client.Configuration()
-            configuration.host = url
-            configuration.api_key['Authorization'] = api_token
+            configuration.host = self.base_url
+            configuration.api_key['Authorization'] = self.qtest_api_token.get_secret_value()
             configuration.api_key_prefix['Authorization'] = 'Bearer'
-            cls._client = swagger_client.ApiClient(configuration)
-        return values
+            self._client = swagger_client.ApiClient(configuration)
+        return self
 
     def __instantiate_test_api_instance(self) -> TestCaseApi:
         # Instantiate the TestCaseApi instance according to the qtest api documentation and swagger client
@@ -163,33 +176,177 @@ class QtestApiWrapper(BaseToolApiWrapper):
     def __instantiate_module_api_instance(self) -> ModuleApi:
         return swagger_client.ModuleApi(self._client)
 
+    def __instantiate_fields_api_instance(self) -> FieldApi:
+        return swagger_client.FieldApi(self._client)
+
+    def __get_field_definitions_cached(self) -> dict:
+        """Get field definitions with session-level caching.
+        
+        Field definitions are cached for the lifetime of this wrapper instance.
+        If project field configuration changes, call refresh_field_definitions_cache()
+        to reload the definitions.
+        
+        Returns:
+            dict: Field definitions mapping
+        """
+        if self._field_definitions_cache is None:
+            self._field_definitions_cache = self.__get_project_field_definitions()
+        return self._field_definitions_cache
+
+    def refresh_field_definitions_cache(self) -> dict:
+        """Manually refresh the field definitions cache.
+        
+        Call this method if project field configuration has been updated
+        (new fields added, dropdown values changed, etc.) and you need to
+        reload the definitions within the same agent session.
+        
+        Returns:
+            dict: Freshly loaded field definitions
+        """
+        self._field_definitions_cache = None
+        return self.__get_field_definitions_cached()
+
+    def __map_properties_to_api_format(self, test_case_data: dict, field_definitions: dict,
+                                       base_properties: list = None) -> list:
+        """
+        Convert user-friendly property names/values to QTest API PropertyResource format.
+        
+        Args:
+            test_case_data: Dict with property names as keys (e.g., {"Status": "New", "Priority": "High"})
+            field_definitions: Output from __get_project_field_definitions()
+            base_properties: Existing properties from a test case (for updates, optional)
+            
+        Returns:
+            list[PropertyResource]: Properties ready for API submission
+            
+        Raises:
+            ValueError: If any field names are unknown or values are invalid (shows ALL errors)
+        """
+        # Start with base properties or empty dict
+        props_dict = {}
+        if base_properties:
+            for prop in base_properties:
+                field_name = prop.get('field_name')
+                if field_name:
+                    props_dict[field_name] = {
+                        'field_id': prop['field_id'],
+                        'field_name': field_name,
+                        'field_value': prop['field_value'],
+                        'field_value_name': prop.get('field_value_name')
+                    }
+        
+        # Collect ALL validation errors before raising
+        validation_errors = []
+        
+        # Map incoming properties from test_case_data
+        for field_name, field_value in test_case_data.items():
+            # Skip non-property fields (these are handled separately)
+            if field_name in ['Name', 'Description', 'Precondition', 'Steps', 'Id', QTEST_ID]:
+                continue
+            
+            # Skip None or empty string values (don't update these fields)
+            if field_value is None or field_value == '':
+                continue
+            
+            # Validate field exists in project - STRICT validation
+            if field_name not in field_definitions:
+                validation_errors.append(
+                    f"❌ Unknown field '{field_name}' - not defined in project configuration"
+                )
+                continue  # Skip to next field, keep collecting errors
+            
+            field_def = field_definitions[field_name]
+            field_id = field_def['field_id']
+            
+            # Validate value for dropdown fields (only if field has allowed values)
+            if field_def['values']:
+                # Field has allowed values (dropdown/combobox) - validate strictly
+                if field_value not in field_def['values']:
+                    available = ", ".join(sorted(field_def['values'].keys()))
+                    validation_errors.append(
+                        f"❌ Invalid value '{field_value}' for field '{field_name}'. "
+                        f"Allowed values: {available}"
+                    )
+                    continue  # Skip to next field, keep collecting errors
+                field_value_id = field_def['values'][field_value]
+                field_value_name = field_value
+            else:
+                # Text field or field without restricted values - use value directly
+                # No validation needed - users can write anything (by design)
+                field_value_id = field_value
+                field_value_name = field_value if isinstance(field_value, str) else None
+            
+            # Update or add property (only if no errors for this field)
+            props_dict[field_name] = {
+                'field_id': field_id,
+                'field_name': field_name,
+                'field_value': field_value_id,
+                'field_value_name': field_value_name
+            }
+        
+        # If ANY validation errors found, raise comprehensive error with all issues
+        if validation_errors:
+            available_fields = ", ".join(sorted(field_definitions.keys()))
+            error_msg = (
+                f"Found {len(validation_errors)} validation error(s) in test case properties:\n\n" +
+                "\n".join(validation_errors) +
+                f"\n\n📋 Available fields for this project: {available_fields}\n\n"
+                f"💡 Tip: Use 'get_all_test_cases_fields_for_project' tool to see all fields with their allowed values."
+            )
+            raise ValueError(error_msg)
+        
+        # Convert to PropertyResource list, filtering out special fields
+        result = []
+        for field_name, prop_data in props_dict.items():
+            if field_name in ['Shared', 'Projects Shared to']:
+                continue
+            result.append(PropertyResource(
+                field_id=prop_data['field_id'],
+                field_name=prop_data['field_name'],
+                field_value=prop_data['field_value'],
+                field_value_name=prop_data.get('field_value_name')
+            ))
+        
+        return result
+
     def __build_body_for_create_test_case(self, test_cases_data: list[dict],
                                           folder_to_place_test_cases_to: str = '') -> list:
-        initial_project_properties = self.__get_properties_form_project()
+        # Get field definitions for property mapping (cached for session)
+        field_definitions = self.__get_field_definitions_cached()
+        
         modules = self._parse_modules()
         parent_id = ''.join(str(module['module_id']) for module in modules if
                             folder_to_place_test_cases_to and module['full_module_name'] == folder_to_place_test_cases_to)
-        props = []
-        for prop in initial_project_properties:
-            if prop.get('field_name', '') == 'Shared' or prop.get('field_name', '') == 'Projects Shared to':
-                continue
-            props.append(PropertyResource(field_id=prop['field_id'], field_name=prop['field_name'],
-                                          field_value_name=prop.get('field_value_name', None),
-                                          field_value=prop['field_value']))
+        
         bodies = []
         for test_case in test_cases_data:
+            # Map properties from user format to API format
+            props = self.__map_properties_to_api_format(test_case, field_definitions)
+            
             body = swagger_client.TestCaseWithCustomFieldResource(properties=props)
-            body.name = test_case.get('Name')
-            body.precondition = test_case.get('Precondition')
-            body.description = test_case.get('Description')
+            
+            # Only set fields if they are explicitly provided in the input
+            # This prevents overwriting existing values with None during partial updates
+            if 'Name' in test_case:
+                body.name = test_case['Name']
+            if 'Precondition' in test_case:
+                body.precondition = test_case['Precondition']
+            if 'Description' in test_case:
+                body.description = test_case['Description']
+            
             if parent_id:
                 body.parent_id = parent_id
-            test_steps_resources = []
-            for step in test_case.get('Steps'):
-                test_steps_resources.append(
-                    swagger_client.TestStepResource(description=step.get('Test Step Description'),
-                                                    expected=step.get('Test Step Expected Result')))
-            body.test_steps = test_steps_resources
+            
+            # Only set test_steps if Steps are provided in the input
+            # This prevents overwriting existing steps during partial updates
+            if 'Steps' in test_case and test_case['Steps'] is not None:
+                test_steps_resources = []
+                for step in test_case['Steps']:
+                    test_steps_resources.append(
+                        swagger_client.TestStepResource(description=step.get('Test Step Description'),
+                                                        expected=step.get('Test Step Expected Result')))
+                body.test_steps = test_steps_resources
+            
             bodies.append(body)
         return bodies
 
@@ -206,6 +363,100 @@ class QtestApiWrapper(BaseToolApiWrapper):
                                 Exception: \n {stacktrace}""")
         return modules
 
+    def __get_project_field_definitions(self) -> dict:
+        """
+        Get structured field definitions for test cases in the project.
+        
+        Returns:
+            dict: Mapping of field names to their IDs and allowed values.
+                  Example: {
+                      'Status': {
+                          'field_id': 12345,
+                          'required': True,
+                          'values': {'New': 1, 'In Progress': 2, 'Completed': 3}
+                      },
+                      'Priority': {
+                          'field_id': 12346,
+                          'required': False,
+                          'values': {'High': 1, 'Medium': 2, 'Low': 3}
+                      }
+                  }
+        """
+        fields_api = self.__instantiate_fields_api_instance()
+        qtest_object = 'test-cases'
+        
+        try:
+            fields = fields_api.get_fields(self.qtest_project_id, qtest_object)
+        except ApiException as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when calling FieldAPI->get_fields:\n {stacktrace}")
+            raise ValueError(
+                f"Unable to get test case fields for project {self.qtest_project_id}. Exception: \n {stacktrace}")
+        
+        # Build structured mapping
+        field_mapping = {}
+        for field in fields:
+            field_name = field.label
+            field_mapping[field_name] = {
+                'field_id': field.id,
+                'required': getattr(field, 'required', False),
+                'values': {}
+            }
+            
+            # Map allowed values if field has them (dropdown/combobox fields)
+            if hasattr(field, 'allowed_values') and field.allowed_values:
+                for allowed_value in field.allowed_values:
+                    # AllowedValueResource has 'label' for the display name and 'value' for the ID
+                    # Note: 'value' is the field_value, not 'id'
+                    value_label = allowed_value.label
+                    value_id = allowed_value.value
+                    field_mapping[field_name]['values'][value_label] = value_id
+        
+        return field_mapping
+
+    def __format_field_info_for_display(self, field_definitions: dict) -> str:
+        """
+        Format field definitions in human-readable format for LLM.
+        
+        Args:
+            field_definitions: Output from __get_project_field_definitions()
+            
+        Returns:
+            Formatted string with field information
+        """
+        output = [f"Available Test Case Fields for Project {self.qtest_project_id}:\n"]
+        
+        for field_name, field_info in sorted(field_definitions.items()):
+            required_marker = " (Required)" if field_info.get('required') else ""
+            output.append(f"\n{field_name}{required_marker}:")
+            
+            if field_info.get('values'):
+                for value_name, value_id in sorted(field_info['values'].items()):
+                    output.append(f"  - {value_name} (id: {value_id})")
+            else:
+                output.append("  Type: text")
+        
+        output.append("\n\nUse these exact value names when creating or updating test cases.")
+        return ''.join(output)
+
+    def get_all_test_cases_fields_for_project(self, force_refresh: bool = False) -> str:
+        """
+        Get formatted information about available test case fields and their values.
+        This method is exposed as a tool for LLM to query field information.
+        
+        Args:
+            force_refresh: If True, reload field definitions from API instead of using cache.
+                          Use this if project configuration has changed (new fields added,
+                          dropdown values modified, etc.).
+        
+        Returns:
+            Formatted string with field names and allowed values
+        """
+        if force_refresh:
+            self.refresh_field_definitions_cache()
+        field_defs = self.__get_field_definitions_cached()
+        return self.__format_field_info_for_display(field_defs)
+
     def _parse_modules(self) -> list[dict]:
         modules = self.__get_all_modules_for_project()
         result = []
@@ -323,18 +574,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
         parsed_data = self.__perform_search_by_dql(dql)
         return parsed_data[0]['QTest Id']
 
-    def __get_properties_form_project(self) -> list[dict] | None:
-        test_api_instance = self.__instantiate_test_api_instance()
-        expand_props = 'true'
-        try:
-            response = test_api_instance.get_test_cases(self.qtest_project_id, 1, 1, expand_props=expand_props)
-            return response[0]['properties']
-        except ApiException as e:
-            stacktrace = format_exc()
-            logger.error(f"Exception when calling TestCaseApi->get_test_cases: \n {stacktrace}")
-            raise e
-
-    def __is_jira_requirement_present(self, jira_issue_id: str) -> (bool, dict):
+    def __is_jira_requirement_present(self, jira_issue_id: str) -> tuple[bool, dict]:
         """ Define if particular Jira requirement is present in qtest or not """
         dql = f"'External Id' = '{jira_issue_id}'"
         search_instance: SearchApi = swagger_client.SearchApi(self._client)
@@ -508,5 +748,12 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 "description": self.get_modules.__doc__,
                 "args_schema": GetModules,
                 "ref": self.get_modules,
+            },
+            {
+                "name": "get_all_test_cases_fields_for_project",
+                "mode": "get_all_test_cases_fields_for_project",
+                "description": "Get information about available test case fields and their valid values for the project. Shows which property values are allowed (e.g., Status: 'New', 'In Progress', 'Completed') based on the project configuration. Use force_refresh=true if project configuration has changed.",
+                "args_schema": GetAllTestCasesFieldsForProject,
+                "ref": self.get_all_test_cases_fields_for_project,
             }
         ]

alita_sdk/tools/sharepoint/api_wrapper.py

@@ -8,6 +8,7 @@ from office365.runtime.auth.client_credential import ClientCredential
 from office365.sharepoint.client_context import ClientContext
 from pydantic import Field, PrivateAttr, create_model, model_validator, SecretStr
 
+from .utils import decode_sharepoint_string
 from ..non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ..utils.content_parser import parse_file_content
 from ...runtime.utils.utils import IndexerKeywords
@@ -91,44 +92,85 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
             target_list = self._client.web.lists.get_by_title(list_title)
             self._client.load(target_list)
             self._client.execute_query()
-            items = target_list.items.get().top(limit).execute_query()
-            logging.info("{0} items from sharepoint loaded successfully.".format(len(items)))
+            items = target_list.items.top(limit).get().execute_query()
+            logging.info("{0} items from sharepoint loaded successfully via SharePoint REST API.".format(len(items)))
             result = []
             for item in items:
                 result.append(item.properties)
             return result
-        except Exception as e:
-            logging.error(f"Failed to load items from sharepoint: {e}")
-            return ToolException("Can not list items. Please, double check List name and read permissions.")
+        except Exception as base_e:
+            logging.warning(f"Primary SharePoint REST list read failed: {base_e}. Attempting Graph API fallback.")
+            # Attempt Graph API fallback
+            try:
+                from .authorization_helper import SharepointAuthorizationHelper
+                auth_helper = SharepointAuthorizationHelper(
+                    client_id=self.client_id,
+                    client_secret=self.client_secret.get_secret_value() if self.client_secret else None,
+                    tenant="",  # optional for graph api (derived inside helper)
+                    scope="",  # optional for graph api
+                    token_json="",  # not needed for client credentials flow here
+                )
+                graph_items = auth_helper.get_list_items(self.site_url, list_title, limit)
+                if graph_items:
+                    logging.info(f"{len(graph_items)} items from sharepoint loaded successfully via Graph API fallback.")
+                    return graph_items
+                else:
+                    return ToolException("List appears empty or inaccessible via both REST and Graph APIs.")
+            except Exception as graph_e:
+                logging.error(f"Graph API fallback failed: {graph_e}")
+                return ToolException(f"Cannot read list '{list_title}'. Check list name and permissions: {base_e} | {graph_e}")
 
 
     def get_files_list(self, folder_name: str = None, limit_files: int = 100):
         """ If folder name is specified, lists all files in this folder under Shared Documents path. If folder name is empty, lists all files under root catalog (Shared Documents). Number of files is limited by limit_files (default is 100)."""
         try:
+            # exclude default system libraries like 'Form Templates', 'Site Assets', 'Style Library'
+            all_libraries = self._client.web.lists.filter("BaseTemplate eq 101 and Title ne 'Form Templates' and Title ne 'Site Assets' and Title ne 'Style Library'").get().execute_query()
             result = []
             if not limit_files:
                 limit_files = 100
-            target_folder_url = f"Shared Documents/{folder_name}" if folder_name else "Shared Documents"
-            files = (self._client.web.get_folder_by_server_relative_path(target_folder_url)
-                     .get_files(True)
-                     .execute_query())
-
-            for file in files:
-                if len(result) >= limit_files:
-                    break
-                temp_props = {
-                    'Name': file.properties['Name'],
-                    'Path': file.properties['ServerRelativeUrl'],
-                    'Created': file.properties['TimeCreated'],
-                    'Modified': file.properties['TimeLastModified'],
-                    'Link': file.properties['LinkingUrl'],
-                    'id': file.properties['UniqueId']
-                }
-                result.append(temp_props)
+            #
+            for lib in all_libraries:
+                library_type = decode_sharepoint_string(lib.properties["EntityTypeName"])
+                target_folder_url = f"{library_type}/{folder_name}" if folder_name else library_type
+                files = (self._client.web.get_folder_by_server_relative_path(target_folder_url)
+                         .get_files(True)
+                         .execute_query())
+                #
+                for file in files:
+                    if f"{library_type}/Forms" in file.properties['ServerRelativeUrl']:
+                        # skip files from system folder "Forms"
+                        continue
+                    if len(result) >= limit_files:
+                        break
+                    temp_props = {
+                        'Name': file.properties['Name'],
+                        'Path': file.properties['ServerRelativeUrl'],
+                        'Created': file.properties['TimeCreated'],
+                        'Modified': file.properties['TimeLastModified'],
+                        'Link': file.properties['LinkingUrl'],
+                        'id': file.properties['UniqueId']
+                    }
+                    result.append(temp_props)
             return result if result else ToolException("Can not get files or folder is empty. Please, double check folder name and read permissions.")
         except Exception as e:
-            logging.error(f"Failed to load files from sharepoint: {e}")
-            return ToolException("Can not get files. Please, double check folder name and read permissions.")
+            # attempt to get via graph api
+            try:
+                # attempt to get files via graph api
+                from .authorization_helper import SharepointAuthorizationHelper
+                auth_helper = SharepointAuthorizationHelper(
+                    client_id=self.client_id,
+                    client_secret=self.client_secret.get_secret_value(),
+                    tenant="", # optional for graph api
+                    scope="", # optional for graph api
+                    token_json="", # optional for graph api
+                )
+                files = auth_helper.get_files_list(self.site_url, folder_name, limit_files)
+                return files
+            except Exception as graph_e:
+                logging.error(f"Failed to load files from sharepoint via base api: {e}")
+                logging.error(f"Failed to load files from sharepoint via graph api: {graph_e}")
+                return ToolException(f"Can not get files. Please, double check folder name and read permissions: {e} and {graph_e}")
 
     def read_file(self, path,
                   is_capture_image: bool = False,
@@ -141,11 +183,28 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
             self._client.load(file).execute_query()
 
             file_content = file.read()
+            file_name = file.name
             self._client.execute_query()
         except Exception as e:
-            logging.error(f"Failed to load file from SharePoint: {e}. Path: {path}. Please, double check file name and path.")
-            return ToolException("File not found. Please, check file name and path.")
-        return parse_file_content(file_name=file.name,
+            # attempt to get via graph api
+            try:
+                # attempt to get files via graph api
+                from .authorization_helper import SharepointAuthorizationHelper
+                auth_helper = SharepointAuthorizationHelper(
+                    client_id=self.client_id,
+                    client_secret=self.client_secret.get_secret_value(),
+                    tenant="",  # optional for graph api
+                    scope="",  # optional for graph api
+                    token_json="",  # optional for graph api
+                )
+                file_content = auth_helper.get_file_content(self.site_url, path)
+                file_name = path.split('/')[-1]
+            except Exception as graph_e:
+                logging.error(f"Failed to load file from SharePoint via base api: {e}. Path: {path}. Please, double check file name and path.")
+                logging.error(f"Failed to load file from SharePoint via graph api: {graph_e}. Path: {path}. Please, double check file name and path.")
+                return ToolException(f"File not found. Please, check file name and path: {e} and {graph_e}")
+        #
+        return parse_file_content(file_name=file_name,
                                   file_content=file_content,
                                   is_capture_image=is_capture_image,
                                   page_number=page_number,
@@ -219,12 +278,24 @@ class SharepointApiWrapper(NonCodeIndexerToolkit):
                 yield document
 
     def _load_file_content_in_bytes(self, path):
-        file = self._client.web.get_file_by_server_relative_path(path)
-        self._client.load(file).execute_query()
-        file_content = file.read()
-        self._client.execute_query()
-        #
-        return file_content
+        try:
+            file = self._client.web.get_file_by_server_relative_path(path)
+            self._client.load(file).execute_query()
+            file_content = file.read()
+            self._client.execute_query()
+            #
+            return file_content
+        except Exception as e:
+            # attempt to get via graph api
+            from .authorization_helper import SharepointAuthorizationHelper
+            auth_helper = SharepointAuthorizationHelper(
+                client_id=self.client_id,
+                client_secret=self.client_secret.get_secret_value(),
+                tenant="",  # optional for graph api
+                scope="",  # optional for graph api
+                token_json="",  # optional for graph api
+            )
+            return auth_helper.get_file_content(self.site_url, path)
 
     def get_available_tools(self):
         return super().get_available_tools() + [