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

aip_agents/ptc/naming.pyi

@@ -1,76 +0,0 @@
-from _typeshed import Incomplete
-from typing import Any
-
-RESERVED_MODULE_NAMES: Incomplete
-DEFAULT_EXAMPLE_PLACEHOLDER: str
-
-def sanitize_module_name(name: str) -> str:
-    """Sanitize server name for use as Python module name.
-
-    Args:
-        name: Original server name.
-
-    Returns:
-        Valid Python module name (lowercase, underscored).
-    """
-def sanitize_module_name_with_reserved(name: str) -> str:
-    """Sanitize server name, avoiding reserved module names.
-
-    If the sanitized name collides with a reserved name (e.g., ptc_helper),
-    appends '_mcp' suffix to avoid collision.
-
-    Args:
-        name: Original server name.
-
-    Returns:
-        Valid Python module name that does not collide with reserved names.
-    """
-def sanitize_function_name(name: str) -> str:
-    """Sanitize tool name for use as Python function name.
-
-    Args:
-        name: Original tool name.
-
-    Returns:
-        Valid Python function name (lowercase, underscored).
-    """
-def sanitize_param_name(name: str) -> str:
-    """Sanitize parameter name for use as Python parameter.
-
-    Args:
-        name: Original parameter name (e.g., userId, user-id).
-
-    Returns:
-        Valid Python parameter name (lowercase, underscored).
-    """
-def json_type_to_python(json_type: str | list) -> str:
-    """Convert JSON schema type to Python type hint.
-
-    Args:
-        json_type: JSON schema type.
-
-    Returns:
-        Python type hint string.
-    """
-def schema_to_params(schema: dict[str, Any]) -> str:
-    """Convert JSON schema to Python function parameters.
-
-    Args:
-        schema: JSON schema for tool input.
-
-    Returns:
-        Function parameter string.
-    """
-def example_value_from_schema(prop_schema: dict[str, Any], default_placeholder: str = ...) -> str:
-    """Return an example value for a schema property.
-
-    Prefers schema-provided examples, defaults, or enums, and falls back
-    to type-based placeholders.
-
-    Args:
-        prop_schema: Property schema from JSON schema.
-        default_placeholder: Placeholder value to use for unknown types.
-
-    Returns:
-        Example value as a Python literal string.
-    """

aip_agents/ptc/payload.pyi

@@ -1,15 +0,0 @@
-from dataclasses import dataclass, field
-
-@dataclass
-class SandboxPayload:
-    """Payload to upload to the sandbox for PTC execution.
-
-    Attributes:
-        files: Mapping of file path -> content to upload (static bundle).
-        per_run_files: Mapping of file path -> content to upload on every run.
-            These files are always re-uploaded, even when the static bundle is cached.
-        env: Environment variables to set in the sandbox.
-    """
-    files: dict[str, str] = field(default_factory=dict)
-    per_run_files: dict[str, str] = field(default_factory=dict)
-    env: dict[str, str] = field(default_factory=dict)

aip_agents/ptc/prompt_builder.pyi

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

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

aip_agents/ptc/sandbox_bridge.pyi

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

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

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

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

aip_agents/sandbox/e2b_runtime.pyi

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

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

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

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

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

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

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

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

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

@@ -1,54 +0,0 @@
-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."""