aip-agents-binary 0.5.20__py3-none-any.whl

aip_agents/storage/providers/object_storage.py

@@ -0,0 +1,214 @@
+"""Object storage provider implementation.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+    Fachriza Adhiatma (fachriza.d.adhiatma@gdplabs.id)
+"""
+
+import json
+import pickle
+from typing import Any
+
+from aip_agents.storage.base import BaseObjectStorageClient
+from aip_agents.storage.providers.base import BaseStorageProvider, StorageError
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ObjectStorageProvider(BaseStorageProvider):
+    """Object storage provider for S3-compatible storage.
+
+    Works with any S3-compatible storage including AWS S3, MinIO,
+    Google Cloud Storage (with S3 compatibility), etc.
+
+    Best for:
+    - Very large datasets
+    - Distributed systems
+    - Cloud deployments
+    - Long-term storage
+    - Multi-region access
+    """
+
+    def __init__(self, client: BaseObjectStorageClient, prefix: str = "", use_json: bool = False):
+        """Initialize object storage provider.
+
+        Args:
+            client: Object storage client instance
+            prefix: Prefix for all keys (like a directory)
+            use_json: Use JSON format (True) or pickle (False)
+        """
+        self.client = client
+        self.prefix = prefix.rstrip("/") + "/" if prefix else ""
+        self.use_json = use_json
+
+    def _get_object_key(self, key: str) -> str:
+        """Get full object key with prefix.
+
+        Args:
+            key: Storage key
+
+        Returns:
+            Full object key with prefix
+        """
+        return f"{self.prefix}{key}"
+
+    def _serialize_data(self, data: Any) -> bytes:
+        """Serialize data to bytes.
+
+        Args:
+            data: Data to serialize
+
+        Returns:
+            Serialized data as bytes
+
+        Raises:
+            StorageError: If serialization fails
+        """
+        try:
+            if self.use_json:
+                return json.dumps(data, default=str).encode("utf-8")
+            return pickle.dumps(data)
+        except Exception as e:
+            raise StorageError(f"Failed to serialize data: {e}") from e
+
+    def _deserialize_data(self, data_bytes: bytes) -> Any:
+        """Deserialize data from bytes.
+
+        Args:
+            data_bytes: Serialized data
+
+        Returns:
+            Deserialized data
+
+        Raises:
+            StorageError: If deserialization fails
+        """
+        try:
+            if self.use_json:
+                return json.loads(data_bytes.decode("utf-8"))
+            return pickle.loads(data_bytes)
+        except Exception as e:
+            raise StorageError(f"Failed to deserialize data: {e}") from e
+
+    def store(self, key: str, data: Any) -> None:
+        """Store data in object storage.
+
+        Args:
+            key: Unique identifier for the data
+            data: Data to store
+
+        Raises:
+            StorageError: If storage operation fails
+        """
+        object_key = self._get_object_key(key)
+
+        try:
+            data_bytes = self._serialize_data(data)
+
+            self.client.upload(
+                object_key=object_key,
+                file_stream=data_bytes,
+                content_type="application/json" if self.use_json else "application/octet-stream",
+                metadata={"storage_key": key, "format": "json" if self.use_json else "pickle"},
+            )
+
+            logger.debug(f"Stored data to object storage: {object_key}")
+
+        except Exception as e:
+            raise StorageError(f"Failed to store data in object storage: {e}") from e
+
+    def retrieve(self, key: str) -> Any:
+        """Retrieve data from object storage.
+
+        Args:
+            key: Unique identifier for the data
+
+        Returns:
+            The stored data
+
+        Raises:
+            KeyError: If key not found
+            StorageError: If retrieval operation fails
+        """
+        object_key = self._get_object_key(key)
+
+        try:
+            data_bytes = self.client.get(object_key)
+            return self._deserialize_data(data_bytes)
+
+        except KeyError as e:
+            raise KeyError(f"Key '{key}' not found in object storage: {e}") from e
+        except Exception as e:
+            raise StorageError(f"Failed to retrieve data from object storage: {e}") from e
+
+    def exists(self, key: str) -> bool:
+        """Check if object exists.
+
+        Args:
+            key: Unique identifier to check
+
+        Returns:
+            True if key exists, False otherwise
+        """
+        object_key = self._get_object_key(key)
+
+        try:
+            return self.client.object_exists(object_key)
+        except Exception as e:
+            logger.warning(f"Failed to check object existence: {e}")
+            return False
+
+    def delete(self, key: str) -> None:
+        """Delete object.
+
+        Args:
+            key: Unique identifier for the data
+        """
+        object_key = self._get_object_key(key)
+
+        try:
+            self.client.delete(object_key)
+            logger.debug(f"Deleted object: {object_key}")
+        except Exception as e:
+            logger.warning(f"Failed to delete object {object_key}: {e}")
+
+    def list_keys(self, prefix: str = "") -> list[str]:
+        """List all keys with optional prefix.
+
+        Args:
+            prefix: Optional prefix to filter keys
+
+        Raises:
+            NotImplementedError: list_keys is not implemented
+        """
+        raise NotImplementedError("list_keys not yet implemented for object storage")
+
+    def clear(self) -> None:
+        """Clear all objects with the configured prefix.
+
+        Warning:
+            This is a dangerous operation!
+        """
+        logger.warning("clear() not implemented for object storage - too dangerous")
+        raise NotImplementedError("Batch clear not implemented for safety reasons")
+
+    def get_presigned_url(self, key: str, expires_hours: int = 24) -> str | None:
+        """Generate presigned URL for direct access.
+
+        Args:
+            key: Storage key
+            expires_hours: URL expiration in hours
+
+        Returns:
+            Presigned URL for direct access
+
+        Raises:
+            StorageError: If URL generation fails
+        """
+        object_key = self._get_object_key(key)
+
+        try:
+            return self.client.generate_presigned_url(object_key=object_key, expires=expires_hours)
+        except Exception as e:
+            raise StorageError(f"Failed to generate presigned URL: {e}") from e

