aip-agents-binary 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

aip_agents/utils/metadata/activity_narrative/utils.pyi

@@ -1,12 +0,0 @@
-__all__ = ['_format_tool_or_subagent_name']
-
-def _format_tool_or_subagent_name(name: str, remove_delegate_prefix: bool = False) -> str:
-    """Format tool/agent names to 'Camel Case' consistently.
-
-    Args:
-        name: Raw tool or sub-agent identifier.
-        remove_delegate_prefix: Whether to strip the ``delegate::`` prefix before formatting.
-
-    Returns:
-        str: Display-friendly tool or agent name.
-    """

aip_agents/utils/metadata/schemas/__init__.pyi

@@ -1,4 +0,0 @@
-from aip_agents.utils.metadata.schemas.activity_schema import Activity as Activity, ActivityDataType as ActivityDataType
-from aip_agents.utils.metadata.schemas.thinking_schema import Thinking as Thinking
-
-__all__ = ['Activity', 'ActivityDataType', 'Thinking']

aip_agents/utils/metadata/schemas/activity_schema.pyi

@@ -1,18 +0,0 @@
-from enum import StrEnum
-from pydantic import BaseModel
-
-class ActivityDataType(StrEnum):
-    """Enumeration of activity data types."""
-    ACTIVITY: str
-
-class Activity(BaseModel):
-    '''Schema for activity info payload.
-
-    Fields:
-    - data_type: always "activity"
-    - id: UUID string identifying this activity event
-    - data_value: JSON string with additional info (e.g., {"message": "..."})
-    '''
-    data_type: ActivityDataType
-    id: str
-    data_value: str

aip_agents/utils/metadata/schemas/thinking_schema.pyi

@@ -1,20 +0,0 @@
-from enum import StrEnum
-from pydantic import BaseModel
-
-class ThinkingDataType(StrEnum):
-    """Enum for thinking data types."""
-    THINKING: str
-    THINKING_START: str
-    THINKING_END: str
-
-class Thinking(BaseModel):
-    '''Schema for thinking info payload.
-
-    Fields:
-    - data_type: type of thinking event
-    - id: UUID string identifying this thinking event
-    - data_value: JSON string with additional info (e.g., {"message": "..."})
-    '''
-    data_type: ThinkingDataType
-    id: str
-    data_value: str

aip_agents/utils/metadata/thinking_metadata_helper.pyi

@@ -1,4 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.metadata.schemas.thinking_schema import Thinking as Thinking, ThinkingDataType as ThinkingDataType
-
-FINAL_THINKING_INFO: Incomplete

aip_agents/utils/metadata_helper.pyi

