alita-sdk 0.3.379__py3-none-any.whl → 0.3.627__py3-none-any.whl

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

@@ -61,7 +61,7 @@ class MemoryToolkit(BaseToolkit):
 
         return create_model(
             'memory',
-            namespace=(str, Field(description="Memory namespace", json_schema_extra={'toolkit_name': True})),
+            namespace=(str, Field(description="Memory namespace")),
             pgvector_configuration=(PgVectorConfiguration, Field(description="PgVector Configuration",
                                                                            json_schema_extra={
                                                                                'configuration_types': ['pgvector']})),
@@ -80,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:
@@ -109,10 +110,17 @@ class MemoryToolkit(BaseToolkit):
         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, "toolkit_type": name}
+        
+        return cls(tools=tools)
 
     def get_tools(self):
         return self.tools

alita_sdk/tools/non_code_indexer_toolkit.py

@@ -7,6 +7,7 @@ from alita_sdk.tools.base_indexer_toolkit import BaseIndexerToolkit
 
 class NonCodeIndexerToolkit(BaseIndexerToolkit):
     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.")

alita_sdk/tools/ocr/__init__.py

@@ -5,7 +5,8 @@ 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
+from ...runtime.utils.constants import TOOLKIT_NAME_META, TOOL_NAME_META, TOOLKIT_TYPE_META
 
 name = "ocr"
 
@@ -23,15 +24,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 +46,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_META: toolkit_name, TOOLKIT_TYPE_META: name, TOOL_NAME_META: tool["name"]} if toolkit_name else {TOOL_NAME_META: tool["name"]}
             ))
         return cls(tools=tools)