alita-sdk 0.3.229__tar.gz → 0.3.231__tar.gz

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.229
+Version: 0.3.231
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0
@@ -181,7 +181,7 @@ venv\Scripts\activate
 Install all required dependencies for the SDK and toolkits:
 
 ```bash
-pip install -r req_bkup/requirements-all.txt
+pip install -U '.[all]'
 ```
 
 Environment Setup

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/README.md

@@ -36,7 +36,7 @@ venv\Scripts\activate
 Install all required dependencies for the SDK and toolkits:
 
 ```bash
-pip install -r req_bkup/requirements-all.txt
+pip install -U '.[all]'
 ```
 
 Environment Setup

alita_sdk-0.3.231/alita_sdk/runtime/langchain/document_loaders/AlitaDocLoader.py

@@ -0,0 +1,29 @@
+from langchain_core.document_loaders import BaseLoader
+from langchain_core.documents import Document
+
+from .utils import file_to_bytes
+
+
+class AlitaDocLoader(BaseLoader):
+
+    def __init__(self, **kwargs):
+        if kwargs.get('file_path'):
+            self.file_path = kwargs['file_path']
+        elif kwargs.get('file_content'):
+            self.file_content = kwargs['file_content']
+            self.file_name = kwargs['file_name']
+        else:
+            raise ValueError(
+                "Path parameter is required (either as 'file_path' positional argument or 'path' keyword argument)")
+
+    def load(self):
+        result_content = self.get_content()
+        return [Document(page_content=result_content, metadata={'source': str(self.file_path if hasattr(self, 'file_path') else self.file_name)})]
+
+    def get_content(self):
+        try:
+            import textract
+            content = textract.process(None, extension='doc', input_data=self.file_content if hasattr(self, 'file_content') else file_to_bytes(self.file_path)).decode('utf-8')
+        except Exception as e:
+            content = f"[Error extracting doc: {str(e)}]"
+        return content

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -18,6 +18,7 @@ from langchain_community.document_loaders import (
         UnstructuredPowerPointLoader, PythonLoader)
 
 from .AlitaCSVLoader import AlitaCSVLoader
+from .AlitaDocLoader import AlitaDocLoader
 from .AlitaDocxMammothLoader import AlitaDocxMammothLoader
 from .AlitaExcelLoader import AlitaExcelLoader
 from .AlitaImageLoader import AlitaImageLoader
@@ -124,6 +125,11 @@ loaders_map = {
         'is_multimodal_processing': True,
         'kwargs': {}
     },
+    '.doc': {
+        'class': AlitaDocLoader,
+        'is_multimodal_processing': True,
+        'kwargs': {}
+    },
     '.json': {
         'class': AlitaTextLoader,
         'is_multimodal_processing': False,

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/alita_sdk/runtime/langchain/document_loaders/utils.py

@@ -60,4 +60,25 @@ def create_temp_file(file_content: bytes):
         temp_file.flush()  # Ensure data is written
 
         # Get the file path for operations
-        return temp_file.name
+        return temp_file.name
+
+def file_to_bytes(filepath):
+    """
+    Reads a file and returns its content as a bytes object.
+
+    Args:
+        filepath (str): The path to the file.
+
+    Returns:
+        bytes: The content of the file as a bytes object.
+    """
+    try:
+        with open(filepath, "rb") as f:
+            file_content_bytes = f.read()
+        return file_content_bytes
+    except FileNotFoundError:
+        logger.error(f"File not found: {filepath}")
+        return None
+    except Exception as e:
+        logger.error(f"Error reading file {filepath}: {e}")
+        return None

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/alita_sdk/runtime/tools/vectorstore.py

@@ -210,38 +210,48 @@ class VectorStoreWrapper(BaseToolApiWrapper):
             tool_name="_remove_collection"
         )
 
-    def _get_indexed_ids(self, store):
+    def _get_indexed_ids(self, collection_suffix: Optional[str] = '') -> List[str]:
         """Get all indexed document IDs from vectorstore"""
 
         # Check if this is a PGVector store
-        if hasattr(store, 'session_maker') and hasattr(store, 'EmbeddingStore'):
-            return self._get_pgvector_indexed_ids(store)
+        if self._is_pgvector():
+            return self._get_pgvector_indexed_ids(collection_suffix)
         else:
             # Fall back to Chroma implementation
-            return self._get_chroma_indexed_ids(store)
+            # TODO: update filter by collection_suffix for Chroma
+            return self._get_chroma_indexed_ids(collection_suffix)
 
-    def _get_pgvector_indexed_ids(self, store):
+    def _get_pgvector_indexed_ids(self, collection_suffix: Optional[str] = ''):
         """Get all indexed document IDs from PGVector"""
         from sqlalchemy.orm import Session
+        from sqlalchemy import func
 
+        store = self.vectorstore
         try:
             with Session(store.session_maker.bind) as session:
-                ids = session.query(store.EmbeddingStore.id).all()
-            return [str(id_tuple[0]) for id_tuple in ids]
+                # Start building the query
+                query = session.query(store.EmbeddingStore.id)
+                # Apply filter only if collection_suffix is provided
+                if collection_suffix:
+                    query = query.filter(
+                        func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection') == collection_suffix
+                    )
+                ids = query.all()
+                return [str(id_tuple[0]) for id_tuple in ids]
         except Exception as e:
             logger.error(f"Failed to get indexed IDs from PGVector: {str(e)}")
             return []
 
-    def _get_chroma_indexed_ids(self, store):
+    def _get_chroma_indexed_ids(self, collection_suffix: Optional[str] = ''):
         """Get all indexed document IDs from Chroma"""
         try:
-            data = store.get(include=[])  # Only get IDs, no metadata
+            data = self.vectorstore.get(include=[])  # Only get IDs, no metadata
             return data.get('ids', [])
         except Exception as e:
             logger.error(f"Failed to get indexed IDs from Chroma: {str(e)}")
             return []
 
-    def _clean_collection(self):
+    def _clean_collection(self, collection_suffix: str = ''):
         """
         Clean the vectorstore collection by deleting all indexed data.
         """
@@ -251,33 +261,37 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         )
         # This logic deletes all data from the vectorstore collection without removal of collection.
         # Collection itself remains available for future indexing.
-        self.vectoradapter.vectorstore.delete(ids=self._get_indexed_ids(self.vectoradapter.vectorstore))
+        self.vectorstore.delete(ids=self._get_indexed_ids(collection_suffix))
 
         self._log_data(
             f"Collection '{self.dataset}' has been cleaned. ",
             tool_name="_clean_collection"
         )
 
+    def _is_pgvector(self) -> bool:
+        """Check if the vectorstore is a PGVector store."""
+        return hasattr(self.vectorstore, 'session_maker') and hasattr(self.vectorstore, 'EmbeddingStore')
+
     # TODO: refactor to use common method for different vectorstores in a separate vectorstore wrappers
-    def _get_indexed_data(self, store):
+    def _get_indexed_data(self):
         """ Get all indexed data from vectorstore for non-code content """
 
         # Check if this is a PGVector store
-        if hasattr(store, 'session_maker') and hasattr(store, 'EmbeddingStore'):
-            return self._get_pgvector_indexed_data(store)
+        if self._is_pgvector():
+            return self._get_pgvector_indexed_data()
         else:
             # Fall back to original Chroma implementation
-            return self._get_chroma_indexed_data(store)
+            return self._get_chroma_indexed_data(self.vectorstore)
 
-    def _get_pgvector_indexed_data(self, store):
+    def _get_pgvector_indexed_data(self):
         """ Get all indexed data from PGVector for non-code content """
         from sqlalchemy.orm import Session
 
         result = {}
         try:
             self._log_data("Retrieving already indexed data from PGVector vectorstore",
-                           tool_name="index_documents")
-
+                           tool_name="get_indexed_data")
+            store = self.vectorstore
             with Session(store.session_maker.bind) as session:
                 docs = session.query(
                     store.EmbeddingStore.id,
@@ -320,7 +334,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         result = {}
         try:
             self._log_data("Retrieving already indexed data from Chroma vectorstore",
-                           tool_name="index_documents")
+                           tool_name="get_indexed_data")
             data = store.get(include=['metadatas'])
 
             # Re-structure data to be more usable
