alita-sdk 0.3.351__py3-none-any.whl → 0.3.499__py3-none-any.whl

alita_sdk/runtime/tools/artifact.py

@@ -1,4 +1,6 @@
 import hashlib
+import io
+import json
 import logging
 import re
 from typing import Any, Optional, Generator, List
@@ -6,10 +8,12 @@ from typing import Any, Optional, Generator, List
 from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
+from openpyxl.workbook.workbook import Workbook
 from pydantic import create_model, Field, model_validator
 
 from ...tools.non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ...tools.utils.available_tools_decorator import extend_with_parent_available_tools
+from ...tools.elitea_base import extend_with_file_operations
 from ...runtime.utils.utils import IndexerKeywords
 
 
@@ -28,10 +32,36 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return super().validate_toolkit(values)
 
     def list_files(self, bucket_name = None, return_as_string = True):
-        return self.artifact.list(bucket_name, return_as_string)
+        """List all files in the artifact bucket with API download links."""
+        result = self.artifact.list(bucket_name, return_as_string=False)
+        
+        # Add API download link to each file
+        if isinstance(result, dict) and 'rows' in result:
+            bucket = bucket_name or self.bucket
+            
+            # Get base_url and project_id from alita client
+            base_url = getattr(self.alita, 'base_url', '').rstrip('/')
+            project_id = getattr(self.alita, 'project_id', '')
+            
+            for file_info in result['rows']:
+                if 'name' in file_info:
+                    # Generate API download link
+                    file_name = file_info['name']
+                    file_info['link'] = f"{base_url}/api/v2/artifacts/artifact/default/{project_id}/{bucket}/{file_name}"
+        
+        return str(result) if return_as_string else result
 
     def create_file(self, filename: str, filedata: str, bucket_name = None):
-        result = self.artifact.create(filename, filedata, bucket_name)
+        # Sanitize filename to prevent regex errors during indexing
+        sanitized_filename, was_modified = self._sanitize_filename(filename)
+        if was_modified:
+            logging.warning(f"Filename sanitized: '{filename}' -> '{sanitized_filename}'")
+        
+        if sanitized_filename.endswith(".xlsx"):
+            data = json.loads(filedata)
+            filedata = self.create_xlsx_filedata(data)
+
+        result = self.artifact.create(sanitized_filename, filedata, bucket_name)
         
         # Dispatch custom event for file creation
         dispatch_custom_event("file_modified", {
@@ -44,8 +74,63 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 "bucket": bucket_name or self.bucket
             }
         })
-        
+
         return result
+    
+    @staticmethod
+    def _sanitize_filename(filename: str) -> tuple:
+        """Sanitize filename for safe storage and regex pattern matching."""
+        from pathlib import Path
+        
+        if not filename or not filename.strip():
+            return "unnamed_file", True
+        
+        original = filename
+        path_obj = Path(filename)
+        name = path_obj.stem
+        extension = path_obj.suffix
+        
+        # Whitelist: alphanumeric, underscore, hyphen, space, Unicode letters/digits
+        sanitized_name = re.sub(r'[^\w\s-]', '', name, flags=re.UNICODE)
+        sanitized_name = re.sub(r'[-\s]+', '-', sanitized_name)
+        sanitized_name = sanitized_name.strip('-').strip()
+        
+        if not sanitized_name:
+            sanitized_name = "file"
+        
+        if extension:
+            extension = re.sub(r'[^\w.-]', '', extension, flags=re.UNICODE)
+        
+        sanitized = sanitized_name + extension
+        return sanitized, (sanitized != original)
+
+    def create_xlsx_filedata(self, data: dict[str, list[list]]) -> bytes:
+        try:
+            workbook = Workbook()
+
+            first_sheet = True
+            for sheet_name, sheet_data in data.items():
+                if first_sheet:
+                    sheet = workbook.active
+                    sheet.title = sheet_name
+                    first_sheet = False
+                else:
+                    sheet = workbook.create_sheet(title=sheet_name)
+
+                for row in sheet_data:
+                    sheet.append(row)
+
+            file_buffer = io.BytesIO()
+            workbook.save(file_buffer)
+            file_buffer.seek(0)
+
+            return file_buffer.read()
+
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON format for .xlsx file data.")
+        except Exception as e:
+            raise ValueError(f"Error processing .xlsx file data: {e}")
+
 
     def read_file(self,
                   filename: str,
@@ -61,6 +146,94 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                                   sheet_name=sheet_name,
                                   excel_by_sheets=excel_by_sheets,
                                   llm=self.llm)
