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

aip_agents/ptc/prompt_builder.pyi

@@ -0,0 +1,55 @@
+from _typeshed import Incomplete
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.ptc.naming import example_value_from_schema as example_value_from_schema, sanitize_function_name as sanitize_function_name, sanitize_module_name_with_reserved as sanitize_module_name_with_reserved, sanitize_param_name as sanitize_param_name, schema_to_params as schema_to_params
+from aip_agents.utils.logger import get_logger as get_logger
+from dataclasses import dataclass
+
+logger: Incomplete
+PromptMode: Incomplete
+PYTHON_BLOCK_START: str
+
+@dataclass
+class PromptConfig:
+    """Configuration for PTC prompt generation.
+
+    Attributes:
+        mode: Prompt mode - minimal, index, full, or auto.
+        auto_threshold: Total tool count threshold for auto mode (default 10).
+        include_example: Whether to include example code in prompt.
+    """
+    mode: PromptMode = ...
+    auto_threshold: int = ...
+    include_example: bool = ...
+
+PTC_USAGE_RULES: str
+
+def build_ptc_prompt(mcp_client: BaseMCPClient | None = None, config: PromptConfig | None = None) -> str:
+    """Build PTC usage guidance prompt from MCP configuration.
+
+    Generates a short usage block that includes:
+    - The import pattern: MCP (`from tools.<server> import <tool>`)
+    - Rule: use `print()`; only printed output returns
+    - Rule: parameter names are sanitized to lowercase/underscored
+    - Prompt mode content (minimal/index/full)
+    - Examples based on the resolved prompt mode
+
+    Args:
+        mcp_client: The MCP client with configured servers.
+        config: Prompt configuration. If None, uses default PromptConfig.
+
+    Returns:
+        PTC usage guidance prompt string.
+    """
+def compute_ptc_prompt_hash(mcp_client: BaseMCPClient | None = None, config: PromptConfig | None = None) -> str:
+    """Compute a hash of the MCP configuration for change detection.
+
+    Includes PromptConfig fields and allowed_tools in hash computation
+    so prompt updates re-sync correctly when configuration changes.
+
+    Args:
+        mcp_client: MCP client instance.
+        config: Prompt configuration. If None, uses default PromptConfig.
+
+    Returns:
+        Hash string representing current configuration.
+    """

aip_agents/ptc/ptc_helper.pyi

@@ -0,0 +1 @@
+from aip_agents.ptc.template_utils import render_template as render_template

aip_agents/ptc/sandbox_bridge.pyi

@@ -0,0 +1,25 @@
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.ptc.mcp.sandbox_bridge import build_mcp_payload as build_mcp_payload
+from aip_agents.ptc.payload import SandboxPayload as SandboxPayload
+
+async def build_sandbox_payload(mcp_client: BaseMCPClient | None = None, default_tool_timeout: float = 60.0) -> SandboxPayload:
+    """Build sandbox payload from MCP client configuration (MCP-only).
+
+    Args:
+        mcp_client: The MCP client with configured servers.
+        default_tool_timeout: Default timeout for tool calls in seconds.
+
+    Returns:
+        SandboxPayload containing files and env vars for the sandbox.
+    """
+def wrap_ptc_code(code: str) -> str:
+    """Wrap user PTC code with necessary imports and setup (MCP-only).
+
+    This prepends sys.path setup to ensure the tools package is importable.
+
+    Args:
+        code: User-provided Python code.
+
+    Returns:
+        Wrapped code ready for sandbox execution.
+    """

aip_agents/ptc/template_utils.pyi

@@ -0,0 +1,13 @@
+from collections.abc import Mapping
+
+def render_template(package: str, template_name: str, values: Mapping[str, str] | None = None) -> str:
+    """Render a template from package resources with optional substitutions.
+
+    Args:
+        package: Package path containing the template.
+        template_name: Template filename.
+        values: Optional mapping of template variables.
+
+    Returns:
+        Rendered template content.
+    """

aip_agents/sandbox/__init__.pyi

@@ -0,0 +1,5 @@
+from aip_agents.sandbox.e2b_runtime import E2BSandboxRuntime as E2BSandboxRuntime
+from aip_agents.sandbox.template_builder import ensure_ptc_template as ensure_ptc_template
+from aip_agents.sandbox.types import SandboxExecutionResult as SandboxExecutionResult
+
+__all__ = ['E2BSandboxRuntime', 'ensure_ptc_template', 'SandboxExecutionResult']

aip_agents/sandbox/defaults.pyi

@@ -0,0 +1,2 @@
+DEFAULT_PTC_TEMPLATE: str
+DEFAULT_PTC_PACKAGES: tuple[str, ...]

aip_agents/sandbox/e2b_runtime.pyi

@@ -0,0 +1,51 @@
+from _typeshed import Incomplete
+from aip_agents.sandbox.defaults import DEFAULT_PTC_PACKAGES as DEFAULT_PTC_PACKAGES, DEFAULT_PTC_TEMPLATE as DEFAULT_PTC_TEMPLATE
+from aip_agents.sandbox.types import SandboxExecutionResult as SandboxExecutionResult
+from aip_agents.sandbox.validation import validate_package_names as validate_package_names
+from aip_agents.utils.logger import get_logger as get_logger
+
+logger: Incomplete
+SANDBOX_NOT_INITIALIZED_ERROR: str
+
+class E2BSandboxRuntime:
+    '''E2B Sandbox runtime for executing code in isolated environments.
+
+    This runtime manages per-run sandbox lifecycle:
+    - Create sandbox on first execute
+    - Reuse sandbox for subsequent executes
+    - Destroy sandbox on cleanup
+
+    Example:
+        runtime = E2BSandboxRuntime()
+        result = await runtime.execute(
+            code="print(\'Hello\')",
+            timeout=60.0,
+            files={"tools/mcp.py": "# MCP client code"},
+        )
+        await runtime.cleanup()
+    '''
+    def __init__(self, template: str | None = None, ptc_packages: list[str] | None = None) -> None:
+        """Initialize E2B sandbox runtime.
+
+        Args:
+            template: Optional E2B template ID for custom sandbox environments.
+            ptc_packages: Packages to install in sandbox. If None or empty, skip install.
+        """
+    async def execute(self, code: str, *, timeout: float = 300.0, files: dict[str, str] | None = None, env: dict[str, str] | None = None, template: str | None = None) -> SandboxExecutionResult:
+        """Execute code inside the sandbox.
+
+        Args:
+            code: Python code to execute.
+            timeout: Execution timeout in seconds.
+            files: Files to upload to the sandbox (path -> content).
+            env: Environment variables to set.
+            template: Optional template override for this execution.
+
+        Returns:
+            SandboxExecutionResult with stdout, stderr, and exit_code.
+        """
+    async def cleanup(self) -> None:
+        """Destroy the sandbox and release resources."""
+    @property
+    def is_active(self) -> bool:
+        """Check if a sandbox is currently active."""

aip_agents/sandbox/template_builder.pyi

@@ -0,0 +1,36 @@
+from _typeshed import Incomplete
+from aip_agents.sandbox.validation import validate_package_names as validate_package_names
+from aip_agents.utils.logger import get_logger as get_logger
+from e2b import Template
+
+logger: Incomplete
+
+def create_ptc_template(base_template: str, ptc_packages: list[str] | None) -> Template:
+    '''Create a PTC template definition based on a base template.
+
+    Args:
+        base_template: Base template alias to build from (e.g., "code-interpreter-v1").
+        ptc_packages: List of packages to install in the template.
+            If None or empty, skips pip install step.
+
+    Returns:
+        Template: A configured template ready to be built.
+    '''
+def ensure_ptc_template(template_id: str, base_template: str, ptc_packages: list[str] | None, force_rebuild: bool = False) -> str | None:
+    '''Ensure a PTC sandbox template exists, creating it if necessary.
+
+    This is an explicit helper that apps can call at startup to ensure the
+    template exists. It is never run implicitly by the SDK.
+
+    Args:
+        template_id: Unique alias for the template (e.g., "aip-agents-ptc-v1").
+        base_template: Base template alias to build from
+            (e.g., "code-interpreter-v1").
+        ptc_packages: List of packages to install in the template.
+            If None or empty, skips pip install step.
+        force_rebuild: If True, rebuild even if alias exists.
+
+    Returns:
+        The template_id on success, None if creation failed.
+        Never raises exceptions.
+    '''

aip_agents/sandbox/types.pyi

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+@dataclass
+class SandboxExecutionResult:
+    """Result of a sandbox code execution.
+
+    Attributes:
+        stdout: Standard output from the execution.
+        stderr: Standard error from the execution.
+        exit_code: Exit code (0 for success, non-zero for failure).
+    """
+    stdout: str
+    stderr: str
+    exit_code: int

aip_agents/sandbox/validation.pyi

