alita-sdk 0.3.334__tar.gz → 0.3.336__tar.gz

{alita_sdk-0.3.334 → alita_sdk-0.3.336}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.334
+Version: 0.3.336
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0
@@ -68,6 +68,7 @@ Requires-Dist: opentelemetry_instrumentation==0.46b0; extra == "runtime"
 Requires-Dist: grpcio_status==1.63.0rc1; extra == "runtime"
 Requires-Dist: protobuf==4.25.7; extra == "runtime"
 Requires-Dist: sentence-transformers==2.7.0; extra == "runtime"
+Requires-Dist: langchain-sandbox>=0.0.6; extra == "runtime"
 Provides-Extra: tools
 Requires-Dist: dulwich==0.21.6; extra == "tools"
 Requires-Dist: paramiko==3.3.1; extra == "tools"

{alita_sdk-0.3.334 → alita_sdk-0.3.336}/alita_sdk/runtime/langchain/assistant.py

@@ -176,6 +176,22 @@ class Assistant:
         # Exclude compiled graph runnables from simple tool agents
         simple_tools = [t for t in self.tools if isinstance(t, (BaseTool, CompiledStateGraph))]
         
+        # Add sandbox tool by default for react agents
+        try:
+            from ..tools.sandbox import create_sandbox_tool
+            sandbox_tool = create_sandbox_tool(stateful=True, allow_net=True)
+            simple_tools.append(sandbox_tool)
+            logger.info("Added PyodideSandboxTool to react agent")
+        except ImportError as e:
+            logger.warning(f"Failed to add PyodideSandboxTool: {e}. Install langchain-sandbox to enable this feature.")
+        except RuntimeError as e:
+            if "Deno" in str(e):
+                logger.warning("Failed to add PyodideSandboxTool: Deno is required. Install from https://docs.deno.com/runtime/getting_started/installation/")
+            else:
+                logger.warning(f"Failed to add PyodideSandboxTool: {e}")
+        except Exception as e:
+            logger.error(f"Error adding PyodideSandboxTool: {e}")
+        
         # Set up memory/checkpointer if available
         checkpointer = None
         if self.memory is not None:

{alita_sdk-0.3.334 → alita_sdk-0.3.336}/alita_sdk/runtime/toolkits/tools.py

@@ -163,7 +163,11 @@ def _mcp_tools(tools_list, alita):
             for available_tool in available_tools:
                 tool_name = available_tool.get("name", "").lower()
                 if not selected_tools or tool_name in selected_tools:
-                    if server_tool := _init_single_mcp_tool(server_toolkit_name, selected_toolkit["name"], available_tool, alita, selected_toolkit['settings']):
+                    if server_tool := _init_single_mcp_tool(server_toolkit_name,
+                                                            # selected_toolkit["name"] is None for toolkit_test
+                                                            selected_toolkit["name"] if selected_toolkit.get("name")
+                                                            else server_toolkit_name,
+                                                            available_tool, alita, selected_toolkit['settings']):
                         tools.append(server_tool)
         return tools
     except Exception:

alita_sdk-0.3.336/alita_sdk/runtime/tools/__init__.py

@@ -0,0 +1,14 @@
+"""
+Runtime tools module for Alita SDK.
+This module provides various tools that can be used within LangGraph agents.
+"""
+
+from .sandbox import PyodideSandboxTool, StatefulPyodideSandboxTool, create_sandbox_tool
+from .echo import EchoTool
+
+__all__ = [
+    "PyodideSandboxTool",
+    "StatefulPyodideSandboxTool", 
+    "create_sandbox_tool",
+    "EchoTool"
+]

alita_sdk-0.3.336/alita_sdk/runtime/tools/sandbox.py