aip_agents/tools/__init__.py

@@ -0,0 +1,33 @@
+"""Initialize Tools Module for AIP Agents."""
+
+from importlib import import_module
+
+from aip_agents.tools.bosa_tools import BOSA_AUTOMATED_TOOLS
+from aip_agents.tools.gl_connector import GLConnectorTool
+from aip_agents.tools.time_tool import TimeTool
+from aip_agents.tools.web_search import GoogleSerperTool
+
+__all__ = ["BOSA_AUTOMATED_TOOLS", "GLConnectorTool", "GoogleSerperTool", "TimeTool"]
+
+
+def _register_optional(module_path: str, export_name: str) -> None:
+    """Try to import optional tool module and expose it in __all__.
+
+    Args:
+        module_path: The module path to import.
+        export_name: The name to export in __all__.
+    """
+    try:
+        module = import_module(module_path)
+    except ImportError:
+        return
+
+    globals()[export_name] = getattr(module, export_name)
+    __all__.append(export_name)
+
+
+_register_optional("aip_agents.tools.browser_use", "BrowserUseTool")
+_register_optional("aip_agents.tools.code_sandbox", "E2BCodeSandboxTool")
+_register_optional("aip_agents.tools.document_loader", "DocxReaderTool")
+_register_optional("aip_agents.tools.document_loader", "ExcelReaderTool")
+_register_optional("aip_agents.tools.document_loader", "PDFReaderTool")

aip_agents/tools/bosa_tools.py

