agentic-layer-sdk-adk 0.7.2__tar.gz

agentic_layer_sdk_adk-0.7.2/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

agentic_layer_sdk_adk-0.7.2/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: agentic-layer-sdk-adk
+Version: 0.7.2
+Requires-Python: >=3.12
+Requires-Dist: google-adk[a2a]
+Requires-Dist: litellm
+Requires-Dist: openinference-instrumentation-google-adk
+Requires-Dist: opentelemetry-exporter-otlp-proto-http
+Requires-Dist: opentelemetry-instrumentation-httpx
+Requires-Dist: opentelemetry-instrumentation-starlette
+Description-Content-Type: text/markdown
+
+# Agentic Layer Python SDK for Google ADK
+
+SDK for Google ADK that helps to get agents configured in the Agentic Layer quickly.
+
+## Features
+
+- Configures OTEL (Tracing, Metrics, Logging)
+- Converts an ADK agent into an instrumented starlette app
+- Configures A2A protocol for inter-agent communication
+- Offers parsing methods for sub agents and tools
+- Set log level via env var `LOGLEVEL` (default: `INFO`)
+
+## Usage
+
+Dependencies can be installed via pip or the tool of your choice:
+
+```shell
+pip install agentic-layer-sdk-adk
+```
+
+Basic usage example:
+
+```python
+from agenticlayer.agent_to_a2a import to_a2a
+from agenticlayer.config import parse_sub_agents, parse_tools
+from agenticlayer.otel import setup_otel
+from google.adk.agents import LlmAgent
+
+# Set up OpenTelemetry instrumentation, logging and metrics
+setup_otel()
+
+# Parse sub agents and tools from JSON configuration
+sub_agent, agent_tools = parse_sub_agents("{}")
+mcp_tools = parse_tools("{}")
+tools = agent_tools + mcp_tools
+
+# Declare your ADK root agent
+root_agent = LlmAgent(
+    name="root-agent",
+    sub_agents=sub_agent,
+    tools=tools,
+    # [...]
+)
+
+# Define the URL where the agent will be available from outside
+# This can not be determined automatically,
+# because the port is only known at runtime,
+# when the starlette app is started with Uvicorn.
+rpc_url = "http://localhost:8000/"
+
+# Create starlette app with A2A protocol
+app = to_a2a(root_agent, rpc_url)
+```
+
+## Configuration
+
+The JSON configuration for sub agents should follow this structure:
+```json5
+{
+  "agent_name": {
+    "url": "http://agent-url/.well-known/agent-card.json",
+    // Optional: interaction type, defaults to "tool_call"
+    // "transfer" for full delegation, "tool_call" for tool-like usage
+    "interaction_type": "transfer|tool_call"
+  }
+}
+```
+
+The JSON configuration for `AGENT_TOOLS` should follow this structure:
+```json5
+{
+  "tool_name": {
+    "url": "https://mcp-tool-endpoint:8000/mcp",
+    "timeout": 30  // Optional: connect timeout in seconds
+  }
+}
+```
+
+## OpenTelemetry Configuration
+
+The SDK automatically configures OpenTelemetry observability when running `setup_otel()`. You can customize the OTLP
+exporters using standard OpenTelemetry environment variables:
+https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/

agentic_layer_sdk_adk-0.7.2/README.md

@@ -0,0 +1,83 @@
+# Agentic Layer Python SDK for Google ADK
+
+SDK for Google ADK that helps to get agents configured in the Agentic Layer quickly.
+
+## Features
+
+- Configures OTEL (Tracing, Metrics, Logging)
+- Converts an ADK agent into an instrumented starlette app
+- Configures A2A protocol for inter-agent communication
+- Offers parsing methods for sub agents and tools
+- Set log level via env var `LOGLEVEL` (default: `INFO`)
+
+## Usage
+
+Dependencies can be installed via pip or the tool of your choice:
+
+```shell
+pip install agentic-layer-sdk-adk
+```
+
+Basic usage example:
+
+```python
+from agenticlayer.agent_to_a2a import to_a2a
+from agenticlayer.config import parse_sub_agents, parse_tools
+from agenticlayer.otel import setup_otel
+from google.adk.agents import LlmAgent
+
+# Set up OpenTelemetry instrumentation, logging and metrics
+setup_otel()
+
+# Parse sub agents and tools from JSON configuration
+sub_agent, agent_tools = parse_sub_agents("{}")
+mcp_tools = parse_tools("{}")
+tools = agent_tools + mcp_tools
+
+# Declare your ADK root agent
+root_agent = LlmAgent(
+    name="root-agent",
+    sub_agents=sub_agent,
+    tools=tools,
+    # [...]
+)
+
+# Define the URL where the agent will be available from outside
+# This can not be determined automatically,
+# because the port is only known at runtime,
+# when the starlette app is started with Uvicorn.
+rpc_url = "http://localhost:8000/"
+
+# Create starlette app with A2A protocol
+app = to_a2a(root_agent, rpc_url)
+```
+
+## Configuration
+
+The JSON configuration for sub agents should follow this structure:
+```json5
+{
+  "agent_name": {
+    "url": "http://agent-url/.well-known/agent-card.json",
+    // Optional: interaction type, defaults to "tool_call"
+    // "transfer" for full delegation, "tool_call" for tool-like usage
+    "interaction_type": "transfer|tool_call"
+  }
+}
+```
+
+The JSON configuration for `AGENT_TOOLS` should follow this structure:
+```json5
+{
+  "tool_name": {
+    "url": "https://mcp-tool-endpoint:8000/mcp",
+    "timeout": 30  // Optional: connect timeout in seconds
+  }
+}
+```
+
+## OpenTelemetry Configuration
+
+The SDK automatically configures OpenTelemetry observability when running `setup_otel()`. You can customize the OTLP
+exporters using standard OpenTelemetry environment variables:
+https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/

agentic_layer_sdk_adk-0.7.2/agenticlayer/__init__.py

@@ -0,0 +1,4 @@
+"""
+SDK for the Agentic Layer.
+Provides some utilities and configurations for integrating a Google ADK-based agent into the Agentic Layer.
+"""

agentic_layer_sdk_adk-0.7.2/agenticlayer/agent_to_a2a.py