@@ -0,0 +1,224 @@
+import logging
+import asyncio
+import subprocess
+from typing import Any, Type, Optional, Union, Dict
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field, create_model
+from pydantic.fields import FieldInfo
+
+logger = logging.getLogger(__name__)
+
+
+def _is_deno_available() -> bool:
+    """Check if Deno is available in the PATH"""
+    try:
+        result = subprocess.run(
+            ["deno", "--version"], 
+            capture_output=True, 
+            text=True, 
+            timeout=10
+        )
+        return result.returncode == 0
+    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+# Create input schema for the sandbox tool
+sandbox_tool_input = create_model(
+    "SandboxToolInput", 
+    code=(str, FieldInfo(description="Python code to execute in the sandbox environment"))
+)
+
+
+class PyodideSandboxTool(BaseTool):
+    """
+    A tool that provides secure Python code execution using Pyodide (Python compiled to WebAssembly).
+    This tool leverages langchain-sandbox to provide a safe environment for running untrusted Python code.
+    """
+    
+    name: str = "pyodide_sandbox"
+    description: str = """Execute Python code in a secure sandbox environment using Pyodide.
+    This tool allows safe execution of Python code without access to the host system.
+    Use this tool when you need to:
+    - Execute Python code snippets
+    - Perform calculations or data analysis
+    - Test Python algorithms
+    - Run code that requires isolation from the host system
+    
+    The sandbox supports most Python standard library modules and can install additional packages.
+    Note: File access and some system operations are restricted for security.
+    """
+    args_schema: Type[BaseModel] = sandbox_tool_input
+    stateful: bool = True
+    allow_net: bool = True
+    session_bytes: Optional[bytes] = None
+    session_metadata: Optional[Dict] = None
+    
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._sandbox = None
+        self._initialize_sandbox()
+    
+    def _initialize_sandbox(self) -> None:
+        """Initialize the PyodideSandbox instance"""
+        try:
+            # Check if Deno is available
+            if not _is_deno_available():
+                error_msg = (
+                    "Deno is required for PyodideSandbox but is not installed. "
+                    "Please install Deno manually or ensure it's available in PATH."
+                )
+                logger.error(error_msg)
+                raise RuntimeError(error_msg)
+            
+            from langchain_sandbox import PyodideSandbox
+            self._sandbox = PyodideSandbox(
+                stateful=self.stateful,
+                allow_net=self.allow_net
+            )
+            logger.info("PyodideSandbox initialized successfully")
+        except ImportError as e:
+            if "langchain_sandbox" in str(e):
+                error_msg = (
+                    "langchain-sandbox is required for the PyodideSandboxTool. "
+                    "Please install it with: pip install langchain-sandbox"
+                )
+                logger.error(error_msg)
+                raise ImportError(error_msg) from e
+            else:
+                logger.error(f"Failed to import required module: {e}")
+                raise
+        except Exception as e:
+            logger.error(f"Failed to initialize PyodideSandbox: {e}")
+            raise
+    
+    def _run(self, code: str) -> str:
+        """
+        Synchronous version - runs the async method in a new event loop
+        """
+        try:
+            # Check if sandbox is initialized, if not try to initialize
+            if self._sandbox is None:
+                self._initialize_sandbox()
+            
+            # Check if we're already in an async context
+            try:
+                loop = asyncio.get_running_loop()
+                # We're in an async context, but _run is supposed to be sync
+                # We'll need to use a different approach
+                import concurrent.futures
+                with concurrent.futures.ThreadPoolExecutor() as executor:
+                    future = executor.submit(asyncio.run, self._arun(code))
+                    return future.result()
+            except RuntimeError:
+                # No running loop, safe to use asyncio.run
+                return asyncio.run(self._arun(code))
+        except (ImportError, RuntimeError) as e:
+            # Handle specific dependency errors gracefully
+            error_msg = str(e)
+            if "langchain-sandbox" in error_msg:
+                return "❌ PyodideSandboxTool requires langchain-sandbox. Install with: pip install langchain-sandbox"
+            elif "Deno" in error_msg:
+                return "❌ PyodideSandboxTool requires Deno. Install from: https://docs.deno.com/runtime/getting_started/installation/"
+            else:
+                return f"❌ PyodideSandboxTool initialization failed: {error_msg}"
+        except Exception as e:
+            logger.error(f"Error executing code in sandbox: {e}")
+            return f"Error executing code: {str(e)}"
+    
+    async def _arun(self, code: str) -> str:
+        """
+        Execute Python code in the Pyodide sandbox
+        """
+        try:
+            if self._sandbox is None:
+                self._initialize_sandbox()
+            
+            # Execute the code with session state if available
+            result = await self._sandbox.execute(
+                code,
+                session_bytes=self.session_bytes,
+                session_metadata=self.session_metadata
+            )
+            
+            # Update session state for stateful execution
+            if self.stateful:
+                self.session_bytes = result.session_bytes
+                self.session_metadata = result.session_metadata
+            
+            # Format the output
+            output_parts = []
+            
+            if result.result is not None:
+                output_parts.append(f"Result: {result.result}")
+            
+            if result.stdout:
+                output_parts.append(f"Output: {result.stdout}")
+            
+            if result.stderr:
+                output_parts.append(f"Error: {result.stderr}")
+            
+            if result.status == 'error':
+                output_parts.append(f"Execution failed with status: {result.status}")
+            
+            execution_info = f"Execution time: {result.execution_time:.2f}s"
+            if result.session_metadata and 'packages' in result.session_metadata:
+                packages = result.session_metadata.get('packages', [])
+                if packages:
+                    execution_info += f", Packages: {', '.join(packages)}"
+            
+            output_parts.append(execution_info)
+            
+            return "\n".join(output_parts) if output_parts else "Code executed successfully (no output)"
+            
+        except Exception as e:
+            logger.error(f"Error executing code in sandbox: {e}")
+            return f"Error executing code: {str(e)}"
+
+
+class StatefulPyodideSandboxTool(PyodideSandboxTool):
+    """
+    A stateful version of the PyodideSandboxTool that maintains state between executions.
+    This version preserves variables, imports, and function definitions across multiple tool calls.
+    """
+    
+    name: str = "stateful_pyodide_sandbox"
+    description: str = """Execute Python code in a stateful sandbox environment using Pyodide.
+    This tool maintains state between executions, preserving variables, imports, and function definitions.
+    Use this tool when you need to:
+    - Build upon previous code executions
+    - Maintain variables across multiple calls
+    - Develop complex programs step by step
+    - Preserve imported libraries and defined functions
+    
+    The sandbox supports most Python standard library modules and can install additional packages.
+    Note: File access and some system operations are restricted for security.
+    """
+    
+    def __init__(self, **kwargs: Any) -> None:
+        kwargs['stateful'] = True  # Force stateful mode
+        super().__init__(**kwargs)
+
+
+# Factory function for creating sandbox tools
+def create_sandbox_tool(stateful: bool = False, allow_net: bool = True) -> BaseTool:
+    """
+    Factory function to create sandbox tools with specified configuration.
+    
+    Note: This tool requires Deno to be installed and available in PATH.
+    For installation, use the bootstrap.sh script or install manually.
+    
+    Args:
+        stateful: Whether to maintain state between executions
+        allow_net: Whether to allow network access (for package installation)
+    
+    Returns:
+        Configured sandbox tool instance
+        
+    Raises:
+        ImportError: If langchain-sandbox is not installed
+        RuntimeError: If Deno is not found in PATH
+    """
+    if stateful:
+        return StatefulPyodideSandboxTool(allow_net=allow_net)
+    else:
+        return PyodideSandboxTool(stateful=False, allow_net=allow_net)

