aip-agents-binary 0.6.5__py3-none-macosx_13_0_arm64.whl → 0.6.6__py3-none-macosx_13_0_arm64.whl

aip_agents/ptc/prompt_builder.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Literal
 
+from aip_agents.ptc.custom_tools import PTCCustomToolConfig
 from aip_agents.ptc.naming import (
     example_value_from_schema,
     sanitize_function_name,
@@ -53,7 +54,9 @@ PTC_USAGE_RULES = """## PTC (Programmatic Tool Calling) Usage
 
 When using `execute_ptc_code`, follow these rules:
 
-1. **Import pattern**: `from tools.<server> import <tool_name>`
+1. **Import patterns**:
+   - MCP tools: `from tools.<server> import <tool_name>`
+   - Custom tools: `from tools.custom import <tool_name>`
 2. **Output**: Only `print()` output is returned to you. Always print results.
 3. **Parameter names**: All parameters are lowercase with underscores.
    - Example: `userId` becomes `userid`, `user-id` becomes `user_id`
@@ -63,19 +66,22 @@ When using `execute_ptc_code`, follow these rules:
 def build_ptc_prompt(
     mcp_client: BaseMCPClient | None = None,
     config: PromptConfig | None = None,
+    custom_tools_config: PTCCustomToolConfig | None = None,
 ) -> str:
-    """Build PTC usage guidance prompt from MCP configuration.
+    """Build PTC usage guidance prompt from MCP and custom tool configurations.
 
     Generates a short usage block that includes:
-    - The import pattern: MCP (`from tools.<server> import <tool>`)
+    - The import patterns: MCP (`from tools.<server> import <tool>`) and
+      custom (`from tools.custom 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.
+        mcp_client: The MCP client with configured servers. Can be None if only custom tools.
         config: Prompt configuration. If None, uses default PromptConfig.
+        custom_tools_config: Optional custom LangChain tools configuration.
 
     Returns:
         PTC usage guidance prompt string.
@@ -90,19 +96,24 @@ def build_ptc_prompt(
             tools = _get_server_tools(mcp_client, server_name)
             server_infos.append({"name": server_name, "tools": tools})
 
+    # Collect custom tool info
+    custom_tool_infos: list[dict[str, Any]] = []
+    if custom_tools_config and custom_tools_config.enabled and custom_tools_config.tools:
+        custom_tool_infos = _get_custom_tool_infos(custom_tools_config)
+
     # Check if we have any tools
-    if not server_infos:
+    if not server_infos and not custom_tool_infos:
         return _build_placeholder_prompt()
 
     # Resolve mode and build appropriate prompt
-    resolved_mode = _resolve_mode(config, server_infos)
+    resolved_mode = _resolve_mode(config, server_infos, custom_tool_infos)
 
     if resolved_mode == "minimal":
-        return _build_minimal_prompt(server_infos, config.include_example)
+        return _build_minimal_prompt(server_infos, config.include_example, custom_tool_infos)
     elif resolved_mode == "index":
-        return _build_index_prompt(server_infos, config.include_example)
+        return _build_index_prompt(server_infos, config.include_example, custom_tool_infos)
     else:  # full
-        return _build_full_prompt(server_infos, config.include_example)
+        return _build_full_prompt(server_infos, config.include_example, custom_tool_infos)
 
 
 def _get_server_tools(
@@ -187,29 +198,61 @@ def _get_allowed_tools_from_config(mcp_client: BaseMCPClient, server_name: str)
     return None
 
 
+def _get_custom_tool_infos(custom_tools_config: PTCCustomToolConfig) -> list[dict[str, Any]]:
+    """Get tool info dicts from custom tools configuration.
+
+    Args:
+        custom_tools_config: Custom tools configuration.
+
+    Returns:
+        List of tool info dicts with name, description, and input_schema.
+    """
+    tools: list[dict[str, Any]] = []
+    for tool_def in custom_tools_config.tools:
+        name = tool_def.get("name", "")
+        description = tool_def.get("description", "")
+        input_schema = tool_def.get("input_schema", {"type": "object", "properties": {}})
+
+        tools.append(
+            {
+                "name": name,
+                "description": description,
+                "input_schema": input_schema,
+                "stub": not description and not input_schema.get("properties"),
+            }
+        )
+    return tools
+
+
 def _count_total_tools(
     server_infos: list[dict[str, Any]],
+    custom_tool_infos: list[dict[str, Any]] | None = None,
 ) -> int:
-    """Count total tools across all servers.
+    """Count total tools across all servers and custom tools.
 
     Args:
         server_infos: List of server info dicts with name and tools.
+        custom_tool_infos: List of custom tool info dicts.
 
     Returns:
         Total tool count.
     """
-    return sum(len(info.get("tools", [])) for info in server_infos)
+    mcp_count = sum(len(info.get("tools", [])) for info in server_infos)
+    custom_count = len(custom_tool_infos) if custom_tool_infos else 0
+    return mcp_count + custom_count
 
 
 def _resolve_mode(
     config: PromptConfig,
     server_infos: list[dict[str, Any]],
+    custom_tool_infos: list[dict[str, Any]] | None = None,
 ) -> PromptMode:
     """Resolve auto mode to concrete mode based on tool count.
 
     Args:
         config: Prompt configuration.
         server_infos: List of server info dicts.
+        custom_tool_infos: List of custom tool info dicts.
 
     Returns:
         Resolved mode (minimal, index, or full).
@@ -217,7 +260,7 @@ def _resolve_mode(
     if config.mode != "auto":
         return config.mode
 
-    total_tools = _count_total_tools(server_infos)
+    total_tools = _count_total_tools(server_infos, custom_tool_infos)
     if total_tools == 0 or total_tools > config.auto_threshold:
         return "minimal"
     return "full"
@@ -243,12 +286,14 @@ print(doc["doc"])"""
 def _build_minimal_prompt(
     server_infos: list[dict[str, Any]],
     include_example: bool,
+    custom_tool_infos: list[dict[str, Any]] | None = None,
 ) -> str:
     """Build minimal prompt with rules and package list only.
 
     Args:
         server_infos: List of server info dicts with name and tools.
         include_example: Whether to include discovery example.
+        custom_tool_infos: List of custom tool info dicts.
 
     Returns:
         Minimal PTC usage prompt.
@@ -265,6 +310,10 @@ def _build_minimal_prompt(
     for pkg in package_names:
         lines.append(f"- `tools.{pkg}`")
 
+    # Add custom tools package if present
+    if custom_tool_infos:
+        lines.append("- `tools.custom`")
+
     lines.append("")
     lines.append("Use `tools.ptc_helper` to discover available tools and their signatures.")
 
@@ -286,12 +335,14 @@ def _build_minimal_prompt(
 def _build_index_prompt(
     server_infos: list[dict[str, Any]],
     include_example: bool,
+    custom_tool_infos: list[dict[str, Any]] | None = None,
 ) -> str:
     """Build index prompt with rules, package list, and tool names.
 
     Args:
         server_infos: List of server info dicts with name and tools.
         include_example: Whether to include discovery example.
+        custom_tool_infos: List of custom tool info dicts.
 
     Returns:
         Index PTC usage prompt.
@@ -316,6 +367,14 @@ def _build_index_prompt(
         lines.append(f"  Tools: {', '.join(tool_names)}")
         lines.append("")
 
+    # Add custom tools section if present
+    if custom_tool_infos:
+        lines.append("**`tools.custom`**")
+        sorted_custom = sorted(custom_tool_infos, key=lambda t: sanitize_function_name(t["name"]))
+        tool_names = [sanitize_function_name(t["name"]) for t in sorted_custom]
+        lines.append(f"  Tools: {', '.join(tool_names)}")
+        lines.append("")
+
     lines.append("Use `tools.ptc_helper` to get tool signatures and descriptions.")
 
     if include_example:
@@ -336,12 +395,14 @@ def _build_index_prompt(
 def _build_full_prompt(
     server_infos: list[dict[str, Any]],
     include_example: bool,
+    custom_tool_infos: list[dict[str, Any]] | None = None,
 ) -> str:
     """Build full prompt with rules, signatures, and descriptions.
 
     Args:
         server_infos: List of server info dicts with name and tools.
         include_example: Whether to include real tool example.
+        custom_tool_infos: List of custom tool info dicts.
 
     Returns:
         Full PTC usage prompt.
@@ -377,8 +438,28 @@ def _build_full_prompt(
 
         lines.append("")
 
+    # Add custom tools section if present
+    if custom_tool_infos:
+        lines.append("**Custom Tools** (from `tools.custom`)")
+        lines.append("")
+
+        sorted_custom = sorted(custom_tool_infos, key=lambda t: sanitize_function_name(t["name"]))
+
+        for tool in sorted_custom:
+            func_name = sanitize_function_name(tool["name"])
+            schema = tool.get("input_schema", {})
+            params = schema_to_params(schema)
+            raw_desc = tool.get("description", "")
+            desc = raw_desc[:120]
+            if raw_desc and len(raw_desc) > 120:
+                desc += "..."
+
+            lines.append(f"- `{func_name}({params})`: {desc}")
+
+        lines.append("")
+
     if include_example:
-        example = _build_example(server_infos)
+        example = _build_example(server_infos, custom_tool_infos)
         lines.extend(
             [
                 "### Example",
@@ -406,15 +487,18 @@ def _build_prompt_from_servers(server_infos: list[dict[str, Any]]) -> str:
 
 def _build_example(
     server_infos: list[dict[str, Any]],
+    custom_tool_infos: list[dict[str, Any]] | None = None,
 ) -> str:
     """Build an example code snippet using the first available tool.
 
     Args:
         server_infos: List of server info dicts.
+        custom_tool_infos: List of custom tool info dicts.
 
     Returns:
         Example code string.
     """
+    # Try MCP tools first
     if server_infos:
         sorted_servers = sorted(server_infos, key=lambda info: sanitize_module_name_with_reserved(info["name"]))
         for server in sorted_servers:
@@ -427,6 +511,17 @@ def _build_example(
                 args_str = _build_example_args_from_schema(tool.get("input_schema", {}))
                 return f"""from tools.{safe_server} import {func_name}
 
+result = {func_name}({args_str})
+print(result)"""
+
+    # Fall back to custom tools
+    if custom_tool_infos:
+        sorted_custom = sorted(custom_tool_infos, key=lambda t: sanitize_function_name(t["name"]))
+        tool = sorted_custom[0]
+        func_name = sanitize_function_name(tool["name"])
+        args_str = _build_example_args_from_schema(tool.get("input_schema", {}))
+        return f"""from tools.custom import {func_name}
+
 result = {func_name}({args_str})
 print(result)"""
 
@@ -534,15 +629,17 @@ def _build_server_hash_part(mcp_client: BaseMCPClient, server_name: str) -> str:
 def compute_ptc_prompt_hash(
     mcp_client: BaseMCPClient | None = None,
     config: PromptConfig | None = None,
+    custom_tools_config: PTCCustomToolConfig | None = None,
 ) -> str:
-    """Compute a hash of the MCP configuration for change detection.
+    """Compute a hash of the MCP and custom tool configuration for change detection.
 
-    Includes PromptConfig fields and allowed_tools in hash computation
+    Includes PromptConfig fields, allowed_tools, and custom tools in hash computation
     so prompt updates re-sync correctly when configuration changes.
 
     Args:
-        mcp_client: MCP client instance.
+        mcp_client: MCP client instance. Can be None if only custom tools.
         config: Prompt configuration. If None, uses default PromptConfig.
+        custom_tools_config: Optional custom LangChain tools configuration.
 
     Returns:
         Hash string representing current configuration.
@@ -563,6 +660,11 @@ def compute_ptc_prompt_hash(
         for server_name in sorted(mcp_client.servers.keys()):
             parts.append(_build_server_hash_part(mcp_client, server_name))
 
+    # Add custom tools parts
+    if custom_tools_config and custom_tools_config.enabled and custom_tools_config.tools:
+        custom_tool_names = sorted(sanitize_function_name(t.get("name", "")) for t in custom_tools_config.tools)
+        parts.append(f"custom:{','.join(custom_tool_names)}")
+
     # Return empty hash if no tools configured
     if len(parts) == 1:
         return ""

aip_agents/ptc/prompt_builder.pyi

@@ -1,5 +1,6 @@
 from _typeshed import Incomplete
 from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.ptc.custom_tools import PTCCustomToolConfig as PTCCustomToolConfig
 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
@@ -23,32 +24,35 @@ class PromptConfig:
 
 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.
+def build_ptc_prompt(mcp_client: BaseMCPClient | None = None, config: PromptConfig | None = None, custom_tools_config: PTCCustomToolConfig | None = None) -> str:
+    """Build PTC usage guidance prompt from MCP and custom tool configurations.
 
     Generates a short usage block that includes:
-    - The import pattern: MCP (`from tools.<server> import <tool>`)
+    - The import patterns: MCP (`from tools.<server> import <tool>`) and
+      custom (`from tools.custom 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.
+        mcp_client: The MCP client with configured servers. Can be None if only custom tools.
         config: Prompt configuration. If None, uses default PromptConfig.
+        custom_tools_config: Optional custom LangChain tools configuration.
 
     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.
+def compute_ptc_prompt_hash(mcp_client: BaseMCPClient | None = None, config: PromptConfig | None = None, custom_tools_config: PTCCustomToolConfig | None = None) -> str:
+    """Compute a hash of the MCP and custom tool configuration for change detection.
 
-    Includes PromptConfig fields and allowed_tools in hash computation
+    Includes PromptConfig fields, allowed_tools, and custom tools in hash computation
     so prompt updates re-sync correctly when configuration changes.
 
     Args:
-        mcp_client: MCP client instance.
+        mcp_client: MCP client instance. Can be None if only custom tools.
         config: Prompt configuration. If None, uses default PromptConfig.
+        custom_tools_config: Optional custom LangChain tools configuration.
 
     Returns:
         Hash string representing current configuration.

aip_agents/ptc/sandbox_bridge.py

@@ -1,7 +1,7 @@
-"""Top-level PTC Sandbox Bridge (MCP-only).
+"""Top-level PTC Sandbox Bridge.
 
 This module provides the unified entry point for building sandbox payloads
-for MCP tools.
+across different tool sources (MCP, custom tools, etc.).
 
 Authors:
     Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
@@ -9,37 +9,225 @@ Authors:
 
 from __future__ import annotations
 
+import json
+from typing import Any
+
 from aip_agents.mcp.client.base_mcp_client import BaseMCPClient
+from aip_agents.ptc.custom_tools import (
+    PTCCustomToolConfig,
+    validate_custom_tool_config,
+)
+from aip_agents.ptc.custom_tools_payload import build_custom_tools_payload
+from aip_agents.ptc.doc_gen import (
+    render_tool_doc,
+)
+from aip_agents.ptc.exceptions import PTCPayloadConflictError
 from aip_agents.ptc.mcp.sandbox_bridge import build_mcp_payload
+from aip_agents.ptc.naming import sanitize_function_name, schema_to_params
 from aip_agents.ptc.payload import SandboxPayload
+from aip_agents.ptc.ptc_helper import _generate_ptc_helper_module
 
 
 async def build_sandbox_payload(
     mcp_client: BaseMCPClient | None = None,
     default_tool_timeout: float = 60.0,
+    custom_tools_config: PTCCustomToolConfig | None = None,
+    tool_configs: dict[str, dict] | None = None,
 ) -> SandboxPayload:
-    """Build sandbox payload from MCP client configuration (MCP-only).
+    """Build sandbox payload from all configured tool sources.
+
+    Composes MCP and custom LangChain tool payloads into a single payload.
 
     Args:
-        mcp_client: The MCP client with configured servers.
+        mcp_client: The MCP client with configured servers. Can be None if only custom tools.
         default_tool_timeout: Default timeout for tool calls in seconds.
+        custom_tools_config: Optional custom LangChain tools configuration.
+        tool_configs: Optional per-tool config values for custom tools.
 
     Returns:
         SandboxPayload containing files and env vars for the sandbox.
     """
     # Build MCP payload
+    mcp_payload = SandboxPayload()
     if mcp_client:
-        return await build_mcp_payload(mcp_client, default_tool_timeout)
-    return SandboxPayload()
+        mcp_payload = await build_mcp_payload(mcp_client, default_tool_timeout)
+
+    # Build custom tools payload if enabled
+    custom_payload = SandboxPayload()
+    if custom_tools_config and custom_tools_config.enabled:
+        # Validate config before building payload (fail fast)
+        validate_custom_tool_config(custom_tools_config)
+        result = build_custom_tools_payload(custom_tools_config, tool_configs)
+        custom_payload = result.payload
+
+    # Check for conflicts before merging payloads
+    _check_payload_conflicts(mcp_payload, custom_payload)
+
+    # Merge payloads (custom tools files should not conflict with MCP files)
+    merged = SandboxPayload()
+    merged.files.update(mcp_payload.files)
+    merged.files.update(custom_payload.files)
+    merged.per_run_files.update(mcp_payload.per_run_files)
+    merged.per_run_files.update(custom_payload.per_run_files)
+    merged.env.update(mcp_payload.env)
+    merged.env.update(custom_payload.env)
+
+    # Merge custom tools into ptc_index.json
+    if custom_tools_config and custom_tools_config.enabled and custom_tools_config.tools:
+        merged.files["tools/ptc_index.json"] = _merge_custom_tools_into_index(
+            merged.files.get("tools/ptc_index.json"),
+            custom_tools_config,
+        )
+        if "tools/ptc_helper.py" not in merged.files:
+            merged.files["tools/ptc_helper.py"] = _generate_ptc_helper_module()
+        # Generate documentation for custom tools
+        custom_docs = _generate_custom_tool_docs(custom_tools_config)
+        merged.files.update(custom_docs)
+
+    return merged
+
+
+def _check_payload_conflicts(
+    mcp_payload: SandboxPayload,
+    custom_payload: SandboxPayload,
+) -> None:
+    """Check for conflicts between MCP and custom tool payloads.
+
+    Args:
+        mcp_payload: Payload from MCP tool configuration.
+        custom_payload: Payload from custom tool configuration.
+
+    Raises:
+        PTCPayloadConflictError: If any conflicts are detected in files,
+            per-run files, or environment variables.
+    """
+    mcp_files = set(mcp_payload.files.keys())
+    custom_files = set(custom_payload.files.keys())
+    file_conflicts = mcp_files & custom_files
+
+    mcp_per_run = set(mcp_payload.per_run_files.keys())
+    custom_per_run = set(custom_payload.per_run_files.keys())
+    per_run_conflicts = mcp_per_run & custom_per_run
+
+    mcp_env_keys = set(mcp_payload.env.keys())
+    custom_env_keys = set(custom_payload.env.keys())
+    env_conflicts = mcp_env_keys & custom_env_keys
+
+    all_conflicts = file_conflicts | per_run_conflicts | env_conflicts
+    if all_conflicts:
+        raise PTCPayloadConflictError(
+            f"Conflicts detected when merging MCP and custom tool payloads. "
+            f"Files: {sorted(file_conflicts)}, "
+            f"Per-run files: {sorted(per_run_conflicts)}, "
+            f"Environment variables: {sorted(env_conflicts)}",
+            conflicts=all_conflicts,
+        )
+
+
+def _merge_custom_tools_into_index(
+    existing_index_json: str | None,
+    custom_tools_config: PTCCustomToolConfig,
+) -> str:
+    """Merge custom tools into the ptc_index.json.
+
+    Args:
+        existing_index_json: Existing ptc_index.json content (may be None).
+        custom_tools_config: Custom tools configuration.
+
+    Returns:
+        Updated JSON string with custom tools included.
+    """
+    # Parse existing index or create new one
+    if existing_index_json:
+        index = json.loads(existing_index_json)
+    else:
+        index = {"packages": {}}
+
+    # Add custom tools package
+    tool_entries = []
+    for tool_def in sorted(custom_tools_config.tools, key=lambda t: sanitize_function_name(t.get("name", ""))):
+        name = tool_def.get("name", "")
+        func_name = sanitize_function_name(name)
+        schema = tool_def.get("input_schema", {"type": "object", "properties": {}})
+        signature = f"{func_name}({schema_to_params(schema)})"
+
+        tool_entries.append(
+            {
+                "name": func_name,
+                "signature": signature,
+                "doc_path": f"tools/docs/custom/{func_name}.md",
+            }
+        )
 
+    index["packages"]["custom"] = {"tools": tool_entries}
 
-def wrap_ptc_code(code: str) -> str:
-    """Wrap user PTC code with necessary imports and setup (MCP-only).
+    return json.dumps(index, indent=2, sort_keys=True)
+
+
+def _generate_custom_tool_docs(custom_tools_config: PTCCustomToolConfig) -> dict[str, str]:
+    """Generate documentation files for custom tools.
+
+    Args:
+        custom_tools_config: Custom tools configuration.
+
+    Returns:
+        Dict mapping file path to content.
+    """
+    docs: dict[str, str] = {}
+
+    for tool_def in sorted(custom_tools_config.tools, key=lambda t: sanitize_function_name(t.get("name", ""))):
+        name = tool_def.get("name", "")
+        func_name = sanitize_function_name(name)
+        description = tool_def.get("description", "")
+        schema = tool_def.get("input_schema", {"type": "object", "properties": {}})
+
+        doc_content = _generate_tool_doc_content(func_name, description, schema)
+        docs[f"tools/docs/custom/{func_name}.md"] = doc_content
+
+    return docs
+
+
+def _generate_tool_doc_content(
+    func_name: str,
+    description: str,
+    schema: dict[str, Any],
+) -> str:
+    """Generate markdown documentation for a single tool.
+
+    Args:
+        func_name: Sanitized function name.
+        description: Tool description.
+        schema: JSON schema for tool input.
+
+    Returns:
+        Markdown documentation string.
+    """
+    # Use schema_to_params for consistent signatures
+    params = schema_to_params(schema)
+    signature = f"{func_name}({params})"
+
+    example_code = f"from tools.custom import {func_name}\nresult = {func_name}(...)\nprint(result)"
+
+    return render_tool_doc(
+        func_name=func_name,
+        signature=signature,
+        description=description,
+        schema=schema,
+        example_code=example_code,
+    )
+
+
+def wrap_ptc_code(code: str, include_packages_path: bool = False) -> str:
+    """Wrap user PTC code with necessary imports and setup.
 
     This prepends sys.path setup to ensure the tools package is importable.
+    When custom tools with bundled package sources are enabled, also adds
+    the packages/ directory to sys.path.
 
     Args:
         code: User-provided Python code.
+        include_packages_path: If True, also add packages/ dir to sys.path
+            for bundled package sources from custom LangChain tools.
 
     Returns:
         Wrapped code ready for sandbox execution.
@@ -52,7 +240,17 @@ import os
 _tools_dir = os.path.dirname(os.path.abspath(__file__)) if "__file__" in dir() else os.getcwd()
 if _tools_dir not in sys.path:
     sys.path.insert(0, _tools_dir)
+"""
+
+    if include_packages_path:
+        preamble += """
+# Add packages directory to path for bundled custom tool sources
+_packages_dir = os.path.join(_tools_dir, "packages")
+if os.path.isdir(_packages_dir) and _packages_dir not in sys.path:
+    sys.path.insert(0, _packages_dir)
+"""
 
+    preamble += """
 # User code below
 """
     return preamble + code

aip_agents/ptc/sandbox_bridge.pyi

@@ -1,24 +1,37 @@
 from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.ptc.custom_tools import PTCCustomToolConfig as PTCCustomToolConfig, validate_custom_tool_config as validate_custom_tool_config
+from aip_agents.ptc.custom_tools_payload import build_custom_tools_payload as build_custom_tools_payload
+from aip_agents.ptc.doc_gen import render_tool_doc as render_tool_doc
+from aip_agents.ptc.exceptions import PTCPayloadConflictError as PTCPayloadConflictError
 from aip_agents.ptc.mcp.sandbox_bridge import build_mcp_payload as build_mcp_payload
+from aip_agents.ptc.naming import sanitize_function_name as sanitize_function_name, schema_to_params as schema_to_params
 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).
+async def build_sandbox_payload(mcp_client: BaseMCPClient | None = None, default_tool_timeout: float = 60.0, custom_tools_config: PTCCustomToolConfig | None = None, tool_configs: dict[str, dict] | None = None) -> SandboxPayload:
+    """Build sandbox payload from all configured tool sources.
+
+    Composes MCP and custom LangChain tool payloads into a single payload.
 
     Args:
-        mcp_client: The MCP client with configured servers.
+        mcp_client: The MCP client with configured servers. Can be None if only custom tools.
         default_tool_timeout: Default timeout for tool calls in seconds.
+        custom_tools_config: Optional custom LangChain tools configuration.
+        tool_configs: Optional per-tool config values for custom tools.
 
     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).
+def wrap_ptc_code(code: str, include_packages_path: bool = False) -> str:
+    """Wrap user PTC code with necessary imports and setup.
 
     This prepends sys.path setup to ensure the tools package is importable.
+    When custom tools with bundled package sources are enabled, also adds
+    the packages/ directory to sys.path.
 
     Args:
         code: User-provided Python code.
+        include_packages_path: If True, also add packages/ dir to sys.path
+            for bundled package sources from custom LangChain tools.
 
     Returns:
         Wrapped code ready for sandbox execution.