@@ -0,0 +1,111 @@
+"""
+Convert an ADK agent to an A2A Starlette application.
+This is an adaption of google.adk.a2a.utils.agent_to_a2a.
+"""
+
+import logging
+
+from a2a.server.apps import A2AStarletteApplication
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types import AgentCapabilities, AgentCard
+from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
+from google.adk.a2a.executor.a2a_agent_executor import A2aAgentExecutor
+from google.adk.agents.base_agent import BaseAgent
+from google.adk.apps.app import App
+from google.adk.artifacts.in_memory_artifact_service import InMemoryArtifactService
+from google.adk.auth.credential_service.in_memory_credential_service import InMemoryCredentialService
+from google.adk.memory.in_memory_memory_service import InMemoryMemoryService
+from google.adk.runners import Runner
+from google.adk.sessions.in_memory_session_service import InMemorySessionService
+from opentelemetry.instrumentation.starlette import StarletteInstrumentor
+from starlette.applications import Starlette
+
+from .callback_tracer_plugin import CallbackTracerPlugin
+
+logger = logging.getLogger("agenticlayer")
+
+
+class HealthCheckFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        # Check if the log message contains the well known path of the card, which is used for health checks
+        return record.getMessage().find(AGENT_CARD_WELL_KNOWN_PATH) == -1
+
+
+def to_a2a(agent: BaseAgent, rpc_url: str) -> Starlette:
+    """Convert an ADK agent to a A2A Starlette application.
+    This is an adaption of google.adk.a2a.utils.agent_to_a2a.
+
+    Args:
+        agent: The ADK agent to convert
+        rpc_url: The URL where the agent will be available for A2A communication
+
+    Returns:
+        A Starlette application that can be run with uvicorn
+
+    Example:
+        agent = MyAgent()
+        rpc_url = "http://localhost:8000/"
+        app = to_a2a(root_agent, rpc_url)
+        # Then run with: uvicorn module:app
+    """
+
+    # Filter out health check logs from uvicorn access logger
+    uvicorn_access_logger = logging.getLogger("uvicorn.access")
+    uvicorn_access_logger.addFilter(HealthCheckFilter())
+
+    async def create_runner() -> Runner:
+        """Create a runner for the agent."""
+        return Runner(
+            app=App(
+                name=agent.name or "adk_agent",
+                root_agent=agent,
+                plugins=[CallbackTracerPlugin()],
+            ),
+            artifact_service=InMemoryArtifactService(),
+            session_service=InMemorySessionService(),  # type: ignore
+            memory_service=InMemoryMemoryService(),  # type: ignore
+            credential_service=InMemoryCredentialService(),  # type: ignore
+        )
+
+    # Create A2A components
+    task_store = InMemoryTaskStore()
+
+    agent_executor = A2aAgentExecutor(
+        runner=create_runner,
+    )
+
+    request_handler = DefaultRequestHandler(agent_executor=agent_executor, task_store=task_store)
+
+    # Build agent card
+    agent_card = AgentCard(
+        name=agent.name,
+        description=agent.description,
+        url=rpc_url,
+        version="0.1.0",
+        capabilities=AgentCapabilities(),
+        skills=[],
+        default_input_modes=["text/plain"],
+        default_output_modes=["text/plain"],
+        supports_authenticated_extended_card=False,
+    )
+    logger.info("Built agent card: %s", agent_card.model_dump_json())
+
+    # Create the A2A Starlette application
+    a2a_app = A2AStarletteApplication(
+        agent_card=agent_card,
+        http_handler=request_handler,
+    )
+
+    # Create a Starlette app that will be configured during startup
+    starlette_app = Starlette()
+
+    # Add A2A routes to the main app
+    a2a_app.add_routes_to_app(
+        starlette_app,
+    )
+
+    # Instrument the Starlette app with OpenTelemetry
+    StarletteInstrumentor().instrument_app(starlette_app)
+
+    return starlette_app

agentic_layer_sdk_adk-0.7.2/agenticlayer/callback_tracer_plugin.py