@@ -1,117 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.metadata import create_tool_activity_info as create_tool_activity_info
-from aip_agents.utils.token_usage_helper import STEP_USAGE_KEY as STEP_USAGE_KEY, TOTAL_USAGE_KEY as TOTAL_USAGE_KEY
-from enum import StrEnum
-from typing import Any
-
-logger: Incomplete
-
-def start_step_counter_scope(start: int = 1) -> None:
-    """Begin a step counter scope, resetting only when entering the outermost scope.
-
-    Args:
-        start: Starting step number for the counter. Defaults to 1.
-    """
-def end_step_counter_scope() -> None:
-    """Exit a step counter scope, maintaining parent scope counters.
-
-    Decrements the depth counter while preserving the step count for parent scopes.
-    """
-def get_next_step_number() -> int:
-    """Return the next step number within the active scope.
-
-    Returns:
-        int: The next sequential step number in the current scope.
-    """
-
-class DefaultStepMessages(StrEnum):
-    """Constants for default step indicator messages."""
-    EN: str
-    ID: str
-
-class Kind(StrEnum):
-    """Constants for metadata kind values."""
-    AGENT_STEP: str
-    AGENT_THINKING_STEP: str
-    FINAL_RESPONSE: str
-    FINAL_THINKING_STEP: str
-    AGENT_DEFAULT: str
-    TOKEN: str
-
-class Status(StrEnum):
-    """Constants for metadata status values."""
-    RUNNING: str
-    FINISHED: str
-    STOPPED: str
-
-class MetadataFieldKeys(StrEnum):
-    """Enumeration of standard metadata field keys used in A2A events."""
-    KIND: str
-    STATUS: str
-    TIME: str
-    MESSAGE: str
-    TOOL_INFO: str
-    REFERENCES: str
-    THINKING_AND_ACTIVITY_INFO: str
-    HITL: str
-    STEP_USAGE = STEP_USAGE_KEY
-    TOTAL_USAGE = TOTAL_USAGE_KEY
-    TOKEN_STREAMING: str
-    PII_MAPPING: str
-
-class MetadataTimeTracker:
-    """Tracks cumulative execution time across agent steps for final response metadata.
-
-    This class provides a clean way to accumulate execution times from individual
-    agent steps and apply the total time to final response metadata.
-
-    Attributes:
-        FLOAT_EPSILON: Epsilon value for floating point comparisons to avoid precision issues.
-    """
-    FLOAT_EPSILON: float
-    def __init__(self) -> None:
-        """Initialize the time tracker with zero accumulated time."""
-    def update_response_metadata(self, response: dict[str, Any]) -> dict[str, Any]:
-        """Update response metadata with accumulated time tracking.
-
-        Args:
-            response: Response dictionary containing metadata to update.
-
-        Returns:
-            dict[str, Any]: Response with updated metadata for final responses. If any error occurs,
-                returns the original response unchanged.
-        """
-
-def create_metadata(content: str = '', status: Status = ..., is_final: bool = False, existing_metadata: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Create metadata for A2A responses with content-based message.
-
-    Args:
-        content: The content to create metadata for.
-        status: The status of the content.
-        is_final: Whether the content is final.
-        existing_metadata: Optional existing metadata to merge with. Existing metadata
-            takes precedence over generated metadata for conflicting keys.
-
-    Returns:
-        dict[str, Any]: The metadata for the content, merged with existing metadata if provided.
-    """
-def create_tool_processing_metadata(original_metadata: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Create metadata for tool processing events (tool_call and tool_result).
-
-    Args:
-        original_metadata: Optional original metadata to merge with.
-
-    Returns:
-        dict[str, Any]: Metadata dictionary with agent_thinking_step kind and no message/time/status.
-    """
-def create_status_update_metadata(content: str, custom_metadata: dict[str, Any] | None = None) -> dict[str, Any]:
-    """Create metadata for status update events with content-based rules.
-
-    Args:
-        content: The content of the status update.
-        custom_metadata: Optional custom metadata to merge with.
-
-    Returns:
-        dict[str, Any]: Metadata dictionary following the specific rules for different content types.
-    """

aip_agents/utils/name_preprocessor/__init__.pyi

@@ -1,6 +0,0 @@
-from aip_agents.utils.name_preprocessor.base_name_preprocessor import BaseNamePreprocessor as BaseNamePreprocessor
-from aip_agents.utils.name_preprocessor.google_name_preprocessor import GoogleNamePreprocessor as GoogleNamePreprocessor
-from aip_agents.utils.name_preprocessor.name_preprocessor import NamePreprocessor as NamePreprocessor
-from aip_agents.utils.name_preprocessor.openai_name_preprocessor import OpenAINamePreprocessor as OpenAINamePreprocessor
-
-__all__ = ['GoogleNamePreprocessor', 'OpenAINamePreprocessor', 'BaseNamePreprocessor', 'NamePreprocessor']

aip_agents/utils/name_preprocessor/base_name_preprocessor.pyi

@@ -1,52 +0,0 @@
-from abc import ABC, abstractmethod
-
-class BaseNamePreprocessor(ABC):
-    """Base class for name preprocessing.
-
-    It contains the common methods for name preprocessing.
-    """
-    def regex_substitute(self, name: str, regex: str, replacement: str) -> str:
-        """Substitute a regex pattern in a name.
-
-        Args:
-            name: The input name to preprocess.
-            regex: The regex pattern to substitute.
-            replacement: The replacement string.
-
-        Returns:
-            A name that is valid for the name processor.
-        """
-    def clean_up_name(self, name: str) -> str:
-        """Process a processed name.
-
-        Step:
-            1. collapse multiple underscores to single underscore
-            2. remove trailing underscores
-            3. if name is empty after clean up, add a single underscore
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that starts with a letter or an underscore.
-        """
-    @abstractmethod
-    def sanitize_agent_name(self, name: str) -> str:
-        """Process a name according to the rules of the name processor.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for the name processor.
-        """
-    @abstractmethod
-    def sanitize_tool_name(self, name: str) -> str:
-        """Process a name according to the rules of the name processor.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for the name processor.
-        """

aip_agents/utils/name_preprocessor/google_name_preprocessor.pyi

@@ -1,38 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.name_preprocessor import BaseNamePreprocessor as BaseNamePreprocessor
-
-logger: Incomplete
-
-class GoogleNamePreprocessor(BaseNamePreprocessor):
-    """Concrete implementation of NamePreprocessor according to Google's name requirements."""
-    NAME_SETTINGS: Incomplete
-    CUT_OFF_INDEX: int
-    def sanitize_agent_name(self, name: str) -> str:
-        """Preprocess an input name according to Google's name requirements for agents.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for Google.
-
-        Notes:
-            Name should start with a letter (a-z, A-Z) or an underscore (_),
-            and can only contain letters, digits (0-9), and underscores.
-            It has no length limit. ( based on experiment )
-        """
-    def sanitize_tool_name(self, name: str) -> str:
-        """Preprocess an input name according to Google's name requirements for tools.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for Google.
-
-        Notes:
-            Name should start with a letter (a-z, A-Z) or an underscore (_),
-            and can only contain letters, digits (0-9), underscores, and dashes.
-            It has a length limit of 64 characters, but google throws error if the length is exactly 64, so cut to 63.
-        """

aip_agents/utils/name_preprocessor/name_preprocessor.pyi

@@ -1,41 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.name_preprocessor.base_name_preprocessor import BaseNamePreprocessor as BaseNamePreprocessor
-from aip_agents.utils.name_preprocessor.google_name_preprocessor import GoogleNamePreprocessor as GoogleNamePreprocessor
-from aip_agents.utils.name_preprocessor.openai_name_preprocessor import OpenAINamePreprocessor as OpenAINamePreprocessor
-
-logger: Incomplete
-
-class NamePreprocessor:
-    """Name Preprocessor for Google ADK and OpenAI compatible models.
-
-    Args:
-        provider: The provider of the model.
-    """
-    PROVIDER_TO_NAME_PREPROCESSOR_MAP: Incomplete
-    provider: Incomplete
-    preprocessor: Incomplete
-    def __init__(self, provider: str) -> None:
-        """Initialize the name preprocessor.
-
-        Args:
-            provider: The provider of the model.
-        """
-    def sanitize_agent_name(self, name: str) -> str:
-        """Preprocess an input name according to the rules of the name processor.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for the name processor.
-        """
-    def sanitize_tool_name(self, name: str) -> str:
-        """Preprocess an input name according to the rules of the name processor.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for the name processor.
-        """

aip_agents/utils/name_preprocessor/openai_name_preprocessor.pyi

@@ -1,34 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.name_preprocessor import BaseNamePreprocessor as BaseNamePreprocessor
-
-logger: Incomplete
-
-class OpenAINamePreprocessor(BaseNamePreprocessor):
-    """Concrete implementation of NamePreprocessor according to OpenAI's name requirements."""
-    CUT_OFF_INDEX: int
-    def sanitize_agent_name(self, name: str) -> str:
-        """Preprocess an input name according to OpenAI's name requirements for agents.
-
-        As of now, OpenAI only has rule for tool name, and it is the same as Google's tool name rule,
-        so just return the name as is.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for OpenAI.
-        """
-    def sanitize_tool_name(self, name: str) -> str:
-        """Preprocess an input name according to OpenAI's name requirements for tools.
-
-        Args:
-            name: The input name to preprocess.
-
-        Returns:
-            A name that is valid for OpenAI.
-
-        Notes:
-            Only contain letters (a-z, A-Z), digits (0-9), underscores (_), and dashes (-).
-            It has a length limit of 64 characters.
-        """

aip_agents/utils/pii/__init__.pyi

@@ -1,5 +0,0 @@
-from aip_agents.utils.pii.pii_handler import ToolPIIHandler as ToolPIIHandler
-from aip_agents.utils.pii.pii_helper import add_pii_mappings as add_pii_mappings, anonymize_final_response_content as anonymize_final_response_content, deanonymize_final_response_content as deanonymize_final_response_content, extract_pii_mapping_from_agent_response as extract_pii_mapping_from_agent_response, normalize_enable_pii as normalize_enable_pii
-from aip_agents.utils.pii.uuid_deanonymizer_mapping import UUIDDeanonymizerMapping as UUIDDeanonymizerMapping
-
-__all__ = ['ToolPIIHandler', 'add_pii_mappings', 'anonymize_final_response_content', 'deanonymize_final_response_content', 'extract_pii_mapping_from_agent_response', 'normalize_enable_pii', 'UUIDDeanonymizerMapping']

aip_agents/utils/pii/pii_handler.pyi

@@ -1,96 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import LoggerManager as LoggerManager
-from aip_agents.utils.pii.uuid_deanonymizer_mapping import UUIDDeanonymizerMapping as UUIDDeanonymizerMapping
-from enum import Enum
-from gllm_privacy.pii_detector import TextAnalyzer, TextAnonymizer
-from typing import Any
-
-TextAnalyzer = Any
-TextAnonymizer = Any
-GDPLabsNerApiRemoteRecognizer = Any
-
-class _Operation(str, Enum):
-    ANONYMIZE: str
-    DEANONYMIZE: str
-
-logger: Incomplete
-NER_API_URL_ENV_VAR: str
-NER_API_KEY_ENV_VAR: str
-NER_API_TIMEOUT: int
-EXCLUDED_ENTITIES: Incomplete
-DEFAULT_SUPPORTED_ENTITIES: Incomplete
-
-class ToolPIIHandler:
-    """Handles PII masking/demasking for tool calling.
-
-    Tag replacement based on runner-provided mappings always works. Optional
-    NER-powered masking/de-masking is only enabled when NER_API_URL and
-    NER_API_KEY environment variables are set.
-
-    Attributes:
-        flat_pii_mapping: Flat mapping from runner service (tag → value)
-        text_analyzer: GLLM Privacy TextAnalyzer instance
-        text_anonymizer: GLLM Privacy TextAnonymizer instance
-        enable_ner: Whether NER is enabled
-    """
-    flat_pii_mapping: dict[str, str]
-    enable_ner: bool
-    text_analyzer: TextAnalyzer | None
-    text_anonymizer: TextAnonymizer | None
-    def __init__(self, pii_mapping: dict[str, str] | None = None, ner_api_url: str | None = None, ner_api_key: str | None = None) -> None:
-        """Initialize PII handler (private - use create_if_enabled() instead).
-
-        Initializes GLLM Privacy components (TextAnalyzer, TextAnonymizer) if NER credentials
-        are provided. Creates dual recognizers for Indonesian and English languages.
-        Pre-loads any existing PII mappings into the anonymizer's internal state.
-
-        Args:
-            pii_mapping: Existing PII mapping from runner service (flat format: tag -> value)
-            ner_api_url: NER API endpoint URL
-            ner_api_key: NER API authentication key
-        """
-    @classmethod
-    def create_if_enabled(cls, pii_mapping: dict[str, str] | None = None) -> ToolPIIHandler | None:
-        """Create ToolPIIHandler when mappings or NER configuration exist.
-
-        Args:
-            pii_mapping: Existing PII mapping from runner service
-
-        Returns:
-            ToolPIIHandler instance when mapping or NER config is available, None otherwise
-        """
-    @classmethod
-    def create_mapping_only(cls, pii_mapping: dict[str, str] | None = None) -> ToolPIIHandler | None:
-        """Create ToolPIIHandler in mapping-only mode (no NER).
-
-        Args:
-            pii_mapping: Existing PII mapping from runner service
-
-        Returns:
-            ToolPIIHandler instance when mapping exists, None otherwise
-        """
-    def deanonymize_tool_args(self, args: dict[str, Any]) -> dict[str, Any]:
-        """Replace PII tags in tool arguments with real values.
-
-        Recursively processes dictionaries, lists, and strings to replace all PII tags
-        (e.g., '<EMAIL_1>') with their corresponding real values from flat_pii_mapping.
-
-        Args:
-            args: Tool arguments that may contain PII tags
-
-        Returns:
-            Arguments with tags replaced by real values
-        """
-    def anonymize_tool_output(self, output: Any) -> tuple[Any, dict[str, str]]:
-        """Mask PII values in tool output.
-
-        Handles string and dictionary outputs. For strings, uses two-phase anonymization:
-        first masks known PII, then detects new PII via NER. For dictionaries, recursively
-        processes all string values. Returns updated mapping with any newly discovered PII.
-
-        Args:
-            output: Tool output that may contain PII values (string, dict, or other)
-
-        Returns:
-            Tuple of (anonymized_output, updated_flat_pii_mapping)
-        """

aip_agents/utils/pii/pii_helper.pyi

@@ -1,78 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import LoggerManager as LoggerManager
-from typing import Any
-
-logger: Incomplete
-
-def normalize_enable_pii(enable_pii: Any) -> bool | None:
-    """Normalize enable_pii value from agent configuration.
-
-    Args:
-        enable_pii: Raw enable_pii value from agent configuration.
-
-    Returns:
-        The normalized enable_pii flag when explicitly set (True/False), otherwise None.
-    """
-def add_pii_mappings(left: dict[str, str] | None, right: dict[str, str] | None) -> dict[str, str]:
-    """Reducer function to merge PII mappings from multiple sources.
-
-    This is a LangGraph reducer function that merges PII mappings from:
-    - Parent agent's initial mapping
-    - Tool outputs with newly discovered PII
-    - Subagent responses with their discovered PII
-
-    Args:
-        left: Existing PII mapping (or None)
-        right: New PII mapping to merge (or None)
-
-    Returns:
-        Merged PII mapping dictionary
-
-    Note:
-        - Right (new) mappings take precedence over left (existing)
-        - Handles None/non-dict cases gracefully
-        - Preserves all unique PII tags
-        - Returns empty dict if both inputs are None/empty
-    """
-def extract_pii_mapping_from_agent_response(result: Any) -> dict[str, str] | None:
-    """Extract PII mapping from subagent response.
-
-    Used by DelegationToolManager to propagate PII mappings from subagents
-    back to parent agents.
-
-    Args:
-        result: The result returned by the delegated agent
-
-    Returns:
-        PII mapping dictionary if found, None otherwise
-
-    Note:
-        - Checks if result is a dict
-        - Extracts 'full_final_state' from result
-        - Extracts 'pii_mapping' from full_final_state
-        - Validates mapping is a non-empty dict
-        - Returns None if any step fails
-    """
-def deanonymize_final_response_content(content: str, is_final_response: bool, metadata: dict[str, Any] | None) -> str:
-    """Deanonymize final response content using PII mapping from metadata.
-
-    Args:
-        content: Final response content that may contain PII tags.
-        is_final_response: Flag indicating whether this message is a final response.
-        metadata: Optional metadata dict (or event payload containing ``metadata``) with
-            ``pii_mapping`` tag-to-value mapping.
-
-    Returns:
-        Content string with PII tags replaced by real values when applicable.
-    """
-def anonymize_final_response_content(content: str, metadata: dict[str, Any] | None) -> str:
-    """Anonymize final response content using PII mapping from metadata.
-
-    Args:
-        content: Final response content that may contain real PII values.
-        metadata: Metadata dict (or event payload containing ``metadata``) with
-            ``pii_mapping`` tag-to-value mapping.
-
-    Returns:
-        Content string with real PII values replaced by their PII tags when mapping is present.
-    """

aip_agents/utils/pii/uuid_deanonymizer_mapping.pyi

@@ -1,73 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.constants import DEFAULT_PII_TAG_NAMESPACE as DEFAULT_PII_TAG_NAMESPACE
-from gllm_privacy.pii_detector.utils.deanonymizer_mapping import DeanonymizerMapping, MappingDataType
-from typing import Any
-
-MappingDataType = dict[str, dict[str, str]]
-
-class DeanonymizerMapping:
-    """Fallback deanonymizer mapping when optional dependency is missing.
-
-        This class exists only to keep the module importable when `gllm-privacy`
-        is not installed.
-        """
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        """Initialize the mapping.
-
-            Raises:
-                ImportError: Always raised because `gllm-privacy` is required.
-            """
-
-logger: Incomplete
-
-def format_operator_with_uuid(operator_name: str, uuid_suffix: str) -> str:
-    """Format the operator name with a UUID suffix.
-
-    Args:
-        operator_name: The operator name.
-        uuid_suffix: The UUID suffix to append.
-
-    Returns:
-        The formatted operator name with UUID suffix.
-    """
-
-class UUIDDeanonymizerMapping(DeanonymizerMapping):
-    """Class to store the deanonymizer mapping with UUID suffixes.
-
-    This class extends DeanonymizerMapping to use UUID suffixes instead of
-    sequential numbers for differentiating multiple entities of the same type.
-
-    Attributes:
-        mapping: The deanonymizer mapping.
-        skip_format_duplicates: Whether to skip formatting duplicated operators.
-        uuid_length: The length of the UUID suffix to use (default: 8).
-    """
-    mapping: Incomplete
-    skip_format_duplicates: Incomplete
-    uuid_length: Incomplete
-    def __init__(self, mapping: MappingDataType | None = None, skip_format_duplicates: bool = False, uuid_length: int = 8) -> None:
-        """Initialize UUIDDeanonymizerMapping.
-
-        Args:
-            mapping: The deanonymizer mapping. If None, creates an empty defaultdict(dict).
-            skip_format_duplicates: Whether to skip formatting duplicated operators.
-            uuid_length: The length of the UUID suffix to use (default: 8).
-        """
-    def update(self, new_mapping: MappingDataType, use_uuid_suffix: bool | None = None) -> None:
-        """Update the deanonymizer mapping with new values using UUID suffixes.
-
-        Duplicated values will not be added. If there are multiple entities of the same type,
-        the mapping will include a UUID suffix to differentiate them. For example, if there are
-        two names in the input text, the mapping will include NAME_<uuid1> and NAME_<uuid2>.
-
-        Args:
-            new_mapping: The new mapping to be added to the existing deanonymizer mapping.
-            use_uuid_suffix: Whether to apply UUID suffixes to keys.
-                If True, keys will always be formatted with UUID suffixes.
-                If False, keys will be used as-is without UUID formatting.
-                If None, behavior falls back to the instance configuration via
-                skip_format_duplicates (preserving existing behavior).
-
-        Returns:
-            None
-        """