aip-agents-binary 0.5.25b1__py3-none-any.whl → 0.5.25b8__py3-none-any.whl

aip_agents/tools/time_tool.pyi

@@ -1,16 +0,0 @@
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-FORMAT_STRING: str
-DEFAULT_TIMEZONE: str
-
-class TimeToolInput(BaseModel):
-    """Input schema for the TimeTool."""
-    datetime_format: str
-    timezone: str | None
-
-class TimeTool(BaseTool):
-    """Tool to get the current time."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]

aip_agents/tools/tool_config_injector.pyi

@@ -1,26 +0,0 @@
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-from typing import TypeVar
-
-__all__ = ['inject_config_methods_into_tool', 'CONFIG_SCHEMA_ATTR', 'CONFIG_ATTR', 'TOOL_CONFIG_SCHEMA_ATTR', 'TOOL_CONFIGS_KEY']
-
-ConfigSchema = TypeVar('ConfigSchema', bound=BaseModel)
-CONFIG_SCHEMA_ATTR: str
-CONFIG_ATTR: str
-TOOL_CONFIG_SCHEMA_ATTR: str
-TOOL_CONFIGS_KEY: str
-
-def inject_config_methods_into_tool(tool: BaseTool, config_schema: type[ConfigSchema]) -> None:
-    """Inject configuration methods into a tool.
-
-    This function is used by the SDK to automatically inject configuration capabilities
-    into tools that have a tool_config_schema attribute. It can also be used directly
-    by developers who want to add configuration support to their tools.
-
-    Args:
-        tool: The tool to inject configuration capabilities into.
-        config_schema: Pydantic model class for configuration validation.
-
-    Raises:
-        ValueError: If tool is not a BaseTool instance or config_schema is not a Pydantic BaseModel subclass.
-    """

aip_agents/tools/web_search/__init__.pyi

@@ -1,3 +0,0 @@
-from aip_agents.tools.web_search.serper_tool import GoogleSerperTool as GoogleSerperTool
-
-__all__ = ['GoogleSerperTool']

aip_agents/tools/web_search/serper_tool.pyi

@@ -1,19 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.utils.logger import get_logger as get_logger
-from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel
-
-logger: Incomplete
-
-class GoogleSerperInput(BaseModel):
-    """Input schema for the GoogleSerperTool."""
-    query: str
-
-class GoogleSerperTool(BaseTool):
-    """Tool to search Google Serper API."""
-    name: str
-    description: str
-    save_output_history: bool
-    args_schema: type[BaseModel]
-    api_wrapper: GoogleSerperAPIWrapper

aip_agents/types/__init__.pyi

@@ -1,36 +0,0 @@
-from aip_agents.schema.a2a import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType, ToolCallInfo as ToolCallInfo, ToolResultInfo as ToolResultInfo
-from pydantic import BaseModel
-from typing import Any, Protocol
-
-__all__ = ['A2AEvent', 'A2AStreamEventType', 'ToolCallInfo', 'ToolResultInfo', 'AgentProtocol', 'ChatMessage']
-
-class ChatMessage(BaseModel):
-    """Represents a single message in a chat conversation."""
-    role: str
-    content: str
-
-class AgentProtocol(Protocol):
-    """Defines the expected interface for an agent."""
-    id: str
-    name: str
-    description: str
-    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Synchronous execution method.
-
-        Args:
-            query (str): The query to execute.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            dict[str, Any]: The execution result.
-        """
-    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Asynchronous execution method.
-
-        Args:
-            query (str): The query to execute.
-            **kwargs (Any): Additional keyword arguments.
-
-        Returns:
-            dict[str, Any]: The execution result.
-        """

aip_agents/types/a2a_events.pyi

@@ -1,3 +0,0 @@
-from aip_agents.schema.a2a import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType, ToolCallInfo as ToolCallInfo, ToolResultInfo as ToolResultInfo
-
-__all__ = ['A2AStreamEventType', 'A2AEvent', 'ToolCallInfo', 'ToolResultInfo']

aip_agents/utils/__init__.pyi

@@ -1,11 +0,0 @@
-from aip_agents.utils.artifact_helpers import create_artifact_command as create_artifact_command, create_artifact_response as create_artifact_response, create_error_response as create_error_response, create_multiple_artifacts_command as create_multiple_artifacts_command, create_text_artifact_response as create_text_artifact_response
-from aip_agents.utils.file_prompt_utils import augment_query_with_file_paths as augment_query_with_file_paths
-from aip_agents.utils.final_response_builder import assemble_final_response as assemble_final_response
-from aip_agents.utils.logger import LoggerManager as LoggerManager, get_logger as get_logger
-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, extract_pii_mapping_from_agent_response as extract_pii_mapping_from_agent_response
-from aip_agents.utils.reference_helper import add_references_chunks as add_references_chunks, serialize_references_for_metadata as serialize_references_for_metadata, validate_references as validate_references
-from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
-from aip_agents.utils.step_limit_manager import StepExecutionContext as StepExecutionContext, StepLimitManager as StepLimitManager, _DELEGATION_CHAIN_CVAR as _DELEGATION_CHAIN_CVAR, _DELEGATION_DEPTH_CVAR as _DELEGATION_DEPTH_CVAR, _REMAINING_STEP_BUDGET_CVAR as _REMAINING_STEP_BUDGET_CVAR, _STEP_LIMIT_CONFIG_CVAR as _STEP_LIMIT_CONFIG_CVAR
-
-__all__ = ['get_logger', 'LoggerManager', 'create_artifact_response', 'create_error_response', 'create_artifact_command', 'create_multiple_artifacts_command', 'create_text_artifact_response', 'validate_references', 'serialize_references_for_metadata', 'add_references_chunks', 'assemble_final_response', 'augment_query_with_file_paths', 'SSEChunkTransformer', 'StepExecutionContext', 'StepLimitManager', '_DELEGATION_CHAIN_CVAR', '_DELEGATION_DEPTH_CVAR', '_REMAINING_STEP_BUDGET_CVAR', '_STEP_LIMIT_CONFIG_CVAR', 'ToolPIIHandler', 'add_pii_mappings', 'extract_pii_mapping_from_agent_response']

aip_agents/utils/a2a_connector.pyi

@@ -1,146 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard
-from aip_agents.schema.a2a import A2AStreamEventType as A2AStreamEventType
-from aip_agents.utils.event_handler_registry import DEFAULT_EVENT_HANDLER_REGISTRY as DEFAULT_EVENT_HANDLER_REGISTRY, EventHandlerRegistry as EventHandlerRegistry
-from aip_agents.utils.final_response_builder import FinalResponseMetadataOptions as FinalResponseMetadataOptions, assemble_final_response as assemble_final_response
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.metadata_helper import Kind as Kind, MetadataFieldKeys as MetadataFieldKeys, MetadataTimeTracker as MetadataTimeTracker, Status as Status, create_metadata as create_metadata, create_status_update_metadata as create_status_update_metadata, create_tool_processing_metadata as create_tool_processing_metadata
-from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
-from collections.abc import AsyncGenerator
-from pydantic import BaseModel
-from typing import Any
-
-logger: Incomplete
-
-class ArtifactInfo(BaseModel):
-    """Structured artifact information for A2A communication.
-
-    This Pydantic model provides type safety and validation for artifact data
-    exchanged between agents through the A2A protocol.
-    """
-    artifact_id: str | None
-    name: str | None
-    content_type: str | None
-    mime_type: str | None
-    file_name: str | None
-    has_file_data: bool
-    has_file_uri: bool
-    file_data: str | None
-    file_uri: str | None
-    description: str | None
-    parts: int | None
-
-class StreamingConfig(BaseModel):
-    """Configuration for A2A streaming operations."""
-    http_kwargs: dict[str, Any] | None
-
-class A2AConnector:
-    """Handles A2A protocol communication between agents.
-
-    This class provides methods for sending messages to other agents using the A2A protocol,
-    supporting both synchronous and asynchronous communication patterns, as well as streaming
-    responses with immediate artifact event handling.
-    """
-    FLOAT_EPSILON: float
-    event_registry: EventHandlerRegistry
-    @staticmethod
-    def send_to_agent(agent_card: AgentCard, message: str | dict[str, Any], **kwargs: Any) -> dict[str, Any]:
-        """Synchronously sends a message to another agent using the A2A protocol.
-
-        This method is a synchronous wrapper around asend_to_agent. It handles the creation
-        of an event loop if one doesn't exist, and manages the asynchronous call internally.
-
-        Args:
-            agent_card: The AgentCard instance containing the target agent's details including
-                URL, authentication requirements, and capabilities.
-            message: The message to send to the agent. Can be either a string for simple text
-                messages or a dictionary for structured data.
-            **kwargs: Additional keyword arguments passed to asend_to_agent.
-
-        Returns:
-            A dictionary containing the response details:
-                - status (str): 'success' or 'error'
-                - content (str): Extracted text content from the response
-                - task_id (str, optional): ID of the created/updated task
-                - task_state (str, optional): Current state of the task
-                - raw_response (str): Complete JSON response from the A2A client
-                - error_type (str, optional): Type of error if status is 'error'
-                - message (str, optional): Error message if status is 'error'
-
-        Raises:
-            RuntimeError: If asend_to_agent encounters an unhandled exception.
-        """
-    @staticmethod
-    async def asend_to_agent(agent_card: AgentCard, message: str | dict[str, Any], **kwargs: Any) -> dict[str, Any]:
-        '''Asynchronously sends a message to another agent using the A2A protocol.
-
-        This method uses the streaming approach internally but only returns the final response,
-        avoiding direct httpx usage that can cause issues with Nuitka compilation.
-
-        Args:
-            agent_card: The AgentCard instance containing the target agent\'s details including
-                URL, authentication requirements, and capabilities.
-            message: The message to send to the agent. Can be either a string for simple text
-                messages or a dictionary for structured data.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            A dictionary containing the final response with the simplified structure:
-                - status (str): "success" or "error"
-                - task_state (str): Final A2A TaskState value
-                - content (str): Final text content from the agent
-                - task_id (str): ID of the associated task
-                - context_id (str): Context ID of the task
-                - final (bool): Always True for final responses
-                - artifacts (list): List of all artifacts created during execution
-
-        Raises:
-            Exception: If there\'s an error during message sending or processing.
-        '''
-    @staticmethod
-    async def astream_to_agent(agent_card: AgentCard, message: str | dict[str, Any], **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
-        '''Asynchronously sends a streaming message to another agent using the A2A protocol.
-
-        This method supports streaming responses from the target agent, yielding chunks of
-        the response as they become available. It handles the official A2A streaming event
-        types as defined in the specification.
-
-        Args:
-            agent_card: The AgentCard instance containing the target agent\'s details including
-                URL, authentication requirements, and capabilities.
-            message: The message to send to the agent. Can be either a string for simple text
-                messages or a dictionary for structured data.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Dictionaries containing streaming response chunks with a simplified structure:
-
-            For successful responses:
-                - status (str): "success" or "error"
-                - task_state (str): A2A TaskState value
-                - content (str): Text content from the agent
-                - task_id (str): ID of the associated task
-                - context_id (str): Context ID of the task
-                - final (bool): Whether this is the final update
-                - artifacts (list, optional): List of artifacts created in this step
-
-            Each artifact in the artifacts list contains:
-                - artifact_id (str): ID of the artifact
-                - name (str): Name of the artifact
-                - content_type (str): "text" or "file"
-                - mime_type (str): MIME type of the artifact
-                - file_name (str, optional): Name of the file for file artifacts
-                - has_file_data (bool): Whether file data is included
-                - has_file_uri (bool): Whether file URI is included
-                - file_data (str, optional): Base64 encoded file content
-                - file_uri (str, optional): URI reference to the file
-
-            For errors:
-                - status (str): "error"
-                - error_type (str): Type of error encountered
-                - message (str): Error description
-
-        Raises:
-            httpx.HTTPError: If there\'s an HTTP-related error during the streaming request.
-            Exception: For any other unexpected errors during message streaming or processing.
-        '''

aip_agents/utils/artifact_helpers.pyi

@@ -1,203 +0,0 @@
-from aip_agents.a2a.types import Artifact as Artifact, ArtifactType as ArtifactType, MimeType as MimeType, get_mime_type_from_filename as get_mime_type_from_filename
-from langgraph.types import Command
-from typing import Any
-
-class ArtifactHandler:
-    """Handler class for creating and managing artifacts in agent tools.
-
-    This class provides a clean, object-oriented interface for artifact creation
-    with built-in validation, deduplication, and standardized formatting.
-    """
-    def __init__(self) -> None:
-        """Initialize the ArtifactHandler."""
-    def create_file_artifact(self, result: str, artifact_data: bytes | str, artifact_name: str, artifact_description: str = '', mime_type: str | None = None, enable_deduplication: bool = True) -> dict[str, Any]:
-        '''Deprecated. Use create_artifact instead.
-
-        Args:
-            result (str): The message/result to show to the agent.
-            artifact_data (bytes | str): The binary data for the artifact.
-            artifact_name (str): The name for the artifact file.
-            artifact_description (str, optional): Description of the artifact. Defaults to "".
-            mime_type (str | None, optional): MIME type of the artifact. If None, will be auto-detected.
-            enable_deduplication (bool, optional): Whether to deduplicate by content hash. Defaults to True.
-
-        Returns:
-            dict[str, Any]: Dictionary with \'result\' and \'artifact\' keys.
-        '''
-    def create_text_artifact(self, result: str, artifact_text: str, artifact_name: str, artifact_description: str = '', mime_type: str | None = None, enable_deduplication: bool = True) -> dict[str, Any]:
-        '''Deprecated. Use create_artifact instead.
-
-        Args:
-            result (str): The message/result to show to the agent.
-            artifact_text (str): The text content for the artifact.
-            artifact_name (str): The name for the artifact file.
-            artifact_description (str, optional): Description of the artifact. Defaults to "".
-            mime_type (str | None, optional): MIME type of the artifact. If None, will be auto-detected.
-            enable_deduplication (bool, optional): Whether to deduplicate by content hash. Defaults to True.
-
-        Returns:
-            dict[str, Any]: Dictionary with \'result\' and \'artifact\' keys.
-        '''
-    def create_artifact(self, result: str, data: bytes | str, artifact_name: str, artifact_description: str = '', mime_type: str | None = None, enable_deduplication: bool = True) -> dict[str, Any]:
-        """Create an artifact with automatic text/binary handling.
-
-        Args:
-            result: The message/result to show to the agent.
-            data: The data for the artifact. Bytes for binary; str for text or base64.
-            artifact_name: The filename to present to users.
-            artifact_description: Description of the artifact.
-            mime_type: Optional MIME type. If None, inferred from filename.
-            enable_deduplication: Whether to deduplicate by content hash.
-
-        Returns:
-            Dictionary with 'result' and 'artifact' keys.
-        """
-    def create_error_response(self, error_message: str) -> str:
-        """Create a standardized error response for tools.
-
-        Args:
-            error_message: The error message to return.
-
-        Returns:
-            String with error information.
-        """
-    def clear_cache(self) -> None:
-        """Clear the artifact cache."""
-    def get_cache_size(self) -> int:
-        """Get the number of cached artifacts.
-
-        Returns:
-            Number of artifacts in cache.
-        """
-    @staticmethod
-    def generate_artifact_hash(artifact_data: str, name: str, mime_type: str) -> str:
-        """Generate a hash for artifact deduplication.
-
-        Args:
-            artifact_data: Base64 encoded artifact data.
-            name: Artifact name.
-            mime_type: MIME type.
-
-        Returns:
-            Hash string for deduplication.
-        """
-
-def create_artifact_response(result: str, artifact_data: bytes | str, artifact_name: str, artifact_description: str = '', mime_type: str | None = None) -> dict[str, Any]:
-    '''Create a standardized artifact response for tools.
-
-    This function creates a response that separates the agent-facing result
-    from the user-facing artifact, following the established pattern for
-    artifact generation in the agent system.
-
-    Args:
-        result: The message/result to show to the agent (clean, no file data).
-        artifact_data: The binary data or base64 string for the artifact.
-        artifact_name: The name for the artifact file.
-        artifact_description: Description of the artifact. Defaults to "".
-        mime_type: MIME type of the artifact. If None, will be auto-detected from filename.
-
-    Returns:
-        Dictionary with \'result\' and \'artifacts\' keys (artifacts is always a list).
-
-    Example:
-        >>> import io
-        >>> csv_data = "Name,Age\\\\nAlice,30\\\\nBob,25"
-        >>> response = create_artifact_response(
-        ...     result="Generated a 2-row CSV table",
-        ...     artifact_data=csv_data.encode(\'utf-8\'),
-        ...     artifact_name="data.csv",
-        ...     artifact_description="Sample data table",
-        ...     mime_type="text/csv"
-        ... )
-        >>> assert "result" in response
-        >>> assert "artifacts" in response
-        >>> assert isinstance(response["artifacts"], list)
-    '''
-def create_text_artifact_response(result: str, artifact_text: str, artifact_name: str, artifact_description: str = '', mime_type: str | None = None) -> dict[str, Any]:
-    """Create a standardized artifact response for tools.
-
-    Args:
-        result: The message/result to show to the agent.
-        artifact_text: The text content for the artifact.
-        artifact_name: The name for the artifact file.
-        artifact_description: Description of the artifact.
-        mime_type: MIME type of the artifact. If None, will be auto-detected from filename.
-
-    Returns:
-        Dictionary with 'result' and 'artifacts' keys (artifacts is always a list).
-    """
-def create_multiple_artifacts_response(result: str, artifacts: list[dict[str, Any]]) -> dict[str, Any]:
-    """Create a standardized response for multiple artifacts.
-
-    Args:
-        result: The message/result to show to the agent.
-        artifacts: List of artifact dictionaries.
-
-    Returns:
-        Dictionary with 'result' and 'artifacts' keys.
-    """
-def create_artifact_command(result: str, artifact_data: bytes | str, artifact_name: str, artifact_description: str = '', mime_type: str | None = None, metadata_update: dict[str, Any] | None = None) -> Command:
-    """Create a Command that updates artifacts (and optional metadata).
-
-    Args:
-        result: Message/result to show to the agent (for ToolMessage content).
-        artifact_data: The binary data or base64 string for the artifact.
-        artifact_name: The name for the artifact file.
-        artifact_description: Description of the artifact.
-        mime_type: MIME type of the artifact. If None, auto-detected from filename.
-        metadata_update: Optional metadata delta to merge into state metadata.
-
-    Returns:
-        Command: A LangGraph Command with update containing 'result', 'artifacts', and optional 'metadata'.
-    """
-def create_multiple_artifacts_command(result: str, artifacts: list[Artifact | dict[str, Any]] | None = None, metadata_update: dict[str, Any] | None = None) -> Command:
-    """Create a Command that updates multiple artifacts (and optional metadata).
-
-    The 'artifacts' list accepts mixed item types:
-    - Artifact: a typed artifact model (preferred). Will be converted via model_dump().
-    - dict: a prebuilt artifact dict ready for A2A.
-    - DataSpec dict: raw spec to build an artifact with keys:
-        {'data': bytes|str, 'artifact_name': str, 'artifact_description'?: str, 'mime_type'?: str}
-
-    Args:
-        result: Message/result to show to the agent.
-        artifacts: List of items (Artifact | dict) to attach or build.
-        metadata_update: Optional metadata delta to merge into state metadata.
-
-    Returns:
-        Command: A LangGraph Command with update containing 'result', 'artifacts', and optional 'metadata'.
-    """
-def create_error_response(error_message: str) -> str:
-    """Create a standardized error response for tools.
-
-    For error cases, we return a simple string that will be passed directly
-    to the agent without any artifact processing.
-
-    Args:
-        error_message: The error message to return.
-
-    Returns:
-        String with error information.
-    """
-def extract_artifacts_from_agent_response(result: Any) -> tuple[str, list[dict[str, Any]]]:
-    """Extract artifacts from agent response for delegation tools.
-
-    Args:
-        result: The result returned by the delegated agent.
-
-    Returns:
-        Tuple of (text_response, artifacts_list) where:
-        - text_response: The text content for the agent
-        - artifacts_list: List of artifacts to be passed through
-    """
-def create_delegation_response_with_artifacts(result: str, artifacts: list[dict[str, Any]], agent_name: str = '') -> Command:
-    """Create a delegation response that includes artifacts only when needed.
-
-    Args:
-        result: The text result from the delegated agent.
-        artifacts: List of artifacts from the delegated agent (always a list).
-        agent_name: Name of the agent for prefixing the result.
-
-    Returns:
-        Command containing 'result' and optional 'artifacts'.
-    """

aip_agents/utils/constants.pyi

@@ -1,10 +0,0 @@
-from enum import StrEnum
-from uuid import UUID
-
-__all__ = ['DefaultTimezone', 'DEFAULT_PII_TAG_NAMESPACE']
-
-class DefaultTimezone(StrEnum):
-    """Default timezone constants used across the application."""
-    JAKARTA: str
-
-DEFAULT_PII_TAG_NAMESPACE: UUID

aip_agents/utils/datetime/__init__.pyi

@@ -1,4 +0,0 @@
-from aip_agents.utils.datetime.normalization import format_created_updated_label as format_created_updated_label, is_valid_date_string as is_valid_date_string, next_day_iso as next_day_iso, normalize_timestamp_to_date as normalize_timestamp_to_date
-from aip_agents.utils.datetime.timezone import ensure_utc_datetime as ensure_utc_datetime, get_timezone_aware_now as get_timezone_aware_now
-
-__all__ = ['normalize_timestamp_to_date', 'format_created_updated_label', 'is_valid_date_string', 'next_day_iso', 'ensure_utc_datetime', 'get_timezone_aware_now']

aip_agents/utils/datetime/normalization.pyi

@@ -1,95 +0,0 @@
-from typing import Any
-
-__all__ = ['normalize_timestamp_to_date', 'format_created_updated_label', 'is_valid_date_string', 'next_day_iso']
-
-def normalize_timestamp_to_date(value: Any) -> str | None:
-    '''Normalize various timestamp representations into a YYYY-MM-DD string.
-
-    This function handles multiple input types and formats, converting them to
-    a standardized ISO date string. It gracefully handles invalid inputs by
-    returning None or the string representation.
-
-    Args:
-        value: The timestamp value to normalize. Can be:
-            - None or empty string: Returns None
-            - int/float: Unix timestamp (seconds since epoch)
-            - str: ISO format, datetime string, or other string representation
-            - Other types: Converted to string representation
-
-    Returns:
-        str | None: A YYYY-MM-DD formatted date string, or None if the input
-            cannot be parsed as a valid date.
-
-    Raises:
-        ValueError: If the timestamp value is invalid (e.g., negative timestamp).
-
-    Examples:
-        >>> normalize_timestamp_to_date(1640995200)  # Unix timestamp
-        \'2022-01-01\'
-        >>> normalize_timestamp_to_date("2022-01-01T12:00:00")
-        \'2022-01-01\'
-        >>> normalize_timestamp_to_date("invalid")
-        \'invalid\'
-        >>> normalize_timestamp_to_date(None)
-        None
-    '''
-def format_created_updated_label(created_at: Any | None, updated_at: Any | None) -> str | None:
-    '''Build a compact label combining created/updated timestamps when available.
-
-    Creates a human-readable label that shows creation and update timestamps
-    in a compact format. If both dates are the same, only shows one date.
-
-    Args:
-        created_at: The creation timestamp (any format supported by normalize_timestamp_to_date).
-        updated_at: The update timestamp (any format supported by normalize_timestamp_to_date).
-
-    Returns:
-        str | None: A formatted label string, or None if both inputs are invalid/empty.
-            Examples: "2022-01-01", "2022-01-01 (updated 2022-01-02)", "updated 2022-01-01"
-
-    Examples:
-        >>> format_created_updated_label("2022-01-01", "2022-01-02")
-        \'2022-01-01 (updated 2022-01-02)\'
-        >>> format_created_updated_label("2022-01-01", "2022-01-01")
-        \'2022-01-01\'
-        >>> format_created_updated_label(None, "2022-01-01")
-        \'updated 2022-01-01\'
-        >>> format_created_updated_label("2022-01-01", None)
-        \'2022-01-01\'
-    '''
-def is_valid_date_string(date_str: str, fmt: str = ...) -> bool:
-    '''Validate that a date string matches the provided strftime format.
-
-    Args:
-        date_str: The date string to validate. Must be a non-empty string.
-        fmt: The strftime format pattern to validate against.
-            Defaults to YYYY-MM-DD format.
-
-    Returns:
-        bool: True if the date string matches the format, False otherwise.
-
-    Raises:
-        ValueError: If the format string is empty or invalid, or if date_str is not a string.
-
-    Examples:
-        >>> is_valid_date_string("2022-01-01")
-        True
-        >>> is_valid_date_string("2022-13-01")
-        False
-        >>> is_valid_date_string("01-01-2022", "%m-%d-%Y")
-        True
-        >>> is_valid_date_string("", "%Y-%m-%d")
-        False
-    '''
-def next_day_iso(date_str: str) -> str:
-    """Return the ISO date string for the day after the given ``YYYY-MM-DD`` date.
-
-    Args:
-        date_str: A date string in ``YYYY-MM-DD`` format.
-
-    Returns:
-        str: The next day's date in ``YYYY-MM-DD`` format.
-
-    Raises:
-        ValueError: If ``date_str`` is not a valid ``YYYY-MM-DD`` date string.
-    """

aip_agents/utils/datetime/timezone.pyi

@@ -1,48 +0,0 @@
-from datetime import datetime
-
-__all__ = ['get_timezone_aware_now', 'ensure_utc_datetime']
-
-def get_timezone_aware_now(timezone: str, fallback_timezone: str = 'UTC') -> tuple[datetime, str, bool]:
-    '''Return a timezone-aware datetime alongside a timezone label.
-
-    This function creates a timezone-aware datetime object using the modern
-    zoneinfo module (Python 3.9+). It gracefully falls back to UTC if the
-    requested timezone is invalid.
-
-    Args:
-        timezone: Desired timezone name in IANA format (e.g., "America/New_York",
-            "Europe/London", "Asia/Tokyo"). Must be a non-empty string.
-        fallback_timezone: Fallback timezone name to use when the primary
-            timezone is invalid. Defaults to "UTC". Must be a non-empty string.
-
-    Returns:
-        tuple[datetime, str, bool]: A 3-tuple containing:
-            - now: A timezone-aware datetime object representing the current time
-            - timezone_label: A human-readable timezone label (e.g., "EST", "UTC")
-            - used_fallback: Boolean indicating whether the fallback timezone was used
-
-    Raises:
-        ValueError: If timezone or fallback_timezone are empty/invalid, or if both
-            the requested timezone and fallback timezone are invalid.
-
-    Examples:
-        >>> now, label, fallback = get_timezone_aware_now("America/New_York")
-        >>> print(f"Current time: {now}, Timezone: {label}, Used fallback: {fallback}")
-        Current time: 2024-01-15 10:30:00-05:00, Timezone: EST, Used fallback: False
-
-        >>> now, label, fallback = get_timezone_aware_now("Invalid/Timezone")
-        >>> print(f"Used fallback: {fallback}, Label: {label}")
-        Used fallback: True, Label: UTC
-    '''
-def ensure_utc_datetime(value: datetime) -> datetime:
-    """Normalize a datetime to UTC (attaching UTC to naive values).
-
-    Args:
-        value: Datetime to normalize.
-
-    Returns:
-        datetime: Timezone-aware datetime expressed in UTC.
-
-    Raises:
-        TypeError: If ``value`` is not a ``datetime`` instance.
-    """

aip_agents/utils/env_loader.pyi

@@ -1,10 +0,0 @@
-from _typeshed import Incomplete
-
-logger: Incomplete
-
-def load_local_env(override: bool = True) -> None:
-    """Load environment variables from a .env file if python-dotenv is available.
-
-    Args:
-        override (bool, optional): Whether to override existing environment variables. Defaults to True.
-    """