agentkernel 0.2.12__tar.gz → 0.2.14__tar.gz

{agentkernel-0.2.12 → agentkernel-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentkernel
-Version: 0.2.12
+Version: 0.2.14
 Summary: Agent Kernel - Unified AI Agents Runtime
 Author: Yaala Labs
 Author-email: Yaala Labs <agentkernel@yaalalabs.com>
@@ -56,6 +56,7 @@ Requires-Dist: ragas>=0.4.1 ; extra == 'test'
 Requires-Dist: datasets>=2.14.0 ; extra == 'test'
 Requires-Dist: pandas>=2.0.0 ; extra == 'test'
 Requires-Dist: litellm>=1.74.9 ; extra == 'test'
+Requires-Dist: walledai>=4.9.3 ; extra == 'walledai'
 Requires-Dist: httpx>=0.27.0 ; extra == 'whatsapp'
 Requires-Python: >=3.12, <3.14
 Provides-Extra: a2a
@@ -78,6 +79,7 @@ Provides-Extra: redis
 Provides-Extra: slack
 Provides-Extra: telegram
 Provides-Extra: test
+Provides-Extra: walledai
 Provides-Extra: whatsapp
 Description-Content-Type: text/markdown
 
@@ -561,7 +563,7 @@ Configure input and output guardrails to validate agent requests and responses f
   - **Type**
     - **Field**: `guardrail.input.type`
     - **Default**: `openai`
-    - **Options**: `openai`, `bedrock`
+    - **Options**: `openai`, `bedrock`, `walledai`
     - **Description**: Guardrail provider type
     - **Environment Variable**: `AK_GUARDRAIL__INPUT__TYPE`
 
@@ -599,7 +601,7 @@ Configure input and output guardrails to validate agent requests and responses f
   - **Type**
     - **Field**: `guardrail.output.type`
     - **Default**: `openai`
-    - **Options**: `openai`, `bedrock`
+    - **Options**: `openai`, `bedrock`, `walledai`
     - **Description**: Guardrail provider type
     - **Environment Variable**: `AK_GUARDRAIL__OUTPUT__TYPE`
 
@@ -641,12 +643,20 @@ To use AWS Bedrock guardrails, install the AWS package:
 pip install agentkernel[aws]
 ```
 
+To use Walled AI guardrails, install the Walled AI package:
+
+```bash
+pip install agentkernel[walledai]
+```
+
 Create guardrail configuration:
 
 **For OpenAI:** Create configuration files following the [OpenAI Guardrails format](https://guardrails.openai.com/).
 
 **For Bedrock:** Create a guardrail in AWS Bedrock and note the guardrail ID and version.
 
+**For Walled AI:** Set `WALLED_API_KEY`, use guardrail type `walledai`, and control PII masking with `pii`.
+
 Configure guardrails in your configuration:
 
 **OpenAI Example:**
@@ -679,6 +689,19 @@ guardrail:
     version: "1"
 ```
 
+**Walled AI Example:**
+```yaml
+guardrail:
+  input:
+    enabled: true
+    type: walledai
+    pii: true
+  output:
+    enabled: true
+    type: walledai
+    pii: true
+```
+
 #### Messaging Platform Integrations
 
 Configure integrations with messaging platforms.
@@ -789,6 +812,11 @@ export AK_GUARDRAIL__OUTPUT__ENABLED=false
 export AK_GUARDRAIL__OUTPUT__TYPE=openai
 export AK_GUARDRAIL__OUTPUT__MODEL=gpt-4o-mini
 export AK_GUARDRAIL__OUTPUT__CONFIG_PATH=/path/to/guardrails_output.json
+# Walled AI guardrails
+export WALLED_API_KEY=your-walledai-api-key
+export AK_GUARDRAIL__INPUT__PII=true
+export AK_GUARDRAIL__OUTPUT__PII=true
+export AK_DEBUG=true
 # Messaging platforms (optional)
 export AK_SLACK__AGENT=my-agent
 export AK_WHATSAPP__AGENT=my-agent
@@ -862,13 +890,17 @@ guardrail:
   input:
     enabled: false
     type: openai
+    pii: true
     model: gpt-4o-mini
     config_path: /path/to/guardrails_input.json
   output:
     enabled: false
     type: openai
+    pii: true
     model: gpt-4o-mini
     config_path: /path/to/guardrails_output.json
+  # For Walled AI, set type: walledai, WALLED_API_KEY,
+  # and optionally use input/output pii (default: true) to enable/disable PII masking.
 slack:
   agent: my-agent
   agent_acknowledgement: "Processing your request..."

{agentkernel-0.2.12 → agentkernel-0.2.14}/README.md

@@ -478,7 +478,7 @@ Configure input and output guardrails to validate agent requests and responses f
   - **Type**
     - **Field**: `guardrail.input.type`
     - **Default**: `openai`
-    - **Options**: `openai`, `bedrock`
+    - **Options**: `openai`, `bedrock`, `walledai`
     - **Description**: Guardrail provider type
     - **Environment Variable**: `AK_GUARDRAIL__INPUT__TYPE`
 
@@ -516,7 +516,7 @@ Configure input and output guardrails to validate agent requests and responses f
   - **Type**
     - **Field**: `guardrail.output.type`
     - **Default**: `openai`
-    - **Options**: `openai`, `bedrock`
+    - **Options**: `openai`, `bedrock`, `walledai`
     - **Description**: Guardrail provider type
     - **Environment Variable**: `AK_GUARDRAIL__OUTPUT__TYPE`
 
@@ -558,12 +558,20 @@ To use AWS Bedrock guardrails, install the AWS package:
 pip install agentkernel[aws]
 ```
 
+To use Walled AI guardrails, install the Walled AI package:
+
+```bash
+pip install agentkernel[walledai]
+```
+
 Create guardrail configuration:
 
 **For OpenAI:** Create configuration files following the [OpenAI Guardrails format](https://guardrails.openai.com/).
 
 **For Bedrock:** Create a guardrail in AWS Bedrock and note the guardrail ID and version.
 
+**For Walled AI:** Set `WALLED_API_KEY`, use guardrail type `walledai`, and control PII masking with `pii`.
+
 Configure guardrails in your configuration:
 
 **OpenAI Example:**
@@ -596,6 +604,19 @@ guardrail:
     version: "1"
 ```
 
+**Walled AI Example:**
+```yaml
+guardrail:
+  input:
+    enabled: true
+    type: walledai
+    pii: true
+  output:
+    enabled: true
+    type: walledai
+    pii: true
+```
+
 #### Messaging Platform Integrations
 
 Configure integrations with messaging platforms.
@@ -706,6 +727,11 @@ export AK_GUARDRAIL__OUTPUT__ENABLED=false
 export AK_GUARDRAIL__OUTPUT__TYPE=openai
 export AK_GUARDRAIL__OUTPUT__MODEL=gpt-4o-mini
 export AK_GUARDRAIL__OUTPUT__CONFIG_PATH=/path/to/guardrails_output.json
+# Walled AI guardrails
+export WALLED_API_KEY=your-walledai-api-key
+export AK_GUARDRAIL__INPUT__PII=true
+export AK_GUARDRAIL__OUTPUT__PII=true
+export AK_DEBUG=true
 # Messaging platforms (optional)
 export AK_SLACK__AGENT=my-agent
 export AK_WHATSAPP__AGENT=my-agent
@@ -779,13 +805,17 @@ guardrail:
   input:
     enabled: false
     type: openai
+    pii: true
     model: gpt-4o-mini
     config_path: /path/to/guardrails_input.json
   output:
     enabled: false
     type: openai
+    pii: true
     model: gpt-4o-mini
     config_path: /path/to/guardrails_output.json
+  # For Walled AI, set type: walledai, WALLED_API_KEY,
+  # and optionally use input/output pii (default: true) to enable/disable PII masking.
 slack:
   agent: my-agent
   agent_acknowledgement: "Processing your request..."

{agentkernel-0.2.12 → agentkernel-0.2.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "agentkernel"
-version = "0.2.12"
+version = "0.2.14"
 description = "Agent Kernel - Unified AI Agents Runtime"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"
@@ -67,6 +67,9 @@ adk = [
     "litellm~=1.74.3",
     "openinference-instrumentation-google-adk>=0.1.6",
 ]
+walledai = [
+    "walledai>=4.9.3"
+]
 api = [
     "fastapi>=0.118.0",
     "uvicorn>=0.37.0",
@@ -113,6 +116,9 @@ mcp = [
     "fastmcp>=2.12.4",
 ]
 
+[project.scripts]
+ak = "agentkernel.cli.ak:main"
+
 [dependency-groups]
 dev = [
     "black>=23.0.0",

{agentkernel-0.2.12 → agentkernel-0.2.14}/src/agentkernel/auth/handler.py

@@ -1,10 +1,6 @@
-import base64
-import hashlib
-import hmac
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional
 
-import jwt
 from pydantic import BaseModel
 
 
@@ -43,6 +39,10 @@ class AuthValidator(ABC):
         :param algorithm: Hash algorithm to use (default: sha256)
         :return: True if signature is valid, False otherwise
         """
+        import base64
+        import hashlib
+        import hmac
+
         mac = hmac.new(key=secret.encode(), msg=message, digestmod=getattr(hashlib, algorithm))
         expected = base64.b64encode(mac.digest()).decode()
         return hmac.compare_digest(expected, signature)
@@ -59,6 +59,8 @@ class AuthValidator(ABC):
         :return: Decoded JWT claims dictionary
         :raises: jwt exceptions if token is invalid
         """
+        import jwt
+
         return jwt.decode(
             token,
             public_key,

agentkernel-0.2.14/src/agentkernel/cli/ak.py

@@ -0,0 +1,258 @@
+"""
+Agent Kernel CLI — `ak` command.
+
+Provides the `ak` top-level CLI entry point with subcommands.
+Currently supports `ak skill` for managing agent skills.
+
+Usage:
+    ak skill list                      List all available skills
+    ak skill info <name>               Show full details for a skill
+    ak skill assistants                List supported coding assistants
+    ak skill install                   Install all skills (default: copilot)
+    ak skill install <name>            Install a specific skill
+    ak skill install --assistant <a>   Install to a specific assistant's directory
+    ak skill install --target <path>   Install to a custom directory
+    ak skill update                    Re-install skills (overwrite existing)
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from agentkernel.skills import ASSISTANTS, DEFAULT_ASSISTANT, Skill
+
+
+class AK:
+    """Agent Kernel CLI."""
+
+    def __init__(self) -> None:
+        self._parser = self._build_parser()
+
+    # ── Subcommand handlers ───────────────────────────────────────────
+
+    @staticmethod
+    def _resolve_target(args: argparse.Namespace) -> Path:
+        """Resolve the target directory from --assistant or --target."""
+        if hasattr(args, "target") and args.target:
+            return Path(args.target)
+        assistant_name = getattr(args, "assistant", DEFAULT_ASSISTANT)
+        assistant = ASSISTANTS.get(assistant_name)
+        if not assistant:
+            print(f"Error: unknown assistant '{assistant_name}'.", file=sys.stderr)
+            print(f"Supported: {', '.join(ASSISTANTS.keys())}", file=sys.stderr)
+            sys.exit(1)
+        return Path(assistant.skills_dir)
+
+    def cmd_skill_list(self, args: argparse.Namespace) -> int:
+        """Handle `ak skill list`."""
+        skills = Skill.list_all()
+
+        if not skills:
+            print("No skills available.")
+            return 1
+
+        print(f"\nAgent Kernel Skills ({len(skills)} available):\n")
+
+        max_name_len = max(len(s.name) for s in skills)
+
+        for skill in skills:
+            name = skill.name.ljust(max_name_len)
+            desc = skill.description
+            if len(desc) > 80:
+                desc = desc[:77] + "..."
+            print(f"  {name}  {desc}")
+
+        print(f"\nInstall with: ak skill install [<name>] [--assistant <name>]")
+        print(f"Details:      ak skill info <name>")
+        return 0
+
+    def cmd_skill_info(self, args: argparse.Namespace) -> int:
+        """Handle `ak skill info <name>`."""
+        skill = Skill.find(args.name)
+        if skill is None:
+            print(f"Error: skill '{args.name}' not found.", file=sys.stderr)
+            print("Run 'ak skill list' to see available skills.", file=sys.stderr)
+            return 1
+
+        print(f"\n  {skill.name}")
+        print(f"  {'─' * len(skill.name)}")
+        print(f"  {skill.description}\n")
+        return 0
+
+    def cmd_skill_assistants(self, args: argparse.Namespace) -> int:
+        """Handle `ak skill assistants`."""
+        print("\nSupported coding assistants:\n")
+
+        max_name = max(len(a.name) for a in ASSISTANTS.values())
+        max_dir = max(len(a.skills_dir) for a in ASSISTANTS.values())
+
+        for assistant in ASSISTANTS.values():
+            name = assistant.name.ljust(max_name)
+            sdir = assistant.skills_dir.ljust(max_dir)
+            default = " (default)" if assistant.name == DEFAULT_ASSISTANT else ""
+            print(f"  {name}  {sdir}  {assistant.description}{default}")
+
+        print(f"\nUsage: ak skill install --assistant <name>")
+        return 0
+
+    def cmd_skill_install(self, args: argparse.Namespace) -> int:
+        """Handle `ak skill install [<name>] [--assistant <name>] [--target <path>]`."""
+        target = self._resolve_target(args)
+        skill_name: str | None = args.name
+
+        if skill_name:
+            skill = Skill.find(skill_name)
+            if skill is None:
+                print(f"Error: skill '{skill_name}' not found.", file=sys.stderr)
+                print(f"Run 'ak skill list' to see available skills.", file=sys.stderr)
+                return 1
+
+            target.mkdir(parents=True, exist_ok=True)
+            print(f"Installing skill '{skill_name}' to {target}/")
+            success = skill.install(target, force=False)
+            return 0 if success else 1
+        else:
+            skills = Skill.list_all()
+            if not skills:
+                print("No skills available to install.")
+                return 1
+
+            target.mkdir(parents=True, exist_ok=True)
+            print(f"Installing {len(skills)} skills to {target}/\n")
+
+            success_count = 0
+            for skill in skills:
+                if skill.install(target, force=False):
+                    success_count += 1
+
+            print(f"\n{success_count}/{len(skills)} skills installed.")
+            return 0
+
+    def cmd_skill_update(self, args: argparse.Namespace) -> int:
+        """Handle `ak skill update [--assistant <name>] [--target <path>]`."""
+        target = self._resolve_target(args)
+        skills = Skill.list_all()
+
+        if not skills:
+            print("No skills available to update.")
+            return 1
+
+        target.mkdir(parents=True, exist_ok=True)
+        print(f"Updating {len(skills)} skills in {target}/\n")
+
+        success_count = 0
+        for skill in skills:
+            if skill.install(target, force=True):
+                success_count += 1
+
+        print(f"\n{success_count}/{len(skills)} skills updated.")
+        return 0 if success_count == len(skills) else 1
+
+    # ── Parser ────────────────────────────────────────────────────────
+
+    @staticmethod
+    def _build_parser() -> argparse.ArgumentParser:
+        """Build the argument parser for the `ak` CLI."""
+        parser = argparse.ArgumentParser(
+            prog="ak",
+            description="Agent Kernel CLI",
+        )
+        subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+        # `ak skill` subcommand
+        skill_parser = subparsers.add_parser("skill", help="Manage agent skills")
+        skill_subparsers = skill_parser.add_subparsers(dest="skill_command", help="Skill commands")
+
+        # `ak skill list`
+        skill_subparsers.add_parser("list", help="List all available skills")
+
+        # `ak skill info <name>`
+        info_parser = skill_subparsers.add_parser("info", help="Show full details for a skill")
+        info_parser.add_argument(
+            "name",
+            help="Skill name to show details for",
+        )
+
+        # `ak skill assistants`
+        skill_subparsers.add_parser("assistants", help="List supported coding assistants")
+
+        # shared --assistant choices
+        assistant_names = list(ASSISTANTS.keys())
+
+        # `ak skill install`
+        install_parser = skill_subparsers.add_parser("install", help="Install skills to your project")
+        install_parser.add_argument(
+            "name",
+            nargs="?",
+            default=None,
+            help="Specific skill name to install (optional)",
+        )
+        install_group = install_parser.add_mutually_exclusive_group()
+        install_group.add_argument(
+            "--assistant",
+            choices=assistant_names,
+            default=DEFAULT_ASSISTANT,
+            help=f"Coding assistant to install for (default: {DEFAULT_ASSISTANT})",
+        )
+        install_group.add_argument(
+            "--target",
+            default=None,
+            help="Custom target directory (overrides --assistant)",
+        )
+
+        # `ak skill update`
+        update_parser = skill_subparsers.add_parser("update", help="Update (overwrite) installed skills")
+        update_group = update_parser.add_mutually_exclusive_group()
+        update_group.add_argument(
+            "--assistant",
+            choices=assistant_names,
+            default=DEFAULT_ASSISTANT,
+            help=f"Coding assistant to update for (default: {DEFAULT_ASSISTANT})",
+        )
+        update_group.add_argument(
+            "--target",
+            default=None,
+            help="Custom target directory (overrides --assistant)",
+        )
+
+        return parser
+
+    # ── Entry point ───────────────────────────────────────────────────
+
+    def run(self, argv: list[str] | None = None) -> None:
+        """Parse arguments and dispatch to the appropriate subcommand."""
+        args = self._parser.parse_args(argv)
+
+        if args.command is None:
+            self._parser.print_help()
+            sys.exit(0)
+
+        if args.command == "skill":
+            if args.skill_command is None:
+                self._parser.parse_args(["skill", "--help"])
+                sys.exit(0)
+
+            handlers = {
+                "list": self.cmd_skill_list,
+                "info": self.cmd_skill_info,
+                "assistants": self.cmd_skill_assistants,
+                "install": self.cmd_skill_install,
+                "update": self.cmd_skill_update,
+            }
+            handler = handlers.get(args.skill_command)
+            if handler:
+                sys.exit(handler(args))
+        else:
+            self._parser.print_help()
+            sys.exit(0)
+
+
+def main() -> None:
+    """Entry point for the `ak` CLI."""
+    AK().run()
+
+
+if __name__ == "__main__":
+    main()

{agentkernel-0.2.12 → agentkernel-0.2.14}/src/agentkernel/core/__init__.py

@@ -27,4 +27,5 @@ from .module import Module
 from .runtime import Runtime, AuxiliaryCache
 from .service import AgentService
 from .hooks import PreHook, PostHook
+from .tool import ToolContext, ToolBuilder
 from .util.key_value_cache import KeyValueCache

{agentkernel-0.2.12 → agentkernel-0.2.14}/src/agentkernel/core/config.py

@@ -149,7 +149,8 @@ class _TestConfig(BaseModel):
 
 class _GuardrailParamConfig(BaseModel):
     enabled: bool = Field(default=False, description="Enable Guardrail")
-    type: str = Field(default="openai", pattern="^(openai|bedrock)$")
+    type: str = Field(default="openai", pattern="^(openai|bedrock|walledai)$")
+    pii: bool = Field(default=True, description="Enable PII redaction/unmasking (WalledAI only)")
     config_path: Optional[str] = Field(default=None, description="Path to guardrail configuration file (OpenAI only)")
     model: Optional[str] = Field(default="gpt-4o-mini", description="LLM model name to use for guardrail (OpenAI only)")
     id: Optional[str] = Field(default=None, description="AWS Bedrock guardrail ID (Bedrock only)")

agentkernel-0.2.14/src/agentkernel/core/tool.py

@@ -0,0 +1,156 @@
+"""
+Generic tool binding support for Agent Kernel.
+
+This module provides the ToolBuilder classes that enable framework-agnostic
+tool function definitions.
+"""
+
+import contextvars
+import uuid
+from typing import Any, Callable, ClassVar, Self
+
+from .base import Agent, AgentRequest, Session
+from .runtime import Runtime
+
+
+class ToolContext:
+    """
+    Execution context for tool functions.
+
+    Provides access to the execution context of the tool, including the runtime, session, agent,
+    and the request being processed. This allows tool functions to interact with the broader
+    agent execution environment in a consistent way across different frameworks.
+    """
+
+    _context: ClassVar[contextvars.ContextVar[Self | None]] = contextvars.ContextVar("tool_context", default=None)
+    _cache: ClassVar[dict[str, Self]] = {}
+
+    def __init__(self, runtime: Runtime, agent: Agent, session: Session, requests: list[AgentRequest]):
+        """
+        Initialize the ToolContext with the given runtime, agent, session, and requests.
+        :param runtime: The Runtime instance representing the current execution context.
+        :param agent: The Agent instance representing the current agent.
+        :param session: The Session instance representing the current session.
+        :param requests: The list of AgentRequest instances representing the current requests being processed.
+        """
+        self._id = uuid.uuid4().hex
+        self._runtime: Runtime = runtime
+        self._agent: Agent = agent
+        self._session: Session = session
+        self._requests: list[AgentRequest] = requests
+        self._token: contextvars.Token[Self | None] | None = None
+
+    @property
+    def id(self) -> str:
+        """
+        Get the unique identifier for this ToolContext instance.
+        :return: The unique identifier as a string.
+        """
+        return self._id
+
+    @property
+    def runtime(self) -> Runtime:
+        """
+        Get the Runtime instance representing the current execution context.
+        :return: The current Runtime instance.
+        """
+        return self._runtime
+
+    @property
+    def agent(self) -> Agent:
+        """
+        Get the Agent instance representing the current agent.
+        :return: The current Agent instance.
+        """
+        return self._agent
+
+    @property
+    def session(self) -> Session:
+        """
+        Get the Session instance representing the current session.
+        :return: The current Session instance.
+        """
+        return self._session
+
+    @property
+    def requests(self) -> list[AgentRequest]:
+        """
+        Get the list of AgentRequest instances representing the current requests being processed.
+        :return: The current list of AgentRequest instances.
+        """
+        return self._requests
+
+    @classmethod
+    def get(cls) -> Self:
+        """
+        Get the current ToolContext instance from the context variable.
+
+        :return: The current ToolContext instance.
+        :raises RuntimeError: If there is no ToolContext set in the current context.
+        """
+        context = cls._context.get()
+        if context is None:
+            raise RuntimeError("No ToolContext is set in the current context")
+        return context
+
+    def set(self) -> Self:
+        """
+        Set this ToolContext instance in the context variable.
+        """
+        self._token = ToolContext._context.set(self)
+
+        return self
+
+    def reset(self) -> None:
+        """
+        Reset the context variable to the previous value before this ToolContext was set.
+        """
+        if self._token is not None:
+            ToolContext._context.reset(self._token)
+            self._token = None
+
+    def __enter__(self) -> Self:
+        """
+        Add the ToolContext instance in to the cache.
+        """
+        ToolContext._cache[self.id] = self
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """
+        Remove the ToolContext instance from the cache.
+        """
+        ToolContext._cache.pop(self.id, None)
+
+    @classmethod
+    def fetch(cls, id: str) -> Self:
+        """
+        Fetch a cached ToolContext instance by its ID.
+        :param id: The unique identifier of the ToolContext instance to fetch.
+        :return: The cached ToolContext instance.
+        :raises KeyError: If no ToolContext instance is found for the given ID.
+        """
+        if id not in cls._cache:
+            raise KeyError(f"No ToolContext found for id: {id}")
+        return cls._cache[id]
+
+
+class ToolBuilder:
+    """
+    Base class for framework-specific tool builders.
+
+    Provides common functionality that bind regular synchronous and asynchronous functions
+    into framework specific tool functions. It also makes sure execution context behaves in the
+    same manner across different frameworks.
+    """
+
+    @classmethod
+    def bind(cls, funcs: list[Callable]) -> list[Any]:
+        """
+        Bind a list of generic tool functions to framework-specific tool definitions.
+
+        :param funcs: List of generic tool functions to bind.
+        :return: List of framework-specific tool definitions.
+        :raises NotImplementedError: If called on the base ToolBuilder class.
+        """
+        raise NotImplementedError("bind() must be implemented by framework-specific subclasses")

{agentkernel-0.2.12 → agentkernel-0.2.14}/src/agentkernel/framework/adk/__init__.py

@@ -13,4 +13,4 @@ try:
 except importlib.metadata.PackageNotFoundError:
     __version__ = "0.1.0"
 
-from .adk import GoogleADKModule
+from .adk import GoogleADKModule, GoogleADKToolBuilder