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

aip_agents/memory/base.pyi

@@ -1,60 +0,0 @@
-from abc import ABC, abstractmethod
-from aip_agents.types import ChatMessage as ChatMessage
-from collections.abc import Sequence
-from typing import Any
-
-class BaseMemory(ABC):
-    """Base class for agent memory.
-
-    This concrete base class provides a default structure. Subclasses
-    can inherit from this class to implement specific memory management
-    behaviors.
-    """
-    @classmethod
-    def validate_env(cls) -> None:
-        """Validate environment prerequisites for a memory backend.
-
-        This hook allows memory implementations to fail fast when required
-        environment variables or credentials are missing. Default is a no-op.
-        """
-    @abstractmethod
-    def get_messages(self) -> list[ChatMessage]:
-        """Retrieve a list of messages.
-
-        Returns:
-            List[ChatMessage]: A list of messages in a generic format.
-        """
-    @abstractmethod
-    def add_message(self, message: ChatMessage) -> None:
-        """Add a message to the memory.
-
-        Adds a single ChatMessage to the memory storage. The exact implementation
-        depends on the specific memory backend.
-
-        Args:
-            message: The ChatMessage object to add to memory. The message should
-                contain role and content information.
-        """
-    def add_messages(self, messages: Sequence[ChatMessage]) -> None:
-        """Add multiple messages to the memory.
-
-        Args:
-            messages: A sequence of ChatMessage objects to add.
-        """
-    @abstractmethod
-    def clear(self) -> None:
-        """Clears the memory or resets the state of the agent.
-
-        This method must be implemented to define the specific behavior
-        for clearing or resetting the memory of the agent.
-        """
-    def get_memory_variables(self) -> dict[str, Any]:
-        """Retrieve memory variables.
-
-        This method returns a dictionary containing memory-related variables.
-        The default implementation returns a dictionary with chat_history.
-
-        Returns:
-            Dict[str, Any]: A dictionary where keys are variable names and values
-            are the corresponding memory-related data.
-        """

aip_agents/memory/constants.pyi

@@ -1,25 +0,0 @@
-from _typeshed import Incomplete
-
-class MemoryMethod:
-    """Constants for memory method names used in hasattr checks."""
-    SEARCH: str
-    SAVE_INTERACTION: str
-    FORMAT_HITS: str
-
-class MemoryDefaults:
-    """Default values for memory configuration parameters."""
-    MAX_ITEMS: int
-    RETRIEVAL_LIMIT: int
-    MAX_CHARS: int
-    LOG_PREVIEW_LENGTH: int
-    SMALL_PREVIEW_LENGTH: int
-    AGENT_ID_PREFIX: str
-    MEMORY_TAG_OPEN: str
-    MEMORY_TAG_CLOSE: str
-    DEFAULT_USER_ID: str
-    DATE_STRING_LENGTH: int
-
-class MemoryBackends:
-    """Supported memory backend identifiers."""
-    MEM0: str
-    SUPPORTED: Incomplete

aip_agents/memory/factory.pyi

@@ -1,24 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.memory.base import BaseMemory as BaseMemory
-from aip_agents.utils.logger import get_logger as get_logger
-from typing import Any
-
-logger: Incomplete
-BACKENDS: Incomplete
-
-class MemoryFactory:
-    """Factory to build concrete memory adapters by backend name."""
-    @staticmethod
-    def create(backend: str, **kwargs: Any) -> BaseMemory:
-        '''Create a memory adapter instance.
-
-        Args:
-            backend: Backend identifier (e.g., "mem0").
-            **kwargs: Keyword args passed to adapter constructor (e.g., limit, max_chars, namespace).
-
-        Returns:
-            BaseMemory: A constructed memory adapter instance.
-
-        Raises:
-            ValueError: If backend is unknown or adapter can\'t be constructed.
-        '''

aip_agents/memory/guidance.pyi

@@ -1,3 +0,0 @@
-from _typeshed import Incomplete
-
-MEM0_MEMORY_RECALL_GUIDANCE: Incomplete

aip_agents/memory/simple_memory.pyi

@@ -1,23 +0,0 @@
-from aip_agents.memory.base import BaseMemory as BaseMemory, ChatMessage as ChatMessage
-
-class SimpleMemory(BaseMemory):
-    """A simple memory implementation that stores messages in a list."""
-    messages: list[ChatMessage]
-    def __init__(self) -> None:
-        """Initialize the SimpleMemory instance with an empty message list."""
-    def add_message(self, message_or_role, content=None) -> None:
-        '''Add a message to memory.
-
-        Supports two calling patterns for backward compatibility:
-        1. add_message(ChatMessage) - Adds a ChatMessage object directly
-        2. add_message(role, content) - Creates and adds a ChatMessage with the given role and content
-
-        Args:
-            message_or_role: Either a ChatMessage object or a string role (e.g., "user", "assistant").
-            content: Optional content string when using the role+content pattern.
-                Required when message_or_role is a string role.
-        '''
-    def get_messages(self) -> list[ChatMessage]:
-        """Get all messages from memory."""
-    def clear(self) -> None:
-        """Clear all messages from memory."""

