aip-agents-binary 0.5.24__py3-none-any.whl → 0.5.25b1__py3-none-any.whl

aip_agents/tools/browser_use/streaming.pyi

@@ -0,0 +1,81 @@
+from aip_agents.tools.browser_use.types import StreamingResponse, ToolCallInfo
+from browser_use import Agent
+from typing import Any, Literal
+
+__all__ = ['PROCESSING_MESSAGE', 'TASK_COMPLETED_MESSAGE', 'create_error_response', 'create_step_response', 'generate_step_content', 'generate_thinking_message', 'yield_iframe_activity', 'yield_status_message', 'yield_thinking_marker']
+
+TASK_COMPLETED_MESSAGE: str
+PROCESSING_MESSAGE: str
+
+def create_step_response(agent: Agent, tool_calls: list[ToolCallInfo], is_done: bool, content: str, thinking_message: str | None) -> StreamingResponse:
+    """Compose the per-step payload emitted during browser-use streaming.
+
+    Args:
+        agent: Browser-use agent producing the step output.
+        tool_calls: Tool call descriptors extracted from the step.
+        is_done: Flag indicating whether this is the final step in the run.
+        content: High-level status text describing the step progress.
+        thinking_message: Optional preformatted thinking summary to attach.
+
+    Returns:
+        StreamingResponse: Serialized payload for the current streaming step.
+    """
+async def generate_thinking_message(content: str, tool_calls: list[dict[str, Any]], *, is_final: bool) -> str | None:
+    """Generate a user-facing thinking summary using the formatter LLM when available.
+
+    Args:
+        content: High-level status text describing the step progress.
+        tool_calls: Serialized tool call dictionaries with outputs.
+        is_final: Whether the task has completed.
+
+    Returns:
+        Markdown-formatted summary string, or ``None`` when not applicable.
+    """
+def create_error_response(error_message: str, recording_url: str = '') -> dict:
+    """Create a standardized error response.
+
+    Args:
+        error_message: The error message to include.
+        recording_url: The recording URL if available.
+
+    Returns:
+        dict: Standardized error response.
+    """
+def generate_step_content(tool_calls: list[ToolCallInfo], is_done: bool) -> str:
+    """Return user-friendly status text derived from tool call outputs.
+
+    Args:
+        tool_calls: Tool call descriptors extracted from the step.
+        is_done: Flag indicating whether this is the final step in the run.
+
+    Returns:
+        User-friendly status text string.
+    """
+def yield_iframe_activity(url: str, content: str) -> dict:
+    """Create and return an iframe activity streaming response.
+
+    Args:
+        url: The URL to display in the iframe.
+        content: The content message for the response.
+
+    Returns:
+        dict: Streaming response dictionary.
+    """
+def yield_status_message(content: str) -> dict:
+    """Create a status update event notifying clients about recovery attempts.
+
+    Args:
+        content: The status message content to include in the event.
+
+    Returns:
+        dict: Streaming response dictionary for the status update event.
+    """
+def yield_thinking_marker(marker_type: Literal['start', 'end']) -> dict:
+    """Create and return a thinking marker streaming response.
+
+    Args:
+        marker_type: Either 'start' or 'end' to indicate thinking phase.
+
+    Returns:
+        dict: Streaming response dictionary.
+    """

aip_agents/tools/browser_use/structured_data_parser.pyi