+    
+    def _read_file(
+        self,
+        file_path: str,
+        branch: str = None,
+        bucket_name: str = None,
+        **kwargs
+    ) -> str:
+        """
+        Read a file from artifact bucket with optional partial read support.
+        
+        Parameters:
+            file_path: Name of the file in the bucket
+            branch: Not used for artifacts (kept for API consistency)
+            bucket_name: Name of the bucket (uses default if None)
+            **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(filename=file_path, bucket_name=bucket_name)
+    
+    def _write_file(
+        self,
+        file_path: str,
+        content: str,
+        branch: str = None,
+        commit_message: str = None,
+        bucket_name: str = None
+    ) -> str:
+        """
+        Write content to a file (create or overwrite).
+        
+        Parameters:
+            file_path: Name of the file in the bucket
+            content: New file content
+            branch: Not used for artifacts (kept for API consistency)
+            commit_message: Not used for artifacts (kept for API consistency)
+            bucket_name: Name of the bucket (uses default if None)
+            
+        Returns:
+            Success message
+        """
+        try:
+            # Sanitize filename
+            sanitized_filename, was_modified = self._sanitize_filename(file_path)
+            if was_modified:
+                logging.warning(f"Filename sanitized: '{file_path}' -> '{sanitized_filename}'")
+            
+            # Check if file exists
+            try:
+                self.artifact.get(artifact_name=sanitized_filename, bucket_name=bucket_name, llm=self.llm)
+                # File exists, overwrite it
+                result = self.artifact.overwrite(sanitized_filename, content, bucket_name)
+                
+                # Dispatch custom event
+                dispatch_custom_event("file_modified", {
+                    "message": f"File '{sanitized_filename}' updated successfully",
+                    "filename": sanitized_filename,
+                    "tool_name": "edit_file",
+                    "toolkit": "artifact",
+                    "operation_type": "modify",
+                    "meta": {
+                        "bucket": bucket_name or self.bucket
+                    }
+                })
+                
+                return f"Updated file {sanitized_filename}"
+            except:
+                # File doesn't exist, create it
+                result = self.artifact.create(sanitized_filename, content, bucket_name)
+                
+                # Dispatch custom event
+                dispatch_custom_event("file_modified", {
+                    "message": f"File '{sanitized_filename}' created successfully",
+                    "filename": sanitized_filename,
+                    "tool_name": "edit_file",
+                    "toolkit": "artifact",
+                    "operation_type": "create",
+                    "meta": {
+                        "bucket": bucket_name or self.bucket
+                    }
+                })
+                
+                return f"Created file {sanitized_filename}"
+        except Exception as e:
+            raise ToolException(f"Unable to write file {file_path}: {str(e)}")
 
     def delete_file(self, filename: str, bucket_name = None):
         return self.artifact.delete(filename, bucket_name)
@@ -100,7 +273,11 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return result
 
     def create_new_bucket(self, bucket_name: str, expiration_measure = "weeks", expiration_value = 1):
-        return self.artifact.client.create_bucket(bucket_name, expiration_measure, expiration_value)
+        # Sanitize bucket name: replace underscores with hyphens and ensure lowercase
+        sanitized_name = bucket_name.replace('_', '-').lower()
+        if sanitized_name != bucket_name:
+            logging.warning(f"Bucket name '{bucket_name}' was sanitized to '{sanitized_name}' (underscores replaced with hyphens, converted to lowercase)")
+        return self.artifact.client.create_bucket(sanitized_name, expiration_measure, expiration_value)
 
     def _index_tool_params(self):
         return {
@@ -135,13 +312,13 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
             file_name = file['name']
 
             # Check if file should be skipped based on skip_extensions
-            if any(re.match(pattern.replace('*', '.*') + '$', file_name, re.IGNORECASE)
+            if any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
                    for pattern in skip_extensions):
                 continue
 
             # Check if file should be included based on include_extensions
             # If include_extensions is empty, process all files (that weren't skipped)
-            if include_extensions and not (any(re.match(pattern.replace('*', '.*') + '$', file_name, re.IGNORECASE)
+            if include_extensions and not (any(re.match(re.escape(pattern).replace(r'\*', '.*') + '$', file_name, re.IGNORECASE)
                                                for pattern in include_extensions)):
                 continue
 
@@ -166,17 +343,20 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 document.metadata[IndexerKeywords.CONTENT_FILE_NAME.value] = document.metadata['name']
                 yield document
             except Exception as e:
-                logging.error(f"Failed while parsing the file '{document.metadata['name']}': {e}")
+                logger.error(f"Failed while parsing the file '{document.metadata['name']}': {e}")
                 yield document
 
-    @extend_with_parent_available_tools
+    @extend_with_file_operations
     def get_available_tools(self):
+        """Get available tools, including indexing tools only if vector store is configured."""
         bucket_name = (Optional[str], Field(description="Name of the bucket to work with."
                                                         "If bucket is not specified by user directly, the name should be taken from chat history."
                                                         "If bucket never mentioned in chat, the name will be taken from tool configuration."
                                                         " ***IMPORTANT*** Underscore `_` is prohibited in bucket name and should be replaced by `-`",
                                             default=None))
-        return [
+        
+        # Basic artifact tools (always available)
+        basic_tools = [
             {
                 "ref": self.list_files,
                 "name": "listFiles",
@@ -190,7 +370,17 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 "args_schema": create_model(
                     "createFile", 
                     filename=(str, Field(description="Filename")),
-                    filedata=(str, Field(description="Stringified content of the file")),
+                    filedata=(str, Field(description="""Stringified content of the file.
+                    Example for .xlsx filedata format:
+                    {
+                        "Sheet1":[
+                            ["Name", "Age", "City"],
+                            ["Alice", 25, "New York"],
+                            ["Bob", 30, "San Francisco"],
+                            ["Charlie", 35, "Los Angeles"]
+                        ]
+                    }
+                    """)),
                     bucket_name=bucket_name
                 )
             },
@@ -251,11 +441,34 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 "description": "Creates new bucket specified by user.",
                 "args_schema": create_model(
                     "createNewBucket",
-                    bucket_name=(str, Field(description="Bucket name to create. ***IMPORTANT*** Underscore `_` is prohibited in bucket name and should be replaced by `-`.")),
+                    bucket_name=(str, Field(
+                        description="Bucket name to create. Must start with lowercase letter and contain only lowercase letters, numbers, and hyphens. Underscores will be automatically converted to hyphens.",
+                        pattern=r'^[a-z][a-z0-9_-]*$'  # Allow underscores in input, will be sanitized
+                    )),
                     expiration_measure=(Optional[str], Field(description="Measure of expiration time for bucket configuration."
                                                                          "Possible values: `days`, `weeks`, `months`, `years`.",
                                                              default="weeks")),
                     expiration_value=(Optional[int], Field(description="Expiration time values.", default=1))
                 )
             }
-        ]
+        ]
+        
+        # Add indexing tools only if vector store is configured
+        has_vector_config = (
+            hasattr(self, 'embedding_model') and self.embedding_model and
+            hasattr(self, 'pgvector_configuration') and self.pgvector_configuration
+        )
+        
+        if has_vector_config:
+            try:
+                # Get indexing tools from parent class
+                indexing_tools = super(ArtifactWrapper, self).get_available_tools()
+                return indexing_tools + basic_tools
+            except Exception as e:
+                # If getting parent tools fails, log warning and return basic tools only
+                logging.warning(f"Failed to load indexing tools: {e}. Only basic artifact tools will be available.")
+                return basic_tools
+        else:
+            # No vector store config, return basic tools only
+            logging.info("Vector store not configured. Indexing tools (index_data, search_index, etc.) are not available.")
+            return basic_tools

alita_sdk/runtime/tools/function.py

@@ -1,18 +1,33 @@
+import json
 import logging
+from copy import deepcopy
 from json import dumps
 
 from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.messages import ToolCall
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool, ToolException
-from typing import Any, Optional, Union, Annotated
+from typing import Any, Optional, Union
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from pydantic import ValidationError
+
 from ..langchain.utils import propagate_the_input_mapping
 
 logger = logging.getLogger(__name__)
 
 
+def replace_escaped_newlines(data):
+    """
+        Replace \\n with \n in all string values recursively.
+        Required for sanitization of state variables in code node
+    """
+    if isinstance(data, dict):
+        return {key: replace_escaped_newlines(value) for key, value in data.items()}
+    elif isinstance(data, str):
+        return data.replace('\\n', '\n')
+    else:
+        return data
+
 class FunctionTool(BaseTool):
     name: str = 'FunctionalTool'
     description: str = 'This is direct call node for tools'
@@ -21,6 +36,61 @@ class FunctionTool(BaseTool):
     input_variables: Optional[list[str]] = None
     input_mapping: Optional[dict[str, dict]] = None
     output_variables: Optional[list[str]] = None
+    structured_output: Optional[bool] = False
+    alita_client: Optional[Any] = None
+
+    def _prepare_pyodide_input(self, state: Union[str, dict, ToolCall]) -> str:
+        """Prepare input for PyodideSandboxTool by injecting state into the code block."""
+        # add state into the code block here since it might be changed during the execution of the code
+        state_copy = replace_escaped_newlines(deepcopy(state))
+
+        del state_copy['messages']  # remove messages to avoid issues with pickling without langchain-core
+        # inject state into the code block as alita_state variable
+        state_json = json.dumps(state_copy, ensure_ascii=False)
+        pyodide_predata = f'#state dict\nimport json\nalita_state = json.loads({json.dumps(state_json)})\n'
+
+        return pyodide_predata
+
+    def _handle_pyodide_output(self, tool_result: Any) -> dict:
+        """Handle output processing for PyodideSandboxTool results."""
+        tool_result_converted = {}
+
+        if self.output_variables:
+            for var in self.output_variables:
+                if var == "messages":
+                    tool_result_converted.update(
+                        {"messages": [{"role": "assistant", "content": dumps(tool_result)}]})
+                    continue
+                if isinstance(tool_result, dict) and var in tool_result:
+                    tool_result_converted[var] = tool_result[var]
+                else:
+                    # handler in case user points to a var that is not in the output of the tool
+                    tool_result_converted[var] = tool_result.get('result',
+                                                                 tool_result.get('error') if tool_result.get('error')
+                                                                 else 'Execution result is missing')
+        else:
+            tool_result_converted.update({"messages": [{"role": "assistant", "content": dumps(tool_result)}]})
+
+        if self.structured_output:
+            # execute code tool and update state variables
+            try:
+                result_value = tool_result.get('result', {})
+                if isinstance(result_value, dict):
+                    tool_result_converted.update(result_value)
+                elif isinstance(result_value, list):
+                    # Handle list case - could wrap in a key or handle differently based on requirements
+                    tool_result_converted.update({"result": result_value})
+                else:
+                    # Handle JSON string case
+                    tool_result_converted.update(json.loads(result_value))
+            except json.JSONDecodeError:
+                logger.error(f"JSONDecodeError: {tool_result}")
+
+        return tool_result_converted
+
+    def _is_pyodide_tool(self) -> bool:
+        """Check if the current tool is a PyodideSandboxTool."""
+        return self.tool.name.lower() == 'pyodide_sandbox'
 
     def invoke(
             self,
@@ -31,8 +101,15 @@ class FunctionTool(BaseTool):
         params = convert_to_openai_tool(self.tool).get(
             'function', {'parameters': {}}).get(
             'parameters', {'properties': {}}).get('properties', {})
+
         func_args = propagate_the_input_mapping(input_mapping=self.input_mapping, input_variables=self.input_variables,
                                                 state=state)
+
+        # special handler for PyodideSandboxTool
+        if self._is_pyodide_tool():
+            # replace new lines in strings in code block
+            code = func_args['code'].replace('\\n', '\\\\n')
+            func_args['code'] = f"{self._prepare_pyodide_input(state)}\n{code}"
         try:
             tool_result = self.tool.invoke(func_args, config, **kwargs)
             dispatch_custom_event(
@@ -44,17 +121,30 @@ class FunctionTool(BaseTool):
                 }, config=config
             )
             logger.info(f"ToolNode response: {tool_result}")
+
+            # handler for PyodideSandboxTool
+            if self._is_pyodide_tool():
+                return self._handle_pyodide_output(tool_result)
+
             if not self.output_variables:
                 return {"messages": [{"role": "assistant", "content": dumps(tool_result)}]}
             else:
-                if self.output_variables[0] == "messages":
-                    return {
+                if "messages" in self.output_variables:
+                    messages_dict = {
                         "messages": [{
                             "role": "assistant",
-                            "content": dumps(tool_result) if not isinstance(tool_result, ToolException) else str(
-                                tool_result)
+                            "content": dumps(tool_result)
+                            if not isinstance(tool_result, ToolException) and not isinstance(tool_result, str)
+                            else str(tool_result)
                         }]
                     }
+                    for var in self.output_variables:
+                        if var != "messages":
+                            if isinstance(tool_result, dict) and var in tool_result:
+                                messages_dict[var] = tool_result[var]
+                            else:
+                                messages_dict[var] = tool_result
+                    return messages_dict
                 else:
                     return { self.output_variables[0]: tool_result }
         except ValidationError:

alita_sdk/runtime/tools/graph.py

@@ -47,8 +47,8 @@ def formulate_query(kwargs):
 
 
 class GraphTool(BaseTool):
-    name: str
-    description: str
+    name: str = 'GraphTool'
+    description: str = 'Graph tool for tools'
     graph: CompiledStateGraph
     args_schema: Type[BaseModel] = graphToolSchema
     return_type: str = "str"
@@ -65,10 +65,16 @@ class GraphTool(BaseTool):
         all_kwargs = {**kwargs, **extras, **schema_values}
         if config is None:
             config = {}
-        return self._run(*config, **all_kwargs)
+        # Pass the config to the _run empty or the one passed from the parent executor.
+        return self._run(config, **all_kwargs)
 
     def _run(self, *args, **kwargs):
-        response = self.graph.invoke(formulate_query(kwargs))
+        config = None
+        # From invoke method we are passing only 1 arg so it is safe to do this condition and config assignment.
+        # Default to None is safe because it will be checked also on the langchain side.
+        if args:
+            config = args[0]
+        response = self.graph.invoke(formulate_query(kwargs), config=config)
         if self.return_type == "str":
             return response["output"]
         else: