aip-agents-binary 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

aip_agents/agent/base_langgraph_agent.pyi

@@ -1,233 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
-from abc import abstractmethod
-from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.agent.system_instruction_context import get_current_date_context as get_current_date_context
-from aip_agents.constants import TEXT_PREVIEW_LENGTH as TEXT_PREVIEW_LENGTH
-from aip_agents.mcp.client import LangchainMCPClient as LangchainMCPClient
-from aip_agents.memory import BaseMemory as BaseMemory, MemoryFactory as MemoryFactory, MemoryMethod as MemoryMethod
-from aip_agents.memory.constants import MemoryDefaults as MemoryDefaults
-from aip_agents.schema.agent import StreamMode as StreamMode
-from aip_agents.schema.hitl import HitlMetadata as HitlMetadata
-from aip_agents.tools.tool_config_injector import CONFIG_SCHEMA_ATTR as CONFIG_SCHEMA_ATTR, TOOL_CONFIG_SCHEMA_ATTR as TOOL_CONFIG_SCHEMA_ATTR, inject_config_methods_into_tool as inject_config_methods_into_tool
-from aip_agents.types import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType
-from aip_agents.utils import augment_query_with_file_paths as augment_query_with_file_paths, validate_references as validate_references
-from aip_agents.utils.langgraph.tool_managers.a2a_tool_manager import A2AToolManager as A2AToolManager
-from aip_agents.utils.langgraph.tool_managers.delegation_tool_manager import DelegationToolManager as DelegationToolManager
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.metadata.activity_metadata_helper import create_tool_activity_info as create_tool_activity_info
-from aip_agents.utils.metadata_helper import DefaultStepMessages as DefaultStepMessages, Kind as Kind, MetadataFieldKeys as MetadataFieldKeys, Status as Status, end_step_counter_scope as end_step_counter_scope, get_next_step_number as get_next_step_number, start_step_counter_scope as start_step_counter_scope
-from aip_agents.utils.pii import deanonymize_final_response_content as deanonymize_final_response_content
-from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
-from aip_agents.utils.token_usage_helper import STEP_USAGE_KEY as STEP_USAGE_KEY, TOTAL_USAGE_KEY as TOTAL_USAGE_KEY, USAGE_METADATA_KEY as USAGE_METADATA_KEY
-from collections.abc import AsyncGenerator, Sequence
-from dataclasses import dataclass
-from gllm_core.event import EventEmitter
-from gllm_core.schema import Chunk as Chunk
-from langchain_core.tools import BaseTool
-from langgraph.graph import StateGraph
-from langgraph.graph.message import add_messages as add_messages
-from langgraph.graph.state import CompiledStateGraph
-from langgraph.types import Checkpointer
-from typing import Any
-
-logger: Incomplete
-
-@dataclass
-class _StreamingContext:
-    """Context object for managing streaming state and configuration."""
-    original_query: str
-    graph_input: dict[str, Any]
-    config: dict[str, Any]
-    memory_user_id: str | None
-    current_thread_id: str
-    token: Any
-    enable_token_streaming: bool
-    final_event_yielded: bool = ...
-    pending_artifacts: list | None = ...
-    seen_artifact_hashes: set | None = ...
-    processed_message_count: int = ...
-    final_state: dict[str, Any] | None = ...
-    last_final_content: str | None = ...
-    saved_memory: bool = ...
-    is_token_streaming: bool = ...
-    def __post_init__(self) -> None:
-        """Initialize mutable defaults."""
-
-class BaseLangGraphAgent(BaseAgent):
-    """Base class for LangGraph-based agents with unified tool approach.
-
-    Provides core LangGraph functionality including:
-    - Graph compilation and execution
-    - State schema management
-    - I/O mapping between user inputs and graph states
-    - Event emission support
-    - Tool resolution and handling
-    - A2A communication capabilities via tools
-    - Agent delegation capabilities via tools
-    - MCP server integration via tools
-    - Enhanced output extraction from various state formats
-
-    Tool Management:
-    - regular_tools: Standard LangChain tools provided during initialization
-    - mcp_tools: Tools retrieved from MCP servers
-    - resolved_tools: Combined collection of all tools for graph execution
-
-    Subclasses must implement:
-    - define_graph(): Define the specific graph structure
-    - _prepare_graph_input(): Convert user input to graph state
-    - _format_graph_output(): Convert final graph state to user output
-    """
-    state_schema: Incomplete
-    thread_id_key: Incomplete
-    enable_a2a_token_streaming: Incomplete
-    event_emitter: Incomplete
-    checkpointer: Incomplete
-    tool_output_manager: Incomplete
-    memory: BaseMemory | None
-    a2a_tool_manager: Incomplete
-    delegation_tool_manager: Incomplete
-    regular_tools: list[BaseTool]
-    mcp_tools: list[BaseTool]
-    resolved_tools: list[BaseTool]
-    def __init__(self, name: str, instruction: str, description: str | None = None, model: Any | None = None, tools: Sequence[BaseTool] | None = None, state_schema: type | None = None, thread_id_key: str = 'thread_id', event_emitter: EventEmitter | None = None, checkpointer: Checkpointer | None = None, enable_a2a_token_streaming: bool = False, **kwargs: Any) -> None:
-        '''Initialize the BaseLangGraphAgent.
-
-        Args:
-            name: The name of the agent.
-            instruction: The system instruction for the agent.
-            description: Human-readable description of the agent.
-            model: The model to use (lm_invoker, LangChain model, string, etc.).
-            tools: Sequence of regular LangChain tools (not A2A or delegation tools).
-            state_schema: The state schema for the LangGraph. Defaults to basic message state.
-            thread_id_key: Key for thread ID in configuration.
-            event_emitter: Optional event emitter for streaming updates.
-            checkpointer: Optional checkpointer for conversation persistence.
-            enable_a2a_token_streaming: Enable token-level streaming for A2A responses.
-                - False (default): Stream message-level events only
-                - True: Stream individual tokens plus message-level events
-            **kwargs: Additional keyword arguments passed to BaseAgent (including tool_configs and memory settings).
-                Memory settings include:
-                - memory_backend: Memory backend (e.g., "mem0")
-                - agent_id: Agent identifier for memory scoping
-                - memory_namespace: Memory namespace
-                - save_interaction_to_memory: Whether to save interactions (default True)
-        '''
-    def set_operation_mode(self, mode: str) -> None:
-        '''Set the operation mode for dependency tracking.
-
-        Args:
-            mode: Operation mode - "parallel" (default) or "sequential"
-        '''
-    @abstractmethod
-    def define_graph(self, graph_builder: StateGraph) -> CompiledStateGraph:
-        """Define the specific graph structure for this agent type.
-
-        Subclasses must implement this method to:
-        1. Add nodes to the graph_builder
-        2. Add edges and conditional edges
-        3. Set entry points
-        4. Return the compiled graph
-
-        Args:
-            graph_builder: The StateGraph builder to define nodes and edges on.
-
-        Returns:
-            The compiled graph ready for execution.
-        """
-    def register_a2a_agents(self, agent_cards: list[AgentCard]) -> None:
-        """Register A2A communication capabilities using the A2A tool manager.
-
-        Args:
-            agent_cards (list[AgentCard]): List of AgentCard instances for external communication.
-        """
-    def register_delegation_agents(self, agents: list[BaseAgent]) -> None:
-        """Register internal agent delegation capabilities using the delegation tool manager.
-
-        Args:
-            agents: List of BaseAgent instances for internal task delegation.
-        """
-    tools: Incomplete
-    def update_regular_tools(self, new_tools: list[BaseTool], rebuild_graph: bool | None = None) -> None:
-        """Update regular tools (not capabilities).
-
-        Args:
-            new_tools: New list of regular tools to use.
-            rebuild_graph: Whether to rebuild graph. If None, uses auto_rebuild_graph setting.
-        """
-    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Synchronously run the LangGraph agent.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Dictionary containing the agent's response.
-        """
-    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Asynchronously run the LangGraph agent with lazy MCP initialization.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments including configurable for LangGraph.
-
-        Returns:
-            Dictionary containing the agent's response and full final state.
-        """
-    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[str | dict[str, Any], None]:
-        """Asynchronously stream the LangGraph agent's response.
-
-        If MCP configuration exists, connects to the MCP server and registers tools before streaming.
-        This method properly handles both LM Invoker and LangChain model streaming:
-        - For LM Invoker: Uses StreamEventHandler to capture streaming events
-        - For LangChain models: Uses LangGraph's native streaming implementation
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Chunks of output (strings or dicts) from the streaming response.
-        """
-    async def cleanup(self) -> None:
-        """Cleanup MCP resources including persistent sessions.
-
-        This method performs best-effort cleanup of MCP client resources.
-        Errors during cleanup are logged but do not raise exceptions to ensure
-        the cleanup process completes gracefully.
-        """
-    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[A2AEvent, None]:
-        '''Asynchronously streams the agent\'s response in A2A format.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            Dictionaries with "status" and "content" keys.
-            Possible statuses: "working", "completed", "failed", "canceled".
-        '''
-    async def arun_sse_stream(self, query: str, task_id: str | None = None, context_id: str | None = None, **kwargs: Any) -> AsyncGenerator[A2AEvent, None]:
-        '''Stream agent response as SSE-compatible chunks.
-
-        This method wraps arun_a2a_stream and transforms output to the normalized
-        dict format matching A2AConnector.astream_to_agent output, enabling direct
-        streaming without A2A server overhead.
-
-        Args:
-            query: The input query for the agent.
-            task_id: Optional task identifier for the stream.
-            context_id: Optional context identifier for the stream.
-            **kwargs: Additional arguments passed to arun_a2a_stream.
-
-        Yields:
-            SSEChunk dicts with normalized structure:
-            - status: "success" | "error"
-            - task_state: "working" | "completed" | "failed" | "canceled"
-            - content: Text content or None
-            - event_type: Always string (never enum)
-            - final: True for terminal events
-            - metadata: Normalized metadata dict
-            - artifacts: Only present when non-empty
-        '''