@@ -0,0 +1,105 @@
+"""Auto-generated tools from BOSA connector.
+
+Authors:
+    Saul Sayers (saul.sayers@gdplabs.id)
+"""
+
+from bosa_connectors import BosaConnector, BOSAConnectorToolGenerator
+from langchain_core.tools import BaseTool
+
+from aip_agents.tools.constants import BOSA_API_BASE_URL, BOSA_API_KEY, BOSA_FETCH_MAX_RETRIES, ToolType
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_bosa_modules_with_retry() -> list[str]:
+    """Try to get available modules with retries.
+
+    Returns:
+        List of available modules.
+    """
+    if not BOSA_API_BASE_URL or not BOSA_API_KEY:
+        logger.warning("BOSA credentials missing (base_url or api_key); returning empty modules list")
+        return []
+
+    connector = BosaConnector(api_base_url=BOSA_API_BASE_URL, api_key=BOSA_API_KEY)
+    modules = []
+    for attempt in range(BOSA_FETCH_MAX_RETRIES):
+        try:
+            modules = list(connector.get_available_modules())
+            if modules:
+                return modules
+            logger.warning(
+                f"Failed to get BOSA available modules, retrying... (attempt {attempt + 1} / {BOSA_FETCH_MAX_RETRIES})"
+            )
+        except Exception as e:
+            logger.exception(
+                f"Exception when getting BOSA available modules (attempt {attempt + 1} / {BOSA_FETCH_MAX_RETRIES}): {e}"
+            )
+    logger.error("Failed to get BOSA available modules after maximum retries")
+    return modules
+
+
+class LazyBosaToolsDict(dict):
+    """Lazy dictionary for BOSA tools."""
+
+    def __missing__(self, app):
+        """When a key is missing, create the tools and store them in the dictionary.
+
+        Args:
+            app: Name of the BOSA connector.
+
+        Returns:
+            List of tools generated by BOSAConnectorToolGenerator.
+        """
+        if app not in get_bosa_modules():
+            return []
+        tools = []
+        for attempt in range(BOSA_FETCH_MAX_RETRIES):
+            try:
+                tools = BOSAConnectorToolGenerator(
+                    api_base_url=BOSA_API_BASE_URL,
+                    api_key=BOSA_API_KEY,
+                    app_name=app,
+                ).generate_tools(tool_type=ToolType.LANGCHAIN)
+                if tools:
+                    self[app] = tools
+                    return tools
+                logger.warning(
+                    f"Failed to create BOSA tools, retrying... (attempt {attempt + 1} / {BOSA_FETCH_MAX_RETRIES})"
+                )
+            except Exception as e:
+                logger.exception(
+                    f"Exception when creating BOSA tools for app '{app}' "
+                    f"(attempt {attempt + 1} / {BOSA_FETCH_MAX_RETRIES}): {e}"
+                )
+        logger.error("Failed to create BOSA tools after maximum retries")
+        return tools
+
+
+# Supported modules (dynamic)
+def get_bosa_modules() -> list[str]:
+    """Lazily fetch and cache BOSA modules.
+
+    This is for backwards compatibility with the old BOSA modules.
+
+    Returns:
+        List of BOSA modules.
+    """
+    if not hasattr(get_bosa_modules, "_cache"):
+        get_bosa_modules._cache = get_bosa_modules_with_retry()
+    return get_bosa_modules._cache
+
+
+# FOR BACKWARDS COMPATIBILITY
+BOSA_MODULES = [
+    "github",
+    "twitter",
+    "google",
+    "google_drive",
+    "google_mail",
+    "google_docs",
+]
+
+BOSA_AUTOMATED_TOOLS: dict[str, list[BaseTool]] = LazyBosaToolsDict()

aip_agents/tools/browser_use/__init__.py

@@ -0,0 +1,82 @@
+# flake8: noqa: F401
+"""Browser use tools package for AI Agent Platform.
+
+Authors:
+    Reinhart Linanda (reinhart.linanda@gdplabs.id)
+"""
+
+import warnings
+from enum import StrEnum
+
+try:
+    import json_repair
+    import minio
+    from browser_use import Agent
+    from steel import Steel
+
+    _TOOL_AVAILABLE = True
+
+except ImportError:
+    _TOOL_AVAILABLE = False
+    warnings.warn(
+        "Browser use tools not available. Install with: pip install aip-agents[local]",
+        ImportWarning,
+        stacklevel=2,
+    )
+
+
+class ImportableName(StrEnum):
+    """Names of the importable attributes."""
+
+    BROWSER_USE_TOOL = "BrowserUseTool"
+    BROWSER_USE_TOOL_INPUT = "BrowserUseToolInput"
+    BROWSER_USE_TOOL_CONFIG = "BrowserUseToolConfig"
+
+
+if _TOOL_AVAILABLE:
+    __all__ = [
+        ImportableName.BROWSER_USE_TOOL,
+        ImportableName.BROWSER_USE_TOOL_INPUT,
+        ImportableName.BROWSER_USE_TOOL_CONFIG,
+    ]
+
+    _LAZY_IMPORTS = {}
+else:
+    # No tools available
+    __all__ = []
+
+
+def __getattr__(name: str):
+    """Lazy import to avoid circular dependencies and import errors in tests.
+
+    Args:
+        name (str): The name of the attribute to get.
+
+    Returns:
+        The attribute value.
+    """
+    if not _TOOL_AVAILABLE:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    if name in _LAZY_IMPORTS:
+        return _LAZY_IMPORTS[name]
+
+    if name == ImportableName.BROWSER_USE_TOOL:
+        from aip_agents.tools.browser_use.browser_use_tool import BrowserUseTool
+
+        _LAZY_IMPORTS[name] = BrowserUseTool
+        return BrowserUseTool
+
+    if name == ImportableName.BROWSER_USE_TOOL_INPUT:
+        from aip_agents.tools.browser_use.schemas import BrowserUseToolInput
+
+        _LAZY_IMPORTS[name] = BrowserUseToolInput
+        return BrowserUseToolInput
+
+    if name == ImportableName.BROWSER_USE_TOOL_CONFIG:
+        from aip_agents.tools.browser_use.schemas import BrowserUseToolConfig
+
+        _LAZY_IMPORTS[name] = BrowserUseToolConfig
+        return BrowserUseToolConfig
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