@@ -0,0 +1,170 @@
+"""
+A custom plugin that traces agent, model, and tool callbacks using OpenTelemetry.
+This is an early draft, created in conjunction with the Observability Dashboard:
+https://github.com/agentic-layer/observability-dashboard
+"""
+
+import re
+from typing import Any, Dict, Optional
+
+from google.adk.agents import BaseAgent
+from google.adk.agents.callback_context import CallbackContext
+from google.adk.models.llm_request import LlmRequest
+from google.adk.models.llm_response import LlmResponse
+from google.adk.plugins.base_plugin import BasePlugin
+from google.adk.tools.base_tool import BaseTool
+from google.adk.tools.tool_context import ToolContext
+from google.genai import types
+from opentelemetry import trace
+
+# Pattern to match any key containing 'structuredcontent' or 'structured_content', case-insensitive
+STRUCTURED_CONTENT_PATTERN = re.compile(r"\.structured_?content", re.IGNORECASE)
+
+
+def _span_attribute_item(key: str, data: Any) -> tuple[str, Any]:
+    """Convert data to a span attribute-compatible type."""
+    if isinstance(data, (str, bool, int, float)):  # only these types are supported by span attributes
+        return key, data
+    else:
+        return key, str(data)
+
+
+def _flatten_dict(
+    data: Any, parent_key: str = "", sep: str = ".", parent_key_lower: Optional[str] = None
+) -> Dict[str, Any]:
+    if parent_key_lower is None:
+        parent_key_lower = parent_key.lower()
+
+    if STRUCTURED_CONTENT_PATTERN.search(parent_key_lower):
+        return {}  # skip structured content as it can add too many attributes
+
+    items: list[tuple[str, Any]] = []
+    if isinstance(data, dict):
+        for k, v in data.items():
+            new_key = f"{parent_key}{sep}{k}" if parent_key else k
+            new_key_lower = new_key.lower()
+            items.extend(_flatten_dict(v, new_key, sep=sep, parent_key_lower=new_key_lower).items())
+    elif isinstance(data, list):
+        for i, v in enumerate(data):
+            new_key = f"{parent_key}{sep}{i}"
+            new_key_lower = new_key.lower()
+            items.extend(_flatten_dict(v, new_key, sep=sep, parent_key_lower=new_key_lower).items())
+    elif data is not None:
+        items.append(_span_attribute_item(parent_key, data))
+    return dict(items)
+
+
+def _set_span_attributes_from_callback_context(span: Any, callback_context: CallbackContext) -> None:
+    conversation_id = (
+        callback_context.state.to_dict().get("conversation_id") or callback_context._invocation_context.session.id
+    )
+    span.set_attribute("agent_name", callback_context.agent_name)
+    span.set_attribute("conversation_id", conversation_id)
+    span.set_attribute("invocation_id", callback_context.invocation_id)
+    span.set_attributes(callback_context.state.to_dict())
+
+    if callback_context.user_content:
+        span.set_attributes(_flatten_dict(callback_context.user_content.model_dump(), parent_key="user_content"))
+
+
+def _set_span_attributes_for_tool(span: Any, tool: BaseTool, args: Dict[str, Any], tool_context: ToolContext) -> None:
+    _set_span_attributes_from_callback_context(span, tool_context)
+    span.set_attributes(_flatten_dict(tool_context.actions.model_dump(), parent_key="tool_context.actions"))
+    span.set_attribute("tool_name", tool.name)
+    span.set_attributes(_flatten_dict(args, parent_key="args"))
+
+
+class CallbackTracerPlugin(BasePlugin):
+    """A custom ADK plugin that traces agent, model, and tool callbacks using OpenTelemetry."""
+
+    def __init__(self) -> None:
+        super().__init__("CallbackTracerPlugin")
+
+    async def before_agent_callback(
+        self, *, agent: BaseAgent, callback_context: CallbackContext
+    ) -> Optional[types.Content]:
+        with trace.get_tracer(__name__).start_as_current_span("before_agent_callback") as span:
+            _set_span_attributes_from_callback_context(span, callback_context)
+        return None
+
+    async def after_agent_callback(
+        self, *, agent: BaseAgent, callback_context: CallbackContext
+    ) -> Optional[types.Content]:
+        with trace.get_tracer(__name__).start_as_current_span("after_agent_callback") as span:
+            _set_span_attributes_from_callback_context(span, callback_context)
+        return None
+
+    async def before_model_callback(
+        self, *, callback_context: CallbackContext, llm_request: LlmRequest
+    ) -> Optional[LlmResponse]:
+        with trace.get_tracer(__name__).start_as_current_span("before_model_callback") as span:
+            _set_span_attributes_from_callback_context(span, callback_context)
+        span.set_attribute("model", llm_request.model or "unknown")
+        if llm_request.contents:
+            span.set_attributes(
+                _flatten_dict(llm_request.contents[-1].model_dump(), parent_key="llm_request.content")
+            )  # only send the last content part (last user input)
+        return None
+
+    async def after_model_callback(
+        self, *, callback_context: CallbackContext, llm_response: LlmResponse
+    ) -> Optional[LlmResponse]:
+        with trace.get_tracer(__name__).start_as_current_span("after_model_callback") as span:
+            _set_span_attributes_from_callback_context(span, callback_context)
+            span.set_attributes(_flatten_dict(llm_response.model_dump(), parent_key="llm_response"))
+        return None
+
+    async def before_tool_callback(
+        self,
+        *,
+        tool: BaseTool,
+        tool_args: Dict[str, Any],
+        tool_context: ToolContext,
+    ) -> Optional[Dict[str, Any]]:
+        with trace.get_tracer(__name__).start_as_current_span("before_tool_callback") as span:
+            _set_span_attributes_for_tool(span, tool, tool_args, tool_context)
+        return None
+
+    async def after_tool_callback(
+        self,
+        *,
+        tool: BaseTool,
+        tool_args: Dict[str, Any],
+        tool_context: ToolContext,
+        result: Dict[str, Any],
+    ) -> Optional[Dict[str, Any]]:
+        with trace.get_tracer(__name__).start_as_current_span("after_tool_callback") as span:
+            _set_span_attributes_for_tool(span, tool, tool_args, tool_context)
+        if isinstance(result, (dict, list)):
+            span.set_attributes(_flatten_dict(result, parent_key="tool_response"))
+        return None
+
+    async def on_model_error_callback(
+        self,
+        *,
+        callback_context: CallbackContext,
+        llm_request: LlmRequest,
+        error: Exception,
+    ) -> Optional[LlmResponse]:
+        with trace.get_tracer(__name__).start_as_current_span("on_model_error_callback") as span:
+            _set_span_attributes_from_callback_context(span, callback_context)
+            span.set_attribute("model", llm_request.model or "unknown")
+            if llm_request.contents:
+                span.set_attributes(
+                    _flatten_dict(llm_request.contents[-1].model_dump(), parent_key="llm_request.content")
+                )  # only send the last content part (last user input)
+            span.set_attribute("error", str(error))
+        return None
+
+    async def on_tool_error_callback(
+        self,
+        *,
+        tool: BaseTool,
+        tool_args: Dict[str, Any],
+        tool_context: ToolContext,
+        error: Exception,
+    ) -> Optional[Dict[str, Any]]:
+        with trace.get_tracer(__name__).start_as_current_span("on_tool_error_callback") as span:
+            _set_span_attributes_for_tool(span, tool, tool_args, tool_context)
+            span.set_attribute("error", str(error))
+        return None

