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

alita_sdk/tools/keycloak/__init__.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, ConfigDict, create_model, Field, SecretStr
 
 from .api_wrapper import KeycloakApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 name = "keycloak"
 
@@ -21,15 +21,13 @@ def get_tools(tool):
 
 class KeycloakToolkit(BaseToolkit):
     tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in KeycloakApiWrapper.model_construct().get_available_tools()}
-        KeycloakToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            base_url=(str, Field(default="", title="Server URL", description="Keycloak server URL", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': KeycloakToolkit.toolkit_max_length})),
+            base_url=(str, Field(default="", title="Server URL", description="Keycloak server URL", json_schema_extra={'toolkit_name': True})),
             realm=(str, Field(default="", title="Realm", description="Keycloak realm")),
             client_id=(str, Field(default="", title="Client ID", description="Keycloak client ID")),
             client_secret=(SecretStr, Field(default="", title="Client sercet", description="Keycloak client secret", json_schema_extra={'secret': True})),
@@ -42,17 +40,21 @@ class KeycloakToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         keycloak_api_wrapper = KeycloakApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = keycloak_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = f"{tool['description']}\nUrl: {keycloak_api_wrapper.base_url}"
+            if toolkit_name:
+                description = f"{description}\nToolkit: {toolkit_name}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=keycloak_api_wrapper,
-                name=prefix + tool["name"],
-                description=f"{tool['description']}\nUrl: {keycloak_api_wrapper.base_url}",
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/localgit/__init__.py

@@ -34,7 +34,7 @@ class AlitaLocalGitToolkit(BaseToolkit):
         )
 
     @classmethod
-    def get_toolkit(cls, selected_tools: list[str] | None = None, **kwargs):
+    def get_toolkit(cls, selected_tools: list[str] | None = None, toolkit_name: Optional[str] = None, **kwargs):
         if selected_tools is None:
             selected_tools = []
         local_git_tool = LocalGit(**kwargs)
@@ -45,12 +45,17 @@ class AlitaLocalGitToolkit(BaseToolkit):
             if selected_tools:
                 if tool["name"] not in selected_tools:
                     continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(LocalGitAction(
                 api_wrapper=local_git_tool,
                 name=repo + "_" + tool["name"],
                 mode=tool["mode"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)
 

alita_sdk/tools/localgit/local_git.py

@@ -8,7 +8,8 @@ from git import Repo
 from pydantic import BaseModel, Field, create_model, model_validator
 from langchain_core.tools import ToolException
 
-from ..elitea_base import BaseToolApiWrapper
+from ..elitea_base import BaseToolApiWrapper, extend_with_file_operations, BaseCodeToolApiWrapper
+from ..utils.text_operations import parse_old_new_markers
 
 logger = logging.getLogger(__name__)
 CREATE_FILE_PROMPT = """Create new file in your local repository."""
@@ -110,6 +111,12 @@ class LocalGit(BaseToolApiWrapper):
     repo_url: str = None
     commit_sha: str = None
     path_pattern: str = '**/*.py'
+    
+    # Import file operation methods from BaseCodeToolApiWrapper
+    read_file_chunk = BaseCodeToolApiWrapper.read_file_chunk
+    read_multiple_files = BaseCodeToolApiWrapper.read_multiple_files
+    search_file = BaseCodeToolApiWrapper.search_file
+    edit_file = BaseCodeToolApiWrapper.edit_file
 
     @model_validator(mode='before')
     @classmethod
@@ -128,58 +135,6 @@ class LocalGit(BaseToolApiWrapper):
             repo.head.reset(commit=commit_sha, working_tree=True)
         return values
 
-    def extract_old_new_pairs(self, file_query):
-        # Split the file content by lines
-        code_lines = file_query.split("\n")
-
-        # Initialize lists to hold the contents of OLD and NEW sections
-        old_contents = []
-        new_contents = []
-
-        # Initialize variables to track whether the current line is within an OLD or NEW section
-        in_old_section = False
-        in_new_section = False
-
-        # Temporary storage for the current section's content
-        current_section_content = []
-
-        # Iterate through each line in the file content
-        for line in code_lines:
-            # Check for OLD section start
-            if "OLD <<<" in line:
-                in_old_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for OLD section end
-            if ">>>> OLD" in line:
-                in_old_section = False
-                old_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section start
-            if "NEW <<<" in line:
-                in_new_section = True
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # Check for NEW section end
-            if ">>>> NEW" in line:
-                in_new_section = False
-                new_contents.append("\n".join(current_section_content).strip())  # Add the captured content
-                current_section_content = []  # Reset current section content
-                continue  # Skip the line with the marker
-
-            # If currently in an OLD or NEW section, add the line to the current section content
-            if in_old_section or in_new_section:
-                current_section_content.append(line)
-
-        # Pair the OLD and NEW contents
-        paired_contents = list(zip(old_contents, new_contents))
-
-        return paired_contents
-
     def checkout_commit(self, commit_sha: str) -> str:
         """ Checkout specific commit from repository """
         try:
@@ -233,6 +188,58 @@ class LocalGit(BaseToolApiWrapper):
                 return f.read()
         else:
             return "File '{}' cannot be read because it is not existed".format(file_path)
+    
+    def _read_file(self, file_path: str, branch: str = None, **kwargs) -> str:
+        """
+        Read a file from the repository with optional partial read support.
+        
+        Parameters:
+            file_path: the file path (relative to repo root)
+            branch: branch name (not used for local git, always reads from working dir)
+            **kwargs: Additional parameters (offset, limit, head, tail) - currently ignored,
+                     partial read handled client-side by base class methods
+        
+        Returns:
+            File content as string
+        """
+        return self.read_file(file_path)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None
+    ) -> str:
+        """
+        Write content to a file (create or update).
+        
+        Parameters:
+            file_path: Path to the file (relative to repo root)
+            content: New file content
+            branch: Branch name (not used for local git)
+            commit_message: Commit message (not used - files are written without commit)
+            
+        Returns:
+            Success message
+        """
+        try:
+            full_path = os.path.normpath(os.path.join(self.repo.working_dir, file_path))
+            
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(full_path), exist_ok=True)
+            
+            # Write the file
+            with open(full_path, 'w') as f:
+                f.write(content)
+            
+            # Determine if file was created or updated
+            if os.path.exists(full_path):
+                return f"Updated file {file_path}"
+            else:
+                return f"Created file {file_path}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def update_file_content_by_lines(self, file_path: str, start_line_index: int, end_line_index: int,
                                      new_content: str) -> str:
@@ -314,7 +321,7 @@ class LocalGit(BaseToolApiWrapper):
             file_path = os.path.normpath(os.path.join(self.repo.working_dir, file_path))
             file_content = self.read_file(file_path)
             updated_file_content = file_content
-            for old, new in self.extract_old_new_pairs(file_query):
+            for old, new in parse_old_new_markers(file_query):  # Use shared utility
                 if not old.strip():
                     continue
                 updated_file_content = updated_file_content.replace(old, new)
@@ -332,6 +339,7 @@ class LocalGit(BaseToolApiWrapper):
         except Exception as e:
             return "Unable to update file due to error:\n" + str(e)
 
+    @extend_with_file_operations
     def get_available_tools(self):
         return [
             {

alita_sdk/tools/localgit/tool.py

@@ -29,6 +29,10 @@ class LocalGitAction(BaseTool):
     ) -> str:
         """Use the GitHub API to run an operation."""
         try:
-            return self.api_wrapper.run(self.mode, *args, **kwargs)
+            # Strip numeric suffix added for deduplication (_2, _3, etc.)
+            # to get the original tool name that exists in the wrapper
+            import re
+            mode = re.sub(r'_\d+$', '', self.mode) if self.mode else self.mode
+            return self.api_wrapper.run(mode, *args, **kwargs)
         except Exception as e:
             return f"Error: {format_exc()}"

alita_sdk/tools/memory/__init__.py

@@ -1,6 +1,8 @@
-from typing import Optional, List
+from typing import List, Literal
 
-from langchain_core.tools import BaseToolkit, BaseTool
+from langchain_core.tools import BaseToolkit, BaseTool, ToolException
+
+from alita_sdk.configurations.pgvector import PgVectorConfiguration
 
 try:
     from langmem import create_manage_memory_tool, create_search_memory_tool
@@ -15,7 +17,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 
 name = "memory"
 
-def get_tools(tools_list: list, alita_client, llm, memory_store=None):
+def get_tools(tools_list: list, memory_store=None):
     """
     Get memory tools for the provided tool configurations.
     
@@ -35,8 +37,9 @@ def get_tools(tools_list: list, alita_client, llm, memory_store=None):
             try:
                 toolkit_instance = MemoryToolkit().get_toolkit(
                     namespace=tool['settings'].get('namespace', str(tool['id'])),
-                    username=tool['settings'].get('username', ''),
+                    # username=tool['settings'].get('username', ''),
                     store=tool['settings'].get('store', memory_store),
+                    pgvector_configuration=tool['settings'].get('pgvector_configuration', {}),
                     toolkit_name=tool.get('toolkit_name', '')
                 )
                 all_tools.extend(toolkit_instance.get_tools())
@@ -53,18 +56,23 @@ class MemoryToolkit(BaseToolkit):
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
+        memory_tools = [create_manage_memory_tool('test'), create_search_memory_tool('test')]
+        selected_tools = {x.name: x.args_schema.schema() for x in memory_tools}
+
         return create_model(
-            'MemoryConfig',
-            namespace=(str, Field(description="Memory namespace", json_schema_extra={'toolkit_name': True})),
-            username=(Optional[str], Field(description="Username", default='Tester', json_schema_extra={'hidden': True})),
-            connection_string=(Optional[SecretStr], Field(description="Connection string for vectorstore",
-                                                          default=None,
-                                                          json_schema_extra={'secret': True})),
+            'memory',
+            namespace=(str, Field(description="Memory namespace")),
+            pgvector_configuration=(PgVectorConfiguration, Field(description="PgVector Configuration",
+                                                                           json_schema_extra={
+                                                                               'configuration_types': ['pgvector']})),
+            selected_tools=(List[Literal[tuple(selected_tools)]],
+                            Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
+
             __config__=ConfigDict(json_schema_extra={
                 'metadata': {
                     "label": "Memory",
                     "icon_url": "memory.svg",
-                    "hidden": True,
+                    "hidden": False,
                     "categories": ["other"],
                     "extra_categories": ["long-term memory", "langmem"],
                 }
@@ -72,13 +80,14 @@ class MemoryToolkit(BaseToolkit):
         )
 
     @classmethod
-    def get_toolkit(cls, namespace: str, store=None, **kwargs):
+    def get_toolkit(cls, namespace: str, store=None, toolkit_name: str = None, **kwargs):
         """
         Get toolkit with memory tools.
         
         Args:
             namespace: Memory namespace
             store: PostgresStore instance (imported dynamically)
+            toolkit_name: Optional toolkit name for metadata
             **kwargs: Additional arguments
         """
         try:
@@ -88,15 +97,30 @@ class MemoryToolkit(BaseToolkit):
                 "PostgreSQL dependencies (psycopg) are required for MemoryToolkit. "
                 "Install with: pip install psycopg[binary]"
             )
+
+        if store is None:
+            # The store is not provided, attempt to create it from configuration
+            from ...runtime.langchain.store_manager import get_manager
+            conn_str = (kwargs.get('pgvector_configuration') or {}).get('connection_string', '')
+            if not conn_str:
+                raise ToolException("Connection string is required to create PostgresStore for memory toolkit.")
+            store = get_manager().get_store(conn_str)
         
         # Validate store type
         if store is not None and not isinstance(store, PostgresStore):
             raise TypeError(f"Expected PostgresStore, got {type(store)}")
         
-        return cls(tools=[
+        tools = [
             create_manage_memory_tool(namespace=namespace, store=store),
             create_search_memory_tool(namespace=namespace, store=store)
-        ])
+        ]
+        
+        # Add metadata to tools if toolkit_name is provided
+        if toolkit_name:
+            for tool in tools:
+                tool.metadata = {"toolkit_name": toolkit_name}
+        
+        return cls(tools=tools)
 
     def get_tools(self):
         return self.tools

alita_sdk/tools/non_code_indexer_toolkit.py

@@ -1,12 +1,17 @@
 from langchain_core.documents import Document
+from langchain_core.tools import ToolException
 
 from alita_sdk.runtime.utils.utils import IndexerKeywords
 from alita_sdk.tools.base_indexer_toolkit import BaseIndexerToolkit
 
 
 class NonCodeIndexerToolkit(BaseIndexerToolkit):
-    def _get_indexed_data(self, collection_suffix: str):
-        return self.vector_adapter.get_indexed_data(self, collection_suffix)
+    def _get_indexed_data(self, index_name: str):
+        self._ensure_vectorstore_initialized()
+        if not self.vector_adapter:
+            raise ToolException("Vector adapter is not initialized. "
+                             "Check your configuration: embedding_model and vectorstore_type.")
+        return self.vector_adapter.get_indexed_data(self, index_name)
 
     def key_fn(self, document: Document):
         return document.metadata.get('id')

alita_sdk/tools/ocr/__init__.py

@@ -5,7 +5,7 @@ from pydantic import create_model, BaseModel, ConfigDict, Field
 
 from .api_wrapper import OCRApiWrapper
 from ..base.tool import BaseAction
-from ..utils import clean_string, TOOLKIT_SPLITTER, get_max_toolkit_length
+from ..utils import clean_string, get_max_toolkit_length
 
 name = "ocr"
 
@@ -23,15 +23,13 @@ def get_tools(tool):
 
 class OCRToolkit(BaseToolkit):
     tools: list[BaseTool] = []
-    toolkit_max_length: int = 0
 
     @staticmethod
     def toolkit_config_schema() -> BaseModel:
         selected_tools = {x['name']: x['args_schema'].schema() for x in OCRApiWrapper.model_construct().get_available_tools()}
-        OCRToolkit.toolkit_max_length = get_max_toolkit_length(selected_tools)
         return create_model(
             name,
-            artifacts_folder=(str, Field(description="Folder path containing artifacts to process", json_schema_extra={'toolkit_name': True, 'max_toolkit_length': OCRToolkit.toolkit_max_length})),
+            artifacts_folder=(str, Field(description="Folder path containing artifacts to process", json_schema_extra={'toolkit_name': True})),
             tesseract_settings=(dict, Field(description="Settings for Tesseract OCR processing", default={})),
             structured_output=(bool, Field(description="Whether to return structured JSON output", default=False)),
             expected_fields=(dict, Field(description="Expected fields for structured output", default={})),
@@ -47,17 +45,21 @@ class OCRToolkit(BaseToolkit):
         if selected_tools is None:
             selected_tools = []
         ocr_api_wrapper = OCRApiWrapper(**kwargs)
-        prefix = clean_string(toolkit_name, cls.toolkit_max_length) + TOOLKIT_SPLITTER if toolkit_name else ''
         available_tools = ocr_api_wrapper.get_available_tools()
         tools = []
         for tool in available_tools:
             if selected_tools and tool["name"] not in selected_tools:
                 continue
+            description = tool["description"]
+            if toolkit_name:
+                description = f"Toolkit: {toolkit_name}\n{description}"
+            description = description[:1000]
             tools.append(BaseAction(
                 api_wrapper=ocr_api_wrapper,
-                name=prefix + tool["name"],
-                description=tool["description"],
-                args_schema=tool["args_schema"]
+                name=tool["name"],
+                description=description,
+                args_schema=tool["args_schema"],
+                metadata={"toolkit_name": toolkit_name} if toolkit_name else {}
             ))
         return cls(tools=tools)