aip-agents-binary 0.0.0b2__py3-none-any.whl → 0.5.11__py3-none-any.whl

aip_agents/utils/langgraph/tool_output_management.pyi

@@ -1,7 +1,7 @@
 from _typeshed import Incomplete
 from aip_agents.storage.providers.base import BaseStorageProvider as BaseStorageProvider, StorageError as StorageError
 from aip_agents.storage.providers.memory import InMemoryStorageProvider as InMemoryStorageProvider
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
+from aip_agents.utils.logger import get_logger as get_logger
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import Any
@@ -91,7 +91,14 @@ class ToolOutput:
     def is_metadata_only(self) -> bool:
         """Check if this instance contains only metadata without data."""
     def is_expired(self, max_age: timedelta) -> bool:
-        """Check if this output has expired based on the given maximum age."""
+        """Check if this output has expired based on the given maximum age.
+
+        Args:
+            max_age (timedelta): The maximum age allowed before expiration.
+
+        Returns:
+            bool: True if the output has expired, False otherwise.
+        """
     def get_data_preview(self, max_length: int = 200, storage_provider: BaseStorageProvider | None = None, thread_id: str | None = None) -> str | None:
         """Get a truncated string representation of the stored data.
 
@@ -109,6 +116,12 @@ class ToolOutput:
         Returns a new ToolOutput instance with the same metadata but with
         data field populated. Useful for converting metadata-only instances
         to complete instances.
+
+        Args:
+            data (Any): The actual output data to populate.
+
+        Returns:
+            ToolOutput: A new instance with data populated.
         """
 
 @dataclass
@@ -219,37 +232,6 @@ class ToolOutputManager:
             A JSON string containing structured data about tool outputs. Always returns
             valid JSON, even when no outputs are stored (empty entries list).
         """
-    def get_stats(self) -> dict[str, Any]:
-        """Get thread-safe statistics about the current state of the manager.
-
-        Args:
-            thread_id: Thread ID to generate summary for.
-            max_entries: Maximum number of entries to include in the summary.
-            Defaults to 10.
-
-        Returns:
-            Dictionary containing current statistics including output count,
-            total size, call count, and thread information.
-        """
-    def clear_all_outputs(self) -> int:
-        """Clear all stored outputs and reset counters.
-
-        Thread-safe: This method uses internal locking to ensure safe concurrent access.
-
-        Returns:
-            Number of outputs that were cleared.
-        """
-    def clear_thread_outputs(self, thread_id: str) -> int:
-        """Clear all stored outputs for a specific thread.
-
-        Thread-safe: This method uses internal locking to ensure safe concurrent access.
-
-        Args:
-            thread_id: The thread ID to clear outputs for.
-
-        Returns:
-            Number of outputs that were cleared for the thread.
-        """
     def clear_all(self) -> None:
         """Clear all stored outputs from both metadata and storage.
 

aip_agents/utils/logger.py