@@ -0,0 +1,86 @@
+from aip_agents.tools.browser_use.types import ToolCallInfo
+from collections.abc import Callable, Sequence
+from typing import Any
+
+__all__ = ['attempt_json_recovery', 'detect_structured_data_failure', 'extract_content_after_marker', 'extract_json_blob', 'parse_structured_data', 'payload_reports_empty', 'payload_reports_error', 'structured_data_failure_for_call']
+
+def detect_structured_data_failure(tool_calls: Sequence[ToolCallInfo], summarize_error: Callable[[str], str]) -> str | None:
+    """Return a descriptive error when structured data extraction yields no results.
+
+    Args:
+        tool_calls: Tool call descriptors extracted from the latest agent step.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Failure reason when extraction yielded nothing, otherwise None.
+    """
+def structured_data_failure_for_call(call: ToolCallInfo, summarize_error: Callable[[str], str]) -> str | None:
+    """Evaluate a single tool call for extractor failures.
+
+    Args:
+        call: Tool call descriptor encapsulating name/args/output.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Failure message when the call represents a bad extraction.
+    """
+def payload_reports_error(payload: dict[str, Any], raw_output: str, summarize_error: Callable[[str], str]) -> str | None:
+    """Return a formatted error message when extractor status indicates failure.
+
+    Args:
+        payload: Parsed JSON payload emitted by the extractor.
+        raw_output: Original extractor output (used for fallback summaries).
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Human-readable failure string when extraction failed.
+    """
+def payload_reports_empty(payload: dict[str, Any], raw_output: str, summarize_error: Callable[[str], str]) -> str | None:
+    """Return a formatted message when the extractor returned no usable data.
+
+    Args:
+        payload: Parsed JSON payload emitted by the extractor.
+        raw_output: Original extractor output string.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        str | None: Human-readable failure message when no content was extracted.
+    """
+def parse_structured_data(output: str, summarize_error: Callable[[str], str]) -> tuple[dict[str, Any] | list[Any] | None, str | None]:
+    """Extract the JSON blob emitted by extract_structured_data if present.
+
+    Args:
+        output: Raw string payload returned by extract_structured_data.
+        summarize_error: Function to summarize error messages.
+
+    Returns:
+        tuple[dict[str, Any] | list[Any] | None, str | None]: Parsed JSON payload when extraction succeeds,
+            otherwise a tuple containing None and a diagnostic string on failure.
+    """
+def extract_content_after_marker(output: str) -> str | None:
+    """Extract content after the 'Extracted Content:' marker and clean trailing metadata.
+
+    Args:
+        output: Raw string payload returned by extract_structured_data.
+
+    Returns:
+        str | None: Cleaned content after the marker, or None if marker not found.
+    """
+def extract_json_blob(content: str) -> str | None:
+    """Extract the JSON blob from content by finding delimiters and trimming trailing content.
+
+    Args:
+        content: Content string potentially containing JSON.
+
+    Returns:
+        str | None: Extracted JSON blob, or None if no valid JSON delimiters found.
+    """
+def attempt_json_recovery(json_blob: str) -> dict[str, Any] | list[Any] | None:
+    """Attempt to parse JSON blob, with recovery strategies for common issues.
+
+    Args:
+        json_blob: JSON string to attempt parsing.
+
+    Returns:
+        dict[str, Any] | list[Any] | None: Parsed JSON data if successful, None if all recovery attempts fail.
+    """

aip_agents/tools/browser_use/structured_data_recovery.pyi

@@ -0,0 +1,43 @@
+from _typeshed import Incomplete
+from aip_agents.utils.logger import get_logger as get_logger
+from typing import Any
+
+logger: Incomplete
+
+def recover_concatenated_json_objects(json_blob: str) -> dict[str, Any] | None:
+    """Normalize concatenated JSON object strings into a structured payload.
+
+    Args:
+        json_blob: Raw JSON-like string returned by the structured data extractor.
+
+    Returns:
+        dict[str, Any] | None: Standardized payload when multiple objects are recovered,
+        otherwise None.
+    """
+def repair_json_blob(json_blob: str) -> str | None:
+    """Apply json_repair to malformed JSON strings and return the mutated payload.
+
+    Args:
+        json_blob: Raw JSON string that may contain syntax mistakes.
+
+    Returns:
+        str | None: Repaired JSON string when modifications were applied, otherwise None.
+    """
+
+class _JsonObjectSplitter:
+    """Helper class to split JSON objects with reduced cognitive complexity."""
+    json_blob: Incomplete
+    segments: list[str]
+    depth: int
+    start: int | None
+    last_end: int
+    in_string: bool
+    escaping: bool
+    def __init__(self, json_blob: str) -> None:
+        """Initialize the splitter with the raw JSON string.
+
+        Args:
+            json_blob: Raw string potentially containing concatenated JSON objects.
+        """
+    def split_objects(self) -> list[str]:
+        """Main method to split JSON objects."""

