kagent-adk 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

kagent_adk/_agent_executor.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import inspect
 import logging
 import uuid
@@ -24,14 +25,12 @@ from google.adk.a2a.converters.request_converter import convert_a2a_request_to_a
 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 google.adk.utils.feature_decorator import experimental
 from pydantic import BaseModel
 from typing_extensions import override
 
 logger = logging.getLogger("google_adk." + __name__)
 
 
-@experimental
 class A2aAgentExecutorConfig(BaseModel):
     """Configuration for the A2aAgentExecutor."""
 
@@ -42,7 +41,6 @@ class A2aAgentExecutorConfig(BaseModel):
 # with the following changes:
 # - The runner is ALWAYS a callable that returns a Runner instance
 # - The runner is cleaned up at the end of the execution
-@experimental
 class A2aAgentExecutor(AgentExecutor):
     """An AgentExecutor that runs an ADK Agent against an A2A request and
     publishes updates to an event queue.
@@ -145,7 +143,16 @@ class A2aAgentExecutor(AgentExecutor):
             except Exception as enqueue_error:
                 logger.error("Failed to publish failure event: %s", enqueue_error, exc_info=True)
         finally:
-            await runner.close()
+            # Shield cleanup from external cancellation so toolsets (e.g., MCP) can
+            # gracefully close their sessions without being torn down mid-flight.
+            try:
+                await asyncio.wait_for(asyncio.shield(runner.close()), timeout=15.0)
+            except asyncio.CancelledError:
+                # Suppress cancellation during cleanup to avoid noisy tracebacks
+                # from libraries that assume non-cancelled close semantics.
+                logger.warning("Runner.close() was cancelled; suppressing during cleanup")
+            except Exception as close_error:
+                logger.error("Error during runner.close(): %s", close_error, exc_info=True)
 
     async def _handle_request(
         self,

kagent_adk/cli.py

@@ -0,0 +1,204 @@
+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()

kagent_adk/models.py

@@ -1,9 +1,10 @@
 import logging
 from typing import Literal, Self, Union
 
-from a2a.types import AgentCard
 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.models.anthropic_llm import Claude as ClaudeLLM
 from google.adk.models.google_llm import Gemini as GeminiLLM
@@ -25,6 +26,12 @@ class SseMcpServerConfig(BaseModel):
     tools: list[str] = Field(default_factory=list)
 
 
+class RemoteAgentConfig(BaseModel):
+    name: str
+    url: str
+    description: str = ""
+
+
 class BaseLLM(BaseModel):
     model: str
 
@@ -62,9 +69,6 @@ class Gemini(BaseLLM):
 
 
 class AgentConfig(BaseModel):
-    kagent_url: str  # The URL of the KAgent server
-    agent_card: AgentCard
-    name: str
     model: Union[OpenAI, Anthropic, GeminiVertexAI, GeminiAnthropic, Ollama, AzureOpenAI, Gemini] = Field(
         discriminator="type"
     )
@@ -73,8 +77,11 @@ class AgentConfig(BaseModel):
     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) -> Agent:
+    def to_agent(self, name: str) -> Agent:
+        if name is None or not str(name).strip():
+            raise ValueError("Agent name must be a non-empty string.")
         mcp_toolsets: list[ToolUnion] = []
         if self.http_tools:
             for http_tool in self.http_tools:  # add http tools
@@ -84,7 +91,17 @@ class AgentConfig(BaseModel):
                 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()))
+                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,
+                    )
+                )
         if self.model.type == "openai":
             model = LiteLlm(model=f"openai/{self.model.model}", base_url=self.model.base_url)
         elif self.model.type == "anthropic":
@@ -102,9 +119,10 @@ class AgentConfig(BaseModel):
         else:
             raise ValueError(f"Invalid model type: {self.model.type}")
         return Agent(
-            name=self.name,
+            name=name,
             model=model,
             description=self.description,
             instruction=self.instruction,
             tools=mcp_toolsets,
+            sub_agents=remote_agents,
         )

{kagent_adk-0.5.5.dist-info → kagent_adk-0.6.1.dist-info}/METADATA

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: kagent-adk
-Version: 0.5.5
+Version: 0.6.1
 Summary: kagent-adk is an sdk for integrating adk agents with kagent
 Requires-Python: >=3.12.11
 Requires-Dist: a2a-sdk>=0.2.16
+Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: anthropic[vertex]>=0.49.0
 Requires-Dist: anyio>=4.9.0
 Requires-Dist: fastapi>=0.115.1
@@ -15,14 +16,17 @@ Requires-Dist: jsonref>=1.1.0
 Requires-Dist: litellm>=1.74.3
 Requires-Dist: mcp>=1.12.0
 Requires-Dist: openai>=1.72.0
-Requires-Dist: opentelemetry-api>=1.32.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.32.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.39.0
-Requires-Dist: opentelemetry-sdk>=1.32.0
-Requires-Dist: protobuf>=6.31.1
+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
 Requires-Dist: typing-extensions>=4.8.0
+Requires-Dist: uvicorn>=0.34.0
 Provides-Extra: memory
 Requires-Dist: psutil>=6.1.0; extra == 'memory'
 Provides-Extra: test

kagent_adk-0.6.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+kagent_adk/__init__.py,sha256=3oB8gbSzsvVmqV8w-BGKkRlH3JPfK6o27AfOD6wAd8o,182
+kagent_adk/_agent_executor.py,sha256=VJn3uQ3EITouzqiIzcN7MZgZ8ozannZIIqjVVyYO57k,10388
+kagent_adk/_session_service.py,sha256=A47gsfDVp8jITzeW987AHTJLEhcU_mU3ik_SFptFGIc,5815
+kagent_adk/_task_store.py,sha256=3ApKbFfcDZmcEnwef6bCDhBhoGY9ZYwwyP671B1DHFo,889
+kagent_adk/a2a.py,sha256=HBEdGq4gPr78AD88GhygsPhntnctY5dw5pt-BN7FpaI,5647
+kagent_adk/cli.py,sha256=MSdd38T1vsFEhpj3MEAg4IdQhlrcumnSbRi-8xUKXVE,6977
+kagent_adk/models.py,sha256=ZR1Hbc6fjA82fGdgrfa5-HyWOkXQTrjX2FiS57_O8i4,4411
+kagent_adk-0.6.1.dist-info/METADATA,sha256=7leqLe0TBAUi1SQf3isjq3n9MVt-lRgAuB99a72P6oc,1242
+kagent_adk-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kagent_adk-0.6.1.dist-info/entry_points.txt,sha256=bmqHEc9zPYkbRoK57wF3wi5ohHTMB6yHTslKfvuVpc4,50
+kagent_adk-0.6.1.dist-info/RECORD,,

kagent_adk-0.6.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kagent-adk = kagent_adk.cli:app

kagent_adk-0.5.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-kagent_adk/__init__.py,sha256=3oB8gbSzsvVmqV8w-BGKkRlH3JPfK6o27AfOD6wAd8o,182
-kagent_adk/_agent_executor.py,sha256=L1ReZ8VPseMcy3-HGE-kbo97M9G8NqSWDDlMplE7Kgw,9798
-kagent_adk/_session_service.py,sha256=A47gsfDVp8jITzeW987AHTJLEhcU_mU3ik_SFptFGIc,5815
-kagent_adk/_task_store.py,sha256=3ApKbFfcDZmcEnwef6bCDhBhoGY9ZYwwyP671B1DHFo,889
-kagent_adk/a2a.py,sha256=HBEdGq4gPr78AD88GhygsPhntnctY5dw5pt-BN7FpaI,5647
-kagent_adk/models.py,sha256=dtwUQny2r5K1JtCtl_mGk3dNMW-XnPPjWJT8JbyWE0E,3654
-kagent_adk-0.5.5.dist-info/METADATA,sha256=jEYOAi56xs-S2f8DMblZja1iJHE1Pka2tUIv6RHIX0g,1092
-kagent_adk-0.5.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kagent_adk-0.5.5.dist-info/RECORD,,