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

aip_agents/tools/nested_agent_tool.pyi

@@ -1,45 +0,0 @@
-import logging
-from aip_agents.tools.base import BaseTool as BaseTool
-from aip_agents.types import AgentProtocol as AgentProtocol
-from gllm_core.event import EventEmitter as EventEmitter
-from pydantic import BaseModel
-from typing import Any
-
-class NestedAgentTool(BaseTool):
-    """Tool for wrapping an agent as a tool for use by another agent.
-
-    This allows agents to delegate tasks to other specialized agents.
-    The wrapped agent must conform to the AgentProtocol interface.
-
-    Attributes:
-        name: The name of the tool (derived from the agent's name).
-        description: The description of the tool (derived from the agent's description).
-        nested_agent: The agent to wrap as a tool.
-        return_direct: Whether to return the result directly to the parent agent without
-            additional processing. When True, the parent agent will receive the nested
-            agent's response directly rather than incorporating it into its reasoning.
-        logger: Logger for tracking tool execution.
-    """
-    name: str
-    description: str
-    nested_agent: AgentProtocol
-    return_direct: bool
-    logger: logging.Logger | None
-    class ArgsSchema(BaseModel):
-        """ArgsSchema is a Pydantic model that defines the schema for the arguments required by the nested agent.
-
-        Attributes:
-            query (str): User query to delegate to the nested agent. This field is required.
-        """
-        query: str
-    args_schema: type[BaseModel]
-    def __init__(self, nested_agent: AgentProtocol, **kwargs: Any) -> None:
-        """Initialize the Tool class with an agent and additional data.
-
-        Args:
-            nested_agent (AgentProtocol): The agent instance to be wrapped.
-            **kwargs (Any): Additional keyword arguments to pass to the parent constructor.
-
-        Raises:
-            ValueError: If the provided agent doesn't conform to AgentProtocol.
-        """

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/types/__init__.pyi

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

aip_agents/types/a2a_events.pyi

@@ -1,74 +0,0 @@
-from enum import Enum
-from typing import Any
-from typing_extensions import TypedDict
-
-class A2AStreamEventType(Enum):
-    """Semantic event types for A2A agent-executor communication.
-
-    These event types preserve the semantic meaning of LangChain message types
-    and eliminate the need for string-based content classification downstream.
-    """
-    STATUS_UPDATE = 'status_update'
-    CONTENT_CHUNK = 'content_chunk'
-    FINAL_RESPONSE = 'final_response'
-    TOOL_CALL = 'tool_call'
-    TOOL_RESULT = 'tool_result'
-    ERROR = 'error'
-
-class A2AEvent(TypedDict):
-    """Structured event data for A2A agent-executor communication.
-
-    This TypedDict replaces the generic dictionary format previously used,
-    providing type safety and semantic clarity for agent streaming events.
-
-    Attributes:
-        event_type: The semantic type of this event (tool call, content, etc.).
-        content: The main text content of the event.
-        metadata: Additional metadata associated with the event.
-        tool_info: Tool-specific information (only present for tool-related events).
-        is_final: Whether this event represents the final output.
-        artifacts: List of artifacts generated by tools or agents.
-        references: Reference data from tools that support reference collection.
-        step_usage: Usage metadata associated with the event.
-        total_usage: Accumulated usage metadata associated with the event.
-    """
-    event_type: A2AStreamEventType
-    content: str
-    metadata: dict[str, Any]
-    tool_info: dict[str, Any] | None
-    is_final: bool
-    artifacts: list[dict[str, Any]] | None
-    references: list[Any] | None
-    step_usage: dict[str, Any] | None
-    total_usage: dict[str, Any] | None
-    thinking_and_activity_info: dict[str, Any] | None
-
-class ToolCallInfo(TypedDict):
-    '''Structured information for tool invocation events.
-
-    This provides a standardized format for tool call information,
-    eliminating the need for JSON encoding/decoding.
-
-    Attributes:
-        tool_calls: List of tool calls with names and arguments.
-        status: Current status of the tool invocation ("running", "finished").
-    '''
-    tool_calls: list[dict[str, Any]]
-    status: str
-
-class ToolResultInfo(TypedDict):
-    """Structured information for tool completion events.
-
-    This provides a standardized format for tool execution results,
-    eliminating the need for JSON encoding/decoding.
-
-    Attributes:
-        name: Name of the executed tool.
-        args: Arguments passed to the tool.
-        output: Output returned by the tool.
-        execution_time: Time taken for tool execution in seconds.
-    """
-    name: str
-    args: dict[str, Any]
-    output: str
-    execution_time: float | None

