codemie-test-harness 0.1.224__py3-none-any.whl → 0.1.226__py3-none-any.whl

codemie_test_harness/tests/conftest.py

@@ -953,7 +953,9 @@ def integration(integration_utils):
 @pytest.fixture(scope="session")
 def vendor_assistant_utils():
     """Create VendorUtils instance for managing vendor assistants"""
-    from codemie_test_harness.tests.utils.vendor_utils import VendorAssistantUtils
+    from codemie_test_harness.tests.utils.vendor_assistant_utils import (
+        VendorAssistantUtils,
+    )
 
     return VendorAssistantUtils()
 
@@ -968,6 +970,16 @@ def vendor_workflow_utils():
     return VendorWorkflowUtils()
 
 
+@pytest.fixture(scope="session")
+def vendor_knowledge_base_utils():
+    """Create VendorKnowledgeBaseUtils instance for managing vendor knowledge bases"""
+    from codemie_test_harness.tests.utils.vendor_knowledge_base_utils import (
+        VendorKnowledgeBaseUtils,
+    )
+
+    return VendorKnowledgeBaseUtils()
+
+
 def pytest_sessionfinish(session):
     """Run cleanup code after all tests have finished."""
     clean_up_timeout = 1 if EnvironmentResolver.is_production() else 0

codemie_test_harness/tests/test_data/vendor_knowledge_base_test_data.py

@@ -0,0 +1,84 @@
+"""Test data for vendor knowledge base integration tests."""
+
+import pytest
+from codemie_sdk.models.vendor_assistant import VendorType
+from codemie_sdk.models.integration import CredentialTypes
+
+from codemie_test_harness.tests.utils.credentials_manager import CredentialsManager
+
+
+# Test data for vendor knowledge base integration tests
+# Extensible for AWS Bedrock, Azure AI, and GCP Vertex AI
+vendor_knowledge_base_test_data = [
+    pytest.param(
+        VendorType.AWS,
+        CredentialTypes.AWS,
+        CredentialsManager.aws_credentials(),
+        "Tell me about filtering by language",
+        "Filtering by language allows you to select books based on your preferred language. "
+        "According to the knowledge base, the available language filter options include:\n\n"
+        "- English\n- Spanish\n- French\n- German\n\n"
+        "You can use these filters to view only the books that are available in the selected language.",
+        marks=[pytest.mark.aws, pytest.mark.bedrock],
+        id="AWS_Bedrock",
+    ),
+    # Future: Azure AI knowledge bases
+    # pytest.param(
+    #     VendorType.AZURE,
+    #     CredentialTypes.AZURE,
+    #     CredentialsManager.azure_credentials(),
+    #     "Tell me about filtering by language",
+    #     "Filtering by language allows you to select books based on your preferred language.",
+    #     marks=[pytest.mark.azure],
+    #     id="Azure_AI",
+    # ),
+    # Future: GCP Vertex AI knowledge bases
+    # pytest.param(
+    #     VendorType.GCP,
+    #     CredentialTypes.GCP,
+    #     CredentialsManager.gcp_credentials(),
+    #     "Tell me about filtering by language",
+    #     "Filtering by language allows you to select books based on your preferred language.",
+    #     marks=[pytest.mark.gcp],
+    #     id="GCP_Vertex_AI",
+    # ),
+]
+
+# Test data for vendor assistant with KB integration tests
+vendor_assistant_with_kb_test_data = [
+    pytest.param(
+        VendorType.AWS,
+        CredentialTypes.AWS,
+        CredentialsManager.aws_credentials(),
+        "codemie-autotests-with-kb",
+        "Tell me about filtering by language",
+        "Filtering by language allows you to select books based on your preferred language. "
+        "According to the knowledge base, the available language filter options include:\n\n"
+        "- English\n- Spanish\n- French\n- German\n\n"
+        "You can use these filters to view only the books that are available in the selected language.",
+        marks=[pytest.mark.aws, pytest.mark.bedrock],
+        id="AWS_Bedrock",
+    ),
+    # Future: Azure AI assistants with KB
+    # pytest.param(
+    #     VendorType.AZURE,
+    #     CredentialTypes.AZURE,
+    #     CredentialsManager.azure_credentials(),
+    #     "codemie-autotests-with-kb",
+    #     "Tell me about filtering by language",
+    #     "Filtering by language allows you to select books based on your preferred language.",
+    #     marks=[pytest.mark.azure],
+    #     id="Azure_AI",
+    # ),
+    # Future: GCP Vertex AI assistants with KB
+    # pytest.param(
+    #     VendorType.GCP,
+    #     CredentialTypes.GCP,
+    #     CredentialsManager.gcp_credentials(),
+    #     "codemie-autotests-with-kb",
+    #     "Tell me about filtering by language",
+    #     "Filtering by language allows you to select books based on your preferred language.",
+    #     marks=[pytest.mark.gcp],
+    #     id="GCP_Vertex_AI",
+    # ),
+]

codemie_test_harness/tests/test_data/vendor_workflow_test_data.py

@@ -27,6 +27,89 @@ vendor_workflow_test_data = [
         marks=[pytest.mark.aws, pytest.mark.bedrock],
         id="AWS_Bedrock_Object_Input",
     ),