{alita_sdk-0.3.334 → alita_sdk-0.3.336}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.334
+Version: 0.3.336
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0
@@ -68,6 +68,7 @@ Requires-Dist: opentelemetry_instrumentation==0.46b0; extra == "runtime"
 Requires-Dist: grpcio_status==1.63.0rc1; extra == "runtime"
 Requires-Dist: protobuf==4.25.7; extra == "runtime"
 Requires-Dist: sentence-transformers==2.7.0; extra == "runtime"
+Requires-Dist: langchain-sandbox>=0.0.6; extra == "runtime"
 Provides-Extra: tools
 Requires-Dist: dulwich==0.21.6; extra == "tools"
 Requires-Dist: paramiko==3.3.1; extra == "tools"

{alita_sdk-0.3.334 → alita_sdk-0.3.336}/alita_sdk.egg-info/SOURCES.txt

@@ -127,6 +127,7 @@ alita_sdk/runtime/tools/mcp_server_tool.py
 alita_sdk/runtime/tools/pgvector_search.py
 alita_sdk/runtime/tools/prompt.py
 alita_sdk/runtime/tools/router.py
+alita_sdk/runtime/tools/sandbox.py
 alita_sdk/runtime/tools/tool.py
 alita_sdk/runtime/tools/vectorstore.py
 alita_sdk/runtime/tools/vectorstore_base.py

{alita_sdk-0.3.334 → alita_sdk-0.3.336}/alita_sdk.egg-info/requires.txt

@@ -73,6 +73,7 @@ opentelemetry_instrumentation==0.46b0
 grpcio_status==1.63.0rc1
 protobuf==4.25.7
 sentence-transformers==2.7.0
+langchain-sandbox>=0.0.6
 
 [tools]
 dulwich==0.21.6

{alita_sdk-0.3.334 → alita_sdk-0.3.336}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.334"
+version = "0.3.336"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,7 +32,7 @@ name = "Artem Dubrovskiy"
 email = "ad13box@gmail.com"
 
 [project.optional-dependencies]