aip_agents/middleware/__init__.pyi

@@ -1,5 +0,0 @@
-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 TodoListMiddleware as TodoListMiddleware, TodoStatus as TodoStatus
-
-__all__ = ['AgentMiddleware', 'ModelRequest', 'MiddlewareManager', 'TodoListMiddleware', 'TodoStatus']

aip_agents/middleware/base.pyi

@@ -1,75 +0,0 @@
-from langchain_core.tools import BaseTool as BaseTool
-from typing import Any, Protocol, TypedDict
-
-class ModelRequest(TypedDict, total=False):
-    """Represents parameters for a model invocation that middleware can modify.
-
-    This TypedDict defines the structure of requests passed to the LLM, allowing
-    middleware to add tools or modify prompts before each invocation.
-
-    Attributes:
-        messages: List of messages in the conversation.
-        tools: List of tools available to the model.
-        system_prompt: System-level instruction for the model.
-    """
-    messages: list[Any]
-    tools: list[BaseTool]
-    system_prompt: str
-
-class AgentMiddleware(Protocol):
-    """Protocol defining the interface for composable agent middleware.
-
-    Middleware components can contribute tools, enhance system prompts, and provide
-    lifecycle hooks that execute before, during, and after model invocations.
-
-    All middleware must implement this protocol to be compatible with MiddlewareManager.
-
-    Attributes:
-        tools: List of tools contributed by this middleware.
-        system_prompt_additions: Optional text to append to the agent's system prompt.
-    """
-    tools: list[BaseTool]
-    system_prompt_additions: str | None
-    def before_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Hook executed before each model invocation.
-
-        Use this hook to prepare state, log context, or perform setup tasks
-        before the model is called.
-
-        Args:
-            state: Current agent state containing messages and other context.
-
-        Returns:
-            Dict of state updates to merge into the agent state. Return empty dict
-            if no updates are needed.
-        """
-    def modify_model_request(self, request: ModelRequest, state: dict[str, Any]) -> ModelRequest:
-        """Hook to modify the model request before invocation.
-
-        Use this hook to add tools, modify the system prompt, adjust model parameters,
-        or change tool selection strategy.
-
-        Args:
-            request: The model request that will be sent to the LLM.
-            state: Current agent state for context.
-
-        Returns:
-            Modified ModelRequest. Can return the same request if no changes needed.
-        """
-    def after_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Hook executed after each model invocation.
-
-        Use this hook for cleanup, logging, state updates, or post-processing
-        of model outputs.
-
-        Args:
-            state: Current agent state after model invocation.
-
-        Returns:
-            Dict of state updates to merge into the agent state. Return empty dict
-            if no updates are needed.
-        """
-    async def abefore_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Asynchronous version of before_model hook."""
-    async def aafter_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Asynchronous version of after_model hook."""

aip_agents/middleware/manager.pyi

@@ -1,84 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.middleware.base import AgentMiddleware as AgentMiddleware, ModelRequest as ModelRequest
-from langchain_core.tools import BaseTool as BaseTool
-from typing import Any
-
-class MiddlewareManager:
-    """Orchestrates multiple middleware components and manages hook execution.
-
-    The manager collects tools from all middleware, builds enhanced system prompts,
-    and executes lifecycle hooks in the correct order (forward for setup, reverse
-    for cleanup).
-
-    Attributes:
-        middleware: List of middleware components in registration order.
-    """
-    middleware: Incomplete
-    def __init__(self, middleware: list[AgentMiddleware]) -> None:
-        """Initialize the middleware manager.
-
-        Args:
-            middleware: List of middleware components to manage. Order matters:
-                       hooks execute forward (first to last) for before/modify,
-                       and reverse (last to first) for after.
-        """
-    def get_all_tools(self) -> list[BaseTool]:
-        """Collect tools from all registered middleware.
-
-        Returns:
-            Combined list of all tools contributed by all middleware components.
-            Empty list if no middleware or if middleware provide no tools.
-        """
-    def build_system_prompt(self, base_instruction: str) -> str:
-        """Build enhanced system prompt by concatenating base instruction with middleware additions.
-
-        Args:
-            base_instruction: The base system prompt for the agent.
-
-        Returns:
-            Enhanced system prompt with all middleware additions appended.
-            If no middleware provide additions, returns base_instruction unchanged.
-        """
-    def before_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Execute before_model hooks for all middleware in forward order.
-
-        Hooks run first to last, allowing earlier middleware to prepare state
-        for later middleware.
-
-        Args:
-            state: Current agent state.
-
-        Returns:
-            Merged dictionary of all state updates from all middleware.
-            Updates are accumulated in order of execution.
-        """
-    def modify_model_request(self, request: ModelRequest, state: dict[str, Any]) -> ModelRequest:
-        """Execute modify_model_request hooks for all middleware in forward order.
-
-        Each middleware receives the request modified by previous middleware,
-        allowing them to build on each other's changes.
-
-        Args:
-            request: The model request to be modified.
-            state: Current agent state for context.
-
-        Returns:
-            Final modified request after all middleware have processed it.
-        """
-    def after_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Execute after_model hooks for all middleware in reverse order.
-
-        Hooks run last to first (reverse of registration order), allowing
-        proper cleanup and unwinding of middleware operations.
-
-        Args:
-            state: Current agent state after model invocation.
-
-        Returns:
-            Merged dictionary of all state updates from all middleware.
-            Updates are accumulated in reverse order of execution.
-        """
-    async def abefore_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Asynchronously execute before_model hooks for all middleware."""
-    async def aafter_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Asynchronously execute after_model hooks for all middleware in reverse order."""

