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

aip_agents/agent/interfaces.pyi

@@ -1,44 +0,0 @@
-from collections.abc import AsyncIterator
-from typing import Any, Protocol
-
-class LangGraphAgentProtocol(Protocol):
-    """Minimal interface required by LangGraphA2AExecutor."""
-    name: str
-    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncIterator[dict[str, Any]]:
-        """Stream A2A-compatible chunks for the given query.
-
-        Args:
-            query (str): The query to execute and stream.
-            **kwargs (Any): Additional keyword arguments for execution.
-
-        Yields:
-            dict[str, Any]: A2A-compatible streaming chunks.
-        """
-
-class LangflowAgentProtocol(Protocol):
-    """Minimal interface required by LangflowA2AExecutor."""
-    name: str
-    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncIterator[dict[str, Any]]:
-        """Stream A2A-compatible chunks for the given query.
-
-        Args:
-            query (str): The query to execute and stream.
-            **kwargs (Any): Additional keyword arguments for execution.
-
-        Yields:
-            dict[str, Any]: A2A-compatible streaming chunks.
-        """
-
-class GoogleADKAgentProtocol(Protocol):
-    """Minimal interface required by GoogleADKExecutor."""
-    name: str
-    async def arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncIterator[dict[str, Any]]:
-        """Stream A2A-compatible chunks for the given query.
-
-        Args:
-            query (str): The query to execute and stream.
-            **kwargs (Any): Additional keyword arguments for execution.
-
-        Yields:
-            dict[str, Any]: A2A-compatible streaming chunks.
-        """

aip_agents/agent/langflow_agent.pyi