@@ -0,0 +1,195 @@
+"""Defines a logger for logging.
+
+Example of displayed logs using simple format:
+    [2025-11-27T15:50:03+0700.643 uvicorn.error INFO] Application startup complete.
+
+Example of displayed logs using JSON format:
+    {"timestamp": "2025-11-27T15:51:00+0700", "name": "uvicorn.error", "level": "INFO", "message": "Application startup complete."}
+
+Authors:
+    Reinhart Linanda (reinhart.linanda@gdplabs.id)
+
+References:
+    [1] https://github.com/GDP-ADMIN/gsdp
+    [2] https://docs.google.com/document/d/1RnXbiAGc6vCFt03YPMM8UleRy0h_pRjzqobdb_u8ty0/edit?tab=t.0
+        (Proposal for Standardized Log Format)
+    [3] https://github.com/GDP-ADMIN/glchat/blob/main/applications/glchat-be/glchat_be/utils/logger.py
+"""
+
+import logging
+import os
+import threading
+import warnings
+
+from dotenv import load_dotenv
+from gllm_core.utils.logger_manager import LoggerManager
+
+load_dotenv()
+
+LOGGER_NAME = "AIPAgentsLogger"
+
+LOG_LEVEL = os.getenv("LOG_LEVEL", logging.INFO)
+if isinstance(LOG_LEVEL, str):
+    try:
+        LOG_LEVEL = getattr(logging, LOG_LEVEL.upper())
+    except AttributeError:
+        LOG_LEVEL = logging.INFO
+
+
+class _GoogleAdkLogFilter(logging.Filter):
+    """Suppress noisy Google ADK model registry logs.
+
+    Google ADK emits a burst of INFO logs when registering Gemini model patterns.
+    They are redundant (class is unchanged) and clutter our startup output, so we
+    drop them at the logging infrastructure level instead of touching ADK internals.
+    """
+
+    SUPPRESSED_PREFIX = "Updating LLM class for"
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Return False when the log should be discarded.
+
+        Args:
+            record (logging.LogRecord): The log record to filter.
+
+        Returns:
+            bool: True if the log should be processed, False if it should be discarded.
+        """
+        if not record.name.startswith("google.adk"):
+            return True
+
+        try:
+            message = record.getMessage()
+        except Exception:  # pragma: no cover - defensive fallback
+            message = str(record.msg)
+
+        if isinstance(message, str) and message.startswith(self.SUPPRESSED_PREFIX):
+            return False
+
+        return True
+
+
+LOG_FILTERS = [_GoogleAdkLogFilter()]
+
+logger_manager = LoggerManager()
+root_logger = logger_manager.get_logger()
+
+_LOGGER_LOCK = threading.Lock()
+
+_LOG_FILTERS_CONFIGURED = False
+
+
+def _configure_log_filters() -> None:
+    """Configure log filters to be applied to all handlers."""
+    global _LOG_FILTERS_CONFIGURED
+
+    with _LOGGER_LOCK:
+        if _LOG_FILTERS_CONFIGURED:
+            return
+
+        for log_filter in LOG_FILTERS:
+            root_logger.addFilter(log_filter)
+            for handler in root_logger.handlers:
+                handler.addFilter(log_filter)
+
+        _LOG_FILTERS_CONFIGURED = True
+
+
+_configure_log_filters()
+
+
+def get_logger(name: str = LOGGER_NAME, level: int = LOG_LEVEL) -> logging.Logger:
+    """Get a logger instance.
+
+    Args:
+        name (str): The name of the logger. Defaults to AIPAgentsLogger.
+        level (int): The level of the logger. Defaults to INFO.
+
+    Returns:
+        logging.Logger: The logger instance.
+    """
+    with _LOGGER_LOCK:
+        if not name:
+            name = LOGGER_NAME
+        if logging._levelToName.get(level) is None:
+            level = LOG_LEVEL
+
+        logger = logger_manager.get_logger(name)
+        logger.setLevel(level)
+        logger.propagate = False
+
+        if not logger.hasHandlers():
+            logger.handlers = root_logger.handlers
+
+        return logger
+
+
+logger = get_logger()
+
+THIRD_PARTY_LOGGER_NAMES = [
+    "uvicorn",
+    "uvicorn.access",
+    "uvicorn.error",
+    "apscheduler",
+    "apscheduler.scheduler",
+    "apscheduler.executors.default",
+    "apscheduler.jobstores.default",
+]
+
+_THIRD_PARTY_LOGGERS_CONFIGURED = False
+
+
+def _configure_third_party_loggers() -> None:
+    """Configure third-party loggers to use the same handlers and settings."""
+    global _THIRD_PARTY_LOGGERS_CONFIGURED
+
+    with _LOGGER_LOCK:
+        if _THIRD_PARTY_LOGGERS_CONFIGURED:
+            return
+
+        for name in THIRD_PARTY_LOGGER_NAMES:
+            third_party_logger = logging.getLogger(name)
+            third_party_logger.handlers = logger.handlers
+            third_party_logger.setLevel(logger.level)
+            third_party_logger.propagate = logger.propagate
+
+        _THIRD_PARTY_LOGGERS_CONFIGURED = True
+
+
+_configure_third_party_loggers()
+
+
+class LoggerManager:
+    """A singleton class to manage logging configuration.
+
+    This class is deprecated and will be removed in a future version.
+    Use get_logger() function directly instead.
+    """
+
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        """Initialize the singleton instance."""
+        warnings.warn(
+            "LoggerManager is deprecated and will be removed in a future version. "
+            "Use get_logger() function directly instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+            return cls._instance
+
+    def get_logger(self, name: str = LOGGER_NAME, level: int = LOG_LEVEL) -> logging.Logger:
+        """Get a logger instance.
+
+        Args:
+            name (str): The name of the logger. Defaults to AIPAgentsLogger.
+            level (int): The level of the logger. Defaults to INFO.
+
+        Returns:
+            logging.Logger: The logger instance.
+        """
+        return get_logger(name, level)

aip_agents/utils/logger.pyi

@@ -0,0 +1,60 @@
+import logging
+from _typeshed import Incomplete
+
+LOGGER_NAME: str
+LOG_LEVEL: Incomplete
+
+class _GoogleAdkLogFilter(logging.Filter):
+    """Suppress noisy Google ADK model registry logs.
+
+    Google ADK emits a burst of INFO logs when registering Gemini model patterns.
+    They are redundant (class is unchanged) and clutter our startup output, so we
+    drop them at the logging infrastructure level instead of touching ADK internals.
+    """
+    SUPPRESSED_PREFIX: str
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Return False when the log should be discarded.
+
+        Args:
+            record (logging.LogRecord): The log record to filter.
+
+        Returns:
+            bool: True if the log should be processed, False if it should be discarded.
+        """
+
+LOG_FILTERS: Incomplete
+logger_manager: Incomplete
+root_logger: Incomplete
+
+def get_logger(name: str = ..., level: int = ...) -> logging.Logger:
+    """Get a logger instance.
+
+    Args:
+        name (str): The name of the logger. Defaults to AIPAgentsLogger.
+        level (int): The level of the logger. Defaults to INFO.
+
+    Returns:
+        logging.Logger: The logger instance.
+    """
+
+logger: Incomplete
+THIRD_PARTY_LOGGER_NAMES: Incomplete
+
+class LoggerManager:
+    """A singleton class to manage logging configuration.
+
+    This class is deprecated and will be removed in a future version.
+    Use get_logger() function directly instead.
+    """
+    def __new__(cls):
+        """Initialize the singleton instance."""
+    def get_logger(self, name: str = ..., level: int = ...) -> logging.Logger:
+        """Get a logger instance.
+
+        Args:
+            name (str): The name of the logger. Defaults to AIPAgentsLogger.
+            level (int): The level of the logger. Defaults to INFO.
+
+        Returns:
+            logging.Logger: The logger instance.
+        """