@@ -0,0 +1,20 @@
+def validate_package_name(package: str) -> bool:
+    """Validate package name/specifier format for pip install.
+
+    Allows standard pip formats: package, package==version, package[extra].
+
+    Args:
+        package: Package name or specifier to validate.
+
+    Returns:
+        True if package name is valid, False otherwise.
+    """
+def validate_package_names(packages: list[str]) -> None:
+    """Validate all package names in a list.
+
+    Args:
+        packages: List of package names or specifiers to validate.
+
+    Raises:
+        ValueError: If any package name is invalid.
+    """

aip_agents/schema/__init__.pyi

@@ -0,0 +1,9 @@
+from aip_agents.schema.a2a import A2AEvent as A2AEvent, A2AStreamEventType as A2AStreamEventType, ToolCallInfo as ToolCallInfo, ToolResultInfo as ToolResultInfo
+from aip_agents.schema.agent import A2AClientConfig as A2AClientConfig, AgentConfig as AgentConfig, BaseAgentConfig as BaseAgentConfig, CredentialType as CredentialType, HttpxClientOptions as HttpxClientOptions, LangflowAgentConfig as LangflowAgentConfig, StreamMode as StreamMode
+from aip_agents.schema.hitl import ApprovalDecision as ApprovalDecision, ApprovalDecisionType as ApprovalDecisionType, ApprovalLogEntry as ApprovalLogEntry, ApprovalRequest as ApprovalRequest, HitlMetadata as HitlMetadata
+from aip_agents.schema.langgraph import ToolCallResult as ToolCallResult, ToolStorageParams as ToolStorageParams
+from aip_agents.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from aip_agents.schema.step_limit import MaxDelegationDepthExceededError as MaxDelegationDepthExceededError, MaxStepsExceededError as MaxStepsExceededError, StepLimitConfig as StepLimitConfig, StepLimitError as StepLimitError, StepLimitErrorResponse as StepLimitErrorResponse, StepLimitErrorType as StepLimitErrorType
+from aip_agents.schema.storage import OBJECT_STORAGE_PREFIX as OBJECT_STORAGE_PREFIX, StorageConfig as StorageConfig, StorageType as StorageType
+
+__all__ = ['A2AEvent', 'A2AStreamEventType', 'ToolCallInfo', 'ToolResultInfo', 'A2AClientConfig', 'AgentConfig', 'BaseAgentConfig', 'CredentialType', 'HttpxClientOptions', 'LangflowAgentConfig', 'StreamMode', 'ApprovalDecision', 'ApprovalDecisionType', 'ApprovalLogEntry', 'ApprovalRequest', 'HitlMetadata', 'ToolCallResult', 'ToolStorageParams', 'ModelId', 'ModelProvider', 'OBJECT_STORAGE_PREFIX', 'StorageConfig', 'StorageType', 'MaxDelegationDepthExceededError', 'MaxStepsExceededError', 'StepLimitConfig', 'StepLimitError', 'StepLimitErrorResponse', 'StepLimitErrorType']

aip_agents/schema/a2a.pyi

@@ -0,0 +1,40 @@
+from enum import Enum
+from typing import Any
+from typing_extensions import TypedDict
+
+__all__ = ['A2AStreamEventType', 'A2AEvent', 'ToolCallInfo', 'ToolResultInfo']
+
+class A2AStreamEventType(Enum):
+    """Semantic event types for A2A agent-executor communication."""
+    STATUS_UPDATE: str
+    CONTENT_CHUNK: str
+    FINAL_RESPONSE: str
+    TOOL_CALL: str
+    TOOL_RESULT: str
+    ERROR: str
+    STEP_LIMIT_EXCEEDED: str
+
+class A2AEvent(TypedDict):
+    """Structured event data used by the A2A connector."""
+    event_type: A2AStreamEventType
+    content: str
+    metadata: dict[str, Any]
+    tool_info: dict[str, Any] | None
+    is_final: bool
+    artifacts: list[dict[str, Any]] | None
+    references: list[Any] | None
+    step_usage: dict[str, Any] | None
+    total_usage: dict[str, Any] | None
+    thinking_and_activity_info: dict[str, Any] | None
+
+class ToolCallInfo(TypedDict):
+    """Structured information for tool invocation events."""
+    tool_calls: list[dict[str, Any]]
+    status: str
+
+class ToolResultInfo(TypedDict):
+    """Structured information for tool completion events."""
+    name: str
+    args: dict[str, Any]
+    output: str
+    execution_time: float | None

aip_agents/schema/agent.pyi

@@ -0,0 +1,65 @@
+from _typeshed import Incomplete
+from a2a.types import AgentCard
+from enum import StrEnum
+from gllm_core.utils.retry import RetryConfig
+from pydantic import BaseModel
+from typing import Any
+
+__all__ = ['CredentialType', 'StreamMode', 'HttpxClientOptions', 'A2AClientConfig', 'BaseAgentConfig', 'AgentConfig', 'LangflowAgentConfig']
+
+class CredentialType(StrEnum):
+    """Credential type enumeration for type safety and better developer experience."""
+    API_KEY: str
+    FILE: str
+    DICT: str
+
+class StreamMode(StrEnum):
+    """LangGraph stream modes for astream operations."""
+    VALUES: str
+    CUSTOM: str
+    MESSAGES: str
+
+class HttpxClientOptions(BaseModel):
+    """Options for the HTTP client."""
+    timeout: float
+    trust_env: bool
+    follow_redirects: bool
+    model_config: Incomplete
+    class Config:
+        """Pydantic v1 fallback config for HttpxClientOptions."""
+        extra: str
+
+class A2AClientConfig(BaseModel):
+    """Configuration for A2A client."""
+    discovery_urls: list[str] | None
+    known_agents: dict[str, AgentCard]
+    httpx_client_options: HttpxClientOptions | None
+
+class BaseAgentConfig(BaseModel):
+    """Base configuration for agent implementations."""
+    tools: list[Any] | None
+    default_hyperparameters: dict[str, Any] | None
+    model_config: Incomplete
+    class Config:
+        """Pydantic v1 fallback config for BaseAgentConfig."""
+        extra: str
+
+class AgentConfig(BaseAgentConfig):
+    """Configuration for agent implementations with language model settings."""
+    lm_name: str | None
+    lm_hyperparameters: dict[str, Any] | None
+    lm_provider: str | None
+    lm_base_url: str | None
+    lm_api_key: str | None
+    lm_credentials: str | dict[str, Any] | None
+    lm_retry_config: RetryConfig | None
+
+class LangflowAgentConfig(BaseAgentConfig):
+    """Configuration for Langflow agent implementations."""
+    flow_id: str
+    base_url: str | None
+    api_key: str | None
+    model_config: Incomplete
+    class Config:
+        """Pydantic v1 fallback config for LangflowAgentConfig."""
+        extra: str

aip_agents/schema/hitl.pyi

@@ -0,0 +1,89 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass
+from datetime import datetime
+from enum import StrEnum
+from pydantic import BaseModel
+from typing import Any
+
+__all__ = ['ApprovalDecisionType', 'ApprovalRequest', 'ApprovalDecision', 'ApprovalLogEntry', 'HitlMetadata']
+
+class ApprovalDecisionType(StrEnum):
+    """Enumeration of possible approval decision types."""
+    APPROVED: str
+    REJECTED: str
+    SKIPPED: str
+    TIMEOUT_SKIP: str
+    PENDING: str
+
+@dataclass
+class ApprovalRequest:
+    """Represents an in-flight prompt shown to the operator."""
+    request_id: str
+    tool_name: str
+    arguments_preview: str
+    context: dict[str, str] | None = ...
+    created_at: datetime | None = ...
+    timeout_at: datetime | None = ...
+    def __post_init__(self) -> None:
+        """Initialize timestamps if not provided."""
+    @classmethod
+    def create(cls, tool_name: str, arguments_preview: str, context: dict[str, str] | None = None) -> ApprovalRequest:
+        """Create a new approval request with generated request_id.
+
+        Args:
+            tool_name (str): The name of the tool requiring approval.
+            arguments_preview (str): A preview of the arguments for display.
+            context (dict[str, str] | None, optional): Additional context information.
+
+        Returns:
+            ApprovalRequest: A new approval request instance.
+        """
+
+@dataclass
+class ApprovalDecision:
+    """Captures the operator outcome."""
+    request_id: str
+    decision: ApprovalDecisionType
+    operator_input: str
+    decided_at: datetime | None = ...
+    latency_ms: int | None = ...
+    def __post_init__(self) -> None:
+        """Initialize timestamp if not provided."""
+
+@dataclass
+class ApprovalLogEntry:
+    """Structured log entry for HITL decisions."""
+    request_id: str
+    tool_name: str
+    decision: str
+    event: str = ...
+    agent_id: str | None = ...
+    thread_id: str | None = ...
+    additional_context: dict[str, Any] | None = ...
+    timestamp: datetime | None = ...
+    def __post_init__(self) -> None:
+        """Initialize timestamp if not provided."""
+
+class HitlMetadata(BaseModel):
+    """Structured metadata payload included in agent streaming events."""
+    required: bool
+    decision: ApprovalDecisionType
+    request_id: str
+    timeout_seconds: int | None
+    timeout_at: datetime | None
+    model_config: Incomplete
+    def as_payload(self) -> dict[str, Any]:
+        """Return a JSON-ready metadata payload."""
+    @classmethod
+    def from_decision(cls, decision: ApprovalDecision, *, required: bool = True, timeout_seconds: int | None = None, timeout_at: datetime | None = None) -> HitlMetadata:
+        """Build metadata from an ``ApprovalDecision``.
+
+        Args:
+            decision (ApprovalDecision): The approval decision to build metadata from.
+            required (bool, optional): Whether approval is required. Defaults to True.
+            timeout_seconds (int | None, optional): Timeout in seconds for the decision.
+            timeout_at (datetime | None, optional): Specific timeout datetime.
+
+        Returns:
+            HitlMetadata: The constructed metadata instance.
+        """

