aip-agents-binary 0.5.20__py3-none-manylinux_2_31_x86_64.whl

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.py

@@ -0,0 +1,34 @@
+"""Utilities for constructing agent system instructions.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+from __future__ import annotations
+
+from aip_agents.utils.constants import DefaultTimezone
+from aip_agents.utils.datetime import get_timezone_aware_now
+
+__all__ = ["get_current_date_context", "DefaultTimezone"]
+
+
+def get_current_date_context(timezone: str = DefaultTimezone.JAKARTA) -> 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.
+    """
+    now, timezone_label, used_fallback = get_timezone_aware_now(timezone)
+    display_timezone = "UTC" if used_fallback else timezone_label
+    current_date = now.strftime("%Y-%m-%d")
+
+    return (
+        f"Very important: The user's timezone is {display_timezone}. "
+        f"The current date is {current_date}\n\n"
+        "Any dates before this are in the past, and any dates after this are in the future. "
+        "When the user asks for the 'latest', 'most recent', 'today's', etc. don't assume\n"
+        "your knowledge is up to date."
+    )

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__.py

@@ -0,0 +1,10 @@
+"""Clients module for external API integrations.
+
+This module contains HTTP clients for various external services and APIs,
+providing a unified interface for communication with different platforms.
+
+Authors:
+    - Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+__all__ = ["langflow"]

aip_agents/clients/__init__.pyi

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

aip_agents/clients/langflow/__init__.py

@@ -0,0 +1,10 @@
+"""Langflow client module for HTTP communication with Langflow APIs.
+
+This module provides the LangflowApiClient class that handles all HTTP communication
+with Langflow APIs, including both streaming and non-streaming execution modes.
+"""
+
+from aip_agents.clients.langflow.client import LangflowApiClient
+from aip_agents.clients.langflow.types import LangflowEventType
+
+__all__ = ["LangflowApiClient", "LangflowEventType"]

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.py

@@ -0,0 +1,477 @@
+"""Langflow API client for HTTP communication with Langflow API.
+
+This module provides the LangflowApiClient class that handles all HTTP communication
+with Langflow APIs, including both streaming and non-streaming execution modes.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+import json
+import os
+import uuid
+from collections.abc import AsyncGenerator
+from typing import Any
+
+import httpx
+
+from aip_agents.clients.langflow.types import LangflowEventType
+from aip_agents.schema.agent import HttpxClientOptions
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+DEFAULT_LANGFLOW_BASE_URL = os.getenv("LANGFLOW_BASE_URL", "https://langflow.obrol.id")
+MAX_PAGE_SIZE = 1000
+
+
+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
+    """
+
+    def __init__(
+        self,
+        flow_id: str | None = None,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        httpx_client_options: "HttpxClientOptions" = 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.
+        """
+        self.flow_id = flow_id
+        self.base_url = self._resolve_base_url(base_url)
+        self.api_key = self._resolve_api_key(api_key)
+        self.sessions: dict[str, str] = {}
+
+        # Get client options from config or use defaults
+        if not isinstance(httpx_client_options, HttpxClientOptions):
+            client_options = HttpxClientOptions()
+        else:
+            client_options = httpx_client_options
+
+        self.client_kwargs = {
+            "timeout": httpx.Timeout(client_options.timeout),
+            "trust_env": client_options.trust_env,
+            "follow_redirects": client_options.follow_redirects,
+        }
+
+        logger.info(f"Initialized Langflow API client for flow {self.flow_id} at {self.base_url}")
+
+    def _resolve_base_url(self, base_url: str | None) -> str:
+        """Resolve the base URL from config or environment variables.
+
+        Args:
+            base_url: Base URL from config.
+
+        Returns:
+            Resolved base URL.
+        """
+        if base_url:
+            return base_url.rstrip("/")
+
+        return DEFAULT_LANGFLOW_BASE_URL.rstrip("/")
+
+    def _resolve_api_key(self, api_key: str | None) -> str:
+        """Resolve the API key from config or environment variables.
+
+        Args:
+            api_key: API key from config.
+
+        Returns:
+            Resolved API key.
+
+        Raises:
+            ValueError: If no API key is found.
+        """
+        if api_key:
+            return api_key
+
+        env_key = os.getenv("LANGFLOW_API_KEY")
+        if env_key:
+            return env_key
+
+        raise ValueError("LANGFLOW_API_KEY not found. Please provide via config or environment variable.")
+
+    def _build_url(self, flow_id: str | None = None, stream: bool = False) -> str:
+        """Build the API URL for flow execution.
+
+        Args:
+            flow_id: Optional flow ID to use in the URL. If None, uses the instance flow_id.
+            stream: Whether to build URL for streaming mode.
+
+        Returns:
+            Complete API URL.
+        """
+        base_flow_url = f"{self.base_url}/api/v1/run/{self._ensure_flow_id(flow_id)}"
+        if stream:
+            return f"{base_flow_url}?stream=true"
+        return base_flow_url
+
+    def _build_headers(self) -> dict[str, str]:
+        """Build HTTP headers for API requests.
+
+        Returns:
+            Dictionary of HTTP headers.
+        """
+        return {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "x-api-key": self.api_key,
+        }
+
+    def _build_payload(self, input_value: str, session_id: str | None = None) -> dict[str, Any]:
+        """Build the request payload for Langflow API.
+
+        Args:
+            input_value: The user input to send to the flow.
+            session_id: Optional session ID for conversation continuity.
+
+        Returns:
+            Dictionary containing the request payload.
+        """
+        payload = {
+            "output_type": "chat",
+            "input_type": "chat",
+            "input_value": input_value,
+        }
+
+        if session_id:
+            payload["session_id"] = session_id
+
+        return payload
+
+    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.
+        """
+        if thread_id and thread_id in self.sessions:
+            return self.sessions[thread_id]
+
+        session_id = str(uuid.uuid4())
+        if thread_id:
+            self.sessions[thread_id] = session_id
+            logger.debug(f"Created new session {session_id} for thread {thread_id}")
+        else:
+            logger.debug(f"Created new session {session_id}")
+
+        return session_id
+
+    def _ensure_flow_id(self, flow_id: str | None) -> str:
+        """Ensure the flow ID is set.
+
+        Args:
+            flow_id: The flow ID to ensure.
+
+        Returns:
+            The flow ID.
+
+        Raises:
+            ValueError: If the flow ID is not set.
+        """
+        flow_id = flow_id or self.flow_id
+        if not flow_id:
+            raise ValueError("Flow ID is required")
+        return flow_id
+
+    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.
+        """
+        url = self._build_url(flow_id=flow_id, stream=False)
+        headers = self._build_headers()
+        payload = self._build_payload(input_value, session_id)
+
+        logger.debug(f"Calling flow {self._ensure_flow_id(flow_id)} with non-streaming mode")
+
+        async with httpx.AsyncClient(**self.client_kwargs) as client:
+            try:
+                response = await client.post(url, json=payload, headers=headers)
+                response.raise_for_status()
+
+                response_data = response.json()
+
+                # Return content or fallback
+                return response_data
+
+            except httpx.HTTPError as e:
+                logger.error(f"HTTP error during flow execution: {e}")
+                raise
+            except Exception as e:
+                logger.error(f"Error parsing flow response: {e}")
+                raise ValueError(f"Failed to parse flow response: {e}") from e
+
+    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.
+        """
+        url = self._build_url(flow_id=flow_id, stream=True)
+        headers = self._build_headers()
+        payload = self._build_payload(input_value, session_id)
+
+        logger.debug(f"Calling flow {self._ensure_flow_id(flow_id)} with streaming mode")
+
+        async with httpx.AsyncClient(**self.client_kwargs) as client:
+            try:
+                async with client.stream("POST", url, json=payload, headers=headers) as response:
+                    response.raise_for_status()
+
+                    async for line in response.aiter_lines():
+                        if line.strip():
+                            try:
+                                event_data = json.loads(line)
+                                yield event_data
+                            except json.JSONDecodeError:
+                                logger.warning(f"Skipping non-JSON line: {line}")
+                                continue
+
+            except httpx.HTTPError as e:
+                logger.error(f"HTTP error during streaming: {e}")
+                raise
+            except Exception as e:
+                logger.error(f"Error during streaming: {e}")
+                raise
+
+    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.
+        """
+        try:
+            event_type = event_data.get("event")
+
+            if event_type == LangflowEventType.ADD_MESSAGE:
+                message_data = event_data.get("data", {})
+                sender = message_data.get("sender", "Unknown")
+                text = message_data.get("text", "")
+                return {"type": LangflowEventType.ADD_MESSAGE, "sender": sender, "content": text, "raw": event_data}
+
+            elif event_type == LangflowEventType.END:
+                return {
+                    "type": LangflowEventType.END,
+                    "content": "Stream completed",
+                    "final": True,
+                    "raw": event_data,
+                }
+
+            else:
+                return {
+                    "type": LangflowEventType.UNKNOWN,
+                    "event_type": event_type,
+                    "content": str(event_data),
+                    "raw": event_data,
+                }
+
+        except Exception as e:
+            logger.warning(f"Error parsing stream event: {e}")
+            return None
+
+    def clear_session(self, thread_id: str) -> None:
+        """Clear session for a specific thread.
+
+        Args:
+            thread_id: Thread ID to clear session for.
+        """
+        if thread_id in self.sessions:
+            del self.sessions[thread_id]
+            logger.debug(f"Cleared session for thread {thread_id}")
+
+    def clear_all_sessions(self) -> None:
+        """Clear all stored sessions."""
+        self.sessions.clear()
+        logger.debug("Cleared all sessions")
+
+    async def get_flows(  # noqa: PLR0913
+        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.
+        """
+        self._validate_pagination_params(page, size)
+
+        url = f"{self.base_url}/api/v1/flows/"
+        headers = self._build_headers()
+
+        # Use exact parameter names from official docs
+        params = {
+            "remove_example_flows": str(remove_example_flows).lower(),
+            "components_only": str(components_only).lower(),
+            "get_all": str(get_all).lower(),
+            "header_flows": str(header_flows).lower(),
+            "page": page,
+            "size": size,
+        }
+
+        if project_id:
+            params["project_id"] = project_id
+
+        async with httpx.AsyncClient(**self.client_kwargs) as client:
+            try:
+                response = await client.get(url, headers=headers, params=params)
+                response.raise_for_status()
+
+                try:
+                    response_data = response.json()
+                except (json.JSONDecodeError, ValueError) as e:
+                    logger.error(f"Failed to parse JSON response: {e}")
+                    logger.warning(f"Response body: {response.text[:500]}...")
+                    raise ValueError(f"Failed to parse flows response: {e}") from e
+
+                if isinstance(response_data, list):
+                    return response_data
+                elif isinstance(response_data, dict) and "flows" in response_data:
+                    return response_data["flows"]
+                else:
+                    logger.warning(f"Unexpected response format: {type(response_data)}")
+                    if isinstance(response_data, dict):
+                        logger.warning(f"Response keys: {list(response_data.keys())}")
+                    else:
+                        logger.warning("Response keys: Not a dict")
+                    return []
+
+            except httpx.HTTPError as e:
+                logger.error(f"HTTP error retrieving flows: {e}")
+                logger.error(f"Response status: {e.response.status_code if hasattr(e, 'response') else 'Unknown'}")
+                raise
+            except Exception as e:
+                logger.error(f"Unexpected error during flows request: {e}")
+                raise ValueError(f"Unexpected error during flows request: {e}") from e
+
+    def _validate_pagination_params(self, page: int, size: int) -> None:
+        """Validate pagination parameters for flow retrieval.
+
+        Args:
+            page: Page number for pagination.
+            size: Number of flows per page.
+
+        Raises:
+            ValueError: If page or size parameters are invalid.
+        """
+        if page < 1:
+            raise ValueError("page must be >= 1")
+        if size < 1:
+            raise ValueError("size must be >= 1")
+        if size > MAX_PAGE_SIZE:
+            logger.warning(f"Large page size requested: {size}")
+
+    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.
+        """
+        return await self.get_flows(
+            project_id=project_id,
+            remove_example_flows=remove_example_flows,
+            components_only=components_only,
+            header_flows=header_flows,
+            get_all=True,
+        )
+
+    async def health_check(self) -> bool:
+        """Check if the Langflow API is accessible.
+
+        Returns:
+            True if the API is accessible, False otherwise.
+        """
+        try:
+            async with httpx.AsyncClient(**self.client_kwargs) as client:
+                response = await client.get(f"{self.base_url}/health", headers={"x-api-key": self.api_key})
+                return response.status_code == httpx.codes.OK
+        except Exception as e:
+            logger.warning(f"Health check failed: {e}")
+            return False