agentic_layer_sdk_adk-0.7.2/agenticlayer/config.py

@@ -0,0 +1,78 @@
+"""
+Configuration parsing for sub-agents and tools.
+Parses JSON configurations to create RemoteA2aAgents, AgentTools and McpToolsets.
+"""
+
+import json
+import logging
+
+from google.adk.agents import BaseAgent
+from google.adk.agents.llm_agent import ToolUnion
+from google.adk.agents.remote_a2a_agent import RemoteA2aAgent
+from google.adk.tools.agent_tool import AgentTool
+from google.adk.tools.mcp_tool import StreamableHTTPConnectionParams
+from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
+
+
+def parse_sub_agents(sub_agents_config: str) -> tuple[list[BaseAgent], list[ToolUnion]]:
+    """
+    Get sub agents from JSON string.
+    Format: {"agent_name": {"url": "http://agent_url", "interaction_type", "transfer|tool_call"}, ...}
+
+    :return: A tuple of:
+        - list of sub agents for transfer interaction type
+        - list of agent tools for tool_call interaction type
+    """
+
+    try:
+        agents_map = json.loads(sub_agents_config)
+    except json.JSONDecodeError as e:
+        raise ValueError("Warning: Invalid JSON in SUB_AGENTS environment variable: " + sub_agents_config, e)
+
+    sub_agents: list[BaseAgent] = []
+    tools: list[ToolUnion] = []
+    for agent_name, config in agents_map.items():
+        if "url" not in config:
+            raise ValueError(f"Missing 'url' for agent '{agent_name}': " + str(config))
+
+        interaction_type = config.get("interaction_type", "tool_call")
+
+        logging.info("Adding sub-agent: %s (%s) with URL: %s", agent_name, interaction_type, config["url"])
+        agent = RemoteA2aAgent(name=agent_name, agent_card=config["url"])
+        if interaction_type == "tool_call":
+            tools.append(AgentTool(agent=agent))
+        else:
+            sub_agents.append(agent)
+
+    return sub_agents, tools
+
+
+def parse_tools(tools_config: str) -> list[ToolUnion]:
+    """
+    Get tools from JSON string.
+    Format: {"tool_name": {"url": "http://tool_url", "timeout": 30}, ...}
+
+    :return: A list of McpToolset tools
+    """
+
+    try:
+        tools_map = json.loads(tools_config)
+    except json.JSONDecodeError as e:
+        raise ValueError("Warning: Invalid JSON in AGENT_TOOLS environment variable: " + tools_config, e)
+
+    tools: list[ToolUnion] = []
+    for name, config in tools_map.items():
+        if "url" not in config:
+            raise ValueError(f"Missing 'url' for tool '{name}': " + str(config))
+
+        logging.info("Adding tool: %s with URL: %s", name, config["url"])
+        tools.append(
+            McpToolset(
+                connection_params=StreamableHTTPConnectionParams(
+                    url=config["url"],
+                    timeout=config.get("timeout", 30),
+                ),
+            )
+        )
+
+    return tools

