kagent-adk 0.6.6__tar.gz → 0.6.8__tar.gz

{kagent_adk-0.6.6 → kagent_adk-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kagent-adk
-Version: 0.6.6
+Version: 0.6.8
 Summary: kagent-adk is an sdk for integrating adk agents with kagent
 Requires-Python: >=3.12.11
 Requires-Dist: a2a-sdk>=0.3.1
@@ -13,15 +13,10 @@ Requires-Dist: google-auth>=2.40.2
 Requires-Dist: google-genai>=1.21.1
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonref>=1.1.0
+Requires-Dist: kagent-core
 Requires-Dist: litellm>=1.74.3
 Requires-Dist: mcp>=1.12.0
 Requires-Dist: openai>=1.72.0
-Requires-Dist: opentelemetry-api>=1.36.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.36.0
-Requires-Dist: opentelemetry-instrumentation-anthropic>=0.44.0
-Requires-Dist: opentelemetry-instrumentation-httpx>=0.52.0
-Requires-Dist: opentelemetry-instrumentation-openai>=0.44.3
-Requires-Dist: opentelemetry-sdk>=1.36.0
 Requires-Dist: protobuf>=6
 Requires-Dist: pydantic>=2.5.0
 Requires-Dist: typer>=0.15.0

{kagent_adk-0.6.6 → kagent_adk-0.6.8}/pyproject.toml

@@ -4,11 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kagent-adk"
-version = "0.6.6"
+version = "0.6.8"
 description = "kagent-adk is an sdk for integrating adk agents with kagent"
 readme = "README.md"
 requires-python = ">=3.12.11"
 dependencies = [
+  "kagent-core",
   "aiofiles>=24.1.0",
   "anyio>=4.9.0",
   "typer>=0.15.0",
@@ -16,12 +17,6 @@ dependencies = [
   "openai>=1.72.0",
   "mcp>=1.12.0",
   "protobuf>=6",
-  "opentelemetry-api>=1.36.0",
-  "opentelemetry-sdk>=1.36.0",
-  "opentelemetry-exporter-otlp-proto-grpc>=1.36.0",
-  "opentelemetry-instrumentation-openai>= 0.44.3",
-  "opentelemetry-instrumentation-anthropic>=0.44.0",
-  "opentelemetry-instrumentation-httpx >= 0.52.0",
   "anthropic[vertex]>=0.49.0",
   "fastapi>=0.115.1",
   "litellm>=1.74.3",
@@ -35,8 +30,11 @@ dependencies = [
   "a2a-sdk>=0.3.1",
 ]
 
+[tool.uv.sources]
+kagent-core = {workspace = true}
+
 [project.scripts]
-kagent-adk = "kagent_adk.cli:app"
+kagent-adk = "kagent.adk.cli:app"
 
 [project.optional-dependencies]
 test = [
@@ -48,7 +46,7 @@ memory = [
 ]
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/kagent_adk"]
+packages = ["src/kagent"]
 
 [tool.ruff]
 extend = "../../pyproject.toml"

{kagent_adk-0.6.6/src/kagent_adk → kagent_adk-0.6.8/src/kagent/adk}/__init__.py

@@ -1,6 +1,6 @@
 import importlib.metadata
 
-from .a2a import KAgentApp
+from ._a2a import KAgentApp
 from .models import AgentConfig
 
 __version__ = importlib.metadata.version("kagent_adk")

kagent_adk-0.6.6/src/kagent_adk/a2a.py → kagent_adk-0.6.8/src/kagent/adk/_a2a.py

@@ -1,20 +1,13 @@
 #! /usr/bin/env python3
 import faulthandler
-import inspect
 import logging
 import os
-import sys
-from contextlib import asynccontextmanager
-from typing import Awaitable, Callable, override
+from typing import Callable
 
 import httpx
-from a2a.auth.user import User
-from a2a.server.agent_execution import RequestContext, SimpleRequestContextBuilder
-from a2a.server.apps import A2AStarletteApplication
-from a2a.server.context import ServerCallContext
+from a2a.server.apps import A2AFastAPIApplication
 from a2a.server.request_handlers import DefaultRequestHandler
-from a2a.server.tasks import TaskStore
-from a2a.types import AgentCard, MessageSendParams, Task
+from a2a.types import AgentCard
 from fastapi import FastAPI, Request
 from fastapi.responses import PlainTextResponse
 from google.adk.agents import BaseAgent
@@ -22,54 +15,16 @@ from google.adk.runners import Runner
 from google.adk.sessions import InMemorySessionService
 from google.genai import types
 
+from kagent.core.a2a import KAgentRequestContextBuilder, KAgentTaskStore
+
 from ._agent_executor import A2aAgentExecutor
 from ._session_service import KAgentSessionService
-from ._task_store import KAgentTaskStore
 from ._token import KAgentTokenService
 
 # --- Configure Logging ---
 logger = logging.getLogger(__name__)
 
 
-class KAgentUser(User):
-    def __init__(self, user_id: str):
-        self.user_id = user_id
-
-    @property
-    def is_authenticated(self) -> bool:
-        return True
-
-    @property
-    def user_name(self) -> str:
-        return self.user_id
-
-
-class KAgentRequestContextBuilder(SimpleRequestContextBuilder):
-    """
-    A request context builder that will be used to hack in the user_id for now.
-    """
-
-    def __init__(self, task_store: TaskStore):
-        super().__init__(task_store=task_store)
-
-    async def build(
-        self,
-        params: MessageSendParams | None = None,
-        task_id: str | None = None,
-        context_id: str | None = None,
-        task: Task | None = None,
-        context: ServerCallContext | None = None,
-    ) -> RequestContext:
-        if context:
-            # grab the user id from the header
-            headers = context.state.get("headers", {})
-            user_id = headers.get("x-user-id", None)
-            if user_id:
-                context.user = KAgentUser(user_id=user_id)
-        request_context = await super().build(params, task_id, context_id, task, context)
-        return request_context
-
-
 def health_check(request: Request) -> PlainTextResponse:
     return PlainTextResponse("OK")
 
@@ -126,7 +81,7 @@ class KAgentApp:
             request_context_builder=request_context_builder,
         )
 
-        a2a_app = A2AStarletteApplication(
+        a2a_app = A2AFastAPIApplication(
             agent_card=self.agent_card,
             http_handler=request_handler,
         )

{kagent_adk-0.6.6/src/kagent_adk → kagent_adk-0.6.8/src/kagent/adk}/_agent_executor.py

@@ -13,6 +13,7 @@ from a2a.server.events.event_queue import EventQueue
 from a2a.types import (
     Artifact,
     Message,
+    Part,
     Role,
     TaskArtifactUpdateEvent,
     TaskState,
@@ -20,14 +21,16 @@ from a2a.types import (
     TaskStatusUpdateEvent,
     TextPart,
 )
-from google.adk.a2a.converters.event_converter import convert_event_to_a2a_events
-from google.adk.a2a.converters.request_converter import convert_a2a_request_to_adk_run_args
-from google.adk.a2a.converters.utils import _get_adk_metadata_key
-from google.adk.a2a.executor.task_result_aggregator import TaskResultAggregator
 from google.adk.runners import Runner
+from opentelemetry import trace
 from pydantic import BaseModel
 from typing_extensions import override
 
+from kagent.core.a2a import TaskResultAggregator, get_kagent_metadata_key
+
+from .converters.event_converter import convert_event_to_a2a_events
+from .converters.request_converter import convert_a2a_request_to_adk_run_args
+
 logger = logging.getLogger("google_adk." + __name__)
 
 
@@ -133,7 +136,7 @@ class A2aAgentExecutor(AgentExecutor):
                             message=Message(
                                 message_id=str(uuid.uuid4()),
                                 role=Role.agent,
-                                parts=[TextPart(text=str(e))],
+                                parts=[Part(TextPart(text=str(e)))],
                             ),
                         ),
                         context_id=context.context_id,
@@ -166,6 +169,14 @@ class A2aAgentExecutor(AgentExecutor):
         # ensure the session exists
         session = await self._prepare_session(context, run_args, runner)
 
+        current_span = trace.get_current_span()
+        if run_args["user_id"]:
+            current_span.set_attribute("kagent.user_id", run_args["user_id"])
+        if context.task_id:
+            current_span.set_attribute("gen_ai.task.id", context.task_id)
+        if run_args["session_id"]:
+            current_span.set_attribute("gen_ai.converstation.id", run_args["session_id"])
+
         # create invocation context
         invocation_context = runner._new_invocation_context(
             session=session,
@@ -184,9 +195,9 @@ class A2aAgentExecutor(AgentExecutor):
                 context_id=context.context_id,
                 final=False,
                 metadata={
-                    _get_adk_metadata_key("app_name"): runner.app_name,
-                    _get_adk_metadata_key("user_id"): run_args["user_id"],
-                    _get_adk_metadata_key("session_id"): run_args["session_id"],
+                    get_kagent_metadata_key("app_name"): runner.app_name,
+                    get_kagent_metadata_key("user_id"): run_args["user_id"],
+                    get_kagent_metadata_key("session_id"): run_args["session_id"],
                 },
             )
         )

{kagent_adk-0.6.6/src/kagent_adk → kagent_adk-0.6.8/src/kagent/adk}/_token.py

@@ -3,6 +3,8 @@ import asyncio
 from contextlib import asynccontextmanager
 from typing import Any, Optional
 
+import httpx
+
 KAGENT_TOKEN_PATH = "/var/run/secrets/tokens/kagent-token"
 logger = logging.getLogger(__name__)
 
@@ -59,7 +61,7 @@ class KAgentTokenService:
                 async with self.update_lock:
                     self.token = token
 
-    async def _add_bearer_token(self, request):
+    async def _add_bearer_token(self, request: httpx.Request):
         # Your function to generate headers dynamically
         token = await self._get_token()
         headers = {"X-Agent-Name": self.app_name}

kagent_adk-0.6.8/src/kagent/adk/cli.py

@@ -0,0 +1,111 @@
+import asyncio
+import json
+import logging
+import os
+from typing import Annotated
+
+import typer
+import uvicorn
+from a2a.types import AgentCard
+from google.adk.cli.utils.agent_loader import AgentLoader
+
+from kagent.core import KAgentConfig, configure_tracing
+
+from . import AgentConfig, KAgentApp
+
+logger = logging.getLogger(__name__)
+
+app = typer.Typer()
+
+
+@app.command()
+def static(
+    host: str = "127.0.0.1",
+    port: int = 8080,
+    workers: int = 1,
+    filepath: str = "/config",
+    reload: Annotated[bool, typer.Option("--reload")] = False,
+):
+    app_cfg = KAgentConfig()
+
+    with open(os.path.join(filepath, "config.json"), "r") as f:
+        config = json.load(f)
+    agent_config = AgentConfig.model_validate(config)
+    with open(os.path.join(filepath, "agent-card.json"), "r") as f:
+        agent_card = json.load(f)
+    agent_card = AgentCard.model_validate(agent_card)
+    root_agent = agent_config.to_agent(app_cfg.name)
+
+    kagent_app = KAgentApp(root_agent, agent_card, app_cfg.url, app_cfg.app_name)
+
+    server = kagent_app.build()
+    configure_tracing(server)
+
+    uvicorn.run(
+        server,
+        host=host,
+        port=port,
+        workers=workers,
+        reload=reload,
+    )
+
+
+@app.command()
+def run(
+    name: Annotated[str, typer.Argument(help="The name of the agent to run")],
+    working_dir: str = ".",
+    host: str = "127.0.0.1",
+    port: int = 8080,
+    workers: int = 1,
+):
+    app_cfg = KAgentConfig()
+
+    agent_loader = AgentLoader(agents_dir=working_dir)
+    root_agent = agent_loader.load_agent(name)
+
+    with open(os.path.join(working_dir, name, "agent-card.json"), "r") as f:
+        agent_card = json.load(f)
+    agent_card = AgentCard.model_validate(agent_card)
+    kagent_app = KAgentApp(root_agent, agent_card, app_cfg.url, app_cfg.app_name)
+    server = kagent_app.build()
+    configure_tracing(server)
+
+    uvicorn.run(
+        server,
+        host=host,
+        port=port,
+        workers=workers,
+    )
+
+
+async def test_agent(agent_config: AgentConfig, agent_card: AgentCard, task: str):
+    app_cfg = KAgentConfig()
+    agent = agent_config.to_agent(app_cfg.name)
+    app = KAgentApp(agent, agent_card, app_cfg.url, app_cfg.app_name)
+    await app.test(task)
+
+
+@app.command()
+def test(
+    task: Annotated[str, typer.Option("--task", help="The task to test the agent with")],
+    filepath: Annotated[str, typer.Option("--filepath", help="The path to the agent config file")],
+):
+    with open(filepath, "r") as f:
+        content = f.read()
+        config = json.loads(content)
+
+    with open(os.path.join(filepath, "agent-card.json"), "r") as f:
+        agent_card = json.load(f)
+    agent_card = AgentCard.model_validate(agent_card)
+    agent_config = AgentConfig.model_validate(config)
+    asyncio.run(test_agent(agent_config, agent_card, task))
+
+
+def run_cli():
+    logging.basicConfig(level=logging.INFO)
+    logging.info("Starting KAgent")
+    app()
+
+
+if __name__ == "__main__":
+    run_cli()

kagent_adk-0.6.8/src/kagent/adk/converters/event_converter.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from a2a.server.events import Event as A2AEvent
+from a2a.types import DataPart, Message, Role, Task, TaskState, TaskStatus, TaskStatusUpdateEvent, TextPart
+from a2a.types import Part as A2APart
+from google.adk.agents.invocation_context import InvocationContext
+from google.adk.events.event import Event
+from google.adk.flows.llm_flows.functions import REQUEST_EUC_FUNCTION_CALL_NAME
+from google.genai import types as genai_types
+
+from kagent.core.a2a import (
+    A2A_DATA_PART_METADATA_IS_LONG_RUNNING_KEY,
+    A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL,
+    A2A_DATA_PART_METADATA_TYPE_KEY,
+    get_kagent_metadata_key,
+)
+
+from .part_converter import (
+    convert_genai_part_to_a2a_part,
+)
+
+# Constants
+
+ARTIFACT_ID_SEPARATOR = "-"
+DEFAULT_ERROR_MESSAGE = "An error occurred during processing"
+
+# Logger
+logger = logging.getLogger("kagent_adk." + __name__)
+
+
+def _serialize_metadata_value(value: Any) -> str:
+    """Safely serializes metadata values to string format.
+
+    Args:
+      value: The value to serialize.
+
+    Returns:
+      String representation of the value.
+    """
+    if hasattr(value, "model_dump"):
+        try:
+            return value.model_dump(exclude_none=True, by_alias=True)
+        except Exception as e:
+            logger.warning("Failed to serialize metadata value: %s", e)
+            return str(value)
+    return str(value)
+
+
+def _get_context_metadata(event: Event, invocation_context: InvocationContext) -> Dict[str, str]:
+    """Gets the context metadata for the event.
+
+    Args:
+      event: The ADK event to extract metadata from.
+      invocation_context: The invocation context containing session information.
+
+    Returns:
+      A dictionary containing the context metadata.
+
+    Raises:
+      ValueError: If required fields are missing from event or context.
+    """
+    if not event:
+        raise ValueError("Event cannot be None")
+    if not invocation_context:
+        raise ValueError("Invocation context cannot be None")
+
+    try:
+        metadata = {
+            get_kagent_metadata_key("app_name"): invocation_context.app_name,
+            get_kagent_metadata_key("user_id"): invocation_context.user_id,
+            get_kagent_metadata_key("session_id"): invocation_context.session.id,
+            get_kagent_metadata_key("invocation_id"): event.invocation_id,
+            get_kagent_metadata_key("author"): event.author,
+        }
+
+        # Add optional metadata fields if present
+        optional_fields = [
+            ("branch", event.branch),
+            ("grounding_metadata", event.grounding_metadata),
+            ("custom_metadata", event.custom_metadata),
+            ("usage_metadata", event.usage_metadata),
+            ("error_code", event.error_code),
+        ]
+
+        for field_name, field_value in optional_fields:
+            if field_value is not None:
+                metadata[get_kagent_metadata_key(field_name)] = _serialize_metadata_value(field_value)
+
+        return metadata
+
+    except Exception as e:
+        logger.error("Failed to create context metadata: %s", e)
+        raise
+
+
+def _create_artifact_id(app_name: str, user_id: str, session_id: str, filename: str, version: int) -> str:
+    """Creates a unique artifact ID.
+
+    Args:
+      app_name: The application name.
+      user_id: The user ID.
+      session_id: The session ID.
+      filename: The artifact filename.
+      version: The artifact version.
+
+    Returns:
+      A unique artifact ID string.
+    """
+    components = [app_name, user_id, session_id, filename, str(version)]
+    return ARTIFACT_ID_SEPARATOR.join(components)
+
+
+def _process_long_running_tool(a2a_part: A2APart, event: Event) -> None:
+    """Processes long-running tool metadata for an A2A part.
+
+    Args:
+      a2a_part: The A2A part to potentially mark as long-running.
+      event: The ADK event containing long-running tool information.
+    """
+    if (
+        isinstance(a2a_part.root, DataPart)
+        and event.long_running_tool_ids
+        and a2a_part.root.metadata
+        and a2a_part.root.metadata.get(get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY))
+        == A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL
+        and a2a_part.root.data.get("id") in event.long_running_tool_ids
+    ):
+        a2a_part.root.metadata[get_kagent_metadata_key(A2A_DATA_PART_METADATA_IS_LONG_RUNNING_KEY)] = True
+
+
+def convert_event_to_a2a_message(
+    event: Event, invocation_context: InvocationContext, role: Role = Role.agent
+) -> Optional[Message]:
+    """Converts an ADK event to an A2A message.
+
+    Args:
+      event: The ADK event to convert.
+      invocation_context: The invocation context.
+
+    Returns:
+      An A2A Message if the event has content, None otherwise.
+
+    Raises:
+      ValueError: If required parameters are invalid.
+    """
+    if not event:
+        raise ValueError("Event cannot be None")
+    if not invocation_context:
+        raise ValueError("Invocation context cannot be None")
+
+    if not event.content or not event.content.parts:
+        return None
+
+    try:
+        a2a_parts = []
+        for part in event.content.parts:
+            a2a_part = convert_genai_part_to_a2a_part(part)
+            if a2a_part:
+                a2a_parts.append(a2a_part)
+                _process_long_running_tool(a2a_part, event)
+
+        if a2a_parts:
+            return Message(message_id=str(uuid.uuid4()), role=role, parts=a2a_parts)
+
+    except Exception as e:
+        logger.error("Failed to convert event to status message: %s", e)
+        raise
+
+    return None
+
+
+def _create_error_status_event(
+    event: Event,
+    invocation_context: InvocationContext,
+    task_id: Optional[str] = None,
+    context_id: Optional[str] = None,
+) -> TaskStatusUpdateEvent:
+    """Creates a TaskStatusUpdateEvent for error scenarios.
+
+    Args:
+      event: The ADK event containing error information.
+      invocation_context: The invocation context.
+      task_id: Optional task ID to use for generated events.
+      context_id: Optional Context ID to use for generated events.
+
+    Returns:
+      A TaskStatusUpdateEvent with FAILED state.
+    """
+    error_message = getattr(event, "error_message", None) or DEFAULT_ERROR_MESSAGE
+
+    # Get context metadata and add error code
+    event_metadata = _get_context_metadata(event, invocation_context)
+    if event.error_code:
+        event_metadata[get_kagent_metadata_key("error_code")] = str(event.error_code)
+
+    return TaskStatusUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        metadata=event_metadata,
+        status=TaskStatus(
+            state=TaskState.failed,
+            message=Message(
+                message_id=str(uuid.uuid4()),
+                role=Role.agent,
+                parts=[A2APart(TextPart(text=error_message))],
+                metadata={get_kagent_metadata_key("error_code"): str(event.error_code)} if event.error_code else {},
+            ),
+            timestamp=datetime.now(timezone.utc).isoformat(),
+        ),
+        final=False,
+    )
+
+
+def _create_status_update_event(
+    message: Message,
+    invocation_context: InvocationContext,
+    event: Event,
+    task_id: Optional[str] = None,
+    context_id: Optional[str] = None,
+) -> TaskStatusUpdateEvent:
+    """Creates a TaskStatusUpdateEvent for running scenarios.
+
+    Args:
+      message: The A2A message to include.
+      invocation_context: The invocation context.
+      event: The ADK event.
+      task_id: Optional task ID to use for generated events.
+      context_id: Optional Context ID to use for generated events.
+
+
+    Returns:
+      A TaskStatusUpdateEvent with RUNNING state.
+    """
+    status = TaskStatus(
+        state=TaskState.working,
+        message=message,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+
+    if any(
+        part.root.metadata.get(get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY))
+        == A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL
+        and part.root.metadata.get(get_kagent_metadata_key(A2A_DATA_PART_METADATA_IS_LONG_RUNNING_KEY)) is True
+        and part.root.data.get("name") == REQUEST_EUC_FUNCTION_CALL_NAME
+        for part in message.parts
+        if part.root.metadata
+    ):
+        status.state = TaskState.auth_required
+    elif any(
+        part.root.metadata.get(get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY))
+        == A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL
+        and part.root.metadata.get(get_kagent_metadata_key(A2A_DATA_PART_METADATA_IS_LONG_RUNNING_KEY)) is True
+        for part in message.parts
+        if part.root.metadata
+    ):
+        status.state = TaskState.input_required
+
+    return TaskStatusUpdateEvent(
+        task_id=task_id,
+        context_id=context_id,
+        status=status,
+        metadata=_get_context_metadata(event, invocation_context),
+        final=False,
+    )
+
+
+def convert_event_to_a2a_events(
+    event: Event,
+    invocation_context: InvocationContext,
+    task_id: Optional[str] = None,
+    context_id: Optional[str] = None,
+) -> List[A2AEvent]:
+    """Converts a GenAI event to a list of A2A events.
+
+    Args:
+      event: The ADK event to convert.
+      invocation_context: The invocation context.
+      task_id: Optional task ID to use for generated events.
+      context_id: Optional Context ID to use for generated events.
+
+    Returns:
+      A list of A2A events representing the converted ADK event.
+
+    Raises:
+      ValueError: If required parameters are invalid.
+    """
+    if not event:
+        raise ValueError("Event cannot be None")
+    if not invocation_context:
+        raise ValueError("Invocation context cannot be None")
+
+    a2a_events = []
+
+    try:
+        # Handle error scenarios
+        if event.error_code:
+            error_event = _create_error_status_event(event, invocation_context, task_id, context_id)
+            a2a_events.append(error_event)
+
+        # Handle regular message content
+        message = convert_event_to_a2a_message(event, invocation_context)
+        if message:
+            running_event = _create_status_update_event(message, invocation_context, event, task_id, context_id)
+            a2a_events.append(running_event)
+
+    except Exception as e:
+        logger.error("Failed to convert event to A2A events: %s", e)
+        raise
+
+    return a2a_events