aip_agents/schema/langgraph.pyi

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from gllm_core.schema import Chunk
+from langchain_core.messages import ToolMessage
+from langchain_core.messages.ai import UsageMetadata
+from langchain_core.tools import BaseTool
+from typing import Any
+
+__all__ = ['ToolCallResult', 'ToolStorageParams']
+
+@dataclass
+class ToolCallResult:
+    """Container for the results of a single tool call execution."""
+    messages: list[ToolMessage]
+    artifacts: list[dict[str, Any]]
+    metadata_delta: dict[str, Any]
+    references: list[Chunk]
+    step_usage: UsageMetadata | None
+    pii_mapping: dict[str, str] | None = ...
+
+@dataclass
+class ToolStorageParams:
+    """Parameters required for automatically storing tool outputs."""
+    tool: BaseTool
+    tool_output: Any
+    tool_call: dict[str, Any]
+    tool_call_id: str
+    resolved_args: dict[str, Any]
+    state: dict[str, Any]

aip_agents/schema/model_id.pyi

@@ -0,0 +1,54 @@
+from _typeshed import Incomplete
+from enum import StrEnum
+
+__all__ = ['ModelId', 'ModelProvider']
+
+class ModelProvider(StrEnum):
+    """Enumeration of supported model providers for the AI agent platform."""
+    OPENAI: str
+    ANTHROPIC: str
+    AZURE_OPENAI: str
+    GOOGLE_GENAI: str
+    GROQ: str
+    TOGETHER_AI: str
+    DEEPINFRA: str
+    DEEPSEEK: str
+    OPENAI_COMPATIBLE: str
+
+class ModelId:
+    """Model identifier class for representing language models."""
+    provider: Incomplete
+    name: Incomplete
+    path: Incomplete
+    def __init__(self, provider: str, name: str, path: str | None = None) -> None:
+        """Initialize a ModelId.
+
+        Args:
+            provider: The model provider (e.g., 'openai', 'anthropic')
+            name: The specific model name
+            path: Optional path component for some providers
+        """
+    @classmethod
+    def from_string(cls, model_string: str) -> ModelId:
+        """Create a ModelId from a string representation.
+
+        Args:
+            model_string: String in format 'provider:name' or 'provider/path:name'
+
+        Returns:
+            ModelId instance
+
+        Raises:
+            ValueError: If the string format is invalid
+        """
+    def __eq__(self, other: object) -> bool:
+        """Check equality with another ModelId object.
+
+        Args:
+            other (object): The object to compare with.
+
+        Returns:
+            bool: True if the objects are equal, False otherwise.
+        """
+    def __hash__(self) -> int:
+        """Return hash of the ModelId."""

aip_agents/schema/step_limit.pyi