aip_agents/agent/google_adk_agent.pyi

@@ -1,141 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard
-from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.agent.google_adk_constants import DEFAULT_AUTH_URL as DEFAULT_AUTH_URL
-from aip_agents.mcp.client.google_adk.client import GoogleADKMCPClient as GoogleADKMCPClient
-from aip_agents.utils.a2a_connector import A2AConnector as A2AConnector
-from aip_agents.utils.logger import get_logger as get_logger
-from collections.abc import AsyncGenerator, AsyncIterator
-from google.adk.agents import LlmAgent
-from google.adk.tools.langchain_tool import LangchainTool
-from langchain.tools import BaseTool as LangchainBaseTool
-from pydantic import BaseModel
-from typing import Any
-
-logger: Incomplete
-MODEL_TEMPERATURE: float
-
-class A2AToolInput(BaseModel):
-    """Input for the A2ATool."""
-    query: str
-
-class A2ATool(LangchainBaseTool):
-    """A tool that communicates with an A2A agent."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]
-    agent_card: AgentCard
-
-def create_a2a_tool(agent_card: AgentCard) -> LangchainTool:
-    """Create a LangChain tool from an A2A agent card.
-
-    Args:
-        agent_card (AgentCard): The A2A agent card to create a tool for.
-
-    Returns:
-        LangchainTool: A LangChain tool that can communicate with the A2A agent.
-    """
-
-class GoogleADKAgent(BaseAgent):
-    """An agent that wraps a native Google ADK Agent with MCP support.
-
-    This class implements the AgentInterface and uses Google's LlmAgent
-    to handle the core conversation and tool execution logic via ADK's
-    async-first design. It includes persistent MCP session management for
-    stateful tool execution across multiple calls.
-
-    The agent supports:
-    - Native ADK tools (FunctionTool, LangchainTool)
-    - MCP tools via GoogleADKMCPClient with session persistence
-    - Sub-agent delegation using ADK's built-in multi-agent capabilities
-    - A2A communication through tool integration
-    """
-    adk_native_agent: LlmAgent
-    model: Incomplete
-    max_iterations: Incomplete
-    tools: Incomplete
-    agents: Incomplete
-    session_service: Incomplete
-    name: Incomplete
-    def __init__(self, name: str, instruction: str, model: str, tools: list[Any] | None = None, description: str | None = None, max_iterations: int = 3, agents: list['GoogleADKAgent'] | None = None, **kwargs: Any) -> None:
-        '''Initializes the GoogleADKAgent with MCP support.
-
-        Args:
-            name: The name of this wrapper agent.
-            instruction: The instruction for this wrapper agent.
-            model: The name of the Google ADK model to use (e.g., "gemini-1.5-pro-latest").
-            tools: An optional list of callable tools for the ADK agent.
-            description: An optional human-readable description.
-            max_iterations: Maximum number of iterations to run (default: 3).
-            agents: Optional list of sub-agents that this agent can delegate to using ADK\'s
-                   built-in multi-agent capabilities. These will be passed as sub_agents to the
-                   underlying LlmAgent.
-            **kwargs: Additional keyword arguments passed to the parent `__init__`.
-        '''
-    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        '''Synchronously runs the Google ADK agent by wrapping the internal async run method.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments passed to the internal async run method.
-                      Supports "session_id", "user_id", "app_name".
-
-        Returns:
-            A dictionary containing the agent\'s response.
-
-        Raises:
-            RuntimeError: If `asyncio.run()` is called from an already running event loop,
-                          or for other unhandled errors during synchronous execution.
-        '''
-    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        '''Asynchronously runs the agent with MCP tool support.
-
-        This method ensures MCP tools are properly initialized before execution
-        and provides persistent session management for stateful MCP tools.
-
-        Args:
-            query: The user\'s query to process.
-            **kwargs: Additional keyword arguments. Supports "session_id", "user_id", "app_name".
-
-        Returns:
-            A dictionary containing the output, tool_calls, and session_id.
-        '''
-    async def cleanup(self) -> None:
-        """Clean up ADK and MCP resources."""
-    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncIterator[str]:
-        '''Runs the agent with the given query and streams the response parts.
-
-        Args:
-            query: The user\'s query to process.
-            **kwargs: Additional keyword arguments. Supports "session_id", "user_id", "app_name".
-
-        Yields:
-            Text response chunks from the model. If an error occurs, the error message is yielded.
-        '''
-    def register_a2a_agents(self, agent_cards: list[AgentCard]) -> None:
-        """Convert known A2A agents to LangChain tools.
-
-        This method takes the agents from a2a_config.known_agents, creates A2AAgent
-        instances for each one, and wraps them in LangChain tools.
-
-        Args:
-            agent_cards (list[AgentCard]): List of A2A agent cards to register as tools.
-
-        Returns:
-            None: The tools are added to the existing tools list.
-        """
-    async def arun_a2a_stream(self, query: str, configurable: dict[str, Any] | None = None, **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
-        '''Asynchronously streams the agent\'s response in a format compatible with A2A.
-
-        This method formats the ADK agent\'s streaming responses into a consistent format
-        that the A2A executor can understand and process.
-
-        Args:
-            query: The input query for the agent.
-            configurable: Optional dictionary for configuration, may include:
-                - thread_id: The A2A task ID (used as session_id).
-            **kwargs: Additional keyword arguments. Supports "user_id", "app_name".
-
-        Yields:
-            Dictionary with \'status\' and \'content\' fields that describe the agent\'s response state.
-        '''

aip_agents/agent/google_adk_constants.pyi

@@ -1,3 +0,0 @@
-__all__ = ['DEFAULT_AUTH_URL']
-
-DEFAULT_AUTH_URL: str

aip_agents/agent/hitl/__init__.pyi

@@ -1,6 +0,0 @@
-from aip_agents.agent.hitl.config import ToolApprovalConfig as ToolApprovalConfig
-from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
-from aip_agents.agent.hitl.prompt import BasePromptHandler as BasePromptHandler, DeferredPromptHandler as DeferredPromptHandler
-from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalLogEntry as ApprovalLogEntry, ApprovalRequest as ApprovalRequest
-
-__all__ = ['ToolApprovalConfig', 'ApprovalManager', 'ApprovalDecision', 'ApprovalLogEntry', 'ApprovalRequest', 'BasePromptHandler', 'DeferredPromptHandler']

aip_agents/agent/hitl/config.pyi

@@ -1,15 +0,0 @@
-from dataclasses import dataclass
-
-@dataclass
-class ToolApprovalConfig:
-    """Configuration for HITL approval behavior attached to a tool.
-
-    Supplying this configuration marks the tool as requiring approval. Only the
-    timeout is configurable; timeouts always result in a safe skip.
-
-    Attributes:
-        timeout_seconds: Defaults to 300; must be >0.
-    """
-    timeout_seconds: int = ...
-    def __post_init__(self) -> None:
-        """Validate configuration after initialization."""

aip_agents/agent/hitl/langgraph_hitl_mixin.pyi

@@ -1,42 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent.hitl.config import ToolApprovalConfig as ToolApprovalConfig
-from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
-from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalRequest as ApprovalRequest, HitlMetadata as HitlMetadata
-from aip_agents.schema.langgraph import ToolCallResult as ToolCallResult
-from aip_agents.tools.tool_config_injector import TOOL_CONFIGS_KEY as TOOL_CONFIGS_KEY
-from aip_agents.utils.datetime import ensure_utc_datetime as ensure_utc_datetime
-from aip_agents.utils.logger import get_logger as get_logger
-from collections.abc import Callable
-from typing import Any
-
-logger: Incomplete
-MAX_CONTEXT_MESSAGE_LENGTH: int
-
-class LangGraphHitLMixin:
-    """Provide Human-in-the-Loop helpers for LangGraph agents."""
-    tool_configs: dict[str, Any] | None
-    name: str
-    @property
-    def hitl_manager(self) -> ApprovalManager | None:
-        """Return the active ``ApprovalManager``, creating one if needed."""
-    @hitl_manager.setter
-    def hitl_manager(self, manager: ApprovalManager | None) -> None:
-        """Set the HITL approval manager instance.
-
-        Args:
-            manager: ApprovalManager instance or None.
-        """
-    def ensure_hitl_manager(self) -> ApprovalManager | None:
-        """Ensure an ``ApprovalManager`` exists when HITL configs are present."""
-    def use_hitl_manager(self, manager: ApprovalManager) -> None:
-        """Replace the current ``ApprovalManager`` with the supplied instance.
-
-        Args:
-            manager: The ApprovalManager instance to use for HITL approvals.
-        """
-    def register_hitl_notifier(self, notifier: Callable[[ApprovalRequest], None]) -> None:
-        """Register a notifier callback to receive HITL approval requests.
-
-        Args:
-            notifier: Callback function that will be called with approval requests.
-        """

aip_agents/agent/hitl/manager.pyi

@@ -1,200 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent.hitl.config import ToolApprovalConfig as ToolApprovalConfig
-from aip_agents.agent.hitl.prompt import BasePromptHandler as BasePromptHandler, DeferredPromptHandler as DeferredPromptHandler
-from aip_agents.agent.hitl.registry import hitl_registry as hitl_registry
-from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalLogEntry as ApprovalLogEntry, ApprovalRequest as ApprovalRequest
-from collections.abc import Callable as Callable, Iterable
-from typing import Any
-
-MAX_ARGUMENTS_PREVIEW_LENGTH: int
-DECISION_MESSAGE_MAP: Incomplete
-TOOL_EXECUTION_BLOCKING_DECISIONS: Incomplete
-
-class ApprovalManager:
-    """Manages the HITL approval workflow for tools.
-
-    This class coordinates the approval process from configuration through
-    to final decision, handling timeouts and cleanup.
-    """
-    def __init__(self, prompt_handler: BasePromptHandler | None = None) -> None:
-        """Initialize the approval manager.
-
-        Args:
-            prompt_handler: Optional prompt handler for user interaction.
-                Defaults to DeferredPromptHandler which exposes pending requests
-                for out-of-band resolution.
-        """
-    def create_approval_request(self, tool_name: str, arguments: dict[str, Any], config: ToolApprovalConfig, context: dict[str, str] | None = None) -> ApprovalRequest:
-        """Create a new approval request for a tool call.
-
-        Args:
-            tool_name: Name of the tool being called.
-            arguments: Tool arguments (will be JSON serialized).
-            config: Approval configuration for this tool.
-            context: Optional context metadata. Defaults to None.
-
-        Returns:
-            The created approval request.
-        """
-    def get_pending_request(self, request_id: str) -> ApprovalRequest | None:
-        """Get a pending approval request by ID.
-
-        Args:
-            request_id: The unique identifier of the approval request.
-
-        Returns:
-            The pending approval request if found, None otherwise.
-        """
-    def approve_request(self, request: ApprovalRequest, operator_input: str = 'approved') -> ApprovalDecision:
-        '''Record an approval decision for a request.
-
-        This method creates an approval decision, calculates latency metrics,
-        and removes the request from the active requests queue.
-
-        Args:
-            request: The approval request to approve.
-            operator_input: Raw operator input that led to this decision. Defaults to "approved".
-
-        Returns:
-            The recorded approval decision.
-        '''
-    def reject_request(self, request: ApprovalRequest, operator_input: str = 'rejected') -> ApprovalDecision:
-        '''Record a rejection decision for a request.
-
-        This method creates a rejection decision, calculates latency metrics,
-        and removes the request from the active requests queue.
-
-        Args:
-            request: The approval request to reject.
-            operator_input: Raw operator input that led to this decision. Defaults to "rejected".
-
-        Returns:
-            The recorded rejection decision.
-        '''
-    def skip_request(self, request: ApprovalRequest, operator_input: str = 'skipped') -> ApprovalDecision:
-        '''Record a skip decision for a request.
-
-        This method creates a skip decision, calculates latency metrics,
-        and removes the request from the active requests queue.
-
-        Args:
-            request: The approval request to skip.
-            operator_input: Raw operator input that led to this decision. Defaults to "skipped".
-
-        Returns:
-            The recorded skip decision.
-        '''
-    def timeout_request(self, request: ApprovalRequest, operator_input: str = 'TIMEOUT') -> ApprovalDecision:
-        '''Record a timeout decision for a request, always skipping the tool.
-
-        Args:
-            request (ApprovalRequest): The approval request that timed out.
-            operator_input (str, optional): Input from the operator (defaults to "TIMEOUT").
-
-        Returns:
-            ApprovalDecision: The timeout decision.
-        '''
-    def check_timeout(self, request: ApprovalRequest) -> ApprovalDecision | None:
-        """Check if a request has timed out and return timeout decision if so.
-
-        Args:
-            request: The approval request to check.
-
-        Returns:
-            Timeout decision if timed out, None otherwise.
-        """
-    async def prompt_for_decision(self, request: ApprovalRequest, timeout_seconds: int, context_keys: list[str] | None = None) -> ApprovalDecision:
-        """Prompt for a decision using the configured handler.
-
-        This method delegates to the configured prompt handler to obtain
-        an approval decision from the operator. The handler may be interactive
-        (CLI) or deferred (programmatic, resume-in-place).
-
-        Args:
-            request: The approval request to prompt for.
-            timeout_seconds: How long to wait for input.
-            context_keys: Optional keys to display from context. Defaults to None.
-
-        Returns:
-            The operator's decision on the request.
-        """
-    def list_pending_requests(self) -> Iterable[ApprovalRequest]:
-        """Return a snapshot of currently pending requests.
-
-        This method provides a thread-safe snapshot of all currently active
-        approval requests that are waiting for operator decisions.
-
-        Returns:
-            An iterable of all pending approval requests.
-        """
-    def resolve_pending_request(self, request_id: str, decision: str, operator_input: str = '') -> ApprovalDecision:
-        '''Resolve a pending request with an explicit decision.
-
-        Args:
-            request_id: The unique identifier of the pending approval request.
-            decision: The decision string (e.g., "approved", "rejected", "skipped").
-            operator_input: Optional raw operator input, defaults to the decision string. Defaults to "".
-
-        Returns:
-            The recorded approval decision.
-
-        Raises:
-            KeyError: If no pending request exists with the given request_id.
-            ValueError: If the decision string is not supported.
-        '''
-    def create_log_entry(self, decision: ApprovalDecision, tool_name: str, agent_id: str | None = None, thread_id: str | None = None, additional_context: dict[str, Any] | None = None) -> ApprovalLogEntry:
-        """Create a log entry for a decision.
-
-        Args:
-            decision: The approval decision.
-            tool_name: Name of the tool.
-            agent_id: Optional agent identifier. Defaults to None.
-            thread_id: Optional thread/session identifier. Defaults to None.
-            additional_context: Optional additional logging context. Defaults to None.
-
-        Returns:
-            Structured log entry.
-        """
-    def cleanup_expired_requests(self) -> int:
-        """Clean up expired requests and return count of cleaned requests.
-
-        This method removes all approval requests that have exceeded their
-        timeout period from the active requests queue. This is typically
-        called periodically to prevent memory leaks from abandoned requests.
-
-        Returns:
-            The number of expired requests that were cleaned up.
-        """
-    def register_waiter(self, request_id: str, future: Any) -> None:
-        """Register a waiter future for an approval request.
-
-        Args:
-            request_id: The id for which to wait.
-            future: An asyncio.Future that will receive a tuple(decision, operator_input).
-        """
-    def unregister_waiter(self, request_id: str) -> None:
-        """Unregister a waiter if present (used on timeout/cancellation).
-
-        Args:
-            request_id (str): The ID of the request to unregister the waiter for.
-        """
-    async def wait_for_pending_decision(self, request: ApprovalRequest, timeout_seconds: int) -> ApprovalDecision:
-        """Wait for a pending request to be resolved and return the final decision.
-
-        Args:
-            request: The pending approval request to wait for.
-            timeout_seconds: Maximum time to wait before treating as timeout.
-
-        Returns:
-            The finalized approval decision.
-        """
-    @staticmethod
-    def get_decision_message(decision: ApprovalDecision) -> str:
-        """Get the appropriate message for a HITL decision.
-
-        Args:
-            decision: The approval decision to get a message for.
-
-        Returns:
-            A human-readable message explaining the decision outcome.
-        """

aip_agents/agent/hitl/models.pyi

@@ -1,3 +0,0 @@
-from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalLogEntry as ApprovalLogEntry, ApprovalRequest as ApprovalRequest
-
-__all__ = ['ApprovalDecisionType', 'ApprovalRequest', 'ApprovalDecision', 'ApprovalLogEntry']

aip_agents/agent/hitl/prompt/__init__.pyi

@@ -1,4 +0,0 @@
-from aip_agents.agent.hitl.prompt.base import BasePromptHandler as BasePromptHandler
-from aip_agents.agent.hitl.prompt.deferred import DeferredPromptHandler as DeferredPromptHandler
-
-__all__ = ['BasePromptHandler', 'DeferredPromptHandler']