aip-agents-binary 0.6.1__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/ptc/__init__.pyi

@@ -1,10 +0,0 @@
-from aip_agents.ptc.exceptions import PTCError as PTCError, PTCToolError as PTCToolError
-from aip_agents.ptc.prompt_builder import PromptConfig as PromptConfig, build_ptc_prompt as build_ptc_prompt, compute_ptc_prompt_hash as compute_ptc_prompt_hash
-
-__all__ = ['PTCError', 'PTCToolError', 'PTCSandboxConfig', 'PTCSandboxExecutor', 'PromptConfig', 'build_ptc_prompt', 'compute_ptc_prompt_hash', 'build_sandbox_payload', 'wrap_ptc_code']
-
-# Names in __all__ with no definition:
-#   PTCSandboxConfig
-#   PTCSandboxExecutor
-#   build_sandbox_payload
-#   wrap_ptc_code

aip_agents/ptc/doc_gen.pyi

@@ -1,40 +0,0 @@
-from aip_agents.ptc.naming import sanitize_function_name as sanitize_function_name
-from typing import Any
-
-DOC_DESC_LIMIT: int
-DOC_PARAM_DESC_LIMIT: int
-
-def json_type_to_display(json_type: Any) -> str:
-    """Convert JSON type to display string.
-
-    Args:
-        json_type: JSON schema type.
-
-    Returns:
-        Human-readable type string.
-    """
-def trim_text(text: str | None, limit: int) -> str:
-    """Trim text to limit with ellipsis if needed.
-
-    Args:
-        text: Text to trim.
-        limit: Maximum length before trimming.
-
-    Returns:
-        Trimmed text.
-    """
-def render_tool_doc(func_name: str, signature: str, description: str, schema: dict[str, Any], is_stub: bool = False, example_code: str | None = None, example_heading: str = '## Example') -> str:
-    """Render markdown documentation for a tool.
-
-    Args:
-        func_name: Sanitized function name.
-        signature: Full function signature.
-        description: Tool description.
-        schema: Input schema for parameters.
-        is_stub: Whether this is a stub documentation.
-        example_code: Optional example code block content (without ```python).
-        example_heading: Heading for the example section.
-
-    Returns:
-        Markdown documentation string.
-    """

aip_agents/ptc/exceptions.pyi

@@ -1,22 +0,0 @@
-from _typeshed import Incomplete
-
-class PTCError(Exception):
-    """Base exception for PTC errors."""
-
-class PTCToolError(PTCError):
-    """Error during tool execution.
-
-    Attributes:
-        server_name: The MCP server where the error occurred.
-        tool_name: The tool that failed.
-    """
-    server_name: Incomplete
-    tool_name: Incomplete
-    def __init__(self, message: str, server_name: str | None = None, tool_name: str | None = None) -> None:
-        """Initialize PTCToolError.
-
-        Args:
-            message: Error message.
-            server_name: The MCP server name (optional).
-            tool_name: The tool name (optional).
-        """

aip_agents/ptc/executor.pyi