aip_agents/tools/browser_use/action_parser.py

@@ -0,0 +1,103 @@
+"""Helper utilities for parsing browser-use agent actions.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from browser_use.agent.views import ActionResult, AgentOutput
+from browser_use.controller.registry.views import ActionModel
+
+from aip_agents.tools.browser_use.types import ToolCallInfo
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class ActionParser:
+    """Dedicated class for parsing agent actions with improved error handling."""
+
+    @staticmethod
+    def extract_actions(
+        model_output: AgentOutput | None, last_result: list[ActionResult] | None = None
+    ) -> list[ToolCallInfo]:
+        """Extract action information from model output.
+
+        Args:
+            model_output: The model output containing action information.
+            last_result: The last result from the agent state for output extraction.
+
+        Returns:
+            list[ToolCallInfo]: Structured action information.
+        """
+        if model_output is None or getattr(model_output, "action", None) is None:
+            return []
+
+        actions = model_output.action
+        outputs = ActionParser._extract_outputs_from_result(last_result)
+
+        return [ActionParser._parse_single_action(action_model, outputs, i) for i, action_model in enumerate(actions)]
+
+    @staticmethod
+    def _extract_outputs_from_result(last_result: list[ActionResult] | None) -> list[str]:
+        """Extract output strings from agent result.
+
+        Args:
+            last_result: The last result from the agent state for output extraction.
+
+        Returns:
+            list[str]: List of output strings.
+        """
+        if not last_result:
+            return []
+
+        outputs: list[str] = []
+        for result in last_result:
+            if result.extracted_content:
+                outputs.append(result.extracted_content)
+            elif result.error:
+                outputs.append(f"Error: {result.error}")
+            else:
+                outputs.append("")
+
+        return outputs
+
+    @staticmethod
+    def _parse_single_action(action_model: ActionModel, outputs: list[str], index: int) -> ToolCallInfo:
+        """Parse a single action model into ToolCallInfo.
+
+        Args:
+            action_model: The action model to parse.
+            outputs: List of output strings.
+            index: Index of the action in the outputs list.
+
+        Returns:
+            ToolCallInfo: Parsed action information.
+        """
+        try:
+            specific_action = action_model.root
+            action_data: dict[str, Any] = specific_action.model_dump(exclude_unset=True)
+
+            tool_name = list(action_data.keys())[0]
+            tool_args = action_data[tool_name]
+
+            if not isinstance(tool_args, dict):
+                tool_args = {"value": tool_args}
+
+            output = outputs[index] if index < len(outputs) else ""
+
+            return ToolCallInfo(name=tool_name, args=tool_args, output=output)
+
+        except Exception as exc:
+            logger.warning("Error parsing action structure: %s", exc)
+            return ToolCallInfo(
+                name="parsing_error",
+                args={"error": str(exc)},
+                output=outputs[index] if index < len(outputs) else "",
+            )
+
+
+__all__ = ["ActionParser"]