alita-sdk 0.3.528__py3-none-any.whl → 0.3.554__py3-none-any.whl

alita_sdk/runtime/tools/tool.py

@@ -86,7 +86,9 @@ Answer must be JSON only extractable by JSON.LOADS."""
         else:
             input_[-1].content += self.unstructured_output
             completion = self.client.invoke(input_, config=config)
-            result = _extract_json(completion.content.strip())
+            from ..langchain.utils import extract_text_from_completion
+            content_text = extract_text_from_completion(completion)
+            result = _extract_json(content_text.strip())
             logger.info(f"ToolNode tool params: {result}")
         try:
             # handler for application added as a tool

alita_sdk/runtime/tools/vectorstore.py

@@ -12,9 +12,11 @@ from alita_sdk.tools.vector_adapters.VectorStoreAdapter import VectorStoreAdapte
 from logging import getLogger
 
 from ..utils.logging import dispatch_custom_event
+from ..langchain.utils import extract_text_from_completion
 
 logger = getLogger(__name__)
 
+
 class IndexDocumentsModel(BaseModel):
     documents: Any = Field(description="Generator of documents to index")
 
@@ -684,8 +686,10 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 ]
             )
         ])
+        # Extract text content safely (handles both string and list content from thinking models)
+        search_query = extract_text_from_completion(result)
         search_results = self.search_documents(
-            result.content, doctype, filter, cut_off, search_top, 
+            search_query, doctype, filter, cut_off, search_top, 
             full_text_search=full_text_search,
             reranking_config=reranking_config,
             extended_search=extended_search
@@ -714,7 +718,8 @@ class VectorStoreWrapper(BaseToolApiWrapper):
                 ]
             )
         ])
-        return result.content
+        # Extract text content safely (handles both string and list content from thinking models)
+        return extract_text_from_completion(result)
 
     def _log_data(self, message: str, tool_name: str = "index_data"):
         """Log data and dispatch custom event for indexing progress"""

alita_sdk/runtime/tools/vectorstore_base.py

@@ -13,9 +13,11 @@ from pydantic import BaseModel, model_validator, Field
 from alita_sdk.tools.elitea_base import BaseToolApiWrapper
 from alita_sdk.tools.vector_adapters.VectorStoreAdapter import VectorStoreAdapterFactory
 from ...runtime.utils.utils import IndexerKeywords
+from ...runtime.langchain.utils import extract_text_from_completion
 
 logger = getLogger(__name__)
 
+
 class IndexDocumentsModel(BaseModel):
     documents: Any = Field(description="Generator of documents to index")
 
@@ -625,8 +627,10 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                 ]
             )
         ])
+        # Extract text content safely (handles both string and list content from thinking models)
+        search_query = extract_text_from_completion(result)
         search_results = self.search_documents(
-            result.content, doctype, filter, cut_off, search_top, 
+            search_query, doctype, filter, cut_off, search_top, 
             full_text_search=full_text_search,
             reranking_config=reranking_config,
             extended_search=extended_search
@@ -655,7 +659,8 @@ class VectorStoreWrapperBase(BaseToolApiWrapper):
                 ]
             )
         ])
-        return result.content
+        # Extract text content safely (handles both string and list content from thinking models)
+        return extract_text_from_completion(result)
 
     def get_available_tools(self):
         return [

alita_sdk/runtime/utils/AlitaCallback.py

@@ -313,7 +313,8 @@ class AlitaStreamlitCallback(BaseCallbackHandler):
         if self.debug:
             log.debug("on_llm_end(%s, %s)", response, kwargs)
         llm_run_id = str(run_id)
-        if self.callback_state.get(llm_run_id):
+        # Check if callback_state exists and is not None before accessing
+        if self.callback_state is not None and self.callback_state.get(llm_run_id):
             status_widget = self.callback_state[llm_run_id]
             self._safe_streamlit_call(
                 status_widget.update,

alita_sdk/runtime/utils/utils.py

@@ -1,5 +1,8 @@
+import base64
+import logging
 import re
 from enum import Enum
+from typing import Any
 
 # DEPRECATED: Tool names no longer use prefixes
 # Kept for backward compatibility only
@@ -32,3 +35,34 @@ def clean_node_str(s: str) -> str:
     """Cleans a node string by removing all non-alphanumeric characters except underscores and spaces."""
     cleaned_string = re.sub(r'[^\w\s]', '', s)
     return cleaned_string
+
+
+def resolve_image_from_cache(client: Any, cached_image_id: str) -> bytes:
+    """
+    Resolve cached_image_id from client's image cache and return decoded binary data.
+
+    Args:
+        client: AlitaClient instance with _generated_images_cache attribute
+        cached_image_id: The cached image ID to resolve
+
+    Returns:
+        bytes: Decoded binary image data
+
+    Raises:
+        ValueError: If cached_image_id not found or decoding fails
+    """
+    cache = getattr(client, '_generated_images_cache', {})
+
+    if cached_image_id not in cache:
+        raise ValueError(f"Image reference '{cached_image_id}' not found. The image may have expired.")
+
+    cached_data = cache[cached_image_id]
+    base64_data = cached_data.get('base64_data', '')
+    logging.debug(f"Resolved cached_image_id '{cached_image_id}' from cache (length: {len(base64_data)} chars)")
+    # Decode base64 to binary data for image files
+    try:
+        binary_data = base64.b64decode(base64_data)
+        logging.debug(f"Decoded base64 to binary data ({len(binary_data)} bytes)")
+        return binary_data
+    except Exception as e:
+        raise ValueError(f"Failed to decode image data for '{cached_image_id}': {e}")

alita_sdk/tools/__init__.py

@@ -49,6 +49,9 @@ def _safe_import_tool(tool_name, module_path, get_tools_name=None, toolkit_class
         if hasattr(module, 'get_toolkit'):
             imported['get_toolkit'] = getattr(module, 'get_toolkit')
 
+        if hasattr(module, 'get_toolkit_available_tools'):
+            imported['get_toolkit_available_tools'] = getattr(module, 'get_toolkit_available_tools')
+
         if toolkit_class_name and hasattr(module, toolkit_class_name):
             imported['toolkit_class'] = getattr(module, toolkit_class_name)
             AVAILABLE_TOOLKITS[toolkit_class_name] = getattr(module, toolkit_class_name)
@@ -64,7 +67,7 @@ def _safe_import_tool(tool_name, module_path, get_tools_name=None, toolkit_class
 
 # Safe imports for all tools
 _safe_import_tool('github', 'github', 'get_tools', 'AlitaGitHubToolkit')
-_safe_import_tool('openapi', 'openapi', 'get_tools')
+_safe_import_tool('openapi', 'openapi', 'get_tools', 'AlitaOpenAPIToolkit')
 _safe_import_tool('jira', 'jira', 'get_tools', 'JiraToolkit')
 _safe_import_tool('confluence', 'confluence', 'get_tools', 'ConfluenceToolkit')
 _safe_import_tool('service_now', 'servicenow', 'get_tools', 'ServiceNowToolkit')
@@ -240,6 +243,42 @@ def get_available_toolkit_models():
     """Return dict with available toolkit classes."""
     return deepcopy(AVAILABLE_TOOLS)
 
+
+def get_toolkit_available_tools(toolkit_type: str, settings: dict) -> dict:
+    """Return dynamic available tools + per-tool JSON schemas for a toolkit instance.
+
+    This is the single SDK entrypoint used by backend services (e.g. indexer_worker)
+    when the UI needs spec/instance-dependent tool enumeration. Toolkits that don't
+    support dynamic enumeration should return an empty payload.
+
+    Args:
+        toolkit_type: toolkit type string (e.g. 'openapi')
+        settings: persisted toolkit settings
+
+    Returns:
+        {
+          "tools": [{"name": str, "description": str}],
+          "args_schemas": {"tool_name": <json schema dict>}
+        }
+    """
+    toolkit_type = (toolkit_type or '').strip().lower()
+    if not isinstance(settings, dict):
+        settings = {}
+
+    tool_module = AVAILABLE_TOOLS.get(toolkit_type) or {}
+    enumerator = tool_module.get('get_toolkit_available_tools')
+    if not callable(enumerator):
+        return {"tools": [], "args_schemas": {}}
+
+    try:
+        result = enumerator(settings)
+        if not isinstance(result, dict):
+            return {"tools": [], "args_schemas": {}, "error": "Invalid response from toolkit enumerator"}
+        return result
+    except Exception as e:  # pylint: disable=W0718
+        logger.exception("Failed to compute available tools for toolkit_type=%s", toolkit_type)
+        return {"tools": [], "args_schemas": {}, "error": str(e)}
+
 def diagnose_imports():
     """Print diagnostic information about tool imports."""
     available_count = len(AVAILABLE_TOOLS)
@@ -276,6 +315,7 @@ def diagnose_imports():
 __all__ = [
     'get_tools',
     'get_toolkits',
+    'get_toolkit_available_tools',
     'get_available_tools',
     'get_failed_imports',
     'get_available_toolkits',

alita_sdk/tools/ado/work_item/ado_wrapper.py

@@ -576,9 +576,40 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
         return b"".join(content_generator)
 
     def _process_document(self, document: Document) -> Generator[Document, None, None]:
-        for attachment_id, file_name in document.metadata.get('attachment_ids', {}).items():
+        raw_attachment_ids = document.metadata.get('attachment_ids', {})
+
+        # Normalize attachment_ids: accept dict or JSON string, raise otherwise
+        if isinstance(raw_attachment_ids, str):
+            try:
+                loaded = json.loads(raw_attachment_ids)
+            except json.JSONDecodeError:
+                raise TypeError(
+                    f"Expected dict or JSON string for 'attachment_ids', got non-JSON string for id="
+                    f"{document.metadata.get('id')}: {raw_attachment_ids!r}"
+                )
+            if not isinstance(loaded, dict):
+                raise TypeError(
+                    f"'attachment_ids' JSON did not decode to dict for id={document.metadata.get('id')}: {loaded!r}"
+                )
+            attachment_ids = loaded
+        elif isinstance(raw_attachment_ids, dict):
+            attachment_ids = raw_attachment_ids
+        else:
+            raise TypeError(
+                f"Expected 'attachment_ids' to be dict or JSON string, got {type(raw_attachment_ids)} "
+                f"for id={document.metadata.get('id')}: {raw_attachment_ids!r}"
+            )
+
+        for attachment_id, file_name in attachment_ids.items():
             content = self.get_attachment_content(attachment_id=attachment_id)
-            yield Document(page_content="", metadata={'id': attachment_id, IndexerKeywords.CONTENT_FILE_NAME.value: file_name, IndexerKeywords.CONTENT_IN_BYTES.value: content})
+            yield Document(
+                page_content="",
+                metadata={
+                    'id': attachment_id,
+                    IndexerKeywords.CONTENT_FILE_NAME.value: file_name,
+                    IndexerKeywords.CONTENT_IN_BYTES.value: content,
+                },
+            )
 
     def _index_tool_params(self):
         """Return the parameters for indexing data."""

alita_sdk/tools/base_indexer_toolkit.py

@@ -29,12 +29,6 @@ class IndexTools(str, Enum):
     REMOVE_INDEX = "remove_index"
     LIST_COLLECTIONS = "list_collections"
 
-# Base Vector Store Schema Models
-BaseIndexParams = create_model(
-    "BaseIndexParams",
-    index_name=(str, Field(description="Index name (max 7 characters)", min_length=1, max_length=7)),
-)
-
 RemoveIndexParams = create_model(
     "RemoveIndexParams",
     index_name=(Optional[str], Field(description="Optional index name (max 7 characters)", default="", max_length=7)),
@@ -101,16 +95,6 @@ BaseStepbackSearchParams = create_model(
         )),
 )
 
-BaseIndexDataParams = create_model(
-    "indexData",
-    __base__=BaseIndexParams,
-    clean_index=(Optional[bool], Field(default=False,
-                       description="Optional flag to enforce clean existing index before indexing new data")),
-    progress_step=(Optional[int], Field(default=10, ge=0, le=100,
-                         description="Optional step size for progress reporting during indexing")),
-    chunking_config=(Optional[dict], Field(description="Chunking tool configuration", default=loaders_allowed_to_override)),
-)
-
 
 class BaseIndexerToolkit(VectorStoreWrapperBase):
     """Base class for tool API wrappers that support vector store functionality."""
@@ -236,7 +220,7 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             self._log_tool_event(f"Dependent documents were processed. "
                                  f"Applying chunking tool '{chunking_tool}' if specified and preparing documents for indexing...")
             documents = self._apply_loaders_chunkers(documents, chunking_tool, chunking_config)
-            self._clean_metadata(documents)
+            documents = self._clean_metadata(documents)
 
             logger.debug(f"Indexing base document #{base_doc_counter}: {base_doc} and all dependent documents: {documents}")
 
@@ -670,21 +654,49 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
         """
         Returns the standardized vector search tools (search operations only).
         Index operations are toolkit-specific and should be added manually to each toolkit.
