aip-agents-binary 0.5.7__py3-none-macosx_13_0_arm64.whl

aip_agents/agent/hitl/prompt/base.pyi

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalRequest as ApprovalRequest
+
+class BasePromptHandler(ABC):
+    """Abstract base class for prompt handlers used in HITL flows."""
+    def attach_manager(self, manager: ApprovalManager) -> None:
+        """Optionally attach the ``ApprovalManager`` coordinating approvals.
+
+        Args:
+            manager (ApprovalManager): The approval manager instance to attach.
+        """
+    @abstractmethod
+    async def prompt_for_decision(self, request: ApprovalRequest, timeout_seconds: int, context_keys: list[str] | None = None) -> ApprovalDecision:
+        """Collect and return a decision for the given approval request.
+
+        Args:
+            request (ApprovalRequest): The approval request to prompt for.
+            timeout_seconds (int): Maximum time to wait for a decision in seconds.
+            context_keys (list[str] | None, optional): Optional keys for additional context. Defaults to None.
+
+        Returns:
+            ApprovalDecision: The decision made for the approval request.
+        """

aip_agents/agent/hitl/prompt/deferred.pyi

@@ -0,0 +1,30 @@
+from aip_agents.agent.hitl.manager import ApprovalManager as ApprovalManager
+from aip_agents.agent.hitl.prompt.base import BasePromptHandler as BasePromptHandler
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalRequest as ApprovalRequest
+from collections.abc import Callable
+
+class DeferredPromptHandler(BasePromptHandler):
+    """Prompt handler that defers tool execution until an external decision is received."""
+    def __init__(self, notify: Callable[[ApprovalRequest], None] | None = None) -> None:
+        """Initialize the deferred prompt handler.
+
+        Args:
+            notify: Optional callback function to notify when an approval request is made.
+        """
+    def attach_manager(self, manager: ApprovalManager) -> None:
+        """Attach the ApprovalManager orchestrating approvals.
+
+        Args:
+            manager: The ApprovalManager instance to attach for handling approval decisions.
+        """
+    async def prompt_for_decision(self, request: ApprovalRequest, timeout_seconds: int, context_keys: list[str] | None = None) -> ApprovalDecision:
+        """Register a waiter and return a pending decision sentinel.
+
+        Args:
+            request: The approval request containing the tool call details and context.
+            timeout_seconds: Number of seconds to wait for approval before timing out.
+            context_keys: Optional list of context keys to include in the approval request.
+
+        Returns:
+            ApprovalDecision with PENDING status and registered waiter for external resolution.
+        """

aip_agents/agent/interface.pyi

@@ -0,0 +1,81 @@
+from a2a.types import AgentCard as AgentCard
+from abc import ABC, abstractmethod
+from aip_agents.schema.agent import BaseAgentConfig as BaseAgentConfig
+from collections.abc import AsyncGenerator
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker
+from typing import Any
+
+class AgentInterface(ABC):
+    """A general and minimal interface for agent implementations.
+
+    Defines core execution methods (`__init__`, `run`, `arun`, `arun_stream`).
+    Concrete subclasses must implement all abstract methods.
+    """
+    name: str
+    instruction: str
+    description: str | None
+    mcp_config: dict[str, Any]
+    lm_invoker: BaseLMInvoker | None
+    config: BaseAgentConfig | None
+    def __init__(self, name: str, instruction: str, description: str | None = None, lm_invoker: BaseLMInvoker | None = None, config: BaseAgentConfig | None = None, **kwargs: Any) -> None:
+        """Initializes the agent.
+
+        Args:
+            name: The name of the agent.
+            instruction: The core directive or system prompt for the agent.
+            description: Human-readable description. Defaults to instruction if not provided.
+            lm_invoker: The language model invoker to use for LLM interactions. Defaults to None.
+            config: Additional configuration for the agent.
+            **kwargs: Additional keyword arguments for concrete implementations.
+        """
+    @abstractmethod
+    def run(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Synchronously runs the agent.
+
+        Args:
+            query: The input query for the agent.
+            **kwargs: Additional keyword arguments for execution.
+
+        Returns:
+            Dict containing at least {'output': ...}.
+        """
+    @abstractmethod
+    async def arun(self, query: str, **kwargs: Any) -> dict[str, Any]:
+        """Asynchronously runs the agent.
+
+        Args:
+            query: The input query for the agent.
+            **kwargs: Additional keyword arguments for execution.
+
+        Returns:
+            Dict containing at least {'output': ...}.
+        """
+    @abstractmethod
+    async def arun_stream(self, query: str, **kwargs: Any) -> AsyncGenerator[str | dict[str, Any], None]:
+        """Asynchronously streams the agent's response.
+
+        Args:
+            query: The input query.
+            **kwargs: Extra parameters for execution.
+
+        Yields:
+            Chunks of output (strings or dicts).
+        """
+    @abstractmethod
+    def add_mcp_server(self, mcp_config: dict[str, dict[str, Any]]) -> None:
+        """Adds a new MCP server configuration.
+
+        Args:
+            mcp_config: Dictionary containing server name as key and its configuration as value.
+
+        Raises:
+            ValueError: If mcp_config is empty or None, or if any server configuration is invalid.
+            KeyError: If any server name already exists in the configuration.
+        """
+    @abstractmethod
+    def register_a2a_agents(self, agents: list[AgentCard]):
+        """Registers A2A agents from a list of AgentCards.
+
+        Args:
+            agents: A list of AgentCard instances.
+        """

aip_agents/agent/interfaces.pyi

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,126 @@
+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.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.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, step_limit_config: StepLimitConfig | 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),
+                                         ...custom middlewares in order provided]
+                        All middleware hooks execute - this extends capabilities, never replaces them.
+            enable_pii: Optional toggle to enable PII handling for tool inputs and outputs.
+            step_limit_config: Optional configuration for step limits and delegation depth.
+            **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.
+        """
+
+class LangGraphAgent(LangGraphReactAgent):
+    """Alias for LangGraphReactAgent."""
+class LangChainAgent(LangGraphReactAgent):
+    """Alias for LangGraphReactAgent."""

aip_agents/agent/system_instruction_context.pyi

@@ -0,0 +1,13 @@
+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

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

aip_agents/clients/langflow/__init__.pyi

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,140 @@
+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

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