aip_agents/utils/__init__.pyi

@@ -1,5 +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.logger_manager import LoggerManager as LoggerManager
-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
-
-__all__ = ['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']

aip_agents/utils/a2a_connector.pyi

@@ -1,135 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-from aip_agents.utils.metadata_helper import Kind as Kind, 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 pydantic import BaseModel
-from typing import Any, AsyncGenerator
-
-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 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.
-    """
-    @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,179 +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."""
-    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."""
-    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/langgraph/__init__.pyi

@@ -1,3 +0,0 @@
-from aip_agents.utils.langgraph.converter import convert_gllm_tool_call_to_langchain_tool_call as convert_gllm_tool_call_to_langchain_tool_call, convert_langchain_messages_to_gllm_messages as convert_langchain_messages_to_gllm_messages, convert_langchain_tool_call_to_gllm_tool_call as convert_langchain_tool_call_to_gllm_tool_call, convert_lm_output_to_langchain_message as convert_lm_output_to_langchain_message
-
-__all__ = ['convert_gllm_tool_call_to_langchain_tool_call', 'convert_langchain_tool_call_to_gllm_tool_call', 'convert_lm_output_to_langchain_message', 'convert_langchain_messages_to_gllm_messages']

aip_agents/utils/langgraph/converter.pyi

@@ -1,49 +0,0 @@
-from gllm_inference.schema import LMOutput, Message, ToolCall as GllmToolCall
-from langchain_core.messages import AIMessage, BaseMessage as BaseMessage
-from langchain_core.messages.tool import ToolCall as LangChainToolCall
-from typing import Sequence
-
-def convert_langchain_messages_to_gllm_messages(messages: Sequence[BaseMessage], instruction: str) -> list[Message]:
-    """Convert LangChain messages to gllm-inference Message format.
-
-    This function transforms a sequence of LangChain messages into the Message
-    format expected by LM Invoker. It handles system messages, human messages, AI messages
-    with tool calls, and tool result messages.
-
-    Args:
-        messages: Sequence of LangChain BaseMessage objects to convert.
-        instruction: System instruction to prepend if not already present in messages.
-
-    Returns:
-        List of Message objects containing the converted message sequence.
-    """
-def convert_lm_output_to_langchain_message(response: LMOutput | str) -> AIMessage:
-    """Convert LM Invoker output to LangChain AIMessage.
-
-    This function transforms the output from LM Invoker back into LangChain's
-    AIMessage format, handling both text responses and tool calls.
-
-    Args:
-        response: The response from LM Invoker (MultimodalOutput).
-
-    Returns:
-        AIMessage containing the converted response.
-    """
-def convert_langchain_tool_call_to_gllm_tool_call(lc_tool_call: LangChainToolCall) -> GllmToolCall:
-    """Convert LangChain tool call to gllm ToolCall.
-
-    Args:
-        lc_tool_call: LangChain ToolCall (TypedDict).
-
-    Returns:
-        GllmToolCall object for gllm-inference.
-    """
-def convert_gllm_tool_call_to_langchain_tool_call(gllm_tool_call: GllmToolCall) -> LangChainToolCall:
-    """Convert gllm ToolCall to LangChain ToolCall format.
-
-    Args:
-        gllm_tool_call: GllmToolCall object from gllm-inference.
-
-    Returns:
-        LangChain ToolCall (TypedDict) with proper type annotation.
-    """

aip_agents/utils/langgraph/tool_managers/__init__.pyi

@@ -1,5 +0,0 @@
-from aip_agents.utils.langgraph.tool_managers.a2a_tool_manager import A2AToolManager as A2AToolManager
-from aip_agents.utils.langgraph.tool_managers.base_tool_manager import BaseLangGraphToolManager as BaseLangGraphToolManager
-from aip_agents.utils.langgraph.tool_managers.delegation_tool_manager import DelegationToolManager as DelegationToolManager
-
-__all__ = ['BaseLangGraphToolManager', 'A2AToolManager', 'DelegationToolManager']

aip_agents/utils/langgraph/tool_managers/a2a_tool_manager.pyi

@@ -1,35 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
-from aip_agents.utils.a2a_connector import A2AConnector as A2AConnector
-from aip_agents.utils.langgraph.tool_managers.base_tool_manager import BaseLangGraphToolManager as BaseLangGraphToolManager
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-from langchain_core.tools import BaseTool as BaseTool
-
-logger: Incomplete
-
-class A2AToolManager(BaseLangGraphToolManager):
-    """Manages A2A communication tools for LangGraph agents.
-
-    This tool manager converts A2A agent cards into LangChain tools that can
-    be used in a unified ToolNode within LangGraph agents. Each A2A agent
-    becomes a tool that the LLM can call for external communication.
-    """
-    registered_agents: list
-    def __init__(self) -> None:
-        """Initialize the A2A tool manager."""
-    created_tools: Incomplete
-    def register_resources(self, agent_cards: list[AgentCard]) -> list[BaseTool]:
-        """Register A2A agents and convert them to LangChain tools.
-
-        Args:
-            agent_cards: List of AgentCard instances for external communication.
-
-        Returns:
-            List of created A2A communication tools.
-        """
-    def get_resource_names(self) -> list[str]:
-        """Get names of all registered A2A agents.
-
-        Returns:
-            list[str]: A list of names of all registered A2A agents.
-        """

aip_agents/utils/langgraph/tool_managers/delegation_tool_manager.pyi

@@ -1,50 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.types.a2a_events import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType
-from aip_agents.utils.artifact_helpers import extract_artifacts_from_agent_response as extract_artifacts_from_agent_response
-from aip_agents.utils.langgraph.tool_managers.base_tool_manager import BaseLangGraphToolManager as BaseLangGraphToolManager
-from aip_agents.utils.logger_manager import LoggerManager as LoggerManager
-from aip_agents.utils.reference_helper import extract_references_from_agent_response as extract_references_from_agent_response
-from aip_agents.utils.token_usage_helper import TOTAL_USAGE_KEY as TOTAL_USAGE_KEY, USAGE_METADATA_KEY as USAGE_METADATA_KEY, extract_token_usage_from_agent_response as extract_token_usage_from_agent_response
-from langchain_core.runnables import RunnableConfig as RunnableConfig
-from langchain_core.tools import BaseTool as BaseTool
-from langgraph.types import StreamWriter as StreamWriter
-
-RESULT_KEY: str
-ARTIFACTS_KEY: str
-METADATA_KEY: str
-REFERENCES_KEY: str
-OUTPUT_KEY: str
-logger: Incomplete
-METADATA_INTERNAL_PREFIXES: Incomplete
-METADATA_INTERNAL_KEYS: Incomplete
-AGENT_RUN_A2A_STREAMING_METHOD: str
-
-class DelegationToolManager(BaseLangGraphToolManager):
-    """Manages internal agent delegation tools for LangGraph agents.
-
-    This tool manager converts internal agent instances into LangChain tools
-    that can be used for task delegation within a unified ToolNode. Each
-    delegated agent becomes a tool that the coordinator can call.
-
-    Simplified version following legacy BaseLangChainAgent patterns.
-    """
-    registered_agents: list[BaseAgent]
-    def __init__(self) -> None:
-        """Initialize the delegation tool manager."""
-    created_tools: Incomplete
-    def register_resources(self, agents: list[BaseAgent]) -> list[BaseTool]:
-        """Register internal agents for delegation and convert them to tools.
-
-        Args:
-            agents: List of BaseAgent instances for internal task delegation.
-
-        Returns:
-            List of created delegation tools.
-        """
-    def get_resource_names(self) -> list[str]:
-        """Get names of all registered delegation agents.
-
-        Returns:
-            list[str]: A list of names of all registered delegation agents.
-        """