@@ -349,21 +363,63 @@ class VectorStoreWrapper(BaseToolApiWrapper):
 
         return result
 
-    def _get_code_indexed_data(self, store) -> Dict[str, Dict[str, Any]]:
+    def _get_code_indexed_data(self) -> Dict[str, Dict[str, Any]]:
         """ Get all indexed data from vectorstore for code content """
 
         # get already indexed data
+        if self._is_pgvector():
+            result = self._get_pgvector_code_indexed_data()
+        else:
+            result = self._get_chroma_code_indexed_data()
+        return result
+
+    def _get_chroma_code_indexed_data(self) -> Dict[str, Dict[str, Any]]:
+        """Get all indexed code data from Chroma."""
         result = {}
         try:
-            self._log_data("Retrieving already indexed code data from vectorstore",
-                           tool_name="index_documents")
-            data = store.get(include=['metadatas'])
-            # re-structure data to be more usable
+            self._log_data("Retrieving already indexed code data from Chroma vectorstore",
+                           tool_name="index_code_data")
+            data = self.vectorstore.get(include=['metadatas'])
             for meta, db_id in zip(data['metadatas'], data['ids']):
-                filename = meta['filename']
+                filename = meta.get('filename')
+                commit_hash = meta.get('commit_hash')
+                if not filename:
+                    continue
+                if filename not in result:
+                    result[filename] = {
+                        'commit_hashes': [],
+                        'ids': []
+                    }
+                if commit_hash is not None:
+                    result[filename]['commit_hashes'].append(commit_hash)
+                result[filename]['ids'].append(db_id)
+        except Exception as e:
+            logger.error(f"Failed to get indexed code data from Chroma: {str(e)}. Continuing with empty index.")
+        return result
+
+    def _get_pgvector_code_indexed_data(self) -> Dict[str, Dict[str, Any]]:
+        """Get all indexed code data from PGVector."""
+        from sqlalchemy.orm import Session
+
+        result = {}
+        try:
+            self._log_data("Retrieving already indexed code data from PGVector vectorstore",
+                           tool_name="index_code_data")
+            store = self.vectorstore
+            with Session(store.session_maker.bind) as session:
+                docs = session.query(
+                    store.EmbeddingStore.id,
+                    store.EmbeddingStore.cmetadata
+                ).all()
+
+            for db_id, meta in docs:
+                filename = meta.get('filename')
                 commit_hash = meta.get('commit_hash')
+                if not filename:
+                    continue
                 if filename not in result:
                     result[filename] = {
+                        'metadata': meta,
                         'commit_hashes': [],
                         'ids': []
                     }
@@ -371,13 +427,64 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                     result[filename]['commit_hashes'].append(commit_hash)
                 result[filename]['ids'].append(db_id)
         except Exception as e:
-            logger.error(f"Failed to get indexed code data from vectorstore: {str(e)}. Continuing with empty index.")
+            logger.error(f"Failed to get indexed code data from PGVector: {str(e)}. Continuing with empty index.")
         return result
 