kagent_adk-0.6.8/src/kagent/adk/converters/part_converter.py

@@ -0,0 +1,206 @@
+# Copyright 2025 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+module containing utilities for conversion betwen A2A Part and Google GenAI Part
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import logging
+from typing import Optional
+
+from a2a import types as a2a_types
+from google.genai import types as genai_types
+
+from kagent.core.a2a import (
+    A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT,
+    A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE,
+    A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL,
+    A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE,
+    A2A_DATA_PART_METADATA_TYPE_KEY,
+    get_kagent_metadata_key,
+)
+
+logger = logging.getLogger("kagent_adk." + __name__)
+
+
+def convert_a2a_part_to_genai_part(
+    a2a_part: a2a_types.Part,
+) -> Optional[genai_types.Part]:
+    """Convert an A2A Part to a Google GenAI Part."""
+    part = a2a_part.root
+    if isinstance(part, a2a_types.TextPart):
+        return genai_types.Part(text=part.text)
+
+    if isinstance(part, a2a_types.FilePart):
+        if isinstance(part.file, a2a_types.FileWithUri):
+            return genai_types.Part(
+                file_data=genai_types.FileData(file_uri=part.file.uri, mime_type=part.file.mime_type)
+            )
+
+        elif isinstance(part.file, a2a_types.FileWithBytes):
+            return genai_types.Part(
+                inline_data=genai_types.Blob(
+                    data=base64.b64decode(part.file.bytes),
+                    mime_type=part.file.mime_type,
+                )
+            )
+        else:
+            logger.warning(
+                "Cannot convert unsupported file type: %s for A2A part: %s",
+                type(part.file),
+                a2a_part,
+            )
+            return None
+
+    if isinstance(part, a2a_types.DataPart):
+        # Conver the Data Part to funcall and function reponse.
+        # This is mainly for converting human in the loop and auth request and
+        # response.
+        # TODO once A2A defined how to suervice such information, migrate below
+        # logic accordinlgy
+        if part.metadata and get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY) in part.metadata:
+            if (
+                part.metadata[get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY)]
+                == A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL
+            ):
+                return genai_types.Part(function_call=genai_types.FunctionCall.model_validate(part.data, by_alias=True))
+            if (
+                part.metadata[get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY)]
+                == A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE
+            ):
+                return genai_types.Part(
+                    function_response=genai_types.FunctionResponse.model_validate(part.data, by_alias=True)
+                )
+            if (
+                part.metadata[get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY)]
+                == A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT
+            ):
+                return genai_types.Part(
+                    code_execution_result=genai_types.CodeExecutionResult.model_validate(part.data, by_alias=True)
+                )
+            if (
+                part.metadata[get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY)]
+                == A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE
+            ):
+                return genai_types.Part(
+                    executable_code=genai_types.ExecutableCode.model_validate(part.data, by_alias=True)
+                )
+        return genai_types.Part(text=json.dumps(part.data))
+
+    logger.warning(
+        "Cannot convert unsupported part type: %s for A2A part: %s",
+        type(part),
+        a2a_part,
+    )
+    return None
+
+
+def convert_genai_part_to_a2a_part(
+    part: genai_types.Part,
+) -> Optional[a2a_types.Part]:
+    """Convert a Google GenAI Part to an A2A Part."""
+
+    if part.text:
+        a2a_part = a2a_types.TextPart(text=part.text)
+        if part.thought is not None:
+            a2a_part.metadata = {get_kagent_metadata_key("thought"): part.thought}
+        return a2a_types.Part(root=a2a_part)
+
+    if part.file_data:
+        return a2a_types.Part(
+            root=a2a_types.FilePart(
+                file=a2a_types.FileWithUri(
+                    uri=part.file_data.file_uri,
+                    mime_type=part.file_data.mime_type,
+                )
+            )
+        )
+
+    if part.inline_data:
+        a2a_part = a2a_types.FilePart(
+            file=a2a_types.FileWithBytes(
+                bytes=base64.b64encode(part.inline_data.data).decode("utf-8"),
+                mime_type=part.inline_data.mime_type,
+            )
+        )
+
+        if part.video_metadata:
+            a2a_part.metadata = {
+                get_kagent_metadata_key("video_metadata"): part.video_metadata.model_dump(
+                    by_alias=True, exclude_none=True
+                )
+            }
+
+        return a2a_types.Part(root=a2a_part)
+
+    # Conver the funcall and function reponse to A2A DataPart.
+    # This is mainly for converting human in the loop and auth request and
+    # response.
+    # TODO once A2A defined how to suervice such information, migrate below
+    # logic accordinlgy
+    if part.function_call:
+        return a2a_types.Part(
+            root=a2a_types.DataPart(
+                data=part.function_call.model_dump(by_alias=True, exclude_none=True),
+                metadata={
+                    get_kagent_metadata_key(A2A_DATA_PART_METADATA_TYPE_KEY): A2A_DATA_PART_METADATA_TYPE_FUNCTION_CALL
+                },
+            )
+        )
+
+    if part.function_response:
+        return a2a_types.Part(
+            root=a2a_types.DataPart(
+                data=part.function_response.model_dump(by_alias=True, exclude_none=True),
+                metadata={
+                    get_kagent_metadata_key(
+                        A2A_DATA_PART_METADATA_TYPE_KEY
+                    ): A2A_DATA_PART_METADATA_TYPE_FUNCTION_RESPONSE
+                },
+            )
+        )
+
+    if part.code_execution_result:
+        return a2a_types.Part(
+            root=a2a_types.DataPart(
+                data=part.code_execution_result.model_dump(by_alias=True, exclude_none=True),
+                metadata={
+                    get_kagent_metadata_key(
+                        A2A_DATA_PART_METADATA_TYPE_KEY
+                    ): A2A_DATA_PART_METADATA_TYPE_CODE_EXECUTION_RESULT
+                },
+            )
+        )
+
+    if part.executable_code:
+        return a2a_types.Part(
+            root=a2a_types.DataPart(
+                data=part.executable_code.model_dump(by_alias=True, exclude_none=True),
+                metadata={
+                    get_kagent_metadata_key(
+                        A2A_DATA_PART_METADATA_TYPE_KEY
+                    ): A2A_DATA_PART_METADATA_TYPE_EXECUTABLE_CODE
+                },
+            )
+        )
+
+    logger.warning(
+        "Cannot convert unsupported part for Google GenAI part: %s",
+        part,
+    )
+    return None

kagent_adk-0.6.8/src/kagent/adk/converters/request_converter.py

@@ -0,0 +1,33 @@
+from typing import Any
+
+from a2a.server.agent_execution import RequestContext
+from google.adk.runners import RunConfig
+from google.genai import types as genai_types
+
+from .part_converter import convert_a2a_part_to_genai_part
+
+
+def _get_user_id(request: RequestContext) -> str:
+    # Get user from call context if available (auth is enabled on a2a server)
+    if request.call_context and request.call_context.user and request.call_context.user.user_name:
+        return request.call_context.user.user_name
+
+    # Get user from context id
+    return f"A2A_USER_{request.context_id}"
+
+
+def convert_a2a_request_to_adk_run_args(
+    request: RequestContext,
+) -> dict[str, Any]:
+    if not request.message:
+        raise ValueError("Request message cannot be None")
+
+    return {
+        "user_id": _get_user_id(request),
+        "session_id": request.context_id,
+        "new_message": genai_types.Content(
+            role="user",
+            parts=[convert_a2a_part_to_genai_part(part) for part in request.message.parts],
+        ),
+        "run_config": RunConfig(),
+    }

{kagent_adk-0.6.6/src/kagent_adk → kagent_adk-0.6.8/src/kagent/adk}/models.py

@@ -4,8 +4,7 @@ from typing import Literal, Self, Union
 from google.adk.agents import Agent
 from google.adk.agents.base_agent import BaseAgent
 from google.adk.agents.llm_agent import ToolUnion