agentic_layer_sdk_adk-0.7.2/agenticlayer/otel.py

@@ -0,0 +1,51 @@
+"""OpenTelemetry setup for a Google ADK Agent App."""
+
+import logging
+
+from openinference.instrumentation.google_adk import GoogleADKInstrumentor
+from opentelemetry import metrics, trace
+from opentelemetry._logs import set_logger_provider
+from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
+from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
+from opentelemetry.sdk import trace as trace_sdk
+from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
+from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+
+
+def setup_otel() -> None:
+    """Set up OpenTelemetry tracing, logging and metrics."""
+
+    # Set log level for urllib to WARNING to reduce noise (like sending logs to OTLP)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+    # Traces
+    _tracer_provider = trace_sdk.TracerProvider()
+    _tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter()))
+    # Sets the global default tracer provider
+    trace.set_tracer_provider(_tracer_provider)
+
+    # Instrument Google ADK using openinference instrumentation
+    GoogleADKInstrumentor().instrument()
+    # Instrument HTTPX clients (this also transfers the trace context automatically)
+    HTTPXClientInstrumentor().instrument()
+
+    # Logs
+    logger_provider = LoggerProvider()
+    logger_provider.add_log_record_processor(BatchLogRecordProcessor(OTLPLogExporter()))
+    # Sets the global default logger provider
+    set_logger_provider(logger_provider)
+
+    # Attach OTLP handler to root logger
+    logging.getLogger().addHandler(LoggingHandler(level=logging.NOTSET, logger_provider=logger_provider))
+
+    # Sets the global default meter provider
+    metrics.set_meter_provider(
+        MeterProvider(
+            metric_readers=[PeriodicExportingMetricReader(OTLPMetricExporter())],
+        )
+    )

agentic_layer_sdk_adk-0.7.2/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "agentic-layer-sdk-adk"
+version = "0.7.2"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "google-adk[a2a]",
+    "litellm",
+    "opentelemetry-exporter-otlp-proto-http",
+    "opentelemetry-instrumentation-starlette",
+    "openinference-instrumentation-google-adk",
+    "opentelemetry-instrumentation-httpx",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["agenticlayer"]

agentic_layer_sdk_adk-0.7.2/tests/test_a2a_starlette.py

