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

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

@@ -0,0 +1,18 @@
+"""Types and enums for Langflow client module.
+
+This module contains type definitions, enums, and data structures
+specific to Langflow API communication and event handling.
+
+Authors:
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
+"""
+
+from enum import StrEnum
+
+
+class LangflowEventType(StrEnum):
+    """Enum for Langflow event types as received from the API."""
+
+    ADD_MESSAGE = "add_message"
+    END = "end"
+    UNKNOWN = "unknown"

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

aip_agents/constants.py

@@ -0,0 +1,23 @@
+"""Generic Constants for AIP Agents components.
+
+Authors:
+    Raymond Christopher (raymond.christopher@gdplabs.id)
+"""
+
+import os
+
+# Base directory of the project
+# Note: This might need adjustment depending on how aip_agents is used as a library.
+#       Consider if this is truly needed in the generic package.
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Agent settings
+DEFAULT_AGENT_TIMEOUT = 120  # seconds
+
+# Chat history settings - These might also be application-specific,
+# but are kept here for now as they are often used by generic agent logic.
+LAST_N_CHATS = 10  # Number of previous chat pairs to include in history
+MAX_MEMORY_TOKENS = 32000  # Maximum tokens allowed in memory
+
+# Logging settings
+TEXT_PREVIEW_LENGTH = 50  # Maximum length for text previews in logs

aip_agents/constants.pyi

@@ -0,0 +1,7 @@
+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/credentials/manager.py

@@ -0,0 +1,132 @@
+"""Manages credentials for different model providers."""
+
+from __future__ import annotations
+
+import os
+
+from aip_agents.schema.model_id import ModelId, ModelProvider
+from aip_agents.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class CredentialsManager:
+    """Manages credentials for different model providers."""
+
+    _ENV_VAR_MAP: dict[ModelProvider, str] = {
+        ModelProvider.OPENAI: "OPENAI_API_KEY",
+        ModelProvider.ANTHROPIC: "ANTHROPIC_API_KEY",
+        ModelProvider.AZURE_OPENAI: "AZURE_OPENAI_API_KEY",
+        ModelProvider.OPENAI_COMPATIBLE: "OPENAI_COMPATIBLE_API_KEY",
+    }
+
+    _ENV_VAR_MAP_OPENAI_COMPATIBLE: dict[str, str] = {
+        "deepseek": "DEEPSEEK_API_KEY",
+        "groq": "GROQ_DEEPSEEK_API_KEY",
+        "deepinfra": "DEEPINFRA_API_KEY",
+        "together": "TOGETHER_API_KEY",
+    }
+
+    @classmethod
+    def get_credentials(cls, model: str | ModelId, explicit_credentials: str | None = None) -> str | None:
+        """Get credentials for a given model.
+
+        Args:
+            model: The model identifier (string or ModelId object).
+            explicit_credentials: Optional explicit credentials to use instead of environment lookup.
+
+        Returns:
+            The credentials string if found, None otherwise.
+        """
+        if explicit_credentials:
+            logger.debug("Using explicitly provided credentials.")
+            return explicit_credentials
+
+        provider, path = cls._extract_provider(model)
+        if provider is None:
+            return None
+
+        return cls._get_env_credentials(provider, path or "")
+
+    @staticmethod
+    def _extract_provider(model: str | ModelId) -> tuple[ModelProvider | None, str | None]:
+        """Parse a model string or ModelId and return the provider metadata.
+
+        Args:
+            model: Raw model identifier or parsed ModelId.
+
+        Returns:
+            Tuple of provider and remaining model path when available, otherwise (None, None).
+        """
+        try:
+            if isinstance(model, str):
+                model_id_obj = ModelId.from_string(model)
+                provider = model_id_obj.provider
+                path = model_id_obj.path
+            elif isinstance(model, ModelId):
+                provider = model.provider
+                path = model.path
+            else:
+                logger.warning("Unexpected model type: %s", type(model))
+                return None, None
+
+            return provider, path
+        except ValueError:
+            logger.warning("Could not parse provider from model string: %s", model)
+            return None, None
+
+    @classmethod
+    def _extract_env_var_name(cls, provider: ModelProvider, path: str | None) -> str | None:
+        """Resolve the environment variable name to use for the given provider.
+
+        Args:
+            provider: Provider enum extracted from the model id.
+            path: Optional model path used to disambiguate OpenAI compatible providers.
+
+        Returns:
+            The name of the environment variable to load or None when no mapping exists.
+        """
+        if provider not in cls._ENV_VAR_MAP:
+            logger.info(
+                "Provider '%s' identified, but no known environment variable mapping in CredentialsManager.",
+                getattr(provider, "value", provider),
+            )
+            return None
+
+        if provider == ModelProvider.OPENAI_COMPATIBLE and path:
+            for key, env_var in cls._ENV_VAR_MAP_OPENAI_COMPATIBLE.items():
+                if key in path:
+                    return env_var
+
+        return cls._ENV_VAR_MAP[provider]
+
+    @classmethod
+    def _get_env_credentials(cls, provider: ModelProvider, path: str | None) -> str | None:
+        """Fetch credentials for the provider from the environment.
+
+        Args:
+            provider: Provider used to determine the environment variable.
+            path: Optional additional path information for provider-specific overrides.
+
+        Returns:
+            The credential string from the environment or None if it was not set.
+        """
+        env_var_name = cls._extract_env_var_name(provider, path)
+        if not env_var_name:
+            return None
+
+        env_credentials = os.environ.get(env_var_name)
+        if env_credentials:
+            logger.info(
+                "Using credentials for %s from environment variable '%s'.",
+                getattr(provider, "value", provider),
+                env_var_name,
+            )
+            return env_credentials
+
+        logger.warning(
+            "Environment variable '%s' not found for %s.",
+            env_var_name,
+            getattr(provider, "value", provider),
+        )
+        return None

aip_agents/examples/__init__.py

@@ -0,0 +1,5 @@
+"""Examples package for aip-agents.
+
+This package contains example implementations demonstrating various use cases
+and patterns for building agents with the aip-agents framework.
+"""