-runtime = [ "langchain_core==0.3.49", "langchain<=0.3.22", "langchain_community~=0.3.7", "langchain-openai~=0.3.0", "langgraph-checkpoint-sqlite~=2.0.0", "langgraph-checkpoint-postgres==2.0.21", "langsmith>=0.3.45", "langgraph>=0.4.8,<0.5", "langchain_chroma~=0.2.2", "langchain-unstructured~=0.1.6", "langchain-postgres~=0.0.13", "keybert==0.8.3", "charset_normalizer==3.3.2", "unstructured[local-inference]==0.16.23", "unstructured_pytesseract==0.3.13", "unstructured_inference==0.8.7", "python-pptx==1.0.2", "pdf2image==1.16.3", "pikepdf==8.7.1", "pypdf==4.3.1", "pdfminer.six==20240706", "opencv-python==4.11.0.86", "python-docx==1.1.2", "openpyxl==3.1.2", "markdown==3.5.1", "beautifulsoup4==4.12.2", "gensim==4.3.3", "chromadb==0.5.20", "pgvector==0.2.5", "scipy==1.13.1", "pytesseract==0.3.13", "reportlab==4.2.5", "svglib==1.5.1", "rlpycairo==0.3.0", "cairocffi==1.7.1", "docx2txt==0.8", "mammoth==1.9.0", "opentelemetry-exporter-otlp-proto-grpc==1.25.0", "opentelemetry_api==1.25.0", "opentelemetry_instrumentation==0.46b0", "grpcio_status==1.63.0rc1", "protobuf==4.25.7", "sentence-transformers==2.7.0",]
+runtime = [ "langchain_core==0.3.49", "langchain<=0.3.22", "langchain_community~=0.3.7", "langchain-openai~=0.3.0", "langgraph-checkpoint-sqlite~=2.0.0", "langgraph-checkpoint-postgres==2.0.21", "langsmith>=0.3.45", "langgraph>=0.4.8,<0.5", "langchain_chroma~=0.2.2", "langchain-unstructured~=0.1.6", "langchain-postgres~=0.0.13", "keybert==0.8.3", "charset_normalizer==3.3.2", "unstructured[local-inference]==0.16.23", "unstructured_pytesseract==0.3.13", "unstructured_inference==0.8.7", "python-pptx==1.0.2", "pdf2image==1.16.3", "pikepdf==8.7.1", "pypdf==4.3.1", "pdfminer.six==20240706", "opencv-python==4.11.0.86", "python-docx==1.1.2", "openpyxl==3.1.2", "markdown==3.5.1", "beautifulsoup4==4.12.2", "gensim==4.3.3", "chromadb==0.5.20", "pgvector==0.2.5", "scipy==1.13.1", "pytesseract==0.3.13", "reportlab==4.2.5", "svglib==1.5.1", "rlpycairo==0.3.0", "cairocffi==1.7.1", "docx2txt==0.8", "mammoth==1.9.0", "opentelemetry-exporter-otlp-proto-grpc==1.25.0", "opentelemetry_api==1.25.0", "opentelemetry_instrumentation==0.46b0", "grpcio_status==1.63.0rc1", "protobuf==4.25.7", "sentence-transformers==2.7.0", "langchain-sandbox>=0.0.6",]
 tools = [ "dulwich==0.21.6", "paramiko==3.3.1", "pygithub==2.3.0", "python-gitlab==4.5.0", "gitpython==3.1.43", "atlassian-python-api~=4.0.7", "jira==3.8.0", "qtest-swagger-client==0.0.3", "testrail-api==1.13.2", "azure-devops==7.1.0b4", "msrest==0.7.1", "python-graphql-client~=0.4.3", "zephyr-python-api==0.1.0", "pyral==1.6.0", "boto3>=1.37.23", "azure-core==1.30.2", "azure-identity==1.16.0", "azure-keyvault-keys==4.9.0", "azure-keyvault-secrets==4.8.0", "azure-mgmt-core==1.4.0", "azure-mgmt-resource==23.0.1", "azure-mgmt-storage==21.1.0", "azure-storage-blob==12.23.1", "azure-search-documents==11.5.2", "PyMySQL==1.1.1", "psycopg2-binary==2.9.10", "Office365-REST-Python-Client==2.5.14", "python-docx==1.1.2", "python-pptx==1.0.2", "pypdf2~=3.0.1", "FigmaPy==2018.1.0", "pandas==2.2.3", "factor_analyzer==0.5.1", "statsmodels==0.14.4", "tabulate==0.9.0", "tree_sitter==0.20.2", "tree-sitter-languages==1.10.2", "astor~=0.8.1", "markdownify~=1.1.0", "requests_openapi==1.0.5", "duckduckgo_search==5.3.0", "playwright>=1.52.0", "google-api-python-client==2.154.0", "wikipedia==1.4.0", "lxml==5.2.2", "beautifulsoup4", "pymupdf==1.24.9", "googlemaps==4.10.0", "yagmail==0.15.293", "pysnc==1.1.10", "shortuuid==1.0.13", "yarl==1.17.1", "langmem==0.0.27", "textract-py3==2.1.1", "slack_sdk==3.35.0", "deltalake==1.0.2", "google_cloud_bigquery==3.34.0",]
 community = [ "retry-extended==0.2.3", "pyobjtojson==0.3", "elitea-analyse==0.1.2",]
 all = [ "alita-sdk[runtime]", "alita-sdk[tools]", "alita-sdk[community]",]