+
+    def _add_to_collection(self, entry_id, new_collection_value):
+        """Add a new collection name to the `collection` key in the `metadata` column."""
+
+        from sqlalchemy import func
+        from sqlalchemy.orm import Session
+
+        store = self.vectorstore
+        try:
+            with Session(store.session_maker.bind) as session:
+                # Query the current value of the `collection` key
+                current_collection_query = session.query(
+                    func.jsonb_extract_path_text(store.EmbeddingStore.cmetadata, 'collection')
+                ).filter(store.EmbeddingStore.id == entry_id).scalar()
+
+                # If the `collection` key is NULL or doesn't contain the new value, update it
+                if current_collection_query is None:
+                    # If `collection` is NULL, initialize it with the new value
+                    session.query(store.EmbeddingStore).filter(
+                        store.EmbeddingStore.id == entry_id
+                    ).update(
+                        {
+                            store.EmbeddingStore.cmetadata: func.jsonb_set(
+                                func.coalesce(store.EmbeddingStore.cmetadata, '{}'),
+                                '{collection}',  # Path to the `collection` key
+                                f'"{new_collection_value}"',  # New value for the `collection` key
+                                True  # Create the key if it doesn't exist
+                            )
+                        }
+                    )
+                elif new_collection_value not in current_collection_query.split(";"):
+                    # If `collection` exists but doesn't contain the new value, append it
+                    updated_collection_value = f"{current_collection_query};{new_collection_value}"
+                    session.query(store.EmbeddingStore).filter(
+                        store.EmbeddingStore.id == entry_id
+                    ).update(
+                        {
+                            store.EmbeddingStore.cmetadata: func.jsonb_set(
+                                store.EmbeddingStore.cmetadata,
+                                '{collection}',  # Path to the `collection` key
+                                f'"{updated_collection_value}"',  # Concatenated value as a valid JSON string
+                                True  # Create the key if it doesn't exist
+                            )
+                        }
+                    )
+
+                session.commit()
+                logger.info(f"Successfully updated collection for entry ID {entry_id}.")
+        except Exception as e:
+            logger.error(f"Failed to update collection for entry ID {entry_id}: {str(e)}")
+
     def _reduce_duplicates(
             self,
             documents: Generator[Any, None, None],
-            store,
+            collection_suffix: str,
             get_indexed_data: Callable,
             key_fn: Callable,
             compare_fn: Callable,
@@ -386,7 +493,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
     ) -> List[Any]:
         """Generic duplicate reduction logic for documents."""
         self._log_data(log_msg, tool_name="index_documents")
-        indexed_data = get_indexed_data(store)
+        indexed_data = get_indexed_data()
         indexed_keys = set(indexed_data.keys())
         if not indexed_keys:
             self._log_data("Vectorstore is empty, indexing all incoming documents", tool_name="index_documents")
@@ -397,8 +504,15 @@ class VectorStoreWrapper(BaseToolApiWrapper):
 
         for document in documents:
             key = key_fn(document)
-            if key in indexed_keys:
+            if key in indexed_keys and collection_suffix == indexed_data[key]['metadata'].get('collection'):
                 if compare_fn(document, indexed_data[key]):
+                    # Disabled addition of new collection to already indexed documents
+                    # # check metadata.collection and update if needed
+                    # for update_collection_id in remove_ids_fn(indexed_data, key):
+                    #     self._add_to_collection(
+                    #         update_collection_id,
+                    #         collection_suffix
+                    #     )
                     continue
                 final_docs.append(document)
                 docs_to_remove.update(remove_ids_fn(indexed_data, key))
@@ -410,14 +524,14 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 f"Removing {len(docs_to_remove)} documents from vectorstore that are already indexed with different updated_on.",
                 tool_name="index_documents"
             )
-            store.delete(ids=list(docs_to_remove))
+            self.vectorstore.delete(ids=list(docs_to_remove))
 
         return final_docs
 