@@ -0,0 +1,63 @@
+from _typeshed import Incomplete
+from dataclasses import dataclass, field
+from enum import StrEnum
+
+class StepLimitErrorType(StrEnum):
+    """Types of step-related limit violations."""
+    STEP_LIMIT_EXCEEDED: str
+    DELEGATION_DEPTH_EXCEEDED: str
+
+@dataclass
+class StepLimitConfig:
+    """Configuration for agent step and delegation limits.
+
+    Attributes:
+        max_steps: Maximum number of execution steps allowed per invocation.
+                   Includes agent node (LLM call) and every tool call (parallel batches count per call).
+        max_delegation_depth: Maximum depth of delegation chain allowed.
+                              Depth 0 means no delegation allowed.
+    """
+    max_steps: int = field(default_factory=Incomplete)
+    max_delegation_depth: int = field(default_factory=Incomplete)
+    def __post_init__(self) -> None:
+        """Validate configuration values and normalize range."""
+
+@dataclass
+class StepLimitErrorResponse:
+    """Structured error response for step limit violations.
+
+    Attributes:
+        error_type: The type of limit that was exceeded.
+        agent_name: Name of the agent that hit the limit.
+        current_value: Current step count or delegation depth.
+        configured_limit: The configured limit that was exceeded.
+        message: Human-readable error message.
+        delegation_chain: Full chain for delegation errors.
+        partial_result: Any output generated before hitting the limit.
+    """
+    error_type: StepLimitErrorType
+    agent_name: str
+    current_value: int
+    configured_limit: int
+    message: str
+    delegation_chain: list[str] | None = ...
+    partial_result: str | None = ...
+
+class StepLimitError(Exception):
+    """Base exception for step and delegation limit violations.
+
+    Attributes:
+        error_response: Structured error response with details.
+    """
+    error_response: Incomplete
+    def __init__(self, error_response: StepLimitErrorResponse) -> None:
+        """Initialize with error response.
+
+        Args:
+            error_response: Structured error details.
+        """
+
+class MaxStepsExceededError(StepLimitError):
+    """Raised when agent exceeds configured max_steps limit."""
+class MaxDelegationDepthExceededError(StepLimitError):
+    """Raised when delegation would exceed max_delegation_depth limit."""

aip_agents/schema/storage.pyi

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from enum import StrEnum
+
+__all__ = ['OBJECT_STORAGE_PREFIX', 'StorageType', 'StorageConfig']
+
+OBJECT_STORAGE_PREFIX: str
+
+class StorageType(StrEnum):
+    """Supported storage types."""
+    MEMORY: str
+    OBJECT_STORAGE: str
+
+@dataclass
+class StorageConfig:
+    """Configuration for storage providers."""
+    storage_type: StorageType = ...
+    object_prefix: str = ...
+    object_use_json: bool = ...
+    @classmethod
+    def from_env(cls) -> StorageConfig:
+        """Create StorageConfig from environment variables."""

aip_agents/sentry/__init__.pyi

@@ -0,0 +1,3 @@
+from aip_agents.sentry.sentry import setup_telemetry as setup_telemetry
+
+__all__ = ['setup_telemetry']

aip_agents/sentry/sentry.pyi

@@ -0,0 +1,48 @@
+from _typeshed import Incomplete
+from aip_agents.agent import BaseAgent as BaseAgent, GoogleADKAgent as GoogleADKAgent, LangChainAgent as LangChainAgent, LangGraphAgent as LangGraphAgent
+from aip_agents.utils.logger import get_logger as get_logger
+from fastapi import FastAPI
+
+logger: Incomplete
+SENTRY_DSN: Incomplete
+SENTRY_ENVIRONMENT: Incomplete
+SENTRY_PROJECT: Incomplete
+VERSION_NUMBER: Incomplete
+BUILD_NUMBER: Incomplete
+USE_OPENTELEMETRY: Incomplete
+CLASSES_TO_INSTRUMENT: Incomplete
+
+def get_all_methods(cls) -> list:
+    """Get all methods from a class.
+
+    Args:
+        cls: The class to get methods from.
+
+    Returns:
+        list: A list of methods.
+    """
+def instrument_gl_functions() -> None:
+    """Instrument GL functions."""
+def traces_sampler(*args) -> float:
+    """Determine appropriate sampling rate for Sentry transactions.
+
+    Args:
+        *args: Additional positional arguments
+
+    Returns:
+        float: Sampling rate between 0 and 1
+    """
+def setup_sentry_with_open_telemetry(app: FastAPI) -> None:
+    """Configure telemetry with both Sentry and OpenTelemetry.
+
+    Args:
+        app: FastAPI application instance
+    """
+def setup_sentry_only() -> None:
+    """Configure telemetry with Sentry only (no OpenTelemetry)."""
+def setup_telemetry(app: FastAPI) -> None:
+    """Configure and initialize telemetry based on configuration.
+
+    Args:
+        app: FastAPI application instance
+    """