+    pytest.param(
+        VendorType.AWS,
+        CredentialTypes.AWS,
+        CredentialsManager.aws_credentials(),
+        "codemie-autotests-flow-string-input",
+        "pop",
+        """
+            # Pop Playlist (3 Songs)
+            
+            1. "Blinding Lights" - The Weeknd
+               *Upbeat synth-pop track with irresistible 80s vibes and a catchy chorus*
+            
+            2. "As It Was" - Harry Styles
+               *Melodic pop anthem with nostalgic undertones and danceable rhythm*
+            
+            3. "Levitating" - Dua Lipa
+               *Disco-infused pop banger with infectious grooves and stellar vocals*
+            
+            Enjoy these modern pop hits! Would you like any specific recommendations or adjustments to the playlist?
+        """,
+        marks=[pytest.mark.aws, pytest.mark.bedrock],
+        id="AWS_Bedrock_String_Input",
+    ),
+    pytest.param(
+        VendorType.AWS,
+        CredentialTypes.AWS,
+        CredentialsManager.aws_credentials(),
+        "codemie-autotests-flow-number-input",
+        json.dumps(3),
+        """
+            # Pop Playlist (3 Songs)
+            
+            1. "Shape of You" - Ed Sheeran
+            2. "Blinding Lights" - The Weeknd
+            3. "Dance Monkey" - Tones and I
+            
+            Each of these songs has been a massive pop hit with catchy hooks and radio-friendly production. Enjoy your playlist!
+        """,
+        marks=[pytest.mark.aws, pytest.mark.bedrock],
+        id="AWS_Bedrock_Number_Input",
+    ),
+    pytest.param(
+        VendorType.AWS,
+        CredentialTypes.AWS,
+        CredentialsManager.aws_credentials(),
+        "codemie-autotests-flow-boolean-input",
+        json.dumps(True),
+        """
+            # Pop Playlist (3 Songs)
+            
+            1. "Bad Guy" by Billie Eilish
+            2. "Blinding Lights" by The Weeknd
+            3. "As It Was" by Harry Styles
+            
+            These are three popular pop songs from recent years that feature catchy melodies, modern production, and have achieved significant commercial success.
+        """,
+        marks=[pytest.mark.aws, pytest.mark.bedrock],
+        id="AWS_Bedrock_Boolean_Input",
+    ),
+    pytest.param(
+        VendorType.AWS,
+        CredentialTypes.AWS,
+        CredentialsManager.aws_credentials(),
+        "codemie-autotests-flow-array-input",
+        json.dumps(["pop", "rock"]),
+        """
+            # Playlist Creation
+            
+            Here are two playlists with 2 songs each:
+            
+            ## Pop Playlist (2 songs)
+            1. "Shape of You" by Ed Sheeran
+            2. "Bad Guy" by Billie Eilish
+            
+            ## Rock Playlist (2 songs)
+            1. "Bohemian Rhapsody" by Queen
+            2. "Sweet Child O' Mine" by Guns N' Roses
+            
+            Would you like me to expand either playlist with more song suggestions or provide information about any of these tracks?
+        """,
+        marks=[pytest.mark.aws, pytest.mark.bedrock],
+        id="AWS_Bedrock_Array_Input",
+    ),
     # pytest.param(
     #     VendorType.AZURE,
     #     CredentialTypes.AZURE,

codemie_test_harness/tests/utils/{vendor_utils.py → vendor_assistant_utils.py}

@@ -161,7 +161,7 @@ class VendorAssistantUtils:
             assistants: List of assistant installation requests
 
         Returns:
-            VendorAssistantInstallResponse containing installation summary with AI run IDs
+            VendorAssistantInstallResponse containing installation summary with CodeMie IDs
         """
         logger.info(f"Installing {len(assistants)} assistant(s) for {vendor.value}")
         response = self.vendor_assistant_service.install_assistants(
@@ -231,6 +231,48 @@ class VendorAssistantUtils:
             aliases[0] if aliases else None,
         )
 
+    def find_assistant_by_name(
+        self,
+        vendor: VendorType,
+        setting_id: str,
+        assistant_name: str,
+    ) -> Optional[tuple[VendorAssistant, str]]:
+        """Find an assistant by name and return it with an alias.
+
+        Args:
+            vendor: Cloud vendor type
+            setting_id: ID of the vendor setting
+            assistant_name: Name of the assistant to find
+
+        Returns:
+            Tuple of (VendorAssistant, alias_id) or None if assistant not found
+        """
+        logger.info(
+            f"Searching for assistant '{assistant_name}' in {vendor.value} setting {setting_id}"
+        )
+        assistants_response = self.get_assistants(vendor=vendor, setting_id=setting_id)
+
+        for assistant in assistants_response.data:
+            if (
+                assistant.name == assistant_name
+                and assistant.status == VendorAssistantStatus.PREPARED
+            ):
+                aliases_response = self.get_assistant_aliases(
+                    vendor=vendor, assistant_id=assistant.id, setting_id=setting_id
+                )
+                if aliases_response.data:
+                    non_draft_alias = self.get_non_draft_alias(aliases_response.data)
+                    if non_draft_alias:
+                        logger.info(
+                            f"Found assistant: {assistant.name} (ID: {assistant.id}, Alias: {non_draft_alias.id})"
+                        )
+                        return assistant, non_draft_alias.id
+
+        logger.warning(
+            f"Assistant '{assistant_name}' not found for {vendor.value} setting {setting_id}"
+        )
+        return None
+
     def find_first_available_assistant(
         self,
         vendor: VendorType,
@@ -252,7 +294,6 @@ class VendorAssistantUtils:
 
         for assistant in assistants_response.data:
             if assistant.status.value == "PREPARED":
-                # Get aliases for this assistant
                 aliases_response = self.get_assistant_aliases(
                     vendor=vendor, assistant_id=assistant.id, setting_id=setting_id
                 )
@@ -268,6 +309,44 @@ class VendorAssistantUtils:
         )
         return None
 
+    def install_assistant_by_name(
+        self,
+        vendor: VendorType,
+        setting_id: str,
+        assistant_name: str,
+    ) -> Optional[str]:
+        """Find and install an assistant by name.
+
+        Args:
+            vendor: Cloud vendor type
+            setting_id: ID of the vendor setting
+            assistant_name: Name of the assistant to install
+
+        Returns:
+            CodeMie ID of the installed assistant or None if assistant not found
+        """
+        result = self.find_assistant_by_name(
+            vendor=vendor, setting_id=setting_id, assistant_name=assistant_name
+        )
+        if not result:
+            return None
+
+        assistant, alias_id = result
+        install_request = VendorAssistantInstallRequest(
+            id=assistant.id,
+            agentAliasId=alias_id,
+            setting_id=setting_id,
+        )
+
+        install_response = self.install_assistants(
+            vendor=vendor, assistants=[install_request]
+        )
+
+        if install_response.summary:
+            return install_response.summary[0].aiRunId
+
+        return None
+
     def install_first_available_assistant(
         self,
         vendor: VendorType,

codemie_test_harness/tests/utils/vendor_knowledge_base_utils.py

@@ -0,0 +1,350 @@
+"""Utility class for managing vendor knowledge bases (AWS Bedrock, Azure, GCP)."""
+
+from typing import Optional, List
+from codemie_sdk.models.vendor_assistant import VendorType
+from codemie_sdk.models.vendor_knowledgebase import (
+    VendorKnowledgeBaseSettingsResponse,
+    VendorKnowledgeBasesResponse,
+    VendorKnowledgeBase,
+    VendorKnowledgeBaseDetail,
+    VendorKnowledgeBaseInstallRequest,
+    VendorKnowledgeBaseInstallResponse,
+    VendorKnowledgeBaseUninstallResponse,
+    VendorKnowledgeBaseStatus,
+)
+from codemie_test_harness.tests.utils.client_factory import get_client
+from codemie_test_harness.tests.utils.logger_util import setup_logger
+
+logger = setup_logger(__name__)
+
+
+class VendorKnowledgeBaseUtils:
+    """Utility class for vendor knowledge base operations."""
+
+    def __init__(self):
+        """Initialize VendorKnowledgeBaseUtils with CodeMie client."""
+        self.client = get_client()
+        self.vendor_kb_service = self.client.vendor_knowledgebases
+
+    def get_knowledgebase_settings(
+        self,
+        vendor: VendorType,
+        page: int = 0,
+        per_page: int = 10,
+    ) -> VendorKnowledgeBaseSettingsResponse:
+        """Get knowledge base settings for a specific cloud vendor.
+
+        Args:
+            vendor: Cloud vendor type (AWS, AZURE, GCP)
+            page: Page number for pagination
+            per_page: Number of items per page
+
+        Returns:
+            VendorKnowledgeBaseSettingsResponse containing list of settings
+        """
+        logger.info(
+            f"Getting KB settings for {vendor.value} (page={page}, per_page={per_page})"
+        )
+        settings = self.vendor_kb_service.get_knowledgebase_settings(
+            vendor=vendor, page=page, per_page=per_page
+        )
+        logger.info(
+            f"Retrieved {len(settings.data)} KB settings for {vendor.value} (total: {settings.pagination.total})"
+        )
+        return settings
+
+    def get_knowledgebases(
+        self,
+        vendor: VendorType,
+        setting_id: str,
+        per_page: int = 10,
+        next_token: Optional[str] = None,
+    ) -> VendorKnowledgeBasesResponse:
+        """Get knowledge bases for a specific vendor setting.
+
+        Args:
+            vendor: Cloud vendor type
+            setting_id: ID of the vendor setting
+            per_page: Number of items per page
+            next_token: Token for pagination
+
+        Returns:
+            VendorKnowledgeBasesResponse containing list of knowledge bases
+        """
+        logger.info(
+            f"Getting knowledge bases for {vendor.value} setting {setting_id} (per_page={per_page})"
+        )
+        kbs = self.vendor_kb_service.get_knowledgebases(
+            vendor=vendor,
+            setting_id=setting_id,
+            per_page=per_page,
+            next_token=next_token,
+        )
+        logger.info(
+            f"Retrieved {len(kbs.data)} knowledge bases for setting {setting_id}"
+        )
+        return kbs
+
+    def get_knowledgebase(
+        self,
+        vendor: VendorType,
+        knowledgebase_id: str,
+        setting_id: str,
+    ) -> VendorKnowledgeBaseDetail:
+        """Get a specific knowledge base by ID.
+
+        Args:
+            vendor: Cloud vendor type
+            knowledgebase_id: ID of the knowledge base
+            setting_id: ID of the vendor setting
+
+        Returns:
+            VendorKnowledgeBaseDetail with knowledge base details
+        """
+        logger.info(
+            f"Getting knowledge base {knowledgebase_id} for {vendor.value} setting {setting_id}"
+        )
+        kb = self.vendor_kb_service.get_knowledgebase(
+            vendor=vendor, knowledgebase_id=knowledgebase_id, setting_id=setting_id
+        )
+        logger.info(f"Retrieved knowledge base: {kb.name} (status: {kb.status})")
+        return kb
+
+    def install_knowledgebases(
+        self,
+        vendor: VendorType,
+        knowledgebases: List[VendorKnowledgeBaseInstallRequest],
+    ) -> VendorKnowledgeBaseInstallResponse:
+        """Install/activate vendor knowledge bases.
+
+        Args:
+            vendor: Cloud vendor type
+            knowledgebases: List of knowledge base installation requests
+
+        Returns:
+            VendorKnowledgeBaseInstallResponse containing installation summary
+        """
+        logger.info(
+            f"Installing {len(knowledgebases)} knowledge base(s) for {vendor.value}"
+        )
+        response = self.vendor_kb_service.install_knowledgebases(
+            vendor=vendor, knowledgebases=knowledgebases
+        )
+        for item in response.summary:
+            logger.info(
+                f"Installed KB {item.knowledgeBaseId} -> CodeMie ID: {item.aiRunId}"
+            )
+        return response
+
+    def uninstall_knowledgebase(
+        self,
+        vendor: VendorType,
+        codemie_id: str,
+    ) -> VendorKnowledgeBaseUninstallResponse:
+        """Uninstall/deactivate a vendor knowledge base.
+
+        Args:
+            vendor: Cloud vendor type
+            codemie_id: CodeMie ID from installation
+
+        Returns:
+            VendorKnowledgeBaseUninstallResponse with success status
+        """
+        logger.info(f"Uninstalling knowledge base with CodeMie ID: {codemie_id}")
+        response = self.vendor_kb_service.uninstall_knowledgebase(
+            vendor=vendor, ai_run_id=codemie_id
+        )
+        if response.success:
+            logger.info(f"Successfully uninstalled knowledge base {codemie_id}")
+        else:
+            logger.warning(f"Failed to uninstall knowledge base {codemie_id}")
+        return response
+
+    def get_available_knowledge_base(
+        self,
+        knowledge_bases: List[VendorKnowledgeBase],
+    ) -> Optional[VendorKnowledgeBase]:
+        """Get first PREPARED knowledge base from the list.
+
+        Args:
+            knowledge_bases: List of vendor knowledge bases
+
+        Returns:
+            First PREPARED knowledge base or first KB if none are PREPARED
+        """
+        return next(
+            (
+                kb
+                for kb in knowledge_bases
+                if kb.status == VendorKnowledgeBaseStatus.PREPARED
+            ),
+            knowledge_bases[0] if knowledge_bases else None,
+        )
+
+    def find_setting_for_integration(
+        self,
+        vendor: VendorType,
+        integration_id: str,
+    ):
+        """Find setting for an integration by paginating through all settings.
+
+        Args:
+            vendor: Type of vendor (AWS, AZURE, GCP)
+            integration_id: ID of the integration to find (searches by setting_id)
+
+        Returns:
+            VendorKnowledgeBaseSetting or None if not found
+        """
+        page = 0
+        per_page = 50
+
+        while True:
+            settings_response = self.get_knowledgebase_settings(
+                vendor=vendor,
+                page=page,
+                per_page=per_page,
+            )
+
+            # Find the setting for our integration by setting_id
+            for s in settings_response.data:
+                if s.setting_id == integration_id:
+                    return s
+
+            # Check if there are more pages
+            if page >= settings_response.pagination.pages - 1:
+                break
+
+            page += 1
+
+        logger.warning(f"Setting not found for integration ID '{integration_id}'")
+        return None
+
+    def find_knowledge_base_by_name(
+        self,
+        vendor: VendorType,
+        setting_id: str,
+        kb_name: str,
+    ) -> Optional[VendorKnowledgeBase]:
+        """Find a knowledge base by name.
+
+        Args:
+            vendor: Cloud vendor type
+            setting_id: ID of the vendor setting
+            kb_name: Name of the knowledge base to find
+
+        Returns:
+            VendorKnowledgeBase or None if knowledge base not found
+        """
+        logger.info(
+            f"Searching for knowledge base '{kb_name}' in {vendor.value} setting {setting_id}"
+        )
+        kbs_response = self.get_knowledgebases(vendor=vendor, setting_id=setting_id)
+
+        for kb in kbs_response.data:
+            if kb.name == kb_name and kb.status == VendorKnowledgeBaseStatus.PREPARED:
+                logger.info(f"Found knowledge base: {kb.name} (ID: {kb.id})")
+                return kb
+
+        logger.warning(
+            f"Knowledge base '{kb_name}' not found for {vendor.value} setting {setting_id}"
+        )
+        return None
+
+    def find_first_available_knowledge_base(
+        self,
+        vendor: VendorType,
+        setting_id: str,
+    ) -> Optional[VendorKnowledgeBase]:
+        """Find the first prepared knowledge base.
+
+        Args:
+            vendor: Cloud vendor type
+            setting_id: ID of the vendor setting
+
+        Returns:
+            VendorKnowledgeBase or None if no prepared knowledge base found
+        """
+        logger.info(
+            f"Searching for prepared knowledge base in {vendor.value} setting {setting_id}"
+        )
+        kbs_response = self.get_knowledgebases(vendor=vendor, setting_id=setting_id)
+
+        for kb in kbs_response.data:
+            if kb.status == VendorKnowledgeBaseStatus.PREPARED:
+                logger.info(f"Found prepared knowledge base: {kb.name} (ID: {kb.id})")
+                return kb
+
+        logger.warning(
+            f"No prepared knowledge base found for {vendor.value} setting {setting_id}"
+        )
+        return None
+
+    def install_knowledge_base_by_name(
+        self,
+        vendor: VendorType,
+        setting_id: str,
+        kb_name: str,
+    ) -> Optional[str]:
+        """Find and install a knowledge base by name.
+
+        Args:
+            vendor: Cloud vendor type
+            setting_id: ID of the vendor setting
+            kb_name: Name of the knowledge base to install
+
+        Returns:
+            CodeMie ID of the installed knowledge base or None if not found
+        """
+        kb = self.find_knowledge_base_by_name(
+            vendor=vendor, setting_id=setting_id, kb_name=kb_name
+        )
+        if not kb:
+            return None
+
+        install_request = VendorKnowledgeBaseInstallRequest(
+            id=kb.id,
+            setting_id=setting_id,
+        )
+
+        install_response = self.install_knowledgebases(
+            vendor=vendor, knowledgebases=[install_request]
+        )
+
+        if install_response.summary:
+            return install_response.summary[0].aiRunId
+
+        return None
+
+    def install_first_available_knowledge_base(
+        self,
+        vendor: VendorType,
+        setting_id: str,
+    ) -> Optional[str]:
+        """Find and install the first available knowledge base.
+
+        Args:
+            vendor: Cloud vendor type
+            setting_id: ID of the vendor setting
+
+        Returns:
+            CodeMie ID of the installed knowledge base or None if not available
+        """
+        kb = self.find_first_available_knowledge_base(
+            vendor=vendor, setting_id=setting_id
+        )
+        if not kb:
+            return None
+
+        install_request = VendorKnowledgeBaseInstallRequest(
+            id=kb.id,
+            setting_id=setting_id,
+        )
+
+        install_response = self.install_knowledgebases(
+            vendor=vendor, knowledgebases=[install_request]
+        )
+
+        if install_response.summary:
+            return install_response.summary[0].aiRunId
+
+        return None

codemie_test_harness/tests/utils/vendor_workflow_utils.py

@@ -157,7 +157,7 @@ class VendorWorkflowUtils:
             workflows: List of workflow installation requests
 
         Returns:
-            VendorWorkflowInstallResponse containing installation summary with AI run IDs
+            VendorWorkflowInstallResponse containing installation summary with CodeMie IDs
         """
         logger.info(f"Installing {len(workflows)} workflow(s) for {vendor.value}")
         response = self.vendor_workflow_service.install_workflows(

codemie_test_harness/tests/vendor/assistants/test_vendor_assistants.py

@@ -1,6 +1,6 @@
 import pytest
 from hamcrest import assert_that, is_not, none, empty, is_
-from codemie_test_harness.tests.test_data.vendor_test_data import (
+from codemie_test_harness.tests.test_data.vendor_assistant_test_data import (
     vendor_assistant_test_data,
 )
 

codemie_test_harness/tests/vendor/knowledge_bases/__init__.py

@@ -0,0 +1 @@
+"""Tests for vendor knowledge base endpoints and functionality."""

codemie_test_harness/tests/vendor/knowledge_bases/test_vendor_knowledge_base_endpoints.py

@@ -0,0 +1,285 @@
+"""Tests for vendor knowledge base SDK endpoints.
+
+Architecture:
+- Parametrized tests that support multiple vendors (AWS, Azure, GCP)
+- Extensible design for easy addition of new vendors
+- Uses integration fixture factory for consistent setup
+- Each test validates a specific SDK endpoint
+"""
+
+import pytest
+from hamcrest import (
+    assert_that,
+    is_not,
+    none,
+    empty,
+    greater_than,
+    instance_of,
+    has_length,
+    is_,
+)
+from codemie_sdk.models.vendor_knowledgebase import (
+    VendorKnowledgeBaseSettingsResponse,
+    VendorKnowledgeBasesResponse,
+    VendorKnowledgeBaseDetail,
+    VendorKnowledgeBaseInstallRequest,
+    VendorKnowledgeBaseInstallResponse,
+    VendorKnowledgeBaseUninstallResponse,
+    VendorKnowledgeBaseStatus,
+)
+from codemie_test_harness.tests.test_data.vendor_endpoint_test_data import (
+    vendor_endpoint_test_data,
+)
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials",
+    vendor_endpoint_test_data,
+)
+def test_get_knowledgebase_settings(
+    vendor_knowledge_base_utils, integration, vendor_type, credential_type, credentials
+):
+    """Test GET /v1/vendors/{vendor}/knowledge-bases/settings endpoint."""
+    _integration = integration(credential_type, credentials)
+
+    settings_response = vendor_knowledge_base_utils.get_knowledgebase_settings(
+        vendor=vendor_type
+    )
+
+    assert_that(settings_response, instance_of(VendorKnowledgeBaseSettingsResponse))
+    assert_that(settings_response.data, is_not(none()))
+    assert_that(settings_response.pagination, is_not(none()))
+    assert_that(settings_response.data, is_not(empty()))
+    assert_that(settings_response.pagination.total, greater_than(0))
+
+    created_setting = vendor_knowledge_base_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(created_setting, is_not(none()))
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials",
+    vendor_endpoint_test_data,
+)
+def test_get_knowledgebases(
+    vendor_knowledge_base_utils, integration, vendor_type, credential_type, credentials
+):
+    """Test GET /v1/vendors/{vendor}/knowledge-bases endpoint."""
+    _integration = integration(credential_type, credentials)
+
+    setting = vendor_knowledge_base_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(setting, is_not(none()))
+
+    kbs_response = vendor_knowledge_base_utils.get_knowledgebases(
+        vendor=vendor_type,
+        setting_id=setting.setting_id,
+    )
+
+    assert_that(kbs_response, instance_of(VendorKnowledgeBasesResponse))
+    assert_that(kbs_response.data, is_not(none()))
+    assert_that(kbs_response.pagination, is_not(none()))
+    assert_that(kbs_response.data, is_not(empty()))
+
+    _kb = vendor_knowledge_base_utils.get_available_knowledge_base(kbs_response.data)
+
+    assert_that(_kb.id, is_not(none()))
+    assert_that(_kb.name, is_not(none()))
+    assert_that(_kb.status, is_(VendorKnowledgeBaseStatus.PREPARED))
+    assert_that(_kb.description, is_not(none()))
+    assert_that(_kb.updatedAt, is_not(none()))
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials",
+    vendor_endpoint_test_data,
+)
+def test_get_knowledgebase(
+    vendor_knowledge_base_utils, integration, vendor_type, credential_type, credentials
+):
+    """Test GET /v1/vendors/{vendor}/knowledge-bases/{knowledgebase_id} endpoint."""
+    _integration = integration(credential_type, credentials)
+
+    setting = vendor_knowledge_base_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(setting, is_not(none()))
+
+    kbs_response = vendor_knowledge_base_utils.get_knowledgebases(
+        vendor=vendor_type,
+        setting_id=setting.setting_id,
+    )
+    assert_that(kbs_response.data, is_not(empty()))
+
+    first_kb = vendor_knowledge_base_utils.get_available_knowledge_base(
+        kbs_response.data
+    )
+
+    _kb = vendor_knowledge_base_utils.get_knowledgebase(
+        vendor=vendor_type,
+        knowledgebase_id=first_kb.id,
+        setting_id=setting.setting_id,
+    )
+
+    assert_that(_kb, instance_of(VendorKnowledgeBaseDetail))
+    assert_that(_kb.id, is_(first_kb.id))
+    assert_that(_kb.name, is_not(none()))
+    assert_that(_kb.status, is_(VendorKnowledgeBaseStatus.PREPARED))
+    assert_that(_kb.description, is_not(none()))
+    assert_that(_kb.updatedAt, is_not(none()))
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials",
+    vendor_endpoint_test_data,
+)
+def test_install_knowledgebases(
+    vendor_knowledge_base_utils, integration, vendor_type, credential_type, credentials
+):
+    """Test POST /v1/vendors/{vendor}/knowledge-bases endpoint."""
+    _integration = integration(credential_type, credentials)
+
+    setting = vendor_knowledge_base_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(setting, is_not(none()))
+
+    kb = vendor_knowledge_base_utils.find_first_available_knowledge_base(
+        vendor=vendor_type,
+        setting_id=setting.setting_id,
+    )
+    assert_that(kb, is_not(none()))
+
+    install_request = VendorKnowledgeBaseInstallRequest(
+        id=kb.id,
+        setting_id=setting.setting_id,
+    )
+
+    install_response = vendor_knowledge_base_utils.install_knowledgebases(
+        vendor=vendor_type,
+        knowledgebases=[install_request],
+    )
+
+    assert_that(install_response, instance_of(VendorKnowledgeBaseInstallResponse))
+    assert_that(install_response.summary, is_not(empty()))
+    assert_that(install_response.summary, has_length(1))
+
+    installed = install_response.summary[0]
+    assert_that(installed.knowledgeBaseId, is_(kb.id))
+    assert_that(installed.aiRunId, is_not(none()))
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials",
+    vendor_endpoint_test_data,
+)
+def test_uninstall_knowledgebase(
+    vendor_knowledge_base_utils, integration, vendor_type, credential_type, credentials
+):
+    """Test DELETE /v1/vendors/{vendor}/knowledge-bases/{ai_run_id} endpoint."""
+    _integration = integration(credential_type, credentials)
+
+    setting = vendor_knowledge_base_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(setting, is_not(none()))
+
+    codemie_id = vendor_knowledge_base_utils.install_first_available_knowledge_base(
+        vendor=vendor_type,
+        setting_id=setting.setting_id,
+    )
+    assert_that(codemie_id, is_not(none()))
+
+    uninstall_response = vendor_knowledge_base_utils.uninstall_knowledgebase(
+        vendor=vendor_type,
+        codemie_id=codemie_id,
+    )
+
+    assert_that(uninstall_response, instance_of(VendorKnowledgeBaseUninstallResponse))
+    assert_that(uninstall_response.success, is_(True))
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials",
+    vendor_endpoint_test_data,
+)
+def test_get_knowledgebase_settings_pagination(
+    vendor_knowledge_base_utils, integration, vendor_type, credential_type, credentials
+):
+    """Test pagination functionality for get_knowledgebase_settings endpoint."""
+    first_page = vendor_knowledge_base_utils.get_knowledgebase_settings(
+        vendor=vendor_type,
+        page=0,
+        per_page=2,
+    )
+
+    assert_that(first_page.pagination.page, is_(0))
+    assert_that(first_page.pagination.per_page, is_(2))
+    assert_that(first_page.pagination.total, greater_than(0))
+
+    if first_page.pagination.pages > 1:
+        second_page = vendor_knowledge_base_utils.get_knowledgebase_settings(
+            vendor=vendor_type,
+            page=1,
+            per_page=2,
+        )
+        assert_that(second_page.pagination.page, is_(1))
+        assert_that(second_page.data, is_not(empty()))
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials",
+    vendor_endpoint_test_data,
+)
+def test_get_knowledgebases_pagination(
+    vendor_knowledge_base_utils, integration, vendor_type, credential_type, credentials
+):
+    """Test pagination functionality for get_knowledgebases endpoint using next_token."""
+    _integration = integration(credential_type, credentials)
+
+    setting = vendor_knowledge_base_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(setting, is_not(none()))
+
+    first_page = vendor_knowledge_base_utils.get_knowledgebases(
+        vendor=vendor_type,
+        setting_id=setting.setting_id,
+        per_page=2,
+    )
+
+    assert_that(first_page.data, is_not(empty()))
+
+    if first_page.pagination.next_token:
+        second_page = vendor_knowledge_base_utils.get_knowledgebases(
+            vendor=vendor_type,
+            setting_id=setting.setting_id,
+            per_page=2,
+            next_token=first_page.pagination.next_token,
+        )
+        assert_that(second_page.data, is_not(empty()))
+        first_page_ids = {kb.id for kb in first_page.data}
+        second_page_ids = {kb.id for kb in second_page.data}
+        assert_that(first_page_ids.intersection(second_page_ids), is_(set()))

codemie_test_harness/tests/vendor/knowledge_bases/test_vendor_knowledge_bases.py

@@ -0,0 +1,123 @@
+"""Integration tests for vendor knowledge bases with CodeMie assistants."""
+
+import pytest
+from hamcrest import assert_that, is_not, none, is_
+
+from codemie_test_harness.tests.test_data.vendor_knowledge_base_test_data import (
+    vendor_knowledge_base_test_data,
+    vendor_assistant_with_kb_test_data,
+)
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials,prompt,expected_response",
+    vendor_knowledge_base_test_data,
+)
+def test_codemie_assistant_with_vendor_knowledgebase(
+    vendor_knowledge_base_utils,
+    integration,
+    assistant,
+    assistant_utils,
+    similarity_check,
+    kb_context,
+    client,
+    vendor_type,
+    credential_type,
+    credentials,
+    prompt,
+    expected_response,
+):
+    """Test CodeMie assistant with vendor knowledge base integration."""
+    _integration = integration(credential_type, credentials)
+
+    setting = vendor_knowledge_base_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(setting, is_not(none()))
+    assert_that(setting.invalid or False, is_(False))
+
+    codemie_kb_id = vendor_knowledge_base_utils.install_first_available_knowledge_base(
+        vendor=vendor_type,
+        setting_id=setting.setting_id,
+    )
+    assert_that(codemie_kb_id, is_not(none()))
+
+    datasource = client.datasources.get(codemie_kb_id)
+    assert_that(datasource, is_not(none()))
+
+    created_assistant = assistant(
+        context=kb_context(datasource),
+        system_prompt="You are a helpful assistant. Use the knowledge base to answer questions.",
+    )
+
+    response = assistant_utils.ask_assistant(
+        assistant=created_assistant,
+        user_prompt=prompt,
+        minimal_response=True,
+    )
+
+    similarity_check.check_similarity(response, expected_response)
+
+    uninstall_response = vendor_knowledge_base_utils.uninstall_knowledgebase(
+        vendor=vendor_type,
+        codemie_id=codemie_kb_id,
+    )
+    assert_that(uninstall_response.success, is_(True))
+
+
+@pytest.mark.vendor
+@pytest.mark.api
+@pytest.mark.parametrize(
+    "vendor_type,credential_type,credentials,assistant_name,prompt,expected_response",
+    vendor_assistant_with_kb_test_data,
+)
+def test_vendor_assistant_with_knowledgebase(
+    vendor_assistant_utils,
+    integration,
+    assistant_utils,
+    similarity_check,
+    vendor_type,
+    credential_type,
+    credentials,
+    assistant_name,
+    prompt,
+    expected_response,
+):
+    """Test vendor assistant with knowledge base already attached."""
+    _integration = integration(credential_type, credentials)
+
+    setting = vendor_assistant_utils.find_setting_for_integration(
+        vendor=vendor_type,
+        integration_id=_integration.id,
+    )
+    assert_that(setting, is_not(none()))
+    assert_that(setting.invalid or False, is_(False))
+
+    codemie_id = vendor_assistant_utils.install_assistant_by_name(
+        vendor=vendor_type,
+        setting_id=setting.setting_id,
+        assistant_name=assistant_name,
+    )
+    assert_that(codemie_id, is_not(none()))
+
+    class AssistantIdWrapper:
+        def __init__(self, assistant_id):
+            self.id = assistant_id
+
+    assistant_wrapper = AssistantIdWrapper(codemie_id)
+    response = assistant_utils.ask_assistant(
+        assistant=assistant_wrapper,
+        user_prompt=prompt,
+        minimal_response=True,
+    )
+
+    similarity_check.check_similarity(response, expected_response)
+
+    uninstall_response = vendor_assistant_utils.uninstall_assistant(
+        vendor=vendor_type,
+        codemie_id=codemie_id,
+    )
+    assert_that(uninstall_response.success, is_(True))