aip_agents/tools/browser_use/types.pyi

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from typing import Any
+
+__all__ = ['BrowserUseFatalError', 'RetryDecision', 'StreamingResponse', 'StreamingState', 'ToolCallInfo']
+
+class BrowserUseFatalError(RuntimeError):
+    """Raised when the Browser Use session must terminate immediately."""
+
+@dataclass
+class ToolCallInfo:
+    """Structured information for a single tool call."""
+    name: str
+    args: dict[str, Any]
+    output: str
+
+@dataclass
+class StreamingResponse:
+    """Standardized streaming response structure."""
+    event_type: str
+    content: str
+    thinking_and_activity_info: dict
+    is_final: bool
+    tool_info: dict[str, Any] | None = ...
+    metadata: dict[str, Any] | None = ...
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary format for yielding."""
+
+@dataclass
+class StreamingState:
+    """State management for streaming operations."""
+    debug_url: str
+    recording_url: str
+    step_count: int = ...
+    is_complete: bool = ...
+    session_id: str | None = ...
+    terminal_error: str | None = ...
+    recording_started: bool = ...
+
+@dataclass
+class RetryDecision:
+    """Encapsulate retry metadata when Steel sessions need to be restarted."""
+    retries_remaining: int
+    attempted_retries: int
+    message: str
+    delay: float

aip_agents/tools/code_sandbox/__init__.pyi

@@ -0,0 +1,3 @@
+from aip_agents.tools.code_sandbox.e2b_sandbox_tool import E2BCodeSandboxTool as E2BCodeSandboxTool
+
+__all__ = ['E2BCodeSandboxTool']

aip_agents/tools/code_sandbox/constant.pyi

@@ -0,0 +1,4 @@
+from _typeshed import Incomplete
+
+DATA_FILE_NAME: str
+DATA_FILE_PATH: Incomplete

aip_agents/tools/code_sandbox/e2b_cloud_sandbox_extended.pyi

@@ -0,0 +1,102 @@
+from _typeshed import Incomplete
+from aip_agents.tools.code_sandbox.constant import DATA_FILE_PATH as DATA_FILE_PATH
+from aip_agents.utils.logger import get_logger as get_logger
+from gllm_inference.schema import Attachment as Attachment
+from gllm_tools.code_interpreter.code_sandbox.e2b_sandbox import E2BSandbox
+from gllm_tools.code_interpreter.code_sandbox.models import ExecutionResult
+from typing import Any
+
+logger: Incomplete
+
+class SandboxFileWatcher:
+    """File watcher for monitoring file creation in sandbox environments."""
+    sandbox: Incomplete
+    def __init__(self, sandbox: Any) -> None:
+        """Initialize the file watcher with a sandbox instance.
+
+        Args:
+            sandbox (Any): The sandbox instance to monitor.
+        """
+    def setup_monitoring(self) -> None:
+        """Set up filesystem watchers for monitoring file creation.
+
+        Note: /tmp/output is a sandbox-isolated directory, not a shared system /tmp.
+        This directory is scoped to the E2B sandbox instance and is safe for use.
+        """
+    async def process_events(self) -> None:
+        """Process filesystem events from watchers and update created files list."""
+    def reset_created_files(self) -> None:
+        """Reset the list of created files."""
+    def get_created_files(self) -> list[str]:
+        """Get the list of files created during monitoring.
+
+        Returns:
+            list[str]: List of file paths that were created.
+        """
+
+class MyE2BCloudSandbox(E2BSandbox):
+    """Extended E2B sandbox with filesystem monitoring capabilities.
+
+    Use `create()` in production to build a fully initialized sandbox wrapper.
+    Direct construction is intentionally blocked to prevent partially initialized
+    instances that lack the underlying E2B sandbox clients.
+    """
+    file_watcher: SandboxFileWatcher | None
+    def __init__(self, language: str = 'python', *, _unsafe_allow_init: bool = False) -> None:
+        """Initialize the sandbox wrapper.
+
+        Args:
+            language (str): Language to execute inside the sandbox.
+            _unsafe_allow_init (bool): Escape hatch for tests/mocks only.
+
+        Raises:
+            RuntimeError: When instantiated directly without `create()`.
+        """
+    @classmethod
+    async def create(cls, api_key: str, domain: str | None = None, template: str | None = None, language: str = 'python', additional_packages: list[str] | None = None, **kwargs: Any) -> MyE2BCloudSandbox:
+        """Create a fully initialized sandbox wrapper.
+
+        This is the supported construction path for production usage. It wires
+        the E2B sandbox instance and its filesystem/command clients, then
+        installs language dependencies.
+        """
+    async def execute_code(self, code: str, timeout: int = 30, files: list[Attachment] | None = None, **kwargs: Any) -> ExecutionResult:
+        """Execute code in the E2B Cloud sandbox with filesystem monitoring.
+
+        This override fixes the Pydantic validation error by ensuring execution.error
+        is converted to string. Always enables filesystem monitoring to track
+        created files.
+
+        Args:
+            code (str): The code to execute.
+            timeout (int, optional): Maximum execution time in seconds. Defaults to 30.
+            files (list[Attachment] | None, optional): List of Attachment objects with file details. Defaults to None.
+            **kwargs (Any): Additional execution parameters.
+
+        Returns:
+            ExecutionResult: Structured result of the execution.
+
+        Raises:
+            RuntimeError: If sandbox is not initialized.
+        """
+    def get_created_files(self) -> list[str]:
+        """Get the list of files created during the last monitored execution.
+
+        Returns:
+            list[str]: List of file paths that were created.
+        """
+    def download_file(self, file_path: str) -> bytes | None:
+        """Download file content from the sandbox.
+
+        Uses download_url when available to avoid binary corruption issues.
+        Falls back to the filesystem API when download_url fails or is unavailable.
+
+        Args:
+            file_path (str): Path to the file in the sandbox.
+
+        Returns:
+            bytes | None: File content as bytes, or None if download fails.
+
+        Raises:
+            RuntimeError: If sandbox is not initialized.
+        """

aip_agents/tools/code_sandbox/e2b_sandbox_tool.pyi

@@ -0,0 +1,29 @@
+from _typeshed import Incomplete
+from aip_agents.a2a.types import get_mime_type_from_filename as get_mime_type_from_filename
+from aip_agents.tools.code_sandbox.constant import DATA_FILE_NAME as DATA_FILE_NAME
+from aip_agents.tools.code_sandbox.e2b_cloud_sandbox_extended import MyE2BCloudSandbox as MyE2BCloudSandbox
+from aip_agents.utils.artifact_helpers import ArtifactHandler as ArtifactHandler, create_multiple_artifacts_response as create_multiple_artifacts_response
+from aip_agents.utils.logger import get_logger as get_logger
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+from typing import Any
+
+logger: Incomplete
+
+class E2BCodeSandboxInput(BaseModel):
+    """Input schema for the E2BCodeSandboxTool."""
+    code: str
+    data_source: str | list[dict[str, Any]] | None
+    timeout: int
+    language: str
+    additional_packages: list[str] | None
+
+class E2BCodeSandboxTool(BaseTool):
+    """Tool to execute Python code in E2B Cloud Sandbox."""
+    name: str
+    description: str
+    save_output_history: bool
+    args_schema: type[BaseModel]
+    api_key: str
+    default_additional_packages: list[str]
+    store_final_output: bool

aip_agents/tools/constants.pyi

@@ -0,0 +1,138 @@
+from _typeshed import Incomplete
+from enum import Enum, StrEnum
+
+GL_CONNECTORS_BASE_URL: Incomplete
+GL_CONNECTORS_API_KEY: Incomplete
+GL_CONNECTORS_FETCH_MAX_RETRIES: Incomplete
+BOSA_API_BASE_URL = GL_CONNECTORS_BASE_URL
+BOSA_API_KEY = GL_CONNECTORS_API_KEY
+BOSA_FETCH_MAX_RETRIES = GL_CONNECTORS_FETCH_MAX_RETRIES
+
+class ToolType(StrEnum):
+    """Tool types for GL Connectors."""
+    GLLM: str
+    LANGCHAIN: str
+
+class Action(Enum):
+    """Actions for GL Connectors."""
+    GITHUB: str
+    GOOGLE: str
+    GOOGLE_DRIVE: str
+    GOOGLE_MAIL: str
+    TWITTER: str
+
+class GitHubEndpoint(Enum):
+    """GitHub endpoints for GL Connectors."""
+    INTEGRATIONS: str
+    USER_HAS_INTEGRATION: str
+    SUCCESS_AUTHORIZE_CALLBACK: str
+    CREATE_ISSUE_HANDLER: str
+    GET_ISSUE_HANDLER: str
+    LIST_ISSUES: str
+    LIST_ISSUES_COMMENTS: str
+    SEARCH_ALL_ISSUES: str
+    GET_COMMITS: str
+    SEARCH_COMMITS: str
+    GET_COLLABORATORS: str
+    GET_RELEASES: str
+    GET_CONTRIBUTORS: str
+    GET_LANGUAGES: str
+    SEARCH_CONTRIBUTIONS: str
+    LIST_PULL_REQUESTS: str
+    SEARCH_PR: str
+    GET_PULL: str
+    GET_ALL_CONTRIBUTOR_COMMIT_ACTIVITIES: str
+    GET_COMMIT_ACTIVITY: str
+    GET_WEEKLY_COMMIT_COUNTS: str
+    GET_USER_CONTRIBUTION_STATISTICS: str
+    LIST_PROJECT_ITEMS: str
+    LIST_PROJECTS: str
+
+class GoogleDriveEndpoint(Enum):
+    """Google Drive endpoints for GL Connectors."""
+    INTEGRATIONS: str
+    USER_HAS_INTEGRATION: str
+    SUCCESS_AUTHORIZE_CALLBACK: str
+    SEARCH_FILES: str
+    GET_FILE: str
+    CREATE_FILE: str
+    CREATE_FOLDER: str
+    UPDATE_FILE: str
+    UPDATE_FOLDER: str
+    COPY_FILE: str
+    DELETE_FILE: str
+    SUMMARIZE_FOLDER_FILES_BY_TYPE: str
+    SUMMARIZE_TOTAL_FILES_BY_TYPE: str
+    RECENT_FILES: str
+    CREATE_PERMISSION: str
+    LIST_PERMISSIONS: str
+    GET_PERMISSION: str
+    UPDATE_PERMISSION: str
+    DELETE_PERMISSION: str
+    DOWNLOAD_FILE: str
+
+class GoogleDocsEndpoint(Enum):
+    """Google Docs endpoints for GL Connectors."""
+    INTEGRATIONS: str
+    USER_HAS_INTEGRATION: str
+    SUCCESS_AUTHORIZE_CALLBACK: str
+    GET_DOCUMENT: str
+    LIST_DOCUMENTS: str
+    CREATE_DOCUMENT: str
+    UPDATE_DOCUMENT: str
+    COPY_CONTENT: str
+    UPDATE_DOCUMENT_MARKDOWN: str
+    LIST_COMMENTS: str
+    SUMMARIZE_COMMENTS: str
+
+class GoogleEndpoint(Enum):
+    """Google endpoints for GL Connectors."""
+    INTEGRATIONS: str
+    USER_HAS_INTEGRATION: str
+    SUCCESS_AUTHORIZE_CALLBACK: str
+    USERINFO: str
+
+class TwitterEndpoint(Enum):
+    """Twitter endpoints for GL Connectors."""
+    INTEGRATIONS: str
+    USER_HAS_INTEGRATION: str
+    SUCCESS_AUTHORIZE_CALLBACK: str
+    SEARCH: str
+    GET_TWEETS: str
+    GET_THREAD: str
+    GET_USERS: str
+
+class GoogleMailEndpoint(Enum):
+    """Google Mail endpoints for GL Connectors."""
+    INTEGRATIONS: str
+    USER_HAS_INTEGRATION: str
+    SUCCESS_AUTHORIZE_CALLBACK: str
+    CREATE_DRAFT: str
+    LIST_DRAFTS: str
+    SEND_DRAFT: str
+    GET_DRAFT: str
+    MODIFY_DRAFT: str
+    LIST_LABELS: str
+    LABEL_STATS: str
+    GET_LABEL_DETAILS: str
+    CREATE_LABELS: str
+    MODIFY_LABELS: str
+    DELETE_LABELS: str
+    SEND_EMAIL: str
+    LIST_EMAILS: str
+    GET_EMAIL_DETAILS: str
+    MODIFY_EMAIL: str
+    DELETE_EMAIL: str
+    TRASH_EMAIL: str
+    UNTRASH_EMAIL: str
+    LIST_THREADS: str
+    THREAD_DETAILS: str
+    MODIFY_THREAD: str
+    GET_AUTO_REPLY: str
+    SET_AUTO_REPLY: str
+    GET_ATTACHMENT: str
+    USERINFO: str
+
+class ActionEndpointMap:
+    """Maps Action enums to their corresponding Endpoint enums."""
+    MAP: dict[Action, type[Enum]]

aip_agents/tools/document_loader/__init__.pyi

@@ -0,0 +1,7 @@
+from aip_agents.tools.document_loader.base_reader import BaseDocumentReaderTool as BaseDocumentReaderTool, DocumentReaderInput as DocumentReaderInput
+from aip_agents.tools.document_loader.docx_reader_tool import DocxReaderTool as DocxReaderTool
+from aip_agents.tools.document_loader.excel_reader_tool import ExcelReaderTool as ExcelReaderTool
+from aip_agents.tools.document_loader.pdf_reader_tool import PDFReaderTool as PDFReaderTool
+from aip_agents.tools.document_loader.pdf_splitter import PDFSplitter as PDFSplitter
+
+__all__ = ['BaseDocumentReaderTool', 'DocumentReaderInput', 'PDFReaderTool', 'DocxReaderTool', 'ExcelReaderTool', 'PDFSplitter']

aip_agents/tools/document_loader/base_reader.pyi

@@ -0,0 +1,75 @@
+from _typeshed import Incomplete
+from abc import ABC
+from aip_agents.utils.logger import get_logger as get_logger
+from gllm_docproc.loader.pipeline_loader import PipelineLoader as PipelineLoaderType
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+from typing import Any
+
+logger: Incomplete
+DOCPROC_MISSING_MESSAGE: str
+PipelineLoaderType = Any
+
+class _MissingDocprocLoader:
+    """Fallback loader that errors when document processing is attempted."""
+    loaders: list[object]
+    def __init__(self) -> None: ...
+    def add_loader(self, loader: object) -> None: ...
+    def load(self, *_args: object, **_kwargs: object) -> list[dict[str, str]]: ...
+    def clear_cache(self) -> None: ...
+
+DOCPROC_AVAILABLE: Incomplete
+
+class BaseDocumentConfig(BaseModel):
+    """Base tool configuration schema for document processing with batching functionality.
+
+    This configuration enables page-by-page batching to optimize memory usage when
+    processing large document files. When batching is enabled, documents are processed
+    sequentially by pages rather than loading the entire document into memory at once.
+
+    Attributes:
+        batching (bool): Enable page-by-page batching to reduce memory usage.
+            When True, documents are processed page by page sequentially.
+            When False, maintains current behavior of loading entire document.
+            Defaults to False for backward compatibility.
+        batch_size (int): Number of pages to process in each batch.
+            Must be between 1 and 100 pages inclusive.
+            Larger batch sizes may use more memory but could be more efficient.
+            Smaller batch sizes use less memory but may have more overhead.
+            Defaults to 10 for balanced memory usage and efficiency.
+
+    Examples:
+        >>> # Default configuration (no batching)
+        >>> config = BaseDocumentConfig()
+        >>> print(config.batching)  # False
+        >>> print(config.batch_size)  # 10
+
+        >>> # Enable batching with single page processing
+        >>> config = BaseDocumentConfig(batching=True, batch_size=1)
+
+        >>> # Enable batching with multi-page batches
+        >>> config = BaseDocumentConfig(batching=True, batch_size=3)
+    """
+    batching: bool
+    batch_size: int
+
+class DocumentReaderInput(BaseModel):
+    """Input schema for the DocumentReader tool."""
+    file_path: str
+
+class BaseDocumentReaderTool(BaseTool, ABC):
+    """Base tool to read and extract text from document files."""
+    name: str
+    description: str
+    args_schema: type[BaseModel]
+    tool_config_schema: type[BaseModel]
+    loader: PipelineLoaderType
+    def __init__(self) -> None:
+        """Initialize the base document reader tool."""
+    def cleanup_memory(self) -> None:
+        """Explicitly clean up memory and force garbage collection.
+
+        This method can be called after processing to minimize memory usage.
+        While it won't reset memory to exactly 0, it will free up as much
+        memory as possible by clearing internal caches and forcing garbage collection.
+        """

aip_agents/tools/document_loader/docx_reader_tool.pyi

@@ -0,0 +1,10 @@
+from _typeshed import Incomplete
+from aip_agents.tools.document_loader.base_reader import BaseDocumentReaderTool as BaseDocumentReaderTool, DOCPROC_MISSING_MESSAGE as DOCPROC_MISSING_MESSAGE
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class DocxReaderTool(BaseDocumentReaderTool):
+    """Tool to read and extract text from Word documents."""
+    name: str
+    description: str

aip_agents/tools/document_loader/excel_reader_tool.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+from aip_agents.tools.document_loader.base_reader import BaseDocumentReaderTool as BaseDocumentReaderTool, DOCPROC_MISSING_MESSAGE as DOCPROC_MISSING_MESSAGE
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class ExcelReaderTool(BaseDocumentReaderTool):
+    '''Tool to read and extract content from Excel files.
+
+    This tool reads Excel files (.xlsx, .xlsm) and extracts their content using
+    the gllm_docproc loader pipeline. The content is formatted as Markdown tables
+    for easy readability.
+
+    Features:
+    - Supports .xlsx and .xlsm formats
+    - Extracts all sheets or specific sheets
+    - Formats output as Markdown tables
+    - Configurable row limits and file size limits
+
+    Examples:
+        >>> tool = ExcelReaderTool()
+        >>> result = tool._run("/tmp/data.xlsx")
+        >>> print(result)
+    '''
+    name: str
+    description: str

aip_agents/tools/document_loader/pdf_reader_tool.pyi

@@ -0,0 +1,11 @@
+from _typeshed import Incomplete
+from aip_agents.tools.document_loader.base_reader import BaseDocumentReaderTool as BaseDocumentReaderTool, DOCPROC_MISSING_MESSAGE as DOCPROC_MISSING_MESSAGE
+from aip_agents.tools.document_loader.pdf_splitter import PDFSplitter as PDFSplitter
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+
+class PDFReaderTool(BaseDocumentReaderTool):
+    """Tool to read and extract text from PDF files."""
+    name: str
+    description: str