@@ -0,0 +1,159 @@
+import uuid
+from typing import Any
+
+import pytest
+from agenticlayer.agent_to_a2a import to_a2a
+from agenticlayer.config import parse_sub_agents, parse_tools
+from google.adk.agents.llm_agent import LlmAgent
+from google.adk.models.lite_llm import LiteLlm
+from starlette.testclient import TestClient
+
+
+def create_mock_agent_card(
+    agent_name: str,
+    base_url: str,
+    skills: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Helper function to create a valid agent card response."""
+    return {
+        "name": agent_name,
+        "description": f"Mock agent {agent_name}",
+        "url": base_url,
+        "version": "1.0.0",
+        "capabilities": {},
+        "skills": skills or [],
+        "default_input_modes": ["text/plain"],
+        "default_output_modes": ["text/plain"],
+        "supports_authenticated_extended_card": False,
+    }
+
+
+def create_send_message_request(
+    message_text: str = "Hello, agent!",
+) -> dict[str, Any]:
+    """Helper function to create a valid A2A send message request."""
+    message_id = str(uuid.uuid4())
+    context_id = str(uuid.uuid4())
+    return {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "message/send",
+        "params": {
+            "message": {
+                "role": "user",
+                "parts": [{"kind": "text", "text": message_text}],
+                "messageId": message_id,
+                "contextId": context_id,
+            },
+            "metadata": {},
+        },
+    }
+
+
+def create_agent(
+    name: str = "test_agent",
+    sub_agents_config: str = "{}",
+    tools_config: str = "{}",
+) -> LlmAgent:
+    sub_agents, agent_tools = parse_sub_agents(sub_agents_config)
+    mcp_tools = parse_tools(tools_config)
+    tools = [*agent_tools, *mcp_tools]
+    return LlmAgent(
+        name=name,
+        model=LiteLlm(model="gemini/gemini-2.5-flash"),
+        description="Test agent",
+        instruction="You are a test agent.",
+        sub_agents=sub_agents,
+        tools=tools,
+    )
+
+
+rpc_url = "http://localhost:80/"
+
+
+class TestA2AStarlette:
+    @pytest.mark.asyncio
+    async def test_agent_card(self) -> None:
+        """Test that the agent card is available at /.well-known/agent-card.json"""
+
+        # Given:
+        agent = create_agent()
+        app = to_a2a(agent, rpc_url)
+        client = TestClient(app)
+
+        # When: Requesting the agent card endpoint
+        response = client.get("/.well-known/agent-card.json")
+
+        # Then: Agent card is returned
+        assert response.status_code == 200
+        data = response.json()
+        assert isinstance(data, dict), "Agent card should return a JSON object"
+        assert data.get("name") == agent.name
+        assert data.get("description") == agent.description
+
+    @pytest.mark.asyncio
+    async def test_agent_rpc_send_message(self) -> None:
+        """Test that the RPC url is working for send message."""
+
+        # Given:
+        agent = create_agent()
+        app = to_a2a(agent, rpc_url)
+        client = TestClient(app)
+
+        # When: Sending an A2A RPC request
+        rpc_response = client.post("", json=create_send_message_request())
+
+        # Then: RPC response is returned
+        assert rpc_response.status_code == 200
+        rpc_data = rpc_response.json()
+        assert rpc_data.get("jsonrpc") == "2.0"
+        assert rpc_data.get("id") == 1
+
+    @pytest.mark.asyncio
+    async def test_sub_agents(self) -> None:
+        """Test that sub-agents are parsed and integrated correctly."""
+
+        # When: Creating an agent with sub-agents
+        sub_agents_config = """{
+                "sub_agent_1": {
+                    "url": "http://sub-agent-1.local/.well-known/agent-card.json",
+                    "interaction_type": "transfer"
+                },
+                "sub_agent_2": {
+                    "url": "http://sub-agent-2.local/.well-known/agent-card.json",
+                    "interaction_type": "tool_call"
+                }
+            }"""
+        agent = create_agent(sub_agents_config=sub_agents_config)
+
+        # Then: Verify sub-agents and tools are parsed correctly
+        assert len(agent.sub_agents) == 1, "There should be 1 sub-agent for transfer interaction type"
+        assert len(agent.tools) == 1, "There should be 1 agent tool for tool_call interaction type"
+
+        # When: Requesting the agent card endpoint
+        app = to_a2a(agent, rpc_url)
+        client = TestClient(app)
+        response = client.get("/.well-known/agent-card.json")
+
+        # Then: Agent card is returned
+        assert response.status_code == 200
+
+    @pytest.mark.asyncio
+    async def test_tools(self) -> None:
+        """Test that tools are parsed and integrated correctly."""
+
+        # When: Creating an agent with tools
+        tools_config = """{
+                "tool_1": {
+                    "url": "http://tool-1.local/mcp"
+                },
+                "tool_2": {
+                    "url": "http://tool-2.local/mcp"
+                }
+            }"""
+        tools = parse_tools(tools_config)
+
+        # Then: Verify McpToolsets are created correctly
+        assert len(tools) == 2, "There should be 2 McpToolset tools"
+
+        # Note: Further integration tests would require mocking MCP tool behavior