aip_agents/utils/metadata/__init__.py

@@ -0,0 +1,27 @@
+"""Metadata utilities module.
+
+This module contains utilities for creating and handling metadata for A2A communication.
+
+Authors:
+    Fachriza Adhiatma (fachriza.d.adhiatma@gdplabs.id)
+"""
+
+from aip_agents.utils.metadata.activity_metadata_helper import (
+    DEFAULT_ACTIVITY_INFO,
+    _format_tool_or_subagent_name,
+    create_tool_activity_info,
+)
+from aip_agents.utils.metadata.schemas import Activity, ActivityDataType, Thinking
+from aip_agents.utils.metadata.thinking_metadata_helper import (
+    FINAL_THINKING_INFO,
+)
+
+__all__ = [
+    "Activity",
+    "ActivityDataType",
+    "Thinking",
+    "create_tool_activity_info",
+    "DEFAULT_ACTIVITY_INFO",
+    "_format_tool_or_subagent_name",
+    "FINAL_THINKING_INFO",
+]

aip_agents/utils/metadata/__init__.pyi

@@ -0,0 +1,5 @@
+from aip_agents.utils.metadata.activity_metadata_helper import DEFAULT_ACTIVITY_INFO as DEFAULT_ACTIVITY_INFO, _format_tool_or_subagent_name as _format_tool_or_subagent_name, create_tool_activity_info as create_tool_activity_info
+from aip_agents.utils.metadata.schemas import Activity as Activity, ActivityDataType as ActivityDataType, Thinking as Thinking
+from aip_agents.utils.metadata.thinking_metadata_helper import FINAL_THINKING_INFO as FINAL_THINKING_INFO
+
+__all__ = ['Activity', 'ActivityDataType', 'Thinking', 'create_tool_activity_info', 'DEFAULT_ACTIVITY_INFO', '_format_tool_or_subagent_name', 'FINAL_THINKING_INFO']