codemie_test_harness/tests/vendor/workflows/test_vendor_workflows.py

@@ -54,7 +54,7 @@ def test_vendor_workflow_installation_and_execution(
         user_input=user_input,
     )
 
-    similarity_check.check_similarity(response, expected_response)
+    similarity_check.check_similarity(response, expected_response, similarity_rank=50)
 
     uninstall_response = vendor_workflow_utils.uninstall_workflow(
         vendor=vendor_type,

{codemie_test_harness-0.1.224.dist-info → codemie_test_harness-0.1.226.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codemie-test-harness
-Version: 0.1.224
+Version: 0.1.226
 Summary: Autotest for CodeMie backend and UI
 Author: Anton Yeromin
 Author-email: anton_yeromin@epam.com
@@ -13,7 +13,7 @@ Requires-Dist: aws-assume-role-lib (>=2.10.0,<3.0.0)
 Requires-Dist: boto3 (>=1.39.8,<2.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: codemie-plugins (>=0.1.123,<0.2.0)
-Requires-Dist: codemie-sdk-python (==0.1.224)
+Requires-Dist: codemie-sdk-python (==0.1.226)
 Requires-Dist: pytest (>=8.4.1,<9.0.0)
 Requires-Dist: pytest-playwright (>=0.7.0,<0.8.0)
 Requires-Dist: pytest-repeat (>=0.9.3,<0.10.0)

{codemie_test_harness-0.1.224.dist-info → codemie_test_harness-0.1.226.dist-info}/RECORD

@@ -65,7 +65,7 @@ codemie_test_harness/tests/assistant/tools/servicenow/__init__.py,sha256=47DEQpj
 codemie_test_harness/tests/assistant/tools/servicenow/test_servicenow_tools.py,sha256=aUjfZ4773WoQJjcHx3JqH5e8ckaKB-aIMO-OZWTm0Ek,888
 codemie_test_harness/tests/assistant/tools/vcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codemie_test_harness/tests/assistant/tools/vcs/test_assistant_with_vcs_tools.py,sha256=qOPr4XOh2rgUV2MXMxkRzRGkAKl9ViwQGCZ-dMEtscU,1145
-codemie_test_harness/tests/conftest.py,sha256=oFH8KXi67CR1sRchq71u-eTFOyHown9W1Bp-wuGwc5E,34463
+codemie_test_harness/tests/conftest.py,sha256=ZfngRtxFi004c831e1cFkaj0S15pIHd4nRRoqf92nS0,34805
 codemie_test_harness/tests/conversations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codemie_test_harness/tests/conversations/test_conversations_endpoints.py,sha256=HQ2nu9lXfRNkyJhA0rzar7Rmv6pMe-te0rFYAy-X5UA,4128
 codemie_test_harness/tests/e2e/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -170,9 +170,10 @@ codemie_test_harness/tests/test_data/report_portal_tools_test_data.py,sha256=YZd
 codemie_test_harness/tests/test_data/research_tools_test_data.py,sha256=zwpzm-VSnrLZEfG97AE9Ms7z7j3xmqxiNd1EmZyWCSk,9102
 codemie_test_harness/tests/test_data/servicenow_tools_test_data.py,sha256=PKw9zEYSNcQM1KApCSjsBiA_3Py0bNQI7clqw8cmT-s,1983
 codemie_test_harness/tests/test_data/vcs_tools_test_data.py,sha256=ZJdday96uOKOy_kPRBPp0w9JZbf0il7Y_hPfwRmUkuM,4518
+codemie_test_harness/tests/test_data/vendor_assistant_test_data.py,sha256=FFS35ikzMzSHShnfmdIme-WjueSjj0qBwa0OU6ooKfc,1409
 codemie_test_harness/tests/test_data/vendor_endpoint_test_data.py,sha256=Fti3ZbpS3m06Heyh5AAcoAKZuimX709iZQFPhzKvrC4,1075
-codemie_test_harness/tests/test_data/vendor_test_data.py,sha256=FFS35ikzMzSHShnfmdIme-WjueSjj0qBwa0OU6ooKfc,1409
-codemie_test_harness/tests/test_data/vendor_workflow_test_data.py,sha256=hZX_GpIz0RIjSuqvgCh_Sv5zwk4-iatP1J-SIKCL8cg,1588
+codemie_test_harness/tests/test_data/vendor_knowledge_base_test_data.py,sha256=mWrtao3VOU5gO3_k-eiiVB4og_DtqBYkwcASPuCbysM,3401
+codemie_test_harness/tests/test_data/vendor_workflow_test_data.py,sha256=xcemVCa2i5SR1qJMNGQ2iND1e0kizdtG4Qh1M_xy9bA,4649
 codemie_test_harness/tests/test_data/workflow/invalid_config/invalid_assistant_id.yaml,sha256=_cioQNq3icemob9u0i-hXkTy2nflzyP0Ce8FWiPG14M,265
 codemie_test_harness/tests/test_data/workflow/invalid_config/invalid_assistant_in_state.yaml,sha256=t_W95zD5bfdGf3F6p64-2qBHz7SkL_7mFT675uieWZg,209
 codemie_test_harness/tests/test_data/workflow/invalid_config/invalid_data_source.yaml,sha256=Vwx3HyrQkL8sWNtfwL6d0qiJhru6X3ojKBASAzJeY9w,252
@@ -298,18 +299,22 @@ codemie_test_harness/tests/utils/pytest_utils.py,sha256=k-mEjX2qpnh37sqKpJqYhZT6
 codemie_test_harness/tests/utils/search_utils.py,sha256=SrXiB2d9wiI5ka9bgg0CD73GOX_1mqi2Hz5FBm5DsEU,1435
 codemie_test_harness/tests/utils/similarity_check.py,sha256=2URqvD3Ft7efwLmhh2iYVsXrYboP9f-_B_ekZmJn0ac,1527
 codemie_test_harness/tests/utils/user_utils.py,sha256=zJNrmL3Fb7iGuaVRobUMwJ2Og6NqEPcM_9lw60m18T8,242
-codemie_test_harness/tests/utils/vendor_utils.py,sha256=976qSTUOBIwg0Rvnw_Zg5YP8gFAr41jbVMk0EvXzVSU,11055
-codemie_test_harness/tests/utils/vendor_workflow_utils.py,sha256=97s7pz9fYRkztK4FrFNfV33ASANiE_C0QOyt8iMgACM,13595
+codemie_test_harness/tests/utils/vendor_assistant_utils.py,sha256=r8g6Vara_aUNWL1GnmcM9ESta2Qtny1B4XgWhYjY63k,13761
+codemie_test_harness/tests/utils/vendor_knowledge_base_utils.py,sha256=UXBM1GLfbD9oqaj--jeFFcKlzG_NnElPJjJ1imQmaec,11274
+codemie_test_harness/tests/utils/vendor_workflow_utils.py,sha256=X2v_keH94BBI6vQBgPWTl9kR8a2oy9xW0LolK-clGTY,13596
 codemie_test_harness/tests/utils/webhook_utils.py,sha256=YjyLwAqQjR12vYFOUmYhJCJIyZvKm4SvU-1oIjIYNqg,340
 codemie_test_harness/tests/utils/workflow_utils.py,sha256=bHxPQkblRPF1fZp_AXI36elMFm14nzqGYoU5Eqz4MWY,11553
 codemie_test_harness/tests/utils/yaml_utils.py,sha256=iIdEl-rUUh1LgzAmD_mjfftthhvlzXyCuA37yBoH0Gw,1617
 codemie_test_harness/tests/vendor/__init__.py,sha256=7kcktgm5ZkmcVLRX2mTRhGzVzFpVR_rcgYUbhKe-3q0,71
 codemie_test_harness/tests/vendor/assistants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-codemie_test_harness/tests/vendor/assistants/test_vendor_assistants.py,sha256=8ubDiB2YlCTuck8aD2MvgOhSWthfjEyZ8k8iqDqL5f8,1957
+codemie_test_harness/tests/vendor/assistants/test_vendor_assistants.py,sha256=whgbSHDP2qjuW4gG_zo4k_aQxcMQsgfF2yqDP_IBkUE,1967
 codemie_test_harness/tests/vendor/assistants/test_vendor_assistants_endpoints.py,sha256=XA9idTm6ZycoKCTGq31QpL_BeybgQa7dFC3RSqAPtec,13271
+codemie_test_harness/tests/vendor/knowledge_bases/__init__.py,sha256=CiKEVPKSbGvB8UqpmISTAl6ohztOrrAdfFQpzNSToIc,67
+codemie_test_harness/tests/vendor/knowledge_bases/test_vendor_knowledge_base_endpoints.py,sha256=GNehIqybcBAIW_jA4pYV0DrHidMz6LgHOksZ0-AaOp0,9426
+codemie_test_harness/tests/vendor/knowledge_bases/test_vendor_knowledge_bases.py,sha256=sRejPbm9QIyQIVKBGgOxy6KcpFi888WccaWzTXRjTJc,3652
 codemie_test_harness/tests/vendor/workflows/__init__.py,sha256=qcP6VHdlR6qbNhjrqRGHE5JReIj4CH0WGlMvpKgm1aM,38
 codemie_test_harness/tests/vendor/workflows/test_vendor_workflow_endpoints.py,sha256=dkCmFPKj-sIVgbuaqQ2Ef7JBKUWGTftW9xZB3D1KCrU,11236
-codemie_test_harness/tests/vendor/workflows/test_vendor_workflows.py,sha256=BVHWU9RN5Wn6XzXbRxo5Lod28GV7mPkbQSkErC-OUY4,1813
+codemie_test_harness/tests/vendor/workflows/test_vendor_workflows.py,sha256=sHMbfc6-uG0nYFtp0CBIyyGFs8DbRdux-WfD4lWsKB8,1833
 codemie_test_harness/tests/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codemie_test_harness/tests/webhook/test_webhook_service.py,sha256=POmxQG0tpcNW9-yKQ62CcnQpUEFYlTOs0_4H9MijIHY,8127
 codemie_test_harness/tests/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -417,7 +422,7 @@ codemie_test_harness/tests/workflow/virtual_assistant_tools/servicenow/__init__.
 codemie_test_harness/tests/workflow/virtual_assistant_tools/servicenow/test_workflow_with_servicenow_tools.py,sha256=D835gaRbCnB4va5mi9TdA_u9StSpGXQ_fgzwW0S2pwo,1173
 codemie_test_harness/tests/workflow/virtual_assistant_tools/vcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codemie_test_harness/tests/workflow/virtual_assistant_tools/vcs/test_workflow_with_vcs_tools.py,sha256=Se9imIiBYuJU78m1pLu0g4ZmHygKZjr6JjIWkGXTy1Q,1364
-codemie_test_harness-0.1.224.dist-info/METADATA,sha256=KLYh0W0-VBL1mczrRSYQfDBmREphumnAb6AcTFvHKjE,27184
-codemie_test_harness-0.1.224.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-codemie_test_harness-0.1.224.dist-info/entry_points.txt,sha256=n98t-EOM5M1mnMl_j2X4siyeO9zr0WD9a5LF7JyElIM,73
-codemie_test_harness-0.1.224.dist-info/RECORD,,
+codemie_test_harness-0.1.226.dist-info/METADATA,sha256=iz3R84OYZ7pyNiD8xyzf8CyL_TrBay_sLamMH_g5Kr8,27184
+codemie_test_harness-0.1.226.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+codemie_test_harness-0.1.226.dist-info/entry_points.txt,sha256=n98t-EOM5M1mnMl_j2X4siyeO9zr0WD9a5LF7JyElIM,73
+codemie_test_harness-0.1.226.dist-info/RECORD,,