@@ -1,133 +0,0 @@
-from _typeshed import Incomplete
-from a2a.types import AgentCard as AgentCard
-from aip_agents.agent.base_agent import BaseAgent as BaseAgent
-from aip_agents.clients.langflow import LangflowApiClient as LangflowApiClient
-from aip_agents.clients.langflow.types import LangflowEventType as LangflowEventType
-from aip_agents.schema.agent import LangflowAgentConfig as LangflowAgentConfig
-from aip_agents.types import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType
-from aip_agents.utils.logger import get_logger as get_logger
-from aip_agents.utils.sse_chunk_transformer import SSEChunkTransformer as SSEChunkTransformer
-from collections.abc import AsyncGenerator
-from typing import Any
-
-logger: Incomplete
-
-class LangflowAgent(BaseAgent):
-    """Langflow agent implementation for executing Langflow flows.
-
-    This agent integrates with Langflow APIs to execute flows while providing
-    full compatibility with the SDK's agent framework, including:
-    - Synchronous and asynchronous execution
-    - Regular and A2A streaming support
-    - Session management for conversation continuity
-    - Error handling and retry logic
-    - Credential management through BaseAgent
-
-    The agent builds on BaseAgent to gain shared A2A utilities while focusing on
-    Langflow-specific execution logic.
-    """
-    langflow_config: Incomplete
-    flow_id: Incomplete
-    api_client: Incomplete
-    def __init__(self, name: str, flow_id: str, description: str | None = None, base_url: str | None = None, api_key: str | None = None, config: LangflowAgentConfig | dict[str, Any] | None = None, **kwargs: Any) -> None:
-        """Initialize the LangflowAgent.
-
-        Args:
-            name: The name of the agent.
-            flow_id: The unique identifier of the Langflow flow to execute.
-            description: Human-readable description.
-            base_url: The base URL of the Langflow API server.
-            api_key: The API key for Langflow authentication.
-            config: Langflow-specific configuration or dict.
-            **kwargs: Additional keyword arguments passed to BaseAgent.
-        """
-    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
-        """Synchronously run the Langflow 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 Langflow agent.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Dictionary containing the agent's response and metadata.
-        """
-    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[str | dict[str, Any], None]:
-        """Asynchronously stream the Langflow agent's response.
-
-        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 arun_a2a_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[dict[str, Any], None]:
-        """Asynchronously stream the agent's response in A2A format.
-
-        This method converts Langflow streaming events into A2A-compatible events
-        following the patterns established by BaseLangGraphAgent.
-
-        Args:
-            query: The input query for the agent.
-            **kwargs: Additional keyword arguments.
-
-        Yields:
-            A2A-compatible event dictionaries with semantic event types.
-        """
-    async def arun_sse_stream(self, query: str, task_id: str | None = None, context_id: str | None = None, **kwargs: Any) -> AsyncGenerator[dict[str, Any], 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
-        '''
-    def register_a2a_agents(self, agents: list[AgentCard]) -> None:
-        """Register A2A agents (not supported for Langflow agents).
-
-        Args:
-            agents: List of AgentCard instances.
-
-        Raises:
-            NotImplementedError: Langflow agents don't support A2A agent registration.
-        """
-    def add_mcp_server(self, mcp_config: dict[str, dict[str, Any]]) -> None:
-        """Add MCP server configuration (not supported for Langflow agents).
-
-        Args:
-            mcp_config: MCP server configuration.
-
-        Raises:
-            NotImplementedError: Langflow agents don't support MCP servers.
-        """
-    async def health_check(self) -> bool:
-        """Check if the Langflow API is accessible.
-
-        Returns:
-            True if the API is accessible, False otherwise.
-        """

aip_agents/agent/langgraph_memory_enhancer_agent.pyi

@@ -1,49 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent.langgraph_react_agent import LangGraphReactAgent as LangGraphReactAgent
-from aip_agents.agent.system_instruction_context import get_current_date_context as get_current_date_context
-from aip_agents.memory.guidance import MEM0_MEMORY_RECALL_GUIDANCE as MEM0_MEMORY_RECALL_GUIDANCE
-from aip_agents.tools.memory_search_tool import LongTermMemorySearchTool as LongTermMemorySearchTool, MEMORY_SEARCH_TOOL_NAME as MEMORY_SEARCH_TOOL_NAME, Mem0SearchTool as Mem0SearchTool
-from aip_agents.utils.logger import get_logger as get_logger
-from langgraph.graph import StateGraph
-from langgraph.graph.state import CompiledStateGraph
-
-logger: Incomplete
-
-class LangGraphMemoryEnhancerAgent(LangGraphReactAgent):
-    """Simplified mini-agent for automatic memory retrieval and query enhancement.
-
-    This agent has a simple 2-node LangGraph (agent + tools) and uses existing memory
-    infrastructure to enhance user queries with relevant context. It acts as a
-    preprocessing layer that automatically attempts memory retrieval for every query.
-
-    Key features:
-    - Uses runtime `memory_user_id` provided via call arguments (no static storage)
-    - Uses simplified instruction reusing existing guidance
-    - Standard 2-node LangGraph pattern (agent -> tools -> agent)
-    - Automatically enhances queries with memory context when available
-    - Returns original query unchanged if no relevant memories found
-    """
-    def __init__(self, memory, **kwargs) -> None:
-        """Initialize the LangGraphMemoryEnhancerAgent with memory backend and configuration.
-
-        Args:
-            memory: Memory backend instance (Mem0Memory or compatible)
-            **kwargs: Additional arguments passed to BaseLangGraphAgent, including:
-                - memory_agent_id: Fallback user ID for memory operations
-                - model: LLM model to use for memory decisions
-                - Other BaseLangGraphAgent parameters
-        """
-    def define_graph(self, graph_builder: StateGraph) -> CompiledStateGraph:
-        """Define the 3-node memory recall LangGraph for this agent.
-
-        This creates a streamlined ReAct-inspired structure that reuses
-        `LangGraphReactAgent` helpers for robust LM invocation, token usage tracking,
-        error handling, and tool execution.
-
-        Args:
-            graph_builder: LangGraph `StateGraph` builder instance used to register nodes and
-                edges for compilation.
-
-        Returns:
-            CompiledStateGraph: The compiled memory recall graph ready for execution.
-        """

aip_agents/agent/langgraph_react_agent.pyi

@@ -1,170 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent.base_langgraph_agent import BaseLangGraphAgent as BaseLangGraphAgent
-from aip_agents.agent.hitl.langgraph_hitl_mixin import LangGraphHitLMixin as LangGraphHitLMixin
-from aip_agents.agent.hitl.manager import TOOL_EXECUTION_BLOCKING_DECISIONS as TOOL_EXECUTION_BLOCKING_DECISIONS
-from aip_agents.guardrails.manager import GuardrailManager as GuardrailManager
-from aip_agents.middleware.base import AgentMiddleware as AgentMiddleware, ModelRequest as ModelRequest
-from aip_agents.middleware.manager import MiddlewareManager as MiddlewareManager
-from aip_agents.middleware.todolist import TodoList as TodoList, TodoListMiddleware as TodoListMiddleware
-from aip_agents.ptc import PTCSandboxConfig as PTCSandboxConfig
-from aip_agents.schema.a2a import A2AStreamEventType as A2AStreamEventType
-from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, HitlMetadata as HitlMetadata
-from aip_agents.schema.langgraph import ToolCallResult as ToolCallResult, ToolStorageParams as ToolStorageParams
-from aip_agents.schema.step_limit import MaxStepsExceededError as MaxStepsExceededError, StepLimitConfig as StepLimitConfig
-from aip_agents.tools.memory_search_tool import MEMORY_SEARCH_TOOL_NAME as MEMORY_SEARCH_TOOL_NAME
-from aip_agents.tools.tool_config_injector import TOOL_CONFIGS_KEY as TOOL_CONFIGS_KEY
-from aip_agents.utils import add_references_chunks as add_references_chunks
-from aip_agents.utils.langgraph import convert_langchain_messages_to_gllm_messages as convert_langchain_messages_to_gllm_messages, convert_lm_output_to_langchain_message as convert_lm_output_to_langchain_message
-from aip_agents.utils.langgraph.tool_output_management import StoreOutputParams as StoreOutputParams, ToolOutputManager as ToolOutputManager, ToolReferenceError as ToolReferenceError, ToolReferenceResolver as ToolReferenceResolver
-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 Kind as Kind, MetadataFieldKeys as MetadataFieldKeys, Status as Status
-from aip_agents.utils.pii import ToolPIIHandler as ToolPIIHandler, add_pii_mappings as add_pii_mappings, normalize_enable_pii as normalize_enable_pii
-from aip_agents.utils.reference_helper import extract_references_from_tool as extract_references_from_tool
-from aip_agents.utils.step_limit_manager import StepLimitManager as StepLimitManager
-from aip_agents.utils.token_usage_helper import TOTAL_USAGE_KEY as TOTAL_USAGE_KEY, USAGE_METADATA_KEY as USAGE_METADATA_KEY, add_usage_metadata as add_usage_metadata, extract_and_update_token_usage_from_ai_message as extract_and_update_token_usage_from_ai_message, extract_token_usage_from_tool_output as extract_token_usage_from_tool_output
-from collections.abc import Awaitable as Awaitable, Sequence
-from dataclasses import dataclass
-from gllm_core.event import EventEmitter
-from gllm_core.schema import Chunk as Chunk
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import BaseMessage as BaseMessage
-from langchain_core.messages.ai import UsageMetadata
-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.managed import IsLastStep, RemainingSteps
-from typing import Annotated, Any
-from typing_extensions import TypedDict
-
-logger: Incomplete
-DEFAULT_INSTRUCTION: str
-TOOL_RUN_STREAMING_METHOD: str
-TOOL_OUTPUT_MANAGER_KEY: str
-CALL_ID_KEY: str
-
-@dataclass
-class ToolCallContext:
-    """Context information for executing a single tool call."""
-    config: dict[str, Any] | None
-    state: dict[str, Any]
-    pending_artifacts: list[dict[str, Any]]
-    hitl_decision: ApprovalDecision | None = ...
-
-class ReactAgentState(TypedDict):
-    """State schema for the ReAct agent.
-
-    Includes messages, step tracking, optional event emission support, artifacts, references,
-    metadata, tool output management, and deep agents middleware state (todos, filesystem).
-    """
-    messages: Annotated[Sequence[BaseMessage], add_messages]
-    is_last_step: IsLastStep
-    remaining_steps: RemainingSteps
-    event_emitter: EventEmitter | None
-    artifacts: list[dict[str, Any]] | None
-    references: Annotated[list[Chunk], add_references_chunks]
-    metadata: dict[str, Any] | None
-    tool_output_manager: ToolOutputManager | None
-    total_usage: Annotated[UsageMetadata | None, add_usage_metadata]
-    pii_mapping: Annotated[dict[str, str] | None, add_pii_mappings]
-    thread_id: str
-    todos: TodoList | None
-    current_step: int
-    delegation_depth: int
-    delegation_chain: list[str]
-    step_limit_config: StepLimitConfig | None
-
-class LangGraphReactAgent(LangGraphHitLMixin, BaseLangGraphAgent):
-    """A ReAct agent template built on LangGraph.
-
-    This agent can use either:
-    - An LMInvoker (if self.lm_invoker is set by BaseAgent)
-    - A LangChain BaseChatModel (if self.model is set by BaseAgent)
-
-    The graph structure follows the standard ReAct pattern:
-    agent -> tools -> agent (loop) -> END
-    """
-    tool_output_manager: Incomplete
-    step_limit_config: Incomplete
-    def __init__(self, name: str, instruction: str = ..., model: BaseChatModel | str | Any | None = None, tools: Sequence[BaseTool] | None = None, agents: Sequence[Any] | None = None, description: str | None = None, thread_id_key: str = 'thread_id', event_emitter: EventEmitter | None = None, tool_output_manager: ToolOutputManager | None = None, planning: bool = False, middlewares: Sequence[AgentMiddleware] | None = None, guardrail: GuardrailManager | None = None, step_limit_config: StepLimitConfig | None = None, ptc_config: PTCSandboxConfig | None = None, **kwargs: Any) -> None:
-        """Initialize the LangGraph ReAct Agent.
-
-        Args:
-            name: The name of the agent.
-            instruction: The system instruction for the agent.
-            model: The model to use (lm_invoker, LangChain model, string, etc.).
-            tools: Sequence of LangChain tools available to the agent.
-            agents: Optional sequence of sub-agents for delegation (coordinator mode).
-            description: Human-readable description of the agent.
-            thread_id_key: Key for thread ID in configuration.
-            event_emitter: Optional event emitter for streaming updates.
-            tool_output_manager: Optional ToolOutputManager instance for tool output management.
-                When provided, enables tool output storage, reference resolution, and sharing capabilities.
-                This enables multi-agent workflows where agents can access each other's tool outputs.
-                If None, tool output management is disabled for this agent.
-            planning: Enable planning capabilities with TodoListMiddleware. Defaults to False.
-            middlewares: Optional sequence of custom middleware to COMPOSE (not override) with built-in middleware.
-                        Execution order: [TodoListMiddleware (if planning=True),
-                                         GuardrailMiddleware (if guardrail provided),
-                                         ...custom middlewares in order provided]
-                        All middleware hooks execute - this extends capabilities, never replaces them.
-            guardrail: Optional GuardrailManager for content filtering and safety checks.
-                     When provided, automatically wraps in GuardrailMiddleware for transparent
-                     input/output filtering during agent execution.
-            enable_pii: Optional toggle to enable PII handling for tool inputs and outputs.
-            step_limit_config: Optional configuration for step limits and delegation depth.
-            ptc_config: Optional configuration for PTC sandbox execution. See PTCSandboxConfig
-                for available options including enabled flag, sandbox timeout, and template settings.
-                PTC is enabled when ptc_config is not None and ptc_config.enabled is True.
-                When enabled, prompt guidance is automatically injected into the agent's instruction.
-                PTC runs in a sandbox only; there is no in-process trusted PTC path.
-            **kwargs: Additional keyword arguments passed to BaseLangGraphAgent.
-        """
-    def define_graph(self, graph_builder: StateGraph) -> CompiledStateGraph:
-        """Define the ReAct agent graph structure.
-
-        Args:
-            graph_builder: The StateGraph builder to define the graph structure.
-
-        Returns:
-            Compiled LangGraph ready for execution.
-        """
-    def add_mcp_server(self, mcp_config: dict[str, dict[str, Any]]) -> None:
-        """Add MCP servers and refresh PTC tool state if needed."""
-    def enable_ptc(self, config: PTCSandboxConfig | None = None) -> None:
-        '''Enable Programmatic Tool Calling (PTC) for this agent.
-
-        PTC allows the LLM to execute Python code that calls MCP tools
-        programmatically inside a sandboxed environment. This is useful for
-        chaining multiple tool calls with local data processing.
-
-        The execute_ptc_code tool is automatically added to the agent\'s tools
-        after MCP servers are configured. If no MCP servers are configured,
-        the tool sync is deferred until servers are added.
-
-        Args:
-            config: Optional configuration for PTC sandbox execution.
-                See PTCSandboxConfig for options like enabled flag and sandbox_timeout.
-                If None is passed, a default config with enabled=True will be created.
-
-        Example:
-            agent.enable_ptc(PTCSandboxConfig(enabled=True))
-            agent.add_mcp_server({"yfinance": {...}})
-            # execute_ptc_code tool is now available
-
-        Note:
-            PTC can also be enabled via the constructor by passing
-            ptc_config=PTCSandboxConfig(enabled=True, ...).
-        '''
-    async def cleanup(self) -> None:
-        """Cleanup agent resources including PTC sandbox.
-
-        Extends base cleanup to also cleanup the PTC sandbox runtime if
-        execute_ptc_code tool was created.
-        """
-
-class LangGraphAgent(LangGraphReactAgent):
-    """Alias for LangGraphReactAgent."""
-class LangChainAgent(LangGraphReactAgent):
-    """Alias for LangGraphReactAgent."""

aip_agents/agent/system_instruction_context.pyi

@@ -1,13 +0,0 @@
-from aip_agents.utils.constants import DefaultTimezone as DefaultTimezone
-
-__all__ = ['get_current_date_context', 'DefaultTimezone']
-
-def get_current_date_context(timezone: str = ...) -> str:
-    """Generate current date context for system prompts.
-
-    Args:
-        timezone: IANA timezone name for date formatting.
-
-    Returns:
-        Formatted date context string for inclusion in system prompts.
-    """

aip_agents/clients/__init__.pyi

@@ -1,4 +0,0 @@
-__all__ = ['langflow']
-
-# Names in __all__ with no definition:
-#   langflow

aip_agents/clients/langflow/__init__.pyi

@@ -1,4 +0,0 @@
-from aip_agents.clients.langflow.client import LangflowApiClient as LangflowApiClient
-from aip_agents.clients.langflow.types import LangflowEventType as LangflowEventType
-
-__all__ = ['LangflowApiClient', 'LangflowEventType']

aip_agents/clients/langflow/client.pyi

@@ -1,140 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.clients.langflow.types import LangflowEventType as LangflowEventType
-from aip_agents.schema.agent import HttpxClientOptions as HttpxClientOptions
-from aip_agents.utils.logger import get_logger as get_logger
-from collections.abc import AsyncGenerator
-from typing import Any
-
-logger: Incomplete
-DEFAULT_LANGFLOW_BASE_URL: Incomplete
-MAX_PAGE_SIZE: int
-
-class LangflowApiClient:
-    """HTTP client for Langflow API with streaming and non-streaming support.
-
-    This client handles all communication with Langflow APIs, including:
-    - Non-streaming execution
-    - Server-Sent Events (SSE) streaming
-    - Session management for conversation continuity
-    - Error handling and retries
-    - Credential management
-    """
-    flow_id: Incomplete
-    base_url: Incomplete
-    api_key: Incomplete
-    sessions: dict[str, str]
-    client_kwargs: Incomplete
-    def __init__(self, flow_id: str | None = None, base_url: str | None = None, api_key: str | None = None, httpx_client_options: HttpxClientOptions = None) -> None:
-        """Initialize the Langflow API client.
-
-        Args:
-            flow_id: The unique identifier of the Langflow flow to execute.
-            base_url: The base URL of the Langflow API server.
-            api_key: The API key for Langflow authentication.
-            httpx_client_options: HTTP client configuration options for httpx, including timeout.
-        """
-    def get_or_create_session(self, thread_id: str | None = None) -> str:
-        """Get existing session ID or create a new one.
-
-        Args:
-            thread_id: Optional thread ID for session mapping.
-
-        Returns:
-            Session ID for the conversation.
-        """
-    async def call_flow(self, input_value: str, session_id: str | None = None, flow_id: str | None = None, **_: Any) -> dict[str, Any]:
-        """Execute Langflow flow without streaming.
-
-        Args:
-            input_value: The user input to send to the flow.
-            session_id: Optional session ID for conversation continuity.
-            flow_id: Optional flow ID to execute. If None, uses the instance flow_id.
-            **_: Additional keyword arguments.
-
-        Returns:
-            The response from the flow execution.
-
-        Raises:
-            httpx.HTTPError: If the HTTP request fails.
-            ValueError: If the response cannot be parsed.
-        """
-    async def stream_flow(self, input_value: str, session_id: str | None = None, flow_id: str | None = None, **_: Any) -> AsyncGenerator[dict[str, Any], None]:
-        """Execute Langflow flow with streaming.
-
-        Args:
-            input_value: The user input to send to the flow.
-            session_id: Optional session ID for conversation continuity.
-            flow_id: Optional flow ID to execute. If None, uses the instance flow_id.
-            **_: Additional keyword arguments.
-
-        Yields:
-            Parsed streaming events from the Langflow API.
-
-        Raises:
-            httpx.HTTPError: If the HTTP request fails.
-            ValueError: If streaming events cannot be parsed.
-        """
-    def parse_stream_event(self, event_data: dict[str, Any]) -> dict[str, Any] | None:
-        """Parse a single streaming event from Langflow.
-
-        Args:
-            event_data: Raw event data from Langflow streaming response.
-
-        Returns:
-            Parsed event dictionary or None if event should be skipped.
-        """
-    def clear_session(self, thread_id: str) -> None:
-        """Clear session for a specific thread.
-
-        Args:
-            thread_id: Thread ID to clear session for.
-        """
-    def clear_all_sessions(self) -> None:
-        """Clear all stored sessions."""
-    async def get_flows(self, project_id: str | None = None, remove_example_flows: bool = False, components_only: bool = False, header_flows: bool = False, get_all: bool = True, page: int = 1, size: int = 50) -> list[dict[str, Any]]:
-        """Retrieve flows from Langflow API with full control over parameters.
-
-        Based on the official API docs: https://docs.langflow.org/api-flows
-        Uses the exact parameter format from the documentation.
-
-        Args:
-            project_id: Optional project ID to filter flows.
-            remove_example_flows: Whether to exclude example flows. Defaults to False.
-            components_only: Whether to return only components. Defaults to False.
-            header_flows: Whether to return only flow headers. Defaults to False.
-            get_all: Whether to return all flows (ignores pagination). Defaults to True.
-            page: Page number for pagination (ignored if get_all=True). Defaults to 1.
-            size: Number of flows per page (ignored if get_all=True). Defaults to 50.
-
-        Returns:
-            List of flows or flow headers from the Langflow API.
-
-        Raises:
-            httpx.HTTPError: If the HTTP request fails.
-            ValueError: If the response cannot be parsed or invalid parameters provided.
-        """
-    async def get_all_flows(self, project_id: str | None = None, remove_example_flows: bool = False, components_only: bool = False, header_flows: bool = False) -> list[dict[str, Any]]:
-        """Convenience method to get ALL flows using the backend's get_all=true feature.
-
-        This method is a simple wrapper around get_flows() with get_all=True,
-        which uses the Langflow backend's ability to return all flows in one request.
-
-        Args:
-            project_id: Optional project ID to filter flows.
-            remove_example_flows: Whether to exclude example flows. Defaults to False.
-            components_only: Whether to return only components. Defaults to False.
-            header_flows: Whether to return only flow headers. Defaults to False.
-
-        Returns:
-            List of all flows from the Langflow API.
-
-        Raises:
-            httpx.HTTPError: If the HTTP request fails.
-            ValueError: If the response cannot be parsed.
-        """
-    async def health_check(self) -> bool:
-        """Check if the Langflow API is accessible.
-
-        Returns:
-            True if the API is accessible, False otherwise.
-        """

aip_agents/clients/langflow/types.pyi

@@ -1,7 +0,0 @@
-from enum import StrEnum
-
-class LangflowEventType(StrEnum):
-    """Enum for Langflow event types as received from the API."""
-    ADD_MESSAGE: str
-    END: str
-    UNKNOWN: str

aip_agents/constants.pyi

@@ -1,7 +0,0 @@
-from _typeshed import Incomplete
-
-BASE_DIR: Incomplete
-DEFAULT_AGENT_TIMEOUT: int
-LAST_N_CHATS: int
-MAX_MEMORY_TOKENS: int
-TEXT_PREVIEW_LENGTH: int

aip_agents/examples/compare_streaming_client.pyi

@@ -1,48 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent import LangGraphAgent as LangGraphAgent
-from aip_agents.examples.tools.mock_retrieval_tool import MockRetrievalTool as MockRetrievalTool
-from aip_agents.examples.tools.pii_demo_tools import get_customer_info as get_customer_info, get_employee_data as get_employee_data, get_user_profile as get_user_profile
-from aip_agents.examples.tools.random_chart_tool import RandomChartTool as RandomChartTool
-from aip_agents.examples.tools.table_generator_tool import TableGeneratorTool as TableGeneratorTool
-from aip_agents.schema.a2a import A2AStreamEventType as A2AStreamEventType
-from aip_agents.schema.agent import A2AClientConfig as A2AClientConfig
-from aip_agents.utils.logger import get_logger as get_logger
-from typing import Any
-
-logger: Incomplete
-SERVER_URL: str
-
-def create_local_agent(enable_token_streaming: bool = False) -> LangGraphAgent:
-    """Create a local agent with the same tools as the server.
-
-    Args:
-        enable_token_streaming: Whether to enable token streaming for content_chunk events.
-    """
-def format_chunk_summary(chunk: dict[str, Any], index: int) -> str:
-    """Format a chunk for display."""
-async def run_direct_streaming(agent: LangGraphAgent, query: str, pii_mapping: dict[str, str] | None = None) -> list[dict[str, Any]]:
-    """Run arun_sse_stream and collect all chunks."""
-async def run_connector_streaming(agent: LangGraphAgent, query: str, pii_mapping: dict[str, str] | None = None) -> list[dict[str, Any]]:
-    """Run astream_to_agent via A2A connector and collect all chunks."""
-def get_chunk_keys(chunks: list[dict[str, Any]]) -> set[str]:
-    """Get all unique keys across all chunks."""
-def get_field_types(chunks: list[dict[str, Any]], field: str) -> set[str]:
-    """Get all types seen for a field across chunks.
-
-    Note: StrEnum values are reported as 'str' since they ARE strings
-    and serialize identically over HTTP/SSE.
-    """
-def group_chunks_by_event_type(chunks: list[dict[str, Any]]) -> dict[str, list[dict[str, Any]]]:
-    """Group chunks by their event_type."""
-def compare_chunk_structure(chunk1: dict[str, Any], chunk2: dict[str, Any]) -> dict[str, Any]:
-    """Compare structure of two chunks and return differences."""
-def compare_event_type_groups(direct_groups: dict[str, list[dict[str, Any]]], connector_groups: dict[str, list[dict[str, Any]]]) -> dict[str, Any]:
-    """Compare chunks grouped by event type - RAW comparison without filtering."""
-def compare_chunks(direct_chunks: list[dict[str, Any]], connector_chunks: list[dict[str, Any]]) -> dict[str, Any]:
-    """Compare the two chunk lists and produce a comprehensive structural summary."""
-def print_event_type_comparison(event_comparison: dict[str, Any]) -> None:
-    """Print per-event-type comparison details with exact key/value examples."""
-def print_structure_comparison(comparison: dict[str, Any]) -> None:
-    """Print detailed structure comparison."""
-async def main() -> None:
-    """Main comparison workflow."""

aip_agents/examples/compare_streaming_server.pyi

@@ -1,18 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.agent import LangGraphAgent as LangGraphAgent
-from aip_agents.examples.tools.mock_retrieval_tool import MockRetrievalTool as MockRetrievalTool
-from aip_agents.examples.tools.pii_demo_tools import get_customer_info as get_customer_info, get_employee_data as get_employee_data, get_user_profile as get_user_profile
-from aip_agents.examples.tools.random_chart_tool import RandomChartTool as RandomChartTool
-from aip_agents.examples.tools.table_generator_tool import TableGeneratorTool as TableGeneratorTool
-from aip_agents.utils.logger import get_logger as get_logger
-
-logger: Incomplete
-SERVER_AGENT_NAME: str
-
-def main(host: str, port: int):
-    """Runs the streaming comparison A2A server.
-
-    Args:
-        host: Host to bind the server to.
-        port: Port to bind the server to.
-    """