-from google.adk.agents.remote_a2a_agent import RemoteA2aAgent
-from google.adk.agents.run_config import RunConfig, StreamingMode
+from google.adk.agents.remote_a2a_agent import AGENT_CARD_WELL_KNOWN_PATH, RemoteA2aAgent
 from google.adk.models.anthropic_llm import Claude as ClaudeLLM
 from google.adk.models.google_llm import Gemini as GeminiLLM
 from google.adk.models.lite_llm import LiteLlm
@@ -76,7 +75,6 @@ class AgentConfig(BaseModel):
     instruction: str
     http_tools: list[HttpMcpServerConfig] | None = None  # tools, always MCP
     sse_tools: list[SseMcpServerConfig] | None = None  # tools, always MCP
-    agents: list[Self] | None = None  # agent names
     remote_agents: list[RemoteAgentConfig] | None = None  # remote agents
 
     def to_agent(self, name: str) -> Agent:
@@ -89,19 +87,15 @@ class AgentConfig(BaseModel):
         if self.sse_tools:
             for sse_tool in self.sse_tools:  # add stdio tools
                 mcp_toolsets.append(MCPToolset(connection_params=sse_tool.params, tool_filter=sse_tool.tools))
-        if self.agents:
-            for agent in self.agents:  # Add sub agents as tools
-                mcp_toolsets.append(AgentTool(agent.to_agent(name)))
-        remote_agents: list[BaseAgent] = []
         if self.remote_agents:
             for remote_agent in self.remote_agents:  # Add remote agents as tools