-    def _reduce_non_code_duplicates(self, documents: Generator[Any, None, None], store) -> List[Any]:
+    def _reduce_non_code_duplicates(self, documents: Generator[Any, None, None], collection_suffix: str) -> List[Any]:
         return self._reduce_duplicates(
             documents,
-            store,
+            collection_suffix,
             self._get_indexed_data,
             lambda doc: doc.metadata.get('id'),
             lambda doc, idx: (
@@ -434,10 +548,10 @@ class VectorStoreWrapper(BaseToolApiWrapper):
             log_msg="Verification of documents to index started"
         )
 
-    def _reduce_code_duplicates(self, documents: Generator[Any, None, None], store) -> List[Any]:
+    def _reduce_code_duplicates(self, documents: Generator[Any, None, None], collection_suffix: str) -> List[Any]:
         return self._reduce_duplicates(
             documents,
-            store,
+            collection_suffix,
             self._get_code_indexed_data,
             lambda doc: doc.metadata.get('filename'),
             lambda doc, idx: (
@@ -449,7 +563,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
             log_msg="Verification of code documents to index started"
         )
 
-    def index_documents(self, documents: Generator[Document, None, None], progress_step: int = 20, clean_index: bool = True, is_code: bool = False):
+    def index_documents(self, documents: Generator[Document, None, None], collection_suffix: str, progress_step: int = 20, clean_index: bool = True, is_code: bool = False):
         """ Index documents in the vectorstore.
 
         Args:
@@ -465,7 +579,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
             logger.info("Cleaning index before re-indexing all documents.")
             self._log_data("Cleaning index before re-indexing all documents. Previous index will be removed", tool_name="index_documents")
             try:
-                self._clean_collection()
+                self._clean_collection(collection_suffix)
                 self.vectoradapter.persist()
                 self.vectoradapter.vacuum()
                 self._log_data("Previous index has been removed",
@@ -476,8 +590,8 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 documents = list(documents)
         else:
             # remove duplicates based on metadata 'id' and 'updated_on' or 'commit_hash' fields
-            documents = self._reduce_code_duplicates(documents, self.vectoradapter.vectorstore) if is_code \
-                else self._reduce_non_code_duplicates(documents, self.vectoradapter.vectorstore)
+            documents = self._reduce_code_duplicates(documents, collection_suffix) if is_code \
+                else self._reduce_non_code_duplicates(documents, collection_suffix)
 
         if not documents or len(documents) == 0:
             logger.info("No new documents to index after duplicate check.")
@@ -498,6 +612,15 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         logger.debug(self.vectoradapter)
 
         documents = documents + list(dependent_docs_generator)
+
+        # if collection_suffix is provided, add it to metadata of each document
+        if collection_suffix:
+            for doc in documents:
+                if not doc.metadata.get('collection'):
+                    doc.metadata['collection'] = collection_suffix
+                else:
+                    doc.metadata['collection'] += f";{collection_suffix}"
+
         total_docs = len(documents)
         documents_count = 0
         _documents = []
@@ -511,8 +634,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
             try:
                 _documents.append(document)
                 if len(_documents) >= self.max_docs_per_add:
-                    add_documents(vectorstore=self.vectoradapter.vectorstore, documents=_documents)
-                    self.vectoradapter.persist()
+                    add_documents(vectorstore=self.vectorstore, documents=_documents)
                     _documents = []
 
                 percent = math.floor((documents_count / total_docs) * 100)
@@ -526,8 +648,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 logger.error(f"Error: {format_exc()}")
                 return {"status": "error", "message": f"Error: {format_exc()}"}
         if _documents:
-            add_documents(vectorstore=self.vectoradapter.vectorstore, documents=_documents)
-            self.vectoradapter.persist()
+            add_documents(vectorstore=self.vectorstore, documents=_documents)
         return {"status": "ok", "message": f"successfully indexed {documents_count} documents"}
 
     def search_documents(self, query:str, doctype: str = 'code', 
@@ -562,7 +683,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 }
                 
             try:
-                document_items = self.vectoradapter.vectorstore.similarity_search_with_score(
+                document_items = self.vectorstore.similarity_search_with_score(
                     query, filter=document_filter, k=search_top
                 )                
                 # Add document results to unique docs
@@ -595,7 +716,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                     }
                 
                 try:
-                    chunk_items = self.vectoradapter.vectorstore.similarity_search_with_score(
+                    chunk_items = self.vectorstore.similarity_search_with_score(
                         query, filter=chunk_filter, k=search_top
                     )
                     
@@ -628,7 +749,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                                 }
                                 
                             try:
-                                fetch_items = self.vectoradapter.vectorstore.similarity_search_with_score(
+                                fetch_items = self.vectorstore.similarity_search_with_score(
                                     query, filter=doc_filter, k=1
                                 )
                                 if fetch_items:
@@ -642,7 +763,7 @@ class VectorStoreWrapper(BaseToolApiWrapper):
         else:
             # Default search behavior (unchanged)
             max_search_results = 30 if search_top * 3 > 30 else search_top * 3
-            vector_items = self.vectoradapter.vectorstore.similarity_search_with_score(
+            vector_items = self.vectorstore.similarity_search_with_score(
                 query, filter=filter, k=max_search_results
             )
             

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/alita_sdk/tools/ado/__init__.py

@@ -10,13 +10,12 @@ def get_tools(tool_type, tool):
         # common
         "selected_tools": tool['settings'].get('selected_tools', []),
         "organization_url": tool['settings']['organization_url'],
-        "project": tool['settings'].get('project', None),
-        "token": tool['settings'].get('token', None),
+        "ado_configuration": tool['settings']['ado_configuration'],
         "limit": tool['settings'].get('limit', 5),
         "toolkit_name": tool.get('toolkit_name', ''),
         # indexer settings
         "llm": tool['settings'].get('llm', None),
-        "connection_string": tool['settings'].get('connection_string', None),
+        "pgvector_configuration": tool['settings'].get('pgvector_configuration', {}),
         "collection_name": tool['toolkit_name'],
         "doctype": 'doc',
         "embedding_model": "HuggingFaceEmbeddings",

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/alita_sdk/tools/ado/repos/__init__.py

@@ -17,15 +17,12 @@ name = "ado_repos"
 def _get_toolkit(tool) -> BaseToolkit:
     return AzureDevOpsReposToolkit().get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
-        organization_url=tool['settings'].get('ado_repos_configuration').get('ado_configuration').get('organization_url', ""),
-        project=tool['settings'].get('ado_repos_configuration').get('ado_configuration').get('project', ""),
-        token=tool['settings'].get('ado_repos_configuration').get('ado_configuration').get('token', ""),
+        ado_repos_configuration=tool['settings']['ado_repos_configuration'],
         limit=tool['settings'].get('limit', 5),
-        repository_id=tool['settings'].get('ado_repos_configuration').get('repository_id', ""),
         base_branch=tool['settings'].get('base_branch', ""),
         active_branch=tool['settings'].get('active_branch', ""),
         toolkit_name=tool['settings'].get('toolkit_name', ""),
-        connection_string=tool['settings'].get('connection_string', None),
+        pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
         collection_name=tool['toolkit_name'],
         doctype='code',
         embedding_model="HuggingFaceEmbeddings",
@@ -49,14 +46,13 @@ class AzureDevOpsReposToolkit(BaseToolkit):
         AzureDevOpsReposToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         m = create_model(
             name,
-            ado_repos_configuration=(Optional[AdoReposConfiguration], Field(description="Ado Repos configuration", default=None,
+            ado_repos_configuration=(AdoReposConfiguration, Field(description="Ado Repos configuration", default=None,
                                                                        json_schema_extra={'configuration_types': ['ado_repos']})),
             base_branch=(Optional[str], Field(default="", title="Base branch", description="ADO base branch (e.g., main)")),
             active_branch=(Optional[str], Field(default="", title="Active branch", description="ADO active branch (e.g., main)")),
 
             # indexer settings
-            pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector configuration", default=None, json_schema_extra={'configuration_types': ['pgvector']})),
-                                      json_schema_extra={'secret': True})),
+            pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
             embedding_model=(str, Field(description="Embedding model: i.e. 'HuggingFaceEmbeddings', etc.",
                                     default="HuggingFaceEmbeddings")),
@@ -110,8 +106,14 @@ class AzureDevOpsReposToolkit(BaseToolkit):
             environ["AZURE_DEVOPS_CACHE_DIR"] = "/tmp/.azure-devops"
         if selected_tools is None:
             selected_tools = []
-        
-        azure_devops_repos_wrapper = ReposApiWrapper(**kwargs)
+
+        wrapper_payload = {
+            **kwargs,
+            # TODO use ado_repos_configuration fields
+            **kwargs['ado_repos_configuration'],
+            **(kwargs.get('pgvector_configuration') or {}),
+        }
+        azure_devops_repos_wrapper = ReposApiWrapper(**wrapper_payload)
         available_tools = azure_devops_repos_wrapper.get_available_tools()
         tools = []
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/alita_sdk/tools/ado/repos/repos_wrapper.py

@@ -242,6 +242,7 @@ class ArgsSchema(Enum):
 
 
 class ReposApiWrapper(BaseCodeToolApiWrapper):
+    # TODO use ado_repos_configuration fields
     organization_url: Optional[str]
     project: Optional[str]
     repository_id: Optional[str]

{alita_sdk-0.3.229 → alita_sdk-0.3.231}/alita_sdk/tools/ado/test_plan/__init__.py

@@ -1,9 +1,11 @@
 from typing import List, Optional, Literal
 
 from langchain_core.tools import BaseTool, BaseToolkit
-from pydantic import create_model, BaseModel, Field, SecretStr
+from pydantic import create_model, BaseModel, Field
 
 import requests
+from ....configurations.ado import AdoConfiguration
+from ....configurations.pgvector import PgVectorConfiguration
 from .test_plan_wrapper import TestPlanApiWrapper
 from ...base.tool import BaseAction
 from ...utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length, check_connection_response
@@ -24,19 +26,10 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
         m = create_model(
             name_alias,
             name=(str, Field(description="Toolkit name", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': AzureDevOpsPlansToolkit.toolkit_max_length})),
-            organization_url=(str, Field(title="Organization URL",
-                                                   description="ADO organization url",
-                                                   json_schema_extra={
-                                                       'configuration': True,
-                                                       'configuration_title': True
-                                                   })),
-            project=(str, Field(title="Project", description="ADO project", json_schema_extra={'configuration': True})),
+            ado_configuration=(AdoConfiguration, Field(description="Ado configuration", json_schema_extra={'configuration_types': ['ado']})),
             limit=(Optional[int], Field(description="ADO plans limit used for limitation of the list with results", default=5)),
-            token=(SecretStr, Field(description="ADO token", json_schema_extra={'secret': True, 'configuration': True})),
             # indexer settings
-            connection_string=(Optional[SecretStr], Field(description="Connection string for vectorstore",
-                                                          default=None,
-                                                          json_schema_extra={'secret': True})),
+            pgvector_configuration=(Optional[PgVectorConfiguration], Field(description="PgVector Configuration", json_schema_extra={'configuration_types': ['pgvector']})),
             # embedder settings
             embedding_model=(str, Field(description="Embedding model: i.e. 'HuggingFaceEmbeddings', etc.",
                                         default="HuggingFaceEmbeddings")),
@@ -75,9 +68,12 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
 
         @check_connection_response
         def check_connection(self):
+            ado_config = self.ado_test_plan_configuration.ado_configuration if self.ado_test_plan_configuration else None
+            if not ado_config:
+                raise ValueError("ADO test plan configuration is required")
             response = requests.get(
-                f'{self.organization_url}/{self.project}/_apis/testplan/plans?api-version=7.0',
-                headers = {'Authorization': f'Bearer {self.token}'},
+                f'{ado_config.organization_url}/{ado_config.project}/_apis/testplan/plans?api-version=7.0',
+                headers = {'Authorization': f'Bearer {ado_config.token}'},
                 timeout=5
             )
             return response
@@ -92,7 +88,13 @@ class AzureDevOpsPlansToolkit(BaseToolkit):
             environ['AZURE_DEVOPS_CACHE_DIR'] = '/tmp/.azure-devops'
         if selected_tools is None:
             selected_tools = []
-        azure_devops_api_wrapper = TestPlanApiWrapper(**kwargs)
+        wrapper_payload = {
+            **kwargs,
+            # TODO use ado_configuration fields in TestPlanApiWrapper
+            **kwargs['ado_configuration'],
+            **(kwargs.get('pgvector_configuration') or {}),
+        }
+        azure_devops_api_wrapper = TestPlanApiWrapper(**wrapper_payload)
         available_tools = azure_devops_api_wrapper.get_available_tools()
         tools = []
         prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''