aip_agents/middleware/todolist.pyi

@@ -1,125 +0,0 @@
-import threading
-from _typeshed import Incomplete
-from aip_agents.middleware.base import ModelRequest as ModelRequest
-from aip_agents.utils.logger import get_logger as get_logger
-from enum import StrEnum
-from langchain_core.tools import BaseTool
-from pydantic import BaseModel, SkipValidation
-from typing import Any
-
-logger: Incomplete
-
-class TodoStatus(StrEnum):
-    """Enumeration of possible todo item statuses."""
-    PENDING: str
-    IN_PROGRESS: str
-    COMPLETED: str
-
-WRITE_TODOS_SYSTEM_PROMPT: str
-EMPTY_TODO_REMINDER: str
-
-class TodoItem(BaseModel):
-    """Represents a single todo item in the agent's plan.
-
-    Attributes:
-        content: Human-readable description of the task.
-        active_form: Short imperative phrase for UI display.
-        status: Current status of the todo item.
-    """
-    content: str
-    active_form: str
-    status: TodoStatus
-
-class TodoList(BaseModel):
-    """Represents a complete todo list for a thread.
-
-    Attributes:
-        items: List of todo items in order.
-    """
-    items: list[TodoItem]
-
-WRITE_TODOS_TOOL_DESCRIPTION: str
-
-class WriteTodosInput(BaseModel):
-    """Input schema for the write_todos tool."""
-    todos: TodoList
-
-class WriteTodosTool(BaseTool):
-    """LangChain-compatible tool for managing todo lists via TodoListMiddleware."""
-    name: str
-    description: str
-    args_schema: type[BaseModel]
-    storage: SkipValidation[dict[str, TodoList]]
-    storage_lock: SkipValidation[threading.RLock]
-
-class TodoListMiddleware:
-    """Middleware that provides planning capabilities via todo list management.
-
-    Adds the write_todos tool and enhances the system prompt with planning
-    instructions, encouraging agents to break down complex tasks.
-
-    This middleware maintains thread-isolated todo lists, ensuring that
-    different conversation threads don't interfere with each other.
-
-    Each middleware instance has its own storage, preventing race conditions
-    when multiple agent instances are used concurrently.
-    """
-    tools: Incomplete
-    system_prompt_additions: Incomplete
-    def __init__(self) -> None:
-        """Initialize the TodoList middleware with planning tools and instructions."""
-    def before_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Hook executed before model invocation.
-
-        Syncs todos FROM state TO internal storage for LangGraph agents.
-        This allows todos to be persisted via LangGraph checkpointer.
-
-        Args:
-            state: Current agent state (may contain 'todos' key).
-
-        Returns:
-            Empty dict (no state updates needed).
-        """
-    def modify_model_request(self, request: ModelRequest, state: dict[str, Any]) -> ModelRequest:
-        """Hook to modify model request before invocation.
-
-        Injects current todo list status into the system prompt, ensuring
-        the agent has visibility into its current plan on every turn.
-        This follows Claude Code's pattern of injecting system reminders.
-
-        Args:
-            request: The model request.
-            state: Current agent state.
-
-        Returns:
-            Modified request with todo status injected into system prompt.
-        """
-    def after_model(self, state: dict[str, Any]) -> dict[str, Any]:
-        """Hook executed after model invocation.
-
-        Syncs todos FROM internal storage TO state for LangGraph agents.
-        This ensures any tool updates are reflected in the checkpointed state.
-
-        Args:
-            state: Current agent state.
-
-        Returns:
-            Dict with 'todos' key containing updated TodoList, or empty dict.
-        """
-    def get_todos(self, thread_id: str = 'default') -> TodoList:
-        '''Retrieve the todo list for a specific thread.
-
-        Args:
-            thread_id: Thread identifier. Defaults to "default".
-
-        Returns:
-            TodoList for the thread, or empty list if none exists.
-        '''
-    def clear_todos(self, thread_id: str = 'default') -> None:
-        '''Clear the todo list for a specific thread.
-
-        Useful for cleanup between test runs or conversation resets.
-
-        Args:
-            thread_id: Thread identifier. Defaults to "default".
-        '''

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]