@@ -1,73 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
-from aip_agents.ptc.exceptions import PTCToolError as PTCToolError
-from aip_agents.ptc.prompt_builder import PromptConfig as PromptConfig
-from aip_agents.ptc.sandbox_bridge import build_sandbox_payload as build_sandbox_payload, wrap_ptc_code as wrap_ptc_code
-from aip_agents.sandbox.defaults import DEFAULT_PTC_PACKAGES as DEFAULT_PTC_PACKAGES, DEFAULT_PTC_TEMPLATE as DEFAULT_PTC_TEMPLATE
-from aip_agents.sandbox.e2b_runtime import E2BSandboxRuntime as E2BSandboxRuntime
-from aip_agents.sandbox.types import SandboxExecutionResult as SandboxExecutionResult
-from aip_agents.utils.logger import get_logger as get_logger
-from dataclasses import dataclass, field
-
-logger: Incomplete
-
-@dataclass
-class PTCSandboxConfig:
-    """Configuration for PTC sandbox executor (MCP-only).
-
-    Attributes:
-        enabled: Whether PTC is enabled. When False, PTC is disabled.
-        default_tool_timeout: Default timeout per tool call in seconds.
-        sandbox_template: Optional E2B sandbox template ID.
-        sandbox_timeout: Sandbox execution timeout in seconds (hard cap/TTL).
-        ptc_packages: List of packages to install in sandbox. None or empty list skips install.
-        prompt: Prompt configuration for PTC usage guidance.
-    """
-    enabled: bool = ...
-    default_tool_timeout: float = ...
-    sandbox_template: str | None = ...
-    sandbox_timeout: float = ...
-    ptc_packages: list[str] | None = field(default_factory=Incomplete)
-    prompt: PromptConfig = field(default_factory=PromptConfig)
-
-class PTCSandboxExecutor:
-    '''Executes PTC code inside an E2B sandbox (MCP-only).
-
-    This executor is used for LLM-generated code that requires sandboxing.
-    It builds a sandbox payload (MCP server config + generated tool modules)
-    and executes the code using the E2B runtime.
-
-    Example:
-        runtime = E2BSandboxRuntime()
-        executor = PTCSandboxExecutor(mcp_client, runtime)
-        result = await executor.execute_code("from tools.yfinance import get_stock\\nprint(get_stock(\'AAPL\'))")
-    '''
-    def __init__(self, mcp_client: BaseMCPClient, runtime: E2BSandboxRuntime, config: PTCSandboxConfig | None = None) -> None:
-        """Initialize PTCSandboxExecutor.
-
-        Args:
-            mcp_client: The MCP client with configured servers.
-            runtime: The E2B sandbox runtime instance.
-            config: Optional sandbox executor configuration.
-
-        Raises:
-            ImportError: If sandbox dependencies are not available.
-        """
-    async def execute_code(self, code: str) -> SandboxExecutionResult:
-        """Execute code inside the sandbox with MCP access.
-
-        This method:
-        1. Builds the sandbox payload (MCP config + generated tool modules)
-        2. Wraps the user code with necessary imports and setup
-        3. Executes the code in the E2B sandbox
-        4. Returns the execution result (stdout/stderr/exit_code)
-
-        Args:
-            code: Python code to execute in the sandbox.
-
-        Returns:
-            SandboxExecutionResult with stdout, stderr, and exit_code.
-
-        Raises:
-            PTCToolError: If sandbox execution fails.
-        """

aip_agents/ptc/mcp/__init__.pyi

@@ -1,7 +0,0 @@
-from aip_agents.ptc.exceptions import PTCError as PTCError, PTCToolError as PTCToolError
-from aip_agents.ptc.mcp.sandbox_bridge import ServerConfig as ServerConfig, build_mcp_payload as build_mcp_payload
-from aip_agents.ptc.naming import json_type_to_python as json_type_to_python, sanitize_function_name as sanitize_function_name, sanitize_module_name as sanitize_module_name, sanitize_param_name as sanitize_param_name, schema_to_params as schema_to_params
-from aip_agents.ptc.payload import SandboxPayload as SandboxPayload
-from aip_agents.ptc.prompt_builder import build_ptc_prompt as build_ptc_prompt, compute_ptc_prompt_hash as compute_ptc_prompt_hash
-
-__all__ = ['PTCError', 'PTCToolError', 'json_type_to_python', 'sanitize_function_name', 'sanitize_module_name', 'sanitize_param_name', 'schema_to_params', 'build_ptc_prompt', 'compute_ptc_prompt_hash', 'SandboxPayload', 'ServerConfig', 'build_mcp_payload']

aip_agents/ptc/mcp/sandbox_bridge.pyi

@@ -1,47 +0,0 @@
-from _typeshed import Incomplete
-from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
-from aip_agents.ptc.doc_gen import render_tool_doc as render_tool_doc
-from aip_agents.ptc.naming import DEFAULT_EXAMPLE_PLACEHOLDER as DEFAULT_EXAMPLE_PLACEHOLDER, 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, schema_to_params as schema_to_params
-from aip_agents.ptc.payload import SandboxPayload as SandboxPayload
-from aip_agents.ptc.template_utils import render_template as render_template
-from aip_agents.utils.logger import get_logger as get_logger
-from dataclasses import dataclass, field
-from typing import Any
-
-logger: Incomplete
-SUPPORTED_TRANSPORTS: Incomplete
-
-@dataclass
-class ServerConfig:
-    """Extracted server configuration for sandbox payload.
-
-    Attributes:
-        name: Server name identifier.
-        transport: Transport type (sse or streamable_http).
-        url: Server URL.
-        headers: HTTP headers for authentication.
-        allowed_tools: List of allowed tool names, or None for all.
-        tools: List of tool definitions from the server.
-        timeout: Request timeout in seconds.
-    """
-    name: str
-    transport: str
-    url: str
-    headers: dict[str, str] = field(default_factory=dict)
-    allowed_tools: list[str] | None = ...
-    tools: list[dict[str, Any]] = field(default_factory=list)
-    timeout: float = ...
-
-async def build_mcp_payload(mcp_client: BaseMCPClient, default_tool_timeout: float = 60.0) -> SandboxPayload:
-    """Build MCP sandbox payload from MCP client configuration.
-
-    Extracts server configs, tools, and generates the necessary files
-    for the sandbox to execute PTC code.
-
-    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.
-    """