aip-agents-binary 0.5.21__py3-none-macosx_13_0_arm64.whl → 0.6.8__py3-none-macosx_13_0_arm64.whl

aip_agents/tools/execute_ptc_code.py

@@ -0,0 +1,357 @@
+"""Execute PTC Code Tool.
+
+This module provides a LangChain tool for executing Python code with MCP tool access
+inside an E2B sandbox. The tool is designed for LLM-generated code that needs to call
+multiple MCP tools programmatically.
+
+Authors:
+    Putu Ravindra Wiguna (putu.r.wiguna@gdplabs.id)
+"""
+
+import asyncio
+import concurrent.futures
+import json
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from aip_agents.ptc.naming import sanitize_function_name
+from aip_agents.tools.tool_config_injector import TOOL_CONFIGS_KEY
+from aip_agents.utils.logger import get_logger
+
+if TYPE_CHECKING:
+    from aip_agents.mcp.client.base_mcp_client import BaseMCPClient
+    from aip_agents.ptc.executor import PTCSandboxConfig, PTCSandboxExecutor
+    from aip_agents.sandbox.e2b_runtime import E2BSandboxRuntime
+
+logger = get_logger(__name__)
+
+
+class PTCCodeInput(BaseModel):
+    """Input schema for PTCCodeTool."""
+
+    code: str = Field(
+        ...,
+        description=(
+            "Python code to execute. Import MCP tools from the generated `tools` package, "
+            "for example: `from tools.yfinance import get_stock_history`, and custom tools "
+            "from `tools.custom`. The code runs in a sandboxed environment with access "
+            "to all configured MCP and custom tools. "
+            "Use print() to output results. The tool returns JSON with keys: "
+            "ok, stdout, stderr, exit_code."
+        ),
+    )
+
+
+def _merge_config_layer(
+    merged: dict[str, dict[str, Any]],
+    source: dict[str, Any],
+    skip_tool_configs_key: bool = True,
+) -> None:
+    """Merge a single layer of tool configs into the merged dict.
+
+    Args:
+        merged: Target dict to merge into (modified in place).
+        source: Source dict containing tool configs.
+        skip_tool_configs_key: Whether to skip the TOOL_CONFIGS_KEY entry.
+    """
+    for name, config in source.items():
+        if skip_tool_configs_key and name == TOOL_CONFIGS_KEY:
+            continue
+        if not isinstance(config, dict):
+            continue
+
+        sanitized = sanitize_function_name(name)
+        if sanitized in merged:
+            merged[sanitized].update(config)
+        else:
+            merged[sanitized] = dict(config)
+
+
+def merge_tool_configs(
+    agent_configs: dict[str, Any] | None,
+    runtime_configs: dict[str, Any] | None,
+) -> dict[str, dict[str, Any]]:
+    """Merge agent-level and runtime tool configs with sanitized keys.
+
+    Merges tool configurations from two sources:
+    1. Agent-level defaults (from agent.tool_configs)
+    2. Runtime overrides (from RunnableConfig.metadata["tool_configs"])
+
+    Both sources support two formats (matching LangGraphReactAgent behavior):
+    - Direct per-tool keys: {"time_tool": {"timezone": "UTC"}}
+    - Nested structure: {"tool_configs": {"time_tool": {"timezone": "UTC"}}}
+
+    The nested "tool_configs" key has higher precedence than direct keys.
+    Tool names are sanitized to match sandbox expectations (e.g., "Time Tool" -> "time_tool").
+
+    Args:
+        agent_configs: Agent-level tool configs (may be None or contain nested dicts)
+        runtime_configs: Runtime overrides from metadata (may be None)
+
+    Returns:
+        Merged dict with sanitized tool names as keys and config dicts as values.
+        Only includes entries that are dicts (non-dict values are agent-wide defaults).
+    """
+    merged: dict[str, dict[str, Any]] = {}
+
+    # Layer 1: Agent-level per-tool configs (direct keys)
+    if agent_configs:
+        _merge_config_layer(merged, agent_configs, skip_tool_configs_key=True)
+
+    # Layer 2: Agent-level per-tool configs (nested tool_configs key)
+    if agent_configs:
+        nested_agent = agent_configs.get(TOOL_CONFIGS_KEY)
+        if isinstance(nested_agent, dict):
+            _merge_config_layer(merged, nested_agent, skip_tool_configs_key=False)
+
+    # Layer 3: Runtime per-tool configs (direct keys, override agent defaults)
+    if runtime_configs:
+        _merge_config_layer(merged, runtime_configs, skip_tool_configs_key=True)
+
+    # Layer 4: Runtime per-tool configs (nested tool_configs key, highest precedence)
+    if runtime_configs:
+        nested_runtime = runtime_configs.get(TOOL_CONFIGS_KEY)
+        if isinstance(nested_runtime, dict):
+            _merge_config_layer(merged, nested_runtime, skip_tool_configs_key=False)
+
+    return merged
+
+
+class PTCCodeTool(BaseTool):
+    """Tool for executing Python code with MCP tool access in a sandbox.
+
+    This tool uses BaseTool to properly access runtime config via run_manager.metadata.
+    The config parameter is NOT exposed to the LLM schema - it's extracted from
+    the callback manager during execution.
+    """
+
+    name: str = "execute_ptc_code"
+    description: str = (
+        "Execute Python code that can call MCP tools programmatically. "
+        "Import tools from the generated `tools` package (e.g., `from tools.yfinance import get_stock`) "
+        "and custom tools from `tools.custom` when enabled. "
+        "Run normal Python code. Use print() to output results. "
+        "Returns JSON with ok, stdout, stderr, and exit_code keys. "
+        "This tool is useful for chaining multiple MCP tool calls with local data processing."
+    )
+
+    # Input schema for LangChain tool invocation
+    args_schema: type[BaseModel] = PTCCodeInput
+
+    # Internal attributes (not exposed to LLM)
+    _ptc_executor: "PTCSandboxExecutor" = None  # type: ignore[assignment]
+    _ptc_runtime: "E2BSandboxRuntime" = None  # type: ignore[assignment]
+    _agent_tool_configs: dict[str, Any] | None = None
+
+    def __init__(
+        self,
+        executor: "PTCSandboxExecutor",
+        runtime: "E2BSandboxRuntime",
+        agent_tool_configs: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the PTC code tool.
+
+        Args:
+            executor: The PTC sandbox executor.
+            runtime: The E2B sandbox runtime.
+            agent_tool_configs: Optional agent-level tool configs.
+            **kwargs: Additional keyword arguments passed to BaseTool.
+        """
+        super().__init__(**kwargs)
+        # Store as private attributes to avoid Pydantic field issues
+        object.__setattr__(self, "_ptc_executor", executor)
+        object.__setattr__(self, "_ptc_runtime", runtime)
+        object.__setattr__(self, "_agent_tool_configs", agent_tool_configs)
+
+    def _run(
+        self,
+        code: str,
+        run_manager: CallbackManagerForToolRun | None = None,
+    ) -> str:
+        """Execute code synchronously (wraps async version)."""
+        # Extract runtime metadata from run_manager
+        runtime_metadata = None
+        if run_manager and hasattr(run_manager, "metadata"):
+            runtime_metadata = run_manager.metadata
+
+        # Run async version in sync context
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(self._execute(code, runtime_metadata))
+
+        # Already in async context - run in thread
+        def run_in_new_loop() -> str:
+            new_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            try:
+                return new_loop.run_until_complete(self._execute(code, runtime_metadata))
+            finally:
+                new_loop.close()
+
+        with concurrent.futures.ThreadPoolExecutor() as executor_service:
+            future = executor_service.submit(run_in_new_loop)
+            return future.result()
+
+    async def _arun(
+        self,
+        code: str,
+        run_manager: AsyncCallbackManagerForToolRun | None = None,
+    ) -> str:
+        """Execute code asynchronously."""
+        # Extract runtime metadata from run_manager
+        runtime_metadata = None
+        if run_manager and hasattr(run_manager, "metadata"):
+            runtime_metadata = run_manager.metadata
+
+        return await self._execute(code, runtime_metadata)
+
+    async def _execute(
+        self,
+        code: str,
+        runtime_metadata: dict[str, Any] | None,
+    ) -> str:
+        """Internal execution logic."""
+        try:
+            # Merge agent defaults with runtime overrides
+            merged_configs = merge_tool_configs(
+                self._agent_tool_configs,
+                runtime_metadata,
+            )
+
+            logger.info("Executing PTC code in sandbox")
+            result = await self._ptc_executor.execute_code(
+                code,
+                tool_configs=merged_configs or None,
+            )
+
+            if result.exit_code == 0:
+                logger.info("PTC code execution completed successfully")
+                payload = {
+                    "ok": True,
+                    "stdout": result.stdout,
+                    "stderr": "",
+                    "exit_code": 0,
+                }
+                return json.dumps(payload)
+
+            logger.warning(f"PTC code execution failed with exit code {result.exit_code}")
+            payload = {
+                "ok": False,
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "exit_code": result.exit_code,
+            }
+            return json.dumps(payload)
+
+        except Exception as e:
+            logger.error(f"PTC code execution failed: {e}")
+            payload = {
+                "ok": False,
+                "stdout": "",
+                "stderr": f"Execution failed: {type(e).__name__}: {e}",
+                "exit_code": 1,
+            }
+            return json.dumps(payload)
+
+    async def cleanup(self) -> None:
+        """Clean up the sandbox runtime."""
+        await self._ptc_runtime.cleanup()
+
+
+def _get_user_provided_packages(config: "PTCSandboxConfig | None") -> list[str] | None:
+    """Determine if user explicitly provided ptc_packages.
+
+    Args:
+        config: Optional sandbox executor configuration.
+
+    Returns:
+        None if packages not explicitly set (equals DEFAULT_PTC_PACKAGES or config is None).
+        List of packages if user explicitly modified ptc_packages.
+    """
+    from aip_agents.sandbox.defaults import DEFAULT_PTC_PACKAGES
+
+    if config is None or config.ptc_packages is None:
+        return None
+
+    # Check if it's the default value (not user-modified)
+    if list(config.ptc_packages) == list(DEFAULT_PTC_PACKAGES):
+        return None
+
+    # User explicitly changed ptc_packages
+    return config.ptc_packages
+
+
+def create_execute_ptc_code_tool(
+    mcp_client: "BaseMCPClient | None",
+    config: "PTCSandboxConfig | None" = None,  # noqa: F821
+    agent_tool_configs: dict[str, Any] | None = None,
+) -> PTCCodeTool:
+    r"""Create a tool that executes Python code with MCP and/or custom tool access.
+
+    The code runs inside an E2B sandbox with access to generated MCP tool modules
+    and/or custom LangChain tools. This tool is designed for LLM-generated code
+    that needs to call multiple tools programmatically in a single execution.
+
+    Args:
+        mcp_client: The MCP client with configured servers. Can be None for custom-only configs.
+        config: Optional sandbox executor configuration.
+        agent_tool_configs: Optional agent-level tool configs (from agent.tool_configs).
+            These are merged with runtime overrides from RunnableConfig.metadata.
+
+    Returns:
+        PTCCodeTool configured for PTC code execution.
+
+    Example:
+        ```python
+        from aip_agents.mcp.client import LangchainMCPClient
+        from aip_agents.tools.execute_ptc_code import create_execute_ptc_code_tool
+
+        mcp_client = LangchainMCPClient()
+        await mcp_client.add_server("yfinance", {...})
+
+        tool = create_execute_ptc_code_tool(mcp_client)
+        result = await tool.ainvoke({"code": "from tools.yfinance import get_stock\\nprint(get_stock('AAPL'))"})
+        ```
+    """
+    # Import here to avoid circular dependencies and allow lazy loading
+    from aip_agents.ptc.executor import PTCSandboxConfig, PTCSandboxExecutor
+    from aip_agents.sandbox.defaults import select_sandbox_packages
+    from aip_agents.sandbox.e2b_runtime import E2BSandboxRuntime
+
+    # Use provided config or create default
+    sandbox_config = config or PTCSandboxConfig()
+
+    # Determine if user explicitly provided packages (None means use smart selection)
+    user_ptc_packages = _get_user_provided_packages(config)
+
+    # Create a package selector callback that defers package selection until after
+    # sandbox creation, when we know if the template actually succeeded.
+    # This ensures smart package selection works correctly even with template fallback.
+    def package_selector(actual_template: str | None) -> list[str] | None:
+        return select_sandbox_packages(
+            mcp_client=mcp_client,
+            custom_tools_config=sandbox_config.custom_tools,
+            template=actual_template,
+            user_ptc_packages=user_ptc_packages,
+        )
+
+    # Create runtime and executor
+    runtime = E2BSandboxRuntime(
+        template=sandbox_config.sandbox_template,
+        package_selector=package_selector,
+    )
+    executor = PTCSandboxExecutor(mcp_client, runtime, sandbox_config)
+
+    return PTCCodeTool(
+        executor=executor,
+        runtime=runtime,
+        agent_tool_configs=agent_tool_configs,
+    )

aip_agents/tools/execute_ptc_code.pyi

@@ -0,0 +1,90 @@
+from _typeshed import Incomplete
+from aip_agents.mcp.client.base_mcp_client import BaseMCPClient as BaseMCPClient
+from aip_agents.ptc.executor import PTCSandboxConfig as PTCSandboxConfig, PTCSandboxExecutor as PTCSandboxExecutor
+from aip_agents.ptc.naming import sanitize_function_name as sanitize_function_name
+from aip_agents.sandbox.e2b_runtime import E2BSandboxRuntime as E2BSandboxRuntime
+from aip_agents.tools.tool_config_injector import TOOL_CONFIGS_KEY as TOOL_CONFIGS_KEY
+from aip_agents.utils.logger import get_logger as get_logger
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel
+from typing import Any
+
+logger: Incomplete
+
+class PTCCodeInput(BaseModel):
+    """Input schema for PTCCodeTool."""
+    code: str
+
+def merge_tool_configs(agent_configs: dict[str, Any] | None, runtime_configs: dict[str, Any] | None) -> dict[str, dict[str, Any]]:
+    '''Merge agent-level and runtime tool configs with sanitized keys.
+
+    Merges tool configurations from two sources:
+    1. Agent-level defaults (from agent.tool_configs)
+    2. Runtime overrides (from RunnableConfig.metadata["tool_configs"])
+
+    Both sources support two formats (matching LangGraphReactAgent behavior):
+    - Direct per-tool keys: {"time_tool": {"timezone": "UTC"}}
+    - Nested structure: {"tool_configs": {"time_tool": {"timezone": "UTC"}}}
+
+    The nested "tool_configs" key has higher precedence than direct keys.
+    Tool names are sanitized to match sandbox expectations (e.g., "Time Tool" -> "time_tool").
+
+    Args:
+        agent_configs: Agent-level tool configs (may be None or contain nested dicts)
+        runtime_configs: Runtime overrides from metadata (may be None)
+
+    Returns:
+        Merged dict with sanitized tool names as keys and config dicts as values.
+        Only includes entries that are dicts (non-dict values are agent-wide defaults).
+    '''
+
+class PTCCodeTool(BaseTool):
+    """Tool for executing Python code with MCP tool access in a sandbox.
+
+    This tool uses BaseTool to properly access runtime config via run_manager.metadata.
+    The config parameter is NOT exposed to the LLM schema - it's extracted from
+    the callback manager during execution.
+    """
+    name: str
+    description: str
+    args_schema: type[BaseModel]
+    def __init__(self, executor: PTCSandboxExecutor, runtime: E2BSandboxRuntime, agent_tool_configs: dict[str, Any] | None = None, **kwargs: Any) -> None:
+        """Initialize the PTC code tool.
+
+        Args:
+            executor: The PTC sandbox executor.
+            runtime: The E2B sandbox runtime.
+            agent_tool_configs: Optional agent-level tool configs.
+            **kwargs: Additional keyword arguments passed to BaseTool.
+        """
+    async def cleanup(self) -> None:
+        """Clean up the sandbox runtime."""
+
+def create_execute_ptc_code_tool(mcp_client: BaseMCPClient | None, config: PTCSandboxConfig | None = None, agent_tool_configs: dict[str, Any] | None = None) -> PTCCodeTool:
+    '''Create a tool that executes Python code with MCP and/or custom tool access.
+
+    The code runs inside an E2B sandbox with access to generated MCP tool modules
+    and/or custom LangChain tools. This tool is designed for LLM-generated code
+    that needs to call multiple tools programmatically in a single execution.
+
+    Args:
+        mcp_client: The MCP client with configured servers. Can be None for custom-only configs.
+        config: Optional sandbox executor configuration.
+        agent_tool_configs: Optional agent-level tool configs (from agent.tool_configs).
+            These are merged with runtime overrides from RunnableConfig.metadata.
+
+    Returns:
+        PTCCodeTool configured for PTC code execution.
+
+    Example:
+        ```python
+        from aip_agents.mcp.client import LangchainMCPClient
+        from aip_agents.tools.execute_ptc_code import create_execute_ptc_code_tool
+
+        mcp_client = LangchainMCPClient()
+        await mcp_client.add_server("yfinance", {...})
+
+        tool = create_execute_ptc_code_tool(mcp_client)
+        result = await tool.ainvoke({"code": "from tools.yfinance import get_stock\\\\nprint(get_stock(\'AAPL\'))"})
+        ```
+    '''

aip_agents/tools/gl_connector/__init__.py

@@ -1,4 +1,4 @@
-"""GL Connector tool wrapper exports."""
+"""GL Connectors tool wrapper exports."""
 
 from aip_agents.tools.gl_connector.tool import GLConnectorTool
 

aip_agents/tools/gl_connector/tool.py

@@ -1,7 +1,8 @@
-"""GL Connector tool wrapper for BOSA connector tools.
+"""Wrapper for GL Connectors.
 
 Authors:
     Saul Sayers (saul.sayers@gdplabs.id)
+    Christian Trisno Sen Long Chen (christian.t.s.l.chen@gdplabs.id)
 
 Reference:
     https://gl-docs.gitbook.io/bosa/gl-connector/gl-connector
@@ -21,11 +22,23 @@ from pydantic import ConfigDict, PrivateAttr
 from aip_agents.tools.constants import ToolType
 
 _REQUIRED_ENV_VARS: tuple[str, ...] = (
-    "BOSA_BASE_URL",
-    "BOSA_API_KEY",
-    "BOSA_USERNAME",
-    "BOSA_PASSWORD",
+    "GL_CONNECTORS_BASE_URL",
+    "GL_CONNECTORS_API_KEY",
+    "GL_CONNECTORS_USERNAME",
+    "GL_CONNECTORS_PASSWORD",
 )
+
+_ENV_VAR_MAPPING: dict[str, tuple[str, ...]] = {
+    "GL_CONNECTORS_BASE_URL": (
+        "GL_CONNECTORS_BASE_URL",
+        "BOSA_BASE_URL",
+        "BOSA_API_BASE_URL",
+    ),
+    "GL_CONNECTORS_API_KEY": ("GL_CONNECTORS_API_KEY", "BOSA_API_KEY"),
+    "GL_CONNECTORS_USERNAME": ("GL_CONNECTORS_USERNAME", "BOSA_USERNAME"),
+    "GL_CONNECTORS_PASSWORD": ("GL_CONNECTORS_PASSWORD", "BOSA_PASSWORD"),
+    "GL_CONNECTORS_IDENTIFIER": ("GL_CONNECTORS_IDENTIFIER", "BOSA_IDENTIFIER"),
+}
 _TOP_LEVEL_KEYS: tuple[str, ...] = (
     "token",
     "identifier",
@@ -145,12 +158,12 @@ def GLConnectorTool(
     api_key: str | None = None,
     identifier: str | None = None,
 ) -> BaseTool:
-    """Create a single GL Connector tool by exact tool name.
+    """Create a single tool from GL Connectors by exact tool name.
 
     Args:
         tool_name: Exact tool name (not module name).
-        api_key: Optional override for BOSA API key.
-        identifier: Optional override for BOSA identifier.
+        api_key: Optional override for GL Connectors API key.
+        identifier: Optional override for GL Connectors identifier.
 
     Returns:
         A single LangChain BaseTool with token injection.
@@ -159,14 +172,17 @@ def GLConnectorTool(
         raise ValueError("tool_name must be a non-empty string")
 
     env_values = _load_env(api_key=api_key, identifier=identifier)
-    connector = BosaConnector(api_base_url=env_values["BOSA_BASE_URL"], api_key=env_values["BOSA_API_KEY"])
+    connector = BosaConnector(
+        api_base_url=env_values["GL_CONNECTORS_BASE_URL"],
+        api_key=env_values["GL_CONNECTORS_API_KEY"],
+    )
 
     modules = _get_available_modules(connector)
     module_name = _resolve_module(tool_name, modules)
 
     generator = BOSAConnectorToolGenerator(
-        api_base_url=env_values["BOSA_BASE_URL"],
-        api_key=env_values["BOSA_API_KEY"],
+        api_base_url=env_values["GL_CONNECTORS_BASE_URL"],
+        api_key=env_values["GL_CONNECTORS_API_KEY"],
         app_name=module_name,
     )
     tools = generator.generate_tools(tool_type=ToolType.LANGCHAIN)
@@ -177,16 +193,20 @@ def GLConnectorTool(
     if len(matching) > 1:
         raise ValueError(f"Multiple tools named '{tool_name}' found in module '{module_name}'")
 
-    token = _create_token(connector, env_values["BOSA_USERNAME"], env_values["BOSA_PASSWORD"])
-    return _InjectedTool(matching[0], token, env_values.get("BOSA_IDENTIFIER"))
+    token = _create_token(
+        connector,
+        env_values["GL_CONNECTORS_USERNAME"],
+        env_values["GL_CONNECTORS_PASSWORD"],
+    )
+    return _InjectedTool(matching[0], token, env_values.get("GL_CONNECTORS_IDENTIFIER"))
 
 
 def _load_env(*, api_key: str | None, identifier: str | None) -> dict[str, str]:
     """Load and validate environment configuration for connector access.
 
     Args:
-        api_key: Optional override for BOSA API key.
-        identifier: Optional override for BOSA identifier.
+        api_key: Optional override for GL Connectors API key.
+        identifier: Optional override for GL Connectors identifier.
 
     Returns:
         Dictionary containing environment configuration values.
@@ -194,28 +214,40 @@ def _load_env(*, api_key: str | None, identifier: str | None) -> dict[str, str]:
     Raises:
         ValueError: If required environment variables are missing.
     """
-    env = {key: os.getenv(key) for key in _REQUIRED_ENV_VARS}
+    env: dict[str, str | None] = {}
 
-    resolved_api_key = api_key or env["BOSA_API_KEY"]
-    env["BOSA_API_KEY"] = resolved_api_key
+    # Load from environment using mapping (prefers GL_CONNECTORS_* over BOSA_*)
+    for internal_key, env_vars in _ENV_VAR_MAPPING.items():
+        val = None
+        for var_name in env_vars:
+            val = os.getenv(var_name)
+            if val:
+                break
+        env[internal_key] = val
 
-    optional_identifier = identifier or os.getenv("BOSA_IDENTIFIER")
+    if api_key:
+        env["GL_CONNECTORS_API_KEY"] = api_key
 
-    if optional_identifier:
-        env["BOSA_IDENTIFIER"] = optional_identifier
+    if identifier:
+        env["GL_CONNECTORS_IDENTIFIER"] = identifier
 
-    missing = [key for key, value in env.items() if key in _REQUIRED_ENV_VARS and not value]
+    missing = [key for key in _REQUIRED_ENV_VARS if not env.get(key)]
     if missing:
-        raise ValueError(f"Missing required environment variables: {', '.join(missing)}")
+        # Map back to human-friendly names for the error message
+        friendly_missing = []
+        for m in missing:
+            preferred = _ENV_VAR_MAPPING[m][0]
+            friendly_missing.append(preferred)
+        raise ValueError(f"Missing required environment variables: {', '.join(friendly_missing)}")
 
-    return {key: value for key, value in env.items() if value is not None}
+    return {k: v for k, v in env.items() if v is not None}
 
 
 def _get_available_modules(connector: BosaConnector) -> list[str]:
     """Return available connector modules or raise an actionable error.
 
     Args:
-        connector: BOSA connector instance to query for modules.
+        connector: GL Connectors instance to query for modules.
 
     Returns:
         List of available module names.
@@ -260,9 +292,9 @@ def _create_token(connector: BosaConnector, username: str, password: str) -> str
     """Authenticate the connector user and return a user token.
 
     Args:
-        connector: BOSA connector instance for authentication.
-        username: BOSA username for authentication.
-        password: BOSA password for authentication.
+        connector: GL Connectors instance for authentication.
+        username: GL Connectors username for authentication.
+        password: GL Connectors password for authentication.
 
     Returns:
         Authentication token string.
@@ -273,11 +305,11 @@ def _create_token(connector: BosaConnector, username: str, password: str) -> str
     try:
         user = connector.authenticate_bosa_user(username, password)
     except Exception as exc:
-        raise ValueError("Failed to authenticate BOSA user") from exc
+        raise ValueError("Failed to authenticate GL Connectors user") from exc
 
     token = getattr(user, "token", None)
     if not token:
-        raise ValueError("BOSA user token missing after authentication")
+        raise ValueError("GL Connectors user token missing after authentication")
     return token
 
 

aip_agents/tools/gl_connector/tool.pyi

@@ -62,12 +62,12 @@ class _InjectedTool(BaseTool):
         """
 
 def GLConnectorTool(tool_name: str, *, api_key: str | None = None, identifier: str | None = None) -> BaseTool:
-    """Create a single GL Connector tool by exact tool name.
+    """Create a single tool from GL Connectors by exact tool name.
 
     Args:
         tool_name: Exact tool name (not module name).
-        api_key: Optional override for BOSA API key.
-        identifier: Optional override for BOSA identifier.
+        api_key: Optional override for GL Connectors API key.
+        identifier: Optional override for GL Connectors identifier.
 
     Returns:
         A single LangChain BaseTool with token injection.