-        
+
+        This method constructs the argument schemas for each tool, merging base parameters with any extra parameters
+        defined in the subclass. It also handles the special case for chunking tools and their configuration.
+
         Returns:
-            List of tool dictionaries with name, ref, description, and args_schema
+            list: List of tool dictionaries with name, ref, description, and args_schema.
         """
+        index_params = {
+            "index_name": (
+                str,
+                Field(description="Index name (max 7 characters)", min_length=1, max_length=7)
+            ),
+            "clean_index": (
+                Optional[bool],
+                Field(default=False, description="Optional flag to enforce clean existing index before indexing new data")
+            ),
+            "progress_step": (
+                Optional[int],
+                Field(default=10, ge=0, le=100, description="Optional step size for progress reporting during indexing")
+            ),
+        }
+        chunking_config = (
+            Optional[dict],
+            Field(description="Chunking tool configuration", default=loaders_allowed_to_override)
+        )
+
+        index_extra_params = self._index_tool_params() or {}
+        chunking_tool = index_extra_params.pop("chunking_tool", None)
+        if chunking_tool:
+            index_params = {
+                **index_params,
+                "chunking_tool": chunking_tool,
+            }
+        index_params["chunking_config"] = chunking_config
+        index_args_schema = create_model("IndexData", **index_params, **index_extra_params)
+
         return [
             {
                 "name": IndexTools.INDEX_DATA.value,
                 "mode": IndexTools.INDEX_DATA.value,
                 "ref": self.index_data,
                 "description": "Loads data to index.",
-                "args_schema": create_model(
-                    "IndexData",
-                    __base__=BaseIndexDataParams,
-                    **self._index_tool_params() if self._index_tool_params() else {}
-                )
+                "args_schema": index_args_schema,
             },
             {
                 "name": IndexTools.SEARCH_INDEX.value,

alita_sdk/tools/confluence/api_wrapper.py

@@ -962,6 +962,9 @@ class ConfluenceAPIWrapper(NonCodeIndexerToolkit):
                     created_date = hist.get('createdDate', '') if hist else attachment.get('created', '')
                     last_updated = hist.get('lastUpdated', {}).get('when', '') if hist else ''
 
+                    attachment_path = attachment['_links']['download'] if attachment.get(
+                            '_links', {}).get('download') else ''
+                    download_url = self.client.url.rstrip('/') + attachment_path
                     metadata = {
                         'name': title,
                         'size': attachment.get('extensions', {}).get('fileSize', None),
@@ -971,14 +974,10 @@ class ConfluenceAPIWrapper(NonCodeIndexerToolkit):
                         'media_type': media_type,
                         'labels': [label['name'] for label in
                                    attachment.get('metadata', {}).get('labels', {}).get('results', [])],
-                        'download_url': self.base_url.rstrip('/') + attachment['_links']['download'] if attachment.get(
-                            '_links', {}).get('download') else None
+                        'download_url': download_url
                     }
-
-                    download_url = self.base_url.rstrip('/') + attachment['_links']['download']
-
                     try:
-                        resp = self.client.request(method="GET", path=download_url[len(self.base_url):], advanced_mode=True)
+                        resp = self.client.request(method="GET", path=attachment_path, advanced_mode=True)
                         if resp.status_code == 200:
                             content = resp.content
                         else:

alita_sdk/tools/confluence/loader.py

@@ -48,7 +48,8 @@ class AlitaConfluenceLoader(ConfluenceLoader):
                 del kwargs[key]
             except:
                 pass
-        self.base_url = kwargs.get('url')
+        # utilize adjusted URL from Confluence instance for base_url
+        self.base_url = confluence_client.url
         self.space_key = kwargs.get('space_key')
         self.page_ids = kwargs.get('page_ids')
         self.label = kwargs.get('label')
@@ -108,7 +109,8 @@ class AlitaConfluenceLoader(ConfluenceLoader):
         texts = []
         for attachment in attachments:
             media_type = attachment["metadata"]["mediaType"]
-            absolute_url = self.base_url + attachment["_links"]["download"]
+            # utilize adjusted URL from Confluence instance for attachment download URL
+            absolute_url = self.confluence.url + attachment["_links"]["download"]
             title = attachment["title"]
             try:
                 if media_type == "application/pdf":