-                remote_agents.append(
-                    RemoteA2aAgent(
-                        name=remote_agent.name,
-                        agent_card=remote_agent.url,
-                        description=remote_agent.description,
-                    )
+                remote_agent = RemoteA2aAgent(
+                    name=remote_agent.name,
+                    agent_card=f"{remote_agent.url}/{AGENT_CARD_WELL_KNOWN_PATH}",
+                    description=remote_agent.description,
                 )
+                mcp_toolsets.append(AgentTool(agent=remote_agent, skip_summarization=True))
+
         if self.model.type == "openai":
             model = LiteLlm(model=f"openai/{self.model.model}", base_url=self.model.base_url)
         elif self.model.type == "anthropic":
@@ -124,5 +118,4 @@ class AgentConfig(BaseModel):
             description=self.description,
             instruction=self.instruction,
             tools=mcp_toolsets,
-            sub_agents=remote_agents,
         )

kagent_adk-0.6.6/src/kagent_adk/_task_store.py

@@ -1,30 +0,0 @@
-from typing import override
-
-import httpx
-from a2a.server.tasks import TaskStore
-from a2a.types import Task
-
-
-class KAgentTaskStore(TaskStore):
-    client: httpx.AsyncClient
-
-    def __init__(self, client: httpx.AsyncClient):
-        self.client = client
-
-    @override
-    async def save(self, task: Task) -> None:
-        response = await self.client.post("/api/tasks", json=task.model_dump())
-        response.raise_for_status()
-
-    @override
-    async def get(self, task_id: str) -> Task | None:
-        response = await self.client.get(f"/api/tasks/{task_id}")
-        if response.status_code == 404:
-            return None
-        response.raise_for_status()
-        return Task.model_validate(response.json())
-
-    @override
-    async def delete(self, task_id: str) -> None:
-        response = await self.client.delete(f"/api/tasks/{task_id}")
-        response.raise_for_status()

kagent_adk-0.6.6/src/kagent_adk/cli.py

@@ -1,204 +0,0 @@
-import asyncio
-import json
-import logging
-import os
-from typing import Annotated
-
-import typer
-import uvicorn
-from a2a.types import AgentCard
-from google.adk.cli.utils.agent_loader import AgentLoader
-from opentelemetry import _logs, trace
-from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
-from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
-from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
-from opentelemetry.instrumentation.httpx import HTTPXClientInstrumentor
-from opentelemetry.instrumentation.openai import OpenAIInstrumentor
-from opentelemetry.sdk._events import EventLoggerProvider
-from opentelemetry.sdk._logs import LoggerProvider
-from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
-from opentelemetry.sdk.resources import Resource
-from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
-
-from . import AgentConfig, KAgentApp
-
-logger = logging.getLogger(__name__)
-
-app = typer.Typer()
-
-kagent_url = os.getenv("KAGENT_URL")
-kagent_name = os.getenv("KAGENT_NAME")
-kagent_namespace = os.getenv("KAGENT_NAMESPACE")
-
-
-class Config:
-    _url: str
-    _name: str
-    _namespace: str
-
-    def __init__(self):
-        if not kagent_url:
-            raise ValueError("KAGENT_URL is not set")
-        if not kagent_name:
-            raise ValueError("KAGENT_NAME is not set")
-        if not kagent_namespace:
-            raise ValueError("KAGENT_NAMESPACE is not set")
-        self._url = kagent_url
-        self._name = kagent_name
-        self._namespace = kagent_namespace
-
-    @property
-    def name(self):
-        return self._name.replace("-", "_")
-
-    @property
-    def namespace(self):
-        return self._namespace.replace("-", "_")
-
-    @property
-    def app_name(self):
-        return self.namespace + "__NS__" + self.name
-
-    @property
-    def url(self):
-        return self._url
-
-
-def configure_tracing():
-    tracing_enabled = os.getenv("OTEL_TRACING_ENABLED", "false").lower() == "true"
-    logging_enabled = os.getenv("OTEL_LOGGING_ENABLED", "false").lower() == "true"
-
-    resource = Resource({"service.name": "kagent"})
-
-    # Configure tracing if enabled
-    if tracing_enabled:
-        logging.info("Enabling tracing")
-        tracer_provider = TracerProvider(resource=resource)
-        # Check new env var first, fall back to old one for backward compatibility
-        trace_endpoint = os.getenv("OTEL_TRACING_EXPORTER_OTLP_ENDPOINT") or os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
-        if trace_endpoint:
-            processor = BatchSpanProcessor(OTLPSpanExporter(endpoint=trace_endpoint))
-        else:
-            processor = BatchSpanProcessor(OTLPSpanExporter())
-        tracer_provider.add_span_processor(processor)
-        trace.set_tracer_provider(tracer_provider)
-        HTTPXClientInstrumentor().instrument()
-
-    # Configure logging if enabled
-    if logging_enabled:
-        logging.info("Enabling logging for GenAI events")
-        logger_provider = LoggerProvider(resource=resource)
-        log_endpoint = os.getenv("OTEL_LOGGING_EXPORTER_OTLP_ENDPOINT")
-        logging.info(f"Log endpoint configured: {log_endpoint}")
-
-        # Add OTLP exporter
-        if log_endpoint:
-            log_processor = BatchLogRecordProcessor(OTLPLogExporter(endpoint=log_endpoint))
-        else:
-            log_processor = BatchLogRecordProcessor(OTLPLogExporter())
-        logger_provider.add_log_record_processor(log_processor)
-
-        _logs.set_logger_provider(logger_provider)
-        logging.info("Log provider configured with OTLP")
-        # When logging is enabled, use new event-based approach (input/output as log events in Body)
-        logging.info("OpenAI instrumentation configured with event logging capability")
-        # Create event logger provider using the configured logger provider
-        event_logger_provider = EventLoggerProvider(logger_provider)
-        OpenAIInstrumentor(use_legacy_attributes=False).instrument(event_logger_provider=event_logger_provider)
-        AnthropicInstrumentor(use_legacy_attributes=False).instrument(event_logger_provider=event_logger_provider)
-    else:
-        # Use legacy attributes (input/output as GenAI span attributes)
-        logging.info("OpenAI instrumentation configured with legacy GenAI span attributes")
-        OpenAIInstrumentor().instrument()
-        AnthropicInstrumentor().instrument()
-
-
-@app.command()
-def static(
-    host: str = "127.0.0.1",
-    port: int = 8080,
-    workers: int = 1,
-    filepath: str = "/config",
-    reload: Annotated[bool, typer.Option("--reload")] = False,
-):
-    configure_tracing()
-
-    app_cfg = Config()
-
-    with open(os.path.join(filepath, "config.json"), "r") as f:
-        config = json.load(f)
-    agent_config = AgentConfig.model_validate(config)
-    with open(os.path.join(filepath, "agent-card.json"), "r") as f:
-        agent_card = json.load(f)
-    agent_card = AgentCard.model_validate(agent_card)
-    root_agent = agent_config.to_agent(app_cfg.name)
-
-    kagent_app = KAgentApp(root_agent, agent_card, app_cfg.url, app_cfg.app_name)
-
-    uvicorn.run(
-        kagent_app.build,
-        host=host,
-        port=port,
-        workers=workers,
-        reload=reload,
-    )
-
-
-@app.command()
-def run(
-    name: Annotated[str, typer.Argument(help="The name of the agent to run")],
-    working_dir: str = ".",
-    host: str = "127.0.0.1",
-    port: int = 8080,
-    workers: int = 1,
-):
-    configure_tracing()
-    app_cfg = Config()
-
-    agent_loader = AgentLoader(agents_dir=working_dir)
-    root_agent = agent_loader.load_agent(name)
-
-    with open(os.path.join(working_dir, name, "agent-card.json"), "r") as f:
-        agent_card = json.load(f)
-    agent_card = AgentCard.model_validate(agent_card)
-    kagent_app = KAgentApp(root_agent, agent_card, app_cfg.url, app_cfg.app_name)
-    uvicorn.run(
-        kagent_app.build,
-        host=host,
-        port=port,
-        workers=workers,
-    )
-
-
-async def test_agent(agent_config: AgentConfig, agent_card: AgentCard, task: str):
-    app_cfg = Config()
-    agent = agent_config.to_agent(app_cfg.name)
-    app = KAgentApp(agent, agent_card, app_cfg.url, app_cfg.app_name)
-    await app.test(task)
-
-
-@app.command()
-def test(
-    task: Annotated[str, typer.Option("--task", help="The task to test the agent with")],
-    filepath: Annotated[str, typer.Option("--filepath", help="The path to the agent config file")],
-):
-    with open(filepath, "r") as f:
-        content = f.read()
-        config = json.loads(content)
-
-    with open(os.path.join(filepath, "agent-card.json"), "r") as f:
-        agent_card = json.load(f)
-    agent_card = AgentCard.model_validate(agent_card)
-    agent_config = AgentConfig.model_validate(config)
-    asyncio.run(test_agent(agent_config, agent_card, task))
-
-
-def run_cli():
-    logging.basicConfig(level=logging.INFO)
-    logging.info("Starting KAgent")
-    app()
-
-
-if __name__ == "__main__":
-    run_cli()